diff --git a/example/capture_in_exception.cpp b/example/dynamic_capture_eh.cpp
similarity index 61%
rename from example/capture_in_exception.cpp
rename to example/dynamic_capture_eh.cpp
index a73d30d9..7b34a833 100644
--- a/example/capture_in_exception.cpp
+++ b/example/dynamic_capture_eh.cpp
@@ -44,30 +44,12 @@ int main()
 {
     int const task_count = 42;
 
-    // The error_handlers are used in this thread (see leaf::try_catch below).
-    // The arguments passed to individual lambdas are transported from the
-    // worker thread to the main thread automatically.
-    auto error_handlers = std::make_tuple(
-        []( e_failure_info1 const & v1, e_failure_info2 const & v2, e_thread_id const & tid )
-        {
-            std::cerr << "Error in thread " << tid.value << "! failure_info1: " << v1.value << ", failure_info2: " << v2.value << std::endl;
-        },
-        []( leaf::diagnostic_info const & unmatched )
-        {
-            std::cerr <<
-                "Unknown failure detected" << std::endl <<
-                "Cryptic diagnostic information follows" << std::endl <<
-                unmatched;
-        } );
-
     // Container to collect the generated std::future objects.
-    std::vector<std::future<task_result>> fut;
+    std::vector<std::future<leaf::result<task_result>>> fut;
 
     // Launch the tasks, but rather than launching the task function directly,
-    // we launch a wrapper function which calls leaf::capture, passing a context
-    // object that will hold the error objects reported from the task in case it
-    // throws. The error types the context is able to hold statically are
-    // automatically deduced from the type of the error_handlers tuple.
+    // we use leaf::try_catch in compbination with leaf::dynamic_capture:
+    // in case of a failure, the returned leaf::result<> will capture all error objects.
     std::generate_n( std::back_inserter(fut), task_count,
         [&]
         {
@@ -75,7 +57,15 @@ int main()
                 std::launch::async,
                 [&]
                 {
-                    return leaf::capture(leaf::make_shared_context(error_handlers), &task);
+                    return leaf::try_catch(
+                        [&]() -> leaf::result<task_result>
+                        {
+                            return task();
+                        },
+                        []( leaf::dynamic_capture const & cap ) -> leaf::result<task_result>
+                        {
+                            return cap;
+                        } );
                 } );
         } );
 
@@ -87,12 +77,22 @@ int main()
         leaf::try_catch(
             [&]
             {
-                task_result r = f.get();
+                task_result r = f.get().value();
 
                 // Success! Use r to access task_result.
                 std::cout << "Success!" << std::endl;
                 (void) r; // Presumably we'll somehow use the task_result.
             },
-            error_handlers );
+            []( e_failure_info1 const & v1, e_failure_info2 const & v2, e_thread_id const & tid )
+            {
+                std::cerr << "Error in thread " << tid.value << "! failure_info1: " << v1.value << ", failure_info2: " << v2.value << std::endl;
+            },
+            []( leaf::diagnostic_info const & unmatched )
+            {
+                std::cerr <<
+                    "Unknown failure detected" << std::endl <<
+                    "Cryptic diagnostic information follows" << std::endl <<
+                    unmatched;
+            } );
     }
 }
diff --git a/example/capture_in_result.cpp b/example/dynamic_capture_result.cpp
similarity index 67%
rename from example/capture_in_result.cpp
rename to example/dynamic_capture_result.cpp
index c8c9ad7f..bf3374cb 100644
--- a/example/capture_in_result.cpp
+++ b/example/dynamic_capture_result.cpp
@@ -44,30 +44,12 @@ int main()
 {
     int const task_count = 42;
 
-    // The error_handlers are used in this thread (see leaf::try_handle_all
-    // below). The arguments passed to individual lambdas are transported from
-    // the worker thread to the main thread automatically.
-    auto error_handlers = std::make_tuple(
-        []( e_failure_info1 const & v1, e_failure_info2 const & v2, e_thread_id const & tid )
-        {
-            std::cerr << "Error in thread " << tid.value << "! failure_info1: " << v1.value << ", failure_info2: " << v2.value << std::endl;
-        },
-        []( leaf::diagnostic_info const & unmatched )
-        {
-            std::cerr <<
-                "Unknown failure detected" << std::endl <<
-                "Cryptic diagnostic information follows" << std::endl <<
-                unmatched;
-        } );
-
     // Container to collect the generated std::future objects.
     std::vector<std::future<leaf::result<task_result>>> fut;
 
     // Launch the tasks, but rather than launching the task function directly,
-    // we launch a wrapper function which calls leaf::capture, passing a context
-    // object that will hold the error objects reported from the task in case of
-    // an error. The error types the context is able to hold statically are
-    // automatically deduced from the type of the error_handlers tuple.
+    // we use leaf::try_handle_some in compbination with leaf::dynamic_capture:
+    // in case of a failure, the returned leaf::result<> will capture all error objects.
     std::generate_n( std::back_inserter(fut), task_count,
         [&]
         {
@@ -75,7 +57,15 @@ int main()
                 std::launch::async,
                 [&]
                 {
-                    return leaf::capture(leaf::make_shared_context(error_handlers), &task);
+                    return leaf::try_handle_some(
+                        [&]() -> leaf::result<task_result>
+                        {
+                            return task();
+                        },
+                        []( leaf::dynamic_capture const & cap ) -> leaf::result<task_result>
+                        {
+                            return cap;
+                        } );
                 } );
         } );
 
@@ -87,14 +77,24 @@ int main()
         leaf::try_handle_all(
             [&]() -> leaf::result<void>
             {
-                BOOST_LEAF_AUTO(r,f.get());
+                BOOST_LEAF_AUTO(r, f.get());
 
                 // Success! Use r to access task_result.
                 std::cout << "Success!" << std::endl;
                 (void) r; // Presumably we'll somehow use the task_result.
                 return { };
             },
-            error_handlers );
+            []( e_failure_info1 const & v1, e_failure_info2 const & v2, e_thread_id const & tid )
+            {
+                std::cerr << "Error in thread " << tid.value << "! failure_info1: " << v1.value << ", failure_info2: " << v2.value << std::endl;
+            },
+            []( leaf::diagnostic_info const & unmatched )
+            {
+                std::cerr <<
+                    "Unknown failure detected" << std::endl <<
+                    "Cryptic diagnostic information follows" << std::endl <<
+                    unmatched;
+            } );
     }
 }
 
diff --git a/example/print_file/print_file_outcome_result.cpp b/example/print_file/print_file_outcome_result.cpp
index 5c642699..bd152c47 100644
--- a/example/print_file/print_file_outcome_result.cpp
+++ b/example/print_file/print_file_outcome_result.cpp
@@ -79,7 +79,7 @@ int main( int argc, char const * argv[] )
             std::cout << buffer;
             std::cout.flush();
             if( std::cout.fail() )
-                return leaf::new_error(output_error, leaf::e_errno{errno}).to_error_code();
+                return leaf::new_error(output_error, leaf::e_errno{errno});
 
             return 0;
         },
@@ -164,7 +164,7 @@ result<char const *> parse_command_line( int argc, char const * argv[] )
     if( argc==2 )
         return argv[1];
     else
-        return leaf::new_error(bad_command_line).to_error_code();
+        return leaf::new_error(bad_command_line);
 }
 
 
@@ -174,7 +174,7 @@ result<std::shared_ptr<FILE>> file_open( char const * file_name )
     if( FILE * f = fopen(file_name, "rb") )
         return std::shared_ptr<FILE>(f, &fclose);
     else
-        return leaf::new_error(open_error, leaf::e_errno{errno}).to_error_code();
+        return leaf::new_error(open_error, leaf::e_errno{errno});
 }
 
 
@@ -184,14 +184,14 @@ result<std::size_t> file_size( FILE & f )
     auto load = leaf::on_error([] { return leaf::e_errno{errno}; });
 
     if( fseek(&f, 0, SEEK_END) )
-        return leaf::new_error(size_error).to_error_code();
+        return leaf::new_error(size_error);
 
     long s = ftell(&f);
     if( s==-1L )
-        return leaf::new_error(size_error).to_error_code();
+        return leaf::new_error(size_error);
 
     if( fseek(&f,0,SEEK_SET) )
-        return leaf::new_error(size_error).to_error_code();
+        return leaf::new_error(size_error);
 
     return std::size_t(s);
 }
@@ -203,10 +203,10 @@ result<void> file_read( FILE & f, void * buf, std::size_t size )
     std::size_t n = fread(buf, 1, size, &f);
 
     if( ferror(&f) )
-        return leaf::new_error(read_error, leaf::e_errno{errno}).to_error_code();
+        return leaf::new_error(read_error, leaf::e_errno{errno});
 
     if( n!=size )
-        return leaf::new_error(eof_error).to_error_code();
+        return leaf::new_error(eof_error);
 
     return outcome::success();
 }
diff --git a/example/readme.md b/example/readme.md
index 3e98584a..323d9e4b 100644
--- a/example/readme.md
+++ b/example/readme.md
@@ -2,8 +2,8 @@
 
 * [print_file](./print_file): The complete example from the [Five Minute Introduction](https://boostorg.github.io/leaf/#introduction). This directory contains several versions of the same program, each using a different error handling style.
 
-* [capture_in_result.cpp](https://github.com/boostorg/leaf/blob/master/example/capture_in_result.cpp?ts=4): Shows how to transport error objects between threads in a `leaf::result<T>` object.
-* [capture_in_exception.cpp](https://github.com/boostorg/leaf/blob/master/example/capture_in_exception.cpp?ts=4): Shows how to transport error objects between threads in an exception object.
+* [dynamic_capture_result.cpp](https://github.com/boostorg/leaf/blob/master/example/dynamic_capture_result.cpp?ts=4): Shows how to transport error objects between threads in a `leaf::result<T>` object without using exception handling.
+* [dynamic_capture_eh.cpp](https://github.com/boostorg/leaf/blob/master/example/dynamic_capture_eh.cpp?ts=4): Shows how to transport error objects between threads in an a `leaf::result<T>` object using exception handling.
 * [lua_callback_result.cpp](https://github.com/boostorg/leaf/blob/master/example/lua_callback_result.cpp?ts=4): Transporting arbitrary error objects through an uncooperative C API.
 * [lua_callback_eh.cpp](https://github.com/boostorg/leaf/blob/master/example/lua_callback_eh.cpp?ts=4): Transporting arbitrary error objects through an uncooperative exception-safe API.
 * [exception_to_result.cpp](https://github.com/boostorg/leaf/blob/master/example/exception_to_result.cpp?ts=4): Demonstrates how to transport exceptions through a `noexcept` layer in the program.
diff --git a/include/boost/leaf/capture.hpp b/include/boost/leaf/capture.hpp
deleted file mode 100644
index 9235a824..00000000
--- a/include/boost/leaf/capture.hpp
+++ /dev/null
@@ -1,239 +0,0 @@
-#ifndef BOOST_LEAF_CAPTURE_HPP_INCLUDED
-#define BOOST_LEAF_CAPTURE_HPP_INCLUDED
-
-// Copyright 2018-2023 Emil Dotchevski and Reverge Studios, Inc.
-
-// 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)
-
-#include <boost/leaf/config.hpp>
-#include <boost/leaf/exception.hpp>
-#include <boost/leaf/on_error.hpp>
-
-#if BOOST_LEAF_CFG_CAPTURE
-
-namespace boost { namespace leaf {
-
-namespace leaf_detail
-{
-    template <class R, bool IsResult = is_result_type<R>::value>
-    struct is_result_tag;
-
-    template <class R>
-    struct is_result_tag<R, false>
-    {
-    };
-
-    template <class R>
-    struct is_result_tag<R, true>
-    {
-    };
-}
-
-#ifdef BOOST_LEAF_NO_EXCEPTIONS
-
-namespace leaf_detail
-{
-    template <class R, class F, class... A, class ContextPtr>
-    inline
-    decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
-    capture_impl(is_result_tag<R, false>, ContextPtr && ctx, F && f, A... a) noexcept
-    {
-        auto active_context = activate_context(*ctx);
-        return std::forward<F>(f)(std::forward<A>(a)...);
-    }
-
-    template <class R, class F, class... A, class ContextPtr>
-    inline
-    decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
-    capture_impl(is_result_tag<R, true>, ContextPtr && ctx, F && f, A... a) noexcept
-    {
-        auto active_context = activate_context(*ctx);
-        if( auto r = std::forward<F>(f)(std::forward<A>(a)...) )
-            return r;
-        else
-        {
-            ctx->captured_id_ = r.error();
-            return std::forward<ContextPtr>(ctx);
-        }
-    }
-
-    template <class R, class Future>
-    inline
-    decltype(std::declval<Future>().get())
-    future_get_impl(is_result_tag<R, false>, Future & fut) noexcept
-    {
-        return fut.get();
-    }
-
-    template <class R, class Future>
-    inline
-    decltype(std::declval<Future>().get())
-    future_get_impl(is_result_tag<R, true>, Future & fut) noexcept
-    {
-        if( auto r = fut.get() )
-            return r;
-        else
-            return error_id(r.error()); // unloads
-    }
-}
-
-#else
-
-namespace leaf_detail
-{
-    class capturing_exception:
-        public std::exception
-    {
-        std::exception_ptr ex_;
-        context_ptr ctx_;
-
-    public:
-
-        template <class ContextPtr>
-        capturing_exception(std::exception_ptr && ex, ContextPtr && ctx) noexcept:
-            ex_(std::move(ex)),
-            ctx_(std::forward<ContextPtr>(ctx))
-        {
-            BOOST_LEAF_ASSERT(ex_);
-            BOOST_LEAF_ASSERT(ctx_);
-            BOOST_LEAF_ASSERT(ctx_->captured_id_);
-        }
-
-        [[noreturn]] void unload_and_rethrow_original_exception() const
-        {
-            BOOST_LEAF_ASSERT(ctx_->captured_id_);
-            tls::write_uint<tls_tag_id_factory_current_id>(unsigned(ctx_->captured_id_.value()));
-            ctx_->propagate(ctx_->captured_id_);
-            std::rethrow_exception(ex_);
-        }
-    };
-
-    template <class R, class F, class... A, class ContextPtr>
-    inline
-    decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
-    capture_impl(is_result_tag<R, false>, ContextPtr && ctx, F && f, A... a)
-    {
-        auto active_context = activate_context(*ctx);
-        error_monitor cur_err;
-        try
-        {
-            return std::forward<F>(f)(std::forward<A>(a)...);
-        }
-        catch( capturing_exception const & )
-        {
-            throw;
-        }
-        catch( exception_base const & e )
-        {
-            ctx->captured_id_ = e.get_error_id();
-            leaf_detail::throw_exception_impl( capturing_exception(std::current_exception(), std::forward<ContextPtr>(ctx)) );
-        }
-        catch(...)
-        {
-            ctx->captured_id_ = cur_err.assigned_error_id();
-            leaf_detail::throw_exception_impl( capturing_exception(std::current_exception(), std::forward<ContextPtr>(ctx)) );
-        }
-    }
-
-    template <class R, class F, class... A, class ContextPtr>
-    inline
-    decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
-    capture_impl(is_result_tag<R, true>, ContextPtr && ctx, F && f, A... a)
-    {
-        auto active_context = activate_context(*ctx);
-        error_monitor cur_err;
-        try
-        {
-            if( auto && r = std::forward<F>(f)(std::forward<A>(a)...) )
-                return std::move(r);
-            else
-            {
-                ctx->captured_id_ = r.error();
-                return std::forward<ContextPtr>(ctx);
-            }
-        }
-        catch( capturing_exception const & )
-        {
-            throw;
-        }
-        catch( exception_base const & e )
-        {
-            ctx->captured_id_ = e.get_error_id();
-            leaf_detail::throw_exception_impl( capturing_exception(std::current_exception(), std::forward<ContextPtr>(ctx)) );
-        }
-        catch(...)
-        {
-            ctx->captured_id_ = cur_err.assigned_error_id();
-            leaf_detail::throw_exception_impl( capturing_exception(std::current_exception(), std::forward<ContextPtr>(ctx)) );
-        }
-    }
-
-    template <class R, class Future>
-    inline
-    decltype(std::declval<Future>().get())
-    future_get_impl(is_result_tag<R, false>, Future & fut )
-    {
-        try
-        {
-            return fut.get();
-        }
-        catch( capturing_exception const & cap )
-        {
-            cap.unload_and_rethrow_original_exception();
-        }
-    }
-
-    template <class R, class Future>
-    inline
-    decltype(std::declval<Future>().get())
-    future_get_impl(is_result_tag<R, true>, Future & fut )
-    {
-        try
-        {
-            if( auto r = fut.get() )
-                return r;
-            else
-                return error_id(r.error()); // unloads
-        }
-        catch( capturing_exception const & cap )
-        {
-            cap.unload_and_rethrow_original_exception();
-        }
-    }
-}
-
-#endif
-
-template <class F, class... A>
-inline
-decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
-capture(context_ptr const & ctx, F && f, A... a)
-{
-    using namespace leaf_detail;
-    return capture_impl(is_result_tag<decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))>(), ctx, std::forward<F>(f), std::forward<A>(a)...);
-}
-
-template <class F, class... A>
-inline
-decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
-capture(context_ptr && ctx, F && f, A... a)
-{
-    using namespace leaf_detail;
-    return capture_impl(is_result_tag<decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))>(), std::move(ctx), std::forward<F>(f), std::forward<A>(a)...);
-}
-
-template <class Future>
-inline
-decltype(std::declval<Future>().get())
-future_get( Future & fut )
-{
-    using namespace leaf_detail;
-    return future_get_impl(is_result_tag<decltype(std::declval<Future>().get())>(), fut);
-}
-
-} }
-
-#endif
-
-#endif
diff --git a/include/boost/leaf/config/tls_array.hpp b/include/boost/leaf/config/tls_array.hpp
index a78addc8..46243f27 100644
--- a/include/boost/leaf/config/tls_array.hpp
+++ b/include/boost/leaf/config/tls_array.hpp
@@ -65,15 +65,21 @@ namespace tls
     {
         static int c_;
 
-    public:
-
-        static BOOST_LEAF_CFG_TLS_INDEX_TYPE next()
+        static BOOST_LEAF_CFG_TLS_INDEX_TYPE next_() noexcept
         {
             int idx = ++c_;
             BOOST_LEAF_ASSERT(idx > (BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX));
             BOOST_LEAF_ASSERT(idx < (BOOST_LEAF_CFG_TLS_ARRAY_SIZE));
             return idx;
         }
+
+    public:
+
+        template <class T>
+        static BOOST_LEAF_CFG_TLS_INDEX_TYPE next() noexcept
+        {
+            return next_(); // Set breakpoint here to monitor TLS intex allocation for T.
+        }
     };
 
     template <class T>
@@ -95,7 +101,7 @@ namespace tls
     BOOST_LEAF_CFG_TLS_INDEX_TYPE tls_index<T>::idx = BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX;
 
     template <class T>
-    BOOST_LEAF_CFG_TLS_INDEX_TYPE const alloc_tls_index<T>::idx = tls_index<T>::idx = index_counter<>::next();
+    BOOST_LEAF_CFG_TLS_INDEX_TYPE const alloc_tls_index<T>::idx = tls_index<T>::idx = index_counter<>::next<T>();
 
     ////////////////////////////////////////
 
diff --git a/include/boost/leaf/context.hpp b/include/boost/leaf/context.hpp
index 6a213be4..d1704f51 100644
--- a/include/boost/leaf/context.hpp
+++ b/include/boost/leaf/context.hpp
@@ -17,7 +17,9 @@ namespace boost { namespace leaf {
 
 class error_info;
 class diagnostic_info;
+#if BOOST_LEAF_CFG_DIAGNOSTICS
 class verbose_diagnostic_info;
+#endif
 
 template <class>
 struct is_predicate: std::false_type
@@ -58,7 +60,9 @@ namespace leaf_detail
         static_assert(!is_predicate<error_type>::value, "Handlers must take predicate arguments by value");
         static_assert(!std::is_same<E, error_info>::value, "Handlers must take leaf::error_info arguments by const &");
         static_assert(!std::is_same<E, diagnostic_info>::value, "Handlers must take leaf::diagnostic_info arguments by const &");
+#if BOOST_LEAF_CFG_DIAGNOSTICS
         static_assert(!std::is_same<E, verbose_diagnostic_info>::value, "Handlers must take leaf::verbose_diagnostic_info arguments by const &");
+#endif
     };
 
     template <class Pred>
@@ -163,20 +167,21 @@ namespace leaf_detail
             tuple_for_each<I-1,Tuple>::deactivate(tup);
         }
 
-        BOOST_LEAF_CONSTEXPR static void propagate( Tuple & tup, int err_id ) noexcept
+        BOOST_LEAF_CONSTEXPR static void unload( Tuple & tup, int err_id ) noexcept
         {
             static_assert(!std::is_same<error_info, typename std::decay<decltype(std::get<I-1>(tup))>::type>::value, "Bug in LEAF: context type deduction");
+            BOOST_LEAF_ASSERT(err_id != 0);
             auto & sl = std::get<I-1>(tup);
-            sl.propagate(err_id);
-            tuple_for_each<I-1,Tuple>::propagate(tup, err_id);
+            sl.unload(err_id);
+            tuple_for_each<I-1,Tuple>::unload(tup, err_id);
         }
 
         template <class CharT, class Traits>
-        static void print( std::basic_ostream<CharT, Traits> & os, void const * tup, int key_to_print )
+        static void print( std::basic_ostream<CharT, Traits> & os, void const * tup, int err_id_to_print )
         {
             BOOST_LEAF_ASSERT(tup != nullptr);
-            tuple_for_each<I-1,Tuple>::print(os, tup, key_to_print);
-            std::get<I-1>(*static_cast<Tuple const *>(tup)).print(os, key_to_print);
+            tuple_for_each<I-1,Tuple>::print(os, tup, err_id_to_print);
+            std::get<I-1>(*static_cast<Tuple const *>(tup)).print(os, err_id_to_print);
         }
     };
 
@@ -185,7 +190,7 @@ namespace leaf_detail
     {
         BOOST_LEAF_CONSTEXPR static void activate( Tuple & ) noexcept { }
         BOOST_LEAF_CONSTEXPR static void deactivate( Tuple & ) noexcept { }
-        BOOST_LEAF_CONSTEXPR static void propagate( Tuple &, int ) noexcept { }
+        BOOST_LEAF_CONSTEXPR static void unload( Tuple &, int ) noexcept { }
         template <class CharT, class Traits>
         BOOST_LEAF_CONSTEXPR static void print( std::basic_ostream<CharT, Traits> &, void const *, int ) { }
     };
@@ -193,37 +198,6 @@ namespace leaf_detail
 
 ////////////////////////////////////////////
 
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-
-namespace leaf_detail
-{
-    template <class T> struct requires_unexpected { constexpr static bool value = false; };
-    template <class T> struct requires_unexpected<T const> { constexpr static bool value = requires_unexpected<T>::value; };
-    template <class T> struct requires_unexpected<T const &> { constexpr static bool value = requires_unexpected<T>::value; };
-    template <class T> struct requires_unexpected<T const *> { constexpr static bool value = requires_unexpected<T>::value; };
-    template <> struct requires_unexpected<e_unexpected_count> { constexpr static bool value = true; };
-    template <> struct requires_unexpected<e_unexpected_info> { constexpr static bool value = true; };
-
-    template <class L>
-    struct unexpected_requested;
-
-    template <template <class ...> class L>
-    struct unexpected_requested<L<>>
-    {
-        constexpr static bool value = false;
-    };
-
-    template <template <class...> class L, template <class> class S, class Car, class... Cdr>
-    struct unexpected_requested<L<S<Car>, S<Cdr>...>>
-    {
-        constexpr static bool value = requires_unexpected<Car>::value || unexpected_requested<L<S<Cdr>...>>::value;
-    };
-}
-
-#endif
-
-////////////////////////////////////////////
-
 namespace leaf_detail
 {
     template <class T> struct does_not_participate_in_context_deduction: std::is_abstract<T> { };
@@ -308,10 +282,6 @@ class context
         using namespace leaf_detail;
         BOOST_LEAF_ASSERT(!is_active());
         tuple_for_each<std::tuple_size<Tup>::value,Tup>::activate(tup_);
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-        if( unexpected_requested<Tup>::value )
-            tls::uint_increment<tls_tag_unexpected_enabled_counter>();
-#endif
 #if !defined(BOOST_LEAF_NO_THREADS) && !defined(NDEBUG)
         thread_id_ = std::this_thread::get_id();
 #endif
@@ -326,18 +296,14 @@ class context
 #if !defined(BOOST_LEAF_NO_THREADS) && !defined(NDEBUG)
         BOOST_LEAF_ASSERT(std::this_thread::get_id() == thread_id_);
         thread_id_ = std::thread::id();
-#endif
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-        if( unexpected_requested<Tup>::value )
-            tls::uint_decrement<tls_tag_unexpected_enabled_counter>();
 #endif
         tuple_for_each<std::tuple_size<Tup>::value,Tup>::deactivate(tup_);
     }
 
-    BOOST_LEAF_CONSTEXPR void propagate(error_id id) noexcept
+    BOOST_LEAF_CONSTEXPR void unload(error_id id) noexcept
     {
         BOOST_LEAF_ASSERT(!is_active());
-        leaf_detail::tuple_for_each<std::tuple_size<Tup>::value,Tup>::propagate(tup_, id.value());
+        leaf_detail::tuple_for_each<std::tuple_size<Tup>::value,Tup>::unload(tup_, id.value());
     }
 
     BOOST_LEAF_CONSTEXPR bool is_active() const noexcept
@@ -365,6 +331,12 @@ class context
     BOOST_LEAF_CONSTEXPR R handle_error( error_id, H && ... );
 };
 
+template <class Ctx>
+BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE context_activator<Ctx> activate_context(Ctx & ctx) noexcept
+{
+    return context_activator<Ctx>(ctx);
+}
+
 ////////////////////////////////////////
 
 namespace leaf_detail
@@ -404,18 +376,6 @@ namespace leaf_detail
     {
         using type = deduce_context<leaf_detail_mp11::mp_append<typename fn_mp_args_fwd<H>::type...>>;
     };
-
-    template <class Ctx>
-    struct polymorphic_context_impl: polymorphic_context, Ctx
-    {
-        void activate() noexcept final override { Ctx::activate(); }
-        void deactivate() noexcept final override { Ctx::deactivate(); }
-        void propagate(error_id id) noexcept final override { Ctx::propagate(id); }
-        bool is_active() const noexcept final override { return Ctx::is_active(); }
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-        void print( std::ostream & os ) const final override { return Ctx::print(os); }
-#endif
-    };
 }
 
 template <class... H>
@@ -435,24 +395,6 @@ BOOST_LEAF_CONSTEXPR inline context_type_from_handlers<H...> make_context( H &&
     return { };
 }
 
-////////////////////////////////////////////
-
-#if BOOST_LEAF_CFG_CAPTURE
-
-template <class...  H>
-inline context_ptr make_shared_context() noexcept
-{
-    return std::make_shared<leaf_detail::polymorphic_context_impl<context_type_from_handlers<H...>>>();
-}
-
-template <class...  H>
-inline context_ptr make_shared_context( H && ... ) noexcept
-{
-    return std::make_shared<leaf_detail::polymorphic_context_impl<context_type_from_handlers<H...>>>();
-}
-
-#endif
-
 } }
 
 #endif
diff --git a/include/boost/leaf/detail/all.hpp b/include/boost/leaf/detail/all.hpp
index 769cfd84..369b0c1b 100644
--- a/include/boost/leaf/detail/all.hpp
+++ b/include/boost/leaf/detail/all.hpp
@@ -4,9 +4,7 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/leaf/config.hpp>
-#include <boost/leaf/capture.hpp>
 #include <boost/leaf/common.hpp>
-#include <boost/leaf/context.hpp>
 #include <boost/leaf/error.hpp>
 #include <boost/leaf/exception.hpp>
 #include <boost/leaf/handle_errors.hpp>
diff --git a/include/boost/leaf/detail/capture_list.hpp b/include/boost/leaf/detail/capture_list.hpp
new file mode 100644
index 00000000..9765b768
--- /dev/null
+++ b/include/boost/leaf/detail/capture_list.hpp
@@ -0,0 +1,129 @@
+#ifndef BOOST_LEAF_DETAIL_CAPTURE_HPP_INCLUDED
+#define BOOST_LEAF_DETAIL_CAPTURE_HPP_INCLUDED
+
+// Copyright 2018-2023 Emil Dotchevski and Reverge Studios, Inc.
+
+// 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)
+
+#include <boost/leaf/config.hpp>
+#include <iosfwd>
+
+#if BOOST_LEAF_CFG_CAPTURE
+
+namespace boost { namespace leaf {
+
+namespace leaf_detail
+{
+    struct BOOST_LEAF_SYMBOL_VISIBLE tls_tag_id_factory_current_id;
+
+    class capture_list
+    {
+        capture_list( capture_list const & ) = delete;
+        capture_list & operator=( capture_list const & ) = delete;
+
+    protected:
+
+        class node
+        {
+            friend class capture_list;
+
+            virtual void unload( int err_id ) = 0;
+#if BOOST_LEAF_CFG_DIAGNOSTICS
+            virtual void print( std::ostream &, int err_id_to_print ) const = 0;
+#endif
+
+        protected:
+
+            virtual ~node() noexcept
+            {
+            };
+
+            node * next_;
+
+            BOOST_LEAF_CONSTEXPR explicit node( node * * & last ) noexcept:
+                next_(nullptr)
+            {
+                BOOST_LEAF_ASSERT(last != nullptr);
+                *last = this;
+                last = &next_;
+            }
+        };
+        node * first_;
+
+        template <class F>
+        BOOST_LEAF_CONSTEXPR void for_each( F f ) const
+        {
+            for( node * p=first_; p; p=p->next_ )
+                f(*p);
+        }
+
+        void clear() noexcept
+        {
+            for( node const * p = first_; p; )
+            {
+                node const * n = p -> next_;
+                delete p;
+                p = n;
+            }
+            first_ = nullptr;
+        }
+
+    public:
+
+        BOOST_LEAF_CONSTEXPR explicit capture_list( node * first ) noexcept:
+            first_(first)
+        {
+        }
+
+        BOOST_LEAF_CONSTEXPR capture_list( capture_list && other ) noexcept:
+            first_(other.first_)
+        {
+            other.first_ = nullptr;
+        }
+
+        ~capture_list() noexcept
+        {
+            clear();
+        }
+
+        void unload( int const err_id )
+        {
+            tls::write_uint<leaf_detail::tls_tag_id_factory_current_id>(unsigned(err_id));
+            for_each(
+                [err_id]( node & n )
+                {
+                    n.unload(err_id);
+                } );
+            clear();
+        }
+
+        template <class CharT, class Traits>
+        void print( std::basic_ostream<CharT, Traits> & os, char const * title, int const err_id_to_print ) const
+        {
+            BOOST_LEAF_ASSERT(title != nullptr);
+#if BOOST_LEAF_CFG_DIAGNOSTICS
+            if( first_ )
+            {
+                os << title;
+                for_each(
+                    [&os, err_id_to_print]( node const & n )
+                    {
+                        n.print(os, err_id_to_print);
+                    } );
+            }
+#else
+            (void) os;
+            (void) title;
+            (void) err_id_to_print;
+#endif
+        }
+};
+
+}
+
+} }
+
+#endif
+
+#endif
diff --git a/include/boost/leaf/detail/optional.hpp b/include/boost/leaf/detail/optional.hpp
index ac1c8a24..aaf8a88e 100644
--- a/include/boost/leaf/detail/optional.hpp
+++ b/include/boost/leaf/detail/optional.hpp
@@ -66,7 +66,7 @@ namespace leaf_detail
             reset();
             if( int key = x.key() )
             {
-                put(key, x.value_);
+                load(key, x.value_);
                 key_ = key;
             }
             return *this;
@@ -77,7 +77,7 @@ namespace leaf_detail
             reset();
             if( int key = x.key() )
             {
-                put(key, std::move(x.value_));
+                load(key, std::move(x.value_));
                 x.reset();
             }
             return *this;
@@ -107,7 +107,7 @@ namespace leaf_detail
             }
         }
 
-        BOOST_LEAF_CONSTEXPR T & put( int key )
+        BOOST_LEAF_CONSTEXPR T & load( int key )
         {
             BOOST_LEAF_ASSERT(key);
             reset();
@@ -116,7 +116,7 @@ namespace leaf_detail
             return value_;
         }
 
-        BOOST_LEAF_CONSTEXPR T & put( int key, T const & v )
+        BOOST_LEAF_CONSTEXPR T & load( int key, T const & v )
         {
             BOOST_LEAF_ASSERT(key);
             reset();
@@ -125,7 +125,7 @@ namespace leaf_detail
             return value_;
         }
 
-        BOOST_LEAF_CONSTEXPR T & put( int key, T && v ) noexcept
+        BOOST_LEAF_CONSTEXPR T & load( int key, T && v ) noexcept
         {
             BOOST_LEAF_ASSERT(key);
             reset();
diff --git a/include/boost/leaf/error.hpp b/include/boost/leaf/error.hpp
index 0791cc7c..82dbaf2c 100644
--- a/include/boost/leaf/error.hpp
+++ b/include/boost/leaf/error.hpp
@@ -9,6 +9,7 @@
 #include <boost/leaf/config.hpp>
 #include <boost/leaf/detail/optional.hpp>
 #include <boost/leaf/detail/function_traits.hpp>
+#include <boost/leaf/detail/capture_list.hpp>
 #include <boost/leaf/detail/print.hpp>
 
 #if BOOST_LEAF_CFG_DIAGNOSTICS
@@ -67,201 +68,60 @@
 
 namespace boost { namespace leaf {
 
-class error_id;
+class BOOST_LEAF_SYMBOL_VISIBLE error_id;
+
+template <class T>
+class BOOST_LEAF_SYMBOL_VISIBLE result;
 
 namespace leaf_detail
 {
-    struct BOOST_LEAF_SYMBOL_VISIBLE tls_tag_unexpected_enabled_counter;
     struct BOOST_LEAF_SYMBOL_VISIBLE tls_tag_id_factory_current_id;
 
-    struct inject_loc
+    template <class=void>
+    struct BOOST_LEAF_SYMBOL_VISIBLE id_factory
     {
-        char const * const file;
-        int const line;
-        char const * const fn;
+        static atomic_unsigned_int counter;
 
-        template <class T>
-        friend T operator+( inject_loc loc, T && x ) noexcept
+        BOOST_LEAF_CONSTEXPR static unsigned generate_next_id() noexcept
         {
-            x.load_source_location_(loc.file, loc.line, loc.fn);
-            return std::move(x);
+            auto id = (counter+=4);
+            BOOST_LEAF_ASSERT((id&3)==1);
+            return id;
         }
     };
-}
-
-} }
-
-////////////////////////////////////////
 
-namespace boost { namespace leaf {
-
-#if BOOST_LEAF_CFG_DIAGNOSTICS
+    template <class T>
+    atomic_unsigned_int id_factory<T>::counter(unsigned(-3));
 
-namespace leaf_detail
-{
-    class BOOST_LEAF_SYMBOL_VISIBLE e_unexpected_count
+    inline int current_id() noexcept
     {
-    public:
-
-        char const * (*first_type)();
-        int count;
-
-        BOOST_LEAF_CONSTEXPR explicit e_unexpected_count(char const * (*ft)()) noexcept:
-            first_type(ft),
-            count(1)
-        {
-        }
-
-        template <class CharT, class Traits>
-        void print( std::basic_ostream<CharT, Traits> & os ) const
-        {
-            BOOST_LEAF_ASSERT(first_type != nullptr);
-            BOOST_LEAF_ASSERT(count>0);
-            os << "Detected ";
-            if( count==1 )
-                os << "1 attempt to communicate an unexpected error object";
-            else
-                os << count << " attempts to communicate unexpected error objects, the first one";
-            (os << " of type " << first_type() << '\n').flush();
-        }
-    };
+        unsigned id = tls::read_uint<tls_tag_id_factory_current_id>();
+        BOOST_LEAF_ASSERT(id==0 || (id&3)==1);
+        return int(id);
+    }
 
-    template <>
-    struct diagnostic<e_unexpected_count, false, false>
+    inline int new_id() noexcept
     {
-        static constexpr bool is_invisible = true;
-
-        template <class CharT, class Traits>
-        BOOST_LEAF_CONSTEXPR static void print( std::basic_ostream<CharT, Traits> &, e_unexpected_count const &) noexcept { }
-    };
-
-    template <class E>
-    class BOOST_LEAF_SYMBOL_VISIBLE slot;
+        unsigned id = id_factory<>::generate_next_id();
+        tls::write_uint<tls_tag_id_factory_current_id>(id);
+        return int(id);
+    }
 
-    class BOOST_LEAF_SYMBOL_VISIBLE e_unexpected_info
+    struct inject_loc
     {
-        e_unexpected_info( e_unexpected_info const & ) = delete;
-        e_unexpected_info & operator=( e_unexpected_info const & ) = delete;
-
-        struct slot_base
-        {
-        public:
-            slot_base * next_;
-            virtual void deactivate() noexcept = 0;
-            virtual void propagate( int err_id ) noexcept = 0;
-            virtual void print( std::ostream &, int key_to_print ) const = 0;
-            virtual ~slot_base() noexcept { };
-        protected:
-            BOOST_LEAF_CONSTEXPR slot_base():
-                next_(nullptr)
-            {
-            }
-        };
-
-        template <class E>
-        class slot_store: public slot_base, public slot<E>
-        {
-            slot_store( slot_store const & ) = delete;
-            slot_store & operator=( slot_store const & ) = delete;
-            void deactivate() noexcept final override
-            {
-                slot<E>::deactivate();
-            }
-            void propagate( int err_id ) noexcept final override
-            {
-                slot<E>::propagate(err_id);
-            }
-            void print( std::ostream & os, int key_to_print ) const final override
-            {
-                slot<E>::print(os, key_to_print);
-            }
-        public:
-            template <class T>
-            BOOST_LEAF_CONSTEXPR slot_store( int err_id, T && e )
-            {
-                slot<E>::put(err_id, std::forward<T>(e));
-            }
-        };
-
-        slot_base * first_;
-        slot_base * * last_;
-
-    public:
-
-        BOOST_LEAF_CONSTEXPR e_unexpected_info() noexcept:
-            first_(nullptr),
-            last_(&first_)
-        {
-        }
-
-        BOOST_LEAF_CONSTEXPR e_unexpected_info( e_unexpected_info && other ) noexcept:
-            first_(other.first_),
-            last_(other.last_ == &other.first_? &first_ : other.last_)
-        {
-            BOOST_LEAF_ASSERT(last_ != nullptr);
-            BOOST_LEAF_ASSERT(*last_ == nullptr);
-            other.first_ = nullptr;
-            other.last_ = nullptr;
-        }
-
-        ~e_unexpected_info() noexcept
-        {
-            for( slot_base const * p = first_; p; )
-            {
-                slot_base const * n = p -> next_;
-                delete p;
-                p = n;
-            }
-        }
-
-        template <class E>
-        BOOST_LEAF_CONSTEXPR typename std::decay<E>::type & put(int err_id, E && e)
-        {
-            using T = typename std::decay<E>::type;
-            BOOST_LEAF_ASSERT(last_ != nullptr);
-            BOOST_LEAF_ASSERT(*last_ == nullptr);
-            BOOST_LEAF_ASSERT(tls::read_ptr<slot<T>>() == nullptr);
-            slot_store<T> * ss = new slot_store<T>(err_id, std::forward<E>(e));
-            *last_ = ss;
-            last_ = &ss->next_;
-            ss->activate();
-            return ss->value(err_id);
-        }
-
-        void deactivate() noexcept
-        {
-            for( slot_base * p=first_; p; p=p->next_ )
-                p->deactivate();
-        }
-
-        void propagate( int err_id ) noexcept
-        {
-            for( slot_base * p=first_; p; p=p->next_ )
-                p->propagate(err_id);
-        }
+        char const * const file;
+        int const line;
+        char const * const fn;
 
-        template <class CharT, class Traits>
-        void print( std::basic_ostream<CharT, Traits> & os, int key_to_print ) const
+        template <class T>
+        friend T operator+( inject_loc loc, T && x ) noexcept
         {
-            os << "Unhandled error objects:\n";
-            for( slot_base const * p=first_; p; p=p->next_ )
-                p->print(os, key_to_print);
+            x.load_source_location_(loc.file, loc.line, loc.fn);
+            return std::move(x);
         }
     };
-
-    template <>
-    struct diagnostic<e_unexpected_info, false, false>
-    {
-        static constexpr bool is_invisible = true;
-
-        template <class CharT, class Traits>
-        BOOST_LEAF_CONSTEXPR static void print( std::basic_ostream<CharT, Traits> &, e_unexpected_info const &) noexcept { }
-    };
-
 }
 
-#endif
-
 } }
 
 ////////////////////////////////////////
@@ -281,8 +141,12 @@ struct BOOST_LEAF_SYMBOL_VISIBLE e_source_location
     }
 };
 
+} }
+
 ////////////////////////////////////////
 
+namespace boost { namespace leaf {
+
 namespace leaf_detail
 {
     template <class E>
@@ -315,23 +179,23 @@ namespace leaf_detail
             tls::write_ptr<slot<E>>(this);
         }
 
-        void deactivate() noexcept
+        void deactivate() const noexcept
         {
             tls::write_ptr<slot<E>>(prev_);
         }
 
-        void propagate( int err_id ) noexcept(!BOOST_LEAF_CFG_DIAGNOSTICS);
+        void unload( int err_id ) noexcept(!BOOST_LEAF_CFG_CAPTURE);
 
         template <class CharT, class Traits>
-        void print( std::basic_ostream<CharT, Traits> & os, int key_to_print ) const
+        void print( std::basic_ostream<CharT, Traits> & os, int err_id_to_print ) const
         {
 #if BOOST_LEAF_CFG_DIAGNOSTICS
             if( !diagnostic<E>::is_invisible )
                 if( int k = this->key() )
                 {
-                    if( key_to_print )
+                    if( err_id_to_print )
                     {
-                        if( key_to_print!=k )
+                        if( err_id_to_print!=k )
                             return;
                     }
                     else
@@ -341,80 +205,251 @@ namespace leaf_detail
                 }
 #else
             (void) os;
-            (void) key_to_print;
+            (void) err_id_to_print;
 #endif
         }
 
-        using impl::put;
+        using impl::load;
         using impl::has_value;
         using impl::value;
     };
+}
+
+} }
+
+////////////////////////////////////////
+
+#if BOOST_LEAF_CFG_CAPTURE
+
+namespace boost { namespace leaf {
+
+namespace leaf_detail
+{
+    class BOOST_LEAF_SYMBOL_VISIBLE dynamic_allocator:
+        capture_list
+    {
+        dynamic_allocator( dynamic_allocator const & ) = delete;
+        dynamic_allocator & operator=( dynamic_allocator const & ) = delete;
+
+        class capturing_node:
+            public capture_list::node
+        {
+        protected:
+            BOOST_LEAF_CONSTEXPR explicit capturing_node( capture_list::node * * & last ) noexcept:
+                node(last)
+            {
+                BOOST_LEAF_ASSERT(last == &next_);
+                BOOST_LEAF_ASSERT(next_ == nullptr);
+            }
+        public:
+            virtual void deactivate() const noexcept = 0;
+        };
+
+        template <class E>
+        class capturing_slot_node:
+            public capturing_node,
+            public slot<E>
+        {
+            using impl = slot<E>;
+
+            capturing_slot_node( capturing_slot_node const & ) = delete;
+            capturing_slot_node & operator=( capturing_slot_node const & ) = delete;
+
+            void deactivate() const noexcept final override
+            {
+                impl::deactivate();
+            }
+
+            void unload( int err_id ) final override
+            {
+                impl::unload(err_id);
+            }
+
+#if BOOST_LEAF_CFG_DIAGNOSTICS
+            void print( std::ostream & os, int err_id_to_print ) const final override
+            {
+                impl::print(os, err_id_to_print);
+            }
+#endif
+
+        public:
+
+            template <class T>
+            BOOST_LEAF_CONSTEXPR capturing_slot_node( capture_list::node * * & last, int err_id, T && e ):
+                capturing_node(last)
+            {
+                BOOST_LEAF_ASSERT(last == &next_);
+                BOOST_LEAF_ASSERT(next_ == nullptr);
+                impl::load(err_id, std::forward<T>(e));
+            }
+        };
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+        class capturing_exception_node:
+            public capturing_node
+        {
+            capturing_exception_node( capturing_exception_node const & ) = delete;
+            capturing_exception_node & operator=( capturing_exception_node const & ) = delete;
+
+            void deactivate() const noexcept final override
+            {
+                BOOST_LEAF_ASSERT(0);
+            }
+
+            void unload( int ) final override
+            {
+                std::rethrow_exception(ex_);
+            }
 
 #if BOOST_LEAF_CFG_DIAGNOSTICS
+            void print( std::ostream &, int err_id_to_print ) const final override
+            {
+            }
+#endif
+
+            std::exception_ptr const ex_;
+
+        public:
+
+            explicit capturing_exception_node( capture_list::node * * & last, std::exception_ptr && ex ) noexcept:
+                capturing_node(last),
+                ex_(std::move(ex))
+            {
+                BOOST_LEAF_ASSERT(last == &next_);
+                BOOST_LEAF_ASSERT(ex_);
+            }
+        };
+#endif
+
+        int err_id_;
+        capture_list::node * * last_;
+
+    public:
+
+        BOOST_LEAF_CONSTEXPR dynamic_allocator() noexcept:
+            capture_list(nullptr),
+            err_id_(0),
+            last_(&first_)
+        {
+            BOOST_LEAF_ASSERT(first_ == nullptr);
+        }
+
+        BOOST_LEAF_CONSTEXPR dynamic_allocator( dynamic_allocator && other ) noexcept:
+            capture_list(std::move(other)),
+            err_id_(other.err_id_),
+            last_(other.last_ == &other.first_? &first_ : other.last_)
+        {
+            BOOST_LEAF_ASSERT(last_ != nullptr);
+            BOOST_LEAF_ASSERT(*last_ == nullptr);
+            BOOST_LEAF_ASSERT(other.first_ == nullptr);
+            other.last_ = nullptr;
+        }
+
+        template <class E>
+        BOOST_LEAF_CONSTEXPR typename std::decay<E>::type & dynamic_load(int err_id, E && e)
+        {
+            using T = typename std::decay<E>::type;
+            BOOST_LEAF_ASSERT(last_ != nullptr);
+            BOOST_LEAF_ASSERT(*last_ == nullptr);
+            BOOST_LEAF_ASSERT(tls::read_ptr<slot<T>>() == nullptr);
+            capturing_slot_node<T> * csn = new capturing_slot_node<T>(last_, err_id, std::forward<E>(e));
+            csn->activate();
+            err_id_ = err_id;
+            return csn->value(err_id);
+        }
+
+        BOOST_LEAF_CONSTEXPR void deactivate() const noexcept
+        {
+            for_each(
+                []( capture_list::node const & n )
+                {
+                    static_cast<capturing_node const &>(n).deactivate();
+                } );
+        }
+
+        BOOST_LEAF_CONSTEXPR bool empty() const noexcept
+        {
+            return last_ == &first_;
+        }
+
+        BOOST_LEAF_CONSTEXPR int size() const noexcept
+        {
+            int n = 0;
+            for_each(
+                [&]( capture_list::node const & )
+                {
+                    ++n;
+                } );
+            return n;
+        }
+
+        template <class T>
+        result<T> extract_capture_list() noexcept
+        {
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+            if( std::exception_ptr ex = std::current_exception() )
+                (void) new capturing_exception_node(last_, std::move(ex));
+#endif
+            leaf_detail::capture_list::node * const f = first_;
+            first_ = nullptr;
+            last_ = &first_;
+            return { err_id_, capture_list(f) };
+        }
+
+        using capture_list::unload;
+        using capture_list::print;
+    };
 
     template <>
-    inline void slot<e_unexpected_info>::deactivate() noexcept
+    inline void slot<dynamic_allocator>::deactivate() const noexcept
     {
         if( int const err_id = this->key() )
-            if( e_unexpected_info * info = this->has_value(err_id) )
-                info->deactivate();
-        tls::write_ptr<slot<e_unexpected_info>>(prev_);
+            if( dynamic_allocator const * c = this->has_value(err_id) )
+                c->deactivate();
+        tls::write_ptr<slot<dynamic_allocator>>(prev_);
     }
 
     template <>
-    inline void slot<e_unexpected_info>::propagate( int err_id )
+    inline void slot<dynamic_allocator>::unload( int err_id ) noexcept(false)
     {
-        if( e_unexpected_info * info = this->has_value(err_id) )
-            info->propagate(err_id);
-    }
-
-    template <class E>
-    BOOST_LEAF_CONSTEXPR inline void load_unexpected_count( int err_id ) noexcept
-    {
-        if( slot<e_unexpected_count> * sl = tls::read_ptr<slot<e_unexpected_count>>() )
-        {
-            if( e_unexpected_count * unx = sl->has_value(err_id) )
-                ++unx->count;
-            else
-                sl->put(err_id, e_unexpected_count(&type<E>));
-        }
+        if( dynamic_allocator * c = this->has_value(err_id) )
+            c->unload(err_id);
     }
 
     template <class E>
-    BOOST_LEAF_CONSTEXPR inline void load_unexpected_info( int err_id, E && e )
+    inline void dynamic_load_( int err_id, E && e )
     {
-        if( slot<e_unexpected_info> * sl = tls::read_ptr<slot<e_unexpected_info>>() )
+        if( slot<dynamic_allocator> * sl = tls::read_ptr<slot<dynamic_allocator>>() )
         {
-            if( e_unexpected_info * unx = sl->has_value(err_id) )
-                (void) unx->put(err_id, std::forward<E>(e));
+            if( dynamic_allocator * c = sl->has_value(err_id) )
+                c->dynamic_load(err_id, std::forward<E>(e));
             else
-                (void) sl->put(err_id).put(err_id, std::forward<E>(e));
+                sl->load(err_id).dynamic_load(err_id, std::forward<E>(e));
         }
     }
 
     template <class E, class F>
-    BOOST_LEAF_CONSTEXPR inline void accumulate_unexpected_info( int err_id, F && f )
+    inline void dynamic_accumulate_( int err_id, F && f )
     {
-        if( slot<e_unexpected_info> * sl = tls::read_ptr<slot<e_unexpected_info>>() )
+        if( slot<dynamic_allocator> * sl = tls::read_ptr<slot<dynamic_allocator>>() )
         {
-            if( e_unexpected_info * unx = sl->has_value(err_id) )
-                (void) std::forward<F>(f)(unx->put(err_id, E{}));
+            if( dynamic_allocator * c = sl->has_value(err_id) )
+                (void) std::forward<F>(f)(c->dynamic_load(err_id, E{}));
             else
-                (void) std::forward<F>(f)(sl->put(err_id).put(err_id, E{}));
+                (void) std::forward<F>(f)(sl->load(err_id).dynamic_load(err_id, E{}));
         }
     }
 
     template <bool OnError, class E>
-    inline void load_unexpected( int err_id, E && e  ) noexcept(OnError)
+    inline void dynamic_load( int err_id, E && e  ) noexcept(OnError)
     {
-        load_unexpected_count<E>(err_id);
         if( OnError )
         {
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
             try
             {
 #endif
-                load_unexpected_info(err_id, std::forward<E>(e));
+                dynamic_load_(err_id, std::forward<E>(e));
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
             }
             catch(...)
@@ -423,20 +458,19 @@ namespace leaf_detail
 #endif
         }
         else
-            load_unexpected_info(err_id, std::forward<E>(e));
+            dynamic_load_(err_id, std::forward<E>(e));
     }
 
     template <bool OnError, class E, class F>
-    inline void accumulate_unexpected( int err_id, F && f  ) noexcept(OnError)
+    inline void dynamic_accumulate( int err_id, F && f  ) noexcept(OnError)
     {
-        load_unexpected_count<E>(err_id);
         if( OnError )
         {
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
             try
             {
 #endif
-                accumulate_unexpected_info<E>(err_id, std::forward<F>(f));
+                dynamic_accumulate_<E>(err_id, std::forward<F>(f));
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
             }
             catch(...)
@@ -445,27 +479,31 @@ namespace leaf_detail
 #endif
         }
         else
-            accumulate_unexpected_info<E>(err_id, std::forward<F>(f));
+            dynamic_accumulate_<E>(err_id, std::forward<F>(f));
     }
+}
+
+} }
 
 #endif
 
+////////////////////////////////////////
+
+namespace boost { namespace leaf {
+
+namespace leaf_detail
+{
     template <class E>
-    inline void slot<E>::propagate( int err_id ) noexcept(!BOOST_LEAF_CFG_DIAGNOSTICS)
+    inline void slot<E>::unload( int err_id ) noexcept(!BOOST_LEAF_CFG_CAPTURE)
     {
         BOOST_LEAF_ASSERT(err_id);
         if( this->key()!=err_id )
             return;
         if( impl * p = tls::read_ptr<slot<E>>() )
             *p = std::move(*this);
-#if BOOST_LEAF_CFG_DIAGNOSTICS
+#if BOOST_LEAF_CFG_CAPTURE
         else
-        {
-            int c = int(tls::read_uint<tls_tag_unexpected_enabled_counter>());
-            BOOST_LEAF_ASSERT(c>=0);
-            if( c )
-                load_unexpected<false>(err_id, std::move(*this).value(err_id));
-        }
+            dynamic_load<false>(err_id, std::move(*this).value(err_id));
 #endif
     }
 
@@ -479,17 +517,12 @@ namespace leaf_detail
         if( slot<T> * p = tls::read_ptr<slot<T>>() )
         {
             if( !OnError || !p->has_value(err_id) )
-                (void) p->put(err_id, std::forward<E>(e));
+                (void) p->load(err_id, std::forward<E>(e));
         }
-#if BOOST_LEAF_CFG_DIAGNOSTICS
+#if BOOST_LEAF_CFG_CAPTURE
         else
-        {
-            int c = int(tls::read_uint<tls_tag_unexpected_enabled_counter>());
-            BOOST_LEAF_ASSERT(c>=0);
-            if( c )
-                load_unexpected<OnError>(err_id, std::forward<E>(e));
-        }
-#endif
+            dynamic_load<OnError>(err_id, std::forward<E>(e));
+#endif        
         return 0;
     }
 
@@ -505,58 +538,22 @@ namespace leaf_detail
             if( auto v = sl->has_value(err_id) )
                 (void) std::forward<F>(f)(*v);
             else
-                (void) std::forward<F>(f)(sl->put(err_id,E()));
+                (void) std::forward<F>(f)(sl->load(err_id,E()));
         }
-#if BOOST_LEAF_CFG_DIAGNOSTICS
+#if BOOST_LEAF_CFG_CAPTURE
         else
-        {
-            int c = int(tls::read_uint<tls_tag_unexpected_enabled_counter>());
-            BOOST_LEAF_ASSERT(c>=0);
-            if( c )
-                accumulate_unexpected<OnError, E>(err_id, std::forward<F>(f));
-        }
+            dynamic_accumulate<OnError, E>(err_id, std::forward<F>(f));
 #endif
         return 0;
     }
 }
 
-////////////////////////////////////////
-
-namespace leaf_detail
-{
-    template <class=void>
-    struct BOOST_LEAF_SYMBOL_VISIBLE id_factory
-    {
-        static atomic_unsigned_int counter;
-
-        BOOST_LEAF_CONSTEXPR static unsigned generate_next_id() noexcept
-        {
-            auto id = (counter+=4);
-            BOOST_LEAF_ASSERT((id&3)==1);
-            return id;
-        }
-    };
-
-    template <class T>
-    atomic_unsigned_int id_factory<T>::counter(unsigned(-3));
-
-    inline int current_id() noexcept
-    {
-        unsigned id = tls::read_uint<tls_tag_id_factory_current_id>();
-        BOOST_LEAF_ASSERT(id==0 || (id&3)==1);
-        return int(id);
-    }
-
-    inline int new_id() noexcept
-    {
-        unsigned id = id_factory<>::generate_next_id();
-        tls::write_uint<tls_tag_id_factory_current_id>(id);
-        return int(id);
-    }
-}
+} }
 
 ////////////////////////////////////////
 
+namespace boost { namespace leaf {
+
 namespace leaf_detail
 {
     template <class T, int Arity = function_traits<T>::arity>
@@ -593,10 +590,14 @@ namespace leaf_detail
     };
 }
 
+} }
+
 ////////////////////////////////////////
 
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
+namespace boost { namespace leaf {
+
 namespace leaf_detail
 {
     class leaf_category final: public std::error_category
@@ -623,7 +624,7 @@ namespace leaf_detail
         if( int err_id = ec.value() )
         {
             std::error_category const & cat = get_error_category<>::cat;
-            if( &ec.category()==&cat )
+            if( &ec.category() == &cat )
             {
                 BOOST_LEAF_ASSERT((err_id&3)==1);
                 return (err_id&~3)|1;
@@ -647,10 +648,14 @@ inline bool is_error_id( std::error_code const & ec ) noexcept
     return res;
 }
 
+} }
+
 #endif
 
 ////////////////////////////////////////
 
+namespace boost { namespace leaf {
+
 namespace leaf_detail
 {
     BOOST_LEAF_CONSTEXPR error_id make_error_id(int) noexcept;
@@ -688,7 +693,7 @@ class BOOST_LEAF_SYMBOL_VISIBLE error_id
     {
     }
 
-    std::error_code to_error_code() const noexcept
+    operator std::error_code() const noexcept
     {
         return std::error_code(value_, leaf_detail::get_error_category<>::cat);
     }
@@ -788,38 +793,6 @@ inline error_id current_error() noexcept
     return leaf_detail::make_error_id(leaf_detail::current_id());
 }
 
-////////////////////////////////////////////
-
-class polymorphic_context
-{
-protected:
-
-    polymorphic_context() noexcept = default;
-    ~polymorphic_context() noexcept = default;
-
-public:
-
-    virtual void activate() noexcept = 0;
-    virtual void deactivate() noexcept = 0;
-    virtual void propagate( error_id ) noexcept = 0;
-    virtual bool is_active() const noexcept = 0;
-    virtual void print( std::ostream & ) const { };
-    error_id captured_id_;
-
-    template <class CharT, class Traits>
-    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, polymorphic_context const & ctx )
-    {
-        ctx.print(os);
-        return os;
-    }
-};
-
-#if BOOST_LEAF_CFG_CAPTURE
-using context_ptr = std::shared_ptr<polymorphic_context>;
-#endif
-
-////////////////////////////////////////////
-
 template <class Ctx>
 class context_activator
 {
@@ -859,14 +832,12 @@ class context_activator
     }
 };
 
-template <class Ctx>
-BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE context_activator<Ctx> activate_context(Ctx & ctx) noexcept
-{
-    return context_activator<Ctx>(ctx);
-}
+} }
 
 ////////////////////////////////////////////
 
+namespace boost { namespace leaf {
+
 template <class R>
 struct is_result_type: std::false_type
 {
diff --git a/include/boost/leaf/handle_errors.hpp b/include/boost/leaf/handle_errors.hpp
index 90cefd7e..e99c7d49 100644
--- a/include/boost/leaf/handle_errors.hpp
+++ b/include/boost/leaf/handle_errors.hpp
@@ -8,10 +8,12 @@
 
 #include <boost/leaf/config.hpp>
 #include <boost/leaf/context.hpp>
-#include <boost/leaf/capture.hpp>
 
 namespace boost { namespace leaf {
 
+template <class T>
+class result;
+
 class BOOST_LEAF_SYMBOL_VISIBLE error_info
 {
     error_info & operator=( error_info const & ) = delete;
@@ -19,14 +21,6 @@ class BOOST_LEAF_SYMBOL_VISIBLE error_info
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
     static error_id unpack_error_id( std::exception const * ex ) noexcept
     {
-#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
-        if( std::system_error const * se = dynamic_cast<std::system_error const *>(ex) )
-            if( is_error_id(se->code()) )
-                return leaf_detail::make_error_id(se->code().value());
-        if( std::error_code const * ec = dynamic_cast<std::error_code const *>(ex) )
-            if( is_error_id(*ec) )
-                return leaf_detail::make_error_id(ec->value());
-#endif
         if( error_id const * err_id = dynamic_cast<error_id const *>(ex) )
             return *err_id;
         return current_error();
@@ -98,22 +92,18 @@ class BOOST_LEAF_SYMBOL_VISIBLE error_info
 
 ////////////////////////////////////////
 
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-
-class BOOST_LEAF_SYMBOL_VISIBLE diagnostic_info: public error_info
+class diagnostic_info: public error_info
 {
-    leaf_detail::e_unexpected_count const * e_uc_;
     void const * tup_;
-    void (*print_)( std::ostream &, void const * tup, int key_to_print );
+    void (*print_)( std::ostream &, void const * tup, int err_id_to_print );
 
 protected:
 
     diagnostic_info( diagnostic_info const & ) noexcept = default;
 
     template <class Tup>
-    BOOST_LEAF_CONSTEXPR diagnostic_info( error_info const & ei, leaf_detail::e_unexpected_count const * e_uc, Tup const & tup ) noexcept:
+    BOOST_LEAF_CONSTEXPR diagnostic_info( error_info const & ei, Tup const & tup ) noexcept:
         error_info(ei),
-        e_uc_(e_uc),
         tup_(&tup),
         print_(&leaf_detail::tuple_for_each<std::tuple_size<Tup>::value, Tup>::print)
     {
@@ -128,8 +118,6 @@ class BOOST_LEAF_SYMBOL_VISIBLE diagnostic_info: public error_info
         x.print(os);
         os << ":\n";
         x.print_(os, x.tup_, x.error().value());
-        if( x.e_uc_  )
-            x.e_uc_->print(os);
         return os;
     }
 };
@@ -139,66 +127,95 @@ namespace leaf_detail
     struct diagnostic_info_: diagnostic_info
     {
         template <class Tup>
-        BOOST_LEAF_CONSTEXPR diagnostic_info_( error_info const & ei, leaf_detail::e_unexpected_count const * e_uc, Tup const & tup ) noexcept:
-            diagnostic_info(ei, e_uc, tup)
+        BOOST_LEAF_CONSTEXPR diagnostic_info_( error_info const & ei, Tup const & tup ) noexcept:
+            diagnostic_info(ei, tup)
         {
         }
     };
 
     template <>
-    struct handler_argument_traits<diagnostic_info const &>: handler_argument_always_available<e_unexpected_count>
+    struct handler_argument_traits<diagnostic_info const &>: handler_argument_always_available<void>
     {
         template <class Tup>
         BOOST_LEAF_CONSTEXPR static diagnostic_info_ get( Tup const & tup, error_info const & ei ) noexcept
         {
-            return diagnostic_info_(ei, handler_argument_traits_defaults<e_unexpected_count>::check(tup, ei), tup);
+            return diagnostic_info_(ei, tup);
         }
     };
 }
 
-#else
+////////////////////////////////////////
+
+#if BOOST_LEAF_CFG_CAPTURE
 
-class BOOST_LEAF_SYMBOL_VISIBLE diagnostic_info: public error_info
+class dynamic_capture
 {
+    template <class T>
+    friend class ::boost::leaf::result;
+
+    dynamic_capture( dynamic_capture const & ) = delete;
+    dynamic_capture & operator=( dynamic_capture const & ) = delete;
+
+    leaf_detail::dynamic_allocator * const da_;
+    error_id err_;
+
 protected:
 
-    diagnostic_info( diagnostic_info const & ) noexcept = default;
+    dynamic_capture( dynamic_capture && ) = default;
 
-    BOOST_LEAF_CONSTEXPR diagnostic_info( error_info const & ei ) noexcept:
-        error_info(ei)
+    BOOST_LEAF_CONSTEXPR dynamic_capture( leaf_detail::dynamic_allocator * da, error_id err ) noexcept:
+        da_(da),
+        err_(err)
     {
     }
 
 public:
 
+    BOOST_LEAF_CONSTEXPR bool empty() const noexcept
+    {
+        return !da_ || da_->empty();
+    }
+
+    BOOST_LEAF_CONSTEXPR int size() const noexcept
+    {
+        return da_ ? da_->size() : 0;
+    }
+
+    template <class T>
+    operator result<T>() const noexcept
+    {
+        if( da_ )
+            return da_->extract_capture_list<T>();
+        else
+            return { error_id() };
+    }
+
     template <class CharT, class Traits>
-    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, diagnostic_info const & x )
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, dynamic_capture const & x )
     {
-        os <<
-            "leaf::diagnostic_info requires #define BOOST_LEAF_CFG_DIAGNOSTICS 1\n"
-            "leaf::error_info: ";
-        x.print(os);
-        return os << '\n';
+        if( x.da_ )
+            x.da_->print(os, "Captured error objects:\n", x.err_.value());
+        return os;
     }
 };
 
 namespace leaf_detail
 {
-    struct diagnostic_info_: diagnostic_info
+    struct dynamic_capture_: dynamic_capture
     {
-        BOOST_LEAF_CONSTEXPR diagnostic_info_( error_info const & ei ) noexcept:
-            diagnostic_info(ei)
+        BOOST_LEAF_CONSTEXPR dynamic_capture_( leaf_detail::dynamic_allocator * da, error_id err ) noexcept:
+            dynamic_capture(da, err)
         {
         }
     };
 
     template <>
-    struct handler_argument_traits<diagnostic_info const &>: handler_argument_always_available<void>
+    struct handler_argument_traits<dynamic_capture const &>: handler_argument_always_available<dynamic_allocator>
     {
         template <class Tup>
-        BOOST_LEAF_CONSTEXPR static diagnostic_info_ get( Tup const &, error_info const & ei ) noexcept
+        BOOST_LEAF_CONSTEXPR static dynamic_capture_ get( Tup & tup, error_info const & ei ) noexcept
         {
-            return diagnostic_info_(ei);
+            return dynamic_capture_(handler_argument_traits_defaults<dynamic_allocator>::check(tup, ei), ei.error());
         }
     };
 }
@@ -209,24 +226,36 @@ namespace leaf_detail
 
 #if BOOST_LEAF_CFG_DIAGNOSTICS
 
-class BOOST_LEAF_SYMBOL_VISIBLE verbose_diagnostic_info: public error_info
+class verbose_diagnostic_info: public error_info
 {
-    leaf_detail::e_unexpected_info const * e_ui_;
-    void const * tup_;
-    void (*print_)( std::ostream &, void const * tup, int key_to_print );
+    void const * const tup_;
+#if BOOST_LEAF_CFG_CAPTURE
+    leaf_detail::dynamic_allocator const * const da_;
+#endif
+    void (* const print_)( std::ostream &, void const * tup, int err_id_to_print );
 
 protected:
 
     verbose_diagnostic_info( verbose_diagnostic_info const & ) noexcept = default;
 
+#if BOOST_LEAF_CFG_CAPTURE
+    template <class Tup>
+    BOOST_LEAF_CONSTEXPR verbose_diagnostic_info( error_info const & ei, Tup const & tup, leaf_detail::dynamic_allocator const * da ) noexcept:
+        error_info(ei),
+        tup_(&tup),
+        da_(da),
+        print_(&leaf_detail::tuple_for_each<std::tuple_size<Tup>::value, Tup>::print)
+    {
+    }
+#else
     template <class Tup>
-    BOOST_LEAF_CONSTEXPR verbose_diagnostic_info( error_info const & ei, leaf_detail::e_unexpected_info const * e_ui, Tup const & tup ) noexcept:
+    BOOST_LEAF_CONSTEXPR verbose_diagnostic_info( error_info const & ei, Tup const & tup ) noexcept:
         error_info(ei),
-        e_ui_(e_ui),
         tup_(&tup),
         print_(&leaf_detail::tuple_for_each<std::tuple_size<Tup>::value, Tup>::print)
     {
     }
+#endif
 
 public:
 
@@ -234,86 +263,63 @@ class BOOST_LEAF_SYMBOL_VISIBLE verbose_diagnostic_info: public error_info
     friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, verbose_diagnostic_info const & x )
     {
         os << "leaf::verbose_diagnostic_info for ";
-        int const err_id = x.error().value();
+        error_id err = x.error();
         x.print(os);
         os << ":\n";
-        x.print_(os, x.tup_, err_id);
-        if( x.e_ui_ )
-            x.e_ui_->print(os, err_id);
+        x.print_(os, x.tup_, err.value());
+#if BOOST_LEAF_CFG_CAPTURE
+        if( x.da_ )
+            x.da_->print(os, "Unhandled error objects:\n", x.error().value());
+#endif
         return os;
     }
 };
 
 namespace leaf_detail
 {
+#if BOOST_LEAF_CFG_CAPTURE
     struct verbose_diagnostic_info_: verbose_diagnostic_info
     {
         template <class Tup>
-        BOOST_LEAF_CONSTEXPR verbose_diagnostic_info_( error_info const & ei, leaf_detail::e_unexpected_info const * e_ui, Tup const & tup ) noexcept:
-            verbose_diagnostic_info(ei, e_ui, tup)
+        BOOST_LEAF_CONSTEXPR verbose_diagnostic_info_( error_info const & ei, Tup const & tup, dynamic_allocator const * da ) noexcept:
+            verbose_diagnostic_info(ei, tup, da)
         {
         }
     };
-
     template <>
-    struct handler_argument_traits<verbose_diagnostic_info const &>: handler_argument_always_available<e_unexpected_info>
+    struct handler_argument_traits<verbose_diagnostic_info const &>: handler_argument_always_available<dynamic_allocator>
     {
         template <class Tup>
         BOOST_LEAF_CONSTEXPR static verbose_diagnostic_info_ get( Tup const & tup, error_info const & ei ) noexcept
         {
-            return verbose_diagnostic_info_(ei, handler_argument_traits_defaults<e_unexpected_info>::check(tup, ei), tup);
+            return verbose_diagnostic_info_(ei, tup, handler_argument_traits_defaults<dynamic_allocator>::check(tup, ei));
         }
     };
-}
-
 #else
-
-class BOOST_LEAF_SYMBOL_VISIBLE verbose_diagnostic_info: public error_info
-{
-protected:
-
-    verbose_diagnostic_info( verbose_diagnostic_info const & ) noexcept = default;
-
-    BOOST_LEAF_CONSTEXPR verbose_diagnostic_info( error_info const & ei ) noexcept:
-        error_info(ei)
-    {
-    }
-
-public:
-
-    template <class CharT, class Traits>
-    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, verbose_diagnostic_info const & x )
-    {
-        os <<
-            "leaf::verbose_diagnostic_info requires #define BOOST_LEAF_CFG_DIAGNOSTICS 1\n"
-            "leaf::error_info: ";
-        x.print(os);
-        return os << '\n';
-    }
-};
-
-namespace leaf_detail
-{
     struct verbose_diagnostic_info_: verbose_diagnostic_info
     {
-        BOOST_LEAF_CONSTEXPR verbose_diagnostic_info_( error_info const & ei ) noexcept:
-            verbose_diagnostic_info(ei)
+        template <class Tup>
+        BOOST_LEAF_CONSTEXPR verbose_diagnostic_info_( error_info const & ei, Tup const & tup ) noexcept:
+            verbose_diagnostic_info(ei, tup)
         {
         }
     };
-
-
     template <>
     struct handler_argument_traits<verbose_diagnostic_info const &>: handler_argument_always_available<void>
     {
         template <class Tup>
-        BOOST_LEAF_CONSTEXPR static verbose_diagnostic_info_ get( Tup const &, error_info const & ei ) noexcept
+        BOOST_LEAF_CONSTEXPR static verbose_diagnostic_info_ get( Tup const & tup, error_info const & ei ) noexcept
         {
-            return verbose_diagnostic_info_(ei);
+            return verbose_diagnostic_info_(ei, tup);
         }
     };
+#endif
 }
 
+#else
+
+using verbose_diagnostic_info = diagnostic_info;
+
 #endif
 
 ////////////////////////////////////////
@@ -695,6 +701,21 @@ handle_error( error_id id, H && ... h )
 
 ////////////////////////////////////////
 
+namespace leaf_detail
+{
+    template <class T>
+    void unload_result( result<T> * r )
+    {
+        (void) r->unload();
+    }
+
+    void unload_result( void * )
+    {
+    }
+}
+
+////////////////////////////////////////
+
 #ifdef BOOST_LEAF_NO_EXCEPTIONS
 
 template <class TryBlock, class... H>
@@ -709,10 +730,11 @@ try_handle_all( TryBlock && try_block, H && ... h ) noexcept
         return std::move(r).value();
     else
     {
+        leaf_detail::unload_result(&r);
         error_id id = r.error();
         ctx.deactivate();
         using R = typename std::decay<decltype(std::declval<TryBlock>()().value())>::type;
-        return ctx.template handle_error<R>(id, std::forward<H>(h)...);
+        return ctx.template handle_error<R>(std::move(id), std::forward<H>(h)...);
     }
 }
 
@@ -728,12 +750,13 @@ try_handle_some( TryBlock && try_block, H && ... h ) noexcept
         return r;
     else
     {
+        leaf_detail::unload_result(&r);
         error_id id = r.error();
         ctx.deactivate();
         using R = typename std::decay<decltype(std::declval<TryBlock>()())>::type;
-        auto rr = ctx.template handle_error<R>(id, std::forward<H>(h)..., [&r]()->R { return std::move(r); });
+        auto rr = ctx.template handle_error<R>(std::move(id), std::forward<H>(h)..., [&r]()->R { return std::move(r); });
         if( !rr )
-            ctx.propagate(rr.error());
+            ctx.unload(rr.error());
         return rr;
     }
 }
@@ -763,37 +786,6 @@ namespace leaf_detail
         {
             return std::forward<TryBlock>(try_block)();
         }
-#if BOOST_LEAF_CFG_CAPTURE
-        catch( capturing_exception const & cap )
-        {
-            try
-            {
-                cap.unload_and_rethrow_original_exception();
-            }
-            catch( std::exception & ex )
-            {
-                ctx.deactivate();
-                error_info e(&ex);
-                return handle_error_<R>(ctx.tup(), e, std::forward<H>(h)...,
-                    [&]() -> R
-                    {
-                        ctx.propagate(e.error());
-                        throw;
-                    } );
-            }
-            catch(...)
-            {
-                ctx.deactivate();
-                error_info e(nullptr);
-                return handle_error_<R>(ctx.tup(), e, std::forward<H>(h)...,
-                    [&]() -> R
-                    {
-                        ctx.propagate(e.error());
-                        throw;
-                    } );
-            }
-        }
-#endif
         catch( std::exception & ex )
         {
             ctx.deactivate();
@@ -801,7 +793,7 @@ namespace leaf_detail
             return handle_error_<R>(ctx.tup(), e, std::forward<H>(h)...,
                 [&]() -> R
                 {
-                    ctx.propagate(e.error());
+                    ctx.unload(e.error());
                     throw;
                 } );
         }
@@ -812,7 +804,7 @@ namespace leaf_detail
             return handle_error_<R>(ctx.tup(), e, std::forward<H>(h)...,
                 [&]() -> R
                 {
-                    ctx.propagate(e.error());
+                    ctx.unload(e.error());
                     throw;
                 } );
         }
@@ -820,56 +812,51 @@ namespace leaf_detail
 }
 
 template <class TryBlock, class... H>
-BOOST_LEAF_CONSTEXPR inline
+inline
 typename std::decay<decltype(std::declval<TryBlock>()().value())>::type
 try_handle_all( TryBlock && try_block, H && ... h )
 {
-    static_assert(is_result_type<decltype(std::declval<TryBlock>()())>::value, "The return type of the try_block passed to a try_handle_all function must be registered with leaf::is_result_type");
+    static_assert(is_result_type<decltype(std::declval<TryBlock>()())>::value, "The return type of the try_block passed to try_handle_all must be registered with leaf::is_result_type");
     context_type_from_handlers<H...> ctx;
     auto active_context = activate_context(ctx);
-    if( auto r = leaf_detail::try_catch_(
-            ctx,
-            [&]
-            {
-                return std::forward<TryBlock>(try_block)();
-            },
-            std::forward<H>(h)...) )
+    if( auto r = leaf_detail::try_catch_(ctx, std::forward<TryBlock>(try_block), std::forward<H>(h)...) )
         return std::move(r).value();
     else
     {
+        BOOST_LEAF_ASSERT(ctx.is_active());
+        leaf_detail::unload_result(&r);
         error_id id = r.error();
-        if( ctx.is_active() )
-            ctx.deactivate();
+        ctx.deactivate();
         using R = typename std::decay<decltype(std::declval<TryBlock>()().value())>::type;
         return ctx.template handle_error<R>(std::move(id), std::forward<H>(h)...);
     }
 }
 
 template <class TryBlock, class... H>
-BOOST_LEAF_NODISCARD BOOST_LEAF_CONSTEXPR inline
+BOOST_LEAF_NODISCARD inline
 typename std::decay<decltype(std::declval<TryBlock>()())>::type
 try_handle_some( TryBlock && try_block, H && ... h )
 {
-    static_assert(is_result_type<decltype(std::declval<TryBlock>()())>::value, "The return type of the try_block passed to a try_handle_some function must be registered with leaf::is_result_type");
+    static_assert(is_result_type<decltype(std::declval<TryBlock>()())>::value, "The return type of the try_block passed to try_handle_some must be registered with leaf::is_result_type");
     context_type_from_handlers<H...> ctx;
     auto active_context = activate_context(ctx);
-    if( auto r = leaf_detail::try_catch_(
-            ctx,
-            [&]
-            {
-                return std::forward<TryBlock>(try_block)();
-            },
-            std::forward<H>(h)...) )
+    if( auto r = leaf_detail::try_catch_(ctx, std::forward<TryBlock>(try_block), std::forward<H>(h)...) )
+        return r;
+    else if( !ctx.is_active() )
         return r;
     else
     {
+        leaf_detail::unload_result(&r);
         error_id id = r.error();
-        if( ctx.is_active() )
-            ctx.deactivate();
+        ctx.deactivate();
         using R = typename std::decay<decltype(std::declval<TryBlock>()())>::type;
-        auto rr = ctx.template handle_error<R>(id, std::forward<H>(h)..., [&r]()->R { return std::move(r); });
+        auto rr = ctx.template handle_error<R>(std::move(id), std::forward<H>(h)...,
+            [&r]()->R
+            {
+                return std::move(r);
+            });
         if( !rr )
-            ctx.propagate(rr.error());
+            ctx.unload(rr.error());
         return rr;
     }
 }
diff --git a/include/boost/leaf/result.hpp b/include/boost/leaf/result.hpp
index 6b08cf83..0d3c0325 100644
--- a/include/boost/leaf/result.hpp
+++ b/include/boost/leaf/result.hpp
@@ -8,6 +8,7 @@
 
 #include <boost/leaf/config.hpp>
 #include <boost/leaf/detail/print.hpp>
+#include <boost/leaf/detail/capture_list.hpp>
 #include <boost/leaf/exception.hpp>
 
 #include <climits>
@@ -15,6 +16,10 @@
 
 namespace boost { namespace leaf {
 
+namespace leaf_detail { class dynamic_allocator; }
+
+////////////////////////////////////////
+
 class bad_result:
     public std::exception,
     public error_id
@@ -117,37 +122,41 @@ namespace leaf_detail
 
     class result_discriminant
     {
-        unsigned state_;
+        int state_;
 
     public:
 
         enum kind_t
         {
-            no_error = 0,
+            err_id_zero = 0,
             err_id = 1,
-            ctx_ptr = 2,
+            err_id_capture_list = 2,
             val = 3
         };
 
         explicit result_discriminant( error_id id ) noexcept:
-            state_(unsigned(id.value()))
+            state_(id.value())
         {
-            BOOST_LEAF_ASSERT(state_==0 || (state_&3)==1);
+            BOOST_LEAF_ASSERT(state_ == 0 || (state_&3) == 1);
+            BOOST_LEAF_ASSERT(kind()==err_id_zero || kind()==err_id);
         }
 
-        struct kind_val { };
-        explicit result_discriminant( kind_val ) noexcept:
-            state_(val)
+#if BOOST_LEAF_CFG_CAPTURE
+        explicit result_discriminant( int err_id, leaf_detail::capture_list const & ) noexcept:
+            state_((err_id&~3) | 2)
         {
+            BOOST_LEAF_ASSERT((err_id&3) == 1);
+            BOOST_LEAF_ASSERT(kind() == err_id_capture_list);
         }
+#endif
 
-#if BOOST_LEAF_CFG_CAPTURE
-        struct kind_ctx_ptr { };
-        explicit result_discriminant( kind_ctx_ptr ) noexcept:
-            state_(ctx_ptr)
+        struct kind_val { };
+        explicit result_discriminant( kind_val ) noexcept:
+            state_(val)
         {
+            BOOST_LEAF_ASSERT((state_&3) == 3);
+            BOOST_LEAF_ASSERT(kind()==val);
         }
-#endif
 
         kind_t kind() const noexcept
         {
@@ -156,8 +165,8 @@ namespace leaf_detail
 
         error_id get_error_id() const noexcept
         {
-            BOOST_LEAF_ASSERT(kind()==no_error || kind()==err_id);
-            return make_error_id(int(state_));
+            BOOST_LEAF_ASSERT(kind()==err_id_zero || kind()==err_id || kind()==err_id_capture_list);
+            return make_error_id(int((state_&~3)|1));
         }
     };
 }
@@ -165,12 +174,35 @@ namespace leaf_detail
 ////////////////////////////////////////
 
 template <class T>
-class BOOST_LEAF_NODISCARD result
+class BOOST_LEAF_NODISCARD BOOST_LEAF_SYMBOL_VISIBLE result
 {
     template <class U>
     friend class result;
 
+    friend class leaf_detail::dynamic_allocator;
+
+#if BOOST_LEAF_CFG_CAPTURE
+    using capture_list = leaf_detail::capture_list;
+#endif
+
     using result_discriminant = leaf_detail::result_discriminant;
+    using stored_type = typename leaf_detail::stored<T>::type;
+    using value_no_ref = typename leaf_detail::stored<T>::value_no_ref;
+    using value_no_ref_const = typename leaf_detail::stored<T>::value_no_ref_const;
+    using value_ref = typename leaf_detail::stored<T>::value_ref;
+    using value_cref = typename leaf_detail::stored<T>::value_cref;
+    using value_rv_ref = typename leaf_detail::stored<T>::value_rv_ref;
+    using value_rv_cref = typename leaf_detail::stored<T>::value_rv_cref;
+
+    union
+    {
+        stored_type stored_;
+#if BOOST_LEAF_CFG_CAPTURE
+        mutable capture_list cap_;
+#endif
+    };
+
+    result_discriminant what_;
 
     struct error_result
     {
@@ -188,78 +220,46 @@ class BOOST_LEAF_NODISCARD result
         template <class U>
         operator result<U>() noexcept
         {
-            switch(r_.what_.kind())
+            result_discriminant const what = r_.what_;
+            switch( what.kind() )
             {
-            case result_discriminant::val:
-                return result<U>(error_id());
-            case result_discriminant::ctx_ptr:
+                case result_discriminant::val:
+                    return result<U>(error_id());
+                case result_discriminant::err_id_capture_list:
 #if BOOST_LEAF_CFG_CAPTURE
-                return result<U>(std::move(r_.ctx_));
+                    return result<U>(what.get_error_id().value(), std::move(r_.cap_));
 #else
-                BOOST_LEAF_ASSERT(0); // Possible ODR violation.
+                    BOOST_LEAF_ASSERT(0); // Possible ODR violation.
 #endif
-            default:
-                return result<U>(std::move(r_.what_));
+                case result_discriminant::err_id_zero:
+                case result_discriminant::err_id:
+                    return result<U>(what.get_error_id());
             }
         }
 
         operator error_id() noexcept
         {
-            switch(r_.what_.kind())
-            {
-            case result_discriminant::val:
-                return error_id();
-            case result_discriminant::ctx_ptr:
-#if BOOST_LEAF_CFG_CAPTURE
-                {
-                    error_id captured_id = r_.ctx_->captured_id_;
-                    r_.ctx_->propagate(captured_id);
-                    tls::write_uint<leaf_detail::tls_tag_id_factory_current_id>(unsigned(captured_id.value()));
-                    return captured_id;
-                }
-#else
-                BOOST_LEAF_ASSERT(0); // Possible ODR violation.
-#endif
-            default:
-                return r_.what_.get_error_id();
-            }
+            result_discriminant const what = r_.what_;
+            return what.kind() == result_discriminant::val? error_id() : what.get_error_id();
         }
     };
 
-    using stored_type = typename leaf_detail::stored<T>::type;
-    using value_no_ref = typename leaf_detail::stored<T>::value_no_ref;
-    using value_no_ref_const = typename leaf_detail::stored<T>::value_no_ref_const;
-    using value_ref = typename leaf_detail::stored<T>::value_ref;
-    using value_cref = typename leaf_detail::stored<T>::value_cref;
-    using value_rv_ref = typename leaf_detail::stored<T>::value_rv_ref;
-    using value_rv_cref = typename leaf_detail::stored<T>::value_rv_cref;
-
-    union
-    {
-        stored_type stored_;
-#if BOOST_LEAF_CFG_CAPTURE
-        context_ptr ctx_;
-#endif
-    };
-
-    result_discriminant what_;
-
     void destroy() const noexcept
     {
         switch(this->what_.kind())
         {
-        case result_discriminant::val:
-            stored_.~stored_type();
+        case result_discriminant::err_id_zero:
+        case result_discriminant::err_id:
             break;
-        case result_discriminant::ctx_ptr:
+        case result_discriminant::err_id_capture_list:
 #if BOOST_LEAF_CFG_CAPTURE
-            BOOST_LEAF_ASSERT(!ctx_ || ctx_->captured_id_);
-            ctx_.~context_ptr();
+            cap_.~capture_list();
 #else
             BOOST_LEAF_ASSERT(0); // Possible ODR violation.
 #endif
-        default:
             break;
+        case result_discriminant::val:
+            stored_.~stored_type();
         }
     }
 
@@ -269,46 +269,26 @@ class BOOST_LEAF_NODISCARD result
         auto x_what = x.what_;
         switch(x_what.kind())
         {
-        case result_discriminant::val:
-            (void) new(&stored_) stored_type(std::move(x.stored_));
+        case result_discriminant::err_id_zero:
+        case result_discriminant::err_id:
             break;
-        case result_discriminant::ctx_ptr:
+        case result_discriminant::err_id_capture_list:
 #if BOOST_LEAF_CFG_CAPTURE
-            BOOST_LEAF_ASSERT(!x.ctx_ || x.ctx_->captured_id_);
-            (void) new(&ctx_) context_ptr(std::move(x.ctx_));
+            (void) new(&cap_) capture_list(std::move(x.cap_));
 #else
             BOOST_LEAF_ASSERT(0); // Possible ODR violation.
 #endif
-        default:
             break;
+        case result_discriminant::val:
+            (void) new(&stored_) stored_type(std::move(x.stored_));
         }
         return x_what;
     }
 
-    result( result_discriminant && what ) noexcept:
-        what_(std::move(what))
-    {
-        BOOST_LEAF_ASSERT(what_.kind()==result_discriminant::err_id || what_.kind()==result_discriminant::no_error);
-    }
-
     error_id get_error_id() const noexcept
     {
         BOOST_LEAF_ASSERT(what_.kind() != result_discriminant::val);
-#if BOOST_LEAF_CFG_CAPTURE
-        if( what_.kind() == result_discriminant::ctx_ptr )
-        {
-            BOOST_LEAF_ASSERT(ctx_ && ctx_->captured_id_);
-            return ctx_->captured_id_;
-        }
-        else
-        {
-            BOOST_LEAF_ASSERT(what_.kind() == result_discriminant::err_id);
-            return what_.get_error_id();
-        }
-#else
-        BOOST_LEAF_ASSERT(what_.kind() != result_discriminant::ctx_ptr); // Possible ODR violation.
         return what_.get_error_id();
-#endif
     }
 
     stored_type const * get() const noexcept
@@ -323,10 +303,30 @@ class BOOST_LEAF_NODISCARD result
 
 protected:
 
+#if BOOST_LEAF_CFG_CAPTURE
+    result( int err_id, leaf_detail::capture_list && cap ) noexcept:
+        cap_(std::move(cap)),
+        what_(err_id, cap)
+    {
+    }
+#endif
+
     void enforce_value_state() const
     {
-        if( !has_value() )
+        switch( what_.kind() )
+        {
+        case result_discriminant::err_id_capture_list:
+#if BOOST_LEAF_CFG_CAPTURE
+            cap_.unload(what_.get_error_id().value());
+#else
+            BOOST_LEAF_ASSERT(0); // Possible ODR violation.
+#endif
+        case result_discriminant::err_id_zero:
+        case result_discriminant::err_id:
             ::boost::leaf::leaf_detail::throw_exception_impl(bad_result(get_error_id()));
+        case result_discriminant::val:
+            break;
+        }
     }
 
 public:
@@ -411,22 +411,6 @@ class BOOST_LEAF_NODISCARD result
     }
 #endif
 
-#if BOOST_LEAF_CFG_CAPTURE
-    result( context_ptr const & ctx ) noexcept:
-        ctx_(ctx),
-        what_(result_discriminant::kind_ctx_ptr{})
-    {
-        BOOST_LEAF_ASSERT(ctx_ && ctx_->captured_id_);
-    }
-
-    result( context_ptr && ctx ) noexcept:
-        ctx_(std::move(ctx)),
-        what_(result_discriminant::kind_ctx_ptr{})
-    {
-        BOOST_LEAF_ASSERT(ctx_ && ctx_->captured_id_);
-    }
-#endif
-
     ~result() noexcept
     {
         destroy();
@@ -573,28 +557,36 @@ class BOOST_LEAF_NODISCARD result
         return error_id(error()).load(std::forward<Item>(item)...);
     }
 
+    void unload() noexcept
+    {
+#if BOOST_LEAF_CFG_CAPTURE
+        if( what_.kind() == result_discriminant::err_id_capture_list )
+        {
+            int err_id = what_.get_error_id().value();
+            cap_.unload( err_id );
+        }
+#endif
+    }
+
     template <class CharT, class Traits>
     void print( std::basic_ostream<CharT, Traits> & os ) const
     {
-        switch(what_.kind())
-        {
-        case result_discriminant::val:
+        result_discriminant const what = what_;
+        if( what.kind() == result_discriminant::val )
             leaf_detail::print_result_value(os, value());
-            break;
-        case result_discriminant::ctx_ptr:
-#if BOOST_LEAF_CFG_CAPTURE
-            BOOST_LEAF_ASSERT(ctx_ && ctx_->captured_id_);
-            os << "Error ID " << ctx_->captured_id_ << ", captured error objects:\n" << *ctx_;
-            break;
+        else
+        {
+            error_id const err_id = what.get_error_id();
+            os << "Error ID " << err_id;
+            if( what.kind() == result_discriminant::err_id_capture_list )
+#if BOOST_LEAF_CFG_CAPTURE && BOOST_LEAF_CFG_DIAGNOSTICS
+                cap_.print(os, ". Captured error objects:\n", err_id.value());
 #else
-            BOOST_LEAF_ASSERT(0); // Possible ODR violation.
+                BOOST_LEAF_ASSERT(0); // Possible ODR violation.
 #endif
-        default:
-            os << "Error ID " << what_.get_error_id();
         }
     }
 
-
     template <class CharT, class Traits>
     friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, result const & r )
     {
@@ -611,20 +603,24 @@ namespace leaf_detail
 }
 
 template <>
-class BOOST_LEAF_NODISCARD result<void>:
+class BOOST_LEAF_NODISCARD BOOST_LEAF_SYMBOL_VISIBLE result<void>:
     result<leaf_detail::void_>
 {
+    template <class U>
+    friend class result;
+
+    friend class leaf_detail::dynamic_allocator;
+
     using result_discriminant = leaf_detail::result_discriminant;
     using void_ = leaf_detail::void_;
     using base = result<void_>;
 
-    template <class U>
-    friend class result;
-
-    result( result_discriminant && what ) noexcept:
-        base(std::move(what))
+#if BOOST_LEAF_CFG_CAPTURE
+    result( int err_id, leaf_detail::capture_list && cap ) noexcept:
+        base(err_id, std::move(cap))
     {
     }
+#endif
 
 public:
 
@@ -657,18 +653,6 @@ class BOOST_LEAF_NODISCARD result<void>:
     }
 #endif
 
-#if BOOST_LEAF_CFG_CAPTURE
-    result( context_ptr const & ctx ) noexcept:
-        base(ctx)
-    {
-    }
-
-    result( context_ptr && ctx ) noexcept:
-        base(std::move(ctx))
-    {
-    }
-#endif
-
     ~result() noexcept
     {
     }
@@ -714,6 +698,7 @@ class BOOST_LEAF_NODISCARD result<void>:
     using base::get_error_id;
     using base::error;
     using base::load;
+    using base::unload;
 };
 
 ////////////////////////////////////////
diff --git a/meson.build b/meson.build
index 96416ed1..0078bcad 100644
--- a/meson.build
+++ b/meson.build
@@ -139,6 +139,7 @@ if option_enable_unit_tests
         'diagnostic_info_test3',
         'diagnostic_info_test4',
         'diagnostic_info_test5',
+        'dynamic_capture_print_test',
         'e_errno_test',
         'e_LastError_test',
         'error_code_test',
@@ -199,7 +200,6 @@ if option_enable_unit_tests
     endforeach
 
     header_tests = [
-        '_hpp_capture_test',
         '_hpp_common_test',
         '_hpp_config_test',
         '_hpp_context_test',
@@ -247,14 +247,14 @@ endif
 if option_enable_examples
 
     examples = [
-        'capture_in_result',
+        'dynamic_capture_result',
         'error_log',
         'error_trace',
         'print_half'
     ]
     if option_exceptions
         examples += [
-            'capture_in_exception',
+            'dynamic_capture_eh',
             'exception_to_result'
         ]
         if option_lua
@@ -264,7 +264,7 @@ if option_enable_examples
         endif
         if option_boost
             examples += [
-    #           'asio_beast_leaf_rpc' #FIXME
+               'asio_beast_leaf_rpc'
             ]
         endif
     endif
diff --git a/test/capture_exception_async_test.cpp b/test/capture_exception_async_test.cpp
index 0e720721..da5c5187 100644
--- a/test/capture_exception_async_test.cpp
+++ b/test/capture_exception_async_test.cpp
@@ -20,7 +20,7 @@ int main()
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
 #else
-#   include <boost/leaf/capture.hpp>
+#   include <boost/leaf/result.hpp>
 #   include <boost/leaf/handle_errors.hpp>
 #   include <boost/leaf/exception.hpp>
 #   include <boost/leaf/on_error.hpp>
@@ -41,10 +41,10 @@ struct fut_info
     int a;
     int b;
     int result;
-    std::future<int> fut;
+    std::future<leaf::result<int>> fut;
 };
 
-template <class H, class F>
+template <class F>
 std::vector<fut_info> launch_tasks( int task_count, F f )
 {
     BOOST_LEAF_ASSERT(task_count>0);
@@ -58,7 +58,15 @@ std::vector<fut_info> launch_tasks( int task_count, F f )
             return fut_info { a, b, res, std::async( std::launch::async,
                 [=]
                 {
-                    return leaf::capture(leaf::make_shared_context<H>(), f, a, b, res);
+                    return leaf::try_handle_some(
+                        [&]() -> leaf::result<int>
+                        {
+                            return f(a, b, res);
+                        },
+                        []( leaf::dynamic_capture const & cap ) -> leaf::result<int>
+                        {
+                            return cap;
+                        } );
                 } ) };
         } );
     return fut;
@@ -66,9 +74,10 @@ std::vector<fut_info> launch_tasks( int task_count, F f )
 
 int main()
 {
+    int const task_count = 1;
     int received_a, received_b;
     auto error_handlers = std::make_tuple(
-        [&received_a, &received_b]( info<1> const & x1, info<2> const & x2, info<4> const & )
+        [&]( info<1> const & x1, info<2> const & x2, info<4> const & )
         {
             received_a = x1.value;
             received_b = x2.value;
@@ -80,8 +89,8 @@ int main()
         } );
 
     {
-        std::vector<fut_info> fut = launch_tasks<decltype(error_handlers)>(
-            100,
+        std::vector<fut_info> fut = launch_tasks(
+            task_count,
             []( int a, int b, int res )
             {
                 if( res >= 0 )
@@ -98,9 +107,7 @@ int main()
                 [&]
                 {
                     auto load = leaf::on_error( info<4>{} );
-
-                    // Calling future_get is required in order to make the on_error (above) work.
-                    return leaf::future_get(f.fut);
+                    return f.fut.get().value();
                 },
                 error_handlers );
             if( f.result>=0 )
@@ -115,8 +122,8 @@ int main()
     }
 
     {
-        std::vector<fut_info> fut = launch_tasks<decltype(error_handlers)>(
-            100,
+        std::vector<fut_info> fut = launch_tasks(
+            task_count,
             []( int a, int b, int res )
             {
                 if( res >= 0 )
@@ -137,9 +144,7 @@ int main()
                     return leaf::try_catch(
                         [&]
                         {
-                            // Not calling future_get, a on_error in this scope won't work correctly.
-                            // This is to verify that the on_error in the outer scope (above) works.
-                            return f.fut.get();
+                            return f.fut.get().value();
                         },
                         []() -> int
                         {
diff --git a/test/capture_exception_result_async_test.cpp b/test/capture_exception_result_async_test.cpp
index 9471ea6c..d37c8743 100644
--- a/test/capture_exception_result_async_test.cpp
+++ b/test/capture_exception_result_async_test.cpp
@@ -20,9 +20,9 @@ int main()
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
 #else
-#   include <boost/leaf/capture.hpp>
 #   include <boost/leaf/result.hpp>
 #   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/on_error.hpp>
 #endif
 
 #include "lightweight_test.hpp"
@@ -43,7 +43,7 @@ struct fut_info
     std::future<leaf::result<int>> fut;
 };
 
-template <class H, class F>
+template <class F>
 std::vector<fut_info> launch_tasks( int task_count, F f )
 {
     BOOST_LEAF_ASSERT(task_count>0);
@@ -57,7 +57,15 @@ std::vector<fut_info> launch_tasks( int task_count, F f )
             return fut_info { a, b, res, std::async( std::launch::async,
                 [=]
                 {
-                    return leaf::capture(leaf::make_shared_context<H>(), f, a, b, res);
+                    return leaf::try_handle_some(
+                        [&]() -> leaf::result<int>
+                        {
+                            return f(a, b, res);
+                        },
+                        []( leaf::dynamic_capture const & cap ) -> leaf::result<int>
+                        {
+                            return cap;
+                        } );
                 } ) };
         } );
     return fut;
@@ -65,6 +73,7 @@ std::vector<fut_info> launch_tasks( int task_count, F f )
 
 int main()
 {
+    int const task_count = 1;
     int received_a, received_b;
     auto error_handlers = std::make_tuple(
         [&]( info<1> const & x1, info<2> const & x2, info<4> const & )
@@ -79,8 +88,8 @@ int main()
         } );
 
     {
-        std::vector<fut_info> fut = launch_tasks<decltype(error_handlers)>(
-            100,
+        std::vector<fut_info> fut = launch_tasks(
+            task_count,
             []( int a, int b, int res ) -> leaf::result<int>
             {
                 if( res >= 0 )
@@ -94,12 +103,10 @@ int main()
             f.fut.wait();
             received_a = received_b = 0;
             int r = leaf::try_handle_all(
-                [&]
+                [&]() -> leaf::result<int>
                 {
                     auto load = leaf::on_error( info<4>{} );
-
-                    // Calling future_get is required in order to make the on_error (above) work.
-                    return leaf::future_get(f.fut);
+                    return f.fut.get().value();
                 },
                 error_handlers );
             if( f.result>=0 )
@@ -114,8 +121,8 @@ int main()
     }
 
     {
-        std::vector<fut_info> fut = launch_tasks<decltype(error_handlers)>(
-            100,
+        std::vector<fut_info> fut = launch_tasks(
+            task_count,
             []( int a, int b, int res ) -> leaf::result<int>
             {
                 if( res >= 0 )
@@ -129,16 +136,14 @@ int main()
             f.fut.wait();
             received_a = received_b = 0;
             int r = leaf::try_handle_all(
-                [&]
+                [&]() -> leaf::result<int>
                 {
                     auto load = leaf::on_error( info<4>{} );
 
                     return leaf::try_handle_some(
-                        [&]
+                        [&]() -> leaf::result<int>
                         {
-                            // Not calling future_get, a on_error in this scope won't work correctly.
-                            // This is to verify that the on_error in the outer scope (above) works.
-                            return f.fut.get();
+                            return f.fut.get().value();
                         },
                         []( leaf::error_info const & err )
                         {
diff --git a/test/capture_exception_state_test.cpp b/test/capture_exception_state_test.cpp
index 78edfcb6..4f94f2ab 100644
--- a/test/capture_exception_state_test.cpp
+++ b/test/capture_exception_state_test.cpp
@@ -20,8 +20,8 @@ int main()
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
 #else
-#   include <boost/leaf/capture.hpp>
 #   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/result.hpp>
 #   include <boost/leaf/exception.hpp>
 #endif
 
@@ -63,38 +63,23 @@ struct info
 
 int main()
 {
-    auto error_handlers = std::make_tuple(
-        []( info<1>, info<3> )
+    leaf::result<int> r = leaf::try_handle_some(
+        []() -> leaf::result<int>
         {
-            return 1;
+            leaf::throw_exception(info<1>{}, info<3>{});
         },
-        []
+        [](leaf::dynamic_capture const & cap) -> leaf::result<int>
         {
-            return 2;
+            BOOST_TEST(!cap.empty());
+            BOOST_TEST_EQ(cap.size(), 2);
+            return cap;
         } );
-    BOOST_TEST_EQ(count, 0);
-    std::exception_ptr ep;
-    leaf::context_ptr ctx = leaf::make_shared_context(error_handlers);
-    try
-    {
-        leaf::capture(
-            ctx,
-            []
-            {
-                leaf::throw_exception(info<1>{}, info<3>{});
-            } );
-        BOOST_TEST(false);
-    }
-    catch(...)
-    {
-        ep = std::current_exception();
-    }
     BOOST_TEST_EQ(count, 2);
 
 #if BOOST_LEAF_CFG_STD_STRING
     {
         std::ostringstream st;
-        st << *ctx;
+        st << r;
         std::string s = st.str();
         std::cout << s << std::endl;
 #if BOOST_LEAF_CFG_DIAGNOSTICS
@@ -104,14 +89,21 @@ int main()
     }
 #endif
 
-    int r = leaf::try_catch(
+    int ret = leaf::try_catch(
         [&]() -> int
         {
-            std::rethrow_exception(ep);
+            return r.value();
         },
-        error_handlers );
-    BOOST_TEST_EQ(r, 1);
-    ep = std::exception_ptr();
+        []( info<1>, info<3> )
+        {
+            return 1;
+        },
+        []
+        {
+            return 2;
+        } );
+    BOOST_TEST_EQ(ret, 1);
+    r = 0;
     BOOST_TEST_EQ(count, 0);
 
     return boost::report_errors();
diff --git a/test/capture_exception_unload_test.cpp b/test/capture_exception_unload_test.cpp
index 31a66e3e..8fff8dba 100644
--- a/test/capture_exception_unload_test.cpp
+++ b/test/capture_exception_unload_test.cpp
@@ -20,9 +20,9 @@ int main()
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
 #else
-#   include <boost/leaf/capture.hpp>
 #   include <boost/leaf/handle_errors.hpp>
 #   include <boost/leaf/exception.hpp>
+#   include <boost/leaf/result.hpp>
 #   include <boost/leaf/on_error.hpp>
 #endif
 
@@ -38,25 +38,26 @@ void test( F f_ )
     auto f =
         [=]
         {
-            try
-            {
-                leaf::capture( std::make_shared<leaf::leaf_detail::polymorphic_context_impl<leaf::context<info<1>, info<2>, info<3>>>>(), f_);
-                BOOST_TEST(false);
-                return std::exception_ptr();
-            }
-            catch(...)
-            {
-                return std::current_exception();
-            }
+            return leaf::try_handle_some(
+                [&]() -> leaf::result<void>
+                {
+                    f_();
+                    BOOST_TEST(false);
+                    return { };
+                },
+                []( leaf::dynamic_capture const & cap ) -> leaf::result<void>
+                {
+                    return cap;
+                });
         };
 
     {
         int c=0;
-        auto ep = f();
+        leaf::result<void> r = f();
         leaf::try_catch(
-            [&ep]
+            [&r]
             {
-                return std::rethrow_exception(ep);
+                return r.value();
             },
             [&c]( info<1> const & x )
             {
@@ -74,11 +75,11 @@ void test( F f_ )
 
     {
         int c=0;
-        auto ep = f();
+        leaf::result<void> r = f();
         leaf::try_catch(
-            [&ep]
+            [&r]
             {
-                return std::rethrow_exception(ep);
+                return r.value();
             },
             [&c]( info<2> const & x )
             {
@@ -95,11 +96,12 @@ void test( F f_ )
     }
 
     {
-        auto ep = f();
+        leaf::result<void> r = f();
         int what = leaf::try_catch(
-            [&ep]
+            [&r]
             {
-                std::rethrow_exception(ep); return 0;
+                (void) r.value();
+                return 0;
             },
             []( info<1> const & x )
             {
@@ -114,11 +116,12 @@ void test( F f_ )
     }
 
     {
-        auto ep = f();
+        leaf::result<void> r = f();
         int what = leaf::try_catch(
-            [&ep]
+            [&r]
             {
-                std::rethrow_exception(ep); return 0;
+                (void) r.value();
+                return 0;
             },
             []( info<2> const & x )
             {
@@ -133,11 +136,12 @@ void test( F f_ )
     }
 
     {
-        auto ep = f();
+        leaf::result<void> r = f();
         bool what = leaf::try_catch(
-            [&ep]
+            [&r]
             {
-                std::rethrow_exception(ep); return true;
+                (void) r.value();
+                return true;
             },
             []( info<1> const &, info<2> const & )
             {
@@ -161,11 +165,12 @@ void test( F f_ )
     }
 
     {
-        auto ep = f();
+        leaf::result<void> r = f();
         bool what = leaf::try_catch(
-            [&ep]
+            [&r]
             {
-                std::rethrow_exception(ep); return false;
+                (void) r.value();
+                return false;
             },
             []( info<1> const &, info<2> const & )
             {
diff --git a/test/capture_result_async_test.cpp b/test/capture_result_async_test.cpp
index 3b6dfba0..e4df2d81 100644
--- a/test/capture_result_async_test.cpp
+++ b/test/capture_result_async_test.cpp
@@ -20,7 +20,6 @@ int main()
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
 #else
-#   include <boost/leaf/capture.hpp>
 #   include <boost/leaf/result.hpp>
 #   include <boost/leaf/handle_errors.hpp>
 #   include <boost/leaf/on_error.hpp>
@@ -44,7 +43,7 @@ struct fut_info
     std::future<leaf::result<int>> fut;
 };
 
-template <class ErrorHandlers, class F>
+template <class F>
 std::vector<fut_info> launch_tasks( int task_count, F f )
 {
     BOOST_LEAF_ASSERT(task_count>0);
@@ -58,7 +57,15 @@ std::vector<fut_info> launch_tasks( int task_count, F f )
             return fut_info { a, b, res, std::async( std::launch::async,
                 [=]
                 {
-                    return leaf::capture(leaf::make_shared_context<ErrorHandlers>(), f, a, b, res);
+                    return leaf::try_handle_some(
+                        [&]() -> leaf::result<int>
+                        {
+                            return f(a, b, res);
+                        },
+                        []( leaf::dynamic_capture const & cap ) -> leaf::result<int>
+                        {
+                            return cap;
+                        } );
                 } ) };
         } );
     return fut;
@@ -66,6 +73,7 @@ std::vector<fut_info> launch_tasks( int task_count, F f )
 
 int main()
 {
+    int const task_count = 100;
     int received_a, received_b;
     auto error_handlers = std::make_tuple(
         [&received_a, &received_b]( info<1> const & x1, info<2> const & x2, info<4> const & )
@@ -80,8 +88,8 @@ int main()
         } );
 
     {
-        std::vector<fut_info> fut = launch_tasks<decltype(error_handlers)>(
-            100,
+        std::vector<fut_info> fut = launch_tasks(
+            task_count,
             []( int a, int b, int res ) -> leaf::result<int>
             {
                 if( res >= 0 )
@@ -97,9 +105,9 @@ int main()
                 [&]
                 {
                     auto load = leaf::on_error( info<4>{} );
-
-                    // Calling future_get is required in order to make the on_error (above) work.
-                    return leaf::future_get(f.fut);
+                    auto fr = f.fut.get();
+                    fr.unload(); // Necessary for the on_error (above) to work
+                    return fr;
                 },
                 error_handlers );
             if( f.result>=0 )
@@ -114,8 +122,8 @@ int main()
     }
 
     {
-        std::vector<fut_info> fut = launch_tasks<decltype(error_handlers)>(
-            100,
+        std::vector<fut_info> fut = launch_tasks(
+            task_count,
             []( int a, int b, int res ) -> leaf::result<int>
             {
                 if( res >= 0 )
diff --git a/test/capture_result_state_test.cpp b/test/capture_result_state_test.cpp
index 6b6e054e..a6743c18 100644
--- a/test/capture_result_state_test.cpp
+++ b/test/capture_result_state_test.cpp
@@ -20,7 +20,6 @@ int main()
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
 #else
-#   include <boost/leaf/capture.hpp>
 #   include <boost/leaf/result.hpp>
 #   include <boost/leaf/handle_errors.hpp>
 #endif
@@ -63,30 +62,22 @@ struct info
 
 int main()
 {
-    auto error_handlers = std::make_tuple(
-        []( info<1>, info<3> )
-        {
-            return 42;
-        },
-        []
-        {
-            return -42;
-        } );
-
     {
-        leaf::context_ptr ctx = leaf::make_shared_context(error_handlers);
-        auto r = leaf::capture(
-            ctx,
+        leaf::result<int> r = leaf::try_handle_some(
             []() -> leaf::result<int>
             {
                 return leaf::new_error( info<1>{}, info<3>{} );
+            },
+            []( leaf::dynamic_capture const & cap ) -> leaf::result<int>
+            {
+                return cap;
             } );
         BOOST_TEST_EQ(count, 2);
 
 #if BOOST_LEAF_CFG_STD_STRING
         {
             std::ostringstream st;
-            st << *ctx;
+            st << r;
             std::string s = st.str();
             std::cout << s << std::endl;
 #if BOOST_LEAF_CFG_DIAGNOSTICS
@@ -101,7 +92,14 @@ int main()
             {
                 return std::move(r);
             },
-            error_handlers);
+            []( info<1>, info<3> )
+            {
+                return 42;
+            },
+            []
+            {
+                return -42;
+            } );
         BOOST_TEST_EQ(answer, 42);
     }
     BOOST_TEST_EQ(count, 0);
diff --git a/test/capture_result_unload_test.cpp b/test/capture_result_unload_test.cpp
index 6c256561..b9c1b99a 100644
--- a/test/capture_result_unload_test.cpp
+++ b/test/capture_result_unload_test.cpp
@@ -20,7 +20,6 @@ int main()
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
 #else
-#   include <boost/leaf/capture.hpp>
 #   include <boost/leaf/result.hpp>
 #   include <boost/leaf/handle_errors.hpp>
 #endif
@@ -126,21 +125,27 @@ int main()
 {
     test( []
     {
-        return leaf::capture(
-            std::make_shared<leaf::leaf_detail::polymorphic_context_impl<leaf::context<info<1>, info<2>, info<3>>>>(),
+        return leaf::try_handle_some(
             []() -> leaf::result<int>
             {
                 return leaf::new_error(errc_a::a0, info<1>{1}, info<3>{3});
+            },
+            []( leaf::dynamic_capture const & cap ) -> leaf::result<int>
+            {
+                return cap;
             } );
      } );
 
     test( []
     {
-        return leaf::capture(
-            std::make_shared<leaf::leaf_detail::polymorphic_context_impl<leaf::context<info<1>, info<2>, info<3>>>>(),
+        return leaf::try_handle_some(
             []() -> leaf::result<void>
             {
                 return leaf::new_error(errc_a::a0, info<1>{1}, info<3>{3});
+            },
+            []( leaf::dynamic_capture const & cap ) -> leaf::result<void>
+            {
+                return cap;
             } );
      } );
 
diff --git a/test/context_activator_test.cpp b/test/context_activator_test.cpp
index 22a364ea..64ccba4a 100644
--- a/test/context_activator_test.cpp
+++ b/test/context_activator_test.cpp
@@ -50,7 +50,7 @@ int main()
                 auto active_context = activate_context(ctx);
                 r1 = f(ctx);
             }
-            ctx.propagate(r1.error());
+            ctx.unload(r1.error());
             return r1;
         },
         error_handlers );
diff --git a/test/context_deduction_test.cpp b/test/context_deduction_test.cpp
index e7f1234d..d7cf26e2 100644
--- a/test/context_deduction_test.cpp
+++ b/test/context_deduction_test.cpp
@@ -137,14 +137,11 @@ void not_called_on_purpose()
     test< std::tuple<info<1>,info<2>,info<3>> >( expd([]( info<1> const *, info<2> ){ }, []( info<1>, info<3> const * ){ }) );
     test< std::tuple<info<1>,info<2>,info<3>> >( expd([]( info<1> const, info<2> ){ }, []( info<1> const *, info<3> ){ }) );
 
+    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, info<2>, leaf::diagnostic_info const & ){ }, []( info<1>, info<2> ){ }) );
 #if BOOST_LEAF_CFG_DIAGNOSTICS
-    test< std::tuple<info<1>,info<2>,leaf::leaf_detail::e_unexpected_count> >( expd([]( info<1>, info<2>, leaf::diagnostic_info const & ){ }, []( info<1>, info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>,leaf::leaf_detail::e_unexpected_info> >( expd([]( info<1>, info<2> ){ }, []( info<1>, leaf::verbose_diagnostic_info const &, info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>,leaf::leaf_detail::e_unexpected_count,leaf::leaf_detail::e_unexpected_info> >( expd([]( info<1>, info<2>, leaf::diagnostic_info const & ){ }, []( info<1>, leaf::verbose_diagnostic_info const &, info<2> ){ }) );
+    test< std::tuple<info<1>,info<2>,leaf::leaf_detail::dynamic_allocator> >( expd([]( info<1>, info<2>, leaf::verbose_diagnostic_info const & ){ }, []( info<1>, info<2> ){ }) );
 #else
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, info<2>, leaf::diagnostic_info const & ){ }, []( info<1>, info<2> ){ }) );
     test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, info<2> ){ }, []( info<1>, leaf::verbose_diagnostic_info const &, info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, info<2>, leaf::diagnostic_info const & ){ }, []( info<1>, leaf::verbose_diagnostic_info const &, info<2> ){ }) );
 #endif
 
     {
diff --git a/test/defer_basic_test.cpp b/test/defer_basic_test.cpp
index 1cb616fd..ff15d8c5 100644
--- a/test/defer_basic_test.cpp
+++ b/test/defer_basic_test.cpp
@@ -62,9 +62,7 @@ int main()
             std::string s = ss.str();
             std::cout << s << std::endl;
 #if BOOST_LEAF_CFG_DIAGNOSTICS
-            BOOST_TEST(s.find("info<-42>")!=s.npos);
-#else
-            BOOST_TEST(s.find("BOOST_LEAF_CFG_DIAGNOSTICS")!=s.npos);
+            BOOST_TEST(s.find("info<42>")!=s.npos);
 #endif
 #endif
             return 1;
diff --git a/test/diagnostic_info_test1.cpp b/test/diagnostic_info_test1.cpp
index a2f8c06b..e8152c9b 100644
--- a/test/diagnostic_info_test1.cpp
+++ b/test/diagnostic_info_test1.cpp
@@ -93,8 +93,6 @@ int main()
                 printable_info_non_printable_payload(),
                 non_printable_info_printable_payload(),
                 non_printable_info_non_printable_payload(),
-                unexpected_test<1>{1},
-                unexpected_test<2>{2},
                 enum_class_payload{},
                 leaf::e_errno{ENOENT} );
         },
@@ -133,8 +131,6 @@ int main()
                 printable_info_non_printable_payload(),
                 non_printable_info_printable_payload(),
                 non_printable_info_non_printable_payload(),
-                unexpected_test<1>{1},
-                unexpected_test<2>{2},
                 enum_class_payload{},
                 leaf::e_errno{ENOENT} );
         },
@@ -161,9 +157,6 @@ int main()
             BOOST_TEST_NE(s.find(": printed printable_payload"), s.npos);
             BOOST_TEST_NE(s.find(": {not printable}"), s.npos);
             BOOST_TEST_NE(s.find("enum_class_payload"), s.npos);
-            BOOST_TEST_NE(s.find("Detected 2 attempts"), s.npos);
-            BOOST_TEST_NE(s.find("unexpected_test<1>"), s.npos);
-            BOOST_TEST_EQ(s.find("unexpected_test<2>"), s.npos);
 #else
             BOOST_TEST_NE(s.find("leaf::diagnostic_info requires #define BOOST_LEAF_CFG_DIAGNOSTICS 1"), s.npos);
             BOOST_TEST_NE(s.find("leaf::error_info: Error ID = "), s.npos);
@@ -243,8 +236,6 @@ int main()
                 printable_info_non_printable_payload(),
                 non_printable_info_printable_payload(),
                 non_printable_info_non_printable_payload(),
-                unexpected_test<1>{1},
-                unexpected_test<2>{2},
                 enum_class_payload{},
                 leaf::e_errno{ENOENT} );
         },
@@ -282,8 +273,6 @@ int main()
                 non_printable_info_printable_payload(),
                 non_printable_info_non_printable_payload(),
                 enum_class_payload{},
-                unexpected_test<1>{1},
-                unexpected_test<2>{2},
                 leaf::e_errno{ENOENT} );
         },
         [](
@@ -311,9 +300,6 @@ int main()
             BOOST_TEST_NE(s.find(": printed printable_payload"), s.npos);
             BOOST_TEST_NE(s.find(": {not printable}"), s.npos);
             BOOST_TEST_NE(s.find("enum_class_payload"), s.npos);
-            BOOST_TEST_NE(s.find("Detected 2 attempts"), s.npos);
-            BOOST_TEST_NE(s.find("unexpected_test<1>"), s.npos);
-            BOOST_TEST_EQ(s.find("unexpected_test<2>"), s.npos);
 #else
             BOOST_TEST_NE(s.find("leaf::diagnostic_info requires #define BOOST_LEAF_CFG_DIAGNOSTICS 1"), s.npos);
             BOOST_TEST_NE(s.find("leaf::error_info: Error ID = "), s.npos);
diff --git a/test/diagnostic_info_test2.cpp b/test/diagnostic_info_test2.cpp
index 0aab481a..3e8bdd14 100644
--- a/test/diagnostic_info_test2.cpp
+++ b/test/diagnostic_info_test2.cpp
@@ -8,6 +8,7 @@
 #else
 #   include <boost/leaf/config.hpp>
 #   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/on_error.hpp>
 #   include <boost/leaf/result.hpp>
 #endif
 
diff --git a/test/diagnostic_info_test3.cpp b/test/diagnostic_info_test3.cpp
index 686c0360..0b3cdc9d 100644
--- a/test/diagnostic_info_test3.cpp
+++ b/test/diagnostic_info_test3.cpp
@@ -8,6 +8,7 @@
 #else
 #   include <boost/leaf/config.hpp>
 #   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/on_error.hpp>
 #   include <boost/leaf/result.hpp>
 #endif
 
diff --git a/test/diagnostic_info_test4.cpp b/test/diagnostic_info_test4.cpp
index 5d152381..d93c10b8 100644
--- a/test/diagnostic_info_test4.cpp
+++ b/test/diagnostic_info_test4.cpp
@@ -8,6 +8,7 @@
 #else
 #   include <boost/leaf/config.hpp>
 #   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/on_error.hpp>
 #   include <boost/leaf/result.hpp>
 #endif
 
diff --git a/test/diagnostic_info_test5.cpp b/test/diagnostic_info_test5.cpp
index 7fce88ee..75b336e2 100644
--- a/test/diagnostic_info_test5.cpp
+++ b/test/diagnostic_info_test5.cpp
@@ -8,6 +8,7 @@
 #else
 #   include <boost/leaf/config.hpp>
 #   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/on_error.hpp>
 #   include <boost/leaf/result.hpp>
 #endif
 
diff --git a/test/dynamic_capture_print_test.cpp b/test/dynamic_capture_print_test.cpp
new file mode 100644
index 00000000..1534f8c5
--- /dev/null
+++ b/test/dynamic_capture_print_test.cpp
@@ -0,0 +1,70 @@
+// Copyright 2018-2023 Emil Dotchevski and Reverge Studios, Inc.
+
+// 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)
+
+#include <boost/leaf/config.hpp>
+
+#if !BOOST_LEAF_CFG_CAPTURE || !BOOST_LEAF_CFG_STD_STRING || !BOOST_LEAF_CFG_DIAGNOSTICS
+
+#include <iostream>
+
+int main()
+{
+    std::cout << "Unit test not applicable." << std::endl;
+    return 0;
+}
+
+#else
+
+#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
+#   include "leaf.hpp"
+#else
+#   include <boost/leaf/result.hpp>
+#   include <boost/leaf/handle_errors.hpp>
+#endif
+
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+struct non_printable_value
+{
+};
+
+struct e_err
+{
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, e_err const & )
+    {
+        return os << "e_err";
+    }
+};
+
+int main()
+{
+    std::string s;
+    (void) leaf::try_handle_all(
+        []() -> leaf::result<void>
+        {
+            return leaf::new_error(e_err{ });
+        },
+        [&]( leaf::dynamic_capture const & cap )
+        {
+            std::stringstream ss;
+            ss << cap;
+            s = ss.str();
+        } );
+    std::cout << s << std::endl;
+    BOOST_TEST_NE(s.find("Captured error objects"), s.npos);
+    BOOST_TEST_NE(s.find("e_err"), s.npos);
+
+    return boost::report_errors();
+}
+
+#endif
diff --git a/test/error_code_test.cpp b/test/error_code_test.cpp
index 0ac0cfd9..3f3c6920 100644
--- a/test/error_code_test.cpp
+++ b/test/error_code_test.cpp
@@ -214,7 +214,7 @@ void test()
         int r = leaf::try_handle_all(
             []() -> R
             {
-                return leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ).to_error_code();
+                return R(leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ));
             },
             []( e_wrapped_error_code const & wec )
             {
@@ -232,7 +232,7 @@ void test()
         int r = leaf::try_handle_all(
             []() -> R
             {
-                return leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ).to_error_code();
+                return R(leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ));
             },
             []( leaf::match_value<leaf::condition<e_wrapped_error_code, errc_a>, errc_a::a0> code )
             {
@@ -252,7 +252,7 @@ void test()
         int r = leaf::try_handle_all(
             []() -> R
             {
-                return leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ).to_error_code();
+                return R(leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ));
             },
             []( leaf::match_value<e_wrapped_error_code, errc_a::a0> code )
             {
@@ -272,7 +272,7 @@ void test()
         int r = leaf::try_handle_all(
             []() -> R
             {
-                return leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ).to_error_code();
+                return R(leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ));
             },
             []( leaf::match_value<leaf::condition<e_wrapped_error_code, cond_x>, cond_x::x00> cond )
             {
@@ -293,7 +293,7 @@ void test()
         int r = leaf::try_handle_all(
             []() -> R
             {
-                return leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ).to_error_code();
+                return R(leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ));
             },
             []( leaf::match_value<e_wrapped_error_code, cond_x::x00> cond )
             {
@@ -504,7 +504,7 @@ void test_void()
         leaf::try_handle_all(
             []() -> R
             {
-                return leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ).to_error_code();
+                return R(leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ));
             },
             [&]( e_wrapped_error_code const & wec )
             {
@@ -523,7 +523,7 @@ void test_void()
         leaf::try_handle_all(
             []() -> R
             {
-                return leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ).to_error_code();
+                return R(leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ));
             },
             [&]( leaf::match_value<leaf::condition<e_wrapped_error_code, errc_a>, errc_a::a0> code )
             {
@@ -544,7 +544,7 @@ void test_void()
         leaf::try_handle_all(
             []() -> R
             {
-                return leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ).to_error_code();
+                return R(leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ));
             },
             [&]( leaf::match_value<e_wrapped_error_code, errc_a::a0> code )
             {
@@ -565,7 +565,7 @@ void test_void()
         leaf::try_handle_all(
             []() -> R
             {
-                return leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ).to_error_code();
+                return R(leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ));
             },
             [&]( leaf::match_value<leaf::condition<e_wrapped_error_code, cond_x>, cond_x::x00> cond )
             {
@@ -587,7 +587,7 @@ void test_void()
         leaf::try_handle_all(
             []() -> R
             {
-                return leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ).to_error_code();
+                return R(leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } ));
             },
             [&]( leaf::match_value<e_wrapped_error_code, cond_x::x00> cond )
             {
diff --git a/test/github_issue53x_test.cpp b/test/github_issue53x_test.cpp
index 6c9870d9..091e4713 100644
--- a/test/github_issue53x_test.cpp
+++ b/test/github_issue53x_test.cpp
@@ -22,6 +22,7 @@ int main()
 #   include "leaf.hpp"
 #else
 #   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/exception.hpp>
 #   include <boost/leaf/pred.hpp>
 #endif
 
diff --git a/test/handle_all_other_result_test.cpp b/test/handle_all_other_result_test.cpp
index 9a7c988c..234e248c 100644
--- a/test/handle_all_other_result_test.cpp
+++ b/test/handle_all_other_result_test.cpp
@@ -45,7 +45,7 @@ ResType g( bool succeed )
     if( auto r = f<ResType>(succeed) )
         return r;
     else
-        return leaf::error_id(r.error()).load(info<42>{42}).to_error_code();
+        return ResType(leaf::error_id(r.error()).load(info<42>{42}));
 }
 
 template <class ResType>
diff --git a/test/handle_some_other_result_test.cpp b/test/handle_some_other_result_test.cpp
index 6bafbf4b..51dd1834 100644
--- a/test/handle_some_other_result_test.cpp
+++ b/test/handle_some_other_result_test.cpp
@@ -46,7 +46,7 @@ ResType g( bool succeed )
     if( auto r = f<ResType>(succeed) )
         return r;
     else
-        return leaf::error_id(r.error()).load(info<42>{42}).to_error_code();
+        return ResType(leaf::error_id(r.error()).load(info<42>{42}));
 }
 
 template <class ResType>
diff --git a/test/handle_some_test.cpp b/test/handle_some_test.cpp
index e763a442..6f79ed62 100644
--- a/test/handle_some_test.cpp
+++ b/test/handle_some_test.cpp
@@ -1302,5 +1302,82 @@ int main()
         BOOST_TEST_EQ(r, 1);
     }
 
+    //////////////////////////////////////
+
+    // void, no exception caught, error handled
+    {
+        int handle_some_handler_called = 0;
+        leaf::result<void> r = leaf::try_handle_some(
+            []() -> leaf::result<void>
+            {
+                return leaf::new_error( info<0>{1} );
+            },
+            [&]( info<0> & x )
+            {
+                BOOST_TEST_EQ(x.value, 1);
+                ++handle_some_handler_called;
+            } );
+        BOOST_TEST(r);
+        BOOST_TEST_EQ(handle_some_handler_called, 1);
+    }
+
+    // void, no exception caught, error not handled
+    {
+        int handle_some_handler_called = 0;
+        leaf::result<void> r = leaf::try_handle_some(
+            []() -> leaf::result<void>
+            {
+                return leaf::new_error( info<0>{1} );
+            },
+            [&]( leaf::error_info const & e, info<0> & x ) -> leaf::result<void>
+            {
+                BOOST_TEST_EQ(x.value, 1);
+                ++handle_some_handler_called;
+                return e.error();
+            } );
+        BOOST_TEST(!r);
+        BOOST_TEST_EQ(handle_some_handler_called, 1);
+    }
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+    // void, exception caught, error handled
+    {
+        int handle_some_handler_called = 0;
+        leaf::result<void> r = leaf::try_handle_some(
+            []() -> leaf::result<void>
+            {
+                BOOST_LEAF_THROW_EXCEPTION( info<0>{1} );
+            },
+            [&]( info<0> & x ) -> leaf::result<void>
+            {
+                BOOST_TEST_EQ(x.value, 1);
+                ++handle_some_handler_called;
+                return { };
+            } );
+        BOOST_TEST(r);
+        BOOST_TEST_EQ(handle_some_handler_called, 1);
+    }
+#endif
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+    // void, exception caught, error not handled
+    {
+        int handle_some_handler_called = 0;
+        leaf::result<void> r = leaf::try_handle_some(
+            []() -> leaf::result<void>
+            {
+                BOOST_LEAF_THROW_EXCEPTION( info<0>{1} );
+            },
+            [&]( leaf::error_info const & e, info<0> & x ) -> leaf::result<void>
+            {
+                BOOST_TEST_EQ(x.value, 1);
+                ++handle_some_handler_called;
+                return e.error();
+            } );
+        BOOST_TEST(!r);
+        BOOST_TEST_EQ(handle_some_handler_called, 1);
+    }
+#endif
+
     return boost::report_errors();
 }
diff --git a/test/multiple_errors_test.cpp b/test/multiple_errors_test.cpp
index 1465f389..c6cd5f70 100644
--- a/test/multiple_errors_test.cpp
+++ b/test/multiple_errors_test.cpp
@@ -5,6 +5,7 @@
 
 #include <boost/leaf/config.hpp>
 #include <boost/leaf/handle_errors.hpp>
+#include <boost/leaf/on_error.hpp>
 
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
@@ -85,6 +86,30 @@ int main()
             } );
         BOOST_TEST_EQ(r, 2);
     }
+    {
+        int r = leaf::try_catch(
+            []() -> int
+            {
+                try
+                {
+                    auto load = leaf::on_error(info<4>{4});
+                    throw std::exception();
+                }
+                catch(...)
+                {
+                }
+                leaf::throw_exception();
+            },
+            []( std::exception const &, info<4> )
+            {
+                return 1;
+            },
+            []( std::exception const & )
+            {
+                return 2;
+            } );
+        BOOST_TEST_EQ(r, 2);
+    }
 #endif
 
     return boost::report_errors();
diff --git a/test/optional_test.cpp b/test/optional_test.cpp
index e83b5d84..41754eee 100644
--- a/test/optional_test.cpp
+++ b/test/optional_test.cpp
@@ -300,7 +300,7 @@ void run_tests()
     {
         optional<my_info> x;
         my_info a(42);
-        x.put(10, a);
+        x.load(10, a);
         BOOST_TEST_EQ(object_count, 2);
         BOOST_TEST_EQ(value_count, 2);
         BOOST_TEST(!x.empty());
@@ -316,7 +316,7 @@ void run_tests()
         BOOST_TEST_EQ(object_count, 1);
         BOOST_TEST_EQ(value_count, 1);
         my_info a(42);
-        x.put(10, a);
+        x.load(10, a);
         BOOST_TEST_EQ(object_count, 2);
         BOOST_TEST_EQ(value_count, 2);
         BOOST_TEST(!x.empty());
@@ -329,7 +329,7 @@ void run_tests()
     {
         optional<my_info> x;
         BOOST_TEST(x.empty());
-        x.put(10, my_info(42));
+        x.load(10, my_info(42));
         BOOST_TEST_EQ(object_count, 1);
         BOOST_TEST_EQ(value_count, 1);
         BOOST_TEST(!x.empty());
@@ -344,7 +344,7 @@ void run_tests()
         BOOST_TEST(!x.empty());
         BOOST_TEST_EQ(object_count, 1);
         BOOST_TEST_EQ(value_count, 1);
-        x.put(10, my_info(42));
+        x.load(10, my_info(42));
         BOOST_TEST(!x.empty());
         BOOST_TEST_EQ(object_count, 1);
         BOOST_TEST_EQ(value_count, 1);
diff --git a/test/preload_basic_test.cpp b/test/preload_basic_test.cpp
index 7a14006a..0a5504e4 100644
--- a/test/preload_basic_test.cpp
+++ b/test/preload_basic_test.cpp
@@ -48,11 +48,6 @@ void test( G && g )
             ss << di;
             std::string s = ss.str();
             std::cout << s << std::endl;
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-            BOOST_TEST(s.find("info<-42>")!=s.npos);
-#else
-            BOOST_TEST(s.find("BOOST_LEAF_CFG_DIAGNOSTICS")!=s.npos);
-#endif
 #endif
             return 1;
         },
diff --git a/test/result_print_test.cpp b/test/result_print_test.cpp
index 8bc28e11..4131cc23 100644
--- a/test/result_print_test.cpp
+++ b/test/result_print_test.cpp
@@ -7,8 +7,7 @@
 #   include "leaf.hpp"
 #else
 #   include <boost/leaf/result.hpp>
-#   include <boost/leaf/capture.hpp>
-#   include <boost/leaf/context.hpp>
+#   include <boost/leaf/handle_errors.hpp>
 #endif
 
 #if BOOST_LEAF_CFG_STD_STRING
@@ -94,22 +93,27 @@ int main()
 
 #if BOOST_LEAF_CFG_CAPTURE
     {
-    using context_type = leaf::leaf_detail::polymorphic_context_impl<leaf::context<e_err>>;
-        {
-            leaf::result<int> r = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<int>( leaf::new_error( e_err { } ) ); } );
+        leaf::result<int> r = leaf::try_handle_some(
+            []() -> leaf::result<int>
+            {
+                return leaf::new_error(e_err{ });
+            },
+            []( leaf::dynamic_capture const & cap ) -> leaf::result<int>
+            {
+                return cap;
+            } );
 #if BOOST_LEAF_CFG_STD_STRING
-            std::stringstream ss;
-            ss << r;
-            std::string s = ss.str();
-            std::cout << s << std::endl;
-            leaf::error_id err = r.error();
-            BOOST_TEST_NE(s.find("Error ID " + std::to_string(err.value())), s.npos);
+        std::stringstream ss;
+        ss << r;
+        std::string s = ss.str();
+        std::cout << s << std::endl;
+        leaf::error_id err = r.error();
+        BOOST_TEST_NE(s.find("Error ID " + std::to_string(err.value())), s.npos);
 #if BOOST_LEAF_CFG_DIAGNOSTICS
-            BOOST_TEST_NE(s.find("captured error objects"), s.npos);
-            BOOST_TEST_NE(s.find("e_err"), s.npos);
+        BOOST_TEST_NE(s.find("Captured error objects"), s.npos);
+        BOOST_TEST_NE(s.find("e_err"), s.npos);
 #endif
 #endif
-        }
     }
 #endif
 
diff --git a/test/result_ref_test.cpp b/test/result_ref_test.cpp
index f7be0cf9..b206ddc9 100644
--- a/test/result_ref_test.cpp
+++ b/test/result_ref_test.cpp
@@ -7,7 +7,6 @@
 #   include "leaf.hpp"
 #else
 #   include <boost/leaf/result.hpp>
-#   include <boost/leaf/capture.hpp>
 #   include <boost/leaf/handle_errors.hpp>
 #endif
 
diff --git a/test/result_state_test.cpp b/test/result_state_test.cpp
index fde52c3e..e05f4732 100644
--- a/test/result_state_test.cpp
+++ b/test/result_state_test.cpp
@@ -7,7 +7,6 @@
 #   include "leaf.hpp"
 #else
 #   include <boost/leaf/result.hpp>
-#   include <boost/leaf/capture.hpp>
 #   include <boost/leaf/handle_errors.hpp>
 #endif
 
@@ -185,89 +184,11 @@ int main()
     BOOST_TEST_EQ(err::count, 0);
     BOOST_TEST_EQ(val::count, 0);
 
-    using context_type = leaf::leaf_detail::polymorphic_context_impl<leaf::context<e_err>>;
-
-#if BOOST_LEAF_CFG_CAPTURE
-    { // value default -> capture -> move
-        leaf::result<val> r1 = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<val>(); } );
-        BOOST_TEST(r1);
-        BOOST_TEST_EQ(err::count, 0);
-        BOOST_TEST_EQ(val::count, 1);
-        leaf::result<val> r2 = std::move(r1);
-        BOOST_TEST(r2);
-        BOOST_TEST_EQ(err::count, 0);
-        BOOST_TEST_EQ(val::count, 2);
-    }
-    BOOST_TEST_EQ(err::count, 0);
-    BOOST_TEST_EQ(val::count, 0);
-    { // value move -> capture -> move
-        leaf::result<val> r1 = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<val>(val()); } );
-        BOOST_TEST(r1);
-        BOOST_TEST_EQ(err::count, 0);
-        BOOST_TEST_EQ(val::count, 1);
-        leaf::result<val> r2 = std::move(r1);
-        BOOST_TEST(r2);
-        BOOST_TEST_EQ(err::count, 0);
-        BOOST_TEST_EQ(val::count, 2);
-    }
-    BOOST_TEST_EQ(err::count, 0);
-    BOOST_TEST_EQ(val::count, 0);
-    { // value copy -> capture -> move
-        leaf::result<val> r1 = leaf::capture( std::make_shared<context_type>(), []{ val v; return leaf::result<val>(v); } );
-        BOOST_TEST(r1);
-        BOOST_TEST_EQ(err::count, 0);
-        BOOST_TEST_EQ(val::count, 1);
-        leaf::result<val> r2 = std::move(r1);
-        BOOST_TEST(r2);
-        BOOST_TEST_EQ(err::count, 0);
-        BOOST_TEST_EQ(val::count, 2);
-    }
-    BOOST_TEST_EQ(err::count, 0);
-    BOOST_TEST_EQ(val::count, 0);
-
-    { // value default -> capture -> assign-move
-        leaf::result<val> r1 = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<val>(); } );
-        BOOST_TEST(r1);
-        BOOST_TEST_EQ(err::count, 0);
-        BOOST_TEST_EQ(val::count, 1);
-        leaf::result<val> r2; r2=std::move(r1);
-        BOOST_TEST(r2);
-        BOOST_TEST_EQ(err::count, 0);
-        BOOST_TEST_EQ(val::count, 2);
-    }
-    BOOST_TEST_EQ(err::count, 0);
-    BOOST_TEST_EQ(val::count, 0);
-    { // value move -> capture -> assign-move
-        leaf::result<val> r1 = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<val>(val()); } );
-        BOOST_TEST(r1);
-        BOOST_TEST_EQ(err::count, 0);
-        BOOST_TEST_EQ(val::count, 1);
-        leaf::result<val> r2; r2=std::move(r1);
-        BOOST_TEST(r2);
-        BOOST_TEST_EQ(err::count, 0);
-        BOOST_TEST_EQ(val::count, 2);
-    }
-    BOOST_TEST_EQ(err::count, 0);
-    BOOST_TEST_EQ(val::count, 0);
-    { // value copy -> capture -> assign-move
-        leaf::result<val> r1 = leaf::capture( std::make_shared<context_type>(), []{ val v; return leaf::result<val>(v); } );
-        BOOST_TEST(r1);
-        BOOST_TEST_EQ(err::count, 0);
-        BOOST_TEST_EQ(val::count, 1);
-        leaf::result<val> r2; r2=std::move(r1);
-        BOOST_TEST(r2);
-        BOOST_TEST_EQ(err::count, 0);
-        BOOST_TEST_EQ(val::count, 2);
-        }
-    BOOST_TEST_EQ(err::count, 0);
-    BOOST_TEST_EQ(val::count, 0);
-#endif
-
     // ^^ value ^^
     // vv error vv
 
     { // error move -> move
-        context_type ctx;
+        leaf::context<e_err>  ctx;
         auto active_context = activate_context(ctx);
         leaf::result<val> r1 = leaf::new_error( e_err { } );
         BOOST_TEST(!r1);
@@ -282,7 +203,7 @@ int main()
     BOOST_TEST_EQ(err::count, 0);
     BOOST_TEST_EQ(val::count, 0);
     { // error copy -> move
-        context_type ctx;
+        leaf::context<e_err>  ctx;
         auto active_context = activate_context(ctx);
         leaf::error_id err = leaf::new_error( e_err{ } );
         leaf::result<val> r1 = err;
@@ -299,7 +220,7 @@ int main()
     BOOST_TEST_EQ(val::count, 0);
 
     { // error move -> assign move
-        context_type ctx;
+        leaf::context<e_err>  ctx;
         ctx.activate();
         leaf::result<val> r1 = leaf::new_error( e_err { } );
         ctx.deactivate();
@@ -321,7 +242,7 @@ int main()
     BOOST_TEST_EQ(err::count, 0);
     BOOST_TEST_EQ(val::count, 0);
     { // error copy -> assign move
-        context_type ctx;
+        leaf::context<e_err>  ctx;
         auto active_context = activate_context(ctx);
         leaf::error_id err = leaf::new_error( e_err{ } );
         leaf::result<val> r1 = err;
@@ -339,7 +260,15 @@ int main()
 
 #if BOOST_LEAF_CFG_CAPTURE
     { // error move -> capture -> move
-        leaf::result<val> r1 = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } );
+        leaf::result<val> r1 = leaf::try_handle_some(
+            []()->leaf::result<val>
+            {
+                return leaf::new_error(e_err{ });
+            },
+            [](leaf::dynamic_capture const & cap)->leaf::result<val>
+            {
+                return cap;
+            });
         BOOST_TEST(!r1);
         BOOST_TEST_EQ(err::count, 1);
         BOOST_TEST_EQ(val::count, 0);
@@ -353,7 +282,16 @@ int main()
     BOOST_TEST_EQ(err::count, 0);
     BOOST_TEST_EQ(val::count, 0);
     { // error copy -> capture -> move
-        leaf::result<val> r1 = leaf::capture( std::make_shared<context_type>(), []{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } );
+        leaf::result<val> r1 = leaf::try_handle_some(
+            []()->leaf::result<val>
+            {
+                leaf::error_id err = leaf::new_error( e_err{ } );
+                return leaf::result<val>(err);
+            },
+            [](leaf::dynamic_capture const & cap)->leaf::result<val>
+            {
+                return cap;
+            });
         BOOST_TEST(!r1);
         BOOST_TEST_EQ(err::count, 1);
         BOOST_TEST_EQ(val::count, 0);
@@ -368,7 +306,15 @@ int main()
     BOOST_TEST_EQ(val::count, 0);
 
     { // error move -> capture -> assign-move
-        leaf::result<val> r1 = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } );
+        leaf::result<val> r1 = leaf::try_handle_some(
+            []()->leaf::result<val>
+            {
+                return leaf::new_error(e_err{ });
+            },
+            [](leaf::dynamic_capture const & cap)->leaf::result<val>
+            {
+                return cap;
+            });
         BOOST_TEST(!r1);
         BOOST_TEST_EQ(err::count, 1);
         BOOST_TEST_EQ(val::count, 0);
@@ -382,7 +328,16 @@ int main()
     BOOST_TEST_EQ(err::count, 0);
     BOOST_TEST_EQ(val::count, 0);
     { // error copy -> capture -> assign-move
-        leaf::result<val> r1 = leaf::capture( std::make_shared<context_type>(), []{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } );
+        leaf::result<val> r1 = leaf::try_handle_some(
+            []()->leaf::result<val>
+            {
+                leaf::error_id err = leaf::new_error( e_err{ } );
+                return leaf::result<val>(err);
+            },
+            [](leaf::dynamic_capture const & cap)->leaf::result<val>
+            {
+                return cap;
+            });
         BOOST_TEST(!r1);
         BOOST_TEST_EQ(err::count, 1);
         BOOST_TEST_EQ(val::count, 0);
@@ -429,38 +384,11 @@ int main()
         *r2;
     }
 
-#if BOOST_LEAF_CFG_CAPTURE
-    { // void default -> capture -> move
-        leaf::result<void> r1 = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<void>(); } );
-        BOOST_TEST(r1);
-        r1.value();
-        BOOST_TEST(r1.operator->() != 0);
-        *r1;
-        leaf::result<void> r2 = std::move(r1);
-        BOOST_TEST(r2);
-        r2.value();
-        BOOST_TEST(r2.operator->() != 0);
-        *r2;
-    }
-    { // void default -> capture -> assign-move
-        leaf::result<void> r1 = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<void>(); } );
-        BOOST_TEST(r1);
-        r1.value();
-        BOOST_TEST(r1.operator->() != 0);
-        *r1;
-        leaf::result<void> r2; r2=std::move(r1);
-        BOOST_TEST(r2);
-        r2.value();
-        BOOST_TEST(r2.operator->() != 0);
-        *r2;
-    }
-#endif
-
     // ^^ void default ^^
     // vv void error vv
 
     { // void error move -> move
-        context_type ctx;
+        leaf::context<e_err>  ctx;
         auto active_context = activate_context(ctx);
         leaf::result<void> r1 = leaf::new_error( e_err { } );
         BOOST_TEST(!r1);
@@ -475,7 +403,7 @@ int main()
     }
     BOOST_TEST_EQ(err::count, 0);
     { // void error copy -> move
-        context_type ctx;
+        leaf::context<e_err>  ctx;
         auto active_context = activate_context(ctx);
         leaf::error_id err = leaf::new_error( e_err{ } );
         leaf::result<void> r1 = err;
@@ -492,7 +420,7 @@ int main()
     BOOST_TEST_EQ(err::count, 0);
 
     { // void error move -> assign move
-        context_type ctx;
+        leaf::context<e_err>  ctx;
         ctx.activate();
         leaf::result<void> r1 = leaf::new_error( e_err { } );
         ctx.deactivate();
@@ -510,7 +438,7 @@ int main()
     }
     BOOST_TEST_EQ(err::count, 0);
     { // void error copy -> assign move
-        context_type ctx;
+        leaf::context<e_err>  ctx;
         auto active_context = activate_context(ctx);
         leaf::error_id err = leaf::new_error( e_err{ } );
         leaf::result<void> r1 = err;
@@ -528,7 +456,15 @@ int main()
 
 #if BOOST_LEAF_CFG_CAPTURE
     { // void error move -> capture -> move
-        leaf::result<void> r1 = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } );
+        leaf::result<void> r1 = leaf::try_handle_some(
+            []()->leaf::result<void>
+            {
+                return leaf::new_error(e_err{ });
+            },
+            [](leaf::dynamic_capture const & cap)->leaf::result<void>
+            {
+                return cap;
+            });
         BOOST_TEST(!r1);
         BOOST_TEST(r1.operator->() == 0);
         BOOST_TEST_EQ(err::count, 1);
@@ -541,7 +477,16 @@ int main()
     }
     BOOST_TEST_EQ(err::count, 0);
     { // void error copy -> capture -> move
-        leaf::result<void> r1 = leaf::capture( std::make_shared<context_type>(), []{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } );
+        leaf::result<void> r1 = leaf::try_handle_some(
+            []()->leaf::result<void>
+            {
+                leaf::error_id err = leaf::new_error( e_err{ } );
+                return leaf::result<void>(err);
+            },
+            [](leaf::dynamic_capture const & cap)->leaf::result<void>
+            {
+                return cap;
+            });
         BOOST_TEST(!r1);
         BOOST_TEST(r1.operator->() == 0);
         BOOST_TEST_EQ(err::count, 1);
@@ -555,7 +500,15 @@ int main()
     BOOST_TEST_EQ(err::count, 0);
 
     { // void error move -> capture -> assign-move
-        leaf::result<void> r1 = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } );
+        leaf::result<void> r1 = leaf::try_handle_some(
+            []()->leaf::result<void>
+            {
+                return leaf::new_error(e_err{ });
+            },
+            [](leaf::dynamic_capture const & cap)->leaf::result<void>
+            {
+                return cap;
+            });
         BOOST_TEST(!r1);
         BOOST_TEST(r1.operator->() == 0);
         BOOST_TEST_EQ(err::count, 1);
@@ -568,7 +521,16 @@ int main()
     }
     BOOST_TEST_EQ(err::count, 0);
     { // void error copy -> capture -> assign-move
-        leaf::result<void> r1 = leaf::capture( std::make_shared<context_type>(), []{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } );
+        leaf::result<void> r1 = leaf::try_handle_some(
+            []()->leaf::result<void>
+            {
+                leaf::error_id err = leaf::new_error( e_err{ } );
+                return leaf::result<void>(err);
+            },
+            [](leaf::dynamic_capture const & cap)->leaf::result<void>
+            {
+                return cap;
+            });
         BOOST_TEST(!r1);
         BOOST_TEST(r1.operator->() == 0);
         BOOST_TEST_EQ(err::count, 1);
diff --git a/test/tls_array_alloc_test1.cpp b/test/tls_array_alloc_test1.cpp
index ebb0eef0..f092bc35 100644
--- a/test/tls_array_alloc_test1.cpp
+++ b/test/tls_array_alloc_test1.cpp
@@ -5,11 +5,7 @@
 
 #define BOOST_LEAF_NO_EXCEPTIONS
 #define BOOST_LEAF_CFG_STD_SYSTEM_ERROR 0
-#define BOOST_LEAF_CFG_STD_STRING 0
-#ifdef BOOST_LEAF_CFG_DIAGNOSTICS
-#   undef BOOST_LEAF_CFG_DIAGNOSTICS
-#endif
-#define BOOST_LEAF_CFG_DIAGNOSTICS 0
+#define BOOST_LEAF_CFG_CAPTURE 0
 #define BOOST_LEAF_USE_TLS_ARRAY
 #define BOOST_LEAF_CFG_TLS_ARRAY_SIZE 64
 #define BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX 10
diff --git a/test/tls_array_alloc_test2.cpp b/test/tls_array_alloc_test2.cpp
index 2b922433..dea5e936 100644
--- a/test/tls_array_alloc_test2.cpp
+++ b/test/tls_array_alloc_test2.cpp
@@ -5,11 +5,7 @@
 
 #define BOOST_LEAF_NO_EXCEPTIONS
 #define BOOST_LEAF_CFG_STD_SYSTEM_ERROR 0
-#define BOOST_LEAF_CFG_STD_STRING 0
-#ifdef BOOST_LEAF_CFG_DIAGNOSTICS
-#   undef BOOST_LEAF_CFG_DIAGNOSTICS
-#endif
-#define BOOST_LEAF_CFG_DIAGNOSTICS 0
+#define BOOST_LEAF_CFG_CAPTURE 0
 #define BOOST_LEAF_USE_TLS_ARRAY
 #define BOOST_LEAF_CFG_TLS_ARRAY_SIZE 64
 #define BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX 10
diff --git a/test/tls_array_alloc_test3.cpp b/test/tls_array_alloc_test3.cpp
index c7ce6bff..fdfc777f 100644
--- a/test/tls_array_alloc_test3.cpp
+++ b/test/tls_array_alloc_test3.cpp
@@ -5,11 +5,7 @@
 
 #define BOOST_LEAF_NO_EXCEPTIONS
 #define BOOST_LEAF_CFG_STD_SYSTEM_ERROR 0
-#define BOOST_LEAF_CFG_STD_STRING 0
-#ifdef BOOST_LEAF_CFG_DIAGNOSTICS
-#   undef BOOST_LEAF_CFG_DIAGNOSTICS
-#endif
-#define BOOST_LEAF_CFG_DIAGNOSTICS 0
+#define BOOST_LEAF_CFG_CAPTURE 0
 #define BOOST_LEAF_USE_TLS_ARRAY
 #define BOOST_LEAF_CFG_TLS_ARRAY_SIZE 64
 #define BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX 10
diff --git a/test/try_catch_system_error_test.cpp b/test/try_catch_system_error_test.cpp
index 5c13eafc..7fcd4fb5 100644
--- a/test/try_catch_system_error_test.cpp
+++ b/test/try_catch_system_error_test.cpp
@@ -22,6 +22,7 @@ int main()
 #else
 #   include <boost/leaf/handle_errors.hpp>
 #   include <boost/leaf/exception.hpp>
+#   include <boost/leaf/on_error.hpp>
 #   include <boost/leaf/pred.hpp>
 #endif
 
diff --git a/test/try_catch_test.cpp b/test/try_catch_test.cpp
index f3ed55fb..fcd8e88a 100644
--- a/test/try_catch_test.cpp
+++ b/test/try_catch_test.cpp
@@ -21,6 +21,7 @@ int main()
 #   include "leaf.hpp"
 #else
 #   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/exception.hpp>
 #   include <boost/leaf/pred.hpp>
 #endif