diff --git a/.drone.jsonnet b/.drone.jsonnet
new file mode 100644
index 00000000..867f472d
--- /dev/null
+++ b/.drone.jsonnet
@@ -0,0 +1,234 @@
+# Copyright 2022 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+local library = "leaf";
+
+local triggers =
+{
+    branch: [ "master", "develop", "feature/*" ]
+};
+
+local ubsan = { UBSAN: '1', UBSAN_OPTIONS: 'print_stacktrace=1' };
+local asan = { ASAN: '1' };
+
+local linux_pipeline(name, image, environment, packages = "", sources = [], arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "docker",
+    trigger: triggers,
+    platform:
+    {
+        os: "linux",
+        arch: arch
+    },
+    steps:
+    [
+        {
+            name: "everything",
+            image: image,
+            environment: environment,
+            commands:
+            [
+                'set -e',
+                'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
+            ] +
+            (if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
+            (if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
+            [
+                'export LIBRARY=' + library,
+                './.drone/drone.sh',
+            ]
+        }
+    ]
+};
+
+local macos_pipeline(name, environment, xcode_version = "14.1", osx_version = "monterey", arch = "arm64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "exec",
+    trigger: triggers,
+    platform: {
+        "os": "darwin",
+        "arch": arch
+    },
+    node: {
+        "os": osx_version
+    },
+    steps: [
+        {
+            name: "everything",
+            environment: environment + { "DEVELOPER_DIR": "/Applications/Xcode-" + xcode_version + ".app/Contents/Developer" },
+            commands:
+            [
+                'export LIBRARY=' + library,
+                './.drone/drone.sh',
+            ]
+        }
+    ]
+};
+
+local windows_pipeline(name, image, environment, arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "docker",
+    trigger: triggers,
+    platform:
+    {
+        os: "windows",
+        arch: arch
+    },
+    "steps":
+    [
+        {
+            name: "everything",
+            image: image,
+            environment: environment,
+            commands:
+            [
+                'cmd /C .drone\\\\drone.bat ' + library,
+            ]
+        }
+    ]
+};
+
+[
+    linux_pipeline(
+        "Linux 16.04 GCC 5*",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 6",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '11,14' },
+        "g++-6",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 7* 32",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14', ADDRMD: '32' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 7* 64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14', ADDRMD: '64' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 8",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '11,14,17' },
+        "g++-8",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* 32",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '32' },
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* 64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '64' },
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9 ARM64 32/64",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '32,64' },
+        arch="arm64",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 10 32 ASAN",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '11,14,17,20', ADDRMD: '32' } + asan,
+        "g++-10-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 10 64 ASAN",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '11,14,17,20', ADDRMD: '64' } + asan,
+        "g++-10-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.6",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.6', CXXSTD: '11,14' },
+        "clang-3.6",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.7",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.7', CXXSTD: '11,14' },
+        "clang-3.7",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.8",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.8', CXXSTD: '11,14' },
+        "clang-3.8",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 13",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '11,14,17,20' },
+        "clang-13",
+        ["deb http://apt.llvm.org/focal/ llvm-toolchain-focal-13 main"],
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 14 UBSAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '11,14,17,20' } + ubsan,
+        "clang-14",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 14 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '11,14,17,20' } + asan,
+        "clang-14",
+    ),
+
+    macos_pipeline(
+        "MacOS 12.5.1 Xcode 14.1 UBSAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '14,17,20' } + ubsan,
+    ),
+
+    macos_pipeline(
+        "MacOS 12.5.1 Xcode 14.1 ASAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '14,17,20' } + asan,
+    ),
+
+    windows_pipeline(
+        "Windows VS2017 msvc-14.1",
+        "cppalliance/dronevs2017",
+        { TOOLSET: 'msvc-14.1', CXXSTD: '14,17,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2019 msvc-14.2",
+        "cppalliance/dronevs2019",
+        { TOOLSET: 'msvc-14.2', CXXSTD: '14,17,20,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2022 msvc-14.3",
+        "cppalliance/dronevs2022:1",
+        { TOOLSET: 'msvc-14.3', CXXSTD: '14,17,20,latest' },
+    ),
+]
diff --git a/.drone.star b/.drone.star
deleted file mode 100644
index 2d1b15aa..00000000
--- a/.drone.star
+++ /dev/null
@@ -1,55 +0,0 @@
-# Use, modification, and distribution are
-# subject to the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE.txt)
-#
-# Copyright Rene Rivera 2020.
-
-# For Drone CI we use the Starlark scripting language to reduce duplication.
-# As the yaml syntax for Drone CI is rather limited.
-#
-#
-globalenv={}
-linuxglobalimage="cppalliance/droneubuntu1404:1"
-windowsglobalimage="cppalliance/dronevs2019"
-
-def main(ctx):
-  return [
-  osx_cxx("UBSAN=1 TOOLSET=clang COMPILER=clang++ CXXSTD Job 1", "clang++", packages="", buildtype="boost", buildscript="drone", environment={'UBSAN': '1', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11,14', 'UBSAN_OPTIONS': 'print_stacktrace=1', 'DRONE_JOB_UUID': '356a192b79'}, globalenv=globalenv),
-  osx_cxx("UBSAN=1 TOOLSET=clang COMPILER=clang++ CXXSTD Job 2", "clang++", packages="", buildtype="boost", buildscript="drone", environment={'UBSAN': '1', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '1z,2a', 'UBSAN_OPTIONS': 'print_stacktrace=1', 'DRONE_JOB_UUID': 'da4b9237ba'}, globalenv=globalenv),
-  osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1 Job 3", "clang++", packages="", buildtype="boost", buildscript="drone", xcode_version="11.5", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': '77de68daec'}, globalenv=globalenv),
-  osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1 Job 4", "clang++", packages="", buildtype="boost", buildscript="drone", xcode_version="11.4", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': '1b64538924'}, globalenv=globalenv),
-  osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1 Job 5", "clang++", packages="", buildtype="boost", buildscript="drone", xcode_version="11.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': 'ac3478d69a'}, globalenv=globalenv),
-  osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1 Job 6", "clang++", packages="", buildtype="boost", buildscript="drone", xcode_version="11.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': 'c1dfd96eea'}, globalenv=globalenv),
-  osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1 Job 7", "clang++", packages="", buildtype="boost", buildscript="drone", xcode_version="11.1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': '902ba3cda1'}, globalenv=globalenv),
-  osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1 Job 8", "clang++", packages="", buildtype="boost", buildscript="drone", xcode_version="11", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': 'fe5dbbcea5'}, globalenv=globalenv),
-  osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1 Job 9", "clang++", packages="", buildtype="boost", buildscript="drone", xcode_version="10.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': '0ade7c2cf9'}, globalenv=globalenv),
-  osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1 Job 10", "clang++", packages="", buildtype="boost", buildscript="drone", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': 'b1d5781111'}, globalenv=globalenv),
-  osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1 Job 11", "clang++", packages="", buildtype="boost", buildscript="drone", xcode_version="10.1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': '17ba079149'}, globalenv=globalenv),
-  linux_cxx("UBSAN=1 TOOLSET=gcc COMPILER=g++-9 CXXSTD=11, Job 12", "g++-9", packages="g++-9", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'UBSAN': '1', 'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '11,14', 'UBSAN_OPTIONS': 'print_stacktrace=1', 'LINKFLAGS': '-fuse-ld=gold', 'DRONE_JOB_UUID': '7b52009b64'}, globalenv=globalenv),
-  linux_cxx("UBSAN=1 TOOLSET=gcc COMPILER=g++-9 CXXSTD=17, Job 13", "g++-9", packages="g++-9", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'UBSAN': '1', 'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '17,2a', 'UBSAN_OPTIONS': 'print_stacktrace=1', 'LINKFLAGS': '-fuse-ld=gold', 'DRONE_JOB_UUID': 'bd307a3ec3'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++-9 CXXSTD=11,14,17,2a Job 14", "g++-9", packages="g++-9", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '11,14,17,2a', 'DRONE_JOB_UUID': 'fa35e19212'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++-8 CXXSTD=11,14,17 Job 15", "g++-8", packages="g++-8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '11,14,17', 'DRONE_JOB_UUID': 'f1abd67035'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++-7 CXXSTD=11,14 Job 16", "g++-7", packages="g++-7", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '11,14', 'DRONE_JOB_UUID': '1574bddb75'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++-6 CXXSTD=11,14 Job 17", "g++-6", packages="g++-6", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '11,14', 'DRONE_JOB_UUID': '0716d9708d'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++-5 CXXSTD=11,14 Job 18", "g++-5", packages="g++-5", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '11,14', 'DRONE_JOB_UUID': '9e6a55b6b4'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=11 Job 19", "g++-4.9", packages="g++-4.9", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.9', 'CXXSTD': '11', 'DRONE_JOB_UUID': 'b3f0c7f6bb'}, globalenv=globalenv),
-  linux_cxx("UBSAN=1 TOOLSET=clang COMPILER=clang++-8 CXXS Job 20", "clang++-8", packages="clang-8", llvm_os="trusty", llvm_ver="8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'UBSAN': '1', 'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '11,14', 'UBSAN_OPTIONS': 'print_stacktrace=1', 'DRONE_JOB_UUID': '91032ad7bb'}, globalenv=globalenv),
-  linux_cxx("UBSAN=1 TOOLSET=clang COMPILER=clang++-8 CXXS Job 21", "clang++-8", packages="clang-8", llvm_os="trusty", llvm_ver="8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'UBSAN': '1', 'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '17,2a', 'UBSAN_OPTIONS': 'print_stacktrace=1', 'DRONE_JOB_UUID': '472b07b9fc'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-10 CXXSTD=11,1 Job 22", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '11,14,17,2a', 'DRONE_JOB_UUID': '12c6fc06c9'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-9 CXXSTD=11,14 Job 23", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '11,14,17,2a', 'DRONE_JOB_UUID': 'd435a6cdd7'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-8 CXXSTD=11,14 Job 24", "clang++-8", packages="clang-8", llvm_os="trusty", llvm_ver="8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '11,14,17,2a', 'DRONE_JOB_UUID': '4d134bc072'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-7 CXXSTD=11,14 Job 25", "clang++-7", packages="clang-7", llvm_os="trusty", llvm_ver="7", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '11,14,17,2a', 'DRONE_JOB_UUID': 'f6e1126ced'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=11, Job 26", "clang++-6.0", packages="clang-6.0", llvm_os="trusty", llvm_ver="6.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-6.0', 'CXXSTD': '11,14,17', 'DRONE_JOB_UUID': '887309d048'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=11, Job 27", "clang++-5.0", packages="clang-5.0", llvm_os="trusty", llvm_ver="5.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': 'bc33ea4e26'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=11, Job 28", "clang++-4.0", packages="clang-4.0", llvm_os="trusty", llvm_ver="4.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': '0a57cb53ba'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=11, Job 29", "clang++-3.9", packages="clang-3.9 libstdc++-4.9-dev", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.9', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': '7719a1c782'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=11, Job 30", "clang++-3.8", packages="clang-3.8 libstdc++-4.9-dev", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.8', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': '22d200f867'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=11, Job 31", "clang++-3.7", packages="clang-3.7", llvm_os="precise", llvm_ver="3.7", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.7', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': '632667547e'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=11, Job 32", "clang++-3.6", packages="clang-3.6 libstdc++-4.9-dev", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.6', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': 'cb4e5208b4'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=11, Job 33", "clang++-3.5", packages="clang-3.5 libstdc++-4.9-dev", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.5', 'CXXSTD': '11,14,1z', 'DRONE_JOB_UUID': 'b6692ea5df'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=/usr/bin/clang++ CXXST Job 34", "/usr/bin/clang++", packages="clang-3.4", llvm_os="precise", llvm_ver="3.8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': '/usr/bin/clang++', 'CXXSTD': '11', 'DRONE_JOB_UUID': 'f1f836cb4e'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=/usr/bin/clang++ CXXST Job 35", "/usr/bin/clang++", packages="clang-3.3", llvm_os="precise", llvm_ver="3.8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': '/usr/bin/clang++', 'CXXSTD': '11', 'DRONE_JOB_UUID': '972a67c481'}, globalenv=globalenv),
-    ]
-
-# from https://github.com/boostorg/boost-ci
-load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx")
diff --git a/.drone/drone.bat b/.drone/drone.bat
new file mode 100644
index 00000000..84d22a86
--- /dev/null
+++ b/.drone/drone.bat
@@ -0,0 +1,28 @@
+@REM Copyright 2022 Peter Dimov
+@REM Distributed under the Boost Software License, Version 1.0.
+@REM https://www.boost.org/LICENSE_1_0.txt
+
+@ECHO ON
+
+set LIBRARY=%1
+set DRONE_BUILD_DIR=%CD%
+
+set BOOST_BRANCH=develop
+if "%DRONE_BRANCH%" == "master" set BOOST_BRANCH=master
+cd ..
+git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/boostdep
+xcopy /s /e /q %DRONE_BUILD_DIR% libs\%LIBRARY%\
+python tools/boostdep/depinst/depinst.py %LIBRARY%
+cmd /c bootstrap
+b2 -d0 headers
+
+echo "Generating single header"
+cd libs/%LIBRARY%
+python gen/generate_single_header.py -i include/boost/leaf/detail/all.hpp -p include -o test/leaf.hpp boost/leaf
+
+echo "Testing"
+if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+..\..\b2 -j3 test toolset=%TOOLSET% %CXXSTD% %ADDRMD% embed-manifest-via=linker link=shared,static variant=debug,release,leaf_debug_capture0,leaf_release_capture0,leaf_debug_diag0,leaf_release_diag0,leaf_debug_embedded,leaf_release_embedded,leaf_debug_single_header,leaf_release_single_header
diff --git a/.drone/drone.sh b/.drone/drone.sh
index 481bb8f1..b7c59eca 100755
--- a/.drone/drone.sh
+++ b/.drone/drone.sh
@@ -1,42 +1,30 @@
 #!/bin/bash
 
-# Copyright 2020 Rene Rivera, Sam Darwin
+# Copyright 2022 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt)
+# https://www.boost.org/LICENSE_1_0.txt
 
-set -e
-export TRAVIS_BUILD_DIR=$(pwd)
-export DRONE_BUILD_DIR=$(pwd)
-export TRAVIS_BRANCH=$DRONE_BRANCH
-export VCS_COMMIT_ID=$DRONE_COMMIT
-export GIT_COMMIT=$DRONE_COMMIT
-export REPO_NAME=$DRONE_REPO
-export PATH=~/.local/bin:/usr/local/bin:$PATH
+set -ex
 
-if [ "$DRONE_JOB_BUILDTYPE" == "boost" ]; then
+DRONE_BUILD_DIR=$(pwd)
+export PATH=~/.local/bin:/usr/local/bin:$PATH
 
-echo '==================================> INSTALL'
+BOOST_BRANCH=develop
+if [ "$DRONE_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
 
 cd ..
-git clone -b master --depth 1 https://github.com/boostorg/boost.git boost-root
+git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
 cd boost-root
-git submodule update --init tools/build
-git submodule update --init tools/inspect
-git submodule update --init libs/config
 git submodule update --init tools/boostdep
-mkdir -p libs/leaf
-cp -r $TRAVIS_BUILD_DIR/* libs/leaf
-python tools/boostdep/depinst/depinst.py leaf -I example
+cp -r $DRONE_BUILD_DIR/* libs/$LIBRARY
+python tools/boostdep/depinst/depinst.py $LIBRARY
 ./bootstrap.sh
-./b2 headers
-cd libs/leaf
+./b2 -d0 headers
 
-echo '==================================> SCRIPT'
+echo "Generating single header"
+cd libs/$LIBRARY
+python gen/generate_single_header.py -i include/boost/leaf/detail/all.hpp -p include -o test/leaf.hpp boost/leaf
 
+echo "Testing"
 echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-../../b2 test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release,leaf_debug_diag0,leaf_release_diag0 ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
-../../b2 exception-handling=off rtti=off test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release,leaf_debug_diag0,leaf_release_diag0 ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
-../../b2 threading=single test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release,leaf_debug_diag0,leaf_release_diag0 ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
-../../b2 threading=single exception-handling=off rtti=off test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release,leaf_debug_diag0,leaf_release_diag0 ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
-
-fi
+../../b2 -j3 test $LINKFLAGS toolset=$TOOLSET cxxstd=$CXXSTD ${ADDRMD:+address-model=$ADDRMD} ${UBSAN:+undefined-sanitizer=norecover debug-symbols=on} ${ASAN:+address-sanitizer=norecover debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS} link=shared,static variant=debug,release,leaf_debug_capture0,leaf_release_capture0,leaf_debug_diag0,leaf_release_diag0,leaf_debug_embedded,leaf_release_embedded,leaf_debug_single_header,leaf_release_single_header
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f0d6acd5..5bec173e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -17,24 +17,23 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - toolset: gcc-4.8
-            cxxstd: "11"
-            os: ubuntu-18.04
-            install: g++-4.8
           - toolset: gcc-5
             cxxstd: "11,14,1z"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
             install: g++-5
           - toolset: gcc-6
             cxxstd: "11,14,1z"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
             install: g++-6
           - toolset: gcc-7
             cxxstd: "11,14"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
           - toolset: gcc-8
             cxxstd: "11,14,17,2a"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
             install: g++-8
           - toolset: gcc-9
             cxxstd: "11,14,17,2a"
@@ -44,33 +43,49 @@ jobs:
             os: ubuntu-20.04
             install: g++-10
           - toolset: gcc-11
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: g++-11
+            cxxstd: "11,14,17,20"
+            os: ubuntu-22.04
+          - toolset: gcc-12
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: g++-12
+          - toolset: gcc-13
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-latest
+            container: ubuntu:24.04
+            install: g++-13
+          - toolset: gcc-14
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-latest
+            container: ubuntu:24.04
+            install: g++-14
           - toolset: clang
             compiler: clang++-3.9
             cxxstd: "11,14"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
             install: clang-3.9
           - toolset: clang
             compiler: clang++-4.0
             cxxstd: "11,14"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
             install: clang-4.0
           - toolset: clang
             compiler: clang++-5.0
             cxxstd: "11,14,1z"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
             install: clang-5.0
           - toolset: clang
             compiler: clang++-6.0
             cxxstd: "11,14,17"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
             install: clang-6.0
           - toolset: clang
             compiler: clang++-7
             cxxstd: "11,14,17"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
             install: clang-7
           - toolset: clang
             compiler: clang++-8
@@ -79,47 +94,126 @@ jobs:
             install: clang-8
           - toolset: clang
             compiler: clang++-9
-            cxxstd: "11,14,17,2a"
+            cxxstd: "11,14,17"
             os: ubuntu-20.04
             install: clang-9
           - toolset: clang
             compiler: clang++-10
             cxxstd: "11,14,17,2a"
             os: ubuntu-20.04
-            install: clang-10
           - toolset: clang
             compiler: clang++-11
             cxxstd: "11,14,17,2a"
             os: ubuntu-20.04
-            install: clang-11
           - toolset: clang
             compiler: clang++-12
-            cxxstd: "11,14,17,2a"
+            cxxstd: "11,14,17,20"
             os: ubuntu-20.04
-            install: clang-12
           - toolset: clang
-            cxxstd: "11,14,17,2a"
-            os: macos-10.15
+            compiler: clang++-13
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-13
+          - toolset: clang
+            compiler: clang++-14
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-14
+          - toolset: clang
+            compiler: clang++-15
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-15
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-16
+          - toolset: clang
+            compiler: clang++-17
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-17
+          - toolset: clang
+            compiler: clang++-18
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-18
+          - toolset: clang
+            compiler: clang++-19
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.10
+            os: ubuntu-latest
+            install: clang-19
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-13
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-14
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-15
 
     runs-on: ${{matrix.os}}
 
+    container:
+      image: ${{matrix.container}}
+      volumes:
+        - /node20217:/node20217:rw,rshared
+        - ${{ startsWith(matrix.container, 'ubuntu:1') && '/node20217:/__e/node20:ro,rshared' || ' ' }}
+
+    defaults:
+      run:
+        shell: bash
+
     steps:
-      - uses: actions/checkout@v2
+      - name: Setup container environment
+        if: matrix.container
+        run: |
+          apt-get update
+          apt-get -y install sudo python3 git g++ curl xz-utils
+
+      - name: Install nodejs20glibc2.17
+        if: ${{ startsWith( matrix.container, 'ubuntu:1' ) }}
+        run: |
+          curl -LO https://archives.boost.io/misc/node/node-v20.9.0-linux-x64-glibc-217.tar.xz
+          tar -xf node-v20.9.0-linux-x64-glibc-217.tar.xz --strip-components 1 -C /node20217
+          ldd /__e/node20/bin/node
+
+      - uses: actions/checkout@v4
 
       - name: Install packages
         if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ${{matrix.install}}
 
       - name: Setup Boost
         run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
           REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
           BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
           cd ..
           git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
           cd boost-root
-          cp -r $GITHUB_WORKSPACE/* libs/leaf
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
           git submodule update --init tools/boostdep
-          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" leaf
+          python3 tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
           ./bootstrap.sh
           ./b2 -d0 headers
 
@@ -131,26 +225,30 @@ jobs:
       - name: Generate headers
         run: |
           cd ../boost-root/libs/leaf
-          python gen/generate_single_header.py -i include/boost/leaf/detail/all.hpp -p include -o test/leaf.hpp boost/leaf
+          python3 gen/generate_single_header.py -i include/boost/leaf/detail/all.hpp -p include -o test/leaf.hpp boost/leaf
 
       - name: Run tests
         run: |
           cd ../boost-root
-          ./b2 -j3 libs/leaf/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} link=shared,static variant=debug,release,leaf_debug_leaf_hpp,leaf_release_leaf_hpp,leaf_debug_diag0,leaf_release_diag0,leaf_debug_embedded,leaf_release_embedded
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} link=shared,static variant=debug,release,leaf_debug_capture0,leaf_release_capture0,leaf_debug_diag0,leaf_release_diag0,leaf_debug_embedded,leaf_release_embedded,leaf_debug_single_header,leaf_release_single_header
 
   windows:
     strategy:
       fail-fast: false
       matrix:
         include:
-          - toolset: msvc-14.1
-            cxxstd: "14,17,latest"
-            addrmd: 32,64
-            os: windows-2016
           - toolset: msvc-14.2
-            cxxstd: "14,17,latest"
+            cxxstd: "14,17,20,latest"
             addrmd: 32,64
             os: windows-2019
+          - toolset: msvc-14.3
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: clang-win
+            cxxstd: "14,17,20,latest"
+            addrmd: 64
+            os: windows-2022
           - toolset: gcc
             cxxstd: "11,14,17,2a"
             addrmd: 64
@@ -159,30 +257,37 @@ jobs:
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
       - name: Setup Boost
         shell: cmd
         run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
           if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
           set BOOST_BRANCH=develop
-          if "%GITHUB_BASE_REF%" == "master" set BOOST_BRANCH=master
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
           cd ..
           git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
           cd boost-root
-          xcopy /s /e /q %GITHUB_WORKSPACE% libs\leaf\
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
           git submodule update --init tools/boostdep
-          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" leaf
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
           cmd /c bootstrap
           b2 -d0 headers
 
       - name: Generate headers
         run: |
           cd ../boost-root/libs/leaf
-          python gen/generate_single_header.py -i include/boost/leaf/detail/all.hpp -p include -o test/leaf.hpp boost/leaf
+          python3 gen/generate_single_header.py -i include/boost/leaf/detail/all.hpp -p include -o test/leaf.hpp boost/leaf
 
       - name: Run tests
         shell: cmd
         run: |
           cd ../boost-root
-          b2 -j3 libs/leaf/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release,leaf_debug_leaf_hpp,leaf_release_leaf_hpp,leaf_debug_diag0,leaf_release_diag0,leaf_debug_embedded,leaf_release_embedded
+          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} ${{matrix.embedmanifest}} variant=debug,release,leaf_debug_capture0,leaf_release_capture0,leaf_debug_diag0,leaf_release_diag0,leaf_debug_embedded,leaf_release_embedded,leaf_debug_single_header,leaf_release_single_header
diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml
index 05108aaf..2744801b 100644
--- a/.github/workflows/gh-pages.yml
+++ b/.github/workflows/gh-pages.yml
@@ -4,12 +4,13 @@ on:
   push:
     branches:
       - master
+      - feature/gha_fixes
 
 jobs:
   publish:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
       - name: Install packages
         run: |
@@ -24,6 +25,7 @@ jobs:
           cd boost-root
           cp -r $GITHUB_WORKSPACE/* libs/leaf
           git submodule update --init tools/build
+          git submodule update --init tools/boost_install
           git submodule update --init libs/config
           ./bootstrap.sh
 
@@ -43,8 +45,8 @@ jobs:
           python gen/generate_single_header.py -i include/boost/leaf/detail/all.hpp -p include -o doc/html/leaf.hpp boost/leaf --hash "$REF"
 
       - name: Deploy to GitHub Pages
-        uses: JamesIves/github-pages-deploy-action@3.7.1
+        uses: JamesIves/github-pages-deploy-action@4.0.0
         with:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          BRANCH: gh-pages
-          FOLDER: ../boost-root/libs/leaf/doc/html
+          token: ${{ secrets.GITHUB_TOKEN }}
+          branch: gh-pages
+          folder: ../boost-root/libs/leaf/doc/html
diff --git a/.gitignore b/.gitignore
index c589ffad..84d0e3de 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,13 +7,12 @@
 *.opensdf
 *.db
 *.opendb
-bld/*
+_bld/*
 doc/html/*
 snippets/*
 subprojects/*/
 .vscode/ipch/*
 .vscode/settings.json
 .vscode/c_cpp_properties.json
-benchmark/tl/*
 test/leaf.hpp
 doc/leaf.html
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 68583bd3..00000000
--- a/.travis.yml
+++ /dev/null
@@ -1,422 +0,0 @@
-# Copyright 2016-2018 Peter Dimov
-# Copyright 2018-2022 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://boost.org/LICENSE_1_0.txt)
-
-language: cpp
-
-sudo: false
-
-dist: trusty
-
-python: "2.7"
-
-os:
-  - linux
-  - osx
-
-branches:
-  only:
-    - master
-    - develop
-    - /^feature.*/
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-addons:
-  apt:
-    packages:
-      - g++-4.9
-      - g++-5
-      - g++-6
-      - clang-3.6
-      - clang-3.7
-      - clang-3.8
-      - ruby-full
-      - ninja-build
-
-    sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-precise
-      - llvm-toolchain-precise-3.6
-      - llvm-toolchain-precise-3.7
-      - llvm-toolchain-precise-3.8
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-
-    - os: linux
-      env: DOC=1
-      install:
-        - gem install asciidoctor
-        - gem install asciidoctor-pdf --pre
-        - gem install rouge
-        - cd ..
-        - git clone -b master --depth 1 https://github.com/boostorg/boost.git boost-root
-        - cd boost-root
-        - git submodule update --init tools/build
-        - git submodule update --init libs/config
-        - mkdir -p libs/leaf
-        - cp -r $TRAVIS_BUILD_DIR/* libs/leaf
-        - ./bootstrap.sh
-        - cd libs/leaf
-      script:
-        - |-
-          echo "using asciidoctor ;" > ~/user-config.jam
-        - ../../b2 doc
-      deploy:
-        local-dir: ../boost-root/libs/leaf/doc/html
-        provider: pages
-        skip-cleanup: true
-        github-token: $GH_PAGES_TOKEN
-        keep-history: false
-        on:
-          branch: master
-
-###################################
-
-    - os: osx
-      compiler: clang++
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++ CXXSTD=11,14 UBSAN_OPTIONS=print_stacktrace=1
-
-    - os: osx
-      compiler: clang++
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++ CXXSTD=1z,2a UBSAN_OPTIONS=print_stacktrace=1
-
-    - os: osx
-      osx_image: xcode11.5
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
-
-    - os: osx
-      osx_image: xcode11.4
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
-
-    - os: osx
-      osx_image: xcode11.3
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
-
-    - os: osx
-      osx_image: xcode11.2
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
-
-    - os: osx
-      osx_image: xcode11.1
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
-
-    - os: osx
-      osx_image: xcode11
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
-
-    - os: osx
-      osx_image: xcode10.3
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
-
-    - os: osx
-      osx_image: xcode10.2
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
-
-    - os: osx
-      osx_image: xcode10.1
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
-
-###################################
-
-    - os: linux
-      compiler: g++-9
-      env: UBSAN=1 TOOLSET=gcc COMPILER=g++-9 CXXSTD=11,14 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
-      addons:
-        apt:
-          packages:
-            - g++-9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-9
-      env: UBSAN=1 TOOLSET=gcc COMPILER=g++-9 CXXSTD=17,2a UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
-      addons:
-        apt:
-          packages:
-            - g++-9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-9
-      env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - g++-9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-8
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=11,14
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=11,14
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=11,14
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.9
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=11
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-###################################
-
-    - os: linux
-      compiler: clang++-8
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-8 CXXSTD=11,14 UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - clang-8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-8
-
-    - os: linux
-      compiler: clang++-8
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-8 CXXSTD=17,2a UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - clang-8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-8
-
-    - os: linux
-      dist: xenial
-      compiler: clang++-10
-      env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-10
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      dist: xenial
-      compiler: clang++-9
-      env: TOOLSET=clang COMPILER=clang++-9 CXXSTD=11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-9
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      compiler: clang++-8
-      env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-8
-
-    - os: linux
-      compiler: clang++-7
-      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-7
-
-    - os: linux
-      compiler: clang++-6.0
-      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=11,14,17
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
-
-    - os: linux
-      compiler: clang++-5.0
-      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.9
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.7
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-
-    - os: linux
-      compiler: clang++-3.6
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.6
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.5
-      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.5
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: /usr/bin/clang++
-      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=11
-      addons:
-        apt:
-          packages:
-            - clang-3.4
-
-    - os: linux
-      compiler: /usr/bin/clang++
-      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=11
-      addons:
-        apt:
-          packages:
-            - clang-3.3
-
-###################################
-
-install:
-  - cd ..
-  - git clone -b master --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init tools/inspect
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - mkdir -p libs/leaf
-  - cp -r $TRAVIS_BUILD_DIR/* libs/leaf
-  - python tools/boostdep/depinst/depinst.py leaf -I example
-  - ./bootstrap.sh
-  - ./b2 headers
-  - cd libs/leaf
-
-script:
-  - |-
-    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - ../../b2 test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release,leaf_debug_diag0,leaf_release_diag0 ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
-  - ../../b2 exception-handling=off rtti=off test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release,leaf_debug_diag0,leaf_release_diag0 ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
-  - ../../b2 threading=single test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release,leaf_debug_diag0,leaf_release_diag0 ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
-  - ../../b2 threading=single exception-handling=off rtti=off test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release,leaf_debug_diag0,leaf_release_diag0 ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
-
-notifications:
-  email:
-    on_success: always
diff --git a/.vscode/launch.json b/.vscode/launch.json
index abdc4a4c..6b2e39ae 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -4,12 +4,23 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
+        {
+            "name": "(Windows) Launch",
+            "type": "cppvsdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/_bld/debug/capture_exception_result_async_test",
+            "args": [],
+            "cwd": "${fileDirname}",
+            "stopAtEntry": false,
+            "externalConsole": false
+        },
+
         {
             "name": "(lldb) Launch",
             "type": "cppdbg",
             "request": "launch",
-            "program": "${workspaceFolder}/bld/debug/lua_callback_eh",
-            "args": [ ],
+            "program": "${workspaceFolder}/_bld/debug/capture_exception_result_async_test",
+            "args": [],
             "cwd": "${workspaceFolder}",
             "stopAtEntry": false,
             "externalConsole": false,
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index d844b069..f94f55c3 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -4,15 +4,45 @@
     "version": "2.0.0",
     "tasks": [
         {
-            "label": "Configure Meson build directories",
+            "label": "Setup Meson build directories",
             "type": "shell",
-            "command": "cd ${workspaceRoot} && meson -D leaf_boost_examples=true -D leaf_lua_examples=true bld/debug && meson -D leaf_boost_examples=true -D leaf_lua_examples=true -D leaf_hpp=true bld/debug_leaf_hpp && meson -D leaf_boost_examples=true -D leaf_lua_examples=true bld/release --buildtype release && meson -D leaf_boost_examples=true -D leaf_lua_examples=true -D leaf_hpp=true bld/release_leaf_hpp --buildtype release && meson -D leaf_diagnostics=0 -D cpp_eh=none -D b_ndebug=true -D b_lto=true -D leaf_enable_benchmarks=true bld/benchmark --buildtype release",
+            "command": "cd ${workspaceRoot} && meson setup -D leaf_boost_examples=true -D leaf_lua_examples=true _bld/debug && meson setup -D leaf_boost_examples=false -D single_header=true _bld/debug_single_header && meson setup -D leaf_boost_examples=true -D leaf_lua_examples=true _bld/release --buildtype release && meson setup -D single_header=true _bld/release_single_header --buildtype release",
             "problemMatcher": []
         },
         {
-            "label": "Configure Meson build directories (no Boost)",
+            "label": "Setup Meson build directories (no exceptions)",
             "type": "shell",
-            "command": "cd ${workspaceRoot} && meson -D leaf_lua_examples=true bld/debug && meson -D leaf_lua_examples=true -D leaf_hpp=true bld/debug_leaf_hpp && meson -D leaf_lua_examples=true bld/release --buildtype release && meson -D leaf_lua_examples=true -D leaf_hpp=true bld/release_leaf_hpp --buildtype release",
+            "command": "cd ${workspaceRoot} && meson setup -D cpp_eh=none -D leaf_boost_examples=true -D leaf_lua_examples=true _bld/debug && meson setup -D cpp_eh=none -D leaf_boost_examples=true -D single_header=true _bld/debug_single_header && meson setup -D cpp_eh=none -D leaf_boost_examples=true -D leaf_lua_examples=true _bld/release --buildtype release && meson setup -D cpp_eh=none -D leaf_boost_examples=true -D single_header=true _bld/release_single_header --buildtype release",
+            "problemMatcher": []
+        },
+        {
+            "label": "Setup Meson build directories (no diagnostics)",
+            "type": "shell",
+            "command": "cd ${workspaceRoot} && meson setup -D leaf_diagnostics=0 -D leaf_boost_examples=true -D leaf_lua_examples=true _bld/debug && meson setup -D leaf_diagnostics=0 -D leaf_boost_examples=true -D single_header=true _bld/debug_single_header && meson setup -D leaf_diagnostics=0 -D leaf_boost_examples=true -D leaf_lua_examples=true _bld/release --buildtype release && meson setup -D leaf_diagnostics=0 -D leaf_boost_examples=true -D single_header=true _bld/release_single_header --buildtype release",
+            "problemMatcher": []
+        },
+        {
+            "label": "Setup Meson build directories (no capture)",
+            "type": "shell",
+            "command": "cd ${workspaceRoot} && meson setup -D leaf_capture=0 -D leaf_boost_examples=true -D leaf_lua_examples=true _bld/debug && meson setup -D leaf_capture=0 -D leaf_boost_examples=true -D single_header=true _bld/debug_single_header && meson setup -D leaf_capture=0 -D leaf_boost_examples=true -D leaf_lua_examples=true _bld/release --buildtype release && meson setup -D leaf_capture=0 -D leaf_boost_examples=true -D single_header=true _bld/release_single_header --buildtype release",
+            "problemMatcher": []
+        },
+        {
+            "label": "Setup Meson build directories (no Boost)",
+            "type": "shell",
+            "command": "cd ${workspaceRoot} && meson setup -D leaf_lua_examples=true _bld/debug && meson setup -D single_header=true _bld/debug_single_header && meson setup -D leaf_lua_examples=true _bld/release --buildtype release && meson setup -D single_header=true _bld/release_single_header --buildtype release",
+            "problemMatcher": []
+        },
+        {
+            "label": "Setup Meson build directories (test embedded)",
+            "type": "shell",
+            "command": "cd ${workspaceRoot} && meson setup -D leaf_embedded=true -D leaf_diagnostics=0 _bld/debug && meson setup -D leaf_embedded=true -D leaf_diagnostics=0 -D single_header=true _bld/debug_single_header && meson setup -D leaf_embedded=true -D leaf_diagnostics=0 _bld/release --buildtype release && meson setup -D leaf_embedded=true -D leaf_diagnostics=0 -D single_header=true _bld/release_single_header --buildtype release",
+            "problemMatcher": []
+        },
+        {
+            "label": "Setup Meson build directories (test embedded, no exceptions)",
+            "type": "shell",
+            "command": "cd ${workspaceRoot} && meson setup -D cpp_eh=none -D leaf_embedded=true -D leaf_diagnostics=0 _bld/debug && meson setup -D cpp_eh=none -D leaf_embedded=true -D leaf_diagnostics=0 -D single_header=true _bld/debug_single_header && meson setup -D cpp_eh=none -D leaf_embedded=true -D leaf_diagnostics=0 _bld/release --buildtype release && meson setup -D cpp_eh=none -D leaf_embedded=true -D leaf_diagnostics=0 -D single_header=true _bld/release_single_header --buildtype release",
             "problemMatcher": []
         },
         {
@@ -28,12 +58,12 @@
             },
             "label": "Build all unit tests and examples (debug)",
             "type": "shell",
-            "command": "cd ${workspaceRoot}/bld/debug && ninja",
+            "command": "cd ${workspaceRoot}/_bld/debug && ninja",
             "problemMatcher": {
                 "base": "$gcc",
                 "fileLocation": [
                     "relative",
-                    "${workspaceRoot}/bld/debug"
+                    "${workspaceRoot}/_bld/debug"
                 ]
             }
         },
@@ -44,12 +74,12 @@
             "dependsOn": [
                 "Generate leaf.hpp"
             ],
-            "command": "cd ${workspaceRoot}/bld/debug_leaf_hpp && ninja && meson test && cd ${workspaceRoot}/bld/debug && ninja && meson test",
+            "command": "cd ${workspaceRoot}/_bld/debug && ninja && meson test && cd ${workspaceRoot}/_bld/debug && ninja && meson test",
             "problemMatcher": {
                 "base": "$gcc",
                 "fileLocation": [
                     "relative",
-                    "${workspaceRoot}/bld/debug"
+                    "${workspaceRoot}/_bld/debug"
                 ]
             }
         },
@@ -60,12 +90,12 @@
             "dependsOn": [
                 "Generate leaf.hpp"
             ],
-            "command": "cd ${workspaceRoot}/bld/release && ninja && meson test && cd ${workspaceRoot}/bld/release_leaf_hpp && ninja && meson test",
+            "command": "cd ${workspaceRoot}/_bld/release && ninja && meson test && cd ${workspaceRoot}/_bld/release_single_header && ninja && meson test",
             "problemMatcher": {
                 "base": "$gcc",
                 "fileLocation": [
                     "relative",
-                    "${workspaceRoot}/bld/release"
+                    "${workspaceRoot}/_bld/release"
                 ]
             }
         },
@@ -76,15 +106,15 @@
             "dependsOn": [
                 "Generate leaf.hpp"
             ],
-            "command": "../../b2 test link=shared,static variant=debug,release,leaf_debug_diag0,leaf_release_diag0,leaf_debug_leaf_hpp,leaf_release_leaf_hpp exception-handling=on,off cxxstd=11,14,1z,17 && ../../b2 test link=shared,static variant=debug,release,leaf_debug_diag0,leaf_release_diag0,leaf_debug_leaf_hpp,leaf_release_leaf_hpp,leaf_debug_embedded,leaf_release_embedded exception-handling=off rtti=off cxxstd=11,14,1z,17",
+            "command": "../../b2 test link=shared,static variant=debug,release,leaf_debug_diag0,leaf_release_diag0,leaf_debug_single_header,leaf_release_single_header,leaf_debug_embedded,leaf_release_embedded exception-handling=off rtti=off cxxstd=11,14,1z,17 && ../../b2 test link=shared,static variant=debug,release,leaf_debug_diag0,leaf_release_diag0,leaf_debug_single_header,leaf_release_single_header exception-handling=on,off cxxstd=11,14,1z,17",
             "windows": {
-                "command": "..\\..\\b2 test link=shared,static variant=debug,release,leaf_debug_diag0,leaf_release_diag0,leaf_debug_leaf_hpp,leaf_release_leaf_hpp exception-handling=on,off cxxstd=14,17,latest && ..\\..\\b2 test link=shared,static variant=debug,release,leaf_debug_diag0,leaf_release_diag0,leaf_debug_leaf_hpp,leaf_release_leaf_hpp,leaf_debug_embedded,leaf_release_embedded exception-handling=off rtti=off cxxstd=14,17,latest",
+                "command": "..\\..\\b2 test link=shared,static variant=debug,release,leaf_debug_diag0,leaf_release_diag0,leaf_debug_single_header,leaf_release_single_header,leaf_debug_embedded,leaf_release_embedded exception-handling=off rtti=off cxxstd=14,17,latest && ..\\..\\b2 test link=shared,static variant=debug,release,leaf_debug_diag0,leaf_release_diag0,leaf_debug_single_header,leaf_release_single_header exception-handling=on,off cxxstd=14,17,latest",
             },
             "problemMatcher": {
                 "base": "$gcc",
                 "fileLocation": [
                     "relative",
-                    "${workspaceRoot}/bld/release"
+                    "${workspaceRoot}/_bld/release"
                 ]
             }
         },
@@ -95,12 +125,15 @@
             },
             "label": "Test current editor file",
             "type": "shell",
-            "command": "cd ${workspaceRoot}/bld/debug && ninja && { meson test ${fileBasenameNoExtension} || cat ./meson-logs/testlog.txt }",
+            "command": "cd ${workspaceRoot}/_bld/debug && ninja && {meson test ${fileBasenameNoExtension} || cat ./meson-logs/testlog.txt}",
+            "windows": {
+                "command": "cd ${workspaceRoot}/_bld/debug && ninja && (meson test ${fileBasenameNoExtension} || cat ./meson-logs/testlog.txt)",
+            },
             "problemMatcher": {
                 "base": "$gcc",
                 "fileLocation": [
                     "relative",
-                    "${workspaceRoot}/bld/debug"
+                    "${workspaceRoot}/_bld/debug"
                 ]
             }
         }
diff --git a/README.md b/README.md
index a8241876..c204a980 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@ https://boostorg.github.io/leaf/
 ## Features
 
 * Portable single-header format, no dependencies.
-* Tiny code size when configured for embedded development.
+* Tiny code size, configurable for embedded development.
 * No dynamic memory allocations, even with very large payloads.
 * Deterministic unbiased efficiency on the "happy" path and the "sad" path.
 * Error objects are handled in constant time, independent of call stack depth.
@@ -26,6 +26,6 @@ https://boostorg.github.io/leaf/
 Besides GitHub, there are two other distribution channels:
 
 * LEAF is included in official [Boost](https://www.boost.org/) releases, starting with Boost 1.75.
-* For maximum portability, the library is also available in single-header format: simply download [leaf.hpp](https://boostorg.github.io/leaf/leaf.hpp) (direct download link).
+* For maximum portability, the library is also available in single-header format: [leaf.hpp](https://raw.githubusercontent.com/boostorg/leaf/gh-pages/leaf.hpp).
 
-Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc. Distributed under the http://www.boost.org/LICENSE_1_0.txt[Boost Software License, Version 1.0].
+Copyright 2018-2024 Emil Dotchevski and Reverge Studios, Inc. Distributed under the http://www.boost.org/LICENSE_1_0.txt[Boost Software License, Version 1.0].
diff --git a/appveyor.yml b/appveyor.yml
deleted file mode 100644
index 0b3a7bd3..00000000
--- a/appveyor.yml
+++ /dev/null
@@ -1,44 +0,0 @@
-# Copyright 2016, 2017 Peter Dimov
-# Copyright 2018-2022 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://boost.org/LICENSE_1_0.txt)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1,clang-win
-      CXXSTD: 14,17
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      TOOLSET: msvc-14.2
-      CXXSTD: 14,17
-
-install:
-  - set BOOST_BRANCH=develop
-  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
-  - cd ..
-  - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init tools/boost_install
-  - git submodule update --init libs/config
-  - git submodule update --init libs/headers
-  - git submodule update --init tools/boostdep
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\leaf\
-  - python tools/boostdep/depinst/depinst.py leaf
-  - cmd /c bootstrap
-  - b2 headers
-
-build: off
-
-test_script:
-  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - b2 -j3 libs/leaf/test toolset=%TOOLSET% exception-handling=on,off variant=debug,release,leaf_debug_diag0,leaf_release_diag0 define=_CRT_SECURE_NO_WARNINGS %CXXSTD%
diff --git a/benchmark/b.bat b/benchmark/b.bat
deleted file mode 100644
index 1f475c54..00000000
--- a/benchmark/b.bat
+++ /dev/null
@@ -1,6 +0,0 @@
-ninja
-del benchmark.csv
-deep_stack_leaf
-deep_stack_tl
-deep_stack_result
-deep_stack_outcome
diff --git a/benchmark/b.sh b/benchmark/b.sh
deleted file mode 100755
index dcd010e1..00000000
--- a/benchmark/b.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-ninja
-rm benchmark.csv
-./deep_stack_leaf
-./deep_stack_tl
-./deep_stack_result
-./deep_stack_outcome
diff --git a/benchmark/benchmark.md b/benchmark/benchmark.md
deleted file mode 100644
index 0ae9b332..00000000
--- a/benchmark/benchmark.md
+++ /dev/null
@@ -1,471 +0,0 @@
-# Benchmark
-
-The LEAF github repository contains two similar benchmarking programs, one using LEAF, the other configurable to use `tl::expected` or Boost Outcome, that simulate transporting error objects across 10 levels of stack frames, measuring the performance of the three libraries.
-
-Links:
-* LEAF: https://boostorg.github.io/leaf
-* `tl::expected`: https://github.com/TartanLlama/expected
-* Boost Outcome V2: https://www.boost.org/doc/libs/release/libs/outcome/doc/html/index.html
-
-## Library design considerations
-
-LEAF serves a similar purpose to other error handling libraries, but its design is very different. The benchmarks are comparing apples and oranges.
-
-The main design difference is that when using LEAF, error objects are not communicated in return values. In case of a failure, the `leaf::result<T>` object transports only an `int`, the unique error ID.
-
-Error objects skip the error neutral functions in the call stack and get moved directly to the the error handling scope that needs them. This mechanism does not depend on RVO or any other optimization: as soon as the program passes an error object to LEAF, it moves it to the correct error handling scope.
-
-Other error handling libraries instead couple the static type of the return value of *all* error neutral functions with the error type an error reporting function may return. This approach suffers from the same problems as statically-enforced exception specifications:
-
-* It's difficult to use in polymorphic function calls, and
-* It  impedes interoperability between the many different error types any non-trivial program must handle.
-
-(The Boost Outcome library is also capable of avoiding such excessive coupling, by passing for the third `P` argument in the `outcome<T, E, P>` template a pointer that erases the exact static type of the object being transported. However, this would require a dynamic memory allocation).
-
-## Syntax
-
-The most common check-only use case looks almost identically in LEAF and in Boost Outcome (`tl::expected` lacks a similar macro):
-
-```c++
-// Outcome
-{
-  BOOST_OUTCOME_TRY(v, f()); // Check for errors, forward failures to the caller
-  // If control reaches here, v is the successful result (the call succeeded).
-}
-```
-
-```c++
-// LEAF
-{
-  BOOST_LEAF_AUTO(v, f()); // Check for errors, forward failures to the caller
-  // If control reaches here, v is the successful result (the call succeeded).
-}
-```
-
-When we want to handle failures, in Boost Outcome and in `tl::expected`, accessing the error object (which is always stored in the return value) is a simple continuation of the error check:
-
-```c++
-// Outcome, tl::expected
-if( auto r = f() )
-{
-  auto v = r.value();
-  // No error, use v
-}
-else
-{ // Error!
-  switch( r.error() )
-  {
-  error_enum::error1:
-    /* handle error_enum::error1 */
-    break;
-
-  error_enum::error2:
-    /* handle error_enum::error2 */
-    break;
-
-  default:
-    /* handle any other failure */
-  }
-}
-```
-
-When using LEAF, we must explicitly state our intention to handle errors, not just check for failures:
-
-```c++
-// LEAF
-leaf::try_handle_all
-
-  []() -> leaf::result<T>
-  {
-    BOOST_LEAF_AUTO(v, f());
-    // No error, use v
-  },
-
-  []( leaf::match<error_enum, error_enum::error1> )
-  {
-    /* handle error_enum::error1 */
-  },
-
-  []( leaf::match<error_enum, error_enum::error2> )
-  {
-    /* handle error_enum::error2 */
-  },
-
-  []
-  {
-    /* handle any other failure */
-  } );
-```
-
-The use of `try_handle_all` reserves storage on the stack for the error object types being handled (in this case, `error_enum`). If the failure is either `error_enum::error1` or `error_enum::error2`, the matching error handling lambda is invoked.
-
-## Code generation considerations
-
-Benchmarking C++ programs is tricky, because we want to prevent the compiler from optimizing out things it shouldn't normally be able to optimize in a real program, yet we don't want to interfere with "legitimate" optimizations.
-
-The primary approach we use to prevent the compiler from optimizing everything out to nothing is to base all computations on a call to `std::rand()`.
-
-When benchmarking error handling, it makes sense to measure the time it takes to return a result or error across multiple stack frames. This calls for disabling inlining.
-
-The technique used to disable inlining in this benchmark is to mark functions with `__attribute__((noinline))`. This is imperfect, because optimizers can still peek into the body of the function and optimize things out, as is seen in this example:
-
-```c++
-__attribute__((noinline)) int val() {return 42;}
-
-int main()
-{
-  return val();
-}
-```
-
-Which on clang 9 outputs:
-
-```x86asm
-val():
-        mov     eax, 42
-          ret
-main:
-        mov     eax, 42
-        ret
-```
-
-It does not appear that anything like this is occurring in our case, but it is still a possibility.
-
-> NOTES:
->
-> - The benchmarks are compiled with exception handling disabled.
-> - LEAF is able to work with external `result<>` types. The benchmark uses `leaf::result<T>`.
-
-## Show me the code!
-
-The following source:
-
-```C++
-leaf::result<int> f();
-
-leaf::result<int> g()
-{
-  BOOST_LEAF_AUTO(x, f());
-  return x+1;
-}
-```
-
-Generates this code on clang ([Godbolt](https://godbolt.org/z/v58drTPhq)):
-
-```x86asm
-g():                                  # @g()
-        push    rbx
-        sub     rsp, 32
-        mov     rbx, rdi
-        lea     rdi, [rsp + 8]
-        call    f()
-        mov     eax, dword ptr [rsp + 24]
-        mov     ecx, eax
-        and     ecx, 3
-        cmp     ecx, 3
-        jne     .LBB0_1
-        mov     eax, dword ptr [rsp + 8]
-        add     eax, 1
-        mov     dword ptr [rbx], eax
-        mov     eax, 3
-        jmp     .LBB0_3
-.LBB0_1:
-        cmp     ecx, 2
-        jne     .LBB0_3
-        mov     rax, qword ptr [rsp + 8]
-        mov     qword ptr [rbx], rax
-        mov     rax, qword ptr [rsp + 16]
-        mov     qword ptr [rbx + 8], rax
-        mov     eax, 2
-.LBB0_3:
-        mov     dword ptr [rbx + 16], eax
-        mov     rax, rbx
-        add     rsp, 32
-        pop     rbx
-        ret
-```
-
-> Description:
->
-> * The happy path can be recognized by the `add eax, 1` instruction generated for `x + 1`.
->
-> * `.LBB0_3`: Regular failure; the returned `result<T>` object holds only the `int` discriminant.
->
-> * `.LBB0_1`: Failure; the returned `result<T>` holds the `int` discriminant and a `std::shared_ptr<leaf::polymorphic_context>` (used to hold error objects transported from another thread).
-
-Note that `f` is undefined, hence the `call` instruction. Predictably, if we provide a trivial definition for `f`:
-
-```C++
-leaf::result<int> f()
-{
-  return 42;
-}
-
-leaf::result<int> g()
-{
-  BOOST_LEAF_AUTO(x, f());
-  return x+1;
-}
-```
-
-We get:
-
-```x86asm
-g():                                  # @g()
-          mov     rax, rdi
-          mov     dword ptr [rdi], 43
-          mov     dword ptr [rdi + 16], 3
-          ret
-```
-
-With a less trivial definition of `f`:
-
-```C++
-leaf::result<int> f()
-{
-  if( rand()%2 )
-    return 42;
-  else
-    return leaf::new_error();
-}
-
-leaf::result<int> g()
-{
-  BOOST_LEAF_AUTO(x, f());
-  return x+1;
-}
-```
-
-We get ([Godbolt](https://godbolt.org/z/87Kezzrs4)):
-
-```x86asm
-g():                                  # @g()
-        push    rbx
-        mov     rbx, rdi
-        call    rand
-        test    al, 1
-        jne     .LBB1_2
-        mov     eax, 4
-        lock            xadd    dword ptr [rip + boost::leaf::leaf_detail::id_factory<void>::counter], eax
-        add     eax, 4
-        mov     dword ptr fs:[boost::leaf::leaf_detail::id_factory<void>::current_id@TPOFF], eax
-        and     eax, -4
-        or      eax, 1
-        mov     dword ptr [rbx + 16], eax
-        mov     rax, rbx
-        pop     rbx
-        ret
-.LBB1_2:
-        mov     dword ptr [rbx], 43
-        mov     eax, 3
-        mov     dword ptr [rbx + 16], eax
-        mov     rax, rbx
-        pop     rbx
-        ret
-```
-
-Above, the call to `f()` is inlined:
-
-* `.LBB1_2`: Success
-* The atomic `add` is from the initial error reporting machinery in LEAF, generating a unique error ID for the error being reported.
-
-## Benchmark matrix dimensions
-
-The benchmark matrix has 2 dimensions:
-
-1. Error object type:
-
-    a. The error object transported in case of a failure is of type `e_error_code`, which is a simple `enum`.
-
-    b. The error object transported in case of a failure is of type `struct e_system_error { e_error_code value; std::string what; }`.
-
-    c. The error object transported in case of a failure is of type `e_heavy_payload`, a `struct` of size 4096.
-
-2. Error rate: 2%, 98%
-
-Now, transporting a large error object might seem unusual, but this is only because it is impractical to return a large object as *the* return value in case of an error. LEAF has two features that make communicating any, even large error objects, practical:
-
-* The return type of error neutral functions is not coupled with the error object types that may be reported. This means that in case of a failure, any function can easily contribute any error information it has available.
-
-* LEAF will only bother with transporting a given error object if an active error handling scope needs it. This means that library functions can and should contribute any and all relevant information when reporting a failure, because if the program doesn't need it, it will simply be discarded.
-
-## Source code
-
-[deep_stack_leaf.cpp](deep_stack_leaf.cpp)
-
-[deep_stack_other.cpp](deep_stack_other.cpp)
-
-## Godbolt
-
-Godbolt has built-in support for Boost (Outcome/LEAF), but `tl::expected` both provide a single header, which makes it very easy to use them online as well. To see the generated code for the benchmark program, you can copy and paste the following into Godbolt:
-
-`leaf::result<T>` ([godbolt](https://godbolt.org/z/1hqqnfhMf))
-
-```c++
-#include "https://raw.githubusercontent.com/boostorg/leaf/master/benchmark/deep_stack_leaf.cpp"
-```
-
-`tl::expected<T, E>` ([godbolt](https://godbolt.org/z/6dfcdsPcc))
-
-```c++
-#include "https://raw.githubusercontent.com/TartanLlama/expected/master/include/tl/expected.hpp"
-#include "https://raw.githubusercontent.com/boostorg/leaf/master/benchmark/deep_stack_other.cpp"
-```
-
-`outcome::result<T, E>` ([godbolt](https://godbolt.org/z/jMEfGMrW9))
-
-```c++
-#define BENCHMARK_WHAT 1
-#include "https://raw.githubusercontent.com/boostorg/leaf/master/benchmark/deep_stack_other.cpp"
-```
-
-## Build options
-
-To build both versions of the benchmark program, the compilers are invoked using the following command line options:
-
-* `-std=c++17`: Required by other libraries (LEAF only requires C++11);
-* `-fno-exceptions`: Disable exception handling;
-* `-O3`: Maximum optimizations;
-* `-DNDEBUG`: Disable asserts.
-
-In addition, the LEAF version is compiled with:
-
-* `-DBOOST_LEAF_CFG_DIAGNOSTICS=0`: Disable diagnostic information for error objects not recognized by the program. This is a debugging feature, see [Configuration Macros](https://boostorg.github.io/leaf/#configuration).
-
-## Results
-
-Below is the output the benchmark programs running on an old MacBook Pro. The tables show the elapsed time for 10,000,000 iterations of returning a result across 10 stack frames, depending on the error type and the rate of failures. In addition, the programs generate a `benchmark.csv` file in the current working directory.
-
-### gcc 9.2.0:
-
-`leaf::result<T>`:
-
-Error type      |  2% (μs) | 98% (μs)
-----------------|---------:|--------:
-e_error_code    |   594965 |   545882
-e_system_error  |   614688 |  1203154
-e_heavy_payload |   736701 |  7397756
-
-`tl::expected<T, E>`:
-
-Error type      |  2% (μs) | 98% (μs)
-----------------|---------:|--------:
-e_error_code    |   921410 |   820757
-e_system_error  |   670191 |  5593513
-e_heavy_payload |  1331724 | 31560432
-
-`outcome::result<T, E>`:
-
-Error type      |  2% (μs) | 98% (μs)
-----------------|---------:|--------:
-e_error_code    |  1080512 |   773206
-e_system_error  |   577403 |  1201693
-e_heavy_payload | 13222387 | 32104693
-
-`outcome::outcome<T, E>`:
-
-Error type      |  2% (μs) | 98% (μs)
-----------------|---------:|--------:
-e_error_code    |   832916 |  1170731
-e_system_error  |   947298 |  2330392
-e_heavy_payload | 13342292 | 33837583
-
-### clang 11.0.0:
-
-`leaf::result<T>`:
-
-Error type      |  2% (μs) | 98% (μs)
-----------------|---------:|--------:
-e_error_code    |   570847 |   493538
-e_system_error  |   592685 |   982799
-e_heavy_payload |   713966 |  5144523
-
-`tl::expected<T, E>`:
-
-Error type      |  2% (μs) | 98% (μs)
-----------------|---------:|--------:
-e_error_code    |   461639 |   312849
-e_system_error  |   620479 |  3534689
-e_heavy_payload |  1037434 | 16078669
-
-`outcome::result<T, E>`:
-
-Error type      |  2% (μs) | 98% (μs)
-----------------|---------:|--------:
-e_error_code    |   431219 |   446854
-e_system_error  |   589456 |  1712739
-e_heavy_payload | 12387405 | 16216894
-
-`outcome::outcome<T, E>`:
-
-Error type      |  2% (μs) | 98% (μs)
-----------------|---------:|--------:
-e_error_code    |   711412 |  1477505
-e_system_error  |   835691 |  2374919
-e_heavy_payload | 13289404 | 29785353
-
-### msvc 19.24.28314:
-
-`leaf::result<T>`:
-
-Error type      |  2% (μs) | 98% (μs)
-----------------|---------:|--------:
-e_error_code    |  1205327 |  1449117
-e_system_error  |  1290277 |  2332414
-e_heavy_payload |  1503103 | 13682308
-
-`tl::expected<T, E>`:
-
-Error type      |  2% (μs) | 98% (μs)
-----------------|---------:|--------:
-e_error_code    |   938839 |   867296
-e_system_error  |  1455627 |  8943881
-e_heavy_payload |  2637494 | 49212901
-
-`outcome::result<T, E>`:
-
-Error type      |  2% (μs) | 98% (μs)
-----------------|---------:|--------:
-e_error_code    |   935331 |  1202475
-e_system_error  |  1228944 |  2269680
-e_heavy_payload | 15239084 | 55618460
-
-`outcome::outcome<T, E>`:
-
-Error type      |  2% (μs) | 98% (μs)
-----------------|---------:|--------:
-e_error_code    |  1472035 |  2529057
-e_system_error  |  1997971 |  4004965
-e_heavy_payload | 16027423 | 64572924
-
-## Charts
-
-The charts below are generated from the results from the previous section, converted from elapsed time in microseconds to millions of calls per second.
-
-### gcc 9.2.0:
-
-![](gcc_e_error_code.png)
-
-![](gcc_e_system_error.png)
-
-![](gcc_e_heavy_payload.png)
-
-### clang 11.0.0:
-
-![](clang_e_error_code.png)
-
-![](clang_e_system_error.png)
-
-![](clang_e_heavy_payload.png)
-
-### msvc 19.24.28314:
-
-![](msvc_e_error_code.png)
-
-![](msvc_e_system_error.png)
-
-![](msvc_e_heavy_payload.png)
-
-## Thanks
-
-Thanks for the valuable feedback: Peter Dimov, Glen Fernandes, Sorin Fetche, Niall Douglas, Ben Craig, Vinnie Falco, Jason Dictos
diff --git a/benchmark/clang_e_error_code.png b/benchmark/clang_e_error_code.png
deleted file mode 100644
index 94a5ee6d..00000000
Binary files a/benchmark/clang_e_error_code.png and /dev/null differ
diff --git a/benchmark/clang_e_heavy_payload.png b/benchmark/clang_e_heavy_payload.png
deleted file mode 100644
index 88004d5f..00000000
Binary files a/benchmark/clang_e_heavy_payload.png and /dev/null differ
diff --git a/benchmark/clang_e_system_error.png b/benchmark/clang_e_system_error.png
deleted file mode 100644
index 267f4ec9..00000000
Binary files a/benchmark/clang_e_system_error.png and /dev/null differ
diff --git a/benchmark/deep_stack_leaf.cpp b/benchmark/deep_stack_leaf.cpp
deleted file mode 100644
index 1c5676a7..00000000
--- a/benchmark/deep_stack_leaf.cpp
+++ /dev/null
@@ -1,276 +0,0 @@
-// Copyright 2018-2022 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)
-
-// See benchmark.md
-
-#include <boost/leaf.hpp>
-
-#ifndef BOOST_LEAF_NO_EXCEPTIONS
-#   error Please disable exception handling.
-#endif
-
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-#   error Please disable diagnostics.
-#endif
-
-#ifdef _MSC_VER
-#   define NOINLINE __declspec(noinline)
-#   define ALWAYS_INLINE __forceinline
-#else
-#   define NOINLINE __attribute__((noinline))
-#   define ALWAYS_INLINE __attribute__((always_inline)) inline
-#endif
-
-#include <cstring>
-#include <cstdlib>
-#include <cassert>
-#include <chrono>
-#include <iostream>
-#include <fstream>
-#include <iomanip>
-#include <numeric>
-#include <algorithm>
-#include <system_error>
-#include <array>
-
-namespace boost
-{
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e )
-    {
-        std::cerr << "Terminating due to a C++ exception under BOOST_LEAF_NO_EXCEPTIONS: " << e.what();
-        std::terminate();
-    }
-
-    struct source_location;
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e, boost::source_location const & )
-    {
-        throw_exception(e);
-    }
-}
-
-//////////////////////////////////////
-
-namespace leaf = boost::leaf;
-
-#define USING_RESULT_TYPE "leaf::result<T>"
-
-//////////////////////////////////////
-
-enum class e_error_code
-{
-    ec0, ec1, ec2, ec3
-};
-
-struct e_system_error
-{
-    int value;
-    std::string what;
-};
-
-struct e_heavy_payload
-{
-    std::array<char, 4096> value;
-};
-
-template <class E>
-leaf::error_id make_error() noexcept;
-
-template <>
-inline leaf::error_id make_error<e_error_code>() noexcept
-{
-    switch(std::rand()%4)
-    {
-        default: return leaf::new_error(e_error_code::ec0);
-        case 1: return leaf::new_error(e_error_code::ec1);
-        case 2: return leaf::new_error(e_error_code::ec2);
-        case 3: return leaf::new_error(e_error_code::ec3);
-    }
-}
-
-template <>
-inline leaf::error_id make_error<std::error_code>() noexcept
-{
-    return std::error_code(std::rand(), std::system_category());
-}
-
-template <>
-inline leaf::error_id make_error<e_system_error>() noexcept
-{
-    return leaf::new_error( e_system_error { std::rand(), std::string(std::rand()%32, ' ') } );
-}
-
-template <>
-inline leaf::error_id make_error<e_heavy_payload>() noexcept
-{
-    e_heavy_payload e;
-    std::fill(e.value.begin(), e.value.end(), std::rand());
-    return leaf::new_error(e);
-}
-
-inline bool should_fail( int failure_rate ) noexcept
-{
-    assert(failure_rate>=0);
-    assert(failure_rate<=100);
-    return (std::rand()%100) < failure_rate;
-}
-
-inline int handle_error( e_error_code e ) noexcept
-{
-    return int(e);
-}
-
-inline int handle_error( std::error_code const & e ) noexcept
-{
-    return e.value();
-}
-
-inline int handle_error( e_system_error const & e ) noexcept
-{
-    return e.value + e.what.size();
-}
-
-inline int handle_error( e_heavy_payload const & e ) noexcept
-{
-    return std::accumulate(e.value.begin(), e.value.end(), 0);
-}
-
-//////////////////////////////////////
-
-// This is used to change the "success" type at each level.
-// Generally, functions return values of different types.
-template <int N, class E, bool Odd = N%2>
-struct select_result_type;
-
-template <int N, class E>
-struct select_result_type<N, E, true>
-{
-    using type = leaf::result<int>; // Does not depend on E
-};
-
-template <int N, class E>
-struct select_result_type<N, E, false>
-{
-    using type = leaf::result<float>; // Does not depend on E
-};
-
-template <int N, class E>
-using select_result_t = typename select_result_type<N, E>::type;
-
-//////////////////////////////////////
-
-template <int N, class E>
-struct benchmark
-{
-    using e_type = E;
-
-    NOINLINE static select_result_t<N, E> f( int failure_rate ) noexcept
-    {
-        BOOST_LEAF_AUTO(x, (benchmark<N-1, E>::f(failure_rate)));
-        return x+1;
-    }
-};
-
-template <class E>
-struct benchmark<1, E>
-{
-    using e_type = E;
-
-    NOINLINE static select_result_t<1, E> f( int failure_rate ) noexcept
-    {
-        if( should_fail(failure_rate) )
-            return make_error<E>();
-        else
-            return std::rand();
-    }
-};
-
-//////////////////////////////////////
-
-template <class Benchmark>
-NOINLINE int runner( int failure_rate ) noexcept
-{
-    return leaf::try_handle_all(
-        [=]
-        {
-            return Benchmark::f(failure_rate);
-        },
-        []( typename Benchmark::e_type const & e )
-        {
-            return handle_error(e);
-        },
-        []
-        {
-            return -1;
-        } );
-}
-
-//////////////////////////////////////
-
-std::fstream append_csv()
-{
-    if( FILE * f = fopen("benchmark.csv","rb") )
-    {
-        fclose(f);
-        return std::fstream("benchmark.csv", std::fstream::out | std::fstream::app);
-    }
-    else
-    {
-        std::fstream fs("benchmark.csv", std::fstream::out | std::fstream::app);
-        fs << "\"Result Type\",2%,98%\n";
-        return fs;
-    }
-}
-
-template <class F>
-int print_elapsed_time( int iteration_count, F && f )
-{
-    auto start = std::chrono::steady_clock::now();
-    int val = 0;
-    for( int i = 0; i!=iteration_count; ++i )
-        val += std::forward<F>(f)();
-    auto stop = std::chrono::steady_clock::now();
-    int elapsed = std::chrono::duration_cast<std::chrono::microseconds>(stop-start).count();
-    std::cout << std::right << std::setw(9) << elapsed;
-    append_csv() << ',' << elapsed;
-    return val;
-}
-
-//////////////////////////////////////
-
-template <int Depth, class E>
-int benchmark_type( char const * type_name, int iteration_count )
-{
-    int x=0;
-    append_csv() << "\"" USING_RESULT_TYPE "\"";
-    std::cout << '\n' << std::left << std::setw(16) << type_name << '|';
-    std::srand(0);
-    x += print_elapsed_time( iteration_count, [] { return runner<benchmark<Depth, E>>(2); } );
-    std::cout << " |";
-    std::srand(0);
-    x += print_elapsed_time( iteration_count, [] { return runner<benchmark<Depth, E>>(98); } );
-    append_csv() << '\n';
-    return x;
-}
-
-//////////////////////////////////////
-
-int main()
-{
-    int const depth = 10;
-    int const iteration_count = 10000000;
-    std::cout <<
-        iteration_count << " iterations, call depth " << depth << ", sizeof(e_heavy_payload) = " << sizeof(e_heavy_payload) << "\n"
-        USING_RESULT_TYPE "\n"
-        "Error type      |  2% (μs) | 98% (μs)\n"
-        "----------------|----------|---------";
-    int r = 0;
-    r += benchmark_type<depth, e_error_code>("e_error_code", iteration_count);
-    r += benchmark_type<depth, std::error_code>("std::error_code", iteration_count);
-    r += benchmark_type<depth, e_system_error>("e_system_error", iteration_count);
-    r += benchmark_type<depth, e_heavy_payload>("e_heavy_payload", iteration_count);
-    std::cout << '\n';
-    // std::cout << std::rand() << '\n';
-    return r;
-}
diff --git a/benchmark/deep_stack_other.cpp b/benchmark/deep_stack_other.cpp
deleted file mode 100644
index aa61f67f..00000000
--- a/benchmark/deep_stack_other.cpp
+++ /dev/null
@@ -1,308 +0,0 @@
-// Copyright 2018-2022 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)
-
-// See benchmark.md
-
-#ifndef BENCHMARK_WHAT
-#   define BENCHMARK_WHAT 0
-#endif
-
-#if BENCHMARK_WHAT == 0
-
-#   ifndef TL_EXPECTED_HPP
-#       include "tl/expected.hpp"
-#   endif
-#   define BENCHMARK_SUCCESS(e) e
-#   define BENCHMARK_FAILURE(e) tl::make_unexpected(e)
-#   define BENCHMARK_TRY(v,r)\
-        auto && _r_##v = r;\
-        if( !_r_##v )\
-            return BENCHMARK_FAILURE(_r_##v.error());\
-    auto && v = _r_##v.value()
-
-#else
-
-#   include <boost/outcome/std_outcome.hpp>
-#   include <boost/outcome/try.hpp>
-#   define BENCHMARK_SUCCESS(e) boost::outcome_v2::success(e)
-#   define BENCHMARK_FAILURE(e) boost::outcome_v2::failure(e)
-#   define BENCHMARK_TRY BOOST_OUTCOME_TRY
-#   ifndef BOOST_NO_EXCEPTIONS
-#       error Please disable exception handling.
-#   endif
-
-#endif
-
-#ifdef _MSC_VER
-#   define NOINLINE __declspec(noinline)
-#   define ALWAYS_INLINE __forceinline
-#else
-#   define NOINLINE __attribute__((noinline))
-#   define ALWAYS_INLINE __attribute__((always_inline)) inline
-#endif
-
-#include <cstring>
-#include <cstdlib>
-#include <cassert>
-#include <chrono>
-#include <iostream>
-#include <fstream>
-#include <iomanip>
-#include <numeric>
-#include <algorithm>
-#include <system_error>
-#include <array>
-
-namespace boost
-{
-    void throw_exception( std::exception const & e )
-    {
-        std::cerr << "Terminating due to a C++ exception under BOOST_NO_EXCEPTIONS: " << e.what();
-        std::terminate();
-    }
-
-    struct source_location;
-    void throw_exception( std::exception const & e, boost::source_location const & )
-    {
-        throw_exception(e);
-    }
-}
-
-//////////////////////////////////////
-
-#if BENCHMARK_WHAT == 0 // tl::expected
-
-#   define USING_RESULT_TYPE "tl::expected<T, E>"
-
-    template <class T, class E>
-    using result = tl::expected<T, E>;
-
-#elif BENCHMARK_WHAT == 1 // outcome::result
-
-#   define USING_RESULT_TYPE "outcome::result<T, E>"
-
-    template <class T, class E>
-    using result = boost::outcome_v2::std_result<T, E, boost::outcome_v2::policy::terminate>;
-
-#elif BENCHMARK_WHAT == 2 // outcome::outcome
-
-#   define USING_RESULT_TYPE "outcome::outcome<T, E>"
-
-    template <class T, class E>
-    using result = boost::outcome_v2::std_outcome<T, E>;
-
-#else
-#   error Benchmark what?
-#endif
-
-//////////////////////////////////////
-
-enum class e_error_code
-{
-    ec0, ec1, ec2, ec3
-};
-
-struct e_system_error
-{
-    int value;
-    std::string what;
-};
-
-struct e_heavy_payload
-{
-    std::array<char, 4096> value;
-};
-
-template <class E>
-E make_error() noexcept;
-
-template <>
-inline e_error_code make_error<e_error_code>() noexcept
-{
-    switch(std::rand()%4)
-    {
-        default: return e_error_code::ec0;
-        case 1: return e_error_code::ec1;
-        case 2: return e_error_code::ec2;
-        case 3: return e_error_code::ec3;
-    }
-}
-
-template <>
-inline std::error_code make_error<std::error_code>() noexcept
-{
-    return std::error_code(std::rand(), std::system_category());
-}
-
-template <>
-inline e_system_error make_error<e_system_error>() noexcept
-{
-    return { std::rand(), std::string(std::rand()%32, ' ') };
-}
-
-template <>
-inline e_heavy_payload make_error<e_heavy_payload>() noexcept
-{
-    e_heavy_payload e;
-    std::fill(e.value.begin(), e.value.end(), std::rand());
-    return e;
-}
-
-inline bool should_fail( int failure_rate ) noexcept
-{
-    assert(failure_rate>=0);
-    assert(failure_rate<=100);
-    return (std::rand()%100) < failure_rate;
-}
-
-inline int handle_error( e_error_code e ) noexcept
-{
-    return int(e);
-}
-
-inline int handle_error( std::error_code const & e ) noexcept
-{
-    return e.value();
-}
-
-inline int handle_error( e_system_error const & e ) noexcept
-{
-    return e.value + e.what.size();
-}
-
-inline int handle_error( e_heavy_payload const & e ) noexcept
-{
-    return std::accumulate(e.value.begin(), e.value.end(), 0);
-}
-
-//////////////////////////////////////
-
-// This is used to change the "success" type at each level.
-// Generally, functions return values of different types.
-template <int N, class E, bool Odd = N%2>
-struct select_result_type;
-
-template <int N, class E>
-struct select_result_type<N, E, true>
-{
-    using type = result<int, E>;
-};
-
-template <int N, class E>
-struct select_result_type<N, E, false>
-{
-    using type = result<float, E>;
-};
-
-template <int N, class E>
-using select_result_t = typename select_result_type<N, E>::type;
-
-//////////////////////////////////////
-
-template <int N, class E>
-struct benchmark
-{
-    using e_type = E;
-
-    NOINLINE static select_result_t<N, E> f( int failure_rate ) noexcept
-    {
-        BENCHMARK_TRY(x, (benchmark<N-1, E>::f(failure_rate)));
-        return BENCHMARK_SUCCESS(x+1);
-    }
-};
-
-template <class E>
-struct benchmark<1, E>
-{
-    using e_type = E;
-
-    NOINLINE static select_result_t<1, E> f( int failure_rate ) noexcept
-    {
-        if( should_fail(failure_rate) )
-            return BENCHMARK_FAILURE(make_error<E>());
-        else
-            return BENCHMARK_SUCCESS(std::rand());
-    }
-};
-
-//////////////////////////////////////
-
-template <class Benchmark>
-NOINLINE int runner( int failure_rate ) noexcept
-{
-    if( auto r = Benchmark::f(failure_rate) )
-        return r.value();
-    else
-        return handle_error(r.error());
-}
-
-//////////////////////////////////////
-
-std::fstream append_csv()
-{
-    if( FILE * f = fopen("benchmark.csv","rb") )
-    {
-        fclose(f);
-        return std::fstream("benchmark.csv", std::fstream::out | std::fstream::app);
-    }
-    else
-    {
-        std::fstream fs("benchmark.csv", std::fstream::out | std::fstream::app);
-        fs << "\"Result Type\",2%,98%\n";
-        return fs;
-    }
-}
-
-template <class F>
-int print_elapsed_time( int iteration_count, F && f )
-{
-    auto start = std::chrono::steady_clock::now();
-    int val = 0;
-    for( int i = 0; i!=iteration_count; ++i )
-        val += std::forward<F>(f)();
-    auto stop = std::chrono::steady_clock::now();
-    int elapsed = std::chrono::duration_cast<std::chrono::microseconds>(stop-start).count();
-    std::cout << std::right << std::setw(9) << elapsed;
-    append_csv() << ',' << elapsed;
-    return val;
-}
-
-//////////////////////////////////////
-
-template <int Depth, class E>
-int benchmark_type( char const * type_name, int iteration_count )
-{
-    int x=0;
-    append_csv() << "\"" USING_RESULT_TYPE "\"";
-    std::cout << '\n' << std::left << std::setw(16) << type_name << '|';
-    std::srand(0);
-    x += print_elapsed_time( iteration_count, [] { return runner<benchmark<Depth, E>>(2); } );
-    std::cout << " |";
-    std::srand(0);
-    x += print_elapsed_time( iteration_count, [] { return runner<benchmark<Depth, E>>(98); } );
-    append_csv() << '\n';
-    return x;
-}
-
-//////////////////////////////////////
-
-int main()
-{
-    int const depth = 10;
-    int const iteration_count = 10000000;
-    std::cout <<
-        iteration_count << " iterations, call depth " << depth << ", sizeof(e_heavy_payload) = " << sizeof(e_heavy_payload) << "\n"
-        USING_RESULT_TYPE "\n"
-        "Error type      |  2% (μs) | 98% (μs)\n"
-        "----------------|----------|---------";
-    int r = 0;
-    r += benchmark_type<depth, e_error_code>("e_error_code", iteration_count);
-    r += benchmark_type<depth, std::error_code>("std::error_code", iteration_count);
-    r += benchmark_type<depth, e_system_error>("e_system_error", iteration_count);
-    r += benchmark_type<depth, e_heavy_payload>("e_heavy_payload", iteration_count);
-    std::cout << '\n';
-    // std::cout << std::rand() << '\n';
-    return r;
-}
diff --git a/benchmark/gcc_e_error_code.png b/benchmark/gcc_e_error_code.png
deleted file mode 100644
index 48a777ab..00000000
Binary files a/benchmark/gcc_e_error_code.png and /dev/null differ
diff --git a/benchmark/gcc_e_heavy_payload.png b/benchmark/gcc_e_heavy_payload.png
deleted file mode 100644
index 4c19bd9f..00000000
Binary files a/benchmark/gcc_e_heavy_payload.png and /dev/null differ
diff --git a/benchmark/gcc_e_system_error.png b/benchmark/gcc_e_system_error.png
deleted file mode 100644
index 255fc9d1..00000000
Binary files a/benchmark/gcc_e_system_error.png and /dev/null differ
diff --git a/benchmark/msvc_e_error_code.png b/benchmark/msvc_e_error_code.png
deleted file mode 100644
index 20962cc7..00000000
Binary files a/benchmark/msvc_e_error_code.png and /dev/null differ
diff --git a/benchmark/msvc_e_heavy_payload.png b/benchmark/msvc_e_heavy_payload.png
deleted file mode 100644
index e5d10844..00000000
Binary files a/benchmark/msvc_e_heavy_payload.png and /dev/null differ
diff --git a/benchmark/msvc_e_system_error.png b/benchmark/msvc_e_system_error.png
deleted file mode 100644
index edd70fae..00000000
Binary files a/benchmark/msvc_e_system_error.png and /dev/null differ
diff --git a/conanfile.py b/conanfile.py
new file mode 100644
index 00000000..641a70c5
--- /dev/null
+++ b/conanfile.py
@@ -0,0 +1,80 @@
+from conan import ConanFile
+from conan.tools.files import copy
+from conan.tools.layout import basic_layout
+from conan.tools.build import check_min_cppstd
+from conan.errors import ConanInvalidConfiguration
+import os
+
+
+required_conan_version = ">=1.50.0"
+
+
+class BoostLEAFConan(ConanFile):
+    name = "boost-leaf"
+    version = "1.81.0"
+    license = "BSL-1.0"
+    url = "https://github.com/conan-io/conan-center-index"
+    homepage = "https://github.com/boostorg/leaf"
+    description = ("Lightweight Error Augmentation Framework")
+    topics = ("multi-platform", "multi-threading", "cpp11", "error-handling",
+              "header-only", "low-latency", "no-dependencies", "single-header")
+    settings = "os", "compiler", "arch", "build_type"
+    exports_sources = "include/*", "LICENSE_1_0.txt"
+    no_copy_source = True
+
+    def package_id(self):
+        self.info.clear()
+
+    @property
+    def _min_cppstd(self):
+        return "11"
+
+    @property
+    def _compilers_minimum_version(self):
+        return {
+            "gcc": "4.8",
+            "Visual Studio": "17",
+            "msvc": "141",
+            "clang": "3.9",
+            "apple-clang": "10.0.0"
+        }
+
+    def requirements(self):
+        pass
+
+    def validate(self):
+        if self.settings.get_safe("compiler.cppstd"):
+            check_min_cppstd(self, self._min_cppstd)
+
+        def lazy_lt_semver(v1, v2):
+            lv1 = [int(v) for v in v1.split(".")]
+            lv2 = [int(v) for v in v2.split(".")]
+            min_length = min(len(lv1), len(lv2))
+            return lv1[:min_length] < lv2[:min_length]
+
+        compiler = str(self.settings.compiler)
+        version = str(self.settings.compiler.version)
+        minimum_version = self._compilers_minimum_version.get(compiler, False)
+
+        if minimum_version and lazy_lt_semver(version, minimum_version):
+            raise ConanInvalidConfiguration(
+                f"{self.name} {self.version} requires C++{self._min_cppstd}, which your compiler ({compiler}-{version}) does not support")
+
+    def layout(self):
+        basic_layout(self)
+
+    def package(self):
+        copy(self, "LICENSE_1_0.txt", dst=os.path.join(
+            self.package_folder, "licenses"),  src=self.source_folder)
+        copy(self, "*.h", dst=os.path.join(self.package_folder, "include"),
+             src=os.path.join(self.source_folder, "include"))
+        copy(self, "*.hpp", dst=os.path.join(self.package_folder,
+             "include"), src=os.path.join(self.source_folder, "include"))
+
+    def package_info(self):
+        self.cpp_info.set_property("cmake_target_name", "boost::leaf")
+
+        self.cpp_info.bindirs = []
+        self.cpp_info.frameworkdirs = []
+        self.cpp_info.libdirs = []
+        self.cpp_info.resdirs = []
diff --git a/doc/Jamfile b/doc/Jamfile
index e183454f..9840338e 100644
--- a/doc/Jamfile
+++ b/doc/Jamfile
@@ -1,15 +1,15 @@
 # Copyright 2017 Peter Dimov
-# Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
+# Copyright 2018-2024 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)
 
 project doc/leaf ;
-import asciidoctor ;
+using asciidoctor ;
 
 html index.html : leaf.adoc : <asciidoctor-attribute>stylesheet=zajo-dark.css <asciidoctor-attribute>linkcss ;
-install html_ : index.html LEAF-1.png LEAF-2.png skin.png zajo-dark.css zajo-light.css rouge-github.css : <location>html ;
+install html_ : index.html skin.png zajo-dark.css zajo-light.css rouge-github.css : <location>html ;
 
 pdf leaf.pdf : leaf.adoc : <asciidoctor-doctype>book  <asciidoctor-attribute>pdf-themesdir=. <asciidoctor-attribute>pdf-theme=leaf ;
 install pdf_ : leaf.pdf : <location>html ;
diff --git a/doc/LEAF-1.png b/doc/LEAF-1.png
deleted file mode 100644
index 9aa55b7b..00000000
Binary files a/doc/LEAF-1.png and /dev/null differ
diff --git a/doc/LEAF-2.png b/doc/LEAF-2.png
deleted file mode 100644
index 1237ef2a..00000000
Binary files a/doc/LEAF-2.png and /dev/null differ
diff --git a/doc/leaf.adoc b/doc/leaf.adoc
index 7e97d26e..ed4517ad 100644
--- a/doc/leaf.adoc
+++ b/doc/leaf.adoc
@@ -29,7 +29,7 @@ Boost LEAF is a lightweight error handling library for {CPP}11. Features:
 ====
 * Portable single-header format, no dependencies.
 
-* Tiny code size when configured for embedded development.
+* Tiny code size, configurable for embedded development.
 
 * No dynamic memory allocations, even with very large payloads.
 
@@ -43,16 +43,13 @@ Boost LEAF is a lightweight error handling library for {CPP}11. Features:
 ifndef::backend-pdf[]
 [grid=none, frame=none]
 |====
-| <<tutorial>> \| <<synopsis>> \| https://github.com/boostorg/leaf/blob/master/doc/whitepaper.md[Whitepaper] \| https://github.com/boostorg/leaf/blob/master/benchmark/benchmark.md[Benchmark] >| Reference: <<functions,Functions>> \| <<types,Types>> \| <<predicates,Predicates>> \| <<traits,Traits>> \| <<macros,Macros>>
+| <<tutorial>> \| <<synopsis>> \| https://github.com/boostorg/leaf/blob/master/doc/whitepaper.md[Whitepaper] >| Reference: <<functions,Functions>> \| <<types,Types>> \| <<predicates,Predicates>> \| <<traits,Traits>> \| <<macros,Macros>>
 |====
 endif::[]
 
 [[support]]
 == Support
 
-* https://Cpplang.slack.com[cpplang on Slack] (use the `#boost` channel)
-* https://lists.boost.org/mailman/listinfo.cgi/boost-users[Boost Users Mailing List]
-* https://lists.boost.org/mailman/listinfo.cgi/boost[Boost Developers Mailing List]
 * https://github.com/boostorg/leaf/issues[Report issues] on GitHub
 
 [[distribution]]
@@ -64,7 +61,7 @@ There are three distribution channels:
 
 * LEAF is included in official https://www.boost.org/[Boost] releases (starting with Boost 1.75), and therefore available via most package managers.
 * The source code is hosted on https://github.com/boostorg/leaf[GitHub].
-* For maximum portability, the latest LEAF release is also available in single-header format: simply download link:https://raw.githubusercontent.com/boostorg/leaf/gh-pages/leaf.hpp[leaf.hpp] (direct download link).
+* For maximum portability, the latest LEAF release is also available in single-header format: link:https://raw.githubusercontent.com/boostorg/leaf/gh-pages/leaf.hpp[leaf.hpp] (direct download link).
 
 NOTE: LEAF does not depend on Boost or other libraries.
 
@@ -75,15 +72,15 @@ What is a failure? It is simply the inability of a function to return a valid re
 
 A typical design is to return a variant type, e.g. `result<T, E>`. Internally, such variant types must store a discriminant (in this case a boolean) to indicate whether the object holds a `T` or an `E`.
 
-The design of LEAF is informed by the observation that the immediate caller must have access to the discriminant in order to determine the availability of a valid `T`, but otherwise it rarely needs to access the `E`. The error object is only needed once an error handling scope is reached.
+The design of LEAF is informed by the observation that the immediate caller must have access to the discriminant in order to determine the availability of a valid `T`, but otherwise it is rare that it needs to access any error objects. They are only needed once an error handling scope is reached.
 
-Therefore what would have been a `result<T, E>` becomes `result<T>`, which stores the discriminant and (optionally) a `T`, while the `E` is communicated directly to the error handling scope where it is needed.
+Therefore what would have been a `result<T, E>` becomes `result<T>`, which stores the discriminant and (optionally) a `T`, while error objects are delivered directly to the error handling scope where they are needed.
 
 The benefit of this decomposition is that `result<T>` becomes extremely lightweight, as it is not coupled with error types; further, error objects are communicated in constant time (independent of the call stack depth). Even very large objects are handled efficiently without dynamic memory allocation.
 
 === Reporting Errors
 
-A function that reports an error is pretty straight-forward:
+A function that reports an error:
 
 [source,c++]
 ----
@@ -209,11 +206,11 @@ leaf::result<U> r = leaf::try_handle_some(
 [.text-right]
 <<try_handle_some>> | <<result>> | <<BOOST_LEAF_AUTO>>
 
-The first lambda passed to `try_handle_some` is executed first; it attempts to produce a `result<U>`, but it may fail.
+First, `try_handle_some` executes the first function passed to it; it attempts to produce a `result<U>`, but it may fail.
 
-The second lambda is an error handler: it will be called iff the first lambda fails and an error object of type `err1` was communicated to LEAF. That object is stored on the stack, local to the `try_handle_some` function (LEAF knows to allocate this storage because we gave it an error handler that takes an `err1`). Error handlers passed to `leaf::try_handle_some` can return a valid `leaf::result<U>` but are allowed to fail.
+The second lambda is an error handler: it will be called iff the first lambda fails with an error object of type `err1`. That object is stored on the stack, local to the `try_handle_some` function (LEAF knows to allocate this storage because we gave it an error handler that takes an `err1`). Error handlers passed to `leaf::try_handle_some` can return a valid `leaf::result<U>` but are allowed to fail.
 
-It is possible for an error handler to specify that it can only deal with some values of a given error type:
+It is possible for an error handler to declare that it can only handle some specific values of a given error type:
 
 [source,c++]
 ----
@@ -229,7 +226,7 @@ leaf::result<U> r = leaf::try_handle_some(
 
   []( leaf::match<err1, err1::e1, err1::e3> ) -> leaf::result<U>
   {
-    // Handle err::e1
+    // Handle err1::e1 or err1::e3
   },
 
   []( err1 e ) -> leaf::result<U>
@@ -240,15 +237,15 @@ leaf::result<U> r = leaf::try_handle_some(
 [.text-right]
 <<try_handle_some>> | <<result>> | <<BOOST_LEAF_AUTO>> | <<match>>
 
-LEAF considers the provided error handlers in order, and calls the first one for which it can supply arguments, based on the error objects currently being communicated. Above:
+LEAF considers the provided error handlers in order, and calls the first one for which it is able to supply arguments, based on the error objects currently being communicated. Above:
 
-* The first error handler uses the predicate `leaf::match` to specify that it should only be considered if an error object of type `err1` is available, and its value is either `err1::e1` or `err1::e3`.
+* The first error handler will be called iff an error object of type `err1` is available, and its value is either `err1::e1` or `err1::e3`.
 
-* Otherwise the second error handler will be called if an error object of type `err1` is available, regardless of its value.
+* Otherwise the second error handler will be called iff an error object of type `err1` is available, regardless of its value.
 
-* Otherwise `leaf::try_handle_some` fails.
+* Otherwise `leaf::try_handle_some` is unable to handle the error.
 
-It is possible for an error handler to conditionally leave the current failure unhandled:
+It is possible for an error handler to conditionally leave the failure unhandled:
 
 [source,c++]
 ----
@@ -347,7 +344,7 @@ leaf::result<U> r = leaf::try_handle_some(
 [.text-right]
 <<try_handle_some>> | <<result>> | <<BOOST_LEAF_AUTO>>
 
-Recall that error handlers are always considered in order:
+Error handlers are always considered in order:
 
 * The first error handler will be used if an error object of type `err1` is available;
 * otherwise, the second error handler will be used if an error object of type `err2` is available;
@@ -390,7 +387,7 @@ leaf::result<U> r = leaf::try_handle_some(
 
   []( io_error ec, e_file_name fn ) -> leaf::result<U>
   {
-    // Handle I/O errors when a file name is available.
+    // Handle I/O errors when a file name is also available.
   },
 
   []( io_error ec ) -> leaf::result<U>
@@ -422,7 +419,7 @@ leaf::result<U> r = leaf::try_handle_some(
   []( io_error ec, e_file_name const * fn ) -> leaf::result<U>
   {
     if( fn )
-      .... // Handle I/O errors when a file name is available.
+      .... // Handle I/O errors when a file name is also available.
     else
       .... // Handle I/O errors when no file name is available.
   } );
@@ -430,9 +427,9 @@ leaf::result<U> r = leaf::try_handle_some(
 [.text-right]
 <<try_handle_some>> | <<result>> | <<BOOST_LEAF_AUTO>>
 
-An error handler is never dropped for lack of error objects of types which the handler takes as pointers; in this case LEAF simply passes `0` for these arguments.
+An error handler is never dropped for lack of error objects of types which the handler takes as pointers; in this case LEAF simply passes `nullptr` for these arguments.
 
-TIP: Error handlers can take arguments by value, by const reference or pointer, and by mutable reference or pointer. It the latter case, changes to the error object state will be propagated up the call stack if the failure is not handled.
+TIP: When an error handler takes arguments by mutable reference or pointer, changes to their state are preserved when the error is communicated to the caller.
 
 [[tutorial-augmenting_errors]]
 === Augmenting Errors
@@ -469,7 +466,7 @@ leaf::result<void> process_file( FILE * f )
 [.text-right]
 <<on_error>> | <<BOOST_LEAF_AUTO>>
 
-Because `process_file` does not handle errors, it remains neutral to failures, except to attach the `current_line` if something goes wrong. The object returned by `on_error` holds a copy of the `current_line` wrapped in `struct e_line`. If `parse_line` succeeds, the `e_line` object is simply discarded; but if it fails, the `e_line` object will be automatically "attached" to the failure.
+Because `process_file` does not handle errors, it remains neutral to failures, except to attach the `current_line` if something goes wrong. The object returned by `on_error` holds a copy of `current_line` wrapped in `struct e_line`. If `parse_line` succeeds, the `e_line` object is simply discarded; if it fails, the `e_line` object will be automatically "attached" to the failure.
 
 Such failures can then be handled like so:
 
@@ -530,7 +527,7 @@ leaf::result<void> r = leaf::try_handle_some(
 [[tutorial-exception_handling]]
 === Exception Handling
 
-What happens if an operation throws an exception? Not to worry, both `try_handle_some` and `try_handle_all` catch exceptions and are able to pass them to any compatible error handler:
+What happens if an operation throws an exception? Both `try_handle_some` and `try_handle_all` catch exceptions and are able to pass them to any compatible error handler:
 
 [source,c++]
 ----
@@ -596,9 +593,9 @@ leaf::try_catch(
 [.text-right]
 <<try_catch>>
 
-Remarkably, we did not have to change the error handlers! But how does this work? What kind of exceptions does `process_file` throw?
+We did not have to change the error handlers! But how does this work? What kind of exceptions does `process_file` throw?
 
-LEAF enables a novel technique of exception handling, which does not use an exception type hierarchy to classify failures and does not carry data in exception objects. Recall that when failures are communicated via `leaf::result`, we call `leaf::new_error` in a `return` statement, passing any number of error objects which are sent directly to the correct error handling scope:
+LEAF enables a novel exception handling technique, which does not require an exception type hierarchy to classify failures and does not carry data in exception objects. Recall that when failures are communicated via `leaf::result`, we call `leaf::new_error` in a `return` statement, passing any number of error objects which are sent directly to the correct error handling scope:
 
 [source,c++]
 ----
@@ -629,24 +626,24 @@ enum class err2 { e1, e2 };
 T f()
 {
   if( error_detected )
-    throw leaf::exception(err1::e1, err2::e2);
+    leaf::throw_exception(err1::e1, err2::e2);
 
   // Produce and return a T.
 }
 ----
 [.text-right]
-<<exception>>
+<<throw_exception>>
 
-The `leaf::exception` function handles the passed error objects just like `leaf::new_error` does, and then returns an object of a type that derives from `std::exception` (which the caller throws). Using this technique, the exception type is not important: `leaf::try_catch` catches all exceptions, then goes through the usual LEAF error handler selection procedure.
+The `leaf::throw_exception` function handles the passed error objects just like `leaf::new_error` does, and then throws an object of a type that derives from `std::exception`. Using this technique, the exception type is not important: `leaf::try_catch` catches all exceptions, then goes through the usual LEAF error handler selection routine.
 
-If instead we want to use the legacy convention of throwing different types to indicate different failures, we simply pass an exception object (that is, an object of a type that derives from `std::exception`) as the first argument to `leaf::exception`:
+If instead we want to use the usual convention of throwing different types to indicate different failures, we simply pass an exception object (that is, an object of a type that derives from `std::exception`) as the first argument to `leaf::throw_exception`:
 
 [source,c++]
 ----
-throw leaf::exception(std::runtime_error("Error!"), err1::e1, err2::e2);
+leaf::throw_exception(std::runtime_error("Error!"), err1::e1, err2::e2);
 ----
 
-In this case the returned object will be of type that derives from `std::runtime_error`, rather than from `std::exception`.
+In this case the thrown exception object will be of type that derives from `std::runtime_error`, rather than from `std::exception`.
 
 Finally, `leaf::on_error` "just works" as well. Here is our `process_file` function rewritten to work with exceptions, rather than return a `leaf::result` (see <<tutorial-augmenting_errors>>):
 
@@ -701,7 +698,7 @@ leaf::result<int> f()
 [.text-right]
 <<result>> | <<new_error>>
 
-Later we simply call `leaf::try_handle_some` passing an error handler for each type:
+Later we simply call `leaf::try_handle_some`, passing an error handler for each type:
 
 [source,c++]
 ----
@@ -756,7 +753,7 @@ lib2::result<int, lib2::error_type> bar();
 
 int g( int a, int b );
 
-lib3::result<int> f()
+lib3::result<int> f() // Note: return type is not leaf::result<int>
 {
   auto a = foo();
   if( !a )
@@ -799,45 +796,14 @@ lib3::result<int> r = leaf::try_handle_some(
 
 '''
 
-[[tutorial-model]]
-=== Error Communication Model
-
-==== `noexcept` API
-
-The following figure illustrates how error objects are transported when using LEAF without exception handling:
-
-.LEAF noexcept Error Communication Model
-image::LEAF-1.png[]
-
-The arrows pointing down indicate the call stack order for the functions `f1` through `f5`: higher level functions calling lower level functions.
-
-Note the call to `on_error` in `f3`: it caches the passed error objects of types `E1` and `E3` in the returned object `load`, where they stay ready to be communicated in case any function downstream from `f3` reports an error. Presumably these objects are relevant to any such failure, but are conveniently accessible only in this scope.
-
-_Figure 1_ depicts the condition where `f5` has detected an error. It calls `leaf::new_error` to create a new, unique `error_id`. The passed error object of type `E2` is immediately loaded in the first active `context` object that provides static storage for it, found in any calling scope (in this case `f1`), and is associated with the newly-generated `error_id` (solid arrow);
-
-The `error_id` itself is returned to the immediate caller `f4`, usually stored in a `result<T>` object `r`. That object takes the path shown by dashed arrows, as each error neutral function, unable to handle the failure, forwards it to its immediate caller in the returned value -- until an error handling scope is reached.
-
-When the destructor of the `load` object in `f3` executes, it detects that `new_error` was invoked after its initialization, loads the cached objects of types `E1` and `E3` in the first active `context` object that provides static storage for them, found in any calling scope (in this case `f1`), and associates them with the last generated `error_id` (solid arrow).
-
-When the error handling scope `f1` is reached, it probes `ctx` for any error objects associated with the `error_id` it received from `f2`, and processes a list of user-provided error handlers, in order, until it finds a handler with arguments that can be supplied using the available (in `ctx`) error objects. That handler is called to deal with the failure.
-
-==== Exception Handling API
-
-The following figure illustrates the slightly different error communication model used when errors are reported by throwing exceptions:
-
-.LEAF Error Communication Model Using Exception Handling
-image::LEAF-2.png[]
-
-The main difference is that the call to `new_error` is implicit in the call to the function template `leaf::exception`, which in this case takes an exception object of type `Ex`, and returns an exception object of unspecified type that derives publicly from `Ex`.
-
 [[tutorial-interoperability]]
-==== Interoperability
+=== Interoperability
 
 Ideally, when an error is detected, a program using LEAF would always call <<new_error>>, ensuring that each encountered failure is definitely assigned a unique <<error_id>>, which then is reliably delivered, by an exception or by a `result<T>` object, to the appropriate error handling scope.
 
 Alas, this is not always possible.
 
-For example, the error may need to be communicated through uncooperative 3rd-party interfaces. To facilitate this transmission, a error ID may be encoded in a `std::error_code`. As long as a 3rd-party interface is able to transport a `std::error_code`, it should be compatible with LEAF.
+For example, the error may need to be communicated through uncooperative 3rd-party interfaces. To facilitate this transmission, a error ID may be encoded in a `std::error_code`. As long as a 3rd-party interface is able to transport a `std::error_code`, it can be compatible with LEAF.
 
 Further, it is sometimes necessary to communicate errors through an interface that does not even use `std::error_code`. An example of this is when an external lower-level library throws an exception, which is unlikely to be able to carry an `error_id`.
 
@@ -852,14 +818,12 @@ Note that if the above logic is nested (e.g. one function calling another), `new
 
 For a detailed tutorial see <<tutorial-on_error_in_c_callbacks>>.
 
-TIP: To avoid ambiguities, whenever possible, use the <<exception>> function template when throwing exceptions to ensure that the exception object transports a unique `error_id`; better yet, use the <<BOOST_LEAF_THROW_EXCEPTION>> macro, which in addition will capture `pass:[__FILE__]` and `pass:[__LINE__]`.
-
 '''
 
 [[tutorial-loading]]
 === Loading of Error Objects
 
-To load an error object is to move it into an active <<context>>, usually local to a <<try_handle_some>>, a <<try_handle_all>> or a <<try_catch>> scope in the calling thread, where it becomes uniquely associated with a specific <<error_id>> -- or discarded if storage is not available.
+Recall that error objects communicated to LEAF are stored on the stack, local to the `try_handle_same`, `try_handle_all` or `try_catch` function used to handle errors. To _load_ an error object means to move it into such storage, if available.
 
 Various LEAF functions take a list of error objects to load. As an example, if a function `copy_file` that takes the name of the input file and the name of the output file as its arguments detects a failure, it could communicate an error code `ec`, plus the two relevant file names using <<new_error>>:
 
@@ -897,7 +861,7 @@ Besides error objects, `load` can take function arguments:
 
 * If we pass a function that takes no arguments, it is invoked, and the returned error object is loaded.
 +
-Consider that if we pass to `load` an error object that is not needed by any error handler, it will be discarded. If the object is expensive to compute, it would be better if the computation can be skipped as well. Passing a function with no arguments to `load` is an excellent way to achieve this behavior:
+Consider that if we pass to `load` an error object that is not used by an error handler, it will be discarded. If instead of an error object we pass a function that returns an error object, that function will only be called if the object it returns is needed, that is, if it will not be discarded. This is helpful when the error object is relatively expensive to produce:
 +
 [source,c++]
 ----
@@ -926,9 +890,9 @@ leaf::result<void> operation( char const * file_name ) noexcept
 <<result>> | <<result::load>>
 +
 <1> Success! Use `r.value()`.
-<2> `try_something` has failed; `compute_info` will only be called if an error handler exists which takes a `info` argument.
+<2> `try_something` has failed; `compute_info` will only be called if an error handler exists in the call stack which takes a `info` argument.
 +
-* If we pass a function that takes a single argument of type `E &`, LEAF calls the function with the object of type `E` currently loaded in an active `context`, associated with the error. If no such object is available, a new one is default-initialized and then passed to the function.
+* If we pass a function that takes a single argument of some type `E &`, LEAF calls the function with the object of type `E` currently loaded in an active `context`, associated with the error. If no such object is available, a new one is default-initialized and then passed to the function.
 +
 For example, if an operation that involves many different files fails, a program may provide for collecting all relevant file names in a `e_relevant_file_names` object:
 +
@@ -969,7 +933,7 @@ leaf::result<void> operation( char const * file_name ) noexcept
 
 It is not typical for an error reporting function to be able to supply all of the data needed by a suitable error handling function in order to recover from the failure. For example, a function that reports `FILE` failures may not have access to the file name, yet an error handling function needs it in order to print a useful error message.
 
-Of course the file name is typically readily available in the call stack leading to the failed `FILE` operation. Below, while `parse_info` can't report the file name, `parse_file` can and does:
+The file name is typically readily available in the call stack leading to the failed `FILE` operation. Below, while `parse_info` can't report the file name, `parse_file` can and does:
 
 [source,c++]
 ----
@@ -993,51 +957,51 @@ leaf::result<info> parse_file( char const * file_name ) noexcept
 [.text-right]
 <<result>> | <<on_error>> | <<new_error>>
 
-<1> `parse_info` parses `f`, communicating errors using `result<info>`.
-<2> Using `on_error` ensures that the file name is included with any error reported out of `parse_file`. All we need to do is hold on to the returned object `load`; when it expires, if an error is being reported, the passed `e_file_name` value will be automatically associated with it.
+<1> `parse_info` communicates errors using `leaf::result`.
+<2> `on_error` ensures that the file name is included with any error reported out of `parse_file`. When the `load` object expires, if an error is being reported, the passed `e_file_name` value will be automatically associated with it.
 
-TIP: `on_error` --  like `load` -- can be passed any number of arguments.
+TIP: `on_error` --  like `new_error` -- can be passed any number of arguments.
 
 When we invoke `on_error`, we can pass three kinds of arguments:
 
 . Actual error objects (like in the example above);
 . Functions that take no arguments and return an error object;
-. Functions that take an error object by mutable reference.
+. Functions that take a single error object by mutable reference.
 
-If we want to use `on_error` to capture `errno`, we can't just pass <<e_errno>> to it, because at that time it hasn't been set (yet). Instead, we'd pass a function that returns it:
+For example, if we want to use `on_error` to capture `errno`, we could use the <<e_errno>> type, which is a simple struct that wraps an `int`. But, we can't just pass an <<e_errno>> to `on_error`, because at that time `errno` hasn't been set (yet). Instead, we'd pass a function that returns it:
 
 [source,c++]
 ----
 void read_file(FILE * f) {
 
-  auto load = leaf::on_error([]{ return e_errno{errno}; });
+  auto load = leaf::on_error([]{ return leaf::e_errno{errno}; });
 
   ....
   size_t nr1=fread(buf1,1,count1,f);
   if( ferror(f) )
-    throw leaf::exception();
+    leaf::throw_exception();
 
   size_t nr2=fread(buf2,1,count2,f);
   if( ferror(f) )
-    throw leaf::exception();
+    leaf::throw_exception();
 
   size_t nr3=fread(buf3,1,count3,f);
   if( ferror(f) )
-    throw leaf::exception();
+    leaf::throw_exception();
   ....
 }
 ----
 
-Above, if a `throw` statement is reached, LEAF will invoke the function passed to `on_error` and associate the returned `e_errno` object with the exception.
+Above, if an exception is thrown, LEAF will invoke the function passed to `on_error` and associate the returned `e_errno` object with the exception.
 
-The final argument type that can be passed to `on_error` is a function that takes a single mutable error object reference. In this case, `on_error` uses it similarly to how such functions are used by `load`; see <<tutorial-loading>>.
+Finally, if `on_error` is passed a function that takes a single error object by mutable reference, the behavior is similar to how such functions are handled by `load`; see <<tutorial-loading>>.
 
 '''
 
 [[tutorial-predicates]]
 === Using Predicates to Handle Errors
 
-Usually, LEAF error handlers are selected based on the type of the arguments they take and the type of the available error objects. When an error handler takes a predicate type as an argument, the <<handler_selection_procedure,handler selection procedure>> is able to also take into account the _value_ of the available error objects.
+Usually, the compatibility between error handlers and the available error objects is determined based on the type of the arguments they take. When an error handler takes a predicate type as an argument, the <<handler_selection_procedure,handler selection procedure>> is able to also take into account the _value_ of the available error objects.
 
 Consider this error code enum:
 
@@ -1059,31 +1023,27 @@ return leaf::try_handle_some(
 
   []
   {
-    return f(); // returns leaf::result<T>
+    return f(); // Returns leaf::result<T>
   },
 
-  []( my_error e )
-  { <1>
+  []( my_error e ) // handle my_error objects
+  {
     switch(e)
     {
       case my_error::e1:
-        ....; <2>
+        ....; // Handle e1 error values
         break;
       case my_error::e2:
       case my_error::e3:
-        ....; <3>
+        ....; // Handle e2 and e3 error values
         break;
       default:
-        ....; <4>
+        ....; // Handle bad my_error values
         break;
   } );
 ----
-<1> This handler will be selected if we've got a `my_error` object.
-<2> Handle `e1` errors.
-<3> Handle `e2` and `e3` errors.
-<4> Handle bad `my_error` values.
 
-If `my_error` object is available, LEAF will call our error handler. If not, the failure will be forwarded to our caller.
+If a `my_error` object is available, LEAF will call our error handler. If not, the failure will be forwarded to the caller.
 
 This can be rewritten using the <<match>> predicate to organize the different cases in different error handlers. The following is equivalent:
 
@@ -1097,25 +1057,22 @@ return leaf::try_handle_some(
   },
 
   []( leaf::match<my_error, my_error::e1> m )
-  { <1>
+  {
     assert(m.matched == my_error::e1);
     ....;
   },
 
   []( leaf::match<my_error, my_error::e2, my_error::e3> m )
-  { <2>
+  {
     assert(m.matched == my_error::e2 || m.matched == my_error::e3);
     ....;
   },
 
   []( my_error e )
-  { <3>
+  {
     ....;
   } );
 ----
-<1> We've got a `my_error` object that compares equal to `e1`.
-<2> We`ve got a `my_error` object that compares equal to either `e2` or `e3`.
-<3> Handle bad `my_error` values.
 
 The first argument to the `match` template generally specifies the type `E` of the error object `e` that must be available for the error handler to be considered at all. Typically, the rest of the arguments are values. The error handler is dropped if `e` does not compare equal to any of them.
 
@@ -1128,7 +1085,7 @@ In particular, `match` works great with `std::error_code`. The following handler
 }
 ----
 
-This, however, requires {CPP}17 or newer, because it is impossible to infer the type of the error enum (in this case, `std::errc`) from the specified type `std::error_code`, and {CPP}11 does not allow `auto` template arguments. LEAF provides the following workaround, compatible with {CPP}11:
+This, however, requires {CPP}17 or newer. LEAF provides the following workaround, compatible with {CPP}11:
 
 [source,c++]
 ----
@@ -1137,7 +1094,7 @@ This, however, requires {CPP}17 or newer, because it is impossible to infer the
 }
 ----
 
-In addition, it is possible to select a handler based on `std::error_category`. The following handler will match any `std::error_code` of the `std::generic_category` (requires {CPP}17 or newer):
+It is also possible to select a handler based on `std::error_category`. The following handler will match any `std::error_code` of the `std::generic_category` (requires {CPP}17 or newer):
 
 [source,c++]
 ----
@@ -1153,17 +1110,17 @@ The following predicates are available:
 * <<match>>: as described above.
 * <<match_value>>: where `match<E, V...>` compares the object `e` of type `E` with the values `V...`, `match_value<E, V...>` compare `e.value` with the values `V...`.
 * <<match_member>>: similar to `match_value`, but takes a pointer to the data member to compare; that is, `match_member<&E::value, V...>` is equvialent to `match_value<E, V...>`. Note, however, that `match_member` requires {CPP}17 or newer, while `match_value` does not.
-* `<<catch_,catch_>><Ex...>`: Similar to `match`, but checks whether the caught `std::exception` object can be `dynamic_cast` to any of the `Ex` types.
+* `<<catch_>><Ex...>`: Similar to `match`, but checks whether the caught `std::exception` object can be `dynamic_cast` to any of the `Ex` types.
 * <<if_not>> is a special predicate that takes any other predicate `Pred` and requires that an error object of type `E` is available and that `Pred` evaluates to `false`. For example, `if_not<match<E, V...>>` requires that an object `e` of type `E` is available, and that it does not compare equal to any of the specified `V...`.
 
-Finally, the predicate system is easily extensible, see <<predicates,Predicates>>.
+The predicate system is easily extensible, see <<predicates,Predicates>>.
 
 NOTE: See also <<tutorial-std_error_code>>.
 
 '''
 
 [[tutorial-binding_handlers]]
-=== Binding Error Handlers in a `std::tuple`
+=== Reusing Common Error Handlers
 
 Consider this snippet:
 
@@ -1195,7 +1152,7 @@ leaf::try_handle_all(
 [.text-right]
 <<try_handle_all>> | <<e_file_name>>
 
-Looks pretty simple, but what if we need to attempt a different set of operations yet use the same handlers? We could repeat the same thing with a different function passed as `TryBlock` for `try_handle_all`:
+If we need to attempt a different set of operations yet use the same handlers, we could repeat the same thing with a different function passed as the `TryBlock` for `try_handle_all`:
 
 [source,c++]
 ----
@@ -1222,7 +1179,7 @@ leaf::try_handle_all(
   });
 ----
 
-That works, but it is better to bind our error handlers in a `std::tuple`:
+That works, but it is also possible to bind the error handlers in a `std::tuple`:
 
 [source,c++]
 ----
@@ -1278,14 +1235,14 @@ Error handling functions accept a `std::tuple` of error handlers in place of any
 '''
 
 [[tutorial-async]]
-=== Transporting Error Objects Between Threads
+=== Transporting Errors Between Threads
 
-Error objects are stored on the stack in an instance of the <<context>> class template in the scope of e.g. <<try_handle_some>>, <<try_handle_all>> or <<try_catch>> functions. When using concurrency, we need a mechanism to collect error objects in one thread, then use them to handle errors in another thread.
+Like exceptions, LEAF error objects are local to a thread. When using concurrency, sometimes we need to collect error objects in one thread, then use them to handle errors in another thread.
 
-LEAF offers two interfaces for this purpose, one using `result<T>`, and another designed for programs that use exception handling.
+LEAF supports this functionality with or without exception handling. In both cases error objects are captured and transported in a `leaf::<<result>><T>` object.
 
 [[tutorial-async_result]]
-==== Using `result<T>`
+==== Transporting Errors Between Threads Without Exception Handling
 
 Let's assume we have a `task` that we want to launch asynchronously, which produces a `task_result` but could also fail:
 
@@ -1294,37 +1251,7 @@ Let's assume we have a `task` that we want to launch asynchronously, which produ
 leaf::result<task_result> task();
 ----
 
-Because the task will run asynchronously, in case of a failure we need it to capture the relevant error objects but not handle errors. To this end, in the main thread we bind our error handlers in a `std::tuple`, which we will later use to handle errors from each completed asynchronous task (see <<tutorial-binding_handlers,tutorial>>):
-
-[source,c++]
-----
-auto error_handlers = std::make_tuple(
-
-  [](E1 e1, E2 e2)
-  {
-    //Deal with E1, E2
-    ....
-    return { };
-  },
-
-  [](E3 e3)
-  {
-    //Deal with E3
-    ....
-    return { };
-  } );
-----
-
-Why did we start with this step? Because we need to create a <<context>> object to collect the error objects we need. We could just instantiate the `context` template with `E1`, `E2` and `E3`, but that would be prone to errors, since it could get out of sync with the handlers we use. Thankfully LEAF can deduce the types we need automatically, we just need to show it our `error_handlers`:
-
-[source,c++]
-----
-std::shared_ptr<leaf::polymorphic_context> ctx = leaf::make_shared_context(error_handlers);
-----
-
-The `polymorphic_context` type is an abstract base class that has the same members as any instance of the `context` class template, allowing us to erase its exact type. In this case what we're holding in `ctx` is a `context<E1, E2, E3>`, where `E1`, `E2` and `E3` were deduced automatically from the `error_handlers` tuple we passed to `make_shared_context`.
-
-We're now ready to launch our asynchronous task:
+Because the task will run asynchronously, in case of a failure we need to capture any produced error objects but not handle errors. We do this by invoking `try_capture_all`:
 
 [source,c++]
 ----
@@ -1334,16 +1261,15 @@ std::future<leaf::result<task_result>> launch_task() noexcept
     std::launch::async,
     [&]
     {
-      std::shared_ptr<leaf::polymorphic_context> ctx = leaf::make_shared_context(error_handlers);
-      return leaf::capture(ctx, &task);
+      return leaf::try_capture_all(task);
     } );
 }
 ----
 
 [.text-right]
-<<result>> | <<make_shared_context>> | <<capture>>
+<<result>> | <<try_capture_all>>
 
-That's it! Later when we `get` the `std::future`, we can process the returned `result<task_result>` in a call to <<try_handle_some>>, using the `error_handlers` tuple we created earlier:
+In case of a failure, the returned from `try_capture_all` `result<T>` object holds all error objects communicated out of the `task`, at the cost of dynamic allocations. The `result<T>` object can then be stashed away or moved to another thread, and later passed to an error-handling function to unload its content and handle errors:
 
 [source,c++]
 ----
@@ -1359,32 +1285,6 @@ return leaf::try_handle_some(
     return { }
   },
 
-  error_handlers );
-----
-
-[.text-right]
-<<try_handle_some>> | <<result>> | <<BOOST_LEAF_AUTO>>
-
-The reason this works is that in case the `leaf::result<T>` communicates a failure, it is able to hold a `shared_ptr<polymorphic_context>` object. That is why earlier instead of calling `task()` directly, we called `leaf::capture`: it calls the passed function and, in case that fails, it stores the `shared_ptr<polymorphic_context>` we created in the returned `result<T>`, which now doesn't just communicate the fact that an error has occurred, but also holds the `context` object that `try_handle_some` needs in order to supply a suitable handler with arguments.
-
-NOTE: Follow this link to see a complete example program: https://github.com/boostorg/leaf/blob/master/example/capture_in_result.cpp?ts=4[capture_in_result.cpp].
-
-[[tutorial-async_eh]]
-==== Using Exception Handling
-
-Let's assume we have an asynchronous `task` which produces a `task_result` but could also throw:
-
-[source,c++]
-----
-task_result task();
-----
-
-Just like we saw in <<tutorial-async_result>>, first we will bind our error handlers in a `std::tuple`:
-
-[source,c++]
-----
-auto handle_errors = std::make_tuple(
-
   [](E1 e1, E2 e2)
   {
     //Deal with E1, E2
@@ -1400,49 +1300,72 @@ auto handle_errors = std::make_tuple(
   } );
 ----
 
-Launching the task looks the same as before, except that we don't use `result<T>`:
+[.text-right]
+<<try_handle_some>> | <<result>> | <<BOOST_LEAF_AUTO>>
+
+NOTE: Follow this link to see a complete example program: https://github.com/boostorg/leaf/blob/master/example/try_capture_all_result.cpp?ts=4[try_capture_all_result.cpp].
+
+[[tutorial-async_eh]]
+==== Transporting Errors Between Threads With Exception Handling
+
+Let's assume we have an asynchronous `task` which produces a `task_result` but could also throw:
+
+[source,c++]
+----
+task_result task();
+----
+
+We use `try_capture_all` to capture all error objects and the `std::current_exception()` in a `result<T>`:
 
 [source,c++]
 ----
-std::future<task_result> launch_task()
+std::future<leaf::result<task_result>> launch_task()
 {
   return std::async(
     std::launch::async,
     [&]
     {
-      std::shared_ptr<leaf::polymorphic_context> ctx = leaf::make_shared_context(&handle_error);
-      return leaf::capture(ctx, &task);
+      return leaf::try_capture_all(task);
     } );
 }
 ----
 
 [.text-right]
-<<make_shared_context>> | <<capture>>
+<<try_capture_all>>
 
-That's it! Later when we `get` the `std::future`, we can process the returned `task_result` in a call to <<try_catch>>, using the `error_handlers` we saved earlier, as if it was generated locally:
+To handle errors after waiting on the future, we use `try_catch` as usual:
 
 [source,c++]
 ----
-//std::future<task_result> fut;
+//std::future<leaf::result<task_result>> fut;
 fut.wait();
 
 return leaf::try_catch(
 
   [&]
   {
-    task_result r = fut.get(); // Throws on error
+    leaf::result<task_result> r = fut.get();
+    task_result v = r.value(); // throws on error
     //Success!
   },
 
-  error_handlers );
+  [](E1 e1, E2 e2)
+  {
+    //Deal with E1, E2
+    ....
+  },
+
+  [](E3 e3)
+  {
+    //Deal with E3
+    ....
+  } );
 ----
 
 [.text-right]
-<<try_catch>>
+<<try_catch>> | <<result>>
 
-This works similarly to using `result<T>`, except that the `std::shared_ptr<polymorphic_context>` is transported in an exception object (of unspecified type which <<try_catch>> recognizes and then automatically unwraps the original exception).
-
-NOTE: Follow this link to see a complete example program: https://github.com/boostorg/leaf/blob/master/example/capture_in_exception.cpp?ts=4[capture_in_exception.cpp].
+NOTE: Follow this link to see a complete example program: https://github.com/boostorg/leaf/blob/master/example/try_capture_all_exceptions.cpp?ts=4[try_capture_all_exceptions.cpp].
 
 '''
 
@@ -1481,7 +1404,7 @@ It will get called if the value of the `error_code` enum communicated with the f
 
 But what if later we add support for detecting and reporting a new type of input error, e.g. `permissions_error`? It is easy to add that to our `error_code` enum; but now our input error handler won't recognize this new input error -- and we have a bug.
 
-If we can use exceptions, the situation is better because exception types can be organized in a hierarchy in order to classify failures:
+Using exceptions is an improvement because exception types can be organized in a hierarchy in order to classify failures:
 
 [source,c++]
 ----
@@ -1564,7 +1487,7 @@ leaf::result<void> file_read( FILE & f, void * buf, int size )
 <2> In addition, this error is classified as `read_error`.
 <3> In addition, this error is classified as `eof_error`.
 
-This technique works just as well if we choose to use exception handling, we just call `leaf::exception` instead of `leaf::new_error`:
+This technique works just as well if we choose to use exception handling, we just call `leaf::throw_exception` instead of `leaf::new_error`:
 
 [source,c++]
 ----
@@ -1575,16 +1498,16 @@ void file_read( FILE & f, void * buf, int size )
   int n = fread(buf, 1, size, &f);
 
   if( ferror(&f) )
-    throw leaf::exception(read_error{}, leaf::e_errno{errno});
+    leaf::throw_exception(read_error{}, leaf::e_errno{errno});
 
   if( n!=size )
-    throw leaf::exception(eof_error{});
+    leaf::throw_exception(eof_error{});
 }
 ----
 [.text-right]
-<<on_error>> | <<exception>> | <<e_errno>>
+<<on_error>> | <<throw_exception>> | <<e_errno>>
 
-NOTE: If the type of the first argument passed to `leaf::exception` derives from `std::exception`, it will be used to initialize the returned exception object taken by `throw`. Here this is not the case, so the function returns a default-initialized `std::exception` object, while the first (and any other) argument is associated with the failure.
+NOTE: If the type of the first argument passed to `leaf::throw_exception` derives from `std::exception`, it will be used to initialize the thrown exception object. Here this is not the case, so the function throws a default-initialized `std::exception` object, while the first (and any other) argument is associated with the failure.
 
 Now we can write a future-proof handler for any `input_error`:
 
@@ -1647,7 +1570,7 @@ leaf::result<int> compute_answer() noexcept
 [.text-right]
 <<result>> | <<exception_to_result>>
 
-The `exception_to_result` template takes any number of exception types. All exception types thrown by the passed function are caught, and an attempt is made to convert the exception object to each of the specified types. Each successfully-converted slice of the caught exception object, as well as the return value of `std::current_exception`, are copied and <<tutorial-loading,loaded>>, and in the end the exception is converted to a `<<result,result>><T>` object.
+The `exception_to_result` template takes any number of exception types. All exception types thrown by the passed function are caught, and an attempt is made to convert the exception object to each of the specified types. Each successfully-converted slice of the caught exception object, as well as the return value of `std::current_exception`, are copied and <<tutorial-loading,loaded>>, and in the end the exception is converted to a `<<result>><T>` object.
 
 (In our example, `error_a` and `error_b` slices as communicated as error objects, but `error_c` exceptions will still be captured by `std::exception_ptr`).
 
@@ -1666,7 +1589,7 @@ leaf::result<void> print_answer() noexcept
 [.text-right]
 <<result>> | <<BOOST_LEAF_AUTO>>
 
-Finally, here is a scope that handles the errors -- it will work correctly regardless of whether `error_a` and `error_b` objects are thrown as exceptions or not.
+Finally, here is the scope that handles the errors -- it will work correctly regardless of whether `error_a` and `error_b` objects are thrown as exceptions or not.
 
 [source,c++]
 ----
@@ -1704,7 +1627,7 @@ NOTE: The complete program illustrating this technique is available https://gith
 [[tutorial-on_error_in_c_callbacks]]
 === Using `error_monitor` to Report Arbitrary Errors from C-callbacks
 
-Communicating information pertaining to a failure detected in a C callback is tricky, because C callbacks are limited to a specific static signature, which may not use {CPP} types.
+Communicating information pertaining to a failure detected in a C callback is tricky, because C callbacks are limited to a specific function signature, which may not use {CPP} types.
 
 LEAF makes this easy. As an example, we'll write a program that uses Lua and reports a failure from a {CPP} function registered as a C callback, called from a Lua program. The failure will be propagated from {CPP}, through the Lua interpreter (written in C), back to the {CPP} function which called it.
 
@@ -1728,9 +1651,9 @@ std::shared_ptr<lua_State> init_lua_state() noexcept
   lua_register(&*L, "do_work", &do_work); //<2>
 
   luaL_dostring(&*L, "\ //<3>
-\n      function call_do_work()\
-\n          return do_work()\
-\n      end");
+\n  function call_do_work()\
+\n    return do_work()\
+\n  end");
 
   return L;
 }
@@ -1777,7 +1700,7 @@ int do_work( lua_State * L ) noexcept
 <3> Generate a new `error_id` and associate a `do_work_error_code` with it. Normally, we'd return this in a `leaf::result<T>`, but the `do_work` function signature (required by Lua) does not permit this.
 <4> Tell the Lua interpreter to abort the Lua program.
 
-Now we'll write the function that calls the Lua interpreter to execute the Lua function `call_do_work`, which in turn calls `do_work`. We'll return `<<result,result>><int>`, so that our caller can get the answer in case of success, or an error:
+Now we'll write the function that calls the Lua interpreter to execute the Lua function `call_do_work`, which in turn calls `do_work`. We'll return `<<result>><int>`, so that our caller can get the answer in case of success, or an error:
 
 [source,c++]
 ----
@@ -1840,10 +1763,7 @@ int main() noexcept
 
       [](leaf::error_info const & unmatched)
       {
-        std::cerr <<
-          "Unknown failure detected" << std::endl <<
-          "Cryptic diagnostic information follows" << std::endl <<
-          unmatched;
+        std::cerr << "Unknown failure detected\n" << unmatched;
       } );
   }
 ----
@@ -1856,7 +1776,7 @@ int main() noexcept
 
 NOTE: Follow this link to see the complete program: https://github.com/boostorg/leaf/blob/master/example/lua_callback_result.cpp?ts=4[lua_callback_result.cpp].
 
-TIP: When using Lua with {CPP}, we need to protect the Lua interpreter from exceptions that may be thrown from {CPP} functions installed as `lua_CFunction` callbacks. Here is the program from this section rewritten to use a {CPP} exception to safely communicate errors out of the `do_work` function: https://github.com/boostorg/leaf/blob/master/example/lua_callback_eh.cpp?ts=4[lua_callback_eh.cpp].
+TIP: When using Lua with {CPP}, we need to protect the Lua interpreter from exceptions that may be thrown from {CPP} functions installed as `lua_CFunction` callbacks. Here is the program from this section rewritten to use a {CPP} exception (instead of `leaf::result`) to safely communicate errors out of the `do_work` function: https://github.com/boostorg/leaf/blob/master/example/lua_callback_exceptions.cpp?ts=4[lua_callback_exceptions.cpp].
 
 ''''
 
@@ -1888,25 +1808,28 @@ leaf::try_handle_all(
     std::cerr << "Read error!" << std::endl;
   },
 
-  []( leaf::verbose_diagnostic_info const & info ) <3>
+  []( leaf::diagnostic_details const & info ) <3>
   {
-    std::cerr << "Unrecognized error detected, cryptic diagnostic information follows.\n" << info;
+    std::cerr << "Unrecognized error detected\n" << info;
   } );
 ----
 <1> We handle all failures that occur in this try block.
 <2> One or more error handlers that should handle all possible failures.
-<3> The "catch all" error handler is required by `try_handle_all`. It will be called if LEAF is unable to use another error handler.
+<3> This "catch all" error handler is required by `try_handle_all`. It will be called if LEAF is unable to use another error handler.
 
-The `verbose_diagnostic_info` output for the snippet above tells us that we got an `error_code` with value `1` (`write_error`), and an object of type `e_file_name` with `"file.txt"` stored in its `.value`:
+The `diagnostic_details` output for the snippet above tells us that we got an `error_code` with value `1` (`write_error`), and an object of type `e_file_name` with `"file.txt"` stored in its `.value`:
 
 ----
-Unrecognized error detected, cryptic diagnostic information follows.
-leaf::verbose_diagnostic_info for Error ID = 1:
-[with Name = error_code]: 1
-Unhandled error objects:
-[with Name = boost::leaf::e_file_name]: file.txt
+Unrecognized error detected
+Error with serial #1
+Caught:
+  error_code: 1
+Diagnostic details:
+  boost::leaf::e_file_name: file.txt
 ----
 
+TIP: In the `diagnostic_details` output, the section under `Caught:` lists the objects which error handlers take as arguments -- these are the objects which are stored on the stack. The section under `Diagnostic details:` lists all other objects that were communicated. These are the objects that would have been discarded if we didn't provide a handler that takes `diagnostic_details`.
+
 To print each error object, LEAF attempts to bind an unqualified call to `operator<<`, passing a `std::ostream` and the error object. If that fails, it will also attempt to bind `operator<<` that takes the `.value` of the error type. If that also does not compile, the error object value will not appear in diagnostic messages, though LEAF will still print its type.
 
 Even with error types that define a printable `.value`, the user may still want to overload `operator<<` for the enclosing `struct`, e.g.:
@@ -1919,16 +1842,16 @@ struct e_errno
 
   friend std::ostream & operator<<( std::ostream & os, e_errno const & e )
   {
-    return os << "errno = " << e.value << ", \"" << strerror(e.value) << '"';
+    return os << e.value << ", \"" << strerror(e.value) << '"';
   }
 };
 ----
 
 The `e_errno` type above is designed to hold `errno` values. The defined `operator<<` overload will automatically include the output from `strerror` when `e_errno` values are printed (LEAF defines `e_errno` in `<boost/leaf/common.hpp>`, together with other commonly-used error types).
 
-Using `verbose_diagnostic_info` comes at a cost. Normally, when the program attempts to communicate error objects of types which are not used in any error handling scope in the current call stack, they are discarded, which saves cycles. However, if an error handler is provided that takes `verbose_diagnostic_info` argument, before such objects are discarded, they are printed and appended to a `std::string` (this is the case with `e_file_name` in our example above). Such objects appear under `Unhandled error objects` in the output from `verbose_diagnostic_info`.
+Using `diagnostic_details` comes at a cost. Normally, when the program attempts to communicate error objects of types which are not used in any error handling scope in the current call stack, they are discarded, which saves cycles. However, if an error handler is provided that takes `diagnostic_details` argument, such objects are stored on the heap instead of being discarded.
 
-If handling `verbose_diagnostic_info` is considered too costly, use `diagnostic_info` instead:
+If handling `diagnostic_details` is considered too costly, use `diagnostic_info` instead:
 
 [source,c++]
 ----
@@ -1947,22 +1870,22 @@ leaf::try_handle_all(
 
   []( leaf::diagnostic_info const & info )
   {
-    std::cerr << "Unrecognized error detected, cryptic diagnostic information follows.\n" << info;
+    std::cerr << "Unrecognized error detected\n" << info;
   } );
 ----
 
 In this case, the output may look like this:
 
 ----
-Unrecognized error detected, cryptic diagnostic information follows.
-leaf::diagnostic_info for Error ID = 1:
-[with Name = error_code]: 1
-Detected 1 attempt to communicate an unexpected error object of type [with Name = boost::leaf::e_file_name]
+Unrecognized error detected
+Error serial #1
+Caught:
+  error_code: 1
 ----
 
-Notice how the diagnostic information for `e_file_name` changed: LEAF no longer prints it before discarding it, and so `diagnostic_info` can only inform about the type of the discarded object, but not its value.
+Notice how we are missing the `Diagnostic details:` section. That's because the `e_file_name` object was discarded by LEAF, since no error handler needed it.
 
-TIP: The automatically-generated diagnostic messages are developer-friendly, but not user-friendly. Therefore, `operator<<` overloads for error types should only print technical information in English, and should not attempt to localize strings or to format a user-friendly message; this should be done in error handling functions specifically designed for that purpose.
+TIP: The automatically-generated diagnostic messages are developer-friendly, but not user-friendly.
 
 '''
 
@@ -1971,7 +1894,7 @@ TIP: The automatically-generated diagnostic messages are developer-friendly, but
 
 ==== Introduction
 
-The relationship between `std::error_code` and `std::error_condition` is not easily understood from reading the standard specifications. This section explains how they're supposed to be used, and how LEAF interacts with them.
+The relationship between `std::error_code` and `std::error_condition` is not easily understood from reading the standard specification. This section explains how they're supposed to be used, and how LEAF interacts with them.
 
 The idea behind `std::error_code` is to encode both an integer value representing an error code, as well as the domain of that value. The domain is represented by a `std::error_category` [underline]#reference#. Conceptually, a `std::error_code` is like a `pair<std::error_category const &, int>`.
 
@@ -2281,6 +2204,56 @@ A standalone single-header option is available; please see <<distribution>>.
 [[synopsis-reporting]]
 === Error Reporting
 
+[[common.hpp]]
+==== `common.hpp`
+
+====
+.#include <boost/leaf/common.hpp>
+[source,c++]
+----
+namespace boost { namespace leaf {
+
+  struct e_api_function { char const * value; };
+
+  struct e_file_name { std::string value; };
+
+  struct e_type_info_name { char const * value; };
+
+  struct e_at_line { int value; };
+
+  struct e_errno
+  {
+    int value;
+    explicit e_errno(int value=errno);
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, e_errno const &);
+  };
+
+  namespace windows
+  {
+    struct e_LastError
+    {
+      unsigned value;
+
+      explicit e_LastError(unsigned value);
+
+#if BOOST_LEAF_CFG_WIN32
+      e_LastError();
+
+      template <class CharT, class Traits>
+      friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, e_LastError const &);
+#endif
+    };
+  }
+
+} }
+----
+
+[.text-right]
+Reference: <<e_api_function>> | <<e_file_name>> | <<e_at_line>> | <<e_type_info_name>> | <<e_source_location>> | <<e_errno>> | <<e_LastError>>
+====
+
 [[error.hpp]]
 ==== `error.hpp`
 
@@ -2313,7 +2286,8 @@ namespace boost { namespace leaf {
     template <class... Item>
     error_id load( Item && ... item ) const noexcept;
 
-    friend std::ostream & operator<<( std::ostream & os, error_id x );
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, error_id );
   };
 
   bool is_error_id( std::error_code const & ec ) noexcept;
@@ -2323,27 +2297,7 @@ namespace boost { namespace leaf {
 
   error_id current_error() noexcept;
 
-  //////////////////////////////////////////
-
-  class polymorphic_context
-  {
-  protected:
-
-    polymorphic_context() noexcept = default;
-    ~polymorphic_context() noexcept = default;
-
-  public:
-
-    virtual void activate() noexcept = 0;
-    virtual void deactivate() noexcept = 0;
-    virtual bool is_active() const noexcept = 0;
-
-    virtual void propagate( error_id ) noexcept = 0;
-
-    virtual void print( std::ostream & ) const = 0;
-  };
-
-  //////////////////////////////////////////
+  ////////////////////////////////////////
 
   template <class Ctx>
   class context_activator
@@ -2382,64 +2336,101 @@ namespace boost { namespace leaf {
 #define BOOST_LEAF_AUTO(v, r)\
   BOOST_LEAF_ASSIGN(auto v, r)
 
+#if BOOST_LEAF_CFG_GNUC_STMTEXPR
+
 #define BOOST_LEAF_CHECK(r)\
-  auto && <<temp>> = r;\
-  if( <<temp>> )\
-    ;\
-  else\
-    return <<temp>>.error()
+  ({\
+    auto && <<temp>> = (r);\
+    if( !<<temp>> )\
+        return <<temp>>.error();\
+    std::move(<<temp>>);\
+  }).value()
+
+#else
+
+#define BOOST_LEAF_CHECK(r)\
+  {\
+    auto && <<temp>> = r;\
+    if( !<<temp>> )\
+      return <<temp>>.error()\
+  }
+
+#endif
 
-#define BOOST_LEAF_NEW_ERROR <<inject e_source_location voodoo>> ::boost::leaf::new_error
+#define BOOST_LEAF_NEW_ERROR <<exact-definition-unspecified>>
 ----
 
 [.text-right]
-Reference: <<error_id>> | <<is_error_id>> | <<new_error>> | <<current_error>> | <<polymorphic_context>> | <<context_activator>> | <<activate_context>> | <<is_result_type>> | <<BOOST_LEAF_ASSIGN>> | <<BOOST_LEAF_AUTO>> | <<BOOST_LEAF_CHECK>> | <<BOOST_LEAF_NEW_ERROR>>
+Reference: <<error_id>> | <<is_error_id>> | <<new_error>> | <<current_error>> | <<context_activator>> | <<activate_context>> | <<is_result_type>> | <<BOOST_LEAF_ASSIGN>> | <<BOOST_LEAF_AUTO>> | <<BOOST_LEAF_CHECK>> | <<BOOST_LEAF_NEW_ERROR>>
 ====
 
-[[common.hpp]]
-==== `common.hpp`
+[[exception.hpp]]
+==== `exception.hpp`
 
 ====
-.#include <boost/leaf/common.hpp>
+.#include <boost/leaf/exception.hpp>
 [source,c++]
 ----
 namespace boost { namespace leaf {
 
-  struct e_api_function { char const * value; };
+  template <class Ex, class... E> <1>
+  [[noreturn]] void throw_exception( Ex &&, E && ... );
 
-  struct e_file_name { std::string value; };
+  template <class E1, class... E> <2>
+  [[noreturn]] void throw_exception( E1 &&, E && ... );
 
-  struct e_type_info_name { char const * value; };
+  [[noreturn]] void throw_exception();
 
-  struct e_at_line { int value; };
+  template <class Ex, class... E> <1>
+  [[noreturn]] void throw_exception( error_id id, Ex &&, E && ... );
 
-  struct e_errno
-  {
-    int value;
-    explicit e_errno(int value=errno);
-    friend std::ostream & operator<<(std::ostream &, e_errno const &);
-  };
+  template <class E1, class... E> <2>
+  [[noreturn]] void throw_exception( error_id id, E1 &&, E && ... );
 
-  namespace windows
+  [[noreturn]] void throw_exception( error_id id );
+
+  template <class... Ex, class F>
+  <<result<T>-deduced>> exception_to_result( F && f ) noexcept;
+
+} }
+
+#define BOOST_LEAF_THROW_EXCEPTION <<exact-definition-unspecified>>
+----
+
+[.text-right]
+Reference: <<throw_exception>> | <<BOOST_LEAF_THROW_EXCEPTION>>
+
+<1> Only enabled if std::is_base_of<std::exception, Ex>::value.
+<2> Only enabled if !std::is_base_of<std::exception, E1>::value.
+====
+
+[[on_error.hpp]]
+==== `on_error.hpp`
+
+====
+[source,c++]
+.#include <boost/leaf/on_error.hpp>
+----
+namespace boost { namespace leaf {
+
+  template <class... Item>
+  <<unspecified-type>> on_error( Item && ... e ) noexcept;
+
+  class error_monitor
   {
-    struct e_LastError
-    {
-      unsigned value;
+  public:
 
-      explicit e_LastError(unsigned value);
+    error_monitor() noexcept;
 
-#if BOOST_LEAF_CFG_WIN32
-      e_LastError();
-      friend std::ostream & operator<<(std::ostream &, e_LastError const &);
-#endif
-    };
-  }
+    error_id check() const noexcept;
+    error_id assigned_error_id() const noexcept;
+  };
 
 } }
 ----
 
 [.text-right]
-Reference: <<e_api_function>> | <<e_file_name>> | <<e_at_line>> | <<e_type_info_name>> | <<e_source_location>> | <<e_errno>> | <<e_LastError>>
+Reference: <<on_error>> | <<error_monitor>>
 ====
 
 [[result.hpp]]
@@ -2456,48 +2447,66 @@ namespace boost { namespace leaf {
   {
   public:
 
+    using value_type = T;
+
+    // NOTE: Copy constructor implicitly deleted.
+    result( result && r ) noexcept;
+
+    template <class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
+    result( result<U> && r ) noexcept;
+
     result() noexcept;
+
     result( T && v ) noexcept;
-    result( T const & v );
 
-    template <class U>
-    result( U && u, <<enabled_if_T_can_be_inited_with_U>> );
+    result( T const & v );
 
     result( error_id err ) noexcept;
-    result( std::shared_ptr<polymorphic_context> && ctx ) noexcept;
 
-    template <class Enum>
-    result( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type * = 0 ) noexcept;
+    template <class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
+    result( U && u );
+
+#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     result( std::error_code const & ec ) noexcept;
 
-    result( result && r ) noexcept;
+    template <class Enum, class = typename std::enable_if<std::is_error_code_enum<Enum>::value, int>::type>
+    result( Enum e ) noexcept;
 
-    template <class U>
-    result( result<U> && r ) noexcept;
+#endif
 
+    // NOTE: Assignment operator implicitly deleted.
     result & operator=( result && r ) noexcept;
 
-    template <class U>
+    template <class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
     result & operator=( result<U> && r ) noexcept;
 
     bool has_value() const noexcept;
     bool has_error() const noexcept;
     explicit operator bool() const noexcept;
 
-    T const & value() const;
-    T & value();
+    T const & value() const &;
+    T & value() &;
+    T const && value() const &&;
+    T && value() &&;
 
     T const * operator->() const noexcept;
     T * operator->() noexcept;
 
-    T const & operator*() const noexcept;
-    T & operator*() noexcept;
+    T const & operator*() const & noexcept;
+    T & operator*() & noexcept;
+    T const && operator*() const && noexcept;
+    T && operator*() && noexcept;
 
     <<unspecified-type>> error() noexcept;
 
     template <class... Item>
     error_id load( Item && ... item ) noexcept;
+    
+    void unload();
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, result const & );
   };
 
   template <>
@@ -2505,34 +2514,45 @@ namespace boost { namespace leaf {
   {
   public:
 
+    using value_type = void;
+
+    // NOTE: Copy constructor implicitly deleted.
+    result( result && r ) noexcept;
+
     result() noexcept;
 
     result( error_id err ) noexcept;
-    result( std::shared_ptr<polymorphic_context> && ctx ) noexcept;
 
-    template <class Enum>
-    result( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type * = 0 ) noexcept;
+#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     result( std::error_code const & ec ) noexcept;
 
-    result( result && r ) noexcept;
+    template <class Enum, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type>
+    result( Enum e ) noexcept;
 
-    template <class U>
-    result( result<U> && r ) noexcept;
+#endif
 
+    // NOTE: Assignment operator implicitly deleted.
     result & operator=( result && r ) noexcept;
 
-    template <class U>
-    result & operator=( result<U> && r ) noexcept;
-
     explicit operator bool() const noexcept;
 
     void value() const;
 
+    void const * operator->() const noexcept;
+    void * operator->() noexcept;
+
+    void operator*() const noexcept;
+
     <<unspecified-type>> error() noexcept;
 
     template <class... Item>
     error_id load( Item && ... item ) noexcept;
+    
+    void unload();
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, result const &);
   };
 
   struct bad_result: std::exception { };
@@ -2549,99 +2569,9 @@ namespace boost { namespace leaf {
 Reference: <<result>> | <<is_result_type>>
 ====
 
-[[on_error.hpp]]
-==== `on_error.hpp`
-
-====
-[source,c++]
-.#include <boost/leaf/on_error.hpp>
-----
-namespace boost { namespace leaf {
-
-  template <class... Item>
-  <<unspecified-type>> on_error( Item && ... e ) noexcept;
-
-  class error_monitor
-  {
-  public:
-
-    error_monitor() noexcept;
-
-    error_id check() const noexcept;
-    error_id assigned_error_id() const noexcept;
-  };
-
-} }
-----
-
-[.text-right]
-Reference: <<on_error>> | <<error_monitor>>
-====
-
-[[exception.hpp]]
-==== `exception.hpp`
-
-====
-.#include <boost/leaf/exception.hpp>
-[source,c++]
-----
-namespace boost { namespace leaf {
-
-  template <class Ex, class... E> <1>
-  <<unspecified-exception-type>> exception( Ex &&, E && ... ) noexcept;
-
-  template <class E1, class... E> <2>
-  <<unspecified-exception-type>> exception( E1 &&, E && ... ) noexcept;
-
-  <<unspecified-exception-type>> exception() noexcept;
-
-  template <class Ex, class... E> <1>
-  <<unspecified-exception-type>> exception( error_id id, Ex &&, E && ... ) noexcept;
-
-  template <class E1, class... E> <2>
-  <<unspecified-exception-type>> exception( error_id id, E1 &&, E && ... ) noexcept;
-
-  <<unspecified-exception-type>> exception( error_id id ) noexcept;
-
-  template <class... Ex, class F>
-  <<result<T>-deduced>> exception_to_result( F && f ) noexcept;
-
-} }
-
-#define BOOST_LEAF_EXCEPTION <<inject e_source_location voodoo>> ::boost::leaf::exception
-
-#define BOOST_LEAF_THROW_EXCEPTION <<inject e_source_location + invoke boost::throw_exception voodoo>> ::boost::leaf::exception
-----
-
-[.text-right]
-Reference: <<exception>> | <<BOOST_LEAF_EXCEPTION>> | <<BOOST_LEAF_THROW_EXCEPTION>>
-
-<1> Only enabled if std::is_base_of<std::exception, Ex>::value.
-<2> Only enabled if !std::is_base_of<std::exception, E1>::value.
-====
-
-==== `capture.hpp`
-
-====
-[source,c++]
-.#include <boost/leaf/capture.hpp>
-----
-namespace boost { namespace leaf {
-
-  template <class F, class... A>
-  decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
-  capture(std::shared_ptr<polymorphic_context> && ctx, F && f, A... a);
-
-} }
-----
-
-[.text-right]
-Reference: <<capture>> | <<exception_to_result>>
-====
-
 '''
 
-[[tutorial-handling]]
+[[synopsis-handling]]
 
 === Error Handling
 
@@ -2670,16 +2600,17 @@ namespace boost { namespace leaf {
     void deactivate() noexcept;
     bool is_active() const noexcept;
 
-    void propagate( error_id ) noexcept;
+    void unload( error_id ) noexcept;
 
     void print( std::ostream & os ) const;
 
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, context const & );
+
     template <class R, class... H>
     R handle_error( R &, H && ... ) const;
   };
 
-  //////////////////////////////////////////
-
   template <class... H>
   using context_type_from_handlers = typename <<unspecified>>::type;
 
@@ -2689,17 +2620,43 @@ namespace boost { namespace leaf {
   template <class...  H>
   BOOST_LEAF_CONSTEXPR context_type_from_handlers<H...> make_context( H && ... ) noexcept;
 
-  template <class...  H>
-  context_ptr make_shared_context() noexcept;
+} }
+----
 
-  template <class...  H>
-  context_ptr make_shared_context( H && ... ) noexcept;
+[.text-right]
+Reference: <<context>> | <<context_type_from_handlers>> | <<make_context>>
+====
+
+[[diagnostics.hpp]]
+==== `diagnostics.hpp`
+
+====
+.#include <boost/leaf/diagnostics.hpp>
+[source,c++]
+----
+namespace boost { namespace leaf {
+
+  class diagnostic_info: public error_info
+  {
+    //No public constructors
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, diagnostic_info const & );
+  };
+
+  class diagnostic_details: public error_info
+  {
+    //No public constructors
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, diagnostic_info const & );
+  };
 
 } }
 ----
 
 [.text-right]
-Reference: <<context>> | <<context_type_from_handlers>> | <<make_context>> | <<make_shared_context>>
+Reference: <<diagnostic_info>> | <<diagnostic_details>>
 ====
 
 [[handle_errors.hpp]]
@@ -2723,7 +2680,11 @@ namespace boost { namespace leaf {
   typename std::decay<decltype(std::declval<TryBlock>()())>::type
   try_catch( TryBlock && try_block, H && ... h );
 
-  //////////////////////////////////////////
+#if BOOST_LEAF_CFG_CAPTURE
+  template <class TryBlock>
+  result<T> // T deduced depending on TryBlock return type
+  try_capture_all( TryBlock && try_block );
+#endif
 
   class error_info
   {
@@ -2736,52 +2697,15 @@ namespace boost { namespace leaf {
     bool exception_caught() const noexcept;
     std::exception const * exception() const noexcept;
 
-    friend std::ostream & operator<<( std::ostream & os, error_info const & x );
-  };
-
-  class diagnostic_info: public error_info
-  {
-    //No public constructors
-
-    friend std::ostream & operator<<( std::ostream & os, diagnostic_info const & x );
-  };
-
-  class verbose_diagnostic_info: public error_info
-  {
-    //No public constructors
-
-    friend std::ostream & operator<<( std::ostream & os, diagnostic_info const & x );
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, error_info const & );
   };
 
 } }
 ----
 
 [.text-right]
-Reference: <<try_handle_all>> | <<try_handle_some>> | <<try_catch>> | <<error_info>> | <<diagnostic_info>> | <<verbose_diagnostic_info>>
-====
-
-[[handle_errors.hpp]]
-==== `to_variant.hpp`
-
-====
-.#include <boost/leaf/to_variant.hpp>
-[source,c++]
-----
-namespace boost { namespace leaf {
-
-  // Requires at least C++17
-  template <class... E, class TryBlock>
-  std::variant<
-    typename std::decay<decltype(std::declval<TryBlock>()().value())>::type
-    std::tuple<
-      std::optional<E>...>>
-  to_variant( TryBlock && try_block );
-
-} }
-----
-
-[.text-right]
-Reference: <<to_variant>>
+Reference: <<try_handle_all>> | <<try_handle_some>> | <<try_catch>> | <<try_capture_all>> | <<error_info>>
 ====
 
 [[pred.hpp]]
@@ -2887,6 +2811,30 @@ namespace boost { namespace leaf {
 Reference: <<match>> | <<match_value>> | <<match_member>> | <<catch_>> | <<if_not>> | <<category,`category`>> | <<condition,`condition`>>
 ====
 
+[[to_variant.hpp]]
+==== `to_variant.hpp`
+
+====
+.#include <boost/leaf/to_variant.hpp>
+[source,c++]
+----
+namespace boost { namespace leaf {
+
+  // Requires at least C++17
+  template <class... E, class TryBlock>
+  std::variant<
+    typename std::decay<decltype(std::declval<TryBlock>()().value())>::type
+    std::tuple<
+      std::optional<E>...>>
+  to_variant( TryBlock && try_block );
+
+} }
+----
+
+[.text-right]
+Reference: <<to_variant>>
+====
+
 [[functions]]
 == Reference: Functions
 
@@ -2920,7 +2868,7 @@ namespace boost { namespace leaf {
 leaf::context<E1, E2, E3> ctx;
 
 {
-  auto active_context = activate_context(ctx); <1>
+  auto active_context = ctx.raii_activate(); <1>
 } <2>
 ----
 <1> Activate `ctx`.
@@ -2928,46 +2876,6 @@ leaf::context<E1, E2, E3> ctx;
 
 '''
 
-[[capture]]
-=== `capture`
-
-.#include <boost/leaf/capture.hpp>
-[source,c++]
-----
-namespace boost { namespace leaf {
-
-  template <class F, class... A>
-  decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
-  capture(std::shared_ptr<polymorphic_context> && ctx, F && f, A... a);
-
-} }
-----
-
-[.text-right]
-<<polymorphic_context>>
-
-This function can be used to capture error objects stored in a <<context>> in one thread and transport them to a different thread for handling, either in a `<<result,result>><T>` object or in an exception.
-
-Returns: :: The same type returned by `F`.
-
-Effects: :: Uses an internal <<context_activator>> to <<context::activate>> `*ctx`, then invokes `std::forward<F>(f)(std::forward<A>(a)...)`. Then:
-+
---
-* If the returned value `r` is not a `result<T>` type (see <<is_result_type>>), it is forwarded to the caller.
-* Otherwise:
-** If `!r`, the return value of `capture` is initialized with `ctx`;
-+
-NOTE: An object of type `leaf::<<result,result>><T>` can be initialized with a `std::shared_ptr<leaf::polymorphic_context>`.
-+
-** otherwise, it is initialized with `r`.
---
-+
-In case `f` throws, `capture` catches the exception in a `std::exception_ptr`, and throws a different exception of unspecified type that transports both the `std::exception_ptr` as well as `ctx`. This exception type is recognized by <<try_catch>>, which automatically unpacks the original exception and propagates the contents of `*ctx` (presumably, in a different thread).
-
-TIP: See also <<tutorial-async>> from the Tutorial.
-
-'''
-
 [[context_type_from_handlers]]
 === `context_type_from_handlers`
 
@@ -3025,82 +2933,6 @@ TIP: See also <<on_error>>.
 
 '''
 
-[[exception]]
-=== `exception`
-
-[source,c++]
-.#include <boost/leaf/exception.hpp>
-----
-namespace boost { namespace leaf {
-
-  template <class Ex, class... E> <1>
-  <<unspecified>> exception( Ex && ex, E && ... e ) noexcept;
-
-  template <class E1, class... E> <2>
-  <<unspecified>> exception( E1 && e1, E && ... e ) noexcept;
-
-  <<unspecified>> exception() noexcept; <3>
-
-  template <class Ex, class... E> <4>
-  <<unspecified>> exception( error_id id, Ex && ex, E && ... e ) noexcept;
-
-  template <class E1, class... E> <5>
-  <<unspecified>> exception( error_id id, E1 && e1, E && ... e ) noexcept;
-
-  <<unspecified>> exception( error_id id ) noexcept; <6>
-
-} }
-----
-The `exception` function is overloaded: it can be invoked with no arguments, or else there are several alternatives, selected using `std::enable_if` based on the type of the passed arguments:
-
-<1> Selected if the first argument is not of type `error_id` and is an exception object, that is, iff `Ex` derives publicly from `std::exception`. In this case the return value is of unspecified type which derives publicly from `Ex` *and* from class <<error_id>>, such that:
-* its `Ex` subobject is initialized by `std::forward<Ex>(ex)`;
-* its `error_id` subobject is initialized by `<<new_error,new_error>>(std::forward<E>(e)...`).
-
-<2> Selected if the first argument is not of type `error_id` and is not an exception object. In this case the return value is of unspecified type which derives publicly from `std::exception` *and* from class `error_id`, such that:
-** its `std::exception` subobject is default-initialized;
-** its `error_id` subobject is initialized by `<<new_error,new_error>>(std::forward<E1>(e1), std::forward<E>(e)...`).
-
-<3> If the fuction is invoked without arguments, the return value is of unspecified type which derives publicly from `std::exception` *and* from class `error_id`, such that:
-** its `std::exception` subobject is default-initialized;
-** its `error_id` subobject is initialized by `<<new_error,new_error>>()`.
-
-<4> Selected if the first argument is of type `error_id` and the second argument is an exception object, that is, iff `Ex` derives publicly from `std::exception`. In this case the return value is of unspecified type which derives publicly from `Ex` *and* from class <<error_id>>, such that:
-** its `Ex` subobject is initialized by `std::forward<Ex>(ex)`;
-** its `error_id` subobject is initialized by `id.<<error_id::load>>(std::forward<E>(e)...)`.
-
-<5> Selected if the first argument is of type `error_id` and the second argument is not an exception object. In this case the return value is of unspecified type which derives publicly from `std::exception` *and* from class `error_id`, such that:
-** its `std::exception` subobject is default-initialized;
-** its `error_id` subobject is initialized by `id.<<error_id::load>>(std::forward<E1>(e1), std::forward<E>(e)...`).
-
-<6> If `exception` is invoked with just an `error_id` object, the return value is of unspecified type which derives publicly from `std::exception` *and* from class `error_id`, such that:
-** its `std::exception` subobject is default-initialized;
-** its `error_id` subobject is initialized by copying from `id`.
-
-NOTE: The first three overloads return an exception object that is associated with a new `error_id`. The second three overloads return an exception object that is associated with the specified `error_id`.
-
-.Example 1:
-[source,c++]
-----
-struct my_exception: std::exception { };
-
-throw leaf::exception(my_exception{}); <1>
-----
-<1> Throws an exception of a type that derives from `error_id` and from `my_exception` (because `my_exception` derives from `std::exception`).
-
-.Example 2:
-[source,c++]
-----
-enum class my_error { e1=1, e2, e3 }; <1>
-
-throw leaf::exception(my_error::e1);
-----
-<1> Throws an exception of a type that derives from `error_id` and from `std::exception` (because `my_error` does not derive from `std::exception`).
-
-NOTE: To automatically capture `pass:[__FILE__]`, `pass:[__LINE__]` and `pass:[__FUNCTION__]` with the returned object, use <<BOOST_LEAF_EXCEPTION>> instead of `leaf::exception`.
-
-'''
-
 [[exception_to_result]]
 === `exception_to_result`
 
@@ -3115,7 +2947,7 @@ namespace boost { namespace leaf {
 } }
 ----
 
-This function can be used to catch exceptions from a lower-level library and convert them to `<<result,result>><T>`.
+This function can be used to catch exceptions from a lower-level library and convert them to `<<result>><T>`.
 
 Returns: :: Where `f` returns a type `T`, `exception_to_result` returns `leaf::result<T>`.
 
@@ -3220,46 +3052,16 @@ auto ctx = leaf::make_context( <1>
 
 '''
 
-[[make_shared_context]]
-=== `make_shared_context`
+[[new_error]]
+=== `new_error`
 
-.#include <boost/leaf/context.hpp>
+.#include <boost/leaf/error.hpp>
 [source,c++]
 ----
 namespace boost { namespace leaf {
 
-  template <class...  H>
-  context_ptr make_shared_context() noexcept
-  {
-    return std::make_shared<leaf_detail::polymorphic_context_impl<context_type_from_handlers<H...>>>();
-  }
-
-  template <class...  H>
-  context_ptr make_shared_context( H && ... ) noexcept
-  {
-    return std::make_shared<leaf_detail::polymorphic_context_impl<context_type_from_handlers<H...>>>();
-  }
-
-} }
-----
-
-[.text-right]
-<<context_type_from_handlers>>
-
-TIP: See also <<tutorial-async>> from the tutorial.
-
-'''
-
-[[new_error]]
-=== `new_error`
-
-.#include <boost/leaf/error.hpp>
-[source,c++]
-----
-namespace boost { namespace leaf {
-
-  template <class... Item>
-  error_id new_error(Item && ... item) noexcept;
+  template <class... Item>
+  error_id new_error(Item && ... item) noexcept;
 
 } }
 ----
@@ -3323,6 +3125,82 @@ TIP: See <<tutorial-on_error>> from the Tutorial.
 
 '''
 
+[[throw_exception]]
+=== `throw_exception`
+
+[source,c++]
+.#include <boost/leaf/exception.hpp>
+----
+namespace boost { namespace leaf {
+
+  template <class Ex, class... E> <1>
+  [[noreturn]] void throw_exception( Ex && ex, E && ... e );
+
+  template <class E1, class... E> <2>
+  [[noreturn]] void throw_exception( E1 && e1, E && ... e );
+
+  [[noreturn]] void throw_exception(); <3>
+
+  template <class Ex, class... E> <4>
+  [[noreturn]] void throw_exception( error_id id, Ex && ex, E && ... e );
+
+  template <class E1, class... E> <5>
+  [[noreturn]] void throw_exception( error_id id, E1 && e1, E && ... e );
+
+  [[noreturn]] void throw_exception( error_id id ); <6>
+
+} }
+----
+The `throw_exception` function is overloaded: it can be invoked with no arguments, or else there are several alternatives, selected using `std::enable_if` based on the type of the passed arguments. All overloads throw an exception:
+
+<1> Selected if the first argument is not of type `error_id` and is an exception object, that is, iff `Ex` derives publicly from `std::exception`. In this case the thrown exception is of unspecified type which derives publicly from `Ex` *and* from class <<error_id>>, such that:
+* its `Ex` subobject is initialized by `std::forward<Ex>(ex)`;
+* its `error_id` subobject is initialized by `<<new_error>>(std::forward<E>(e)...`).
+
+<2> Selected if the first argument is not of type `error_id` and is not an exception object. In this case the thrown exception is of unspecified type which derives publicly from `std::exception` *and* from class `error_id`, such that:
+** its `std::exception` subobject is default-initialized;
+** its `error_id` subobject is initialized by `<<new_error>>(std::forward<E1>(e1), std::forward<E>(e)...`).
+
+<3> If the fuction is invoked without arguments, the thrown exception is of unspecified type which derives publicly from `std::exception` *and* from class `error_id`, such that:
+** its `std::exception` subobject is default-initialized;
+** its `error_id` subobject is initialized by `<<new_error>>()`.
+
+<4> Selected if the first argument is of type `error_id` and the second argument is an exception object, that is, iff `Ex` derives publicly from `std::exception`. In this case the thrown exception is of unspecified type which derives publicly from `Ex` *and* from class <<error_id>>, such that:
+** its `Ex` subobject is initialized by `std::forward<Ex>(ex)`;
+** its `error_id` subobject is initialized by `id.<<error_id::load>>(std::forward<E>(e)...)`.
+
+<5> Selected if the first argument is of type `error_id` and the second argument is not an exception object. In this case the thrown exception is of unspecified type which derives publicly from `std::exception` *and* from class `error_id`, such that:
+** its `std::exception` subobject is default-initialized;
+** its `error_id` subobject is initialized by `id.<<error_id::load>>(std::forward<E1>(e1), std::forward<E>(e)...`).
+
+<6> If `exception` is invoked with just an `error_id` object, the thrown exception is of unspecified type which derives publicly from `std::exception` *and* from class `error_id`, such that:
+** its `std::exception` subobject is default-initialized;
+** its `error_id` subobject is initialized by copying from `id`.
+
+NOTE: The first three overloads throw an exception object that is associated with a new `error_id`. The second three overloads throw an exception object that is associated with the specified `error_id`.
+
+.Example 1:
+[source,c++]
+----
+struct my_exception: std::exception { };
+
+leaf::throw_exception(my_exception{}); <1>
+----
+<1> Throws an exception of a type that derives from `error_id` and from `my_exception` (because `my_exception` derives from `std::exception`).
+
+.Example 2:
+[source,c++]
+----
+enum class my_error { e1=1, e2, e3 }; <1>
+
+leaf::throw_exception(my_error::e1);
+----
+<1> Throws an exception of a type that derives from `error_id` and from `std::exception` (because `my_error` does not derive from `std::exception`).
+
+NOTE: To automatically capture `pass:[__FILE__]`, `pass:[__LINE__]` and `pass:[__FUNCTION__]` with the returned object, use <<BOOST_LEAF_THROW_EXCEPTION>> instead of `leaf::throw_exception`.
+
+'''
+
 [[to_variant]]
 === `to_variant`
 
@@ -3345,7 +3223,7 @@ Requires: ::
 
 * This function is only available under {CPP}-17 or newer.
 * The `try_block` function may not take any arguments.
-* The type returned by the `try_block` function must be a `result<T>` type (see <<is_result_type>>). It is valid for the `try_block` to return `leaf::<<result,result>><T>`, however this is not a requirement.
+* The type returned by the `try_block` function must be a `result<T>` type (see <<is_result_type>>). It is valid for the `try_block` to return `leaf::<<result>><T>`, however this is not a requirement.
 
 The `to_variant` function uses <<try_handle_all>> internally to invoke the `try_block` and capture the result in a `std::variant`. On success, the variant contains the `T` object from the produced `result<T>`. Otherwise, the variant contains a `std::tuple` where each `std::optional` element contains an object of type `E~i~` from the user-supplied sequence `E...`, or is empty if the failure did not produce an error object of that type.
 
@@ -3378,6 +3256,39 @@ assert(std::get<2>(t).value() == E3::e33); <3>
 
 '''
 
+[[try_capture_all]]
+=== `try_capture_all`
+
+.#include <boost/leaf/handle_errors.hpp>
+[source,c++]
+----
+#if BOOST_LEAF_CFG_CAPTURE
+
+namespace boost { namespace leaf {
+
+  template <class TryBlock>
+  result<T> // T deduced depending on TryBlock return type
+  try_capture_all( TryBlock && try_block ) noexcept;
+
+} }
+
+#endif
+----
+
+Return type: :: An instance of `leaf::<<result>><T>`, where T is deduced depending on the return type `R` of the `TryBlock`:
+* If `R` is a some type `Result<T>` for which <<is_result_type>> is true, `try_capture_all` returns `leaf::<<result>><T>`.
+* Otherwise it is assumed that the `TryBlock` reports errors by throwing exceptions, and the return value of `try_capture_all` is deduced as `leaf::result<R>`.
+
+Effects: :: `try_capture_all` executes `try_block`, catching and capturing all exceptions and all communicated error objects in the returned `leaf::result` object. The error objects are allocated dynamically.
+
+WARNING: Calls to `try_capture_all` must not be nested in `try_handle_all`/`try_handle_some`/`try_catch` or in another `try_capture_all`.
+
+NOTE: Under `BOOST_LEAF_CFG_CAPTURE=0`, `try_capture_all` is unavailable.
+
+See also: :: <<tutorial-async>>.
+
+'''
+
 [[try_catch]]
 === `try_catch`
 
@@ -3445,18 +3356,18 @@ namespace boost { namespace leaf {
 
 Requires: ::
 * The `try_block` function may not take any arguments.
-* The type `R` returned by the `try_block` function must be a `result<T>` type (see <<is_result_type>>). It is valid for the `try_block` to return `leaf::<<result,result>><T>`, however this is not a requirement.
+* The type `R` returned by the `try_block` function must be a `result<T>` type (see <<is_result_type>>). It is valid for the `try_block` to return `leaf::<<result>><T>`, however this is not a requirement.
 * Each of the `h...` functions:
 ** must return a type that can be used to initialize an object of the type `R`; in case R is a `result<void>` (that is, in case of success it does not communicate a value), handlers that return `void` are permitted. If such a handler is selected, the `try_handle_some` return value is initialized by `{}`;
 ** may take any error objects, by value, by (`const`) reference, or as pointer (to `const`);
-** may take arguments, by value, of any predicate type: <<catch_>>, <<match>>, <<match_value>>, <<match_member>>, <<if_not>>, or of any user-defined predicate type `Pred` for which `<<is_predicate,is_predicate>><Pred>::value` is `true`;
+** may take arguments, by value, of any predicate type: <<catch_>>, <<match>>, <<match_value>>, <<match_member>>, <<if_not>>, or of any user-defined predicate type `Pred` for which `<<is_predicate>><Pred>::value` is `true`;
 ** may take an <<error_info>> argument by `const &`;
 ** may take a <<diagnostic_info>> argument by `const &`;
-** may take a <<verbose_diagnostic_info>> argument by `const &`.
+** may take a <<diagnostic_details>> argument by `const &`.
 
 Effects: ::
 
-* Creates a local `<<context,context>><E...>` object `ctx`, where the `E...` types are automatically deduced from the types of arguments taken by each of `h...`, which guarantees that `ctx` is able to store all of the types required to handle errors.
+* Creates a local `<<context>><E...>` object `ctx`, where the `E...` types are automatically deduced from the types of arguments taken by each of `h...`, which guarantees that `ctx` is able to store all of the types required to handle errors.
 * Invokes the `try_block`:
 ** if the returned object `r` indicates success [.underline]#and# the `try_block` did not throw, `r` is forwarded to the caller.
 ** otherwise, LEAF  considers each of the `h...` handlers, in order, until it finds one that it can supply with arguments using the error objects currently stored in `ctx`, associated with `r.error()`. The first such handler is invoked and its return value is used to initialize the return value of `try_handle_some`, which can indicate success if the handler was able to handle the error, or failure if it was not.
@@ -3536,7 +3447,7 @@ try_handle_some(
 <1> This handler can be selected to handle any error, because it takes `e_file_name` as a `const *` (and nothing else).
 <2> If an `e_file_name` is available with the current error, print it.
 +
-* If `a~i~` is of a predicate type `Pred` (for which `<<is_predicate,is_predicate>><Pred>::value` is `true`), `E` is deduced as `typename Pred::error_type`, and then:
+* If `a~i~` is of a predicate type `Pred` (for which `<<is_predicate>><Pred>::value` is `true`), `E` is deduced as `typename Pred::error_type`, and then:
 ** If `E` is not `void`, and an error object `e` of type `E`, associated with `err`, is not currently stored in `ctx`, the handler is dropped; otherwise the handler is dropped  if the expression `Pred::evaluate(e)` returns `false`.
 ** if `E` is `void`, and a `std::exception` was not caught, the handler is dropped; otherwise the handler is dropped if the expression `Pred::evaluate(e)`, where `e` is of type `std::exception const &`, returns `false`.
 ** To invoke the handler, the `Pred` argument `a~i~` is initialized with `Pred{e}`.
@@ -3558,7 +3469,7 @@ try_handle_some(
 
   [](leaf::error_info const & info) <1>
   {
-    std::cerr << "leaf::error_info:" << std::endl << info; <2>
+    std::cerr << "leaf::error_info:\n" << info; <2>
     return info.error(); <3>
   } );
 ----
@@ -3585,7 +3496,7 @@ try_handle_some(
 
   [](leaf::diagnostic_info const & info) <1>
   {
-    std::cerr << "leaf::diagnostic_information:" << std::endl << info; <2>
+    std::cerr << "leaf::diagnostic_information:\n" << info; <2>
     return info.error(); <3>
   } );
 ----
@@ -3597,7 +3508,7 @@ try_handle_some(
 <2> Print diagnostic information, including limited information about dropped error objects.
 <3> Return the original error, which will be returned out of `try_handle_some`.
 +
-* If `a~i~` is of type `verbose_diagnostic_info const &`,  `try_handle_some` is always able to produce it.
+* If `a~i~` is of type `diagnostic_details const &`,  `try_handle_some` is always able to produce it.
 +
 .Example:
 [source,c++]
@@ -3610,15 +3521,15 @@ try_handle_some(
     return f(); // throws
   },
 
-  [](leaf::verbose_diagnostic_info const & info) <1>
+  [](leaf::diagnostic_details const & info) <1>
   {
-    std::cerr << "leaf::verbose_diagnostic_information:" << std::endl << info; <2>
+    std::cerr << "leaf::diagnostic_details\n" << info; <2>
     return info.error(); <3>
   } );
 ----
 +
 [.text-right]
-<<result>> | <<verbose_diagnostic_info>>
+<<result>> | <<diagnostic_details>>
 +
 <1> This handler matches any error.
 <2> Print verbose diagnostic information, including values of dropped error objects.
@@ -3656,7 +3567,7 @@ namespace boost { namespace leaf {
     void deactivate() noexcept;
     bool is_active() const noexcept;
 
-    void propagate( error_id ) noexcept;
+    void unload( error_id ) noexcept;
 
     void print( std::ostream & os ) const;
 
@@ -3671,7 +3582,7 @@ namespace boost { namespace leaf {
 } }
 ----
 [.text-right]
-<<context::context>> | <<context::activate>> | <<context::deactivate>> | <<context::is_active>> | <<context::propagate>> | <<context::print>> | <<context::handle_error>> | <<context_type_from_handlers>>
+<<context::context>> | <<context::activate>> | <<context::deactivate>> | <<context::is_active>> | <<context::unload>> | <<context::print>> | <<context::handle_error>> | <<context_type_from_handlers>>
 
 The `context` class template provides storage for each of the specified `E...` types. Typically, `context` objects are not used directly; they're created internally when the <<try_handle_some>>, <<try_handle_all>> or <<try_catch>> functions are invoked, instantiated with types that are automatically deduced from the types of the arguments of the passed handlers.
 
@@ -3681,7 +3592,7 @@ Even in that case it is recommended that users do not instantiate the `context`
 
 To be able to load up error objects in a `context` object, it must be activated. Activating a `context` object `ctx` binds it to the calling thread, setting thread-local pointers of the stored `E...` types to point to the corresponding storage within `ctx`. It is possible, even likely, to have more than one active `context` in any given thread. In this case, activation/deactivation must happen in a LIFO manner. For this reason, it is best to use a <<context_activator>>, which relies on RAII to activate and deactivate a `context`.
 
-When a `context` is deactivated, it detaches from the calling thread, restoring the thread-local pointers to their pre-`activate` values. Typically, at this point the stored error objects, if any, are either discarded (by default) or moved to corresponding storage in other `context` objects active in the calling thread (if available), by calling <<context::propagate>>.
+When a `context` is deactivated, it detaches from the calling thread, restoring the thread-local pointers to their pre-`activate` values. Typically, at this point the stored error objects, if any, are either discarded (by default) or moved to corresponding storage in other `context` objects active in the calling thread (if available), by calling <<context::unload>>.
 
 While error handling typically uses <<try_handle_some>>, <<try_handle_all>> or <<try_catch>>, it is also possible to handle errors by calling the member function <<context::handle_error>>. It takes an <<error_id>>, and attempts to select an error handler based on the error objects stored in `*this`, associated with the passed `error_id`.
 
@@ -3730,11 +3641,11 @@ namespace boost { namespace leaf {
 } }
 ----
 
-Requires: :: `!<<context::is_active,is_active>>()`.
+Requires: :: `!<<context::is_active>>()`.
 
 Effects: :: Associates `*this` with the calling thread.
 
-Ensures: :: `<<context::is_active,is_active>>()`.
+Ensures: :: `<<context::is_active>>()`.
 
 When a context is associated with a thread, thread-local pointers are set to point each `E...` type in its store, while the previous value of each such pointer is preserved in the `context` object, so that the effect of `activate` can be undone by calling `deactivate`.
 
@@ -3757,12 +3668,12 @@ namespace boost { namespace leaf {
 ----
 
 Requires: ::
-* `<<context::is_active,is_active>>()`;
+* `<<context::is_active>>()`;
 * `*this` must be the last activated `context` object in the calling thread.
 
 Effects: :: Un-associates `*this` with the calling thread.
 
-Ensures: :: `!<<context::is_active,is_active>>()`.
+Ensures: :: `!<<context::is_active>>()`.
 
 When a context is deactivated, the thread-local pointers that currently point to each individual error object storage in it are restored to their original value prior to calling <<context::activate>>.
 
@@ -3818,6 +3729,13 @@ namespace boost { namespace leaf {
   template <class... E>
   void context<E...>::print( std::ostream & os ) const;
 
+  template <class CharT, class Traits>
+  friend std::ostream & context<E...>::operator<<( std::basic_ostream<CharT, Traits> &, context const & )
+  {
+      ctx.print(os);
+      return os;
+  }
+
 } }
 ----
 
@@ -3825,8 +3743,8 @@ Effects: :: Prints all error objects currently stored in `*this`, together with
 
 '''
 
-[[context::propagate]]
-==== `propagate`
+[[context::unload]]
+==== `unload`
 
 .#include <boost/leaf/context.hpp>
 [source,c++]
@@ -3834,13 +3752,13 @@ Effects: :: Prints all error objects currently stored in `*this`, together with
 namespace boost { namespace leaf {
 
   template <class... E>
-  void context<E...>::propagate( error_id id ) noexcept;
+  void context<E...>::unload( error_id id ) noexcept;
 
 } }
 ----
 
 Requires: ::
-`!<<context::is_active,is_active>>()`.
+`!<<context::is_active>>()`.
 
 Effects: ::
 
@@ -3884,10 +3802,47 @@ For automatic deduction of `Ctx`, use <<activate_context>>.
 
 '''
 
+[[diagnostic_details]]
+=== `diagnostic_details`
+
+.#include <boost/leaf/diagnostics.hpp>
+[source,c++]
+----
+namespace boost { namespace leaf {
+
+  class diagnostic_details: public error_info
+  {
+    //Constructors unspecified
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, diagnostic_details const & );
+  };
+
+} }
+----
+
+Handlers passed to error handling functions such as <<try_handle_some>>, <<try_handle_all>> or <<try_catch>> may take an argument of type `diagnostic_details const &` if they need to print diagnostic information about the error.
+
+The message printed by `operator<<` includes the message printed by `error_info`, followed by information about error objects that were communicated to LEAF (to be associated with the error) for which there was no storage available in any active <<context>> (these error objects were discarded by LEAF, because no handler needed them).
+
+The additional information includes the types and the values of all such error objects (but see  <<show_in_diagnostics>>).
+
+[NOTE]
+--
+The behavior of `diagnostic_details` (and <<diagnostic_info>>) is affected by the value of the macro `BOOST_LEAF_CFG_DIAGNOSTICS`:
+
+* If it is 1 (the default), LEAF produces `diagnostic_details` but only if an active error handling context on the call stack takes an argument of type `diagnostic_details`;
+* If it is 0, the `diagnostic_details` functionality is stubbed out even for error handling contexts that take an argument of type `diagnostic_details`. This could save some cycles on the error path in some programs (but is probably not worth it).
+--
+
+WARNING: Using `diagnostic_details` may allocate memory dynamically, but only if an active error handler takes an argument of type `diagnostic_details`.
+
+'''
+
 [[diagnostic_info]]
 === `diagnostic_info`
 
-.#include <boost/leaf/handle_errors.hpp>
+.#include <boost/leaf/diagnostics.hpp>
 [source,c++]
 ----
 namespace boost { namespace leaf {
@@ -3896,7 +3851,8 @@ namespace boost { namespace leaf {
   {
     //Constructors unspecified
 
-    friend std::ostream & operator<<( std::ostream & os, diagnostic_info const & x );
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, diagnostic_info const & );
   };
 
 } }
@@ -3910,14 +3866,12 @@ The additional information is limited to the type name of the first such error o
 
 [NOTE]
 --
-The behavior of `diagnostic_info` (and <<verbose_diagnostic_info>>) is affected by the value of the macro `BOOST_LEAF_CFG_DIAGNOSTICS`:
+The behavior of `diagnostic_info` (and <<diagnostic_details>>) is affected by the value of the macro `BOOST_LEAF_CFG_DIAGNOSTICS`:
 
 * If it is 1 (the default), LEAF produces `diagnostic_info` but only if an active error handling context on the call stack takes an argument of type `diagnostic_info`;
 * If it is 0, the `diagnostic_info` functionality is stubbed out even for error handling contexts that take an argument of type `diagnostic_info`. This could shave a few cycles off the error path in some programs (but it is probably not worth it).
 --
 
-'''
-
 [[error_id]]
 === `error_id`
 
@@ -3949,7 +3903,8 @@ namespace boost { namespace leaf {
     template <class... Item>
     error_id load( Item && ... item ) const noexcept;
 
-    friend std::ostream & operator<<( std::ostream & os, error_id x );
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, error_id );
   };
 
   bool is_error_id( std::error_code const & ec ) noexcept;
@@ -3998,7 +3953,7 @@ TIP: To check if a given `std::error_code` is actually carrying an `error_id`, u
 Typically, users create new `error_id` objects by invoking <<new_error>>. The constructor that takes `std::error_code`, and the one that takes a type `Enum` for which `std::is_error_code_enum<Enum>::value` is `true`, have the following effects:
 
 * If `ec.value()` is `0`, the effect is the same as using the default constructor.
-* Otherwise, if `<<is_error_id,is_error_id>>(ec)` is `true`, the original `error_id` value is used to initialize `*this`;
+* Otherwise, if `<<is_error_id>>(ec)` is `true`, the original `error_id` value is used to initialize `*this`;
 * Otherwise, `*this` is initialized by the value returned by <<new_error>>, while `ec` is passed to `load`, which enables handlers used with `try_handle_some`, `try_handle_all` or `try_catch` to receive it as an argument of type `std::error_code`.
 
 '''
@@ -4037,10 +3992,10 @@ namespace boost { namespace leaf {
 Requires: :: Each of the `Item...` types must be no-throw movable.
 
 Effects: ::
-* If `value()==0`, all of `item...` are discarded and no further action is taken.
+* If `thispass:[->]value()==0`, all of `item...` are discarded and no further action is taken.
 * Otherwise, what happens with each `item` depends on its type:
 ** If it is a function that takes a single argument of some type `E &`, that function is called with the object of type `E` currently associated with `*this`. If no such object exists, a default-initialized object is associated with `*this` and then passed to the function.
-** If it is a function that takes no arguments, than function is called to obtain an error object, which is associated with `*this`.
+** If it is a function that takes no arguments, that function is called to obtain an error object which is associated with `*this`, except in the special case of a `void` function, in which case it is invoked and no error object is obtained/loaded.
 ** Otherwise, the `item` itself is assumed to be an error object, which is associated with `*this`.
 
 Returns: :: `*this`.
@@ -4236,7 +4191,9 @@ namespace boost { namespace leaf {
   {
     int value;
     explicit e_errno(int value=errno);
-    friend std::ostream & operator<<( std::ostream & os, e_errno const & err );
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, e_errno const & );
   };
 
 } }
@@ -4283,7 +4240,9 @@ namespace boost { namespace leaf {
 
 #if BOOST_LEAF_CFG_WIN32
       e_LastError();
-      friend std::ostream & operator<<(std::ostream &, e_LastError const &);
+
+      template <class CharT, class Traits>
+      friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, e_LastError const & );
 #endif
     };
   }
@@ -4309,13 +4268,14 @@ namespace boost { namespace leaf {
     int line;
     char const * function;
 
-    friend std::ostream & operator<<( std::ostream & os, e_source_location const & x );
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, e_source_location const & );
   };
 
 } }
 ----
 
-The <<BOOST_LEAF_NEW_ERROR>>, <<BOOST_LEAF_EXCEPTION>> and <<BOOST_LEAF_THROW_EXCEPTION>> macros capture `pass:[__FILE__]`, `pass:[__LINE__]` and `pass:[__FUNCTION__]` into a `e_source_location` object.
+The <<BOOST_LEAF_NEW_ERROR>> and <<BOOST_LEAF_THROW_EXCEPTION>> macros capture `pass:[__FILE__]`, `pass:[__LINE__]` and `pass:[__FUNCTION__]` into a `e_source_location` object.
 
 '''
 
@@ -4355,7 +4315,8 @@ namespace boost { namespace leaf {
     bool exception_caught() const noexcept;
     std::exception const * exception() const noexcept;
 
-    friend std::ostream & operator<<( std::ostream & os, error_info const & x );
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, error_info const & );
   };
 
 } }
@@ -4375,39 +4336,6 @@ The `operator<<` overload prints diagnostic information about each error object
 
 '''
 
-[[polymorphic_context]]
-=== `polymorphic_context`
-
-.#include <boost/leaf/error.hpp>
-[source,c++]
-----
-namespace boost { namespace leaf {
-
-  class polymorphic_context
-  {
-  protected:
-
-    polymorphic_context() noexcept;
-    ~polymorphic_context() noexcept;
-
-  public:
-
-    virtual void activate() noexcept = 0;
-    virtual void deactivate() noexcept = 0;
-    virtual bool is_active() const noexcept = 0;
-
-    virtual void propagate( error_id ) noexcept = 0;
-
-    virtual void print( std::ostream & ) const = 0;
-  };
-
-} }
-----
-
-The `polymorphic_context` class is an abstract base type which can be used to erase the type of the exact instantiation of the <<context>> class template used. See <<make_shared_context>>.
-
-'''
-
 [[result]]
 === `result`
 
@@ -4421,48 +4349,66 @@ namespace boost { namespace leaf {
   {
   public:
 
+    using value_type = T;
+
+    // NOTE: Copy constructor implicitly deleted.
+    result( result && r ) noexcept;
+
+    template <class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
+    result( result<U> && r ) noexcept;
+
     result() noexcept;
+
     result( T && v ) noexcept;
-    result( T const & v );
 
-    template <class U>
-    result( U &&, <<enabled_if_T_can_be_inited_with_U>> );
+    result( T const & v );
 
     result( error_id err ) noexcept;
-    result( std::shared_ptr<polymorphic_context> && ctx ) noexcept;
 
-    template <class Enum>
-    result( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type * = 0 ) noexcept;
+    template <class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
+    result( U && u );
+
+#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     result( std::error_code const & ec ) noexcept;
 
-    result( result && r ) noexcept;
+    template <class Enum, class = typename std::enable_if<std::is_error_code_enum<Enum>::value, int>::type>
+    result( Enum e ) noexcept;
 
-    template <class U>
-    result( result<U> && r ) noexcept;
+#endif
 
+    // NOTE: Assignment operator implicitly deleted.
     result & operator=( result && r ) noexcept;
 
-    template <class U>
+    template <class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
     result & operator=( result<U> && r ) noexcept;
 
     bool has_value() const noexcept;
     bool has_error() const noexcept;
     explicit operator bool() const noexcept;
 
-    T const & value() const;
-    T & value();
+    T const & value() const &;
+    T & value() &;
+    T const && value() const &&;
+    T && value() &&;
 
     T const * operator->() const noexcept;
     T * operator->() noexcept;
 
-    T const & operator*() const noexcept;
-    T & operator*() noexcept;
+    T const & operator*() const & noexcept;
+    T & operator*() & noexcept;
+    T const && operator*() const && noexcept;
+    T && operator*() && noexcept;
 
     <<unspecified-type>> error() noexcept;
 
     template <class... Item>
     error_id load( Item && ... item ) noexcept;
+    
+    void unload();
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, result const & );
   };
 
   template <>
@@ -4470,40 +4416,54 @@ namespace boost { namespace leaf {
   {
   public:
 
+    using value_type = void;
+
+    // NOTE: Copy constructor implicitly deleted.
+    result( result && r ) noexcept;
+
     result() noexcept;
 
     result( error_id err ) noexcept;
-    result( std::shared_ptr<polymorphic_context> && ctx ) noexcept;
 
-    template <class Enum>
-    result( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type * = 0 ) noexcept;
+#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     result( std::error_code const & ec ) noexcept;
 
-    result( result && r ) noexcept;
+    template <class Enum, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type>
+    result( Enum e ) noexcept;
 
-    template <class U>
-    result( result<U> && r ) noexcept;
+#endif
 
+    // NOTE: Assignment operator implicitly deleted.
     result & operator=( result && r ) noexcept;
 
-    template <class U>
-    result & operator=( result<U> && r ) noexcept;
-
-    bool has_value() const noexcept;
-    bool has_error() const noexcept;
     explicit operator bool() const noexcept;
 
     void value() const;
 
+    void const * operator->() const noexcept;
+    void * operator->() noexcept;
+
+    void operator*() const noexcept;
+
     <<unspecified-type>> error() noexcept;
 
     template <class... Item>
     error_id load( Item && ... item ) noexcept;
+    
+    void unload();
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, result const &);
   };
 
   struct bad_result: std::exception { };
 
+  template <class T>
+  struct is_result_type<result<T>>: std::true_type
+  {
+  };
+
 } }
 ----
 [.text-right]
@@ -4514,9 +4474,9 @@ The `result<T>` type can be returned by functions which produce a value of type
 Requires: :: `T` must be movable, and its move constructor may not throw.
 
 Invariant: :: A `result<T>` object is in one of three states:
-* Value state, in which case it contains an object of type `T`, and <<result::value>>/<<result::operator_deref>>/<<result::operator_ptr>> can be used to access the contained value.
+* Value state, in which case it contains an object of type `T`, and <<result::value>> / <<result::operator_deref>> / <<result::operator_ptr>> can be used to access the contained value.
 * Error state, in which case it contains an error ID, and calling <<result::value>> throws `leaf::bad_result`.
-* Error capture state, which is the same as the Error state, but in addition to the error ID, it holds a `std::shared_ptr<<<polymorphic_context,polymorphic_context>>>`.
+* Dynamic capture state, which is the same as the Error state, but in addition to the error ID, it holds a list of dynamically captured error objects; see <<try_capture_all>>.
 
 `result<T>` objects are nothrow-moveable but are not copyable.
 
@@ -4531,49 +4491,51 @@ Invariant: :: A `result<T>` object is in one of three states:
 ----
 namespace boost { namespace leaf {
 
-  template <class T>
-  result<T>::result() noexcept;
+    // NOTE: Copy constructor implicitly deleted.
 
-  template <class T>
-  result<T>::result( T && v ) noexcept; <1>
+    template <class T>
+    result<T>::result( result && r ) noexcept;
 
-  template <class T>
-  result<T>::result( T const & v ); <1>
+    template <class T>
+    template <class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
+    result<T>::result( result<U> && r ) noexcept;
 
-  template <class U>
-  result<T>::result( U && u, <<enabled_if_T_can_be_inited_with_U>> ); <2>
+    template <class T>
+    result<T>::result() noexcept;
 
-  template <class T>
-  result<T>::result( leaf::error_id err ) noexcept;
+    template <class T>
+    result<T>::result( T && v ) noexcept;
 
-  template <class T>
-  template <class Enum>
-  result<T>::result( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type * = 0 ) noexcept;
+    template <class T>
+    result<T>::result( T const & v );
 
-  template <class T>
-  result<T>::result( std::error_code const & ec ) noexcept;
+    template <class T>
+    result<T>::result( error_id err ) noexcept;
 
-  template <class T>
-  result<T>::result( std::shared_ptr<polymorphic_context> && ctx ) noexcept;
+    template <class T>
+    template <class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
+    result<T>::result( U && u );
 
-  template <class T>
-  result<T>::result( result && ) noexcept;
+#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
-  template <class T>
-  template <class U>
-  result<T>::result( result<U> && ) noexcept;
+    template <class T>
+    result<T>::result( std::error_code const & ec ) noexcept;
+
+    template <class T>
+    template <class Enum, class = typename std::enable_if<std::is_error_code_enum<Enum>::value, int>::type>
+    result<T>::result( Enum e ) noexcept;
+
+#endif
 
 } }
 ----
-<1> Not available if `T` is `void`.
-<2> Available if an object of type `T` can be initialized with `std::forward<U>(u)`. This is to enable e.g. `result<std::string>` to be initialized with a string literal.
 --
 
 Requires: :: `T` must be movable, and its move constructor may not throw; or `void`.
 
 Effects: ::
 
-Establishes the `result<T>` invariant:
+Establishes the `result<T>` invariants:
 +
 --
 * To get a `result<T>` in <<result,Value state>>, initialize it with an object of type `T` or use the default constructor.
@@ -4584,7 +4546,7 @@ CAUTION: Initializing a `result<T>` with a default-initialized `error_id` object
 +
 ** a `std::error_code` object.
 ** an object of type `Enum` for which `std::is_error_code_enum<Enum>::value` is `true`.
-* To get a `result<T>` in <<result,Error capture state>>, initialize it with a `std::shared_ptr<<<polymorphic_context,polymorphic_context>>>` (which can be obtained by calling e.g. <<make_shared_context>>).
+* To get a `result<T>` in <<result,dynamic capture state>>, call <<try_capture_all>>.
 --
 +
 When a `result` object is initialized with a `std::error_code` object, it is used to initialize an `error_id` object, then the behavior is the same as if initialized with `error_id`.
@@ -4748,6 +4710,23 @@ namespace boost { namespace leaf {
 } }
 ----
 
+Effects:
+
+* If `*this` is in <<result,value state>>, returns a reference to the stored value.
+* If `*this` is in <<result,dynamic capture state>>, the captured error objects are unloaded, and:
+** If `*this` contains a captured exception object `ex`, the behavior is equivalent to `<<throw_exception>>(ex)`.
+** Otherwise, the behavior is equivalent to `<<throw_exception>>(bad_result{})`. 
+* If `*this` is in any other state, the behavior is equivalent to `<<throw_exception>>(bad_result{})`.
+
+'''
+
+[[result::value_type]]
+==== `value_type`
+
+A member type of `result<T>`, defined as a synonim for `T`.
+
+'''
+
 [[result::bad_result]]
 Effects: :: If `*this` is in <<result,value state>>, returns a reference to the stored value, otherwise throws `bad_result`.
 
@@ -4797,39 +4776,40 @@ Returns :: a reference to the stored value.
 
 '''
 
-[[verbose_diagnostic_info]]
-=== `verbose_diagnostic_info`
+[[show_in_diagnostics]]
+=== `show_in_diagnostics`
 
 .#include <boost/leaf/handle_errors.hpp>
 [source,c++]
 ----
 namespace boost { namespace leaf {
 
-  class verbose_diagnostic_info: public error_info
-  {
-    //Constructors unspecified
-
-    friend std::ostream & operator<<( std::ostream & os, verbose_diagnostic_info const & x );
-  };
+template <class E>
+struct show_in_diagnostics: std::true_type
+{
+};
 
 } }
 ----
 
-Handlers passed to error handling functions such as <<try_handle_some>>, <<try_handle_all>> or <<try_catch>> may take an argument of type `verbose_diagnostic_info const &` if they need to print diagnostic information about the error.
-
-The message printed by `operator<<` includes the message printed by `error_info`, followed by information about error objects that were communicated to LEAF (to be associated with the error) for which there was no storage available in any active <<context>> (these error objects were discarded by LEAF, because no handler needed them).
+This template can be specialized to prevent error objects of sensitive types from appearing in automatically generated diagnostic messages. Example:
 
-The additional information includes the types and the values of all such error objects.
+[source,c++]
+----
+struct e_user_name
+{
+  std::string value;
+};
 
-[NOTE]
---
-The behavior of `verbose_diagnostic_info` (and <<diagnostic_info>>) is affected by the value of the macro `BOOST_LEAF_CFG_DIAGNOSTICS`:
+namespace boost { namespace leaf {
 
-* If it is 1 (the default), LEAF produces `verbose_diagnostic_info` but only if an active error handling context on the call stack takes an argument of type `verbose_diagnostic_info`;
-* If it is 0, the `verbose_diagnostic_info` functionality is stubbed out even for error handling contexts that take an argument of type `verbose_diagnostic_info`. This could save some cycles on the error path in some programs (but is probably not worth it).
---
+  template <>
+  struct show_in_diagnostics<e_user_name>: std::false_type
+  {
+  };
 
-WARNING: Using `verbose_diagnostic_info` may allocate memory dynamically, but only if an active error handler takes an argument of type `verbose_diagnostic_info`.
+} }
+----
 
 [[predicates]]
 == Reference: Predicates
@@ -4846,7 +4826,7 @@ The following predicates are available:
 * <<catch_>>
 * <<if_not>>
 
-In addition, any user-defined type `Pred` for which `<<is_predicate,is_predicate>><Pred>::value` is `true` is treated as a predicate. In this case, it is required that:
+In addition, any user-defined type `Pred` for which `<<is_predicate>><Pred>::value` is `true` is treated as a predicate. In this case, it is required that:
 
 * `Pred` defines an accessible member type `error_type` to specify the error object type it requires;
 * `Pred` defines an accessible static member function `evaluate`, which returns a boolean type, and can be invoked with an object of type `error_type const &`;
@@ -5381,7 +5361,7 @@ The error handling functionality provided by <<try_handle_some>> and <<try_handl
 
 To use an external `result<T>`  type R, you must specialize the `is_result_type` template so that `is_result_type<R>::value` evaluates to `true`.
 
-Naturally, the provided `leaf::<<result,result>><T>` class template satisfies these requirements. In addition, it allows error objects to be transported across thread boundaries, using a `std::shared_ptr<<<polymorphic_context,polymorphic_context>>>`.
+Naturally, the provided `leaf::<<result>><T>` class template satisfies these requirements. In addition, it allows error objects to be transported across thread boundaries, using a <<try_capture_all>>.
 
 [[macros]]
 == Reference: Macros
@@ -5524,16 +5504,16 @@ If `BOOST_LEAF_CFG_GNUC_STMTEXPR` is `1` (which is the default under `pass:[__GN
 
 '''
 
-[[BOOST_LEAF_EXCEPTION]]
-=== `BOOST_LEAF_EXCEPTION`
+[[BOOST_LEAF_THROW_EXCEPTION]]
+=== `BOOST_LEAF_THROW_EXCEPTION`
 
 [source,c++]
 .#include <boost/leaf/exception.hpp>
 ----
-#define BOOST_LEAF_EXCEPTION <<voodoo>>
+#define BOOST_LEAF_THROW_EXCEPTION <<exact-dedfinition-unspecified>>
 ----
 
-Effects: :: `BOOST_LEAF_EXCEPTION(e...)` is equivalent to `leaf::<<exception,exception>>(e...)`, except the current source location is automatically passed, in a `<<e_source_location>>` object (in addition to all `e...` objects).
+Effects: :: `BOOST_LEAF_THROW_EXCEPTION(e...)` is equivalent to `leaf::<<throw_exception>>(e...)`, except the current source location is automatically communicated with the thrown exception, in a `<<e_source_location>>` object (in addition to all `e...` objects).
 
 '''
 
@@ -5543,41 +5523,145 @@ Effects: :: `BOOST_LEAF_EXCEPTION(e...)` is equivalent to `leaf::<<exception,exc
 .#include <boost/leaf/error.hpp>
 [source,c++]
 ----
-#define BOOST_LEAF_NEW_ERROR <<voodoo>>
+#define BOOST_LEAF_NEW_ERROR <<exact-definition-unspecified>>
 ----
 
-Effects: :: `BOOST_LEAF_NEW_ERROR(e...)` is equivalent to `leaf::<<new_error,new_error>>(e...)`, except the current source location is automatically passed, in a `<<e_source_location>>` object (in addition to all `e...` objects).
+Effects: :: `BOOST_LEAF_NEW_ERROR(e...)` is equivalent to `leaf::<<new_error>>(e...)`, except the current source location is automatically passed, in a `<<e_source_location>>` object (in addition to all `e...` objects).
 
-'''
+[[configuration]]
+== Configuration
 
-[[BOOST_LEAF_THROW_EXCEPTION]]
-=== `BOOST_LEAF_THROW_EXCEPTION`
+The following configuration macros are recognized:
 
-[source,c++]
-.#include <boost/leaf/exception.hpp>
-----
-#define BOOST_LEAF_THROW_EXCEPTION throw BOOST_LEAF_EXCEPTION
-----
+* `BOOST_LEAF_CFG_DIAGNOSTICS`: Defining this macro as `0` stubs out both <<diagnostic_info>> and <<diagnostic_details>> (if the macro is left undefined, LEAF defines it as `1`).
 
-Effects: :: Throws the exception object returned by <<BOOST_LEAF_EXCEPTION>>.
+* `BOOST_LEAF_CFG_STD_SYSTEM_ERROR`: Defining this macro as `0` disables the `std::error_code` / `std::error_condition` integration. In this case LEAF does not `#include <system_error>`, which may be too heavy for embedded platforms (if the macro is left undefined, LEAF defines it as `1`).
 
-[[rationale]]
-== Design
+* `BOOST_LEAF_CFG_STD_STRING`: Defining this macro as `0` disables all use of `std::string` (this requires `BOOST_LEAF_CFG_DIAGNOSTICS=0` as well). In this case LEAF does not `#include <string>` which may be too heavy for embedded platforms (if the macro is left undefined, LEAF defines it as `1`).
 
-=== Rationale
+* `BOOST_LEAF_CFG_CAPTURE`: Defining this macro as `0` disables <<try_capture_all>>, which (only if used) allocates memory dynamically (if the macro is left undefined, LEAF defines it as `1`).
 
-Definition: :: Objects that carry information about error conditions are called error objects. For example, objects of type `std::error_code` are error objects.
+* `BOOST_LEAF_CFG_GNUC_STMTEXPR`: This macro controls whether or not <<BOOST_LEAF_CHECK>> is defined in terms of a https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html[GNU C statement expression], which enables its use to check for errors similarly to how the questionmark operator works in some languages (see <<checking_for_errors>>). By default the macro is defined as `1` under `pass:[__GNUC__]`, otherwise as `0`.
 
-NOTE: The following reasoning is independent of the mechanism used to transport error objects, whether it is exception handling or anything else.
+* `BOOST_LEAF_CFG_WIN32`: Defining this macro as 1 enables the default constructor in <<e_LastError>>, and the automatic conversion to string (via `FormatMessageA`) when <<diagnostic_details>> is printed. If the macro is left undefined, LEAF defines it as `0` (even on windows, since including `windows.h` is generally not desirable). Note that the `e_LastError` type itself is available on all platforms, there is no need for conditional compilation in error handlers that use it.
 
-Definition: :: Depending on their interaction with error objects, functions can be classified as follows:
-* *Error initiating*: functions that initiate error conditions by creating new error objects.
-* *Error neutral*: functions that forward to the caller error objects communicated by lower-level functions they call.
-* *Error handling*: functions that dispose of error objects they have received, recovering normal program operation.
+* `BOOST_LEAF_NO_EXCEPTIONS`: Disables all exception handling support. If left undefined, LEAF defines it automatically based on the compiler configuration (e.g. `-fno-exceptions`).
 
-A crucial observation is that _error initiating_ functions are typically low-level functions that lack any context and can not determine, much less dictate, the correct program behavior in response to the errors they may initiate. Error conditions which (correctly) lead to termination in some programs may (correctly) be ignored in others; yet other programs may recover from them and resume normal operation.
+* `BOOST_LEAF_NO_THREADS`: Disables all thread safety in LEAF.
 
-The same reasoning applies to _error neutral_ functions, but in this case there is the additional issue that the errors they need to communicate, in general, are initiated by functions multiple levels removed from them in the call chain, functions which usually are -- and should be treated as -- implementation details. An _error neutral_ function should not be coupled with error object types communicated by _error initiating_ functions, for the same reason it should not be coupled with any other aspect of their interface.
+[[configuring_tls_access]]
+=== Configuring TLS Access
+
+LEAF requires support for thread-local `void` pointers. By default, this is implemented by means of the {CPP}11 `thread_local` keyword, but in order to support <<embedded_platforms,embedded platforms>>, it is possible to configure LEAF to use an array of thread local pointers instead, by defining `BOOST_LEAF_USE_TLS_ARRAY`. In this case, the user is required to define the following two functions to implement the required TLS access:
+
+[source,c++]
+----
+namespace boost { namespace leaf {
+
+namespace tls
+{
+    void * read_void_ptr( int tls_index ) noexcept;
+    void write_void_ptr( int tls_index, void * p ) noexcept;
+}
+
+} }
+----
+
+TIP: For efficiency, `read_void_ptr` and `write_void_ptr` should be defined `inline`.
+
+Under `BOOST_LEAF_USE_TLS_ARRAY` the following additional configuration macros are recognized:
+
+* `BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX` specifies the start TLS array index available to LEAF (if the macro is left undefined, LEAF defines it as `0`).
+
+* `BOOST_LEAF_CFG_TLS_ARRAY_SIZE` may be defined to specify the size of the TLS array. In this case TLS indices are validated via `BOOST_LEAF_ASSERT` before being passed to `read_void_ptr` / `write_void_ptr`.
+
+* `BOOST_LEAF_CFG_TLS_INDEX_TYPE` may be defined to specify the integral type used to store assigned TLS indices (if the macro is left undefined, LEAF defines it as `unsigned char`).
+
+TIP: Reporting error objects of types that are not used by the program to handle failures does not consume TLS pointers. The minimum size of the TLS pointer array required by LEAF is the total number of different types used as arguments to error handlers (in the entire program), plus one.
+
+WARNING: Beware of `read_void_ptr`/`write_void_ptr` accessing thread local pointers beyond the static boundaries of the thread local pointer array; this will likely result in undefined behavior.
+
+[[embedded_platforms]]
+=== Embedded Platforms
+
+Defining `BOOST_LEAF_EMBEDDED` is equivalent to the following:
+
+[source,c++]
+----
+#ifndef BOOST_LEAF_CFG_DIAGNOSTICS
+#   define BOOST_LEAF_CFG_DIAGNOSTICS 0
+#endif
+
+#ifndef BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+#   define BOOST_LEAF_CFG_STD_SYSTEM_ERROR 0
+#endif
+
+#ifndef BOOST_LEAF_CFG_STD_STRING
+#   define BOOST_LEAF_CFG_STD_STRING 0
+#endif
+
+#ifndef BOOST_LEAF_CFG_CAPTURE
+#   define BOOST_LEAF_CFG_CAPTURE 0
+#endif
+----
+
+LEAF supports FreeRTOS out of the box, please define `BOOST_LEAF_TLS_FREERTOS` (in which case LEAF automatically defines `BOOST_LEAF_EMBEDDED`, if it is not defined already).
+
+For other embedded platforms, please define `BOOST_LEAF_USE_TLS_ARRAY`, see <<configuring_tls_access>>.
+
+If your program does not use concurrency at all, simply define `BOOST_LEAF_NO_THREADS`, which requires no TLS support at all (but is NOT thread-safe).
+
+TIP: Contrary to popular belief, exception handling works great on embedded platforms. In https://www.youtube.com/watch?v=BGmzMuSDt-Y[this talk] Khalil Estell demonstrates that using exceptions to handle errors leads to a significant reduction in firmware code size (of course LEAF works with or without exception handling).
+
+[[portability]]
+== Portability
+
+The source code is compatible with {CPP}11 or newer.
+
+LEAF uses thread-local storage (only for pointers). By default, this is implemented via the {CPP}11 `thread_local` storage class specifier, but the library is easily configurable to use any platform-specific TLS API instead (it ships with built-in support for FreeRTOS). See <<configuration>>.
+
+== Running the Unit Tests
+
+The unit tests can be run with https://mesonbuild.com[Meson Build] or with Boost Build. To run the unit tests:
+
+=== Meson Build
+
+Clone LEAF into any local directory and execute:
+
+[source,sh]
+----
+cd leaf
+meson bld/debug
+cd bld/debug
+meson test
+----
+
+See `meson_options.txt` found in the root directory for available build options.
+
+=== Boost Build
+
+Assuming the current working directory is `<boostroot>/libs/leaf`:
+
+[source,sh]
+----
+../../b2 test
+----
+
+[[rationale]]
+== Design Rationale
+
+Definition: :: Objects that carry information about error conditions are called error objects. For example, objects of type `std::error_code` are error objects.
+
+NOTE: The following reasoning is independent of the mechanism used to transport error objects, whether it is exception handling or anything else.
+
+Definition: :: Depending on their interaction with error objects, functions can be classified as follows:
+* *Error initiating*: functions that initiate error conditions by creating new error objects.
+* *Error neutral*: functions that forward to the caller error objects communicated by lower-level functions they call.
+* *Error handling*: functions that dispose of error objects they have received, recovering normal program operation.
+
+A crucial observation is that _error initiating_ functions are typically low-level functions that lack any context and can not determine, much less dictate, the correct program behavior in response to the errors they may initiate. Error conditions which (correctly) lead to termination in some programs may (correctly) be ignored in others; yet other programs may recover from them and resume normal operation.
+
+The same reasoning applies to _error neutral_ functions, but in this case there is the additional issue that the errors they need to communicate, in general, are initiated by functions multiple levels removed from them in the call chain, functions which usually are -- and should be treated as -- implementation details. An _error neutral_ function should not be coupled with error object types communicated by _error initiating_ functions, for the same reason it should not be coupled with any other aspect of their interface.
 
 Finally, _error handling_ functions, by definition, have the full context they need to deal with at least some, if not all, failures. In their scope it is an absolute necessity that the author knows exactly what information must be communicated by lower level functions in order to recover from each error condition. Specifically, none of this necessary information can be treated as implementation details; in this case, the coupling which is to be avoided in _error neutral_ functions is in fact desirable.
 
@@ -5671,7 +5755,7 @@ leaf::try_catch(
 [.text-right]
 <<try_catch>> | <<e_file_name>> | <<e_errno>>
 
-Similar syntax works without exception handling as well. Below is the same snippet, written using `<<result,result>><T>`:
+Similar syntax works without exception handling as well. Below is the same snippet, written using `<<result>><T>`:
 
 [source,c++]
 ----
@@ -5708,185 +5792,21 @@ return leaf::try_handle_some(
 [.text-right]
 <<result>> | <<try_handle_some>> | <<match>> | <<e_file_name>> | <<e_errno>>
 
-NOTE: Please post questions and feedback on the Boost Developers Mailing List.
-
-'''
-
-[[exception_specifications]]
-=== Critique 1: Error Types Do Not Participate in Function Signatures
-
-A knee-jerk critique of the LEAF design is that it does not statically enforce that each possible error condition is recognized and handled by the program. One idea I've heard from multiple sources is to add `E...` parameter pack to `result<T>`, essentially turning it into `expected<T,E...>`, so we could write something along these lines:
-
-[source,c++]
-----
-expected<T, E1, E2, E3> f() noexcept; <1>
-
-expected<T, E1, E3> g() noexcept <2>
-{
-  if( expected<T, E1, E2, E3> r = f() )
-  {
-    return r; //Success, return the T
-  }
-  else
-  {
-    return r.handle_error<E2>( [] ( .... ) <3>
-      {
-        ....
-      } );
-  }
-}
-----
-<1> `f` may only return error objects of type `E1`, `E2`, `E3`.
-<2> `g` narrows that to only `E1` and `E3`.
-<3> Because `g` may only return error objects of type `E1` and `E3`, it uses `handle_error` to deal with `E2`. In case `r` contains `E1` or `E3`, `handle_error` simply returns `r`, narrowing the error type parameter pack from `E1, E2, E3` down to `E1, E3`. If `r` contains an `E2`, `handle_error` calls the supplied lambda, which is required to return one of `E1`, `E3` (or a valid `T`).
-
-The motivation here is to help avoid bugs in functions that handle errors that pop out of `g`: as long as the programmer deals with `E1` and `E3`, he can rest assured that no error is left unhandled.
-
-Congratulations, we've just discovered exception specifications. The difference is that exception specifications, before being removed from {CPP}, were enforced dynamically, while this idea is equivalent to statically-enforced exception specifications, like they are in Java.
-
-Why not use the equivalent of exception specifications, even if they are enforced statically?
-
-"The short answer is that nobody knows how to fix exception specifications in any language, because the dynamic enforcement {CPP} chose has only different (not greater or fewer) problems than the static enforcement Java chose. ... When you go down the Java path, people love exception specifications until they find themselves all too often encouraged, or even forced, to add `throws Exception`, which immediately renders the exception specification entirely meaningless. (Example: Imagine writing a Java generic that manipulates an arbitrary type `T`).footnote:[https://herbsutter.com/2007/01/24/questions-about-exception-specifications/]"
--- Herb Sutter
-
-Consider again the example above: assuming we don't want important error-related information to be lost, values of type `E1` and/or `E3` must be able to encode any `E2` value dynamically. But like Sutter points out, in generic contexts we don't know what errors may result in calling a user-supplied function. The only way around that is to specify a single type (e.g. `std::error_code`) that can communicate any and all errors, which ultimately defeats the idea of using static type checking to enforce correct error handling.
-
-That said, in every program there are certain _error handling_ functions (e.g. `main`) which are required to handle any error, and it is highly desirable to be able to enforce this requirement at compile-time. In LEAF, the `try_handle_all` function implements this idea: if the user fails to supply at least one handler that will match any error, the result is a compile error. This guarantees that the scope invoking `try_handle_all` is prepared to recover from any failure.
-
-'''
-
-[[translation]]
-=== Critique 2: LEAF Does Not Facilitate Mapping Between Different Error Types
-
-Most {CPP} programs use multiple C and {CPP} libraries, and each library may provide its own system of error codes. But because it is difficult to define static interfaces that can communicate arbitrary error code types, a popular idea is to map each library-specific error code to a common program-wide enum.
-
-For example, if we have --
-
-[source,c++,options="nowrap"]
-----
-namespace lib_a
-{
-  enum error
-  {
-    ok,
-    ec1,
-    ec2,
-    ....
-  };
-}
-----
-
-[source,c++,options="nowrap"]
-----
-namespace lib_b
-{
-  enum error
-  {
-    ok,
-    ec1,
-    ec2,
-    ....
-  };
-}
-----
-
--- we could define:
-
-[source,c++]
-----
-namespace program
-{
-  enum error
-  {
-    ok,
-    lib_a_ec1,
-    lib_a_ec2,
-    ....
-    lib_b_ec1,
-    lib_b_ec2,
-    ....
-  };
-}
-----
-
-An error handling library could provide conversion API that uses the {CPP} static type system to automate the mapping between the different error enums. For example, it may define a class template `result<T,E>` with value-or-error variant semantics, so that:
-
-* `lib_a` errors are transported in `result<T,lib_a::error>`,
-* `lib_b` errors are transported in `result<T,lib_b::error>`,
-* then both are automatically mapped to `result<T,program::error>` once control reaches the appropriate scope.
-
-There are several problems with this idea:
-
-* It is prone to errors, both during the initial implementation as well as under maintenance.
-
-* It does not compose well. For example, if both of `lib_a` and `lib_b` use `lib_c`, errors that originate in `lib_c` would be obfuscated by the different APIs exposed by each of `lib_a` and `lib_b`.
-
-* It presumes that all errors in the program can be specified by exactly one error code, which is false.
+== Limitations
 
-To elaborate on the last point, consider a program that attempts to read a configuration file from three different locations: in case all of the attempts fail, it should communicate each of the failures. In theory `result<T,E>` handles this case well:
+When using dynamic linking, it is required that error types are declared with `default` visibility, e.g.:
 
 [source,c++]
 ----
-struct attempted_location
-{
-  std::string path;
-  error ec;
-};
-
-struct config_error
+struct __attribute__ ((visibility ("default"))) my_error_info
 {
-  attempted_location current_dir, user_dir, app_dir;
+    int value;
 };
-
-result<config,config_error> read_config();
-----
-
-This looks nice, until we realize what the `config_error` type means for the automatic mapping API we wanted to define: an `enum` can not represent a `struct`. It is a fact that we can not assume that all error conditions can be fully specified by an `enum`; an error handling library must be able to transport arbitrary static types efficiently.
-
-[[errors_are_not_implementation_details]]
-=== Critique 3: LEAF Does Not Treat Low Level Error Types as Implementation Details
-
-This critique is a combination of <<exception_specifications,Critique 1>> and <<translation,Critique 2>>, but it deserves special attention. Let's consider this example using LEAF:
-
-[source,c++]
-----
-leaf::result<std::string> read_line( reader & r );
-
-leaf::result<parsed_line> parse_line( std::string const & line );
-
-leaf::result<parsed_line> read_and_parse_line( reader & r )
-{
-  BOOST_LEAF_AUTO(line, read_line(r)); <1>
-  BOOST_LEAF_AUTO(parsed, parse_line(line)); <2>
-  return parsed;
-}
 ----
-[.text-right]
-<<result>> | <<BOOST_LEAF_AUTO>>
-
-<1> Read a line, forward errors to the caller.
-<2> Parse the line, forward errors to the caller.
-
-The objection is that LEAF will forward verbatim the errors that are detected in `read_line` or `parse_line` to the caller of  `read_and_parse_line`. The premise of this objection is that such low-level errors are implementation details and should be treated as such. Under this premise, `read_and_parse_line` should act as a translator of sorts, in both directions:
-
-* When called, it should translate its own arguments to call `read_line` and `parse_line`;
-* If an error is detected, it should translate the errors from the error types returned by `read_line` and `parse_line` to a higher-level type.
-
-The motivation is to isolate the caller of `read_and_parse_line` from its implementation details `read_line` and `parse_line`.
-
-There are two possible ways to implement this translation:
-
-*1)* `read_and_parse_line` understands the semantics of *all possible failures* that may be reported by both `read_line` and `parse_line`, implementing a non-trivial mapping which both _erases_ information that is considered not relevant to its caller, as well as encodes _different_ semantics in the error it reports. In this case `read_and_parse_line` assumes full responsibility for describing precisely what went wrong, using its own type specifically designed for the job.
 
-*2)* `read_and_parse_line` returns an error object that essentially indicates which of the two inner functions failed, and also transports the original error object without understanding its semantics and without any loss of information, wrapping it in a new error type.
+This works as expected except on Windows, where thread-local storage is not shared between the individual binary modules. For this reason, to transport error objects across DLL boundaries.
 
-The problem with *1)* is that typically the caller of `read_and_parse_line` is not going to handle the error, but it does need to forward it to its caller. In our attempt to protect the *one* error handling function from "implementation details", we've coupled the interface of *all* intermediate error neutral functions with the static types of errors they do not understand and do not handle.
-
-Consider the case where `read_line` communicates `errno` in its errors. What is `read_and_parse_line` supposed to do with e.g. `EACCESS`? Turn it into `READ_AND_PARSE_LINE_EACCESS`? To what end, other than to obfuscate the original (already complex and platform-specific) semantics of `errno`?
-
-And what if the call to `read` is polymorphic, which is also typical? What if it involves a user-supplied function object? What kinds of errors does it return and why should `read_and_parse_line` care?
-
-Therefore, we're left with *2)*. There's almost nothing wrong with this option, since it passes any and all error-related information from lower level functions without any loss. However, using a wrapper type to grant (presumably dynamic) access to any lower-level error type it may be transporting is cumbersome and (like Niall Douglas <<interoperability,explains>>) in general probably requires dynamic allocations. It is better to use independent error types that communicate the additional information not available in the original error object, while error handlers rely on LEAF to provide efficient access to any and all low-level error types, as needed.
+TIP: When using dynamic linking, it is always best to define module interfaces in terms of C (and implement them in {CPP} if appropriate).
 
 == Alternatives to LEAF
 
@@ -5943,12 +5863,12 @@ https://www.boost.org/doc/libs/release/libs/exception/doc/exception_operator_shl
 |
 [source,c++,options="nowrap"]
 ----
-throw leaf::exception( my_exception(),
+leaf::throw_exception( my_exception(),
   my_info{x},
   my_info{y} );
 ----
 [.text-right]
-<<exception>>
+<<throw_exception>>
 |====
 
 .Augmenting exceptions in error neutral contexts
@@ -6046,9 +5966,9 @@ leaf::try_catch(
 
 [WARNING]
 ====
-The fact that Boost Exception stores all supplied `boost::error_info` objects -- while LEAF discards them if they aren't needed -- affects the completeness of the message we get when we print `leaf::<<diagnostic_info,diagnostic_info>>` objects, compared to the string returned by https://www.boost.org/doc/libs/release/libs/exception/doc/diagnostic_information.html[`boost::diagnostic_information`].
+The fact that Boost Exception stores all supplied `boost::error_info` objects -- while LEAF discards them if they aren't needed -- affects the completeness of the message we get when we print `leaf::<<diagnostic_info>` objects, compared to the string returned by https://www.boost.org/doc/libs/release/libs/exception/doc/diagnostic_information.html[`boost::diagnostic_information`].
 
-If the user requires a complete diagnostic message, the solution is to use `leaf::<<verbose_diagnostic_info,verbose_diagnostic_info>>`. In this case, before unused error objects are discarded by LEAF, they are converted to string and printed. Note that this allocates memory dynamically.
+If the user requires a complete diagnostic message, the solution is to use `leaf::<<diagnostic_details>>`. In this case, before unused error objects are discarded by LEAF, they are converted to string and printed. Note that this allocates memory dynamically.
 ====
 
 '''
@@ -6112,143 +6032,6 @@ Further, consider that Outcome aims to hopefully become _the_ one error handling
 
 In contrast, the design of LEAF acknowledges that {CPP} programmers don't even agree on what a string is. If your project uses 10 different libraries, this probably means 15 different ways to report errors, sometimes across uncooperative interfaces (e.g. C APIs). LEAF helps you get the job done.
 
-== Benchmark
-
-https://github.com/boostorg/leaf/blob/master/benchmark/benchmark.md[This benchmark] compares the performance of LEAF, Boost Outcome and `tl::expected`.
-
-== Running the Unit Tests
-
-The unit tests can be run with https://mesonbuild.com[Meson Build] or with Boost Build. To run the unit tests:
-
-=== Meson Build
-
-Clone LEAF into any local directory and execute:
-
-[source,sh]
-----
-cd leaf
-meson bld/debug
-cd bld/debug
-meson test
-----
-
-See `meson_options.txt` found in the root directory for available build options.
-
-=== Boost Build
-
-Assuming the current working directory is `<boostroot>/libs/leaf`:
-
-[source,sh]
-----
-../../b2 test
-----
-
-[[configuration]]
-== Configuration
-
-The following configuration macros are recognized:
-
-* `BOOST_LEAF_CFG_DIAGNOSTICS`: Defining this macro as `0` stubs out both <<diagnostic_info>> and <<verbose_diagnostic_info>> (if the macro is left undefined, LEAF defines it as `1`).
-
-* `BOOST_LEAF_CFG_STD_SYSTEM_ERROR`: Defining this macro as `0` disables the `std::error_code` / `std::error_condition` integration. In this case LEAF does not `#include <system_error>`, which may be too heavy for embedded platforms (if the macro is left undefined, LEAF defines it as `1`).
-
-* `BOOST_LEAF_CFG_STD_STRING`: Defining this macro as `0` disables all use of `std::string` (this requires `BOOST_LEAF_CFG_DIAGNOSTICS=0` as well). In this case LEAF does not `#include <string>` which may be too heavy for embedded platforms (if the macro is left undefined, LEAF defines it as `1`).
-
-* `BOOST_LEAF_CFG_CAPTURE`: Defining this macro as `0` disables the ability of `leaf::result` to transport errors between threads. In this case LEAF does not `#include <memory>`, which may be too heavy for embedded platforms (if the macro is left undefined, LEAF defines it as `1`).
-
-* `BOOST_LEAF_CFG_GNUC_STMTEXPR`: This macro controls whether or not <<BOOST_LEAF_CHECK>> is defined in terms of a https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html[GNU C statement expression], which enables its use to check for errors similarly to how the questionmark operator works in some languages (see <<checking_for_errors>>). By default the macro is defined as `1` under `pass:[__GNUC__]`, otherwise as `0`.
-
-* `BOOST_LEAF_CFG_WIN32`: Defining this macro as 1 enables the default constructor in <<e_LastError>>, and the automatic conversion to string (via `FormatMessageA`) when <<verbose_diagnostic_info>> is printed. If the macro is left undefined, LEAF defines it as `0` (even on windows, since including `windows.h` is generally not desirable). Note that the `e_LastError` type itself is available on all platforms, there is no need for conditional compilation in error handlers that use it.
-
-* `BOOST_LEAF_NO_EXCEPTIONS`: Disables all exception handling support. If left undefined, LEAF defines it automatically based on the compiler configuration (e.g. `-fno-exceptions`).
-
-* `BOOST_LEAF_NO_THREADS`: Disables all thread safety in LEAF.
-
-[[configuring_tls_access]]
-=== Configuring TLS Access
-
-LEAF requires support for thread-local `void` pointers. By default, this is implemented by means of the {CPP}11 `thread_local` keyword, but in order to support <<embedded_platforms,embedded platforms>>, it is possible to configure LEAF to use an array of thread local pointers instead, by defining `BOOST_LEAF_USE_TLS_ARRAY`. In this case, the user is required to define the following two functions to implement the required TLS access:
-
-[source,c++]
-----
-namespace boost { namespace leaf {
-
-namespace tls
-{
-    void * read_void_ptr( int tls_index ) noexcept;
-    void write_void_ptr( int tls_index, void * p ) noexcept;
-}
-
-} }
-----
-
-TIP: For efficiency, `read_void_ptr` and `write_void_ptr` should be defined `inline`.
-
-Under `BOOST_LEAF_USE_TLS_ARRAY` the following additional configuration macros are recognized:
-
-* `BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX` specifies the start TLS array index available to LEAF (if the macro is left undefined, LEAF defines it as `0`).
-
-* `BOOST_LEAF_CFG_TLS_ARRAY_SIZE` may be defined to specify the size of the TLS array. In this case TLS indices are validated via `BOOST_LEAF_ASSERT` before being passed to `read_void_ptr` / `write_void_ptr`.
-
-* `BOOST_LEAF_CFG_TLS_INDEX_TYPE` may be defined to specify the integral type used to store assigned TLS indices (if the macro is left undefined, LEAF defines it as `unsigned char`).
-
-TIP: Reporting error objects of types that are not used by the program to handle failures does not consume TLS pointers. The minimum size of the TLS pointer array required by LEAF is the total number of different types used as arguments to error handlers (in the entire program), plus one.
-
-WARNING: Beware of `read_void_ptr`/`write_void_ptr` accessing thread local pointers beyond the static boundaries of the thread local pointer array; this will likely result in undefined behavior.
-
-[[embedded_platforms]]
-=== Embedded Platforms
-
-Defining `BOOST_LEAF_EMBEDDED` is equivalent to the following:
-
-[source,c++]
-----
-#ifndef BOOST_LEAF_CFG_DIAGNOSTICS
-#   define BOOST_LEAF_CFG_DIAGNOSTICS 0
-#endif
-
-#ifndef BOOST_LEAF_CFG_STD_SYSTEM_ERROR
-#   define BOOST_LEAF_CFG_STD_SYSTEM_ERROR 0
-#endif
-
-#ifndef BOOST_LEAF_CFG_STD_STRING
-#   define BOOST_LEAF_CFG_STD_STRING 0
-#endif
-
-#ifndef BOOST_LEAF_CFG_CAPTURE
-#   define BOOST_LEAF_CFG_CAPTURE 0
-#endif
-----
-
-LEAF supports FreeRTOS out of the box, please define `BOOST_LEAF_TLS_FREERTOS` (in which case LEAF automatically defines `BOOST_LEAF_EMBEDDED`, if it is not defined already).
-
-For other embedded platforms, please define `BOOST_LEAF_USE_TLS_ARRAY`, see <<configuring_tls_access>>.
-
-If your program does not use concurrency at all, simply define `BOOST_LEAF_NO_THREADS`, which requires no TLS support at all (but is NOT thread-safe).
-
-[[portability]]
-== Portability
-
-The source code is compatible with {CPP}11 or newer.
-
-LEAF uses thread-local storage (only for pointers). By default, this is implemented via the {CPP}11 `thread_local` storage class specifier, but the library is easily configurable to use any platform-specific TLS API instead (it ships with built-in support for FreeRTOS). See <<configuration>>.
-
-== Limitations
-
-When using dynamic linking, it is required that error types are declared with `default` visibility, e.g.:
-
-[source,c++]
-----
-struct __attribute__ ((visibility ("default"))) my_error_info
-{
-    int value;
-};
-----
-
-This works as expected except on Windows, where thread-local storage is not shared between the individual binary modules. For this reason, to transport error objects across DLL boundaries, it is required that they're captured in a <<polymorphic_context>>, just like when <<tutorial-async>>.
-
-TIP: When using dynamic linking, it is always best to define module interfaces in terms of C (and implement them in {CPP} if appropriate).
-
 == Acknowledgements
 
 Special thanks to Peter Dimov and Sorin Fetche.
diff --git a/doc/zajo-dark.css b/doc/zajo-dark.css
index 5d7986a0..4247e85e 100644
--- a/doc/zajo-dark.css
+++ b/doc/zajo-dark.css
@@ -448,7 +448,7 @@ a:hover{color:#00cc99}
 a:focus{color:#FFFFFF}
 h1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6{font-family:"Quicksand","DejaVu Sans",sans-serif;font-weight:300;font-style:normal;color:#00cc99;text-rendering:optimizeLegibility;margin-top:1em;margin-bottom:.5em;line-height:1.4em}
 code{font-family:"Anonymous Pro","DejaVu Sans Mono",monospace;font-weight:400;color:black}
-*:not(pre)>code{font-size:1.08em;font-style:normal!important;letter-spacing:0;padding:0 0;word-spacing:-.15em;background-color:transparent;-webkit-border-radius:0;border-radius:0;line-height:1.45;text-rendering:optimizeLegibility;word-wrap:break-word;color:white}
+*:not(pre)>code{font-size:1.0em;font-style:normal!important;letter-spacing:0;padding:0 0;word-spacing:-.15em;background-color:transparent;-webkit-border-radius:0;border-radius:0;line-height:1.45;text-rendering:optimizeLegibility;word-wrap:break-word;color:white}
 pre,pre>code{line-height:1.45;color:rgba(255,255,255,.67);font-family:"Anonymous Pro","DejaVu Sans Mono",monospace;font-weight:400;text-rendering:optimizeLegibility;font-size:1.05em;background-color:#101010}
 a:not(pre)>code:hover {color:#00cc99}
 kbd{font-family:"Anonymous Pro","DejaVu Sans Mono",monospace;display:inline-block;color:rgba(0,0,0,.8);font-size:.65em;line-height:1.45;background-color:#f7f7f7;border:1px solid #ccc;-webkit-border-radius:3px;border-radius:3px;-webkit-box-shadow:0 1px 0 rgba(0,0,0,.2),0 0 0 .1em white inset;box-shadow:0 1px 0 rgba(0,0,0,.2),0 0 0 .1em #fff inset;margin:0 .15em;padding:.2em .5em;vertical-align:middle;position:relative;top:-.1em;white-space:nowrap}
diff --git a/doc/zajo-light.css b/doc/zajo-light.css
index ac0dd299..89a5cdaf 100644
--- a/doc/zajo-light.css
+++ b/doc/zajo-light.css
@@ -442,7 +442,7 @@ a:hover{color:#4101a7}
 a:focus{color:#000000}
 h1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6{font-family:"Quicksand","DejaVu Sans",sans-serif;font-weight:300;font-style:normal;color:#4101a7;text-rendering:optimizeLegibility;margin-top:1em;margin-bottom:.5em;line-height:1.4em}
 code{font-family:"Anonymous Pro","DejaVu Sans Mono",monospace;font-weight:400;color:black}
-*:not(pre)>code{font-size:1.08em;font-style:normal!important;letter-spacing:0;padding:0 0;word-spacing:-.15em;background-color:transparent;-webkit-border-radius:0;border-radius:0;line-height:1.45;text-rendering:optimizeLegibility;word-wrap:break-word}
+*:not(pre)>code{font-size:1.0em;font-style:normal!important;letter-spacing:0;padding:0 0;word-spacing:-.15em;background-color:transparent;-webkit-border-radius:0;border-radius:0;line-height:1.45;text-rendering:optimizeLegibility;word-wrap:break-word}
 pre,pre>code{line-height:1.45;color:rgba(0,0,0,.9);font-family:"Anonymous Pro","DejaVu Sans Mono",monospace;font-weight:400;text-rendering:optimizeLegibility;font-size:1.05em;background-color:#f7f8f7}
 a:not(pre)>code:hover {color:#4101a7}
 kbd{font-family:"Anonymous Pro","DejaVu Sans Mono",monospace;display:inline-block;color:rgba(0,0,0,.8);font-size:.65em;line-height:1.45;background-color:#f7f7f7;border:1px solid #ccc;-webkit-border-radius:3px;border-radius:3px;-webkit-box-shadow:0 1px 0 rgba(0,0,0,.2),0 0 0 .1em white inset;box-shadow:0 1px 0 rgba(0,0,0,.2),0 0 0 .1em #fff inset;margin:0 .15em;padding:.2em .5em;vertical-align:middle;position:relative;top:-.1em;white-space:nowrap}
diff --git a/example/asio_beast_leaf_rpc.cpp b/example/asio_beast_leaf_rpc.cpp
deleted file mode 100644
index 8201a2ac..00000000
--- a/example/asio_beast_leaf_rpc.cpp
+++ /dev/null
@@ -1,565 +0,0 @@
-// Copyright (c) 2019 Sorin Fetche
-
-// 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)
-
-// PLEASE NOTE: This example requires the Boost 1.70 version of Asio and Beast,
-// which at the time of this writing is in beta.
-
-// Example of a composed asynchronous operation which uses the LEAF library for
-// error handling and reporting.
-//
-// Examples of running:
-// - in one terminal (re)run: ./asio_beast_leaf_rpc_v3 0.0.0.0 8080
-// - in another run:
-//      curl localhost:8080 -v -d "sum 0 1 2 3"
-//   generating errors returned to the client:
-//      curl localhost:8080 -v -X DELETE -d ""
-//      curl localhost:8080 -v -d "mul 1 2x3"
-//      curl localhost:8080 -v -d "div 1 0"
-//      curl localhost:8080 -v -d "mod 1"
-//
-// Runs that showcase the error handling on the server side:
-//  - error starting the server:
-//      ./asio_beast_leaf_rpc_v3 0.0.0.0 80
-//  - error while running the server logic:
-//      ./asio_beast_leaf_rpc_v3 0.0.0.0 8080
-//      curl localhost:8080 -v -d "error-quit"
-//
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/asio/io_context.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/beast/core.hpp>
-#include <boost/beast/http.hpp>
-#include <boost/beast/version.hpp>
-#include <boost/format.hpp>
-#include <boost/leaf.hpp>
-#include <boost/spirit/include/qi_numeric.hpp>
-#include <boost/spirit/include/qi_parse.hpp>
-#include <deque>
-#include <iostream>
-#include <list>
-#include <optional>
-#include <string>
-
-namespace beast = boost::beast;
-namespace http = beast::http;
-namespace leaf = boost::leaf;
-namespace net = boost::asio;
-
-namespace {
-using error_code = boost::system::error_code;
-} // namespace
-
-// The operation being performed when an error occurs.
-struct e_last_operation {
-    std::string_view value;
-};
-
-// The HTTP request type.
-using request_t = http::request<http::string_body>;
-// The HTTP response type.
-using response_t = http::response<http::string_body>;
-
-response_t handle_request(request_t &&request);
-
-// A composed asynchronous operation that implements a basic remote calculator
-// over HTTP. It receives from the remote side commands such as:
-//      sum 1 2 3
-//      div 3 2
-//      mod 1 0
-// in the body of POST requests and sends back the result.
-//
-// Besides the calculator related commands, it also offer a special command:
-// - `error_quit` that asks the server to simulate a server side error that
-//   leads to the connection being dropped.
-//
-// From the error handling perspective there are three parts of the implementation:
-// - the handling of an HTTP request and creating the response to send back
-//      (see handle_request)
-// - the parsing and execution of the remote command we received as the body of
-//   an an HTTP POST request
-//      (see execute_command())
-// - this composed asynchronous operation which calls them,
-//
-// This example operation is based on:
-// - https://github.com/boostorg/beast/blob/b02f59ff9126c5a17f816852efbbd0ed20305930/example/echo-op/echo_op.cpp
-// - part of
-// https://github.com/boostorg/beast/blob/b02f59ff9126c5a17f816852efbbd0ed20305930/example/advanced/server/advanced_server.cpp
-//
-template <class AsyncStream, typename ErrorContext, typename CompletionToken>
-auto async_demo_rpc(AsyncStream &stream, ErrorContext &error_context, CompletionToken &&token) ->
-    typename net::async_result<typename std::decay<CompletionToken>::type, void(leaf::result<void>)>::return_type {
-
-    static_assert(beast::is_async_stream<AsyncStream>::value, "AsyncStream requirements not met");
-
-    using handler_type =
-        typename net::async_completion<CompletionToken, void(leaf::result<void>)>::completion_handler_type;
-    using base_type = beast::stable_async_base<handler_type, beast::executor_type<AsyncStream>>;
-    struct internal_op : base_type {
-        // This object must have a stable address
-        struct temporary_data {
-            beast::flat_buffer buffer;
-            std::optional<http::request_parser<request_t::body_type>> parser;
-            std::optional<response_t> response;
-        };
-
-        AsyncStream &m_stream;
-        ErrorContext &m_error_context;
-        temporary_data &m_data;
-        bool m_write_and_quit;
-
-        internal_op(AsyncStream &stream, ErrorContext &error_context, handler_type &&handler)
-            : base_type{std::move(handler), stream.get_executor()}, m_stream{stream}, m_error_context{error_context},
-              m_data{beast::allocate_stable<temporary_data>(*this)}, m_write_and_quit{false} {
-            start_read_request();
-        }
-
-        void operator()(error_code ec, std::size_t /*bytes_transferred*/ = 0) {
-            leaf::result<bool> result_continue_execution;
-            {
-                auto active_context = activate_context(m_error_context);
-                auto load = leaf::on_error(e_last_operation{m_data.response ? "async_demo_rpc::continuation-write"
-                                                                           : "async_demo_rpc::continuation-read"});
-                if (ec == http::error::end_of_stream) {
-                    // The remote side closed the connection.
-                    result_continue_execution = false;
-                } else if (ec) {
-                    result_continue_execution = leaf::new_error(ec);
-                } else {
-                    result_continue_execution = leaf::exception_to_result([&]() -> leaf::result<bool> {
-                        if (!m_data.response) {
-                            // Process the request we received.
-                            m_data.response = handle_request(std::move(m_data.parser->release()));
-                            m_write_and_quit = m_data.response->need_eof();
-                            http::async_write(m_stream, *m_data.response, std::move(*this));
-                            return true;
-                        }
-
-                        // If getting here, we completed a write operation.
-                        m_data.response.reset();
-                        // And start reading a new message if not quitting (i.e.
-                        // the message semantics of the last response we sent
-                        // required an end of file)
-                        if (!m_write_and_quit) {
-                            start_read_request();
-                            return true;
-                        }
-
-                        // We didn't initiate any new async operation above, so
-                        // we will not continue the execution.
-                        return false;
-                    });
-                }
-                // The activation object and load_last_operation need to be
-                // reset before calling the completion handler This is because,
-                // in general, the completion handler may be called directly or
-                // posted and if posted, it could execute in another thread.
-                // This means that regardless of how the handler gets to be
-                // actually called we must ensure that it is not called with the
-                // error context active. Note: An error context cannot be
-                // activated twice
-            }
-            if (!result_continue_execution) {
-                // We don't continue the execution due to an error, calling the
-                // completion handler
-                this->complete_now(result_continue_execution.error());
-            } else if( !*result_continue_execution ) {
-                // We don't continue the execution due to the flag not being
-                // set, calling the completion handler
-                this->complete_now(leaf::result<void>{});
-            }
-        }
-
-        void start_read_request() {
-            m_data.parser.emplace();
-            m_data.parser->body_limit(1024);
-            http::async_read(m_stream, m_data.buffer, *m_data.parser, std::move(*this));
-        }
-    };
-
-    auto initiation = [](auto &&completion_handler, AsyncStream *stream, ErrorContext *error_context) {
-        internal_op op{*stream, *error_context, std::forward<decltype(completion_handler)>(completion_handler)};
-    };
-
-    // We are in the "initiation" part of the async operation.
-    [[maybe_unused]] auto load = leaf::on_error(e_last_operation{"async_demo_rpc::initiation"});
-    return net::async_initiate<CompletionToken, void(leaf::result<void>)>(initiation, token, &stream, &error_context);
-}
-
-// The location of a int64 parse error. It refers the range of characters from
-// which the parsing was done.
-struct e_parse_int64_error {
-    using location_base = std::pair<std::string_view const, std::string_view::const_iterator>;
-    struct location : public location_base {
-        using location_base::location_base;
-
-        friend std::ostream &operator<<(std::ostream &os, location const &value) {
-            auto const &sv = value.first;
-            std::size_t pos = std::distance(sv.begin(), value.second);
-            if (pos == 0) {
-                os << "->\"" << sv << "\"";
-            } else if (pos < sv.size()) {
-                os << "\"" << sv.substr(0, pos) << "\"->\"" << sv.substr(pos) << "\"";
-            } else {
-                os << "\"" << sv << "\"<-";
-            }
-            return os;
-        }
-    };
-
-    location value;
-};
-
-// Parses an integer from a string_view.
-leaf::result<std::int64_t> parse_int64(std::string_view word) {
-    auto const begin = word.begin();
-    auto const end = word.end();
-    std::int64_t value = 0;
-    auto i = begin;
-    bool result = boost::spirit::qi::parse(i, end, boost::spirit::long_long, value);
-    if (!result || i != end) {
-        return leaf::new_error(e_parse_int64_error{std::make_pair(word, i)});
-    }
-    return value;
-}
-
-// The command being executed while we get an error. It refers the range of
-// characters from which the command was extracted.
-struct e_command {
-    std::string_view value;
-};
-
-// The details about an incorrect number of arguments error Some commands may
-// accept a variable number of arguments (e.g. greater than 1 would mean [2,
-// SIZE_MAX]).
-struct e_unexpected_arg_count {
-    struct arg_info {
-        std::size_t count;
-        std::size_t min;
-        std::size_t max;
-
-        friend std::ostream &operator<<(std::ostream &os, arg_info const &value) {
-            os << value.count << " (required: ";
-            if (value.min == value.max) {
-                os << value.min;
-            } else if (value.max < SIZE_MAX) {
-                os << "[" << value.min << ", " << value.max << "]";
-            } else {
-                os << "[" << value.min << ", MAX]";
-            }
-            os << ")";
-            return os;
-        }
-    };
-
-    arg_info value;
-};
-
-// The HTTP status that should be returned in case we get into an error.
-struct e_http_status {
-    http::status value;
-};
-
-// Unexpected HTTP method.
-struct e_unexpected_http_method {
-    http::verb value;
-};
-
-// The E-type that describes the `error_quit` command as an error condition.
-struct e_error_quit {
-    struct none_t {};
-    none_t value;
-};
-
-// Processes a remote command.
-leaf::result<std::string> execute_command(std::string_view line) {
-    // Split the command in words.
-    std::list<std::string_view> words; // or std::deque<std::string_view> words;
-
-    char const *const ws = "\t \r\n";
-    auto skip_ws = [&](std::string_view &line) {
-        if (auto pos = line.find_first_not_of(ws); pos != std::string_view::npos) {
-            line = line.substr(pos);
-        } else {
-            line = std::string_view{};
-        }
-    };
-
-    skip_ws(line);
-    while (!line.empty()) {
-        std::string_view word;
-        if (auto pos = line.find_first_of(ws); pos != std::string_view::npos) {
-            word = line.substr(0, pos);
-            line = line.substr(pos + 1);
-        } else {
-            word = line;
-            line = std::string_view{};
-        }
-
-        if (!word.empty()) {
-            words.push_back(word);
-        }
-        skip_ws(line);
-    }
-
-    static char const *const help = "Help:\n"
-                                    "    error-quit                  Simulated error to end the session\n"
-                                    "    sum <int64>*                Addition\n"
-                                    "    sub <int64>+                Substraction\n"
-                                    "    mul <int64>*                Multiplication\n"
-                                    "    div <int64>+                Division\n"
-                                    "    mod <int64> <int64>         Remainder\n"
-                                    "    <anything else>             This message";
-
-    if (words.empty()) {
-        return std::string(help);
-    }
-
-    auto command = words.front();
-    words.pop_front();
-
-    auto load_cmd = leaf::on_error(e_command{command}, e_http_status{http::status::bad_request});
-    std::string response;
-
-    if (command == "error-quit") {
-        return leaf::new_error(e_error_quit{});
-    } else if (command == "sum") {
-        std::int64_t sum = 0;
-        for (auto const &w : words) {
-            BOOST_LEAF_AUTO(i, parse_int64(w));
-            sum += i;
-        }
-        response = std::to_string(sum);
-    } else if (command == "sub") {
-        if (words.size() < 2) {
-            return leaf::new_error(e_unexpected_arg_count{words.size(), 2, SIZE_MAX});
-        }
-        BOOST_LEAF_AUTO(sub, parse_int64(words.front()));
-        words.pop_front();
-        for (auto const &w : words) {
-            BOOST_LEAF_AUTO(i, parse_int64(w));
-            sub -= i;
-        }
-        response = std::to_string(sub);
-    } else if (command == "mul") {
-        std::int64_t mul = 1;
-        for (auto const &w : words) {
-            BOOST_LEAF_AUTO(i, parse_int64(w));
-            mul *= i;
-        }
-        response = std::to_string(mul);
-    } else if (command == "div") {
-        if (words.size() < 2) {
-            return leaf::new_error(e_unexpected_arg_count{words.size(), 2, SIZE_MAX});
-        }
-        BOOST_LEAF_AUTO(div, parse_int64(words.front()));
-        words.pop_front();
-        for (auto const &w : words) {
-            BOOST_LEAF_AUTO(i, parse_int64(w));
-            if (i == 0) {
-                // In some cases this command execution function might throw,
-                // not just return an error.
-                throw std::runtime_error{"division by zero"};
-            }
-            div /= i;
-        }
-        response = std::to_string(div);
-    } else if (command == "mod") {
-        if (words.size() != 2) {
-            return leaf::new_error(e_unexpected_arg_count{words.size(), 2, 2});
-        }
-        BOOST_LEAF_AUTO(i1, parse_int64(words.front()));
-        words.pop_front();
-        BOOST_LEAF_AUTO(i2, parse_int64(words.front()));
-        words.pop_front();
-        if (i2 == 0) {
-            // In some cases this command execution function might throw, not
-            // just return an error.
-            throw leaf::exception(std::runtime_error{"division by zero"});
-        }
-        response = std::to_string(i1 % i2);
-    } else {
-        response = help;
-    }
-
-    return response;
-}
-
-std::string diagnostic_to_str(leaf::verbose_diagnostic_info const &diag) {
-    auto str = boost::str(boost::format("%1%") % diag);
-    boost::algorithm::replace_all(str, "\n", "\n    ");
-    return "\nDetailed error diagnostic:\n----\n" + str + "\n----";
-};
-
-// Handles an HTTP request and returns the response to send back.
-response_t handle_request(request_t &&request) {
-
-    auto msg_prefix = [](e_command const *cmd) {
-        if (cmd != nullptr) {
-            return boost::str(boost::format("Error (%1%):") % cmd->value);
-        }
-        return std::string("Error:");
-    };
-
-    auto make_sr = [](e_http_status const *status, std::string &&response) {
-        return std::make_pair(status != nullptr ? status->value : http::status::internal_server_error,
-                              std::move(response));
-    };
-
-    // In this variant of the RPC example we execute the remote command and
-    // handle any errors coming from it in one place (using
-    // `leaf::try_handle_all`).
-    auto pair_status_response = leaf::try_handle_all(
-        [&]() -> leaf::result<std::pair<http::status, std::string>> {
-            if (request.method() != http::verb::post) {
-                return leaf::new_error(e_unexpected_http_method{http::verb::post},
-                                       e_http_status{http::status::bad_request});
-            }
-            BOOST_LEAF_AUTO(response, execute_command(request.body()));
-            return std::make_pair(http::status::ok, std::move(response));
-        },
-        // For the `error_quit` command and associated error condition we have
-        // the error handler itself fail (by throwing). This means that the
-        // server will not send any response to the client, it will just
-        // shutdown the connection. This implementation showcases two aspects:
-        // - that the implementation of error handling can fail, too
-        // - how the asynchronous operation calling this error handling function
-        //   reacts to this failure.
-        [](e_error_quit const &) -> std::pair<http::status, std::string> { throw std::runtime_error("error_quit"); },
-        // For the rest of error conditions we just build a message to be sent
-        // to the remote client.
-        [&](e_parse_int64_error const &e, e_http_status const *status, e_command const *cmd,
-            leaf::verbose_diagnostic_info const &diag) {
-            return make_sr(status, boost::str(boost::format("%1% int64 parse error: %2%") % msg_prefix(cmd) % e.value) +
-                                       diagnostic_to_str(diag));
-        },
-        [&](e_unexpected_arg_count const &e, e_http_status const *status, e_command const *cmd,
-            leaf::verbose_diagnostic_info const &diag) {
-            return make_sr(status,
-                           boost::str(boost::format("%1% wrong argument count: %2%") % msg_prefix(cmd) % e.value) +
-                               diagnostic_to_str(diag));
-        },
-        [&](e_unexpected_http_method const &e, e_http_status const *status, e_command const *cmd,
-            leaf::verbose_diagnostic_info const &diag) {
-            return make_sr(status, boost::str(boost::format("%1% unexpected HTTP method. Expected: %2%") %
-                                              msg_prefix(cmd) % e.value) +
-                                       diagnostic_to_str(diag));
-        },
-        [&](std::exception const & e, e_http_status const *status, e_command const *cmd,
-            leaf::verbose_diagnostic_info const &diag) {
-            return make_sr(status, boost::str(boost::format("%1% %2%") % msg_prefix(cmd) % e.what()) +
-                                       diagnostic_to_str(diag));
-        },
-        [&](e_http_status const *status, e_command const *cmd, leaf::verbose_diagnostic_info const &diag) {
-            return make_sr(status, boost::str(boost::format("%1% unknown failure") % msg_prefix(cmd)) +
-                                       diagnostic_to_str(diag));
-        });
-    response_t response{pair_status_response.first, request.version()};
-    response.set(http::field::server, "Example-with-" BOOST_BEAST_VERSION_STRING);
-    response.set(http::field::content_type, "text/plain");
-    response.keep_alive(request.keep_alive());
-    pair_status_response.second += "\n";
-    response.body() = std::move(pair_status_response.second);
-    response.prepare_payload();
-    return response;
-}
-
-int main(int argc, char **argv) {
-    auto msg_prefix = [](e_last_operation const *op) {
-        if (op != nullptr) {
-            return boost::str(boost::format("Error (%1%): ") % op->value);
-        }
-        return std::string("Error: ");
-    };
-
-    // Error handler for internal server internal errors (not communicated to
-    // the remote client).
-    auto error_handlers = std::make_tuple(
-        [&](std::exception_ptr const &ep, e_last_operation const *op) {
-            return leaf::try_handle_all(
-                [&]() -> leaf::result<int> { std::rethrow_exception(ep); },
-                [&](std::exception const & e, leaf::verbose_diagnostic_info const &diag) {
-                    std::cerr << msg_prefix(op) << e.what() << " (captured)" << diagnostic_to_str(diag)
-                                << std::endl;
-                    return -11;
-                },
-                [&](leaf::verbose_diagnostic_info const &diag) {
-                    std::cerr << msg_prefix(op) << "unknown (captured)" << diagnostic_to_str(diag) << std::endl;
-                    return -12;
-                });
-        },
-        [&](std::exception const & e, e_last_operation const *op, leaf::verbose_diagnostic_info const &diag) {
-            std::cerr << msg_prefix(op) << e.what() << diagnostic_to_str(diag) << std::endl;
-            return -21;
-        },
-        [&](error_code ec, leaf::verbose_diagnostic_info const &diag, e_last_operation const *op) {
-            std::cerr << msg_prefix(op) << ec << ":" << ec.message() << diagnostic_to_str(diag) << std::endl;
-            return -22;
-        },
-        [&](leaf::verbose_diagnostic_info const &diag, e_last_operation const *op) {
-            std::cerr << msg_prefix(op) << "unknown" << diagnostic_to_str(diag) << std::endl;
-            return -23;
-        });
-
-    // Top level try block and error handler. It will handle errors from
-    // starting the server for example failure to bind to a given port (e.g.
-    // ports less than 1024 if not running as root)
-    return leaf::try_handle_all(
-        [&]() -> leaf::result<int> {
-            auto load = leaf::on_error(e_last_operation{"main"});
-            if (argc != 3) {
-                std::cerr << "Usage: " << argv[0] << " <address> <port>" << std::endl;
-                std::cerr << "Example:\n    " << argv[0] << " 0.0.0.0 8080" << std::endl;
-                return -1;
-            }
-
-            auto const address{net::ip::make_address(argv[1])};
-            auto const port{static_cast<std::uint16_t>(std::atoi(argv[2]))};
-            net::ip::tcp::endpoint const endpoint{address, port};
-
-            net::io_context io_context;
-
-            // Start the server acceptor and wait for a client.
-            net::ip::tcp::acceptor acceptor{io_context, endpoint};
-
-            auto local_endpoint = acceptor.local_endpoint();
-            auto address_try_msg = acceptor.local_endpoint().address().to_string();
-            if (address_try_msg == "0.0.0.0") {
-                address_try_msg = "localhost";
-            }
-            std::cout << "Server: Started on: " << local_endpoint << std::endl;
-            std::cout << "Try in a different terminal:\n"
-                      << "    curl " << address_try_msg << ":" << local_endpoint.port() << " -d \"\"\nor\n"
-                      << "    curl " << address_try_msg << ":" << local_endpoint.port() << " -d \"sum 1 2 3\""
-                      << std::endl;
-
-            auto socket = acceptor.accept();
-            std::cout << "Server: Client connected: " << socket.remote_endpoint() << std::endl;
-
-            // The error context for the async operation.
-            auto error_context = leaf::make_context(error_handlers);
-            int rv = 0;
-            async_demo_rpc(socket, error_context, [&](leaf::result<void> result) {
-                // Note: In case we wanted to add some additional information to
-                // the error associated with the result we would need to
-                // activate the error context
-                auto active_context = activate_context(error_context);
-                if (result) {
-                    std::cout << "Server: Client work completed successfully" << std::endl;
-                    rv = 0;
-                } else {
-                    // Handle errors from running the server logic
-                    leaf::result<int> result_int{result.error()};
-                    rv = error_context.handle_error<int>(result_int.error(), error_handlers);
-                }
-            });
-            io_context.run();
-
-            // Let the remote side know we are shutting down.
-            error_code ignored;
-            socket.shutdown(net::ip::tcp::socket::shutdown_both, ignored);
-            return rv;
-        },
-        error_handlers);
-}
diff --git a/example/error_log.cpp b/example/error_log.cpp
index c8ccc81a..ea19e8cb 100644
--- a/example/error_log.cpp
+++ b/example/error_log.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -133,14 +132,14 @@ int main()
 
 namespace boost
 {
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e )
+    [[noreturn]] void throw_exception( std::exception const & e )
     {
         std::cerr << "Terminating due to a C++ exception under BOOST_LEAF_NO_EXCEPTIONS: " << e.what();
         std::terminate();
     }
 
     struct source_location;
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e, boost::source_location const & )
+    [[noreturn]] void throw_exception( std::exception const & e, boost::source_location const & )
     {
         throw_exception(e);
     }
diff --git a/example/error_trace.cpp b/example/error_trace.cpp
index 706f577e..c3299b95 100644
--- a/example/error_trace.cpp
+++ b/example/error_trace.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -133,14 +132,14 @@ int main()
 
 namespace boost
 {
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e )
+    [[noreturn]] void throw_exception( std::exception const & e )
     {
         std::cerr << "Terminating due to a C++ exception under BOOST_LEAF_NO_EXCEPTIONS: " << e.what();
         std::terminate();
     }
 
     struct source_location;
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e, boost::source_location const & )
+    [[noreturn]] void throw_exception( std::exception const & e, boost::source_location const & )
     {
         throw_exception(e);
     }
diff --git a/example/exception_to_result.cpp b/example/exception_to_result.cpp
index 793f6777..d6e3a7b3 100644
--- a/example/exception_to_result.cpp
+++ b/example/exception_to_result.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -68,12 +67,12 @@ int main()
                 return { };
             },
 
-            []( error_a const & e )
+            []( error_a const & )
             {
                 std::cerr << "Error A!" << std::endl;
             },
 
-            []( error_b const & e )
+            []( error_b const & )
             {
                 std::cerr << "Error B!" << std::endl;
             },
diff --git a/example/lua_callback_eh.cpp b/example/lua_callback_exceptions.cpp
similarity index 96%
rename from example/lua_callback_eh.cpp
rename to example/lua_callback_exceptions.cpp
index 4e87f267..ecad96f6 100644
--- a/example/lua_callback_eh.cpp
+++ b/example/lua_callback_exceptions.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -12,6 +11,7 @@ extern "C" {
 }
 #include <boost/leaf.hpp>
 #include <iostream>
+#include <memory>
 #include <stdlib.h>
 
 namespace leaf = boost::leaf;
@@ -75,7 +75,7 @@ int do_work( lua_State * L )
     }
     else
     {
-        throw leaf::exception(ec1);
+        leaf::throw_exception(ec1);
     }
 }
 
@@ -127,7 +127,7 @@ int call_lua( lua_State * L )
                 // cur_err.assigned_error_id() will return a new leaf::error_id,
                 // otherwise we'll be working with the original error reported
                 // by a C++ exception out of do_work.
-                throw leaf::exception( cur_err.assigned_error_id().load( e_lua_pcall_error{err}, e_lua_error_message{std::move(msg)} ) );
+                leaf::throw_exception( cur_err.assigned_error_id().load( e_lua_pcall_error{err}, e_lua_error_message{std::move(msg)} ) );
             }
             else
             {
diff --git a/example/lua_callback_result.cpp b/example/lua_callback_result.cpp
index 47ac6839..fc7a046f 100644
--- a/example/lua_callback_result.cpp
+++ b/example/lua_callback_result.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -12,6 +11,7 @@ extern "C" {
 }
 #include <boost/leaf.hpp>
 #include <iostream>
+#include <memory>
 #include <stdlib.h>
 
 namespace leaf = boost::leaf;
@@ -158,14 +158,14 @@ int main()
 
 namespace boost
 {
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e )
+    [[noreturn]] void throw_exception( std::exception const & e )
     {
         std::cerr << "Terminating due to a C++ exception under BOOST_LEAF_NO_EXCEPTIONS: " << e.what();
         std::terminate();
     }
 
     struct source_location;
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e, boost::source_location const & )
+    [[noreturn]] void throw_exception( std::exception const & e, boost::source_location const & )
     {
         throw_exception(e);
     }
diff --git a/example/print_file/print_file_eh.cpp b/example/print_file/print_file_exceptions.cpp
similarity index 85%
rename from example/print_file/print_file_eh.cpp
rename to example/print_file/print_file_exceptions.cpp
index 69361e40..adf54f7f 100644
--- a/example/print_file/print_file_eh.cpp
+++ b/example/print_file/print_file_exceptions.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -8,10 +7,11 @@
 
 // It reads a text file in a buffer and prints it to std::cout, using LEAF to
 // handle errors. This version uses exception handling. The version that does
-// not use exception handling is in print_file_result.cpp.
+// not use exception handling is in print_file_leaf_result.cpp.
 
 #include <boost/leaf.hpp>
 #include <iostream>
+#include <memory>
 #include <stdio.h>
 
 namespace leaf = boost::leaf;
@@ -40,10 +40,10 @@ char const * parse_command_line( int argc, char const * argv[] );
 std::shared_ptr<FILE> file_open( char const * file_name );
 
 // Return the size of the file.
-int file_size( FILE & f );
+std::size_t file_size( FILE & f );
 
 // Read size bytes from f into buf.
-void file_read( FILE & f, void * buf, int size );
+void file_read( FILE & f, void * buf, std::size_t size );
 
 
 // The main function, which handles all errors.
@@ -59,7 +59,7 @@ int main( int argc, char const * argv[] )
 
             std::shared_ptr<FILE> f = file_open(file_name);
 
-            int s = file_size(*f);
+            std::size_t s = file_size(*f);
 
             std::string buffer(1 + s, '\0');
             file_read(*f, &buffer[0], buffer.size()-1);
@@ -67,7 +67,7 @@ int main( int argc, char const * argv[] )
             std::cout << buffer;
             std::cout.flush();
             if( std::cout.fail() )
-                throw leaf::exception(output_error, leaf::e_errno{errno});
+                leaf::throw_exception(output_error, leaf::e_errno{errno});
 
             return 0;
         },
@@ -149,10 +149,10 @@ int main( int argc, char const * argv[] )
 // Parse the command line, return the file name.
 char const * parse_command_line( int argc, char const * argv[] )
 {
-    if( argc==2 )
+    if( argc == 2 )
         return argv[1];
     else
-        throw leaf::exception(bad_command_line);
+        leaf::throw_exception(bad_command_line);
 }
 
 
@@ -162,37 +162,37 @@ 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
-        throw leaf::exception(open_error, leaf::e_errno{errno});
+        leaf::throw_exception(open_error, leaf::e_errno{errno});
 }
 
 
 // Return the size of the file.
-int file_size( FILE & f )
+std::size_t file_size( FILE & f )
 {
     auto load = leaf::on_error([] { return leaf::e_errno{errno}; });
 
     if( fseek(&f, 0, SEEK_END) )
-        throw leaf::exception(size_error);
+        leaf::throw_exception(size_error);
 
-    int s = ftell(&f);
-    if( s==-1L )
-        throw leaf::exception(size_error);
+    long s = ftell(&f);
+    if( s == -1L )
+        leaf::throw_exception(size_error);
 
     if( fseek(&f,0,SEEK_SET) )
-        throw leaf::exception(size_error);
+        leaf::throw_exception(size_error);
 
-    return s;
+    return std::size_t(s);
 }
 
 
 // Read size bytes from f into buf.
-void file_read( FILE & f, void * buf, int size )
+void file_read( FILE & f, void * buf, std::size_t size )
 {
-    int n = fread(buf, 1, size, &f);
+    std::size_t n = fread(buf, 1, size, &f);
 
     if( ferror(&f) )
-        throw leaf::exception(read_error, leaf::e_errno{errno});
+        leaf::throw_exception(read_error, leaf::e_errno{errno});
 
-    if( n!=size )
-        throw leaf::exception(eof_error);
+    if( n != size )
+        leaf::throw_exception(eof_error);
 }
diff --git a/example/print_file/print_file_result.cpp b/example/print_file/print_file_leaf_result.cpp
similarity index 90%
rename from example/print_file/print_file_result.cpp
rename to example/print_file/print_file_leaf_result.cpp
index 46f5af25..a32ec549 100644
--- a/example/print_file/print_file_result.cpp
+++ b/example/print_file/print_file_leaf_result.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -8,10 +7,11 @@
 
 // It reads a text file in a buffer and prints it to std::cout, using LEAF to
 // handle errors. This version does not use exception handling. The version that
-// does use exception handling is in print_file_eh.cpp.
+// does use exception handling is in print_file_exceptions.cpp.
 
 #include <boost/leaf.hpp>
 #include <iostream>
+#include <memory>
 #include <stdio.h>
 
 namespace leaf = boost::leaf;
@@ -44,10 +44,10 @@ result<char const *> parse_command_line( int argc, char const * argv[] );
 result<std::shared_ptr<FILE>> file_open( char const * file_name );
 
 // Return the size of the file.
-result<int> file_size( FILE & f );
+result<std::size_t> file_size( FILE & f );
 
 // Read size bytes from f into buf.
-result<void> file_read( FILE & f, void * buf, int size );
+result<void> file_read( FILE & f, void * buf, std::size_t size );
 
 
 // The main function, which handles all errors.
@@ -153,7 +153,7 @@ int main( int argc, char const * argv[] )
 // Parse the command line, return the file name.
 result<char const *> parse_command_line( int argc, char const * argv[] )
 {
-    if( argc==2 )
+    if( argc == 2 )
         return argv[1];
     else
         return leaf::new_error(bad_command_line);
@@ -171,33 +171,33 @@ result<std::shared_ptr<FILE>> file_open( char const * file_name )
 
 
 // Return the size of the file.
-result<int> file_size( FILE & f )
+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);
 
-    int s = ftell(&f);
-    if( s==-1L )
+    long s = ftell(&f);
+    if( s == -1L )
         return leaf::new_error(size_error);
 
     if( fseek(&f,0,SEEK_SET) )
         return leaf::new_error(size_error);
 
-    return s;
+    return std::size_t(s);
 }
 
 
 // Read size bytes from f into buf.
-result<void> file_read( FILE & f, void * buf, int size )
+result<void> file_read( FILE & f, void * buf, std::size_t size )
 {
-    int n = fread(buf, 1, size, &f);
+    std::size_t n = fread(buf, 1, size, &f);
 
     if( ferror(&f) )
         return leaf::new_error(read_error, leaf::e_errno{errno});
 
-    if( n!=size )
+    if( n != size )
         return leaf::new_error(eof_error);
 
     return { };
@@ -209,14 +209,14 @@ result<void> file_read( FILE & f, void * buf, int size )
 
 namespace boost
 {
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e )
+    [[noreturn]] void throw_exception( std::exception const & e )
     {
         std::cerr << "Terminating due to a C++ exception under BOOST_LEAF_NO_EXCEPTIONS: " << e.what();
         std::terminate();
     }
 
     struct source_location;
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e, boost::source_location const & )
+    [[noreturn]] void throw_exception( std::exception const & e, boost::source_location const & )
     {
         throw_exception(e);
     }
diff --git a/example/print_file/print_file_outcome_result.cpp b/example/print_file/print_file_system_result.cpp
similarity index 80%
rename from example/print_file/print_file_outcome_result.cpp
rename to example/print_file/print_file_system_result.cpp
index 6710829d..b5addfb5 100644
--- a/example/print_file/print_file_outcome_result.cpp
+++ b/example/print_file/print_file_system_result.cpp
@@ -1,21 +1,21 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
 // This is the program presented in
-// https://boostorg.github.io/leaf/#introduction-result, converted to use
-// outcome::result instead of leaf::result.
+// https://boostorg.github.io/leaf/#introduction-result.
 
 // It reads a text file in a buffer and prints it to std::cout, using LEAF to
-// handle errors. This version does not use exception handling.
+// handle errors. This version does not use exception handling. The version that
+// does use exception handling is in print_file_exceptions.cpp.
+
 
-#include <boost/outcome/std_result.hpp>
 #include <boost/leaf.hpp>
+#include <boost/system/result.hpp>
 #include <iostream>
+#include <memory>
 #include <stdio.h>
 
-namespace outcome = boost::outcome_v2;
 namespace leaf = boost::leaf;
 
 
@@ -32,12 +32,12 @@ enum error_code
 
 
 template <class T>
-using result = outcome::std_result<T>;
+using result = boost::system::result<T, std::error_code>;
 
-// To enable LEAF to work with outcome::result, we need to specialize the
+// To enable LEAF to work with boost::system::result, we need to specialize the
 // is_result_type template:
 namespace boost { namespace leaf {
-    template <class T> struct is_result_type<outcome::std_result<T>>: std::true_type { };
+    template <class T> struct is_result_type<boost::system::result<T, std::error_code>>: std::true_type { };
 } }
 
 
@@ -52,10 +52,10 @@ result<char const *> parse_command_line( int argc, char const * argv[] );
 result<std::shared_ptr<FILE>> file_open( char const * file_name );
 
 // Return the size of the file.
-result<int> file_size( FILE & f );
+result<std::size_t> file_size( FILE & f );
 
 // Read size bytes from f into buf.
-result<void> file_read( FILE & f, void * buf, int size );
+result<void> file_read( FILE & f, void * buf, std::size_t size );
 
 
 // The main function, which handles all errors.
@@ -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;
         },
@@ -161,10 +161,10 @@ int main( int argc, char const * argv[] )
 // Parse the command line, return the file name.
 result<char const *> parse_command_line( int argc, char const * argv[] )
 {
-    if( argc==2 )
+    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,41 +174,41 @@ 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});
 }
 
 
 // Return the size of the file.
-result<int> file_size( FILE & f )
+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);
 
-    int s = ftell(&f);
-    if( s==-1L )
-        return leaf::new_error(size_error).to_error_code();
+    long s = ftell(&f);
+    if( s == -1L )
+        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 s;
+    return std::size_t(s);
 }
 
 
 // Read size bytes from f into buf.
-result<void> file_read( FILE & f, void * buf, int size )
+result<void> file_read( FILE & f, void * buf, std::size_t size )
 {
-    int n = fread(buf, 1, size, &f);
+    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();
+    if( n != size )
+        return leaf::new_error(eof_error);
 
-    return outcome::success();
+    return { };
 }
 
 ////////////////////////////////////////
@@ -217,14 +217,14 @@ result<void> file_read( FILE & f, void * buf, int size )
 
 namespace boost
 {
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e )
+    BOOST_NORETURN void throw_exception( std::exception const & e )
     {
         std::cerr << "Terminating due to a C++ exception under BOOST_LEAF_NO_EXCEPTIONS: " << e.what();
         std::terminate();
     }
 
     struct source_location;
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e, boost::source_location const & )
+    BOOST_NORETURN void throw_exception( std::exception const & e, boost::source_location const & )
     {
         throw_exception(e);
     }
diff --git a/example/print_file/readme.md b/example/print_file/readme.md
index 3c5a51cd..050e1f6f 100644
--- a/example/print_file/readme.md
+++ b/example/print_file/readme.md
@@ -1,16 +1,14 @@
 # Print File Example
 
-This directory has three versions of the same simple program, which reads a
-file, prints it to standard out and handles errors using LEAF, each using a
-different variation on error handling:
+This directory contains several versions of a trivial program which takes a file name on the command line and prints it. Each version uses a different error handling implementaiton.
 
-* [print_file_result.cpp](./print_file_result.cpp) reports errors with
+* [print_file_leaf_result.cpp](./print_file_leaf_result.cpp) reports errors with
   `leaf::result<T>`, using an error code `enum` for classification of failures.
 
-* [print_file_outcome_result.cpp](./print_file_outcome_result.cpp) is the same
-  as the above, but using `outcome::result<T>`. This demonstrates the ability
-  to transport arbitrary error objects through APIs that do not use
-  `leaf::result<T>`.
+* [print_file_system_result.cpp](./print_file_system_result.cpp) is the same as
+  above, but using `boost::system::result<T>` instead of `leaf::result<T>`.
+  This demonstrates the ability of LEAF to transport arbitrary error objects using an
+  external result type, rather than `boost::leaf::result<T>`.
 
-* [print_file_eh.cpp](./print_file_eh.cpp) throws on error, using an error code
+* [print_file_exceptions.cpp](./print_file_exceptions.cpp) throws on error, using an error code
   `enum` for classification of failures.
diff --git a/example/print_half.cpp b/example/print_half.cpp
index f6caaa8e..1211d277 100644
--- a/example/print_half.cpp
+++ b/example/print_half.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -104,14 +103,14 @@ int main( int argc, char const * argv[] )
 
 namespace boost
 {
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e )
+    [[noreturn]] void throw_exception( std::exception const & e )
     {
         std::cerr << "Terminating due to a C++ exception under BOOST_LEAF_NO_EXCEPTIONS: " << e.what();
         std::terminate();
     }
 
     struct source_location;
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e, boost::source_location const & )
+    [[noreturn]] void throw_exception( std::exception const & e, boost::source_location const & )
     {
         throw_exception(e);
     }
diff --git a/example/readme.md b/example/readme.md
index 3e98584a..8b5f4086 100644
--- a/example/readme.md
+++ b/example/readme.md
@@ -1,13 +1,12 @@
 # Example Programs Using LEAF to Handle Errors
 
-* [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.
+* [print_file](./print_file): This directory contains several versions of a trivial program which takes a file name on the command line and prints it. Each version uses a different error handling implementaiton.
 
-* [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.
+* [try_capture_all_result.cpp](https://github.com/boostorg/leaf/blob/master/example/try_capture_all_result.cpp?ts=4): Shows how to transport error objects between threads in a `leaf::result<T>` object without using exception handling.
+* [try_capture_all_exceptions.cpp](https://github.com/boostorg/leaf/blob/master/example/try_capture_all_exceptions.cpp?ts=4): Shows how to transport error objects between threads in 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.
+* [lua_callback_exceptions.cpp](https://github.com/boostorg/leaf/blob/master/example/lua_callback_exceptions.cpp?ts=4): Transporting arbitrary error objects through an uncooperative API using exceptions.
 * [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.
 * [exception_error_log.cpp](https://github.com/boostorg/leaf/blob/master/example/error_log.cpp?ts=4): Using `accumulate` to produce an error log.
 * [exception_error_trace.cpp](https://github.com/boostorg/leaf/blob/master/example/error_trace.cpp?ts=4): Same as above, but the log is recorded in a `std::deque` rather than just printed.
 * [print_half.cpp](https://github.com/boostorg/leaf/blob/master/example/print_half.cpp?ts=4): This is a Boost Outcome example adapted to LEAF, demonstrating the use of `try_handle_some` to handle some errors, forwarding any other error to the caller.
-* [asio_beast_leaf_rpc.cpp](https://github.com/boostorg/leaf/blob/master/example/asio_beast_leaf_rpc.cpp?ts=4): A simple RPC calculator implemented with Beast+ASIO+LEAF.
diff --git a/example/capture_in_exception.cpp b/example/try_capture_all_exceptions.cpp
similarity index 58%
rename from example/capture_in_exception.cpp
rename to example/try_capture_all_exceptions.cpp
index c203affa..4372482b 100644
--- a/example/capture_in_exception.cpp
+++ b/example/try_capture_all_exceptions.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -7,6 +6,20 @@
 // objects between threads, using exception handling. See capture_in_result.cpp
 // for the version that does not use exception handling.
 
+#include <boost/leaf/config.hpp>
+
+#if !BOOST_LEAF_CFG_CAPTURE || defined(BOOST_LEAF_NO_EXCEPTIONS)
+
+#include <iostream>
+
+int main()
+{
+    std::cout << "Unit test not applicable." << std::endl;
+    return 0;
+}
+
+#else
+
 #include <boost/leaf.hpp>
 #include <vector>
 #include <string>
@@ -14,6 +27,7 @@
 #include <iterator>
 #include <iostream>
 #include <algorithm>
+#include <thread>
 
 namespace leaf = boost::leaf;
 
@@ -33,7 +47,7 @@ task_result task()
     if( succeed )
         return { };
     else
-        throw leaf::exception(
+        leaf::throw_exception(
             e_thread_id{std::this_thread::get_id()},
             e_failure_info1{"info"},
             e_failure_info2{42} );
@@ -43,30 +57,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 try_capture_all: in case of a failure, the returned leaf::result<>
+    // will capture all error objects.
     std::generate_n( std::back_inserter(fut), task_count,
         [&]
         {
@@ -74,7 +70,7 @@ int main()
                 std::launch::async,
                 [&]
                 {
-                    return leaf::capture(leaf::make_shared_context(error_handlers), &task);
+                    return leaf::try_capture_all(task);
                 } );
         } );
 
@@ -86,12 +82,24 @@ 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;
+            } );
     }
 }
+
+#endif
diff --git a/example/capture_in_result.cpp b/example/try_capture_all_result.cpp
similarity index 61%
rename from example/capture_in_result.cpp
rename to example/try_capture_all_result.cpp
index f2aec02f..617f77da 100644
--- a/example/capture_in_result.cpp
+++ b/example/try_capture_all_result.cpp
@@ -1,12 +1,25 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
 // This is a simple program that demonstrates the use of LEAF to transport error
-// objects between threads, without using exception handling. See capture_eh.cpp
+// objects between threads, without using exception handling. See try_capture_all_exceptions.cpp
 // for the version that uses exception handling.
 
+#include <boost/leaf/config.hpp>
+
+#if !BOOST_LEAF_CFG_CAPTURE
+
+#include <iostream>
+
+int main()
+{
+    std::cout << "Unit test not applicable." << std::endl;
+    return 0;
+}
+
+#else
+
 #include <boost/leaf.hpp>
 #include <vector>
 #include <string>
@@ -14,6 +27,7 @@
 #include <iterator>
 #include <iostream>
 #include <algorithm>
+#include <thread>
 
 namespace leaf = boost::leaf;
 
@@ -43,30 +57,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_capture_all: in case of a failure, the returned leaf::result<>
+    // will capture all error objects.
     std::generate_n( std::back_inserter(fut), task_count,
         [&]
         {
@@ -74,7 +70,7 @@ int main()
                 std::launch::async,
                 [&]
                 {
-                    return leaf::capture(leaf::make_shared_context(error_handlers), &task);
+                    return leaf::try_capture_all(task);
                 } );
         } );
 
@@ -86,14 +82,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;
+            } );
     }
 }
 
@@ -103,17 +109,19 @@ int main()
 
 namespace boost
 {
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e )
+    [[noreturn]] void throw_exception( std::exception const & e )
     {
         std::cerr << "Terminating due to a C++ exception under BOOST_LEAF_NO_EXCEPTIONS: " << e.what();
         std::terminate();
     }
 
     struct source_location;
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e, boost::source_location const & )
+    [[noreturn]] void throw_exception( std::exception const & e, boost::source_location const & )
     {
         throw_exception(e);
     }
 }
 
 #endif
+
+#endif
diff --git a/gen/generate_single_header.py b/gen/generate_single_header.py
index 623fddfb..ea190af1 100644
--- a/gen/generate_single_header.py
+++ b/gen/generate_single_header.py
@@ -1,6 +1,6 @@
 """
 
-    Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
+    Copyright 2018-2024 Emil Dotchevski and Reverge Studios, Inc.
     Copyright (c) Sorin Fetche
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -18,33 +18,53 @@
 
 import argparse
 import os
+import filecmp
 import re
 from datetime import date
 import subprocess
 
-included = {}
-total_line_count = 11
+def compare_and_update(old_file, new_file):
+    if not os.path.exists(old_file):
+        os.rename(new_file, old_file)
+    elif filecmp.cmp(old_file, new_file, shallow=False):
+        os.remove(new_file)
+    else:
+        os.remove(old_file)
+        os.rename(new_file, old_file)
 
-def append(input_file_name, input_file, output_file, regex_includes, include_folder):
+included = {}
+total_line_count = 14
+def append(input_file_name, input_file, output_file, regex_includes, include_folder, line_directive_prefix, depth):
     global total_line_count
+    inside_copyright = False
     line_count = 1
     for line in input_file:
         line_count += 1
+        if 'Emil Dotchevski' in line:
+            inside_copyright = True
+        if inside_copyright:
+            if line.startswith('//') :
+                continue
+            if not line.strip():
+                inside_copyright = False
+                if depth > 0:
+                    output_file.write('%s#line %d "%s"\n' % (line_directive_prefix, line_count, input_file_name))
+                continue
         result = regex_includes.search(line)
         if result:
-            next_input_file_name = result.group("include")
+            next_input_file_name = result.group('include')
             if next_input_file_name in included:
-                output_file.write("// Expanded at line %d: %s" % (included[next_input_file_name], line))
+                output_file.write('// %s // Expanded at line %d\n' % (line.strip(), included[next_input_file_name]))
                 total_line_count += 1
             else:
                 included[next_input_file_name] = total_line_count
-                print("%s (%d)" % (next_input_file_name, total_line_count))
-                with open(os.path.join(include_folder, next_input_file_name), "r") as next_input_file:
-                    output_file.write('// >>> %s#line 1 "%s"\n' % (line, next_input_file_name))
+                print('%s (%d)' % (next_input_file_name, total_line_count))
+                with open(os.path.join(include_folder, next_input_file_name), 'r') as next_input_file:
+                    output_file.write('// >>> %s' % (line))
                     total_line_count += 2
-                    append(next_input_file_name, next_input_file, output_file, regex_includes, include_folder)
-                    if not ('include/boost/leaf/detail/all.hpp' in input_file_name):
-                        output_file.write('// <<< %s#line %d "%s"\n' % (line, line_count, input_file_name))
+                    append(next_input_file_name, next_input_file, output_file, regex_includes, include_folder, line_directive_prefix, depth + 1)
+                    if depth > 0:
+                        output_file.write('// <<< %s%s#line %d "%s"\n' % (line, line_directive_prefix, line_count, input_file_name))
                         total_line_count += 2
         else:
             output_file.write(line)
@@ -52,41 +72,49 @@ def append(input_file_name, input_file, output_file, regex_includes, include_fol
 
 def _main():
     parser = argparse.ArgumentParser(
-        description="Generates a single include file from a file including multiple C/C++ headers")
-    parser.add_argument("-i", "--input", action="store", type=str, default="in.cpp",
-        help="Input file including the headers to be merged")
-    parser.add_argument("-o", "--output", action="store", type=str, default="out.cpp",
-        help="Output file. NOTE: It will be overwritten!")
-    parser.add_argument("-p", "--path", action="store", type=str, default=".",
-        help="Include path")
-    parser.add_argument("--hash", action="store", type=str,
-        help="The git hash to print in the output file, e.g. the output of \"git rev-parse HEAD\"")
-    parser.add_argument("prefix", action="store", type=str,
-        help="Non-empty include file prefix (e.g. a/b)")
+        description='Generates a single include file from a file including multiple C/C++ headers')
+    parser.add_argument('-i', '--input', action='store', type=str, default='in.cpp',
+        help='Input file including the headers to be merged')
+    parser.add_argument('-o', '--output', action='store', type=str, default='out.cpp',
+        help='Output file. NOTE: It will be overwritten!')
+    parser.add_argument('-p', '--path', action='store', type=str, default='.',
+        help='Include path')
+    parser.add_argument('--hash', action='store', type=str,
+        help='The git hash to print in the output file, e.g. the output of "git rev-parse HEAD"')
+    parser.add_argument('prefix', action='store', type=str,
+        help='Non-empty include file prefix (e.g. a/b)')
+    parser.add_argument('--linerefs', action='store_true',
+        help='Output #line references to the original files. By default the line references are written commented out')
     args = parser.parse_args()
 
     regex_includes = re.compile(r"""^\s*#[\t\s]*include[\t\s]*("|\<)(?P<include>%s.*)("|\>)""" % args.prefix)
-    print("Rebuilding %s:" % args.input)
-    with open(args.output, 'w') as output_file, open(args.input, 'r') as input_file:
-        output_file.write(
+    print('Rebuilding %s:' % args.input)
+    tmp_file_name = args.output + '.tmp'
+    with open(tmp_file_name, 'w') as tmp_file, open(args.input, 'r') as input_file:
+        tmp_file.write(
             '#ifndef BOOST_LEAF_HPP_INCLUDED\n'
             '#define BOOST_LEAF_HPP_INCLUDED\n'
             '\n'
-            '// LEAF single header distribution. Do not edit.\n'
-            '\n'
-            '// Generated on ' + date.today().strftime("%m/%d/%Y"))
+            '// Boost LEAF single header distribution. Do not edit.\n'
+            '// Generated on ' + date.today().strftime('%b %d, %Y'))
         if args.hash:
-            output_file.write(
+            tmp_file.write(
                 ' from https://github.com/boostorg/leaf/tree/' + args.hash[0:7])
-        output_file.write(
+        tmp_file.write(
             '.\n'
-            '// Latest version of this file: https://raw.githubusercontent.com/boostorg/leaf/gh-pages/leaf.hpp.\n'
+            '\n'
+            '// Latest published version of this file: https://raw.githubusercontent.com/boostorg/leaf/gh-pages/leaf.hpp.\n'
+            '\n'
+            '// Copyright 2018-2024 Emil Dotchevski and Reverge Studios, Inc.\n'
+            '// Distributed under the Boost Software License, Version 1.0. (See accompanying\n'
+            '// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n'
             '\n')
-        append(args.input, input_file, output_file, regex_includes, args.path)
-        output_file.write(
+        append(args.input, input_file, tmp_file, regex_includes, args.path, '' if args.linerefs else '// ', 0)
+        tmp_file.write(
             '\n'
-            '#endif\n' )
-#       print("%d" % total_line_count)
+            '#endif // BOOST_LEAF_HPP_INCLUDED\n' )
+    compare_and_update(args.output, tmp_file_name)
+#       print('%d' % total_line_count)
 
 if __name__ == "__main__":
     _main()
diff --git a/include/boost/leaf.hpp b/include/boost/leaf.hpp
index 743221b6..8c2b181a 100644
--- a/include/boost/leaf.hpp
+++ b/include/boost/leaf.hpp
@@ -1,8 +1,7 @@
 #ifndef BOOST_LEAF_HPP_INCLUDED
 #define BOOST_LEAF_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/include/boost/leaf/capture.hpp b/include/boost/leaf/capture.hpp
deleted file mode 100644
index 6455eb2d..00000000
--- a/include/boost/leaf/capture.hpp
+++ /dev/null
@@ -1,235 +0,0 @@
-#ifndef BOOST_LEAF_CAPTURE_HPP_INCLUDED
-#define BOOST_LEAF_CAPTURE_HPP_INCLUDED
-
-// Copyright 2018-2022 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>
-    inline
-    decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
-    capture_impl(is_result_tag<R, false>, context_ptr && 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>
-    inline
-    decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
-    capture_impl(is_result_tag<R, true>, context_ptr && 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::move(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:
-
-        capturing_exception(std::exception_ptr && ex, context_ptr && ctx) noexcept:
-            ex_(std::move(ex)),
-            ctx_(std::move(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_uint32<tls_tag_id_factory_current_id>(ctx_->captured_id_.value());
-            ctx_->propagate(ctx_->captured_id_);
-            std::rethrow_exception(ex_);
-        }
-
-        template <class CharT, class Traits>
-        void print( std::basic_ostream<CharT, Traits> & os ) const
-        {
-            ctx_->print(os);
-        }
-    };
-
-    template <class R, class F, class... A>
-    inline
-    decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
-    capture_impl(is_result_tag<R, false>, context_ptr && 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();
-            throw_exception( capturing_exception(std::current_exception(), std::move(ctx)) );
-        }
-        catch(...)
-        {
-            ctx->captured_id_ = cur_err.assigned_error_id();
-            throw_exception( capturing_exception(std::current_exception(), std::move(ctx)) );
-        }
-    }
-
-    template <class R, class F, class... A>
-    inline
-    decltype(std::declval<F>()(std::forward<A>(std::declval<A>())...))
-    capture_impl(is_result_tag<R, true>, context_ptr && 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::move(ctx);
-            }
-        }
-        catch( capturing_exception const & )
-        {
-            throw;
-        }
-        catch( exception_base const & e )
-        {
-            ctx->captured_id_ = e.get_error_id();
-            throw_exception( capturing_exception(std::current_exception(), std::move(ctx)) );
-        }
-        catch(...)
-        {
-            ctx->captured_id_ = cur_err.assigned_error_id();
-            throw_exception( capturing_exception(std::current_exception(), std::move(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 && 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/common.hpp b/include/boost/leaf/common.hpp
index 2069f55a..05ec9871 100644
--- a/include/boost/leaf/common.hpp
+++ b/include/boost/leaf/common.hpp
@@ -1,8 +1,7 @@
 #ifndef BOOST_LEAF_COMMON_HPP_INCLUDED
 #define BOOST_LEAF_COMMON_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -10,10 +9,13 @@
 #include <boost/leaf/detail/demangle.hpp>
 
 #include <iosfwd>
+#include <cerrno>
+#include <cstring>
+
 #if BOOST_LEAF_CFG_STD_STRING
 #   include <string>
 #endif
-#include <cerrno>
+
 #if BOOST_LEAF_CFG_WIN32
 #   include <windows.h>
 #   include <cstring>
@@ -40,7 +42,7 @@ struct BOOST_LEAF_SYMBOL_VISIBLE e_file_name
 
 struct BOOST_LEAF_SYMBOL_VISIBLE e_file_name
 {
-    constexpr static char const * const value = "<unavailable>";
+    char const * value = "<unavailable>";
     BOOST_LEAF_CONSTEXPR explicit e_file_name( char const * ) { }
 };
 
@@ -50,12 +52,12 @@ struct BOOST_LEAF_SYMBOL_VISIBLE e_errno
 {
     int value;
 
-    explicit e_errno(int value=errno): value(value) { }
+    explicit e_errno(int val=errno): value(val) { }
 
     template <class CharT, class Traits>
-    friend std::basic_ostream<CharT, Traits> & operator<<(std::basic_ostream<CharT, Traits> & os, e_errno const & err)
+    friend std::ostream & operator<<(std::basic_ostream<CharT, Traits> & os, e_errno const & err)
     {
-        return os << type<e_errno>() << ": " << err.value << ", \"" << std::strerror(err.value) << '"';
+        return os << err.value << ", \"" << std::strerror(err.value) << '"';
     }
 };
 
@@ -69,13 +71,13 @@ namespace windows
     {
         unsigned value;
 
-        explicit e_LastError(unsigned value): value(value) { }
+        explicit e_LastError(unsigned val): value(val) { }
 
 #if BOOST_LEAF_CFG_WIN32
         e_LastError(): value(GetLastError()) { }
 
         template <class CharT, class Traits>
-        friend std::basic_ostream<CharT, Traits> & operator<<(std::basic_ostream<CharT, Traits> & os, e_LastError const & err)
+        friend std::ostream & operator<<(std::basic_ostream<CharT, Traits> & os, e_LastError const & err)
         {
             struct msg_buf
             {
@@ -99,7 +101,7 @@ namespace windows
                     *--z = 0;
                 if( z[-1] == '\r' )
                     *--z = 0;
-                return os << type<e_LastError>() << ": " << err.value << ", \"" << (LPCSTR)mb.p << '"';
+                return os << err.value << ", \"" << (LPCSTR)mb.p << '"';
             }
             return os;
         }
@@ -109,4 +111,4 @@ namespace windows
 
 } }
 
-#endif
+#endif // BOOST_LEAF_COMMON_HPP_INCLUDED
diff --git a/include/boost/leaf/config.hpp b/include/boost/leaf/config.hpp
index 7c7e7d2b..a744c101 100644
--- a/include/boost/leaf/config.hpp
+++ b/include/boost/leaf/config.hpp
@@ -1,59 +1,36 @@
 #ifndef BOOST_LEAF_CONFIG_HPP_INCLUDED
 #define BOOST_LEAF_CONFIG_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
-// The following is based in part on Boost Config.
-
-// (C) Copyright John Maddock 2001 - 2003.
-// (C) Copyright Martin Wille 2003.
-// (C) Copyright Guillaume Melquiond 2003.
-
-#ifndef BOOST_LEAF_ASSERT
-#   include <cassert>
-#   define BOOST_LEAF_ASSERT assert
-#endif
-
-////////////////////////////////////////
-
-#ifdef BOOST_LEAF_DIAGNOSTICS
-#   warning BOOST_LEAF_DIAGNOSTICS has been renamed to BOOST_LEAF_CFG_DIAGNOSTICS.
-#   define BOOST_LEAF_CFG_DIAGNOSTICS BOOST_LEAF_DIAGNOSTICS
-#endif
-
-////////////////////////////////////////
-
 #ifdef BOOST_LEAF_TLS_FREERTOS
-
 #   ifndef BOOST_LEAF_EMBEDDED
 #       define BOOST_LEAF_EMBEDDED
 #   endif
-
 #endif
 
-////////////////////////////////////////
-
 #ifdef BOOST_LEAF_EMBEDDED
-
 #   ifndef BOOST_LEAF_CFG_DIAGNOSTICS
 #       define BOOST_LEAF_CFG_DIAGNOSTICS 0
 #   endif
-
 #   ifndef BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 #       define BOOST_LEAF_CFG_STD_SYSTEM_ERROR 0
 #   endif
-
 #   ifndef BOOST_LEAF_CFG_STD_STRING
 #       define BOOST_LEAF_CFG_STD_STRING 0
 #   endif
-
 #   ifndef BOOST_LEAF_CFG_CAPTURE
 #       define BOOST_LEAF_CFG_CAPTURE 0
 #   endif
+#endif
+
+////////////////////////////////////////
 
+#ifndef BOOST_LEAF_ASSERT
+#   include <cassert>
+#   define BOOST_LEAF_ASSERT assert
 #endif
 
 ////////////////////////////////////////
@@ -86,108 +63,92 @@
 #   endif
 #endif
 
-#if BOOST_LEAF_CFG_DIAGNOSTICS!=0 && BOOST_LEAF_CFG_DIAGNOSTICS!=1
+#ifndef BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER
+#   define BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "\n    "
+#endif
+
+#ifndef BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER
+#   define BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "\n    "
+#endif
+
+#if BOOST_LEAF_CFG_DIAGNOSTICS != 0 && BOOST_LEAF_CFG_DIAGNOSTICS != 1
 #   error BOOST_LEAF_CFG_DIAGNOSTICS must be 0 or 1.
 #endif
 
-#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR!=0 && BOOST_LEAF_CFG_STD_SYSTEM_ERROR!=1
+#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR != 0 && BOOST_LEAF_CFG_STD_SYSTEM_ERROR != 1
 #   error BOOST_LEAF_CFG_STD_SYSTEM_ERROR must be 0 or 1.
 #endif
 
-#if BOOST_LEAF_CFG_STD_STRING!=0 && BOOST_LEAF_CFG_STD_STRING!=1
+#if BOOST_LEAF_CFG_STD_STRING != 0 && BOOST_LEAF_CFG_STD_STRING != 1
 #   error BOOST_LEAF_CFG_STD_STRING must be 0 or 1.
 #endif
 
-#if BOOST_LEAF_CFG_CAPTURE!=0 && BOOST_LEAF_CFG_CAPTURE!=1
+#if BOOST_LEAF_CFG_CAPTURE != 0 && BOOST_LEAF_CFG_CAPTURE != 1
 #   error BOOST_LEAF_CFG_CAPTURE must be 0 or 1.
 #endif
 
+#if BOOST_LEAF_CFG_WIN32 != 0 && BOOST_LEAF_CFG_WIN32 != 1
+#   error BOOST_LEAF_CFG_WIN32 must be 0 or 1.
+#endif
+
+#if BOOST_LEAF_CFG_GNUC_STMTEXPR != 0 && BOOST_LEAF_CFG_GNUC_STMTEXPR != 1
+#   error BOOST_LEAF_CFG_GNUC_STMTEXPR must be 0 or 1.
+#endif
+
 #if BOOST_LEAF_CFG_DIAGNOSTICS && !BOOST_LEAF_CFG_STD_STRING
-#   error BOOST_LEAF_CFG_DIAGNOSTICS requires the use of std::string
+#   error BOOST_LEAF_CFG_DIAGNOSTICS requires BOOST_LEAF_CFG_STD_STRING, which has been disabled.
 #endif
 
-#if BOOST_LEAF_CFG_WIN32!=0 && BOOST_LEAF_CFG_WIN32!=1
-#   error BOOST_LEAF_CFG_WIN32 must be 0 or 1.
+#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR && !BOOST_LEAF_CFG_STD_STRING
+#   error BOOST_LEAF_CFG_STD_SYSTEM_ERROR requires BOOST_LEAF_CFG_STD_STRING, which has been disabled.
 #endif
 
-#if BOOST_LEAF_CFG_GNUC_STMTEXPR!=0 && BOOST_LEAF_CFG_GNUC_STMTEXPR!=1
-#   error BOOST_LEAF_CFG_GNUC_STMTEXPR must be 0 or 1.
+////////////////////////////////////////
+
+#ifndef BOOST_LEAF_PRETTY_FUNCTION
+#   if defined(_MSC_VER) && !defined(__clang__) && !defined(__GNUC__)
+#       define BOOST_LEAF_PRETTY_FUNCTION __FUNCSIG__
+#   else
+#       define BOOST_LEAF_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#   endif
 #endif
 
 ////////////////////////////////////////
 
-// Configure BOOST_LEAF_NO_EXCEPTIONS, unless already #defined
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
-
+// The following is based in part on Boost Config.
+// (C) Copyright John Maddock 2001 - 2003.
+// (C) Copyright Martin Wille 2003.
+// (C) Copyright Guillaume Melquiond 2003.
 #   if defined(__clang__) && !defined(__ibmxl__)
 //  Clang C++ emulates GCC, so it has to appear early.
-
 #       if !__has_feature(cxx_exceptions)
 #           define BOOST_LEAF_NO_EXCEPTIONS
 #       endif
-
-#   elif defined(__DMC__)
-//  Digital Mars C++
-
-#       if !defined(_CPPUNWIND)
-#           define BOOST_LEAF_NO_EXCEPTIONS
-#       endif
-
 #   elif defined(__GNUC__) && !defined(__ibmxl__)
 //  GNU C++:
-
 #       if !defined(__EXCEPTIONS)
 #           define BOOST_LEAF_NO_EXCEPTIONS
 #       endif
-
-#   elif defined(__KCC)
-//  Kai C++
-
-#       if !defined(_EXCEPTIONS)
-#           define BOOST_LEAF_NO_EXCEPTIONS
-#       endif
-
 #   elif defined(__CODEGEARC__)
 //  CodeGear - must be checked for before Borland
-
-#       if !defined(_CPPUNWIND) && !defined(__EXCEPTIONS)
-#           define BOOST_LEAF_NO_EXCEPTIONS
-#       endif
-
-#   elif defined(__BORLANDC__)
-//  Borland
-
 #       if !defined(_CPPUNWIND) && !defined(__EXCEPTIONS)
 #           define BOOST_LEAF_NO_EXCEPTIONS
 #       endif
-
-#   elif defined(__MWERKS__)
-//  Metrowerks CodeWarrior
-
-#       if !__option(exceptions)
-#           define BOOST_LEAF_NO_EXCEPTIONS
-#       endif
-
 #   elif defined(__IBMCPP__) && defined(__COMPILER_VER__) && defined(__MVS__)
 //  IBM z/OS XL C/C++
-
 #       if !defined(_CPPUNWIND) && !defined(__EXCEPTIONS)
 #           define BOOST_LEAF_NO_EXCEPTIONS
 #       endif
-
 #   elif defined(__ibmxl__)
 //  IBM XL C/C++ for Linux (Little Endian)
-
 #       if !__has_feature(cxx_exceptions)
 #           define BOOST_LEAF_NO_EXCEPTIONS
 #       endif
-
 #   elif defined(_MSC_VER)
 //  Microsoft Visual C++
-//
 //  Must remain the last #elif since some other vendors (Metrowerks, for
 //  example) also #define _MSC_VER
-
 #       if !_CPPUNWIND
 #           define BOOST_LEAF_NO_EXCEPTIONS
 #       endif
@@ -195,27 +156,6 @@
 
 #endif
 
-#ifdef BOOST_NORETURN
-#   define BOOST_LEAF_NORETURN BOOST_NORETURN
-#else
-#   if defined(_MSC_VER)
-#       define BOOST_LEAF_NORETURN __declspec(noreturn)
-#   elif defined(__GNUC__)
-#       define BOOST_LEAF_NORETURN __attribute__ ((__noreturn__))
-#   elif defined(__has_attribute) && defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x5130)
-#       if __has_attribute(noreturn)
-#           define BOOST_LEAF_NORETURN [[noreturn]]
-#       endif
-#   elif defined(__has_cpp_attribute)
-#       if __has_cpp_attribute(noreturn)
-#           define BOOST_LEAF_NORETURN [[noreturn]]
-#       endif
-#   endif
-#endif
-#if !defined(BOOST_LEAF_NORETURN)
-#  define BOOST_LEAF_NORETURN
-#endif
-
 ////////////////////////////////////////
 
 #ifdef _MSC_VER
@@ -226,12 +166,18 @@
 
 ////////////////////////////////////////
 
-#ifndef BOOST_LEAF_NODISCARD
-#   if __cplusplus >= 201703L
-#       define BOOST_LEAF_NODISCARD [[nodiscard]]
-#   else
-#       define BOOST_LEAF_NODISCARD
+#if defined(__has_attribute) && defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x5130)
+#   if __has_attribute(nodiscard)
+#       define BOOST_LEAF_ATTRIBUTE_NODISCARD [[nodiscard]]
 #   endif
+#elif defined(__has_cpp_attribute)
+// require c++17 regardless of compiler
+#   if __has_cpp_attribute(nodiscard) && __cplusplus >= 201703L
+#       define BOOST_LEAF_ATTRIBUTE_NODISCARD [[nodiscard]]
+#   endif
+#endif
+#ifndef BOOST_LEAF_ATTRIBUTE_NODISCARD
+#   define BOOST_LEAF_ATTRIBUTE_NODISCARD
 #endif
 
 ////////////////////////////////////////
@@ -246,6 +192,16 @@
 
 ////////////////////////////////////////
 
+#ifndef BOOST_LEAF_DEPRECATED
+#   if __cplusplus > 201402L
+#       define BOOST_LEAF_DEPRECATED(msg) [[deprecated(msg)]]
+#   else
+#       define BOOST_LEAF_DEPRECATED(msg)
+#   endif
+#endif
+
+////////////////////////////////////////
+
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
 #   include <exception>
 #   if (defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L) || (defined(_MSC_VER) && _MSC_VER >= 1900)
@@ -258,7 +214,7 @@
 ////////////////////////////////////////
 
 #ifdef __GNUC__
-#   define BOOST_LEAF_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
+#   define BOOST_LEAF_SYMBOL_VISIBLE [[gnu::visibility("default")]]
 #else
 #   define BOOST_LEAF_SYMBOL_VISIBLE
 #endif
@@ -276,6 +232,4 @@
 // Configure TLS access
 #include <boost/leaf/config/tls.hpp>
 
-////////////////////////////////////////
-
-#endif
+#endif // BOOST_LEAF_CONFIG_HPP_INCLUDED
diff --git a/include/boost/leaf/config/tls.hpp b/include/boost/leaf/config/tls.hpp
index 279bafb2..0dd42489 100644
--- a/include/boost/leaf/config/tls.hpp
+++ b/include/boost/leaf/config/tls.hpp
@@ -1,8 +1,7 @@
 #ifndef BOOST_LEAF_CONFIG_TLS_HPP_INCLUDED
 #define BOOST_LEAF_CONFIG_TLS_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -30,4 +29,4 @@
 #   include <boost/leaf/config/tls_cpp11.hpp>
 #endif
 
-#endif
+#endif // BOOST_LEAF_CONFIG_TLS_HPP_INCLUDED
diff --git a/include/boost/leaf/config/tls_array.hpp b/include/boost/leaf/config/tls_array.hpp
index f194c56c..456e50f9 100644
--- a/include/boost/leaf/config/tls_array.hpp
+++ b/include/boost/leaf/config/tls_array.hpp
@@ -1,15 +1,15 @@
 #ifndef BOOST_LEAF_CONFIG_TLS_ARRAY_HPP_INCLUDED
 #define BOOST_LEAF_CONFIG_TLS_ARRAY_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-// Copyright (c) 2022 Khalil Estell
-
+// Copyright 2018-2024 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)
 
+// Copyright (c) 2022 Khalil Estell
+
 // LEAF requires thread local storage support for pointers and for uin32_t values.
 
-// This header implements thread local storage for pointers and for uint32_t
+// This header implements thread local storage for pointers and for unsigned int
 // values for platforms that support thread local pointers by index.
 
 namespace boost { namespace leaf {
@@ -53,7 +53,7 @@ static_assert((BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX) >= 0,
 
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+namespace detail
 {
     using atomic_unsigned_int = std::atomic<unsigned int>;
 }
@@ -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 index 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>();
 
     ////////////////////////////////////////
 
@@ -121,32 +127,20 @@ namespace tls
     ////////////////////////////////////////
 
     template <class Tag>
-    std::uint32_t read_uint32() noexcept
+    unsigned read_uint() noexcept
     {
-        static_assert(sizeof(std::intptr_t) >= sizeof(std::uint32_t), "Incompatible tls_array implementation");
-        return (std::uint32_t) (std::intptr_t) (void *) read_ptr<Tag>();
+        static_assert(sizeof(std::intptr_t) >= sizeof(unsigned), "Incompatible tls_array implementation");
+        return (unsigned) (std::intptr_t) (void *) read_ptr<Tag>();
     }
 
     template <class Tag>
-    void write_uint32( std::uint32_t x ) noexcept
+    void write_uint( unsigned x ) noexcept
     {
-        static_assert(sizeof(std::intptr_t) >= sizeof(std::uint32_t), "Incompatible tls_array implementation");
+        static_assert(sizeof(std::intptr_t) >= sizeof(unsigned), "Incompatible tls_array implementation");
         write_ptr<Tag>((Tag *) (void *) (std::intptr_t) x);
     }
-
-    template <class Tag>
-    void uint32_increment() noexcept
-    {
-        write_uint32<Tag>(read_uint32<Tag>() + 1);
-    }
-
-    template <class Tag>
-    void uint32_decrement() noexcept
-    {
-        write_uint32<Tag>(read_uint32<Tag>() - 1);
-    }
 }
 
 } }
 
-#endif
+#endif // BOOST_LEAF_CONFIG_TLS_ARRAY_HPP_INCLUDED
diff --git a/include/boost/leaf/config/tls_cpp11.hpp b/include/boost/leaf/config/tls_cpp11.hpp
index dbc6711e..9828c77a 100644
--- a/include/boost/leaf/config/tls_cpp11.hpp
+++ b/include/boost/leaf/config/tls_cpp11.hpp
@@ -1,14 +1,13 @@
 #ifndef BOOST_LEAF_CONFIG_TLS_CPP11_HPP_INCLUDED
 #define BOOST_LEAF_CONFIG_TLS_CPP11_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
 // LEAF requires thread local storage support for pointers and for uin32_t values.
 
-// This header implements thread local storage for pointers and for uint32_t
+// This header implements thread local storage for pointers and for unsigned int
 // values using the C++11 built-in thread_local storage class specifier.
 
 #include <cstdint>
@@ -16,7 +15,7 @@
 
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+namespace detail
 {
     using atomic_unsigned_int = std::atomic<unsigned int>;
 }
@@ -47,39 +46,27 @@ namespace tls
     ////////////////////////////////////////
 
     template <class Tag>
-    struct BOOST_LEAF_SYMBOL_VISIBLE tagged_uint32
+    struct BOOST_LEAF_SYMBOL_VISIBLE tagged_uint
     {
-        static thread_local std::uint32_t x;
+        static thread_local unsigned x;
     };
 
     template <class Tag>
-    thread_local std::uint32_t tagged_uint32<Tag>::x;
-
-    template <class Tag>
-    std::uint32_t read_uint32() noexcept
-    {
-        return tagged_uint32<Tag>::x;
-    }
-
-    template <class Tag>
-    void write_uint32( std::uint32_t x ) noexcept
-    {
-        tagged_uint32<Tag>::x = x;
-    }
+    thread_local unsigned tagged_uint<Tag>::x;
 
     template <class Tag>
-    void uint32_increment() noexcept
+    unsigned read_uint() noexcept
     {
-        ++tagged_uint32<Tag>::x;
+        return tagged_uint<Tag>::x;
     }
 
     template <class Tag>
-    void uint32_decrement() noexcept
+    void write_uint( unsigned x ) noexcept
     {
-        --tagged_uint32<Tag>::x;
+        tagged_uint<Tag>::x = x;
     }
 }
 
 } }
 
-#endif
+#endif // BOOST_LEAF_CONFIG_TLS_CPP11_HPP_INCLUDED
diff --git a/include/boost/leaf/config/tls_freertos.hpp b/include/boost/leaf/config/tls_freertos.hpp
index a2678693..d1d0be98 100644
--- a/include/boost/leaf/config/tls_freertos.hpp
+++ b/include/boost/leaf/config/tls_freertos.hpp
@@ -1,12 +1,17 @@
 #ifndef BOOST_LEAF_CONFIG_TLS_FREERTOS_HPP_INCLUDED
 #define BOOST_LEAF_CONFIG_TLS_FREERTOS_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-// Copyright (c) 2022 Khalil Estell
-
+// Copyright 2018-2024 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)
 
+// Copyright (c) 2022 Khalil Estell
+
+// LEAF requires thread local storage support for pointers and for uin32_t values.
+
+// This header implements "thread local" storage via FreeTOS functions
+// pvTaskGetThreadLocalStoragePointer / pvTaskSetThreadLocalStoragePointer
+
 #include <task.h>
 
 #ifndef BOOST_LEAF_USE_TLS_ARRAY
@@ -39,4 +44,4 @@ namespace tls
 
 } }
 
-#endif
+#endif // BOOST_LEAF_CONFIG_TLS_FREERTOS_HPP_INCLUDED
diff --git a/include/boost/leaf/config/tls_globals.hpp b/include/boost/leaf/config/tls_globals.hpp
index 0dc92ffc..5e9b1e90 100644
--- a/include/boost/leaf/config/tls_globals.hpp
+++ b/include/boost/leaf/config/tls_globals.hpp
@@ -1,21 +1,20 @@
 #ifndef BOOST_LEAF_CONFIG_TLS_GLOBALS_HPP_INCLUDED
 #define BOOST_LEAF_CONFIG_TLS_GLOBALS_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
 // LEAF requires thread local storage support for pointers and for uin32_t values.
 
-// This header implements "thread local" storage for pointers and for uint32_t
+// This header implements "thread local" storage for pointers and for unsigned int
 // values using globals, which is suitable for single thread environments.
 
 #include <cstdint>
 
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+namespace detail
 {
     using atomic_unsigned_int = unsigned int;
 }
@@ -46,39 +45,27 @@ namespace tls
     ////////////////////////////////////////
 
     template <class Tag>
-    struct BOOST_LEAF_SYMBOL_VISIBLE tagged_uint32
+    struct BOOST_LEAF_SYMBOL_VISIBLE tagged_uint
     {
-        static std::uint32_t x;
+        static unsigned x;
     };
 
     template <class Tag>
-    std::uint32_t tagged_uint32<Tag>::x;
-
-    template <class Tag>
-    std::uint32_t read_uint32() noexcept
-    {
-        return tagged_uint32<Tag>::x;
-    }
-
-    template <class Tag>
-    void write_uint32( std::uint32_t x ) noexcept
-    {
-        tagged_uint32<Tag>::x = x;
-    }
+    unsigned tagged_uint<Tag>::x;
 
     template <class Tag>
-    void uint32_increment() noexcept
+    unsigned read_uint() noexcept
     {
-        ++tagged_uint32<Tag>::x;
+        return tagged_uint<Tag>::x;
     }
 
     template <class Tag>
-    void uint32_decrement() noexcept
+    void write_uint( unsigned x ) noexcept
     {
-        --tagged_uint32<Tag>::x;
+        tagged_uint<Tag>::x = x;
     }
 }
 
 } }
 
-#endif
+#endif // BOOST_LEAF_CONFIG_TLS_GLOBALS_HPP_INCLUDED
diff --git a/include/boost/leaf/context.hpp b/include/boost/leaf/context.hpp
index 0ac45d20..15dcb22c 100644
--- a/include/boost/leaf/context.hpp
+++ b/include/boost/leaf/context.hpp
@@ -1,8 +1,7 @@
 #ifndef BOOST_LEAF_CONTEXT_HPP_INCLUDED
 #define BOOST_LEAF_CONTEXT_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -10,21 +9,21 @@
 #include <boost/leaf/error.hpp>
 
 #if !defined(BOOST_LEAF_NO_THREADS) && !defined(NDEBUG)
-# include <thread>
+#   include <thread>
 #endif
 
 namespace boost { namespace leaf {
 
 class error_info;
 class diagnostic_info;
-class verbose_diagnostic_info;
+class diagnostic_details;
 
 template <class>
 struct is_predicate: std::false_type
 {
 };
 
-namespace leaf_detail
+namespace detail
 {
     template <class T>
     struct is_exception: std::is_base_of<std::exception, typename std::decay<T>::type>
@@ -41,6 +40,7 @@ namespace leaf_detail
     struct handler_argument_traits_defaults<E, false>
     {
         using error_type = typename std::decay<E>::type;
+        using context_types = leaf_detail_mp11::mp_list<error_type>;
         constexpr static bool always_available = false;
 
         template <class Tup>
@@ -58,7 +58,7 @@ 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 &");
-        static_assert(!std::is_same<E, verbose_diagnostic_info>::value, "Handlers must take leaf::verbose_diagnostic_info arguments by const &");
+        static_assert(!std::is_same<E, diagnostic_details>::value, "Handlers must take leaf::diagnostic_details arguments by const &");
     };
 
     template <class Pred>
@@ -81,10 +81,10 @@ namespace leaf_detail
         }
     };
 
-    template <class E>
+    template <class... E>
     struct handler_argument_always_available
     {
-        using error_type = E;
+        using context_types = leaf_detail_mp11::mp_list<E...>;
         constexpr static bool always_available = true;
 
         template <class Tup>
@@ -102,7 +102,7 @@ namespace leaf_detail
     template <>
     struct handler_argument_traits<void>
     {
-        using error_type = void;
+        using context_types = leaf_detail_mp11::mp_list<>;
         constexpr static bool always_available = false;
 
         template <class Tup>
@@ -125,120 +125,115 @@ namespace leaf_detail
         }
     };
 
-    template <>
-    struct handler_argument_traits<error_info const &>: handler_argument_always_available<void>
+    template <class E>
+    struct handler_argument_traits_require_by_value
     {
-        template <class Tup>
-        BOOST_LEAF_CONSTEXPR static error_info const & get( Tup const &, error_info const & ei ) noexcept
+        static_assert(sizeof(E) == 0, "Error handlers must take this type by value");
+    };
+}
+
+////////////////////////////////////////
+
+namespace detail
+{
+    template <class T>
+    struct get_dispatch
+    {
+        static BOOST_LEAF_CONSTEXPR T const * get(T const * x) noexcept
+        {
+            return x;
+        }
+        static BOOST_LEAF_CONSTEXPR T const * get(void const *) noexcept
         {
-            return ei;
+            return nullptr;
         }
     };
 
-    template <class E>
-    struct handler_argument_traits_require_by_value
+    template <class T>
+    BOOST_LEAF_CONSTEXPR inline T * find_in_tuple(std::tuple<> const &)
     {
-        static_assert(sizeof(E) == 0, "Error handlers must take this type by value");
-    };
+        return nullptr;
+    }
+
+    template <class T, int I = 0, class... Tp>
+    BOOST_LEAF_CONSTEXPR inline typename std::enable_if<I == sizeof...(Tp) - 1, T>::type const *
+    find_in_tuple(std::tuple<Tp...> const & t) noexcept
+    {
+        return get_dispatch<T>::get(&std::get<I>(t));
+    }
+
+    template<class T, int I = 0, class... Tp>
+    BOOST_LEAF_CONSTEXPR inline typename std::enable_if<I < sizeof...(Tp) - 1, T>::type const *
+    find_in_tuple(std::tuple<Tp...> const & t) noexcept
+    {
+        if( T const * x = get_dispatch<T>::get(&std::get<I>(t)) )
+            return x;
+        else
+            return find_in_tuple<T, I+1, Tp...>(t);
+    }
 }
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
-    template <int I, class Tuple>
+    template <int I, class Tup>
     struct tuple_for_each
     {
-        BOOST_LEAF_CONSTEXPR static void activate( Tuple & tup ) noexcept
+        BOOST_LEAF_CONSTEXPR static void activate( Tup & tup ) 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");
-            tuple_for_each<I-1,Tuple>::activate(tup);
+            tuple_for_each<I-1,Tup>::activate(tup);
             std::get<I-1>(tup).activate();
         }
 
-        BOOST_LEAF_CONSTEXPR static void deactivate( Tuple & tup ) noexcept
+        BOOST_LEAF_CONSTEXPR static void deactivate( Tup & tup ) 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");
             std::get<I-1>(tup).deactivate();
-            tuple_for_each<I-1,Tuple>::deactivate(tup);
-        }
-
-        BOOST_LEAF_CONSTEXPR static void propagate( 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");
-            auto & sl = std::get<I-1>(tup);
-            sl.propagate(err_id);
-            tuple_for_each<I-1,Tuple>::propagate(tup, err_id);
+            tuple_for_each<I-1,Tup>::deactivate(tup);
         }
 
-        BOOST_LEAF_CONSTEXPR static void propagate_captured( Tuple & tup, int err_id ) noexcept
+        BOOST_LEAF_CONSTEXPR static void unload( Tup & 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);
-            if( sl.has_value(err_id) )
-                load_slot(err_id, std::move(sl).value(err_id));
-            tuple_for_each<I-1,Tuple>::propagate_captured(tup, err_id);
+            sl.unload(err_id);
+            tuple_for_each<I-1,Tup>::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, error_id to_print, char const * & prefix)
         {
             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,Tup>::print(os, tup, to_print, prefix);
+            std::get<I-1>(*static_cast<Tup const *>(tup)).print(os, to_print, prefix);
         }
     };
 
-    template <class Tuple>
-    struct tuple_for_each<0, Tuple>
+    template <class Tup>
+    struct tuple_for_each<0, Tup>
     {
-        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 propagate_captured( Tuple &, int ) noexcept { }
+        BOOST_LEAF_CONSTEXPR static void activate( Tup & ) noexcept { }
+        BOOST_LEAF_CONSTEXPR static void deactivate( Tup & ) noexcept { }
+        BOOST_LEAF_CONSTEXPR static void unload( Tup &, int ) noexcept { }
         template <class CharT, class Traits>
-        BOOST_LEAF_CONSTEXPR static void print( std::basic_ostream<CharT, Traits> &, void const *, int ) { }
+        BOOST_LEAF_CONSTEXPR static void print(std::basic_ostream<CharT, Traits> &, void const *, error_id, char const * &) { }
     };
-}
-
-////////////////////////////////////////////
-
-#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<>>
+    template <class Tup, class CharT, class Traits>
+    BOOST_LEAF_CONSTEXPR void print_tuple_contents(std::basic_ostream<CharT, Traits> & os, void const * tup, error_id to_print, char const * & prefix)
     {
-        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;
-    };
+        tuple_for_each<std::tuple_size<Tup>::value, Tup>::print(os, tup, to_print, prefix);
+    }
 }
 
-#endif
-
-////////////////////////////////////////////
+////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class T> struct does_not_participate_in_context_deduction: std::is_abstract<T> { };
-    template <> struct does_not_participate_in_context_deduction<void>: std::true_type { };
     template <> struct does_not_participate_in_context_deduction<error_id>: std::true_type { };
 
     template <class L>
@@ -250,7 +245,7 @@ namespace leaf_detail
         using type =
             leaf_detail_mp11::mp_remove_if<
                 leaf_detail_mp11::mp_unique<
-                    leaf_detail_mp11::mp_list<typename handler_argument_traits<T>::error_type...>
+                    leaf_detail_mp11::mp_append<typename handler_argument_traits<T>::context_types...>
                 >,
                 does_not_participate_in_context_deduction
             >;
@@ -269,7 +264,7 @@ namespace leaf_detail
     using deduce_e_tuple = typename deduce_e_tuple_impl<typename deduce_e_type_list<leaf_detail_mp11::mp_list<E...>>::type>::type;
 }
 
-////////////////////////////////////////////
+////////////////////////////////////////
 
 template <class... E>
 class context
@@ -277,7 +272,7 @@ class context
     context( context const & ) = delete;
     context & operator=( context const & ) = delete;
 
-    using Tup = leaf_detail::deduce_e_tuple<E...>;
+    using Tup = detail::deduce_e_tuple<E...>;
     Tup tup_;
     bool is_active_;
 
@@ -285,13 +280,29 @@ class context
     std::thread::id thread_id_;
 #endif
 
-protected:
-
-    BOOST_LEAF_CONSTEXPR error_id propagate_captured_errors( error_id err_id ) noexcept
+    class raii_deactivator
     {
-        leaf_detail::tuple_for_each<std::tuple_size<Tup>::value,Tup>::propagate_captured(tup_, err_id.value());
-        return err_id;
-    }
+        raii_deactivator( raii_deactivator const & ) = delete;
+        raii_deactivator & operator=( raii_deactivator const & ) = delete;
+        context * ctx_;
+    public:
+        explicit BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE raii_deactivator(context & ctx) noexcept:
+            ctx_(ctx.is_active() ? nullptr : &ctx)
+        {
+            if( ctx_ )
+                ctx_->activate();
+        }
+        BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE raii_deactivator( raii_deactivator && x ) noexcept:
+            ctx_(x.ctx_)
+        {
+            x.ctx_ = nullptr;
+        }
+        BOOST_LEAF_ALWAYS_INLINE ~raii_deactivator() noexcept
+        {
+            if( ctx_ && ctx_->is_active() )
+                ctx_->deactivate();
+        }
+    };
 
 public:
 
@@ -324,13 +335,9 @@ class context
 
     BOOST_LEAF_CONSTEXPR void activate() noexcept
     {
-        using namespace leaf_detail;
+        using namespace 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::uint32_increment<tls_tag_unexpected_enabled_counter>();
-#endif
 #if !defined(BOOST_LEAF_NO_THREADS) && !defined(NDEBUG)
         thread_id_ = std::this_thread::get_id();
 #endif
@@ -339,24 +346,20 @@ class context
 
     BOOST_LEAF_CONSTEXPR void deactivate() noexcept
     {
-        using namespace leaf_detail;
+        using namespace detail;
         BOOST_LEAF_ASSERT(is_active());
         is_active_ = false;
 #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::uint32_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());
+        detail::tuple_for_each<std::tuple_size<Tup>::value,Tup>::unload(tup_, id.value());
     }
 
     BOOST_LEAF_CONSTEXPR bool is_active() const noexcept
@@ -367,7 +370,22 @@ class context
     template <class CharT, class Traits>
     void print( std::basic_ostream<CharT, Traits> & os ) const
     {
-        leaf_detail::tuple_for_each<std::tuple_size<Tup>::value,Tup>::print(os, &tup_, 0);
+        char const * prefix = "Contents:";
+        detail::print_tuple_contents<Tup>(os, &tup_, error_id(), prefix);
+    }
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, context const & ctx )
+    {
+        ctx.print(os);
+        return os << '\n';
+    }
+
+    template <class T>
+    BOOST_LEAF_CONSTEXPR T const * get(error_id err) const noexcept
+    {
+        detail::slot<T> const * e = detail::find_in_tuple<detail::slot<T>>(tup_);
+        return e ? e->has_value(err.value()) : nullptr;
     }
 
     template <class R, class... H>
@@ -375,11 +393,16 @@ class context
 
     template <class R, class... H>
     BOOST_LEAF_CONSTEXPR R handle_error( error_id, H && ... );
+
+    friend BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE raii_deactivator activate_context(context & ctx) noexcept
+    {
+        return raii_deactivator(ctx);
+    }
 };
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class TypeList>
     struct deduce_context_impl;
@@ -416,25 +439,12 @@ 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
-    {
-        error_id propagate_captured_errors() noexcept final override { return Ctx::propagate_captured_errors(captured_id_); }
-        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>
-using context_type_from_handlers = typename leaf_detail::context_type_from_handlers_impl<H...>::type;
+using context_type_from_handlers = typename detail::context_type_from_handlers_impl<H...>::type;
 
-////////////////////////////////////////////
+////////////////////////////////////////
 
 template <class...  H>
 BOOST_LEAF_CONSTEXPR inline context_type_from_handlers<H...> make_context() noexcept
@@ -448,24 +458,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
+#endif // BOOST_LEAF_CONTEXT_HPP_INCLUDED
diff --git a/include/boost/leaf/detail/all.hpp b/include/boost/leaf/detail/all.hpp
index 8f5dcbd4..49edc16b 100644
--- a/include/boost/leaf/detail/all.hpp
+++ b/include/boost/leaf/detail/all.hpp
@@ -1,12 +1,11 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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/capture.hpp>
 #include <boost/leaf/common.hpp>
 #include <boost/leaf/context.hpp>
+#include <boost/leaf/diagnostics.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..37d24800
--- /dev/null
+++ b/include/boost/leaf/detail/capture_list.hpp
@@ -0,0 +1,124 @@
+#ifndef BOOST_LEAF_DETAIL_CAPTURE_LIST_HPP_INCLUDED
+#define BOOST_LEAF_DETAIL_CAPTURE_LIST_HPP_INCLUDED
+
+// Copyright 2018-2024 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/detail/print.hpp>
+
+#if BOOST_LEAF_CFG_CAPTURE
+
+#include <iosfwd>
+
+namespace boost { namespace leaf {
+
+class error_id;
+
+namespace 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 &, error_id const & to_print, char const * & prefix) 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_;
+            }
+        } * first_;
+
+        template <class F>
+        BOOST_LEAF_CONSTEXPR void for_each( F f ) const
+        {
+            for( node * p=first_; p; p=p->next_ )
+                f(*p);
+        }
+
+    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
+        {
+            for( node const * p = first_; p; )
+            {
+                node const * n = p -> next_;
+                delete p;
+                p = n;
+            }
+        }
+
+        void unload( int const err_id )
+        {
+            capture_list moved(first_);
+            first_ = nullptr;
+            tls::write_uint<detail::tls_tag_id_factory_current_id>(unsigned(err_id));
+            moved.for_each(
+                [err_id]( node & n )
+                {
+                    n.unload(err_id); // last node may throw
+                } );
+        }
+
+        template <class CharT, class Traits>
+        void print(std::basic_ostream<CharT, Traits> & os, error_id const & to_print, char const * & prefix) const
+        {
+#if BOOST_LEAF_CFG_DIAGNOSTICS
+            if( first_ )
+            {
+                for_each(
+                    [&os, &to_print, &prefix]( node const & n )
+                    {
+                        n.print(os, to_print, prefix);
+                    } );
+            }
+#else
+            (void) os;
+            (void) prefix;
+            (void) to_print;
+#endif
+        }
+    };
+
+}
+
+} }
+
+#endif
+
+#endif // BOOST_LEAF_DETAIL_CAPTURE_LIST_HPP_INCLUDED
diff --git a/include/boost/leaf/detail/demangle.hpp b/include/boost/leaf/detail/demangle.hpp
index ed275241..0465b877 100644
--- a/include/boost/leaf/detail/demangle.hpp
+++ b/include/boost/leaf/detail/demangle.hpp
@@ -1,8 +1,7 @@
 #ifndef BOOST_LEAF_DETAIL_DEMANGLE_HPP_INCLUDED
 #define BOOST_LEAF_DETAIL_DEMANGLE_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -16,50 +15,10 @@
 // http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/leaf/config.hpp>
+#include <iosfwd>
+#include <cstdlib>
 
-#include <cstring>
-
-namespace boost { namespace leaf {
-
-namespace leaf_detail
-{
-    template <int N>
-    BOOST_LEAF_CONSTEXPR inline char const * check_prefix( char const * t, char const (&prefix)[N] )
-    {
-        return std::strncmp(t,prefix,sizeof(prefix)-1)==0 ? t+sizeof(prefix)-1 : t;
-    }
-}
-
-template <class Name>
-inline char const * type()
-{
-    using leaf_detail::check_prefix;
-char const * t =
-#ifdef __FUNCSIG__
-    __FUNCSIG__;
-#else
-    __PRETTY_FUNCTION__;
-#endif
-#if defined(__clang__)
-    BOOST_LEAF_ASSERT(check_prefix(t,"const char *boost::leaf::type() ")==t+32);
-    return t+32;
-#elif defined(__GNUC__)
-    BOOST_LEAF_ASSERT(check_prefix(t,"const char* boost::leaf::type() ")==t+32);
-    return t+32;
-#else
-    char const * clang_style = check_prefix(t,"const char *boost::leaf::type() ");
-    if( clang_style!=t )
-        return clang_style;
-    char const * gcc_style = check_prefix(t,"const char* boost::leaf::type() ");
-    if( gcc_style!=t )
-        return gcc_style;
-#endif
-    return t;
-}
-
-} }
-
-////////////////////////////////////////
+#if BOOST_LEAF_CFG_DIAGNOSTICS
 
 // __has_include is currently supported by GCC and Clang. However GCC 4.9 may have issues and
 // returns 1 for 'defined( __has_include )', while '__has_include' is actually not supported:
@@ -68,123 +27,227 @@ char const * t =
 #   if __has_include(<cxxabi.h>)
 #       define BOOST_LEAF_HAS_CXXABI_H
 #   endif
-#elif defined( __GLIBCXX__ ) || defined( __GLIBCPP__ )
+#elif defined(__GLIBCXX__) || defined(__GLIBCPP__)
 #   define BOOST_LEAF_HAS_CXXABI_H
 #endif
 
-#if defined( BOOST_LEAF_HAS_CXXABI_H )
+#if defined(BOOST_LEAF_HAS_CXXABI_H)
 #   include <cxxabi.h>
 //  For some archtectures (mips, mips64, x86, x86_64) cxxabi.h in Android NDK is implemented by gabi++ library
 //  (https://android.googlesource.com/platform/ndk/+/master/sources/cxx-stl/gabi++/), which does not implement
 //  abi::__cxa_demangle(). We detect this implementation by checking the include guard here.
-#   if defined( __GABIXX_CXXABI_H__ )
+#   if defined(__GABIXX_CXXABI_H__)
 #       undef BOOST_LEAF_HAS_CXXABI_H
-#   else
-#       include <cstdlib>
-#       include <cstddef>
 #   endif
 #endif
 
-#if BOOST_LEAF_CFG_STD_STRING
-
-#include <string>
+#endif
 
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+namespace detail
 {
-    inline char const * demangle_alloc( char const * name ) noexcept;
-    inline void demangle_free( char const * name ) noexcept;
+    // The functions below are C++11 constexpr, but we use BOOST_LEAF_ALWAYS_INLINE to control object file
+    // section count / template bleat. Evidently this makes a difference on gcc / windows at least.
 
-    class scoped_demangled_name
+    template <int S1, int S2, int I, bool = S1 >= S2>
+    struct cpp11_prefix
     {
-    private:
-
-        char const * m_p;
-
-    public:
-
-        explicit scoped_demangled_name( char const * name ) noexcept :
-            m_p( demangle_alloc( name ) )
+        BOOST_LEAF_ALWAYS_INLINE constexpr static bool check(char const (&)[S1], char const (&)[S2]) noexcept
         {
+            return false;
         }
-
-        ~scoped_demangled_name() noexcept
+    };
+    template <int S1, int S2, int I>
+    struct cpp11_prefix<S1, S2, I, true>
+    {
+        BOOST_LEAF_ALWAYS_INLINE constexpr static bool check(char const (&str)[S1], char const (&prefix)[S2]) noexcept
         {
-            demangle_free( m_p );
+            return str[I] == prefix[I] && cpp11_prefix<S1, S2, I - 1>::check(str, prefix);
         }
-
-        char const * get() const noexcept
+    };
+    template <int S1, int S2>
+    struct cpp11_prefix<S1, S2, 0, true>
+    {
+        BOOST_LEAF_ALWAYS_INLINE constexpr static bool check(char const (&str)[S1], char const (&prefix)[S2]) noexcept
         {
-            return m_p;
+            return str[0] == prefix[0];
         }
-
-        scoped_demangled_name( scoped_demangled_name const& ) = delete;
-        scoped_demangled_name& operator= ( scoped_demangled_name const& ) = delete;
     };
-
-#ifdef BOOST_LEAF_HAS_CXXABI_H
-
-    inline char const * demangle_alloc( char const * name ) noexcept
+    template <int S1, int S2>
+    BOOST_LEAF_ALWAYS_INLINE constexpr int check_prefix(char const (&str)[S1], char const (&prefix)[S2]) noexcept
     {
-        int status = 0;
-        std::size_t size = 0;
-        return abi::__cxa_demangle( name, NULL, &size, &status );
+        return cpp11_prefix<S1, S2, S2 - 2>::check(str, prefix) ? S2 - 1 : 0;
     }
 
-    inline void demangle_free( char const * name ) noexcept
-    {
-        std::free( const_cast< char* >( name ) );
-    }
+    ////////////////////////////////////////
 
-    inline std::string demangle( char const * name )
+    template <int S1, int S2, int I1, int I2, bool = S1 >= S2>
+    struct cpp11_suffix
     {
-        scoped_demangled_name demangled_name( name );
-        char const * p = demangled_name.get();
-        if( !p )
-            p = name;
-        return p;
-    }
-
-#else
-
-    inline char const * demangle_alloc( char const * name ) noexcept
+        BOOST_LEAF_ALWAYS_INLINE constexpr static bool check(char const (&)[S1], char const (&)[S2]) noexcept
+        {
+            return false;
+        }
+    };
+    template <int S1, int S2, int I1, int I2>
+    struct cpp11_suffix<S1, S2, I1, I2, true>
+    {
+        BOOST_LEAF_ALWAYS_INLINE constexpr static bool check(char const (&str)[S1], char const (&suffix)[S2]) noexcept
+        {
+            return str[I1] == suffix[I2] && cpp11_suffix<S1, S2, I1 - 1, I2 - 1>::check(str, suffix);
+        }
+    };
+    template <int S1, int S2, int I1>
+    struct cpp11_suffix<S1, S2, I1, 0, true>
     {
-        return name;
+        BOOST_LEAF_ALWAYS_INLINE constexpr static bool check(char const (&str)[S1], char const (&suffix)[S2]) noexcept
+        {
+            return str[I1] == suffix[0];
+        }
+    };
+    template <int S1, int S2>
+    BOOST_LEAF_ALWAYS_INLINE constexpr int check_suffix(char const (&str)[S1], char const (&suffix)[S2]) noexcept
+    {
+        return cpp11_suffix<S1, S2, S1 - 2, S2 - 2>::check(str, suffix) ? S1 - S2 : 0;
     }
+}
 
-    inline void demangle_free( char const * ) noexcept
+namespace n
+{
+    struct r
     {
-    }
+        char const * name;
+        int len;
+        r(char const * name, int len) noexcept:
+            name(name),
+            len(len)
+        {
+        }
+        template <class CharT, class Traits>
+        friend std::ostream & operator<<(std::basic_ostream<CharT, Traits> & os, r const & pn)
+        {
+            return os.write(pn.name, pn.len);
+        }
+    };
 
-    inline char const * demangle( char const * name )
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE r p()
     {
-        return name;
+        // C++11 compile-time parsing of __PRETTY_FUNCTION__/__FUNCSIG__. The sizeof hacks are a
+        // workaround for older GCC versions, where __PRETTY_FUNCTION__ is not constexpr, which triggers
+        // compile errors when used in constexpr expressinos, yet evaluating a sizeof exrpession works.
+
+        // We don't try to recognize the compiler based on compiler-specific macros. Any compiler/version
+        // is supported as long as it uses one of the formats we recognize.
+
+        // Unrecognized __PRETTY_FUNCTION__/__FUNCSIG__ formats will result in compiler diagnostics.
+        // In that case, please file an issue on https://github.com/boostorg/leaf.
+
+#define BOOST_LEAF_P(P) (sizeof(char[1 + detail::check_prefix(BOOST_LEAF_PRETTY_FUNCTION, P)]) - 1)
+        // clang style:
+        int const p01 = BOOST_LEAF_P("r boost::leaf::n::p() [T = ");
+        int const p02 = BOOST_LEAF_P("r __cdecl boost::leaf::n::p(void) [T = ");
+        int const p03 = BOOST_LEAF_P("r __stdcall boost::leaf::n::p(void) [T = ");
+        int const p04 = BOOST_LEAF_P("r __fastcall boost::leaf::n::p(void) [T = ");
+        // old clang style:
+        int const p05 = BOOST_LEAF_P("boost::leaf::n::r boost::leaf::n::p() [T = ");
+        int const p06 = BOOST_LEAF_P("boost::leaf::n::r __cdecl boost::leaf::n::p(void) [T = ");
+        int const p07 = BOOST_LEAF_P("boost::leaf::n::r __stdcall boost::leaf::n::p(void) [T = ");
+        int const p08 = BOOST_LEAF_P("boost::leaf::n::r __fastcall boost::leaf::n::p(void) [T = ");
+        // gcc style:
+        int const p09 = BOOST_LEAF_P("boost::leaf::n::r boost::leaf::n::p() [with T = ");
+        int const p10 = BOOST_LEAF_P("boost::leaf::n::r __cdecl boost::leaf::n::p() [with T = ");
+        int const p11 = BOOST_LEAF_P("boost::leaf::n::r __stdcall boost::leaf::n::p() [with T = ");
+        int const p12 = BOOST_LEAF_P("boost::leaf::n::r __fastcall boost::leaf::n::p() [with T = ");
+        // msvc style, struct:
+        int const p13 = BOOST_LEAF_P("struct boost::leaf::n::r __cdecl boost::leaf::n::p<struct ");
+        int const p14 = BOOST_LEAF_P("struct boost::leaf::n::r __stdcall boost::leaf::n::p<struct ");
+        int const p15 = BOOST_LEAF_P("struct boost::leaf::n::r __fastcall boost::leaf::n::p<struct ");
+        // msvc style, class:
+        int const p16 = BOOST_LEAF_P("struct boost::leaf::n::r __cdecl boost::leaf::n::p<class ");
+        int const p17 = BOOST_LEAF_P("struct boost::leaf::n::r __stdcall boost::leaf::n::p<class ");
+        int const p18 = BOOST_LEAF_P("struct boost::leaf::n::r __fastcall boost::leaf::n::p<class ");
+        // msvc style, enum:
+        int const p19 = BOOST_LEAF_P("struct boost::leaf::n::r __cdecl boost::leaf::n::p<enum ");
+        int const p20 = BOOST_LEAF_P("struct boost::leaf::n::r __stdcall boost::leaf::n::p<enum ");
+        int const p21 = BOOST_LEAF_P("struct boost::leaf::n::r __fastcall boost::leaf::n::p<enum ");
+        // msvc style, built-in type:
+        int const p22 = BOOST_LEAF_P("struct boost::leaf::n::r __cdecl boost::leaf::n::p<");
+        int const p23 = BOOST_LEAF_P("struct boost::leaf::n::r __stdcall boost::leaf::n::p<");
+        int const p24 = BOOST_LEAF_P("struct boost::leaf::n::r __fastcall boost::leaf::n::p<");
+#undef BOOST_LEAF_P
+
+#define BOOST_LEAF_S(S) (sizeof(char[1 + detail::check_suffix(BOOST_LEAF_PRETTY_FUNCTION, S)]) - 1)
+        // clang/gcc style:
+        int const s01 = BOOST_LEAF_S("]");
+        // msvc style:
+        int const s02 = BOOST_LEAF_S(">(void)");
+#undef BOOST_LEAF_S
+
+        char static_assert_unrecognized_pretty_function_format_please_file_github_issue[sizeof(
+            char[
+                (s01 && (1 == (!!p01 + !!p02 + !!p03 + !!p04 + !!p05 + !!p06 + !!p07 + !!p08 + !!p09 + !!p10 + !!p11 + !!p12)))
+                ||
+                (s02 && (1 == (!!p13 + !!p14 + !!p15 + !!p16 + !!p17 + !!p18 + !!p19 + !!p20 + !!p21)))
+                ||
+                (s02 && (1 == (!!p22 + !!p23 + !!p24)))
+            ]
+        ) * 2 - 1];
+        (void) static_assert_unrecognized_pretty_function_format_please_file_github_issue;
+
+        if( int const p = sizeof(char[1 + !!s01 * (p01 + p02 + p03 + p04 + p05 + p06 + p07 + p08 + p09 + p10 + p11 + p12)]) - 1 )
+            return { BOOST_LEAF_PRETTY_FUNCTION + p, s01 - p };
+
+        if( int const p = sizeof(char[1 + !!s02 * (p13 + p14 + p15 + p16 + p17 + p18 + p19 + p20 + p21)]) - 1 )
+            return { BOOST_LEAF_PRETTY_FUNCTION + p, s02 - p };
+
+        int const p = sizeof(char[1 + !!s02 * (p22 + p23 + p24)]) - 1; // p is not zero, we've static asserted the hell out of it
+        return { BOOST_LEAF_PRETTY_FUNCTION + p, s02 - p };
     }
+}
 
-#endif
+using parsed = n::r;
+
+template <class T>
+parsed parse()
+{
+    return n::p<T>();
 }
 
 } }
 
-#else
+////////////////////////////////////////
 
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+namespace detail
 {
-    inline char const * demangle( char const * name )
+    template <class CharT, class Traits>
+    std::ostream & demangle_and_print(std::basic_ostream<CharT, Traits> & os, char const * mangled_name)
     {
-        return name;
+        BOOST_LEAF_ASSERT(mangled_name);
+#if defined(BOOST_LEAF_CFG_DIAGNOSTICS) && defined(BOOST_LEAF_HAS_CXXABI_H)
+        struct raii
+        {
+            char * demangled_name;
+            raii(char const * mangled_name) noexcept 
+            {
+                int status = 0;
+                demangled_name = abi::__cxa_demangle(mangled_name, nullptr, nullptr, &status);
+            }
+            ~raii() noexcept
+            {
+                std::free(demangled_name);
+            }
+        } d(mangled_name);
+        if( d.demangled_name )
+            return os << d.demangled_name;
+#endif
+        return os << mangled_name;
     }
 }
 
 } }
 
-#endif
-
-#ifdef BOOST_LEAF_HAS_CXXABI_H
-#   undef BOOST_LEAF_HAS_CXXABI_H
-#endif
-
-#endif
+#endif // BOOST_LEAF_DETAIL_DEMANGLE_HPP_INCLUDED
diff --git a/include/boost/leaf/detail/function_traits.hpp b/include/boost/leaf/detail/function_traits.hpp
index 3ef58ced..bfc336ce 100644
--- a/include/boost/leaf/detail/function_traits.hpp
+++ b/include/boost/leaf/detail/function_traits.hpp
@@ -1,8 +1,7 @@
 #ifndef BOOST_LEAF_DETAIL_FUNCTION_TRAITS_HPP_INCLUDED
 #define BOOST_LEAF_DETAIL_FUNCTION_TRAITS_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -12,7 +11,7 @@
 
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+namespace detail
 {
     template <class T> struct remove_noexcept { using type = T; };
     template <class R, class... A>  struct remove_noexcept<R(*)(A...) noexcept> { using type = R(*)(A...); };
@@ -97,4 +96,4 @@ namespace leaf_detail
 
 } }
 
-#endif
+#endif // BOOST_LEAF_DETAIL_FUNCTION_TRAITS_HPP_INCLUDED
diff --git a/include/boost/leaf/detail/mp11.hpp b/include/boost/leaf/detail/mp11.hpp
index 6a1aee32..10e8e11f 100644
--- a/include/boost/leaf/detail/mp11.hpp
+++ b/include/boost/leaf/detail/mp11.hpp
@@ -2,7 +2,7 @@
 #define BOOST_LEAF_DETAIL_MP11_HPP_INCLUDED
 
 //  Copyright 2015-2017 Peter Dimov.
-//  Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
+//  Copyright 2018-2024 Emil Dotchevski and Reverge Studios, Inc.
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //
@@ -300,4 +300,4 @@ template<template<class...> class F, class... T> using mp_valid = typename detai
 
 } } }
 
-#endif
+#endif // BOOST_LEAF_DETAIL_MP11_HPP_INCLUDED
diff --git a/include/boost/leaf/detail/optional.hpp b/include/boost/leaf/detail/optional.hpp
index 494ecedc..60c77835 100644
--- a/include/boost/leaf/detail/optional.hpp
+++ b/include/boost/leaf/detail/optional.hpp
@@ -1,8 +1,7 @@
 #ifndef BOOST_LEAF_DETAIL_OPTIONAL_HPP_INCLUDED
 #define BOOST_LEAF_DETAIL_OPTIONAL_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -13,7 +12,7 @@
 
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+namespace detail
 {
     template <class T>
     class optional
@@ -66,7 +65,7 @@ namespace leaf_detail
             reset();
             if( int key = x.key() )
             {
-                put(key, x.value_);
+                load(key, x.value_);
                 key_ = key;
             }
             return *this;
@@ -77,7 +76,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;
@@ -90,7 +89,7 @@ namespace leaf_detail
 
         BOOST_LEAF_CONSTEXPR bool empty() const noexcept
         {
-            return key_==0;
+            return key_ == 0;
         }
 
         BOOST_LEAF_CONSTEXPR int key() const noexcept
@@ -107,7 +106,16 @@ namespace leaf_detail
             }
         }
 
-        BOOST_LEAF_CONSTEXPR T & put( int key, T const & v )
+        BOOST_LEAF_CONSTEXPR T & load( int key )
+        {
+            BOOST_LEAF_ASSERT(key);
+            reset();
+            (void) new(&value_) T;
+            key_=key;
+            return value_;
+        }
+
+        BOOST_LEAF_CONSTEXPR T & load( int key, T const & v )
         {
             BOOST_LEAF_ASSERT(key);
             reset();
@@ -116,7 +124,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();
@@ -125,47 +133,69 @@ namespace leaf_detail
             return value_;
         }
 
+        BOOST_LEAF_CONSTEXPR T const * has_value_any_key() const noexcept
+        {
+            return key_ ? &value_ : nullptr;
+        }
+
+        BOOST_LEAF_CONSTEXPR T * has_value_any_key() noexcept
+        {
+            return key_ ? &value_ : nullptr;
+        }
+
         BOOST_LEAF_CONSTEXPR T const * has_value(int key) const noexcept
         {
             BOOST_LEAF_ASSERT(key);
-            return key_==key ? &value_ : nullptr;
+            return key_ == key ? &value_ : nullptr;
         }
 
         BOOST_LEAF_CONSTEXPR T * has_value(int key) noexcept
         {
             BOOST_LEAF_ASSERT(key);
-            return key_==key ? &value_ : nullptr;
+            return key_ == key ? &value_ : nullptr;
         }
 
         BOOST_LEAF_CONSTEXPR T const & value(int key) const & noexcept
         {
             BOOST_LEAF_ASSERT(has_value(key) != 0);
+            (void) key;
             return value_;
         }
 
         BOOST_LEAF_CONSTEXPR T & value(int key) & noexcept
         {
             BOOST_LEAF_ASSERT(has_value(key) != 0);
+            (void) key;
             return value_;
         }
 
         BOOST_LEAF_CONSTEXPR T const && value(int key) const && noexcept
         {
             BOOST_LEAF_ASSERT(has_value(key) != 0);
+            (void) key;
             return value_;
         }
 
         BOOST_LEAF_CONSTEXPR T value(int key) && noexcept
         {
             BOOST_LEAF_ASSERT(has_value(key) != 0);
+            (void) key;
             T tmp(std::move(value_));
             reset();
             return tmp;
         }
+
+        BOOST_LEAF_CONSTEXPR T & value_or_default(int key) noexcept
+        {
+            if( T * v = has_value(key) )
+                return *v;
+            else
+                return load(key);
+        }
     };
 
 }
 
 } }
 
-#endif
+#endif // BOOST_LEAF_DETAIL_OPTIONAL_HPP_INCLUDED
diff --git a/include/boost/leaf/detail/print.hpp b/include/boost/leaf/detail/print.hpp
index d37c75f6..2189fb29 100644
--- a/include/boost/leaf/detail/print.hpp
+++ b/include/boost/leaf/detail/print.hpp
@@ -1,16 +1,13 @@
 #ifndef BOOST_LEAF_DETAIL_PRINT_HPP_INCLUDED
 #define BOOST_LEAF_DETAIL_PRINT_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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/detail/demangle.hpp>
 
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-
 #include <type_traits>
 #include <exception>
 #include <iosfwd>
@@ -18,7 +15,12 @@
 
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+template <class E>
+struct show_in_diagnostics: std::true_type
+{
+};
+
+namespace detail
 {
     template <class T, class E = void>
     struct is_printable: std::false_type
@@ -26,7 +28,7 @@ namespace leaf_detail
     };
 
     template <class T>
-    struct is_printable<T, decltype(std::declval<std::ostream&>()<<std::declval<T const &>(), void())>: std::true_type
+    struct is_printable<T, decltype(std::declval<std::ostream&>()<<std::declval<T const &>(), void())>: show_in_diagnostics<T>
     {
     };
 
@@ -38,94 +40,123 @@ namespace leaf_detail
     };
 
     template <class T>
-    struct has_printable_member_value<T, decltype(std::declval<std::ostream&>()<<std::declval<T const &>().value, void())>: std::true_type
+    struct has_printable_member_value<T, decltype(std::declval<std::ostream&>()<<std::declval<T const &>().value, void())>: show_in_diagnostics<T>
     {
     };
 
     ////////////////////////////////////////
 
+    template <class T, class CharT, class Traits>
+    void print_name(std::basic_ostream<CharT, Traits> & os, char const * & prefix, char const * delimiter)
+    {
+        static_assert(show_in_diagnostics<T>::value, "show_in_diagnostics violation");
+        BOOST_LEAF_ASSERT(delimiter);
+        char const * p = prefix;
+        prefix = nullptr;
+        os << (p ? p : delimiter) << parse<T>();
+    }
+
+    template <class T, class PrintableInfo, class CharT, class Traits>
+    bool print_impl(std::basic_ostream<CharT, Traits> & os, char const * & prefix, char const * delimiter, char const * mid, PrintableInfo const & x)
+    {
+        print_name<T>(os, prefix, delimiter);
+        if( mid )
+            os << mid << x;
+        return true;
+    }
+
+    template <class T, class PrintableInfo, class CharT, class Traits>
+    bool print_impl(std::basic_ostream<CharT, Traits> & os, char const * & prefix, char const * delimiter, char const * mid, PrintableInfo const * x)
+    {
+        print_name<T>(os, prefix, delimiter);
+        if( mid )
+        {
+            os << mid;
+            if( x )
+                os << x;
+            else
+                os << "<nullptr>";
+        }
+        return true;
+    }
+
+    ////////////////////////////////////////
+
     template <
         class Wrapper,
+        bool ShowInDiagnostics = show_in_diagnostics<Wrapper>::value,
         bool WrapperPrintable = is_printable<Wrapper>::value,
         bool ValuePrintable = has_printable_member_value<Wrapper>::value,
         bool IsException = std::is_base_of<std::exception,Wrapper>::value,
         bool IsEnum = std::is_enum<Wrapper>::value>
     struct diagnostic;
 
-    template <class Wrapper, bool ValuePrintable, bool IsException, bool IsEnum>
-    struct diagnostic<Wrapper, true, ValuePrintable, IsException, IsEnum>
+    template <class Wrapper, bool WrapperPrintable, bool ValuePrintable, bool IsException, bool IsEnum>
+    struct diagnostic<Wrapper, false, WrapperPrintable, ValuePrintable, IsException, IsEnum>
     {
-        static constexpr bool is_invisible = false;
-
         template <class CharT, class Traits>
-        static void print( std::basic_ostream<CharT, Traits> & os, Wrapper const & x )
+        static bool print(std::basic_ostream<CharT, Traits> &, char const * &, char const *, Wrapper const & x) noexcept
         {
-            os << x;
+            return false;
         }
     };
 
-    template <class Wrapper, bool IsException, bool IsEnum>
-    struct diagnostic<Wrapper, false, true, IsException, IsEnum>
+    template <class Wrapper, bool ValuePrintable, bool IsEnum>
+    struct diagnostic<Wrapper, true, true, ValuePrintable, false, IsEnum>
     {
-        static constexpr bool is_invisible = false;
-
         template <class CharT, class Traits>
-        static void print( std::basic_ostream<CharT, Traits> & os, Wrapper const & x )
+        static bool print(std::basic_ostream<CharT, Traits> & os, char const * & prefix, char const * delimiter, Wrapper const & x)
         {
-            os << type<Wrapper>() << ": " << x.value;
+            return print_impl<Wrapper>(os, prefix, delimiter, ": ", x);
         }
     };
 
-    template <class Wrapper, bool IsEnum>
-    struct diagnostic<Wrapper, false, false, true, IsEnum>
+    template <class Wrapper>
+    struct diagnostic<Wrapper, true, false, true, false, false>
     {
-        static constexpr bool is_invisible = false;
-
         template <class CharT, class Traits>
-        static void print( std::basic_ostream<CharT, Traits> & os, Wrapper const & ex )
+        static bool print(std::basic_ostream<CharT, Traits> & os, char const * & prefix, char const * delimiter, Wrapper const & x)
         {
-            os << type<Wrapper>() << ": std::exception::what(): " << ex.what();
+            return print_impl<Wrapper>(os, prefix, delimiter, ": ", x.value);
         }
     };
 
-    template <class Wrapper>
-    struct diagnostic<Wrapper, false, false, false, false>
+    template <class Exception, bool WrapperPrintable, bool ValuePrintable>
+    struct diagnostic<Exception, true, WrapperPrintable, ValuePrintable, true, false>
     {
-        static constexpr bool is_invisible = false;
-
         template <class CharT, class Traits>
-        static void print( std::basic_ostream<CharT, Traits> & os, Wrapper const & )
+        static bool print(std::basic_ostream<CharT, Traits> & os, char const * & prefix, char const * delimiter, Exception const & ex)
         {
-            os << type<Wrapper>() << ": {Non-Printable}";
+            if( print_impl<Exception>(os, prefix, delimiter, ": \"", static_cast<std::exception const &>(ex).what()) )
+            {
+                os << '"';
+                return true;
+            }
+            return false;
         }
     };
 
     template <class Wrapper>
-    struct diagnostic<Wrapper, false, false, false, true>
+    struct diagnostic<Wrapper, true, false, false, false, false>
     {
-        static constexpr bool is_invisible = false;
-
         template <class CharT, class Traits>
-        static void print( std::basic_ostream<CharT, Traits> & os, Wrapper const & w )
+        static bool print(std::basic_ostream<CharT, Traits> & os, char const * & prefix, char const * delimiter, Wrapper const &)
         {
-            os << type<Wrapper>() << ": " << static_cast<typename std::underlying_type<Wrapper>::type>(w);
+            return print_impl<Wrapper>(os, prefix, delimiter, nullptr, 0);
         }
     };
 
-    template <>
-    struct diagnostic<std::exception_ptr, false, false, false>
+    template <class Enum>
+    struct diagnostic<Enum, true, false, false, false, true>
     {
-        static constexpr bool is_invisible = true;
-
         template <class CharT, class Traits>
-        BOOST_LEAF_CONSTEXPR static void print( std::basic_ostream<CharT, Traits> &, std::exception_ptr const & )
+        static bool print(std::basic_ostream<CharT, Traits> & os, char const * & prefix, char const * delimiter, Enum const & enum_)
         {
+            return print_impl<Enum>(os, prefix, delimiter, ": ", static_cast<typename std::underlying_type<Enum>::type>(enum_));
         }
     };
 }
 
 } }
 
-#endif
-
-#endif
+#endif // BOOST_LEAF_DETAIL_PRINT_HPP_INCLUDED
diff --git a/include/boost/leaf/diagnostics.hpp b/include/boost/leaf/diagnostics.hpp
new file mode 100644
index 00000000..5ab490f5
--- /dev/null
+++ b/include/boost/leaf/diagnostics.hpp
@@ -0,0 +1,293 @@
+#ifndef BOOST_LEAF_DIAGNOSTICS_HPP_INCLUDED
+#define BOOST_LEAF_DIAGNOSTICS_HPP_INCLUDED
+
+// Copyright 2018-2024 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/context.hpp>
+#include <boost/leaf/handle_errors.hpp>
+
+namespace boost { namespace leaf {
+
+#if BOOST_LEAF_CFG_DIAGNOSTICS
+
+class diagnostic_info: public error_info
+{
+    void const * tup_;
+    void (*print_tuple_contents_)(std::ostream &, void const * tup, error_id to_print, char const * & prefix);
+
+protected:
+
+    diagnostic_info( diagnostic_info const & ) noexcept = default;
+
+    template <class Tup>
+    BOOST_LEAF_CONSTEXPR diagnostic_info( error_info const & ei, Tup const & tup ) noexcept:
+        error_info(ei),
+        tup_(&tup),
+        print_tuple_contents_(&detail::print_tuple_contents<Tup>)
+    {
+    }
+
+    template <class CharT, class Traits>
+    void print_diagnostic_info(std::basic_ostream<CharT, Traits> & os) const
+    {
+        print_error_info(os);
+        char const * prefix = exception() ? nullptr : "\nCaught:" BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER;
+        print_tuple_contents_(os, tup_, error(), prefix);
+    }
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, diagnostic_info const & x )
+    {
+        x.print_diagnostic_info(os);
+        return os << '\n';
+    }
+};
+
+namespace detail
+{
+    struct diagnostic_info_: diagnostic_info
+    {
+        template <class 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_source_location>
+    {
+        template <class Tup>
+        BOOST_LEAF_CONSTEXPR static diagnostic_info_ get( Tup const & tup, error_info const & ei ) noexcept
+        {
+            return diagnostic_info_(ei, tup);
+        }
+    };
+}
+
+#else
+
+class diagnostic_info: public error_info
+{
+protected:
+
+    diagnostic_info( diagnostic_info const & ) noexcept = default;
+
+    BOOST_LEAF_CONSTEXPR diagnostic_info( error_info const & ei ) noexcept:
+        error_info(ei)
+    {
+    }
+
+    template <class CharT, class Traits>
+    void print_diagnostic_info( std::basic_ostream<CharT, Traits> & os ) const
+    {
+        print_error_info(os);
+        os << "\nboost::leaf::diagnostic_info N/A due to BOOST_LEAF_CFG_DIAGNOSTICS=0";
+    }
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, diagnostic_info const & x )
+    {
+        x.print_diagnostic_info(os);
+        return os << "\n";
+    }
+};
+
+namespace detail
+{
+    struct diagnostic_info_: diagnostic_info
+    {
+        BOOST_LEAF_CONSTEXPR diagnostic_info_( error_info const & ei ) noexcept:
+            diagnostic_info(ei)
+        {
+        }
+    };
+
+    template <>
+    struct handler_argument_traits<diagnostic_info const &>: handler_argument_always_available<e_source_location>
+    {
+        template <class Tup>
+        BOOST_LEAF_CONSTEXPR static diagnostic_info_ get( Tup const &, error_info const & ei ) noexcept
+        {
+            return diagnostic_info_(ei);
+        }
+    };
+}
+
+#endif
+
+////////////////////////////////////////
+
+#if BOOST_LEAF_CFG_DIAGNOSTICS
+
+#if BOOST_LEAF_CFG_CAPTURE
+
+class diagnostic_details: public diagnostic_info
+{
+    detail::dynamic_allocator const * const da_;
+
+protected:
+
+    diagnostic_details( diagnostic_details const & ) noexcept = default;
+
+    template <class Tup>
+    BOOST_LEAF_CONSTEXPR diagnostic_details( error_info const & ei, Tup const & tup, detail::dynamic_allocator const * da ) noexcept:
+        diagnostic_info(ei, tup),
+        da_(da)
+    {
+    }
+
+    template <class CharT, class Traits>
+    void print_diagnostic_details( std::basic_ostream<CharT, Traits> & os) const
+    {
+        print_diagnostic_info(os);
+        if( da_ )
+        {
+            char const * prefix = "\nDiagnostic details:" BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER;
+            da_->print(os, error(), prefix);
+        }
+    }
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, diagnostic_details const & x )
+    {
+        x.print_diagnostic_details(os);
+        return os << '\n';
+    }
+};
+
+namespace detail
+{
+    struct diagnostic_details_: diagnostic_details
+    {
+        template <class Tup>
+        BOOST_LEAF_CONSTEXPR diagnostic_details_( error_info const & ei, Tup const & tup, dynamic_allocator const * da ) noexcept:
+            diagnostic_details(ei, tup, da)
+        {
+        }
+    };
+
+    template <>
+    struct handler_argument_traits<diagnostic_details const &>: handler_argument_always_available<e_source_location, dynamic_allocator>
+    {
+        template <class Tup>
+        BOOST_LEAF_CONSTEXPR static diagnostic_details_ get( Tup const & tup, error_info const & ei ) noexcept
+        {
+            slot<dynamic_allocator> const * da = find_in_tuple<slot<dynamic_allocator>>(tup);
+            return diagnostic_details_(ei, tup, da ? da->has_value_any_key() : nullptr );
+        }
+    };
+}
+
+#else
+
+class diagnostic_details: public diagnostic_info
+{
+protected:
+
+    diagnostic_details( diagnostic_details const & ) noexcept = default;
+
+    template <class Tup>
+    BOOST_LEAF_CONSTEXPR diagnostic_details( error_info const & ei, Tup const & tup ) noexcept:
+        diagnostic_info(ei, tup)
+    {
+    }
+
+    template <class CharT, class Traits>
+    void print_diagnostic_details( std::basic_ostream<CharT, Traits> & os ) const
+    {
+        print_diagnostic_info(os);
+        os << "\nboost::leaf::diagnostic_details N/A due to BOOST_LEAF_CFG_CAPTURE=0";
+    }
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, diagnostic_details const & x )
+    {
+        x.print_diagnostic_details(os);
+        return os << "\n";
+    }
+};
+
+namespace detail
+{
+    struct diagnostic_details_: diagnostic_details
+    {
+        template <class Tup>
+        BOOST_LEAF_CONSTEXPR diagnostic_details_( error_info const & ei, Tup const & tup ) noexcept:
+            diagnostic_details(ei, tup)
+        {
+        }
+    };
+
+    template <>
+    struct handler_argument_traits<diagnostic_details const &>: handler_argument_always_available<e_source_location>
+    {
+        template <class Tup>
+        BOOST_LEAF_CONSTEXPR static diagnostic_details_ get( Tup const & tup, error_info const & ei ) noexcept
+        {
+            return diagnostic_details_(ei, tup);
+        }
+    };
+}
+
+#endif
+
+#else
+
+class diagnostic_details: public diagnostic_info
+{
+protected:
+
+    diagnostic_details( diagnostic_details const & ) noexcept = default;
+
+    BOOST_LEAF_CONSTEXPR diagnostic_details( error_info const & ei ) noexcept:
+        diagnostic_info(ei)
+    {
+    }
+
+    template <class CharT, class Traits>
+    void print_diagnostic_details( std::basic_ostream<CharT, Traits> & os ) const
+    {
+        print_error_info(os);
+        os << "\nboost::leaf::diagnostic_details N/A due to BOOST_LEAF_CFG_DIAGNOSTICS=0";
+    }
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, diagnostic_details const & x )
+    {
+        x.print_diagnostic_details(os);
+        return os << "\n";
+    }
+};
+
+namespace detail
+{
+    struct diagnostic_details_: diagnostic_details
+    {
+        BOOST_LEAF_CONSTEXPR diagnostic_details_( error_info const & ei ) noexcept:
+            diagnostic_details(ei)
+        {
+        }
+    };
+
+    template <>
+    struct handler_argument_traits<diagnostic_details const &>: handler_argument_always_available<e_source_location>
+    {
+        template <class Tup>
+        BOOST_LEAF_CONSTEXPR static diagnostic_details_ get( Tup const &, error_info const & ei ) noexcept
+        {
+            return diagnostic_details_(ei);
+        }
+    };
+}
+
+#endif
+
+using verbose_diagnostic_info = diagnostic_details;
+
+} }
+
+#endif // BOOST_LEAF_DIAGNOSTICS_HPP_INCLUDED
diff --git a/include/boost/leaf/error.hpp b/include/boost/leaf/error.hpp
index 179b9068..bac3f50c 100644
--- a/include/boost/leaf/error.hpp
+++ b/include/boost/leaf/error.hpp
@@ -1,34 +1,23 @@
 #ifndef BOOST_LEAF_ERROR_HPP_INCLUDED
 #define BOOST_LEAF_ERROR_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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/detail/optional.hpp>
-#include <boost/leaf/detail/demangle.hpp>
 #include <boost/leaf/detail/function_traits.hpp>
-#include <boost/leaf/detail/print.hpp>
-
-#include <type_traits>
-#include <iosfwd>
+#include <boost/leaf/detail/capture_list.hpp>
 
 #if BOOST_LEAF_CFG_DIAGNOSTICS
-#   include <sstream>
-#   include <string>
-#   include <set>
+#   include <ostream>
 #endif
 
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 #   include <system_error>
 #endif
 
-#if BOOST_LEAF_CFG_CAPTURE
-#   include <memory>
-#endif
-
 #define BOOST_LEAF_TOKEN_PASTE(x, y) x ## y
 #define BOOST_LEAF_TOKEN_PASTE2(x, y) BOOST_LEAF_TOKEN_PASTE(x, y)
 #define BOOST_LEAF_TMP BOOST_LEAF_TOKEN_PASTE2(boost_leaf_tmp_, __LINE__)
@@ -69,442 +58,560 @@
 
 #endif
 
-#define BOOST_LEAF_NEW_ERROR ::boost::leaf::leaf_detail::inject_loc{__FILE__,__LINE__,__FUNCTION__}+::boost::leaf::new_error
+#define BOOST_LEAF_NEW_ERROR ::boost::leaf::detail::inject_loc{__FILE__,__LINE__,__FUNCTION__}+::boost::leaf::new_error
 
 namespace boost { namespace leaf {
 
-class error_id;
-
-namespace leaf_detail
+struct BOOST_LEAF_SYMBOL_VISIBLE e_source_location
 {
-    struct BOOST_LEAF_SYMBOL_VISIBLE tls_tag_unexpected_enabled_counter;
-    struct BOOST_LEAF_SYMBOL_VISIBLE tls_tag_id_factory_current_id;
+    char const * file;
+    int line;
+    char const * function;
 
-    struct inject_loc
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<(std::basic_ostream<CharT, Traits> & os, e_source_location const & x)
     {
-        char const * const file;
-        int const line;
-        char const * const fn;
-
-        template <class T>
-        friend T operator+( inject_loc loc, T && x ) noexcept
-        {
-            x.load_source_location_(loc.file, loc.line, loc.fn);
-            return std::move(x);
-        }
-    };
-}
-
-} }
-
-////////////////////////////////////////
-
-#ifdef BOOST_LEAF_NO_EXCEPTIONS
-
-namespace boost
-{
-BOOST_LEAF_NORETURN void throw_exception( std::exception const & ); // user defined
-}
-
-namespace boost { namespace leaf {
+        return os << x.file << '(' << x.line << ") in function " << x.function;
+    }
+};
 
-template <class T>
-BOOST_LEAF_NORETURN void throw_exception( T const & e )
+template <>
+struct show_in_diagnostics<e_source_location>: std::false_type
 {
-    ::boost::throw_exception(e);
-}
-
-} }
+};
 
-#else
+////////////////////////////////////////
 
-namespace boost { namespace leaf {
+class BOOST_LEAF_SYMBOL_VISIBLE error_id;
 
-template <class T>
-BOOST_LEAF_NORETURN void throw_exception( T const & e )
+namespace detail
 {
-    throw e;
-}
-
-} }
-
+    class BOOST_LEAF_SYMBOL_VISIBLE exception_base
+    {
+    public:
+        virtual error_id get_error_id() const noexcept = 0;
+#if BOOST_LEAF_CFG_DIAGNOSTICS && !defined(BOOST_LEAF_NO_EXCEPTIONS)
+        virtual void print_type_name(std::ostream &) const = 0;
 #endif
+    protected:
+        exception_base() noexcept { }
+        ~exception_base() noexcept { }
+    };
+}
 
 ////////////////////////////////////////
 
-namespace boost { namespace leaf {
-
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-
-namespace leaf_detail
+namespace detail
 {
-    class BOOST_LEAF_SYMBOL_VISIBLE e_unexpected_count
+    template <class E>
+    class BOOST_LEAF_SYMBOL_VISIBLE slot:
+        optional<E>
     {
-    public:
+        slot( slot const & ) = delete;
+        slot & operator=( slot const & ) = delete;
 
-        char const * (*first_type)();
-        int count;
+        using impl = optional<E>;
+        slot<E> * prev_;
+
+    public:
 
-        BOOST_LEAF_CONSTEXPR explicit e_unexpected_count(char const * (*first_type)()) noexcept:
-            first_type(first_type),
-            count(1)
+        BOOST_LEAF_CONSTEXPR slot() noexcept:
+            prev_(nullptr)
         {
         }
 
-        template <class CharT, class Traits>
-        void print( std::basic_ostream<CharT, Traits> & os ) const
+        BOOST_LEAF_CONSTEXPR slot( slot && x ) noexcept:
+            optional<E>(std::move(x)),
+            prev_(nullptr)
         {
-            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();
+            BOOST_LEAF_ASSERT(x.prev_ == nullptr);
         }
-    };
 
-    template <>
-    struct diagnostic<e_unexpected_count, 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_count const &) noexcept { }
-    };
-
-    class BOOST_LEAF_SYMBOL_VISIBLE e_unexpected_info
-    {
-        std::string s_;
-        std::set<char const *(*)()> already_;
-
-    public:
-
-        e_unexpected_info() noexcept
+        ~slot() noexcept
         {
+            BOOST_LEAF_ASSERT(tls::read_ptr<slot<E>>() != this);
         }
 
-        template <class E>
-        void add(E && e)
+        void activate() noexcept
         {
-            if( !diagnostic<E>::is_invisible && already_.insert(&type<E>).second  )
-            {
-                std::stringstream s;
-                diagnostic<E>::print(s,e);
-                (s << '\n').flush();
-                s_ += s.str();
-            }
+            prev_ = tls::read_ptr<slot<E>>();
+            tls::write_ptr<slot<E>>(this);
         }
 
-        template <class CharT, class Traits>
-        void print( std::basic_ostream<CharT, Traits> & os ) const
+        void deactivate() const noexcept
         {
-            os << "Unhandled error objects:\n" << s_;
+            tls::write_ptr<slot<E>>(prev_);
         }
-    };
 
-    template <>
-    struct diagnostic<e_unexpected_info, false, false>
-    {
-        static constexpr bool is_invisible = true;
+        void unload( int err_id ) noexcept(!BOOST_LEAF_CFG_CAPTURE);
 
-        template <class CharT, class Traits>
-        BOOST_LEAF_CONSTEXPR static void print( std::basic_ostream<CharT, Traits> &, e_unexpected_info const &) noexcept { }
-    };
+        template <class CharT, class Traits, class ErrorID>
+        void print(std::basic_ostream<CharT, Traits> & os, ErrorID to_print, char const * & prefix) const
+        {
+            if( int k = this->key() )
+            {
+                if( to_print && to_print.value() != k )
+                    return;
+                if( diagnostic<E>::print(os, prefix, BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER, value(k)) && !to_print )
+                    os << '(' << k/4 << ')';
+            }
+        }
 
+        using impl::load;
+        using impl::has_value;
+        using impl::has_value_any_key;
+        using impl::value;
+        using impl::value_or_default;
+    };
 }
 
-#endif
-
-} }
-
 ////////////////////////////////////////
 
-namespace boost { namespace leaf {
+#if BOOST_LEAF_CFG_CAPTURE
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_source_location
+namespace detail
 {
-    char const * file;
-    int line;
-    char const * function;
-
-    template <class CharT, class Traits>
-    friend std::basic_ostream<CharT, Traits> & operator<<( std::basic_ostream<CharT, Traits> & os, e_source_location const & x )
+    class BOOST_LEAF_SYMBOL_VISIBLE dynamic_allocator:
+        capture_list
     {
-        return os << leaf::type<e_source_location>() << ": " << x.file << '(' << x.line << ") in function " << x.function;
-    }
-};
+        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;
+        };
 
-namespace leaf_detail
-{
-    template <class E>
-    class BOOST_LEAF_SYMBOL_VISIBLE slot:
-        optional<E>
-    {
-        slot( slot const & ) = delete;
-        slot & operator=( slot const & ) = delete;
+        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, error_id const & to_print, char const * & prefix) const final override
+            {
+                impl::print(os, to_print, prefix);
+            }
+#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));
+            }
+        };
 
-        using impl = optional<E>;
-        slot<E> * prev_;
+#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 &, error_id const &, char const * &) const final override
+            {
+            }
+#endif
+            std::exception_ptr const ex_;
+        public:
+            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
+
+        node * * last_;
 
     public:
 
-        BOOST_LEAF_CONSTEXPR slot() noexcept:
-            prev_(nullptr)
+        dynamic_allocator() noexcept:
+            capture_list(nullptr),
+            last_(&first_)
         {
+            BOOST_LEAF_ASSERT(first_ == nullptr);
         }
 
-        BOOST_LEAF_CONSTEXPR slot( slot && x ) noexcept:
-            optional<E>(std::move(x)),
-            prev_(nullptr)
+        dynamic_allocator( dynamic_allocator && other ) noexcept:
+            capture_list(std::move(other)),
+            last_(other.last_ == &other.first_? &first_ : other.last_)
         {
-            BOOST_LEAF_ASSERT(x.prev_==nullptr);
+            BOOST_LEAF_ASSERT(last_ != nullptr);
+            BOOST_LEAF_ASSERT(*last_ == nullptr);
+            BOOST_LEAF_ASSERT(other.first_ == nullptr);
+            other.last_ = &other.first_;
         }
 
-        BOOST_LEAF_CONSTEXPR void activate() noexcept
+        template <class E>
+        typename std::decay<E>::type & dynamic_load(int err_id, E && e)
         {
-            prev_ = tls::read_ptr<slot<E>>();
-            tls::write_ptr<slot<E>>(this);
+            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();
+            return csn->value(err_id);
         }
 
-        BOOST_LEAF_CONSTEXPR void deactivate() noexcept
+        void deactivate() const noexcept
         {
-            tls::write_ptr<slot<E>>(prev_);
+            for_each(
+                []( capture_list::node const & n )
+                {
+                    static_cast<capturing_node const &>(n).deactivate();
+                } );
         }
 
-        BOOST_LEAF_CONSTEXPR void propagate( int err_id ) noexcept;
-
-        template <class CharT, class Traits>
-        void print( std::basic_ostream<CharT, Traits> & os, int key_to_print ) const
+        template <class LeafResult>
+        LeafResult extract_capture_list(int err_id)
         {
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-            if( !diagnostic<E>::is_invisible )
-                if( int k = this->key() )
-                {
-                    if( key_to_print )
-                    {
-                        if( key_to_print!=k )
-                            return;
-                    }
-                    else
-                        os << '[' << k << ']';
-                    diagnostic<E>::print(os, value(k));
-                    (os << '\n').flush();
-                }
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+            if( std::exception_ptr ex = std::current_exception() )
+                (void) new capturing_exception_node(last_, std::move(ex));
 #endif
+            detail::capture_list::node * const f = first_;
+            first_ = nullptr;
+            last_ = &first_;
+            return { err_id, capture_list(f) };
         }
 
-        using impl::put;
-        using impl::has_value;
-        using impl::value;
+        using capture_list::unload;
+        using capture_list::print;
     };
 
-#if BOOST_LEAF_CFG_DIAGNOSTICS
+    template <>
+    inline void slot<dynamic_allocator>::deactivate() const noexcept
+    {
+        if( dynamic_allocator const * c = this->has_value_any_key() )
+            c->deactivate();
+        tls::write_ptr<slot<dynamic_allocator>>(prev_);
+    }
+
+    template <>
+    inline void slot<dynamic_allocator>::unload( int err_id ) noexcept(false)
+    {
+        BOOST_LEAF_ASSERT(err_id);
+        if( dynamic_allocator * da1 = this->has_value_any_key() )
+            da1->unload(err_id);
+    }
 
     template <class E>
-    BOOST_LEAF_CONSTEXPR inline void load_unexpected_count( int err_id ) noexcept
+    inline void dynamic_load_( int err_id, E && e )
     {
-        if( slot<e_unexpected_count> * sl = tls::read_ptr<slot<e_unexpected_count>>() )
+        if( slot<dynamic_allocator> * sl = tls::read_ptr<slot<dynamic_allocator>>() )
         {
-            if( e_unexpected_count * unx = sl->has_value(err_id) )
-                ++unx->count;
+            if( dynamic_allocator * c = sl->has_value_any_key() )
+                c->dynamic_load(err_id, std::forward<E>(e));
             else
-                sl->put(err_id, e_unexpected_count(&type<E>));
+                sl->load(err_id).dynamic_load(err_id, std::forward<E>(e));
         }
     }
 
-    template <class E>
-    BOOST_LEAF_CONSTEXPR inline void load_unexpected_info( int err_id, E && e ) noexcept
+    template <class E, class 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) )
-                unx->add(std::forward<E>(e));
+            if( dynamic_allocator * c = sl->has_value(err_id) )
+                (void) std::forward<F>(f)(c->dynamic_load(err_id, E{}));
             else
-                sl->put(err_id, e_unexpected_info()).add(std::forward<E>(e));
+                (void) std::forward<F>(f)(sl->load(err_id).dynamic_load(err_id, E{}));
         }
     }
 
-    template <class E>
-    BOOST_LEAF_CONSTEXPR inline void load_unexpected( int err_id, E && e  ) noexcept
+    template <bool OnError, class E>
+    inline void dynamic_load( int err_id, E && e  ) noexcept(OnError)
     {
-        load_unexpected_count<E>(err_id);
-        load_unexpected_info(err_id, std::forward<E>(e));
+        if( OnError )
+        {
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+            try
+            {
+#endif
+                dynamic_load_(err_id, std::forward<E>(e));
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+            }
+            catch(...)
+            {
+            }
+#endif
+        }
+        else
+            dynamic_load_(err_id, std::forward<E>(e));
+    }
+
+    template <bool OnError, class E, class F>
+    inline void dynamic_load_accumulate( int err_id, F && f  ) noexcept(OnError)
+    {
+        if( OnError )
+        {
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+            try
+            {
+#endif
+                dynamic_accumulate_<E>(err_id, std::forward<F>(f));
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+            }
+            catch(...)
+            {
+            }
+#endif
+        }
+        else
+            dynamic_accumulate_<E>(err_id, std::forward<F>(f));
     }
+}
+
+template <>
+struct show_in_diagnostics<detail::dynamic_allocator>: std::false_type
+{
+};
 
 #endif
 
+////////////////////////////////////////
+
+namespace detail
+{
     template <class E>
-    BOOST_LEAF_CONSTEXPR inline void slot<E>::propagate( int err_id ) noexcept
+    inline void slot<E>::unload( int err_id ) noexcept(!BOOST_LEAF_CFG_CAPTURE)
     {
-        if( this->key()!=err_id && err_id!=0 )
+        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
-        else
         {
-            int c = tls::read_uint32<tls_tag_unexpected_enabled_counter>();
-            BOOST_LEAF_ASSERT(c>=0);
-            if( c )
-                load_unexpected(err_id, std::move(*this).value(err_id));
+            if( !p->has_value(err_id) )
+                *p = std::move(*this);
         }
+#if BOOST_LEAF_CFG_CAPTURE
+        else
+            dynamic_load<false>(err_id, std::move(*this).value(err_id));
 #endif
     }
 
-    template <class E>
-    BOOST_LEAF_CONSTEXPR inline int load_slot( int err_id, E && e ) noexcept
+    template <bool OnError, class E>
+    BOOST_LEAF_CONSTEXPR inline int load_slot( int err_id, E && e ) noexcept(OnError)
     {
-        static_assert(!std::is_pointer<E>::value, "Error objects of pointer types are not allowed");
-        static_assert(!std::is_same<typename std::decay<E>::type, error_id>::value, "Error objects of type error_id are not allowed");
         using T = typename std::decay<E>::type;
-        BOOST_LEAF_ASSERT((err_id&3)==1);
+        static_assert(!std::is_pointer<E>::value, "Error objects of pointer types are not allowed");
+        static_assert(!std::is_same<T, error_id>::value, "Error objects of type error_id are not allowed");
+        BOOST_LEAF_ASSERT((err_id&3) == 1);
         if( slot<T> * p = tls::read_ptr<slot<T>>() )
-            (void) p->put(err_id, std::forward<E>(e));
-#if BOOST_LEAF_CFG_DIAGNOSTICS
+        {
+            if( !OnError || !p->has_value(err_id) )
+                (void) p->load(err_id, std::forward<E>(e));
+        }
+#if BOOST_LEAF_CFG_CAPTURE
         else
+            dynamic_load<OnError>(err_id, std::forward<E>(e));
+#endif        
+        return 0;
+    }
+
+    template <bool OnError, class F>
+    BOOST_LEAF_CONSTEXPR inline int load_slot_deferred( int err_id, F && f ) noexcept(OnError)
+    {
+        using E = typename function_traits<F>::return_type;
+        using T = typename std::decay<E>::type;
+        static_assert(!std::is_pointer<E>::value, "Error objects of pointer types are not allowed");
+        static_assert(!std::is_same<T, error_id>::value, "Error objects of type error_id are not allowed");
+        BOOST_LEAF_ASSERT((err_id&3) == 1);
+        if( slot<T> * p = tls::read_ptr<slot<T>>() )
         {
-            int c = tls::read_uint32<tls_tag_unexpected_enabled_counter>();
-            BOOST_LEAF_ASSERT(c>=0);
-            if( c )
-                load_unexpected(err_id, std::forward<E>(e));
+            if( !OnError || !p->has_value(err_id) )
+                (void) p->load(err_id, std::forward<F>(f)());
         }
-#endif
+#if BOOST_LEAF_CFG_CAPTURE
+        else
+            dynamic_load<OnError>(err_id, std::forward<F>(f)());
+#endif        
         return 0;
     }
 
-    template <class F>
-    BOOST_LEAF_CONSTEXPR inline int accumulate_slot( int err_id, F && f ) noexcept
+    template <bool OnError, class F>
+    BOOST_LEAF_CONSTEXPR inline int load_slot_accumulate( int err_id, F && f ) noexcept(OnError)
     {
-        static_assert(function_traits<F>::arity==1, "Lambdas passed to accumulate must take a single e-type argument by reference");
+        static_assert(function_traits<F>::arity == 1, "Lambdas passed to accumulate must take a single e-type argument by reference");
         using E = typename std::decay<fn_arg_type<F,0>>::type;
         static_assert(!std::is_pointer<E>::value, "Error objects of pointer types are not allowed");
-        BOOST_LEAF_ASSERT((err_id&3)==1);
+        BOOST_LEAF_ASSERT((err_id&3) == 1);
         if( auto sl = tls::read_ptr<slot<E>>() )
         {
             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_CAPTURE
+        else
+            dynamic_load_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(-3);
-
-    inline int current_id() noexcept
-    {
-        auto id = tls::read_uint32<tls_tag_id_factory_current_id>();
-        BOOST_LEAF_ASSERT(id==0 || (id&3)==1);
-        return id;
-    }
-
-    inline int new_id() noexcept
-    {
-        auto id = id_factory<>::generate_next_id();
-        tls::write_uint32<tls_tag_id_factory_current_id>(id);
-        return id;
-    }
-}
-
-////////////////////////////////////////
-
-namespace leaf_detail
+namespace detail
 {
     template <class T, int Arity = function_traits<T>::arity>
     struct load_item
     {
-        static_assert(Arity==0 || Arity==1, "If a functions is passed to new_error or load, it must take zero or one argument");
+        static_assert(Arity == 0 || Arity == 1, "If a functions is passed to new_error or load, it must take zero or one argument");
     };
 
     template <class E>
     struct load_item<E, -1>
     {
-        BOOST_LEAF_CONSTEXPR static int load( int err_id, E && e ) noexcept
+        BOOST_LEAF_CONSTEXPR static int load_( int err_id, E && e ) noexcept
         {
-            return load_slot(err_id, std::forward<E>(e));
+            return load_slot<false>(err_id, std::forward<E>(e));
         }
     };
 
     template <class F>
     struct load_item<F, 0>
     {
-        BOOST_LEAF_CONSTEXPR static int load( int err_id, F && f ) noexcept
+        BOOST_LEAF_CONSTEXPR static int load_( int err_id, F && f ) noexcept
         {
-            return load_slot(err_id, std::forward<F>(f)());
+            return load_slot_deferred<false>(err_id, std::forward<F>(f));
         }
     };
 
     template <class F>
     struct load_item<F, 1>
     {
-        BOOST_LEAF_CONSTEXPR static int load( int err_id, F && f ) noexcept
+        BOOST_LEAF_CONSTEXPR static int load_( int err_id, F && f ) noexcept
         {
-            return accumulate_slot(err_id, std::forward<F>(f));
+            return load_slot_accumulate<false>(err_id, std::forward<F>(f));
         }
     };
 }
 
 ////////////////////////////////////////
 
+namespace detail
+{
+    struct BOOST_LEAF_SYMBOL_VISIBLE tls_tag_id_factory_current_id;
+
+    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(1);
+
+    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);
+    }
+
+    struct inject_loc
+    {
+        char const * file;
+        int line;
+        char const * fn;
+
+        template <class T>
+        friend T operator+( inject_loc loc, T && x ) noexcept
+        {
+            x.load_source_location_(loc.file, loc.line, loc.fn);
+            return std::move(x);
+        }
+    };
+}
+
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
-namespace leaf_detail
+
+namespace detail
 {
-    class leaf_category final: public std::error_category
+    class leaf_error_category final: public std::error_category
     {
         bool equivalent( int,  std::error_condition const & ) const noexcept final override { return false; }
         bool equivalent( std::error_code const &, int ) const noexcept final override { return false; }
         char const * name() const noexcept final override { return "LEAF error"; }
-        std::string message( int condition ) const final override { return name(); }
+        std::string message( int ) const final override { return name(); }
     public:
-        ~leaf_category() noexcept final override { }
+        ~leaf_error_category() noexcept final override { }
     };
 
     template <class=void>
-    struct get_error_category
+    struct get_leaf_error_category
     {
-        static leaf_category cat;
+        static leaf_error_category cat;
     };
 
     template <class T>
-    leaf_category get_error_category<T>::cat;
+    leaf_error_category get_leaf_error_category<T>::cat;
 
     inline int import_error_code( std::error_code const & ec ) noexcept
     {
         if( int err_id = ec.value() )
         {
-            std::error_category const & cat = get_error_category<>::cat;
-            if( &ec.category()==&cat )
+            std::error_category const & cat = get_leaf_error_category<>::cat;
+            if( &ec.category() == &cat )
             {
-                BOOST_LEAF_ASSERT((err_id&3)==1);
+                BOOST_LEAF_ASSERT((err_id&3) == 1);
                 return (err_id&~3)|1;
             }
             else
             {
                 err_id = new_id();
-                (void) load_slot(err_id, ec);
+                (void) load_slot<false>(err_id, ec);
                 return (err_id&~3)|1;
             }
         }
@@ -515,29 +622,30 @@ namespace leaf_detail
 
 inline bool is_error_id( std::error_code const & ec ) noexcept
 {
-    bool res = (&ec.category() == &leaf_detail::get_error_category<>::cat);
-    BOOST_LEAF_ASSERT(!res || !ec.value() || ((ec.value()&3)==1));
+    bool res = (&ec.category() == &detail::get_leaf_error_category<>::cat);
+    BOOST_LEAF_ASSERT(!res || !ec.value() || ((ec.value()&3) == 1));
     return res;
 }
+
 #endif
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     BOOST_LEAF_CONSTEXPR error_id make_error_id(int) noexcept;
 }
 
 class BOOST_LEAF_SYMBOL_VISIBLE error_id
 {
-    friend error_id BOOST_LEAF_CONSTEXPR leaf_detail::make_error_id(int) noexcept;
+    friend error_id BOOST_LEAF_CONSTEXPR detail::make_error_id(int) noexcept;
 
     int value_;
 
     BOOST_LEAF_CONSTEXPR explicit error_id( int value ) noexcept:
         value_(value)
     {
-        BOOST_LEAF_ASSERT(value_==0 || ((value_&3)==1));
+        BOOST_LEAF_ASSERT(value_ == 0 || ((value_&3) == 1));
     }
 
 public:
@@ -548,21 +656,22 @@ class BOOST_LEAF_SYMBOL_VISIBLE error_id
     }
 
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
-    error_id( std::error_code const & ec ) noexcept:
-        value_(leaf_detail::import_error_code(ec))
+    explicit error_id( std::error_code const & ec ) noexcept:
+        value_(detail::import_error_code(std::error_code(ec)))
     {
-        BOOST_LEAF_ASSERT(!value_ || ((value_&3)==1));
+        BOOST_LEAF_ASSERT(!value_ || ((value_&3) == 1));
     }
 
     template <class Enum>
-    error_id( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type * = 0 ) noexcept:
-        value_(leaf_detail::import_error_code(e))
+    error_id( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, int>::type = 0 ) noexcept:
+        value_(detail::import_error_code(e))
     {
     }
 
-    std::error_code to_error_code() const noexcept
+    template <class T, typename std::enable_if<std::is_constructible<T, std::error_code>::value, int>::type = 0>
+    operator T() const noexcept
     {
-        return std::error_code(value_, leaf_detail::get_error_category<>::cat);
+        return std::error_code(value_, detail::get_leaf_error_category<>::cat);
     }
 #endif
 
@@ -571,12 +680,23 @@ class BOOST_LEAF_SYMBOL_VISIBLE error_id
         return *this;
     }
 
+    template <class Item>
+    BOOST_LEAF_CONSTEXPR error_id load(Item && item) const noexcept
+    {
+        if (int err_id = value())
+        {
+            int const unused[] = { 42, detail::load_item<Item>::load_(err_id, std::forward<Item>(item)) };
+            (void)unused;
+        }
+        return *this;
+    }
+
     template <class... Item>
     BOOST_LEAF_CONSTEXPR error_id load( Item && ... item ) const noexcept
     {
         if( int err_id = value() )
         {
-            int const unused[ ] = { 42, leaf_detail::load_item<Item>::load(err_id, std::forward<Item>(item))... };
+            int const unused[] = { 42, detail::load_item<Item>::load_(err_id, std::forward<Item>(item))... };
             (void) unused;
         }
         return *this;
@@ -584,13 +704,8 @@ class BOOST_LEAF_SYMBOL_VISIBLE error_id
 
     BOOST_LEAF_CONSTEXPR int value() const noexcept
     {
-        if( int v = value_ )
-        {
-            BOOST_LEAF_ASSERT((v&3)==1);
-            return (v&~3)|1;
-        }
-        else
-            return 0;
+        BOOST_LEAF_ASSERT(value_ == 0 || ((value_&3) == 1));
+        return value_;
     }
 
     BOOST_LEAF_CONSTEXPR explicit operator bool() const noexcept
@@ -614,9 +729,9 @@ class BOOST_LEAF_SYMBOL_VISIBLE error_id
     }
 
     template <class CharT, class Traits>
-    friend std::basic_ostream<CharT, Traits> & operator<<( std::basic_ostream<CharT, Traits> & os, error_id x )
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, error_id x )
     {
-        return os << x.value_;
+        return os << (x.value_ / 4);
     }
 
     BOOST_LEAF_CONSTEXPR void load_source_location_( char const * file, int line, char const * function ) const noexcept
@@ -629,103 +744,32 @@ class BOOST_LEAF_SYMBOL_VISIBLE error_id
     }
 };
 
-namespace leaf_detail
+namespace detail
 {
     BOOST_LEAF_CONSTEXPR inline error_id make_error_id( int err_id ) noexcept
     {
-        BOOST_LEAF_ASSERT(err_id==0 || (err_id&3)==1);
+        BOOST_LEAF_ASSERT(err_id == 0 || (err_id&3) == 1);
         return error_id((err_id&~3)|1);
     }
 }
 
 inline error_id new_error() noexcept
 {
-    return leaf_detail::make_error_id(leaf_detail::new_id());
+    return detail::make_error_id(detail::new_id());
 }
 
 template <class... Item>
 inline error_id new_error( Item && ... item ) noexcept
 {
-    return leaf_detail::make_error_id(leaf_detail::new_id()).load(std::forward<Item>(item)...);
+    return detail::make_error_id(detail::new_id()).load(std::forward<Item>(item)...);
 }
 
 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 error_id propagate_captured_errors() noexcept = 0;
-    virtual void activate() noexcept = 0;
-    virtual void deactivate() noexcept = 0;
-    virtual void propagate( error_id ) noexcept = 0;
-    virtual bool is_active() const noexcept = 0;
-    inline virtual void print( std::ostream & ) const { };
-    error_id captured_id_;
-};
-
-#if BOOST_LEAF_CFG_CAPTURE
-using context_ptr = std::shared_ptr<polymorphic_context>;
-#endif
-
-////////////////////////////////////////////
-
-template <class Ctx>
-class context_activator
-{
-    context_activator( context_activator const & ) = delete;
-    context_activator & operator=( context_activator const & ) = delete;
-
-#if !defined(BOOST_LEAF_NO_EXCEPTIONS) && BOOST_LEAF_STD_UNCAUGHT_EXCEPTIONS
-    int const uncaught_exceptions_;
-#endif
-    Ctx * ctx_;
-
-public:
-
-    explicit BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE context_activator(Ctx & ctx) noexcept:
-#if !defined(BOOST_LEAF_NO_EXCEPTIONS) && BOOST_LEAF_STD_UNCAUGHT_EXCEPTIONS
-        uncaught_exceptions_(std::uncaught_exceptions()),
-#endif
-        ctx_(ctx.is_active() ? nullptr : &ctx)
-    {
-        if( ctx_ )
-            ctx_->activate();
-    }
-
-    BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE context_activator( context_activator && x ) noexcept:
-#if !defined(BOOST_LEAF_NO_EXCEPTIONS) && BOOST_LEAF_STD_UNCAUGHT_EXCEPTIONS
-        uncaught_exceptions_(x.uncaught_exceptions_),
-#endif
-        ctx_(x.ctx_)
-    {
-        x.ctx_ = nullptr;
-    }
-
-    BOOST_LEAF_ALWAYS_INLINE ~context_activator() noexcept
-    {
-        if( ctx_ && ctx_->is_active() )
-            ctx_->deactivate();
-    }
-};
-
-template <class Ctx>
-BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE context_activator<Ctx> activate_context(Ctx & ctx) noexcept
-{
-    return context_activator<Ctx>(ctx);
+    return detail::make_error_id(detail::current_id());
 }
 
-////////////////////////////////////////////
+////////////////////////////////////////
 
 template <class R>
 struct is_result_type: std::false_type
@@ -739,4 +783,4 @@ struct is_result_type<R const>: is_result_type<R>
 
 } }
 
-#endif
+#endif // BOOST_LEAF_ERROR_HPP_INCLUDED
diff --git a/include/boost/leaf/exception.hpp b/include/boost/leaf/exception.hpp
index bda4dd77..c0224573 100644
--- a/include/boost/leaf/exception.hpp
+++ b/include/boost/leaf/exception.hpp
@@ -1,26 +1,59 @@
 #ifndef BOOST_LEAF_EXCEPTION_HPP_INCLUDED
 #define BOOST_LEAF_EXCEPTION_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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/error.hpp>
+#include <exception>
+#include <typeinfo>
 
-#ifndef BOOST_LEAF_NO_EXCEPTIONS
+#ifdef BOOST_LEAF_NO_EXCEPTIONS
 
-#include <exception>
+namespace boost
+{
+    [[noreturn]] void throw_exception( std::exception const & ); // user defined
+}
 
-#define BOOST_LEAF_EXCEPTION ::boost::leaf::leaf_detail::inject_loc{__FILE__,__LINE__,__FUNCTION__}+::boost::leaf::exception
-#define BOOST_LEAF_THROW_EXCEPTION ::boost::leaf::leaf_detail::throw_with_loc{__FILE__,__LINE__,__FUNCTION__}+::boost::leaf::exception
+namespace boost { namespace leaf {
+
+namespace detail
+{
+    template <class T>
+    [[noreturn]] void throw_exception_impl( T && e )
+    {
+        ::boost::throw_exception(std::move(e));
+    }
+}
+
+} }
+
+#else
+
+namespace boost { namespace leaf {
+
+namespace detail
+{
+    template <class T>
+    [[noreturn]] void throw_exception_impl( T && e )
+    {
+        throw std::move(e);
+    }
+}
+
+} }
+
+#endif
 
 ////////////////////////////////////////
 
+#define BOOST_LEAF_THROW_EXCEPTION ::boost::leaf::detail::throw_with_loc{__FILE__,__LINE__,__FUNCTION__}+::boost::leaf::detail::make_exception
+
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+namespace detail
 {
     struct throw_with_loc
     {
@@ -29,76 +62,94 @@ namespace leaf_detail
         char const * const fn;
 
         template <class Ex>
-        [[noreturn]] friend void operator+( throw_with_loc loc, Ex const & ex )
+        [[noreturn]] friend void operator+( throw_with_loc loc, Ex && ex )
         {
             ex.load_source_location_(loc.file, loc.line, loc.fn);
-            ::boost::leaf::throw_exception(ex);
+            ::boost::leaf::detail::throw_exception_impl(std::move(ex));
         }
     };
 }
 
-} }
-
 ////////////////////////////////////////
 
-namespace boost { namespace leaf {
-
-namespace leaf_detail
+namespace detail
 {
     inline void enforce_std_exception( std::exception const & ) noexcept { }
 
-    class BOOST_LEAF_SYMBOL_VISIBLE exception_base
-    {
-        std::shared_ptr<void const> auto_id_bump_;
-    public:
-
-        virtual error_id get_error_id() const noexcept = 0;
-
-    protected:
-
-        exception_base():
-            auto_id_bump_(nullptr, [](void const *) { (void) new_id(); })
-        {
-        }
-
-        ~exception_base() noexcept { }
-    };
-
     template <class Ex>
     class BOOST_LEAF_SYMBOL_VISIBLE exception:
         public Ex,
         public exception_base,
         public error_id
     {
+        mutable bool clear_current_error_;
+
+        bool is_current_exception() const noexcept
+        {
+            return tls::read_uint<detail::tls_tag_id_factory_current_id>() == unsigned(error_id::value());
+        }
+
         error_id get_error_id() const noexcept final override
         {
+            clear_current_error_ = false;
             return *this;
         }
 
+#if BOOST_LEAF_CFG_DIAGNOSTICS && !defined(BOOST_LEAF_NO_EXCEPTIONS)
+        void print_type_name(std::ostream & os) const final override
+        {
+            detail::demangle_and_print(os, typeid(Ex).name());
+        }
+#endif
+
     public:
 
-        exception( exception const & ) = default;
-        exception( exception && ) = default;
+        exception( exception const & other ):
+            Ex(other),
+            exception_base(other),
+            error_id(other),
+            clear_current_error_(other.clear_current_error_)
+        {
+            other.clear_current_error_ = false;
+        }
+
+        exception( exception && other ) noexcept:
+            Ex(std::move(other)),
+            exception_base(std::move(other)),
+            error_id(std::move(other)),
+            clear_current_error_(std::move(other.clear_current_error_))
+        {
+            other.clear_current_error_ = false;
+        }
 
-        BOOST_LEAF_CONSTEXPR exception( error_id id, Ex const & ex ) noexcept:
+        exception( error_id id, Ex const & ex ) noexcept:
             Ex(ex),
-            error_id(id)
+            error_id(id),
+            clear_current_error_(true)
         {
             enforce_std_exception(*this);
         }
 
-        BOOST_LEAF_CONSTEXPR exception( error_id id, Ex && ex ) noexcept:
+        exception( error_id id, Ex && ex ) noexcept:
             Ex(std::move(ex)),
-            error_id(id)
+            error_id(id),
+            clear_current_error_(true)
         {
             enforce_std_exception(*this);
         }
 
-        explicit BOOST_LEAF_CONSTEXPR exception( error_id id ) noexcept:
-            error_id(id)
+        explicit exception( error_id id ) noexcept:
+            error_id(id),
+            clear_current_error_(true)
         {
             enforce_std_exception(*this);
         }
+
+        ~exception() noexcept
+        {
+            if( clear_current_error_ && is_current_exception() )
+                tls::write_uint<detail::tls_tag_id_factory_current_id>(0);
+        }
     };
 
     template <class... T>
@@ -112,52 +163,62 @@ namespace leaf_detail
     {
         constexpr static const bool value = std::is_base_of<std::exception,typename std::remove_reference<T>::type>::value || at_least_one_derives_from_std_exception<Rest...>::value;
     };
-}
 
-template <class Ex, class... E>
-inline
-typename std::enable_if<std::is_base_of<std::exception,typename std::remove_reference<Ex>::type>::value, leaf_detail::exception<typename std::remove_reference<Ex>::type>>::type
-exception( error_id err, Ex && ex, E && ... e ) noexcept
-{
-    static_assert(!leaf_detail::at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
-    return leaf_detail::exception<typename std::remove_reference<Ex>::type>( err.load(std::forward<E>(e)...), std::forward<Ex>(ex) );
-}
+    template <class Ex, class... E>
+    inline
+    typename std::enable_if<std::is_base_of<std::exception,typename std::remove_reference<Ex>::type>::value, exception<typename std::remove_reference<Ex>::type>>::type
+    make_exception( error_id err, Ex && ex, E && ... e ) noexcept
+    {
+        static_assert(!at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
+        return exception<typename std::remove_reference<Ex>::type>( err.load(std::forward<E>(e)...), std::forward<Ex>(ex) );
+    }
 
-template <class E1, class... E>
-inline
-typename std::enable_if<!std::is_base_of<std::exception,typename std::remove_reference<E1>::type>::value, leaf_detail::exception<std::exception>>::type
-exception( error_id err, E1 && car, E && ... cdr ) noexcept
-{
-    static_assert(!leaf_detail::at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
-    return leaf_detail::exception<std::exception>( err.load(std::forward<E1>(car), std::forward<E>(cdr)...) );
-}
+    template <class E1, class... E>
+    inline
+    typename std::enable_if<!std::is_base_of<std::exception,typename std::remove_reference<E1>::type>::value, exception<std::exception>>::type
+    make_exception( error_id err, E1 && car, E && ... cdr ) noexcept
+    {
+        static_assert(!at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
+        return exception<std::exception>( err.load(std::forward<E1>(car), std::forward<E>(cdr)...) );
+    }
 
-inline leaf_detail::exception<std::exception> exception( error_id err ) noexcept
-{
-    return leaf_detail::exception<std::exception>(err);
-}
+    inline exception<std::exception> make_exception( error_id err ) noexcept
+    {
+        return exception<std::exception>(err);
+    }
 
-template <class Ex, class... E>
-inline
-typename std::enable_if<std::is_base_of<std::exception,typename std::remove_reference<Ex>::type>::value, leaf_detail::exception<typename std::remove_reference<Ex>::type>>::type
-exception( Ex && ex, E && ... e ) noexcept
-{
-    static_assert(!leaf_detail::at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
-    return leaf_detail::exception<typename std::remove_reference<Ex>::type>( new_error().load(std::forward<E>(e)...), std::forward<Ex>(ex) );
-}
+    template <class Ex, class... E>
+    inline
+    typename std::enable_if<std::is_base_of<std::exception,typename std::remove_reference<Ex>::type>::value, exception<typename std::remove_reference<Ex>::type>>::type
+    make_exception( Ex && ex, E && ... e ) noexcept
+    {
+        static_assert(!at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
+        return exception<typename std::remove_reference<Ex>::type>( new_error().load(std::forward<E>(e)...), std::forward<Ex>(ex) );
+    }
 
-template <class E1, class... E>
-inline
-typename std::enable_if<!std::is_base_of<std::exception,typename std::remove_reference<E1>::type>::value, leaf_detail::exception<std::exception>>::type
-exception( E1 && car, E && ... cdr ) noexcept
-{
-    static_assert(!leaf_detail::at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
-    return leaf_detail::exception<std::exception>( new_error().load(std::forward<E1>(car), std::forward<E>(cdr)...) );
+    template <class E1, class... E>
+    inline
+    typename std::enable_if<!std::is_base_of<std::exception,typename std::remove_reference<E1>::type>::value, exception<std::exception>>::type
+    make_exception( E1 && car, E && ... cdr ) noexcept
+    {
+        static_assert(!at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
+        return exception<std::exception>( new_error().load(std::forward<E1>(car), std::forward<E>(cdr)...) );
+    }
+
+    inline exception<std::exception> make_exception() noexcept
+    {
+        return exception<std::exception>(leaf::new_error());
+    }
 }
 
-inline leaf_detail::exception<std::exception> exception() noexcept
+template <class... E>
+[[noreturn]] void throw_exception( E && ... e )
 {
-    return leaf_detail::exception<std::exception>(leaf::new_error());
+    // Warning: setting a breakpoint here will not intercept exceptions thrown
+    // via BOOST_LEAF_THROW_EXCEPTION or originating in the few other throw
+    // points elsewhere in LEAF. To intercept all of those exceptions as well,
+    // set a breakpoint inside boost::leaf::detail::throw_exception_impl.
+    detail::throw_exception_impl(detail::make_exception(std::forward<E>(e)...));
 }
 
 ////////////////////////////////////////
@@ -165,11 +226,11 @@ inline leaf_detail::exception<std::exception> exception() noexcept
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
 
 template <class T>
-class result;
+class BOOST_LEAF_SYMBOL_VISIBLE result;
 
-namespace leaf_detail
+namespace detail
 {
-    inline error_id catch_exceptions_helper( std::exception const & ex, leaf_detail_mp11::mp_list<> )
+    inline error_id catch_exceptions_helper( std::exception const &, leaf_detail_mp11::mp_list<> )
     {
         return leaf::new_error(std::current_exception());
     }
@@ -201,7 +262,7 @@ namespace leaf_detail
 
 template <class... Ex, class F>
 inline
-leaf_detail::deduce_exception_to_result_return_type<leaf_detail::fn_return_type<F>>
+detail::deduce_exception_to_result_return_type<detail::fn_return_type<F>>
 exception_to_result( F && f ) noexcept
 {
     try
@@ -210,7 +271,7 @@ exception_to_result( F && f ) noexcept
     }
     catch( std::exception const & ex )
     {
-        return leaf_detail::catch_exceptions_helper(ex, leaf_detail_mp11::mp_list<Ex...>());
+        return detail::catch_exceptions_helper(ex, leaf_detail_mp11::mp_list<Ex...>());
     }
     catch(...)
     {
@@ -222,6 +283,4 @@ exception_to_result( F && f ) noexcept
 
 } }
 
-#endif
-
-#endif
+#endif // BOOST_LEAF_EXCEPTION_HPP_INCLUDED
diff --git a/include/boost/leaf/handle_errors.hpp b/include/boost/leaf/handle_errors.hpp
index c3c4e68b..d0ba7b49 100644
--- a/include/boost/leaf/handle_errors.hpp
+++ b/include/boost/leaf/handle_errors.hpp
@@ -1,78 +1,64 @@
 #ifndef BOOST_LEAF_HANDLE_ERRORS_HPP_INCLUDED
 #define BOOST_LEAF_HANDLE_ERRORS_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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/context.hpp>
-#include <boost/leaf/capture.hpp>
-#include <boost/leaf/detail/demangle.hpp>
+#include <typeinfo>
 
 namespace boost { namespace leaf {
 
-class BOOST_LEAF_SYMBOL_VISIBLE error_info
-{
-    error_info & operator=( error_info const & ) = delete;
+template <class T>
+class BOOST_LEAF_SYMBOL_VISIBLE result;
+
+////////////////////////////////////////
 
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
-    static error_id unpack_error_id( std::exception const * ex ) noexcept
+
+namespace detail
+{
+    inline 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) )
+        if( detail::exception_base const * eb = dynamic_cast<detail::exception_base const *>(&ex) )
+            return eb->get_error_id();
+        if( error_id const * err_id = dynamic_cast<error_id const *>(&ex) )
             return *err_id;
         return current_error();
     }
+}
 
-    std::exception * const ex_;
 #endif
 
+////////////////////////////////////////
+
+class BOOST_LEAF_SYMBOL_VISIBLE error_info
+{
+    error_info & operator=( error_info const & ) = delete;
+
     error_id const err_id_;
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+    std::exception * const ex_;
+#endif
+    e_source_location const * const loc_;
 
 protected:
 
     error_info( error_info const & ) noexcept = default;
 
-    template <class CharT, class Traits>
-    void print( std::basic_ostream<CharT, Traits> & os ) const
-    {
-        os << "Error ID = " << err_id_.value();
-#ifndef BOOST_LEAF_NO_EXCEPTIONS
-        if( ex_ )
-        {
-            os <<
-                "\nException dynamic type: " << leaf_detail::demangle(typeid(*ex_).name()) <<
-                "\nstd::exception::what(): " << ex_->what();
-        }
-#endif
-    }
-
 public:
 
-    BOOST_LEAF_CONSTEXPR explicit error_info( error_id id ) noexcept:
-#ifndef BOOST_LEAF_NO_EXCEPTIONS
-        ex_(nullptr),
-#endif
-        err_id_(id)
-    {
-    }
-
+    BOOST_LEAF_CONSTEXPR error_info(error_id id, std::exception * ex, e_source_location const * loc) noexcept:
+        err_id_(id),
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
-    explicit error_info( std::exception * ex ) noexcept:
         ex_(ex),
-        err_id_(unpack_error_id(ex_))
+#endif
+        loc_(loc)
     {
+        (void) ex;
     }
-#endif
 
     BOOST_LEAF_CONSTEXPR error_id error() const noexcept
     {
@@ -88,237 +74,56 @@ class BOOST_LEAF_SYMBOL_VISIBLE error_info
 #endif
     }
 
-    template <class CharT, class Traits>
-    friend std::basic_ostream<CharT, Traits> & operator<<( std::basic_ostream<CharT, Traits> & os, error_info const & x )
+    BOOST_LEAF_CONSTEXPR e_source_location const * source_location() const noexcept
     {
-        os << "leaf::error_info: ";
-        x.print(os);
-        return os << '\n';
+        return loc_;
     }
-};
-
-////////////////////////////////////////
-
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-
-class BOOST_LEAF_SYMBOL_VISIBLE 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 );
-
-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:
-        error_info(ei),
-        e_uc_(e_uc),
-        tup_(&tup),
-        print_(&leaf_detail::tuple_for_each<std::tuple_size<Tup>::value, Tup>::print)
-    {
-    }
-
-public:
 
     template <class CharT, class Traits>
-    friend std::basic_ostream<CharT, Traits> & operator<<( std::basic_ostream<CharT, Traits> & os, diagnostic_info const & x )
-    {
-        os << "leaf::diagnostic_info for ";
-        x.print(os);
-        os << ":\n";
-        x.print_(os, x.tup_, x.error().value());
-        if( x.e_uc_  )
-            x.e_uc_->print(os);
-        return os;
-    }
-};
-
-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)
-        {
-        }
-    };
-
-    template <>
-    struct handler_argument_traits<diagnostic_info const &>: handler_argument_always_available<e_unexpected_count>
+    void print_error_info(std::basic_ostream<CharT, Traits> & os) const
     {
-        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);
-        }
-    };
-}
-
-#else
-
-class BOOST_LEAF_SYMBOL_VISIBLE diagnostic_info: public error_info
-{
-protected:
-
-    diagnostic_info( diagnostic_info const & ) noexcept = default;
-
-    BOOST_LEAF_CONSTEXPR diagnostic_info( error_info const & ei ) noexcept:
-        error_info(ei)
-    {
-    }
-
-public:
-
-    template <class CharT, class Traits>
-    friend std::basic_ostream<CharT, Traits> & operator<<( std::basic_ostream<CharT, Traits> & os, diagnostic_info const & x )
-    {
-        os <<
-            "leaf::diagnostic_info requires #define BOOST_LEAF_CFG_DIAGNOSTICS 1\n"
-            "leaf::error_info: ";
-        x.print(os);
-        return os << '\n';
-    }
-};
-
-namespace leaf_detail
-{
-    struct diagnostic_info_: diagnostic_info
-    {
-        BOOST_LEAF_CONSTEXPR diagnostic_info_( error_info const & ei ) noexcept:
-            diagnostic_info(ei)
-        {
-        }
-    };
-
-    template <>
-    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
+        os << "Error with serial #" << err_id_;
+        if( loc_ )
+            os << " reported at " << *loc_;
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+        if( ex_ )
         {
-            return diagnostic_info_(ei);
-        }
-    };
-}
-
-#endif
-
-////////////////////////////////////////
-
+            os << "\nCaught:" BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER;
 #if BOOST_LEAF_CFG_DIAGNOSTICS
-
-class BOOST_LEAF_SYMBOL_VISIBLE 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 );
-
-protected:
-
-    verbose_diagnostic_info( verbose_diagnostic_info const & ) noexcept = default;
-
-    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:
-        error_info(ei),
-        e_ui_(e_ui),
-        tup_(&tup),
-        print_(&leaf_detail::tuple_for_each<std::tuple_size<Tup>::value, Tup>::print)
-    {
-    }
-
-public:
-
-    template <class CharT, class Traits>
-    friend std::basic_ostream<CharT, Traits> & operator<<( std::basic_ostream<CharT, Traits> & os, verbose_diagnostic_info const & x )
-    {
-        os << "leaf::verbose_diagnostic_info for ";
-        x.print(os);
-        os << ":\n";
-        x.print_(os, x.tup_, x.error().value());
-        if( x.e_ui_ )
-            x.e_ui_->print(os);
-        return os;
-    }
-};
-
-namespace leaf_detail
-{
-    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)
-        {
-        }
-    };
-
-    template <>
-    struct handler_argument_traits<verbose_diagnostic_info const &>: handler_argument_always_available<e_unexpected_info>
-    {
-        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);
+            if( auto eb = dynamic_cast<detail::exception_base const *>(ex_) )
+                eb->print_type_name(os);
+            else
+#endif
+                detail::demangle_and_print(os, typeid(*ex_).name());
+            os << ": \"" << ex_->what() << '"';
         }
-    };
-}
-
-#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)
-    {
+#endif
     }
 
-public:
-
     template <class CharT, class Traits>
-    friend std::basic_ostream<CharT, Traits> & operator<<( std::basic_ostream<CharT, Traits> & os, verbose_diagnostic_info const & x )
+    friend std::ostream & operator<<(std::basic_ostream<CharT, Traits> & os, error_info const & x)
     {
-        os <<
-            "leaf::verbose_diagnostic_info requires #define BOOST_LEAF_CFG_DIAGNOSTICS 1\n"
-            "leaf::error_info: ";
-        x.print(os);
+        x.print_error_info(os);
         return os << '\n';
     }
 };
 
-namespace leaf_detail
+namespace detail
 {
-    struct verbose_diagnostic_info_: verbose_diagnostic_info
-    {
-        BOOST_LEAF_CONSTEXPR verbose_diagnostic_info_( error_info const & ei ) noexcept:
-            verbose_diagnostic_info(ei)
-        {
-        }
-    };
-
-
     template <>
-    struct handler_argument_traits<verbose_diagnostic_info const &>: handler_argument_always_available<void>
+    struct handler_argument_traits<error_info const &>: handler_argument_always_available<>
     {
         template <class Tup>
-        BOOST_LEAF_CONSTEXPR static verbose_diagnostic_info_ get( Tup const & tup, error_info const & ei ) noexcept
+        BOOST_LEAF_CONSTEXPR static error_info const & get(Tup const &, error_info const & ei) noexcept
         {
-            return verbose_diagnostic_info_(ei);
+            return ei;
         }
     };
 }
 
-#endif
-
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class T, class... List>
     struct type_index;
@@ -335,7 +140,7 @@ namespace leaf_detail
         constexpr static int value = 1 + type_index<T,Cdr...>::value;
     };
 
-    template <class T, class Tuple>
+    template <class T, class Tup>
     struct tuple_type_index;
 
     template <class T, class... TupleTypes>
@@ -491,7 +296,7 @@ namespace leaf_detail
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class A>
     template <class Tup>
@@ -546,7 +351,7 @@ namespace leaf_detail
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class>
     struct handler_matches_any_error: std::false_type
@@ -567,7 +372,7 @@ namespace leaf_detail
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class Tup, class... A>
     BOOST_LEAF_CONSTEXPR inline bool check_handler_( Tup & tup, error_info const & ei, leaf_detail_mp11::mp_list<A...> ) noexcept
@@ -679,7 +484,7 @@ context<E...>::
 handle_error( error_id id, H && ... h ) const
 {
     BOOST_LEAF_ASSERT(!is_active());
-    return leaf_detail::handle_error_<R>(tup(), error_info(id), std::forward<H>(h)...);
+    return detail::handle_error_<R>(tup(), error_info(id, nullptr, this->get<e_source_location>(id)), std::forward<H>(h)...);
 }
 
 template <class... E>
@@ -690,7 +495,22 @@ context<E...>::
 handle_error( error_id id, H && ... h )
 {
     BOOST_LEAF_ASSERT(!is_active());
-    return leaf_detail::handle_error_<R>(tup(), error_info(id), std::forward<H>(h)...);
+    return detail::handle_error_<R>(tup(), error_info(id, nullptr, this->get<e_source_location>(id)), std::forward<H>(h)...);
+}
+
+////////////////////////////////////////
+
+namespace detail
+{
+    template <class T>
+    void unload_result( result<T> * r )
+    {
+        (void) r->unload();
+    }
+
+    inline void unload_result( void * )
+    {
+    }
 }
 
 ////////////////////////////////////////
@@ -709,15 +529,16 @@ try_handle_all( TryBlock && try_block, H && ... h ) noexcept
         return std::move(r).value();
     else
     {
-        error_id id = r.error();
+        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)...);
     }
 }
 
 template <class TryBlock, class... H>
-BOOST_LEAF_NODISCARD BOOST_LEAF_CONSTEXPR inline
+BOOST_LEAF_ATTRIBUTE_NODISCARD BOOST_LEAF_CONSTEXPR inline
 typename std::decay<decltype(std::declval<TryBlock>()())>::type
 try_handle_some( TryBlock && try_block, H && ... h ) noexcept
 {
@@ -728,12 +549,13 @@ try_handle_some( TryBlock && try_block, H && ... h ) noexcept
         return r;
     else
     {
-        error_id id = r.error();
+        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(id);
+            ctx.unload(error_id(rr.error()));
         return rr;
     }
 }
@@ -750,67 +572,40 @@ try_catch( TryBlock && try_block, H && ... ) noexcept
 
 #else
 
-namespace leaf_detail
+namespace detail
 {
     template <class Ctx, class TryBlock, class... H>
     decltype(std::declval<TryBlock>()())
     try_catch_( Ctx & ctx, TryBlock && try_block, H && ... h )
     {
-        using namespace leaf_detail;
+        using namespace detail;
         BOOST_LEAF_ASSERT(ctx.is_active());
         using R = decltype(std::declval<TryBlock>()());
         try
         {
-            return std::forward<TryBlock>(try_block)();
-        }
-        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;
-                    } );
-            }
+            auto r = std::forward<TryBlock>(try_block)();
+            unload_result(&r);
+            return r;
         }
         catch( std::exception & ex )
         {
             ctx.deactivate();
-            error_info e(&ex);
-            return handle_error_<R>(ctx.tup(), e, std::forward<H>(h)...,
+            error_id id = detail::unpack_error_id(ex);
+            return handle_error_<R>(ctx.tup(), error_info(id, &ex, ctx.template get<e_source_location>(id)), std::forward<H>(h)...,
                 [&]() -> R
                 {
-                    ctx.propagate(e.error());
+                    ctx.unload(id);
                     throw;
                 } );
         }
         catch(...)
         {
             ctx.deactivate();
-            error_info e(nullptr);
-            return handle_error_<R>(ctx.tup(), e, std::forward<H>(h)...,
+            error_id id = current_error();
+            return handle_error_<R>(ctx.tup(), error_info(id, nullptr, ctx.template get<e_source_location>(id)), std::forward<H>(h)...,
                 [&]() -> R
                 {
-                    ctx.propagate(e.error());
+                    ctx.unload(id);
                     throw;
                 } );
         }
@@ -818,76 +613,206 @@ 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 = detail::try_catch_(ctx, std::forward<TryBlock>(try_block), std::forward<H>(h)...) )
         return std::move(r).value();
     else
     {
-        error_id id = r.error();
-        if( ctx.is_active() )
-            ctx.deactivate();
+        BOOST_LEAF_ASSERT(ctx.is_active());
+        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>(std::move(id), std::forward<H>(h)...);
     }
 }
 
 template <class TryBlock, class... H>
-BOOST_LEAF_NODISCARD BOOST_LEAF_CONSTEXPR inline
+BOOST_LEAF_ATTRIBUTE_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 = detail::try_catch_(ctx, std::forward<TryBlock>(try_block), std::forward<H>(h)...) )
         return r;
-    else
+    else if( ctx.is_active() )
     {
-        error_id id = r.error();
-        if( ctx.is_active() )
-            ctx.deactivate();
+        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(id);
+            ctx.unload(error_id(rr.error()));
         return rr;
     }
+    else
+    {
+        ctx.unload(error_id(r.error()));
+        return r;
+    }
 }
 
 template <class TryBlock, class... H>
-BOOST_LEAF_CONSTEXPR inline
+inline
 decltype(std::declval<TryBlock>()())
 try_catch( TryBlock && try_block, H && ... h )
 {
     context_type_from_handlers<H...> ctx;
     auto active_context = activate_context(ctx);
-    return leaf_detail::try_catch_(
-        ctx,
-        [&]
+    using R = decltype(std::declval<TryBlock>()());
+    try
+    {
+        return std::forward<TryBlock>(try_block)();
+    }
+    catch( std::exception & ex )
+    {
+        ctx.deactivate();
+        error_id id = detail::unpack_error_id(ex);
+        return detail::handle_error_<R>(ctx.tup(), error_info(id, &ex, ctx.template get<e_source_location>(id)), std::forward<H>(h)...,
+            [&]() -> R
+            {
+                ctx.unload(id);
+                throw;
+            } );
+    }
+    catch(...)
+    {
+        ctx.deactivate();
+        error_id id = current_error();
+        return detail::handle_error_<R>(ctx.tup(), error_info(id, nullptr, ctx.template get<e_source_location>(id)), std::forward<H>(h)...,
+            [&]() -> R
+            {
+                ctx.unload(id);
+                throw;
+            } );
+    }
+}
+
+#endif
+
+#if BOOST_LEAF_CFG_CAPTURE
+
+namespace detail
+{
+    template <class LeafResult>
+    struct try_capture_all_dispatch_non_void
+    {
+        using leaf_result = LeafResult;
+
+        template <class TryBlock>
+        inline
+        static
+        leaf_result
+        try_capture_all_( TryBlock && try_block ) noexcept
         {
-            return std::forward<TryBlock>(try_block)();
-        },
-        std::forward<H>(h)...);
+            detail::slot<detail::dynamic_allocator> sl;
+            sl.activate();
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+            try
+#endif
+            {
+                if( leaf_result r = std::forward<TryBlock>(try_block)() )
+                {
+                    sl.deactivate();
+                    return r;
+                }
+                else
+                {
+                    sl.deactivate();
+                    int const err_id = error_id(r.error()).value();
+                    return leaf_result(sl.value_or_default(err_id).template extract_capture_list<leaf_result>(err_id));
+                }
+            }
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+            catch( std::exception & ex )
+            {
+                sl.deactivate();
+                int err_id = unpack_error_id(ex).value();
+                return sl.value_or_default(err_id).template extract_capture_list<leaf_result>(err_id);
+            }
+            catch(...)
+            {
+                sl.deactivate();
+                int err_id = current_error().value();
+                return sl.value_or_default(err_id).template extract_capture_list<leaf_result>(err_id);
+            }
+#endif
+        }
+    };
+
+    template <class R, bool IsVoid = std::is_same<void, R>::value, bool IsResultType = is_result_type<R>::value>
+    struct try_capture_all_dispatch;
+
+    template <class R>
+    struct try_capture_all_dispatch<R, false, true>:
+        try_capture_all_dispatch_non_void<::boost::leaf::result<typename std::decay<decltype(std::declval<R>().value())>::type>>
+    {
+    };
+
+    template <class R>
+    struct try_capture_all_dispatch<R, false, false>:
+        try_capture_all_dispatch_non_void<::boost::leaf::result<typename std::remove_reference<R>::type>>
+    {
+    };
+
+    template <class R>
+    struct try_capture_all_dispatch<R, true, false>
+    {
+        using leaf_result = ::boost::leaf::result<R>;
+
+        template <class TryBlock>
+        inline
+        static
+        leaf_result
+        try_capture_all_( TryBlock && try_block ) noexcept
+        {
+            detail::slot<detail::dynamic_allocator> sl;
+            sl.activate();
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+            try
+#endif
+            {
+                std::forward<TryBlock>(try_block)();
+                return {};
+            }
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+            catch( std::exception & ex )
+            {
+                sl.deactivate();
+                int err_id = unpack_error_id(ex).value();
+                return sl.value_or_default(err_id).template extract_capture_list<leaf_result>(err_id);
+            }
+            catch(...)
+            {
+                sl.deactivate();
+                int err_id = current_error().value();
+                return sl.value_or_default(err_id).template extract_capture_list<leaf_result>(err_id);
+            }
+#endif
+        }
+    };
 }
 
+template <class TryBlock>
+inline
+typename detail::try_capture_all_dispatch<decltype(std::declval<TryBlock>()())>::leaf_result
+try_capture_all( TryBlock && try_block ) noexcept
+{
+    return detail::try_capture_all_dispatch<decltype(std::declval<TryBlock>()())>::try_capture_all_(std::forward<TryBlock>(try_block));
+}
 #endif
 
 } }
@@ -900,7 +825,7 @@ namespace boost { namespace exception_detail { template <class ErrorInfo> struct
 
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+namespace detail
 {
     template <class T>
     struct match_enum_type;
@@ -926,11 +851,11 @@ namespace leaf_detail
     template <class Tag, class T>
     struct handler_argument_traits<boost::error_info<Tag, T>>
     {
-        using error_type = void;
+        using context_types = leaf_detail_mp11::mp_list<>;
         constexpr static bool always_available = false;
 
         template <class Tup>
-        BOOST_LEAF_CONSTEXPR static T * check( Tup & tup, error_info const & ei ) noexcept
+        BOOST_LEAF_CONSTEXPR static T * check( Tup &, error_info const & ei ) noexcept
         {
             using boost_exception = dependent_type_t<T, boost::exception>;
             if( auto * be = get_exception<boost_exception>(ei) )
@@ -954,4 +879,4 @@ namespace leaf_detail
 
 } }
 
-#endif
+#endif // BOOST_LEAF_HANDLE_ERRORS_HPP_INCLUDED
diff --git a/include/boost/leaf/on_error.hpp b/include/boost/leaf/on_error.hpp
index c41d7fc5..a01bce52 100644
--- a/include/boost/leaf/on_error.hpp
+++ b/include/boost/leaf/on_error.hpp
@@ -1,8 +1,7 @@
 #ifndef BOOST_LEAF_ON_ERROR_HPP_INCLUDED
 #define BOOST_LEAF_ON_ERROR_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -24,13 +23,13 @@ class error_monitor
 #if !defined(BOOST_LEAF_NO_EXCEPTIONS) && BOOST_LEAF_STD_UNCAUGHT_EXCEPTIONS
         uncaught_exceptions_(std::uncaught_exceptions()),
 #endif
-        err_id_(leaf_detail::current_id())
+        err_id_(detail::current_id())
     {
     }
 
     int check_id() const noexcept
     {
-        int err_id = leaf_detail::current_id();
+        int err_id = detail::current_id();
         if( err_id != err_id_ )
             return err_id;
         else
@@ -41,7 +40,7 @@ class error_monitor
 #   else
             if( std::uncaught_exception() )
 #   endif
-                return leaf_detail::new_id();
+                return detail::new_id();
 #endif
             return 0;
         }
@@ -49,112 +48,97 @@ class error_monitor
 
     int get_id() const noexcept
     {
-        int err_id = leaf_detail::current_id();
+        int err_id = detail::current_id();
         if( err_id != err_id_ )
             return err_id;
         else
-            return leaf_detail::new_id();
+            return detail::new_id();
     }
 
     error_id check() const noexcept
     {
-        return leaf_detail::make_error_id(check_id());
+        return detail::make_error_id(check_id());
     }
 
     error_id assigned_error_id() const noexcept
     {
-        return leaf_detail::make_error_id(get_id());
+        return detail::make_error_id(get_id());
     }
 };
 
-////////////////////////////////////////////
+////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
-    template <int I, class Tuple>
+    template <int I, class Tup>
     struct tuple_for_each_preload
     {
-        BOOST_LEAF_CONSTEXPR static void trigger( Tuple & tup, int err_id ) noexcept
+        BOOST_LEAF_CONSTEXPR static void trigger( Tup & tup, int err_id ) noexcept
         {
-            BOOST_LEAF_ASSERT((err_id&3)==1);
-            tuple_for_each_preload<I-1,Tuple>::trigger(tup,err_id);
+            BOOST_LEAF_ASSERT((err_id&3) == 1);
+            tuple_for_each_preload<I-1,Tup>::trigger(tup,err_id);
             std::get<I-1>(tup).trigger(err_id);
         }
     };
 
-    template <class Tuple>
-    struct tuple_for_each_preload<0, Tuple>
+    template <class Tup>
+    struct tuple_for_each_preload<0, Tup>
     {
-        BOOST_LEAF_CONSTEXPR static void trigger( Tuple const &, int ) noexcept { }
+        BOOST_LEAF_CONSTEXPR static void trigger( Tup const &, int ) noexcept { }
     };
 
     template <class E>
     class preloaded_item
     {
         using decay_E = typename std::decay<E>::type;
-        slot<decay_E> * s_;
         decay_E e_;
 
     public:
 
         BOOST_LEAF_CONSTEXPR preloaded_item( E && e ):
-            s_(tls::read_ptr<slot<decay_E>>()),
             e_(std::forward<E>(e))
         {
         }
 
         BOOST_LEAF_CONSTEXPR void trigger( int err_id ) noexcept
         {
-            BOOST_LEAF_ASSERT((err_id&3)==1);
-            if( s_ )
-            {
-                if( !s_->has_value(err_id) )
-                    s_->put(err_id, std::move(e_));
-            }
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-            else
-            {
-                int c = tls::read_uint32<tls_tag_unexpected_enabled_counter>();
-                BOOST_LEAF_ASSERT(c>=0);
-                if( c )
-                    load_unexpected(err_id, std::move(e_));
-            }
-#endif
+            (void) load_slot<true>(err_id, std::move(e_));
         }
     };
 
-    template <class F>
+    template <class F, class ReturnType = typename function_traits<F>::return_type>
     class deferred_item
     {
-        using E = decltype(std::declval<F>()());
-        slot<E> * s_;
         F f_;
 
     public:
 
         BOOST_LEAF_CONSTEXPR deferred_item( F && f ) noexcept:
-            s_(tls::read_ptr<slot<E>>()),
             f_(std::forward<F>(f))
         {
         }
 
         BOOST_LEAF_CONSTEXPR void trigger( int err_id ) noexcept
         {
-            BOOST_LEAF_ASSERT((err_id&3)==1);
-            if( s_ )
-            {
-                if( !s_->has_value(err_id) )
-                    s_->put(err_id, f_());
-            }
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-            else
-            {
-                int c = tls::read_uint32<tls_tag_unexpected_enabled_counter>();
-                BOOST_LEAF_ASSERT(c>=0);
-                if( c )
-                    load_unexpected(err_id, std::forward<E>(f_()));
-            }
-#endif
+            (void) load_slot_deferred<true>(err_id, f_);
+        }
+    };
+
+    template <class F>
+    class deferred_item<F, void>
+    {
+        F f_;
+
+    public:
+
+        BOOST_LEAF_CONSTEXPR deferred_item( F && f ) noexcept:
+            f_(std::forward<F>(f))
+        {
+        }
+
+        BOOST_LEAF_CONSTEXPR void trigger( int ) noexcept
+        {
+            f_();
         }
     };
 
@@ -164,28 +148,18 @@ namespace leaf_detail
     template <class F, class A0>
     class accumulating_item<F, A0 &, 1>
     {
-        using E = A0;
-        slot<E> * s_;
         F f_;
 
     public:
 
         BOOST_LEAF_CONSTEXPR accumulating_item( F && f ) noexcept:
-            s_(tls::read_ptr<slot<E>>()),
             f_(std::forward<F>(f))
         {
         }
 
         BOOST_LEAF_CONSTEXPR void trigger( int err_id ) noexcept
         {
-            BOOST_LEAF_ASSERT((err_id&3)==1);
-            if( s_ )
-            {
-                if( E * e = s_->has_value(err_id) )
-                    (void) f_(*e);
-                else
-                    (void) f_(s_->put(err_id, E()));
-            }
+            load_slot_accumulate<true>(err_id, std::move(f_));
         }
     };
 
@@ -246,13 +220,13 @@ namespace leaf_detail
 }
 
 template <class... Item>
-BOOST_LEAF_NODISCARD BOOST_LEAF_CONSTEXPR inline
-leaf_detail::preloaded<typename leaf_detail::deduce_item_type<Item>::type...>
+BOOST_LEAF_ATTRIBUTE_NODISCARD BOOST_LEAF_CONSTEXPR inline
+detail::preloaded<typename detail::deduce_item_type<Item>::type...>
 on_error( Item && ... i )
 {
-    return leaf_detail::preloaded<typename leaf_detail::deduce_item_type<Item>::type...>(std::forward<Item>(i)...);
+    return detail::preloaded<typename detail::deduce_item_type<Item>::type...>(std::forward<Item>(i)...);
 }
 
 } }
 
-#endif
+#endif // BOOST_LEAF_ON_ERROR_HPP_INCLUDED
diff --git a/include/boost/leaf/pred.hpp b/include/boost/leaf/pred.hpp
index 01ecf47e..136368a7 100644
--- a/include/boost/leaf/pred.hpp
+++ b/include/boost/leaf/pred.hpp
@@ -1,8 +1,7 @@
 #ifndef BOOST_LEAF_PRED_HPP_INCLUDED
 #define BOOST_LEAF_PRED_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -12,13 +11,13 @@
 #if __cplusplus >= 201703L
 #   define BOOST_LEAF_MATCH_ARGS(et,v1,v) auto v1, auto... v
 #else
-#   define BOOST_LEAF_MATCH_ARGS(et,v1,v) typename leaf_detail::et::type v1, typename leaf_detail::et::type... v
+#   define BOOST_LEAF_MATCH_ARGS(et,v1,v) typename detail::et::type v1, typename detail::et::type... v
 #endif
 #define BOOST_LEAF_ESC(...) __VA_ARGS__
 
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+namespace detail
 {
 #if __cplusplus >= 201703L
     template <class MatchType, class T>
@@ -76,7 +75,7 @@ BOOST_LEAF_CONSTEXPR inline bool category( std::error_code const & ec )
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class T>
     struct match_enum_type
@@ -108,7 +107,7 @@ struct match
     template <class T>
     BOOST_LEAF_CONSTEXPR static bool evaluate(T && x)
     {
-        return leaf_detail::cmp_value_pack(std::forward<T>(x), V1, V...);
+        return detail::cmp_value_pack(std::forward<T>(x), V1, V...);
     }
 };
 
@@ -121,7 +120,7 @@ struct match<condition<Enum, Enum>, V1, V...>
 
     BOOST_LEAF_CONSTEXPR static bool evaluate(std::error_code const & e) noexcept
     {
-        return leaf_detail::cmp_value_pack(e, V1, V...);
+        return detail::cmp_value_pack(e, V1, V...);
     }
 };
 #endif
@@ -133,7 +132,7 @@ struct is_predicate<match<E, V1, V...>>: std::true_type
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class E>
     struct match_value_enum_type
@@ -151,7 +150,7 @@ namespace leaf_detail
     template <class Enum>
     struct match_value_enum_type<condition<Enum, Enum>>
     {
-        static_assert(sizeof(Enum)==0, "leaf::condition<Enum> should be used with leaf::match<>, not with leaf::match_value<>");
+        static_assert(sizeof(Enum) == 0, "leaf::condition<Enum> should be used with leaf::match<>, not with leaf::match_value<>");
     };
 #endif
 }
@@ -164,7 +163,7 @@ struct match_value
 
     BOOST_LEAF_CONSTEXPR static bool evaluate(E const & e) noexcept
     {
-        return leaf_detail::cmp_value_pack(e.value, V1, V...);
+        return detail::cmp_value_pack(e.value, V1, V...);
     }
 };
 
@@ -177,7 +176,7 @@ struct match_value<condition<E, Enum>, V1, V...>
 
     BOOST_LEAF_CONSTEXPR static bool evaluate(E const & e)
     {
-        return leaf_detail::cmp_value_pack(e.value, V1, V...);
+        return detail::cmp_value_pack(e.value, V1, V...);
     }
 };
 #endif
@@ -201,7 +200,7 @@ struct match_member<P, V1, V...>
 
     BOOST_LEAF_CONSTEXPR static bool evaluate(E const & e) noexcept
     {
-        return leaf_detail::cmp_value_pack(e.*P, V1, V...);
+        return detail::cmp_value_pack(e.*P, V1, V...);
     }
 };
 
@@ -236,18 +235,18 @@ struct is_predicate<if_not<P>>: std::true_type
 
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
 
-namespace leaf_detail
+namespace detail
 {
     template <class Ex>
     BOOST_LEAF_CONSTEXPR inline bool check_exception_pack( std::exception const & ex, Ex const * ) noexcept
     {
-        return dynamic_cast<Ex const *>(&ex)!=nullptr;
+        return dynamic_cast<Ex const *>(&ex) != nullptr;
     }
 
     template <class Ex, class... ExRest>
     BOOST_LEAF_CONSTEXPR inline bool check_exception_pack( std::exception const & ex, Ex const *, ExRest const * ... ex_rest ) noexcept
     {
-        return dynamic_cast<Ex const *>(&ex)!=nullptr || check_exception_pack(ex, ex_rest...);
+        return dynamic_cast<Ex const *>(&ex) != nullptr || check_exception_pack(ex, ex_rest...);
     }
 
     BOOST_LEAF_CONSTEXPR inline bool check_exception_pack( std::exception const & ) noexcept
@@ -264,7 +263,7 @@ struct catch_
 
     BOOST_LEAF_CONSTEXPR static bool evaluate(std::exception const & ex) noexcept
     {
-        return leaf_detail::check_exception_pack(ex, static_cast<Ex const *>(nullptr)...);
+        return detail::check_exception_pack(ex, static_cast<Ex const *>(nullptr)...);
     }
 };
 
@@ -294,4 +293,4 @@ struct is_predicate<catch_<Ex...>>: std::true_type
 
 } }
 
-#endif
+#endif // BOOST_LEAF_PRED_HPP_INCLUDED
diff --git a/include/boost/leaf/result.hpp b/include/boost/leaf/result.hpp
index f2ad7e11..55dffab6 100644
--- a/include/boost/leaf/result.hpp
+++ b/include/boost/leaf/result.hpp
@@ -1,58 +1,88 @@
 #ifndef BOOST_LEAF_RESULT_HPP_INCLUDED
 #define BOOST_LEAF_RESULT_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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/error.hpp>
+#include <boost/leaf/detail/print.hpp>
+#include <boost/leaf/detail/capture_list.hpp>
+#include <boost/leaf/exception.hpp>
 
 #include <climits>
 #include <functional>
 
 namespace boost { namespace leaf {
 
+namespace detail { class dynamic_allocator; }
+
+////////////////////////////////////////
+
 class bad_result:
-    public std::exception,
-    public error_id
+    public std::exception
 {
     char const * what() const noexcept final override
     {
         return "boost::leaf::bad_result";
     }
+};
 
-public:
+////////////////////////////////////////
+
+namespace detail
+{
+    template <class T, bool Printable = is_printable<T>::value>
+    struct result_value_printer;
+
+    template <class T>
+    struct result_value_printer<T, true>
+    {
+        template <class CharT, class Traits>
+        static void print( std::basic_ostream<CharT, Traits> & s, T const & x )
+        {
+            (void) (s << x);
+        }
+    };
+
+    template <class T>
+    struct result_value_printer<T, false>
+    {
+        template <class CharT, class Traits>
+        static void print( std::basic_ostream<CharT, Traits> & s, T const & )
+        {
+            (void) (s << "{not printable}");
+        }
+    };
 
-    explicit bad_result( error_id id ) noexcept:
-        error_id(id)
+    template <class CharT, class Traits, class T>
+    void print_result_value( std::basic_ostream<CharT, Traits> & s, T const & x )
     {
-        BOOST_LEAF_ASSERT(value());
+        result_value_printer<T>::print(s, x);
     }
-};
+}
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class T>
     struct stored
     {
         using type = T;
-        using value_type = T;
-        using value_type_const = T const;
+        using value_no_ref = T;
+        using value_no_ref_const = T const;
         using value_cref = T const &;
         using value_ref = T &;
         using value_rv_cref = T const &&;
         using value_rv_ref = T &&;
 
-        static value_type_const * cptr( type const & v ) noexcept
+        static value_no_ref_const * cptr( type const & v ) noexcept
         {
             return &v;
         }
 
-        static value_type * ptr( type & v ) noexcept
+        static value_no_ref * ptr( type & v ) noexcept
         {
             return &v;
         }
@@ -62,19 +92,19 @@ namespace leaf_detail
     struct stored<T &>
     {
         using type = std::reference_wrapper<T>;
-        using value_type_const = T;
-        using value_type = T;
+        using value_no_ref = T;
+        using value_no_ref_const = T;
         using value_ref = T &;
         using value_cref = T &;
         using value_rv_ref = T &;
         using value_rv_cref = T &;
 
-        static value_type_const * cptr( type const & v ) noexcept
+        static value_no_ref_const * cptr( type const & v ) noexcept
         {
             return &v.get();
         }
 
-        static value_type * ptr( type const & v ) noexcept
+        static value_no_ref * ptr( type const & v ) noexcept
         {
             return &v.get();
         }
@@ -82,37 +112,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_(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, 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
         {
@@ -121,8 +155,8 @@ namespace leaf_detail
 
         error_id get_error_id() const noexcept
         {
-            BOOST_LEAF_ASSERT(kind()==no_error || kind()==err_id);
-            return make_error_id(state_);
+            BOOST_LEAF_ASSERT(kind() == err_id_zero || kind() == err_id || kind() == err_id_capture_list);
+            return make_error_id(int((state_&~3)|1));
         }
     };
 }
@@ -130,12 +164,35 @@ namespace leaf_detail
 ////////////////////////////////////////
 
 template <class T>
-class result
+class BOOST_LEAF_SYMBOL_VISIBLE BOOST_LEAF_ATTRIBUTE_NODISCARD result
 {
     template <class U>
     friend class result;
 
-    using result_discriminant = leaf_detail::result_discriminant;
+    friend class detail::dynamic_allocator;
+
+#if BOOST_LEAF_CFG_CAPTURE
+    using capture_list = detail::capture_list;
+#endif
+
+    using result_discriminant = detail::result_discriminant;
+    using stored_type = typename detail::stored<T>::type;
+    using value_no_ref = typename detail::stored<T>::value_no_ref;
+    using value_no_ref_const = typename detail::stored<T>::value_no_ref_const;
+    using value_ref = typename detail::stored<T>::value_ref;
+    using value_cref = typename detail::stored<T>::value_cref;
+    using value_rv_ref = typename detail::stored<T>::value_rv_ref;
+    using value_rv_cref = typename 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
     {
@@ -153,77 +210,50 @@ class result
         template <class U>
         operator result<U>() noexcept
         {
-            switch(r_.what_.kind())
+            result_discriminant const what = r_.what_;
+            switch(auto k = 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_));
+                default:
+                    BOOST_LEAF_ASSERT(k == result_discriminant::err_id);
+                case result_discriminant::err_id_zero:
+                    return result<U>(what.get_error_id());
             }
         }
 
-        operator error_id() noexcept
+        operator error_id() const 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_->propagate_captured_errors();
-                    tls::write_uint32<leaf_detail::tls_tag_id_factory_current_id>(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_type = typename leaf_detail::stored<T>::value_type;
-    using value_type_const = typename leaf_detail::stored<T>::value_type_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())
+        switch(auto k = this->what_.kind())
         {
-        case result_discriminant::val:
-            stored_.~stored_type();
+        default:
+            BOOST_LEAF_ASSERT(k == result_discriminant::err_id);
+        case result_discriminant::err_id_zero:
             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();
         }
     }
 
@@ -231,39 +261,29 @@ class result
     result_discriminant move_from( result<U> && x ) noexcept
     {
         auto x_what = x.what_;
-        switch(x_what.kind())
+        switch(auto k = x_what.kind())
         {
-        case result_discriminant::val:
-            (void) new(&stored_) stored_type(std::move(x.stored_));
+        default:
+            BOOST_LEAF_ASSERT(k == result_discriminant::err_id);
+        case result_discriminant::err_id_zero:
             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
-        return what_.kind()==result_discriminant::ctx_ptr ? ctx_->captured_id_ : what_.get_error_id();
-#else
-        BOOST_LEAF_ASSERT(what_.kind()!=result_discriminant::ctx_ptr); // Possible ODR violation.
+        BOOST_LEAF_ASSERT(what_.kind() != result_discriminant::val);
         return what_.get_error_id();
-#endif
     }
 
     stored_type const * get() const noexcept
@@ -278,14 +298,64 @@ class result
 
 protected:
 
+#if BOOST_LEAF_CFG_CAPTURE
+    result( int err_id, detail::capture_list && cap ) noexcept:
+        cap_(std::move(cap)),
+        what_(err_id, cap)
+    {
+    }
+#endif
+
     void enforce_value_state() const
     {
-        if( !has_value() )
-            ::boost::leaf::throw_exception(bad_result(get_error_id()));
+        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:
+            throw_exception(get_error_id(), bad_result{});
+        case result_discriminant::val:
+            break;
+        }
+    }
+
+    template <class U>
+    void move_assign( result<U> && x ) noexcept
+    {
+        destroy();
+        what_ = move_from(std::move(x));
+    }
+
+    template <class CharT, class Traits>
+    void print_error_result(std::basic_ostream<CharT, Traits> & os) const
+    {
+        result_discriminant const what = what_;
+        BOOST_LEAF_ASSERT(what.kind() != result_discriminant::val);
+        error_id const err_id = what.get_error_id();
+        os << "Error serial #" << err_id;
+        if( what.kind() == result_discriminant::err_id_capture_list )
+        {
+#if BOOST_LEAF_CFG_CAPTURE
+            char const * prefix = "\nCaptured:";
+            cap_.print(os, err_id, prefix);
+            os << "\n";
+#else
+            BOOST_LEAF_ASSERT(0); // Possible ODR violation.
+#endif
+        }
     }
 
 public:
 
+    using value_type = T;
+
+    // NOTE: Copy constructor implicitly deleted.
+
     result( result && x ) noexcept:
         what_(move_from(std::move(x)))
     {
@@ -303,18 +373,25 @@ class result
     {
     }
 
-    result( value_type && v ) noexcept:
-        stored_(std::forward<value_type>(v)),
+    result( value_no_ref && v ) noexcept:
+        stored_(std::forward<value_no_ref>(v)),
         what_(result_discriminant::kind_val{})
     {
     }
 
-    result( value_type const & v ):
+    result( value_no_ref const & v ):
         stored_(v),
         what_(result_discriminant::kind_val{})
     {
     }
 
+    template<class... A, class = typename std::enable_if<std::is_constructible<T, A...>::value && sizeof...(A) >= 2>::type>
+    result( A && ... a ) noexcept:
+        stored_(std::forward<A>(a)...),
+        what_(result_discriminant::kind_val{})
+    {
+    }
+
     result( error_id err ) noexcept:
         what_(err)
     {
@@ -327,10 +404,10 @@ class result
     // On the other hand, the workaround exposes a rather severe bug in
     //__GNUC__ under 11: https://github.com/boostorg/leaf/issues/25.
 
-    // SFINAE: T can be initialized with a U, e.g. result<std::string>("literal").
-    template <class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
-    result( U && u ):
-        stored_(std::forward<U>(u)),
+    // SFINAE: T can be initialized with an A, e.g. result<std::string>("literal").
+    template<class A, class = typename std::enable_if<std::is_constructible<T, A>::value && std::is_convertible<A, T>::value>::type>
+    result( A && a ) noexcept:
+        stored_(std::forward<A>(a)),
         what_(result_discriminant::kind_val{})
     {
     }
@@ -338,13 +415,13 @@ class result
 #else
 
 private:
-    static int init_T_with_U( T && );
+    static int init_T_with_A( T && );
 public:
 
-    // SFINAE: T can be initialized with a U, e.g. result<std::string>("literal").
-    template <class U>
-    result( U && u, decltype(init_T_with_U(std::forward<U>(u))) * = nullptr ):
-        stored_(std::forward<U>(u)),
+    // SFINAE: T can be initialized with an A, e.g. result<std::string>("literal").
+    template <class A>
+    result( A && a, decltype(init_T_with_A(std::forward<A>(a))) * = nullptr ):
+        stored_(std::forward<A>(a)),
         what_(result_discriminant::kind_val{})
     {
     }
@@ -357,38 +434,30 @@ class result
     {
     }
 
-    template <class Enum>
-    result( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, int>::type * = nullptr ) noexcept:
+    template <class Enum, class = typename std::enable_if<std::is_error_code_enum<Enum>::value, int>::type>
+    result( Enum e ) noexcept:
         what_(error_id(e))
     {
     }
 #endif
 
-#if BOOST_LEAF_CFG_CAPTURE
-    result( context_ptr && ctx ) noexcept:
-        ctx_(std::move(ctx)),
-        what_(result_discriminant::kind_ctx_ptr{})
-    {
-    }
-#endif
-
     ~result() noexcept
     {
         destroy();
     }
 
+    // NOTE: Assignment operator implicitly deleted.
+
     result & operator=( result && x ) noexcept
     {
-        destroy();
-        what_ = move_from(std::move(x));
+        move_assign(std::move(x));
         return *this;
     }
 
-    template <class U>
+    template <class U, class = typename std::enable_if<std::is_convertible<U, T>::value>::type>
     result & operator=( result<U> && x ) noexcept
     {
-        destroy();
-        what_ = move_from(std::move(x));
+        move_assign(std::move(x));
         return *this;
     }
 
@@ -449,14 +518,14 @@ class result
 
 #endif
 
-    value_type_const * operator->() const noexcept
+    value_no_ref_const * operator->() const noexcept
     {
-        return has_value() ? leaf_detail::stored<T>::cptr(stored_) : nullptr;
+        return has_value() ? detail::stored<T>::cptr(stored_) : nullptr;
     }
 
-    value_type * operator->() noexcept
+    value_no_ref * operator->() noexcept
     {
-        return has_value() ? leaf_detail::stored<T>::ptr(stored_) : nullptr;
+        return has_value() ? detail::stored<T>::ptr(stored_) : nullptr;
     }
 
 #ifdef BOOST_LEAF_NO_CXX11_REF_QUALIFIERS
@@ -517,35 +586,58 @@ class result
     {
         return error_id(error()).load(std::forward<Item>(item)...);
     }
+
+    void unload()
+    {
+#if BOOST_LEAF_CFG_CAPTURE
+        if( what_.kind() == result_discriminant::err_id_capture_list )
+            cap_.unload(what_.get_error_id().value());
+#endif
+    }
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, result const & r )
+    {
+        if( r.what_.kind() == result_discriminant::val )
+            detail::print_result_value(os, r.value());
+        else
+            r.print_error_result(os);
+        return os;
+    }
 };
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     struct void_ { };
 }
 
 template <>
-class result<void>:
-    result<leaf_detail::void_>
+class BOOST_LEAF_SYMBOL_VISIBLE BOOST_LEAF_ATTRIBUTE_NODISCARD result<void>:
+    result<detail::void_>
 {
-    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))
+    friend class detail::dynamic_allocator;
+
+    using result_discriminant = detail::result_discriminant;
+    using void_ = detail::void_;
+    using base = result<void_>;
+
+#if BOOST_LEAF_CFG_CAPTURE
+    result( int err_id, detail::capture_list && cap ) noexcept:
+        base(err_id, std::move(cap))
     {
     }
+#endif
 
 public:
 
     using value_type = void;
 
+    // NOTE: Copy constructor implicitly deleted.
     result( result && x ) noexcept:
         base(std::move(x))
     {
@@ -566,22 +658,22 @@ class result<void>:
     {
     }
 
-    template <class Enum>
-    result( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type * = nullptr ) noexcept:
+    template <class Enum, class = typename std::enable_if<std::is_error_code_enum<Enum>::value, int>::type>
+    result( Enum e ) noexcept:
         base(e)
     {
     }
 #endif
 
-#if BOOST_LEAF_CFG_CAPTURE
-    result( context_ptr && ctx ) noexcept:
-        base(std::move(ctx))
+    ~result() noexcept
     {
     }
-#endif
 
-    ~result() noexcept
+    // NOTE: Assignment operator implicitly deleted.
+    result & operator=( result && x ) noexcept
     {
+        base::move_assign(std::move(x));
+        return *this;
     }
 
     void value() const
@@ -604,11 +696,22 @@ class result<void>:
         BOOST_LEAF_ASSERT(has_value());
     }
 
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, result const & r )
+    {
+        if( r )
+            os << "No error";
+        else
+            r.print_error_result(os);
+        return os;
+    }
+
     using base::operator=;
     using base::operator bool;
     using base::get_error_id;
     using base::error;
     using base::load;
+    using base::unload;
 };
 
 ////////////////////////////////////////
@@ -623,4 +726,4 @@ struct is_result_type<result<T>>: std::true_type
 
 } }
 
-#endif
+#endif // BOOST_LEAF_RESULT_HPP_INCLUDED
diff --git a/include/boost/leaf/to_variant.hpp b/include/boost/leaf/to_variant.hpp
index 83a23b4c..2acd1b05 100644
--- a/include/boost/leaf/to_variant.hpp
+++ b/include/boost/leaf/to_variant.hpp
@@ -1,8 +1,7 @@
 #ifndef BOOST_LEAF_TO_VARIANT_HPP_INCLUDED
 #define BOOST_LEAF_TO_VARIANT_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -47,4 +46,4 @@ to_variant( TryBlock && try_block )
 
 #endif
 
-#endif
+#endif // BOOST_LEAF_TO_VARIANT_HPP_INCLUDED
diff --git a/meson.build b/meson.build
index 0ac746f5..8b62aa8e 100644
--- a/meson.build
+++ b/meson.build
@@ -1,18 +1,18 @@
-# Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
+# Copyright 2018-2024 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)
 
 project('leaf', 'cpp', default_options : ['cpp_std=c++17', 'b_pch=false'], license : 'boost')
 
-option_leaf_hpp = get_option('leaf_hpp')
+option_single_header = get_option('single_header')
 option_boost = get_option('leaf_boost_examples')
 option_lua = get_option('leaf_lua_examples')
 option_diagnostics = get_option('leaf_diagnostics')
+option_capture = get_option('leaf_capture')
 option_exceptions = (get_option('cpp_eh')!='none')
 option_enable_unit_tests = get_option('leaf_enable_unit_tests')
 option_enable_examples = get_option('leaf_enable_examples')
-option_enable_benchmarks = get_option('leaf_enable_benchmarks')
 option_embedded = get_option('leaf_embedded')
 
 if not option_enable_examples
@@ -24,6 +24,10 @@ if not option_enable_examples
     endif
 endif
 
+if target_machine.system() == 'windows'
+    add_global_arguments('-D_CRT_SECURE_NO_WARNINGS', language: 'cpp')
+endif
+
 compiler = meson.get_compiler('cpp')
 compiler_id = compiler.get_id()
 if not meson.is_subproject()
@@ -32,7 +36,11 @@ if not meson.is_subproject()
             '-DBOOST_LEAF_BOOST_AVAILABLE',
             language:'cpp' )
     endif
-    if compiler_id=='clang'
+    if compiler_id=='msvc'
+        add_global_arguments(
+            '/FC',
+            language:'cpp' )
+    elif compiler_id=='clang'
         if get_option('buildtype')!='debug'
             add_global_arguments(
                 '-Wno-unused-variable',
@@ -43,6 +51,10 @@ if not meson.is_subproject()
             '-Wno-dangling-else',
             '-Wno-non-virtual-dtor',
             '-Wno-delete-non-abstract-non-virtual-dtor',
+#            '-Wshadow-all',
+#            '-Wsign-conversion',
+#            '-Wextra',
+#            '-Werror',
             language:'cpp' )
     elif compiler_id=='gcc'
         if get_option('buildtype')!='debug'
@@ -85,7 +97,10 @@ if option_lua
     dep_lua = subproject('lua').get_variable('all')
 endif
 
-defines = [ '-DBOOST_LEAF_CFG_DIAGNOSTICS=' + option_diagnostics.to_string() ]
+defines = [
+    '-DBOOST_LEAF_CFG_DIAGNOSTICS=' + option_diagnostics.to_string(),
+    '-DBOOST_LEAF_CFG_CAPTURE=' + option_capture.to_string()
+]
 
 if option_embedded
     defines += '-DBOOST_LEAF_EMBEDDED'
@@ -100,38 +115,29 @@ leaf = declare_dependency( include_directories: 'include', compile_args: defines
 if option_enable_unit_tests
 
     tests = [
-        'accumulate_basic_test',
-        'accumulate_nested_error_exception_test',
-        'accumulate_nested_error_result_test',
-        'accumulate_nested_new_error_exception_test',
-        'accumulate_nested_new_error_result_test',
-        'accumulate_nested_success_exception_test',
-        'accumulate_nested_success_result_test',
-        'BOOST_LEAF_AUTO_test',
         'BOOST_LEAF_ASSIGN_test',
+        'BOOST_LEAF_AUTO_test',
         'BOOST_LEAF_CHECK_test',
         'capture_exception_async_test',
         'capture_exception_result_async_test',
+        'capture_exception_result_unload_test',
         'capture_exception_state_test',
         'capture_exception_unload_test',
         'capture_result_async_test',
         'capture_result_state_test',
+        'capture_result_unload_test',
         'context_activator_test',
         'context_deduction_test',
-        'capture_result_unload_test',
         'ctx_handle_all_test',
         'ctx_handle_some_test',
         'ctx_remote_handle_all_test',
         'ctx_remote_handle_some_test',
-        'defer_basic_test',
-        'defer_nested_error_exception_test',
-        'defer_nested_error_result_test',
-        'defer_nested_new_error_exception_test',
-        'defer_nested_new_error_result_test',
-        'defer_nested_success_exception_test',
-        'defer_nested_success_result_test',
-        'diagnostic_info_test',
-        'diagnostic_info_test2',
+        'diagnostics_test1',
+        'diagnostics_test2',
+        'diagnostics_test3',
+        'diagnostics_test4',
+        'diagnostics_test5',
+        'diagnostics_test6',
         'e_errno_test',
         'e_LastError_test',
         'error_code_test',
@@ -139,28 +145,46 @@ if option_enable_unit_tests
         'exception_test',
         'exception_to_result_test',
         'function_traits_test',
+        'github_issue53_test',
+        'github_issue53x_test',
         'handle_all_other_result_test',
         'handle_all_test',
         'handle_basic_test',
         'handle_some_other_result_test',
         'handle_some_test',
-        'match_test',
         'match_member_test',
+        'match_test',
         'match_value_test',
         'multiple_errors_test',
+        'on_error_accumulate_basic_test',
+        'on_error_accumulate_nested_error_exception_test',
+        'on_error_accumulate_nested_error_result_test',
+        'on_error_accumulate_nested_new_error_exception_test',
+        'on_error_accumulate_nested_new_error_result_test',
+        'on_error_accumulate_nested_success_exception_test',
+        'on_error_accumulate_nested_success_result_test',
+        'on_error_defer_basic_test',
+        'on_error_defer_nested_error_exception_test',
+        'on_error_defer_nested_error_result_test',
+        'on_error_defer_nested_new_error_exception_test',
+        'on_error_defer_nested_new_error_result_test',
+        'on_error_defer_nested_success_exception_test',
+        'on_error_defer_nested_success_result_test',
+        'on_error_preload_basic_test',
+        'on_error_preload_exception_test',
+        'on_error_preload_nested_error_exception_test',
+        'on_error_preload_nested_error_result_test',
+        'on_error_preload_nested_new_error_exception_test',
+        'on_error_preload_nested_new_error_result_test',
+        'on_error_preload_nested_success_exception_test',
+        'on_error_preload_nested_success_result_test',
         'optional_test',
-        'preload_basic_test',
-        'preload_exception_test',
-        'preload_nested_error_exception_test',
-        'preload_nested_error_result_test',
-        'preload_nested_new_error_exception_test',
-        'preload_nested_new_error_result_test',
-        'preload_nested_success_exception_test',
-        'preload_nested_success_result_test',
+        'parse_name_test',
         'print_test',
         'result_bad_result_test',
         'result_implicit_conversion_test',
         'result_load_test',
+        'result_print_test',
         'result_ref_test',
         'result_state_test',
         'tls_array_alloc_test1',
@@ -168,6 +192,7 @@ if option_enable_unit_tests
         'tls_array_alloc_test3',
         'tls_array_test',
         'to_variant_test',
+        'try_capture_all_test',
         'try_catch_error_id_test',
         'try_catch_system_error_test',
         'try_catch_test',
@@ -180,7 +205,7 @@ if option_enable_unit_tests
     endif
 
     dep_test_single_header = []
-    if option_leaf_hpp
+    if option_single_header
         dep_test_single_header = declare_dependency(compile_args: ['-DBOOST_LEAF_TEST_SINGLE_HEADER'])
     endif
 
@@ -189,18 +214,18 @@ if option_enable_unit_tests
     endforeach
 
     header_tests = [
-        '_hpp_capture_test',
         '_hpp_common_test',
         '_hpp_config_test',
         '_hpp_context_test',
+        '_hpp_diagnostics_test',
         '_hpp_error_test',
         '_hpp_exception_test',
         '_hpp_handle_errors_test',
+        '_hpp_leaf_test',
         '_hpp_on_error_test',
         '_hpp_pred_test',
         '_hpp_result_test',
         '_hpp_to_variant_test',
-        '_hpp_leaf_test',
     ]
     foreach t : header_tests
         test(t, executable(t, 'test/'+t+'.cpp', dependencies: [leaf, dep_thread, dep_boost]) )
@@ -212,82 +237,28 @@ endif
 
 if option_enable_examples
 
-    print_file_examples = [
-        'print_file_result'
-    ]
+    executable('print_file_leaf_result', 'example/print_file/print_file_leaf_result.cpp', dependencies: [leaf] )
     if option_exceptions
-        print_file_examples += [
-            'print_file_eh'
-        ]
+        executable('print_file_exceptions', 'example/print_file/print_file_exceptions.cpp', dependencies: [leaf] )
     endif
     if option_boost
-        print_file_examples += [
-            'print_file_outcome_result'
-        ]
-    endif
-
-    foreach e : print_file_examples
-        executable(e, 'example/print_file/'+e+'.cpp', dependencies: [leaf, dep_thread, dep_boost] )
-    endforeach
-
-endif
-
-#################################
-
-if option_enable_examples
-
-    examples = [
-        'capture_in_result',
-        'error_log',
-        'error_trace',
-        'print_half'
-    ]
-    if option_exceptions
-        examples += [
-            'capture_in_exception',
-            'exception_to_result'
-        ]
-        if option_lua
-            examples += [
-                'lua_callback_eh'
-            ]
-        endif
-        if option_boost
-            examples += [
-    #           'asio_beast_leaf_rpc' #FIXME
-            ]
-        endif
-    endif
-    if option_lua
-        examples += [
-            'lua_callback_result'
-        ]
-    endif
-
-    foreach e : examples
-        executable(e, 'example/'+e+'.cpp', dependencies: [leaf, dep_thread, dep_boost, dep_lua] )
-    endforeach
-
-endif
-
-#################################
-
-if option_enable_benchmarks
-
-    if get_option('optimization')=='0'
-        error('The option leaf_enable_benchmarks requires optimizations to be enabled. Aborting.')
+        executable('print_file_system_result', 'example/print_file/print_file_system_result.cpp', dependencies: [leaf, dep_boost] )
     endif
 
+    executable('error_log', 'example/error_log.cpp', dependencies: [leaf] )
+    executable('error_trace', 'example/error_trace.cpp', dependencies: [leaf] )
+    executable('print_half', 'example/print_half.cpp', dependencies: [leaf] )
+    executable('try_capture_all_result', 'example/try_capture_all_result.cpp', dependencies: [leaf] )
     if option_exceptions
-        error('The option leaf_enable_benchmarks requires the built-in option cpp_eh set to none. Aborting.')
+        executable('try_capture_all_exceptions', 'example/try_capture_all_exceptions.cpp', dependencies: [leaf] )
+        executable('exception_to_result', 'example/exception_to_result.cpp', dependencies: [leaf] )
     endif
 
-    dep_tl_expected = subproject('tl_expected').get_variable('headers')
-    executable('deep_stack_tl', 'benchmark/deep_stack_other.cpp', override_options: ['cpp_std=c++17'], cpp_args: '-DBENCHMARK_WHAT=0', dependencies: [dep_tl_expected] )
-    executable('deep_stack_leaf', 'benchmark/deep_stack_leaf.cpp', dependencies: [leaf], override_options: ['cpp_std=c++17'], cpp_args: '-DBOOST_LEAF_CFG_DIAGNOSTICS=0')
-    if option_boost
-        executable('deep_stack_result', 'benchmark/deep_stack_other.cpp', dependencies: [dep_boost], override_options: ['cpp_std=c++17'], cpp_args: '-DBENCHMARK_WHAT=1' )
-        executable('deep_stack_outcome', 'benchmark/deep_stack_other.cpp', dependencies: [dep_boost], override_options: ['cpp_std=c++17'], cpp_args: '-DBENCHMARK_WHAT=2' )
+    if option_lua
+        if option_exceptions
+            executable('lua_callback_exceptions', 'example/lua_callback_exceptions.cpp', dependencies: [leaf, dep_lua] )
+        endif
+        executable('lua_callback_result', 'example/lua_callback_result.cpp', dependencies: [leaf, dep_lua] )
     endif
 
 endif
diff --git a/meson_options.txt b/meson_options.txt
index 66ddd1a8..7b35317e 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -1,8 +1,8 @@
-option('leaf_hpp',type:'boolean',value:false,description:'Unit tests #include <boost/leaf.hpp> instead of individual headers')
-option('leaf_boost_examples',type:'boolean',value:false,description:'Builds the Boost examples and Boost Outcome benchmark')
+option('single_header',type:'boolean',value:false,description:'Unit tests #include "leaf.hpp" instead of individual headers')
+option('leaf_boost_examples',type:'boolean',value:false,description:'Builds the examples that use Boost')
 option('leaf_lua_examples',type:'boolean',value:false,description:'Enable or disable downloading of Lua and building the Lua examples')
 option('leaf_diagnostics',type:'integer',value:1,description:'BOOST_LEAF_CFG_DIAGNOSTICS value')
+option('leaf_capture',type:'integer',value:1,description:'BOOST_LEAF_CFG_CAPTURE value')
 option('leaf_embedded',type:'boolean',value:false,description:'Defines BOOST_LEAF_EMBEDDED')
 option('leaf_enable_unit_tests',type:'boolean',value:true,description:'Enable the building of unit test programs')
 option('leaf_enable_examples',type:'boolean',value:true,description:'Enable the building of example programs')
-option('leaf_enable_benchmarks',type:'boolean',value:false,description:'Enable the building of benchmark programs')
diff --git a/test/BOOST_LEAF_ASSIGN_test.cpp b/test/BOOST_LEAF_ASSIGN_test.cpp
index 2724636b..1b974f4a 100644
--- a/test/BOOST_LEAF_ASSIGN_test.cpp
+++ b/test/BOOST_LEAF_ASSIGN_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -23,7 +22,7 @@ struct value
 {
     int x;
 
-    explicit value( int x ): x(x) { };
+    explicit value( int x_ ): x(x_) { };
 
 #ifndef BOOST_LEAF_NO_CXX11_REF_QUALIFIERS
     value( value const & ) = delete;
diff --git a/test/BOOST_LEAF_AUTO_test.cpp b/test/BOOST_LEAF_AUTO_test.cpp
index 5a53e7fa..a56dff68 100644
--- a/test/BOOST_LEAF_AUTO_test.cpp
+++ b/test/BOOST_LEAF_AUTO_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -23,7 +22,7 @@ struct value
 {
     int x;
 
-    explicit value( int x ): x(x) { };
+    explicit value( int x_ ): x(x_) { };
 
 #ifndef BOOST_LEAF_NO_CXX11_REF_QUALIFIERS
     value( value const & ) = delete;
diff --git a/test/BOOST_LEAF_CHECK_test.cpp b/test/BOOST_LEAF_CHECK_test.cpp
index 52510e15..e6c4523e 100644
--- a/test/BOOST_LEAF_CHECK_test.cpp
+++ b/test/BOOST_LEAF_CHECK_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -24,7 +23,7 @@ struct value
 {
     int x;
 
-    explicit value( int x ): x(x) { };
+    explicit value( int x_ ): x(x_) { };
 
 #ifndef BOOST_LEAF_NO_CXX11_REF_QUALIFIERS
     value( value const & ) = delete;
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index bc872ada..85371b5b 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -1,76 +1,73 @@
-# Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
+# Copyright 2018-2024 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)
 
 import testing ;
 
+variant leaf_debug_capture0 : debug : <define>BOOST_LEAF_CFG_CAPTURE=0 ;
+variant leaf_release_capture0 : release : <define>BOOST_LEAF_CFG_CAPTURE=0 ;
+
 variant leaf_debug_diag0 : debug : <define>BOOST_LEAF_CFG_DIAGNOSTICS=0 ;
 variant leaf_release_diag0 : release : <define>BOOST_LEAF_CFG_DIAGNOSTICS=0 ;
 
 variant leaf_debug_embedded : debug : <define>BOOST_LEAF_EMBEDDED <rtti>off <exception-handling>off ;
 variant leaf_release_embedded : release : <define>BOOST_LEAF_EMBEDDED <rtti>off <exception-handling>off ;
 
-variant leaf_debug_leaf_hpp : debug : <define>BOOST_LEAF_TEST_SINGLE_HEADER ;
-variant leaf_release_leaf_hpp : release : <define>BOOST_LEAF_TEST_SINGLE_HEADER ;
+variant leaf_debug_single_header : debug : <define>BOOST_LEAF_TEST_SINGLE_HEADER ;
+variant leaf_release_single_header : release : <define>BOOST_LEAF_TEST_SINGLE_HEADER ;
 
 project
     : default-build
         <cxxstd>11
+        <threading>multi
     : requirements
         <define>BOOST_LEAF_BOOST_AVAILABLE
+        <target-os>windows:<define>_CRT_SECURE_NO_WARNINGS
         <threading>single:<define>BOOST_LEAF_NO_THREADS
         <toolset>gcc:<cxxflags>"-Wno-delete-non-virtual-dtor -Wno-parentheses"
-        <toolset>clang:<cxxflags>"-Wno-dangling-else"
-        <toolset>darwin:<cxxflags>"-Wno-unused-variable -Wno-delete-non-virtual-dtor -Wno-non-virtual-dtor -Wno-dangling-else"
+        <toolset>clang:<cxxflags>"-Wno-unused-variable -Wno-delete-non-virtual-dtor -Wno-non-virtual-dtor -Wno-dangling-else"
+        <toolset>darwin:<cxxflags>"-Wno-unused-variable -Wno-delete-non-virtual-dtor -Wno-non-virtual-dtor -Wno-delete-non-abstract-non-virtual-dtor -Wno-dangling-else"
         <toolset>msvc:<cxxflags>"-wd 4267 -wd 4996 -wd 4244"
         <include>../../..
     ;
 
-compile _hpp_capture_test.cpp ;
 compile _hpp_common_test.cpp ;
 compile _hpp_config_test.cpp ;
 compile _hpp_context_test.cpp ;
+compile _hpp_diagnostics_test.cpp ;
 compile _hpp_error_test.cpp ;
 compile _hpp_exception_test.cpp ;
 compile _hpp_handle_errors_test.cpp ;
+compile _hpp_leaf_test.cpp ;
 compile _hpp_on_error_test.cpp ;
 compile _hpp_pred_test.cpp ;
 compile _hpp_result_test.cpp ;
 compile _hpp_to_variant_test.cpp ;
-compile _hpp_leaf_test.cpp ;
 
-run accumulate_basic_test.cpp ;
-run accumulate_nested_error_exception_test.cpp ;
-run accumulate_nested_error_result_test.cpp ;
-run accumulate_nested_new_error_exception_test.cpp ;
-run accumulate_nested_new_error_result_test.cpp ;
-run accumulate_nested_success_exception_test.cpp ;
-run accumulate_nested_success_result_test.cpp ;
-run BOOST_LEAF_AUTO_test.cpp ;
+run boost_exception_test.cpp ;
 run BOOST_LEAF_ASSIGN_test.cpp ;
+run BOOST_LEAF_AUTO_test.cpp ;
 run BOOST_LEAF_CHECK_test.cpp ;
-run boost_exception_test.cpp ;
 run capture_exception_async_test.cpp ;
 run capture_exception_result_async_test.cpp ;
+run capture_exception_result_unload_test.cpp ;
 run capture_exception_state_test.cpp ;
 run capture_exception_unload_test.cpp ;
 run capture_result_async_test.cpp ;
 run capture_result_state_test.cpp ;
 run capture_result_unload_test.cpp ;
+run context_activator_test.cpp ;
+run context_deduction_test.cpp ;
 run ctx_handle_all_test.cpp ;
 run ctx_handle_some_test.cpp ;
 run ctx_remote_handle_all_test.cpp ;
 run ctx_remote_handle_some_test.cpp ;
-run defer_basic_test.cpp ;
-run defer_nested_error_exception_test.cpp ;
-run defer_nested_error_result_test.cpp ;
-run defer_nested_new_error_exception_test.cpp ;
-run defer_nested_new_error_result_test.cpp ;
-run defer_nested_success_exception_test.cpp ;
-run defer_nested_success_result_test.cpp ;
-run diagnostic_info_test.cpp ;
-run diagnostic_info_test2.cpp ;
+run diagnostics_test1.cpp ;
+run diagnostics_test2.cpp ;
+run diagnostics_test3.cpp ;
+run diagnostics_test4.cpp ;
+run diagnostics_test5.cpp ;
 run e_errno_test.cpp ;
 run e_LastError_test.cpp ;
 run error_code_test.cpp ;
@@ -78,37 +75,56 @@ run error_id_test.cpp ;
 run exception_test.cpp ;
 run exception_to_result_test.cpp ;
 run function_traits_test.cpp ;
+run github_issue53_test.cpp ;
+run github_issue53x_test.cpp ;
 run handle_all_other_result_test.cpp ;
 run handle_all_test.cpp ;
 run handle_basic_test.cpp ;
 run handle_some_other_result_test.cpp ;
 run handle_some_test.cpp ;
-run match_test.cpp ;
 run match_member_test.cpp ;
+run match_test.cpp ;
 run match_value_test.cpp ;
 run multiple_errors_test.cpp ;
+run on_error_accumulate_basic_test.cpp ;
+run on_error_accumulate_nested_error_exception_test.cpp ;
+run on_error_accumulate_nested_error_result_test.cpp ;
+run on_error_accumulate_nested_new_error_exception_test.cpp ;
+run on_error_accumulate_nested_new_error_result_test.cpp ;
+run on_error_accumulate_nested_success_exception_test.cpp ;
+run on_error_accumulate_nested_success_result_test.cpp ;
+run on_error_defer_basic_test.cpp ;
+run on_error_defer_nested_error_exception_test.cpp ;
+run on_error_defer_nested_error_result_test.cpp ;
+run on_error_defer_nested_new_error_exception_test.cpp ;
+run on_error_defer_nested_new_error_result_test.cpp ;
+run on_error_defer_nested_success_exception_test.cpp ;
+run on_error_defer_nested_success_result_test.cpp ;
+run on_error_preload_basic_test.cpp ;
+run on_error_preload_exception_test.cpp ;
+run on_error_preload_nested_error_exception_test.cpp ;
+run on_error_preload_nested_error_result_test.cpp ;
+run on_error_preload_nested_new_error_exception_test.cpp ;
+run on_error_preload_nested_new_error_result_test.cpp ;
+run on_error_preload_nested_success_exception_test.cpp ;
+run on_error_preload_nested_success_result_test.cpp ;
 run optional_test.cpp ;
-run preload_basic_test.cpp ;
-run preload_exception_test.cpp ;
-run preload_nested_error_exception_test.cpp ;
-run preload_nested_error_result_test.cpp ;
-run preload_nested_new_error_exception_test.cpp ;
-run preload_nested_new_error_result_test.cpp ;
-run preload_nested_success_exception_test.cpp ;
-run preload_nested_success_result_test.cpp ;
+run parse_name_test.cpp ;
 run print_test.cpp ;
 run result_bad_result_test.cpp ;
 run result_implicit_conversion_test.cpp ;
 run result_load_test.cpp ;
+run result_print_test.cpp ;
 run result_ref_test.cpp ;
 run result_state_test.cpp ;
-run context_deduction_test.cpp ;
 run tls_array_alloc_test1.cpp ;
 run tls_array_alloc_test2.cpp ;
 run tls_array_alloc_test3.cpp ;
 run tls_array_test.cpp ;
 run to_variant_test.cpp ;
+run try_capture_all_test.cpp ;
 run try_catch_error_id_test.cpp ;
+run try_catch_system_error_test.cpp ;
 run try_catch_test.cpp ;
 run try_exception_and_result_test.cpp ;
 
@@ -125,6 +141,7 @@ compile-fail _compile-fail-arg_match_2.cpp ;
 compile-fail _compile-fail-arg_rvalue_ref.cpp ;
 compile-fail _compile-fail-BOOST_LEAF_ASSIGN.cpp ;
 compile-fail _compile-fail-BOOST_LEAF_AUTO.cpp ;
+compile-fail _compile-fail-diagnostic_details.cpp ;
 compile-fail _compile-fail-diagnostic_info.cpp ;
 compile-fail _compile-fail-error_info.cpp ;
 compile-fail _compile-fail-exception_1.cpp ;
@@ -134,16 +151,13 @@ compile-fail _compile-fail-result_1.cpp ;
 compile-fail _compile-fail-result_2.cpp ;
 compile-fail _compile-fail-result_3.cpp ;
 compile-fail _compile-fail-result_4.cpp ;
-compile-fail _compile-fail-verbose_diagnostic_info.cpp ;
 
-exe capture_in_exception : ../example/capture_in_exception.cpp : <threading>single:<build>no <exception-handling>off:<build>no ;
-exe capture_in_result : ../example/capture_in_result.cpp : <threading>single:<build>no <exception-handling>off:<build>no ;
-exe error_log : ../example/error_log.cpp : <exception-handling>off:<build>no ;
-exe error_trace : ../example/error_trace.cpp : <exception-handling>off:<build>no ;
+exe try_capture_all_exceptions : ../example/try_capture_all_exceptions.cpp : <threading>single:<build>no <exception-handling>off:<build>no <variant>leaf_debug_capture0:<build>no <variant>leaf_release_capture0:<build>no ;
+exe try_capture_all_result : ../example/try_capture_all_result.cpp : <threading>single:<build>no <variant>leaf_debug_capture0:<build>no <variant>leaf_release_capture0:<build>no <variant>leaf_debug_embedded:<build>no <variant>leaf_release_embedded:<build>no ;
+exe error_log : ../example/error_log.cpp ;
+exe error_trace : ../example/error_trace.cpp ;
 exe exception_to_result : ../example/exception_to_result.cpp : <exception-handling>off:<build>no ;
-# exe lua_callback_result : ../example/lua_callback_result.cpp : <exception-handling>off:<build>no ;
-# exe lua_callback_eh : ../example/lua_callback_eh.cpp : <exception-handling>off:<build>no ;
-exe print_file_eh : ../example/print_file/print_file_eh.cpp : <exception-handling>off:<build>no ;
-# exe print_file_outcome_result : ../example/print_file/print_file_outcome_result.cpp : <exception-handling>off:<build>no ;
-exe print_file_result : ../example/print_file/print_file_result.cpp : <exception-handling>off:<build>no ;
-exe print_half : ../example/print_half.cpp : <exception-handling>off:<build>no ;
+exe print_file_exceptions : ../example/print_file/print_file_exceptions.cpp : <exception-handling>off:<build>no ;
+exe print_file_leaf_result : ../example/print_file/print_file_leaf_result.cpp ;
+exe print_file_system_result : ../example/print_file/print_file_system_result.cpp : <variant>leaf_debug_embedded:<build>no <variant>leaf_release_embedded:<build>no ;
+exe print_half : ../example/print_half.cpp ;
diff --git a/test/_compile-fail-BOOST_LEAF_ASSIGN.cpp b/test/_compile-fail-BOOST_LEAF_ASSIGN.cpp
index effe3b2e..854f47f2 100644
--- a/test/_compile-fail-BOOST_LEAF_ASSIGN.cpp
+++ b/test/_compile-fail-BOOST_LEAF_ASSIGN.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -17,15 +16,6 @@ struct my_result
     explicit operator bool() const;
 };
 
-#if 0
-namespace boost { namespace leaf {
-    template <class T>
-    struct is_result_type<my_result<T>>: std::true_type
-    {
-    };
-} }
-#endif
-
 my_result<int> f();
 
 my_result<int> g()
diff --git a/test/_compile-fail-BOOST_LEAF_AUTO.cpp b/test/_compile-fail-BOOST_LEAF_AUTO.cpp
index 25be0027..4e0970cf 100644
--- a/test/_compile-fail-BOOST_LEAF_AUTO.cpp
+++ b/test/_compile-fail-BOOST_LEAF_AUTO.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -17,15 +16,6 @@ struct my_result
     explicit operator bool() const;
 };
 
-#if 0
-namespace boost { namespace leaf {
-    template <class T>
-    struct is_result_type<my_result<T>>: std::true_type
-    {
-    };
-} }
-#endif
-
 my_result<int> f();
 
 my_result<int> g()
diff --git a/test/_compile-fail-arg_boost_error_info_1.cpp b/test/_compile-fail-arg_boost_error_info_1.cpp
index b3bc8fcb..4ff8a7e2 100644
--- a/test/_compile-fail-arg_boost_error_info_1.cpp
+++ b/test/_compile-fail-arg_boost_error_info_1.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-arg_boost_error_info_2.cpp b/test/_compile-fail-arg_boost_error_info_2.cpp
index b3bc8fcb..4ff8a7e2 100644
--- a/test/_compile-fail-arg_boost_error_info_2.cpp
+++ b/test/_compile-fail-arg_boost_error_info_2.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-arg_catch_1.cpp b/test/_compile-fail-arg_catch_1.cpp
index 6d0b3f62..a3bdce06 100644
--- a/test/_compile-fail-arg_catch_1.cpp
+++ b/test/_compile-fail-arg_catch_1.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-arg_catch_2.cpp b/test/_compile-fail-arg_catch_2.cpp
index d1aaf276..6d99ac67 100644
--- a/test/_compile-fail-arg_catch_2.cpp
+++ b/test/_compile-fail-arg_catch_2.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-arg_match_1.cpp b/test/_compile-fail-arg_match_1.cpp
index 6ad721fc..85307a73 100644
--- a/test/_compile-fail-arg_match_1.cpp
+++ b/test/_compile-fail-arg_match_1.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-arg_match_2.cpp b/test/_compile-fail-arg_match_2.cpp
index 0d1ae1cb..fec38421 100644
--- a/test/_compile-fail-arg_match_2.cpp
+++ b/test/_compile-fail-arg_match_2.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-arg_rvalue_ref.cpp b/test/_compile-fail-arg_rvalue_ref.cpp
index 458cf4ba..44155227 100644
--- a/test/_compile-fail-arg_rvalue_ref.cpp
+++ b/test/_compile-fail-arg_rvalue_ref.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-verbose_diagnostic_info.cpp b/test/_compile-fail-diagnostic_details.cpp
similarity index 56%
rename from test/_compile-fail-verbose_diagnostic_info.cpp
rename to test/_compile-fail-diagnostic_details.cpp
index 61ecc650..e45dfbd5 100644
--- a/test/_compile-fail-verbose_diagnostic_info.cpp
+++ b/test/_compile-fail-diagnostic_details.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -7,6 +6,6 @@
 
 namespace leaf = boost::leaf;
 
-leaf::verbose_diagnostic_info f();
-leaf::verbose_diagnostic_info a = f();
-leaf::verbose_diagnostic_info b = a;
+leaf::diagnostic_details f();
+leaf::diagnostic_details a = f();
+leaf::diagnostic_details b = a;
diff --git a/test/_compile-fail-diagnostic_info.cpp b/test/_compile-fail-diagnostic_info.cpp
index 59df9664..15c24189 100644
--- a/test/_compile-fail-diagnostic_info.cpp
+++ b/test/_compile-fail-diagnostic_info.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-error_info.cpp b/test/_compile-fail-error_info.cpp
index 39d7267c..358cb82b 100644
--- a/test/_compile-fail-error_info.cpp
+++ b/test/_compile-fail-error_info.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-exception_1.cpp b/test/_compile-fail-exception_1.cpp
index 15fdc922..10b65d0c 100644
--- a/test/_compile-fail-exception_1.cpp
+++ b/test/_compile-fail-exception_1.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-exception_2.cpp b/test/_compile-fail-exception_2.cpp
index 540a6e61..0536c8e5 100644
--- a/test/_compile-fail-exception_2.cpp
+++ b/test/_compile-fail-exception_2.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-new_error.cpp b/test/_compile-fail-new_error.cpp
index 6aca1ff5..5995878c 100644
--- a/test/_compile-fail-new_error.cpp
+++ b/test/_compile-fail-new_error.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-result_1.cpp b/test/_compile-fail-result_1.cpp
index c4bec3df..fc29317e 100644
--- a/test/_compile-fail-result_1.cpp
+++ b/test/_compile-fail-result_1.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_compile-fail-result_2.cpp b/test/_compile-fail-result_2.cpp
index 1acdd95a..b67d67a6 100644
--- a/test/_compile-fail-result_2.cpp
+++ b/test/_compile-fail-result_2.cpp
@@ -1,4 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
+// Copyright 2018-2024 Emil Dotchevski and Reverge Studios, Inc.
 // Thanks @strager
 
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/test/_compile-fail-result_3.cpp b/test/_compile-fail-result_3.cpp
index 47bd73cf..611b5267 100644
--- a/test/_compile-fail-result_3.cpp
+++ b/test/_compile-fail-result_3.cpp
@@ -1,4 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
+// Copyright 2018-2024 Emil Dotchevski and Reverge Studios, Inc.
 // Thanks @strager
 
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
diff --git a/test/_compile-fail-result_4.cpp b/test/_compile-fail-result_4.cpp
index f25f6403..545eeb8b 100644
--- a/test/_compile-fail-result_4.cpp
+++ b/test/_compile-fail-result_4.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_hpp_capture_test.cpp b/test/_hpp_capture_test.cpp
index 4107de3e..99bd00e9 100644
--- a/test/_hpp_capture_test.cpp
+++ b/test/_hpp_capture_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_hpp_common_test.cpp b/test/_hpp_common_test.cpp
index b3afd016..fa52f4dc 100644
--- a/test/_hpp_common_test.cpp
+++ b/test/_hpp_common_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_hpp_config_test.cpp b/test/_hpp_config_test.cpp
index a517cafb..cc1017a6 100644
--- a/test/_hpp_config_test.cpp
+++ b/test/_hpp_config_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_hpp_context_test.cpp b/test/_hpp_context_test.cpp
index 667e244e..3b3ea326 100644
--- a/test/_hpp_context_test.cpp
+++ b/test/_hpp_context_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_hpp_diagnostics_test.cpp b/test/_hpp_diagnostics_test.cpp
new file mode 100644
index 00000000..613c28ee
--- /dev/null
+++ b/test/_hpp_diagnostics_test.cpp
@@ -0,0 +1,7 @@
+// Copyright 2018-2024 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/diagnostics.hpp>
+#include <boost/leaf/diagnostics.hpp>
+int main() { return 0; }
diff --git a/test/_hpp_error_test.cpp b/test/_hpp_error_test.cpp
index 1dc20a54..9e363d4c 100644
--- a/test/_hpp_error_test.cpp
+++ b/test/_hpp_error_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_hpp_exception_test.cpp b/test/_hpp_exception_test.cpp
index bda12919..c6365d0a 100644
--- a/test/_hpp_exception_test.cpp
+++ b/test/_hpp_exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_hpp_handle_errors_test.cpp b/test/_hpp_handle_errors_test.cpp
index 9e779013..8038f511 100644
--- a/test/_hpp_handle_errors_test.cpp
+++ b/test/_hpp_handle_errors_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_hpp_leaf_test.cpp b/test/_hpp_leaf_test.cpp
index 306c2bfe..6446d233 100644
--- a/test/_hpp_leaf_test.cpp
+++ b/test/_hpp_leaf_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_hpp_on_error_test.cpp b/test/_hpp_on_error_test.cpp
index 578f299a..bfa697f1 100644
--- a/test/_hpp_on_error_test.cpp
+++ b/test/_hpp_on_error_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_hpp_pred_test.cpp b/test/_hpp_pred_test.cpp
index e7826451..c2a5405a 100644
--- a/test/_hpp_pred_test.cpp
+++ b/test/_hpp_pred_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_hpp_result_test.cpp b/test/_hpp_result_test.cpp
index 3cf95d65..cf838cf7 100644
--- a/test/_hpp_result_test.cpp
+++ b/test/_hpp_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_hpp_to_variant_test.cpp b/test/_hpp_to_variant_test.cpp
index 3bedbe54..b79a9061 100644
--- a/test/_hpp_to_variant_test.cpp
+++ b/test/_hpp_to_variant_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/_test_ec.hpp b/test/_test_ec.hpp
index 77399c3c..cf0070e7 100644
--- a/test/_test_ec.hpp
+++ b/test/_test_ec.hpp
@@ -1,8 +1,7 @@
 #ifndef BOOST_LEAF_TEST_EC_HPP_INCLUDED
 #define BOOST_LEAF_TEST_EC_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -43,7 +42,7 @@ inline std::error_code make_error_code( errc_a code )
 
 template <int> struct e_errc_a { std::error_code value; };
 
-///////////////////////////////////
+////////////////////////////////////////
 
 enum class errc_b { b0 = 20, b1, b2, b3 };
 
@@ -80,7 +79,7 @@ inline std::error_code make_error_code( errc_b code )
 
 template <int> struct e_errc_b { std::error_code value; };
 
-///////////////////////////////////
+////////////////////////////////////////
 
 enum class cond_x { x00 = 30, x11, x22, x33 };
 
@@ -115,13 +114,13 @@ inline std::error_category const & cat_cond_x()
             switch( cond_x(cond) )
             {
                 case cond_x::x00:
-                    return code==make_error_code(errc_a::a0) || code==make_error_code(errc_b::b0);
+                    return code == make_error_code(errc_a::a0) || code == make_error_code(errc_b::b0);
                 case cond_x::x11:
-                    return code==make_error_code(errc_a::a1) || code==make_error_code(errc_b::b1);
+                    return code == make_error_code(errc_a::a1) || code == make_error_code(errc_b::b1);
                 case cond_x::x22:
-                    return code==make_error_code(errc_a::a2) || code==make_error_code(errc_b::b2);
+                    return code == make_error_code(errc_a::a2) || code == make_error_code(errc_b::b2);
                 case cond_x::x33:
-                    return code==make_error_code(errc_a::a3) || code==make_error_code(errc_b::b3);
+                    return code == make_error_code(errc_a::a3) || code == make_error_code(errc_b::b3);
                 default:
                     return false;
             }
@@ -138,7 +137,7 @@ inline std::error_condition make_error_condition( cond_x cond )
 
 template <int> struct e_cond_x { cond_x value; };
 
-///////////////////////////////////
+////////////////////////////////////////
 
 enum class cond_y { y03 = 40, y12, y21, y30 };
 
@@ -173,13 +172,13 @@ inline std::error_category const & cat_cond_y()
             switch( cond_y(cond) )
             {
                 case cond_y::y03:
-                    return code==make_error_code(errc_a::a0) || code==make_error_code(errc_b::b0);
+                    return code == make_error_code(errc_a::a0) || code == make_error_code(errc_b::b0);
                 case cond_y::y12:
-                    return code==make_error_code(errc_a::a1) || code==make_error_code(errc_b::b1);
+                    return code == make_error_code(errc_a::a1) || code == make_error_code(errc_b::b1);
                 case cond_y::y21:
-                    return code==make_error_code(errc_a::a2) || code==make_error_code(errc_b::b2);
+                    return code == make_error_code(errc_a::a2) || code == make_error_code(errc_b::b2);
                 case cond_y::y30:
-                    return code==make_error_code(errc_a::a3) || code==make_error_code(errc_b::b3);
+                    return code == make_error_code(errc_a::a3) || code == make_error_code(errc_b::b3);
                 default:
                     return false;
             }
diff --git a/test/_test_res.hpp b/test/_test_res.hpp
index 089f85ae..26cb3bcd 100644
--- a/test/_test_res.hpp
+++ b/test/_test_res.hpp
@@ -1,8 +1,7 @@
 #ifndef BOOST_LEAF_TEST_RES_HPP_INCLUDED
 #define BOOST_LEAF_TEST_RES_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -41,16 +40,16 @@ class test_res
     }
     explicit operator bool() const noexcept
     {
-        return which_==variant::value;
+        return which_ == variant::value;
     }
     T const & value() const
     {
-        BOOST_LEAF_ASSERT(which_==variant::value);
+        BOOST_LEAF_ASSERT(which_ == variant::value);
         return value_;
     }
     E const & error() const
     {
-        BOOST_LEAF_ASSERT(which_==variant::error);
+        BOOST_LEAF_ASSERT(which_ == variant::error);
         return error_;
     }
 };
@@ -84,15 +83,15 @@ class test_res<void, E>
     }
     explicit operator bool() const noexcept
     {
-        return which_==variant::value;
+        return which_ == variant::value;
     }
     void value() const
     {
-        BOOST_LEAF_ASSERT(which_==variant::value);
+        BOOST_LEAF_ASSERT(which_ == variant::value);
     }
     E const & error() const
     {
-        BOOST_LEAF_ASSERT(which_==variant::error);
+        BOOST_LEAF_ASSERT(which_ == variant::error);
         return error_;
     }
 };
diff --git a/test/boost_exception_test.cpp b/test/boost_exception_test.cpp
index 1ed1bb97..318a71f8 100644
--- a/test/boost_exception_test.cpp
+++ b/test/boost_exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -38,8 +37,8 @@ int main()
 {
     static_assert(std::is_same<test_info, decltype(std::declval<leaf::match<test_info, 42>>().matched)>::value, "handler_argument_traits deduction bug");
 
-    using tr = leaf::leaf_detail::handler_argument_traits<leaf::match<test_info, 42>>;
-    static_assert(std::is_same<void, tr::error_type>::value, "handler_argument_traits deduction bug");
+    using tr = leaf::detail::handler_argument_traits<leaf::match<test_info, 42>>;
+    static_assert(std::is_same<leaf::leaf_detail_mp11::mp_list<>, tr::context_types>::value, "handler_argument_traits deduction bug");
 
     {
         int r = leaf::try_catch(
diff --git a/test/capture_exception_async_test.cpp b/test/capture_exception_async_test.cpp
index 57a5ea7b..21d681fd 100644
--- a/test/capture_exception_async_test.cpp
+++ b/test/capture_exception_async_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -20,7 +19,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,13 +40,13 @@ 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);
+    BOOST_LEAF_ASSERT(task_count > 0);
     std::vector<fut_info> fut;
     std::generate_n( std::back_inserter(fut), task_count,
         [=]
@@ -58,7 +57,11 @@ 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_capture_all(
+                        [&]
+                        {
+                            return f(a, b, res);
+                        } );
                 } ) };
         } );
     return fut;
@@ -66,9 +69,20 @@ std::vector<fut_info> launch_tasks( int task_count, F f )
 
 int main()
 {
+    int const task_count = 100;
     int received_a, received_b;
+
+    auto task =
+        []( int a, int b, int res )
+        {
+            if( res >= 0 )
+                return res;
+            else
+                leaf::throw_exception(info<1>{a}, info<2>{b}, info<3>{});
+        };
+
     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,15 +94,7 @@ int main()
         } );
 
     {
-        std::vector<fut_info> fut = launch_tasks<decltype(error_handlers)>(
-            100,
-            []( int a, int b, int res )
-            {
-                if( res >= 0 )
-                    return res;
-                else
-                    throw leaf::exception(info<1>{a}, info<2>{b}, info<3>{});
-            } );
+        std::vector<fut_info> fut = launch_tasks(task_count, task);
 
         for( auto & f : fut )
         {
@@ -98,9 +104,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 )
@@ -108,22 +112,14 @@ int main()
             else
             {
                 BOOST_TEST_EQ(r, -1);
-                BOOST_TEST_EQ(received_a, f.a);
-                BOOST_TEST_EQ(received_b, f.b);
+                BOOST_TEST_EQ(f.a, received_a);
+                BOOST_TEST_EQ(f.b, received_b);
             }
         }
     }
 
     {
-        std::vector<fut_info> fut = launch_tasks<decltype(error_handlers)>(
-            100,
-            []( int a, int b, int res )
-            {
-                if( res >= 0 )
-                    return res;
-                else
-                    throw leaf::exception(info<1>{a}, info<2>{b}, info<3>{});
-            } );
+        std::vector<fut_info> fut = launch_tasks(task_count, task);
 
         for( auto & f : fut )
         {
@@ -137,9 +133,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
                         {
@@ -152,8 +146,8 @@ int main()
             else
             {
                 BOOST_TEST_EQ(r, -1);
-                BOOST_TEST_EQ(received_a, f.a);
-                BOOST_TEST_EQ(received_b, f.b);
+                BOOST_TEST_EQ(f.a, received_a);
+                BOOST_TEST_EQ(f.b, received_b);
             }
         }
     }
diff --git a/test/capture_exception_result_async_test.cpp b/test/capture_exception_result_async_test.cpp
index 48df5ead..6498380d 100644
--- a/test/capture_exception_result_async_test.cpp
+++ b/test/capture_exception_result_async_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -20,9 +19,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 +42,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 +56,11 @@ 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_capture_all(
+                        [&]
+                        {
+                            return f(a, b, res);
+                        } );
                 } ) };
         } );
     return fut;
@@ -65,7 +68,18 @@ std::vector<fut_info> launch_tasks( int task_count, F f )
 
 int main()
 {
+    int const task_count = 100;
     int received_a, received_b;
+
+    auto task =
+        []( int a, int b, int res ) -> leaf::result<int>
+        {
+            if( res >= 0 )
+                return res;
+            else
+                return leaf::new_error( info<1>{a}, info<2>{b}, info<3>{} );
+        };
+
     auto error_handlers = std::make_tuple(
         [&]( info<1> const & x1, info<2> const & x2, info<4> const & )
         {
@@ -79,27 +93,17 @@ int main()
         } );
 
     {
-        std::vector<fut_info> fut = launch_tasks<decltype(error_handlers)>(
-            100,
-            []( int a, int b, int res ) -> leaf::result<int>
-            {
-                if( res >= 0 )
-                    return res;
-                else
-                    return leaf::new_error( info<1>{a}, info<2>{b}, info<3>{} );
-            } );
+        std::vector<fut_info> fut = launch_tasks(task_count, task);
 
         for( auto & f : fut )
         {
             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 )
@@ -107,22 +111,14 @@ int main()
             else
             {
                 BOOST_TEST_EQ(r, -1);
-                BOOST_TEST_EQ(received_a, f.a);
-                BOOST_TEST_EQ(received_b, f.b);
+                BOOST_TEST_EQ(f.a, received_a);
+                BOOST_TEST_EQ(f.b, received_b);
             }
         }
     }
 
     {
-        std::vector<fut_info> fut = launch_tasks<decltype(error_handlers)>(
-            100,
-            []( int a, int b, int res ) -> leaf::result<int>
-            {
-                if( res >= 0 )
-                    return res;
-                else
-                    return leaf::new_error( info<1>{a}, info<2>{b}, info<3>{} );
-            } );
+        std::vector<fut_info> fut = launch_tasks(task_count, task);
 
         for( auto & f : fut )
         {
@@ -134,11 +130,9 @@ int main()
                     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 )
                         {
@@ -151,8 +145,8 @@ int main()
             else
             {
                 BOOST_TEST_EQ(r, -1);
-                BOOST_TEST_EQ(received_a, f.a);
-                BOOST_TEST_EQ(received_b, f.b);
+                BOOST_TEST_EQ(f.a, received_a);
+                BOOST_TEST_EQ(f.b, received_b);
             }
         }
     }
diff --git a/test/capture_exception_result_unload_test.cpp b/test/capture_exception_result_unload_test.cpp
new file mode 100644
index 00000000..4085089d
--- /dev/null
+++ b/test/capture_exception_result_unload_test.cpp
@@ -0,0 +1,188 @@
+// Copyright 2018-2024 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 defined(BOOST_LEAF_NO_EXCEPTIONS) || !BOOST_LEAF_CFG_CAPTURE
+
+#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>
+#   include <boost/leaf/on_error.hpp>
+#   include <boost/leaf/exception.hpp>
+#endif
+
+#include "_test_ec.hpp"
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+template <int> struct info { int value; };
+
+template <class F>
+void test( F f )
+{
+    {
+        int c=0;
+        auto r = f();
+        leaf::try_handle_all(
+            [&r]() -> leaf::result<void>
+            {
+                BOOST_LEAF_CHECK(std::move(r));
+                return { };
+            },
+            [&c]( info<1> const & x )
+            {
+                BOOST_TEST_EQ(x.value, 1);
+                BOOST_TEST_EQ(c, 0);
+                c = 1;
+            },
+            [&c]
+            {
+                BOOST_TEST_EQ(c, 0);
+                c = 2;
+            } );
+        BOOST_TEST_EQ(c, 1);
+    }
+
+    {
+        int c=0;
+        auto r = f();
+        leaf::try_handle_all(
+            [&r]() -> leaf::result<void>
+            {
+                BOOST_LEAF_CHECK(std::move(r));
+                return { };
+            },
+            [&c]( info<2> const & x )
+            {
+                BOOST_TEST_EQ(x.value, 2);
+                BOOST_TEST_EQ(c, 0);
+                c = 1;
+            },
+            [&c]
+            {
+                BOOST_TEST_EQ(c, 0);
+                c = 2;
+            } );
+        BOOST_TEST_EQ(c, 2);
+    }
+
+    {
+        auto r = f();
+        int what = leaf::try_handle_all(
+            [&r]() -> leaf::result<int>
+            {
+                BOOST_LEAF_CHECK(std::move(r));
+                return 0;
+            },
+            []( info<1> const & x )
+            {
+                BOOST_TEST_EQ(x.value, 1);
+                return 1;
+            },
+            []
+            {
+                return 2;
+            } );
+        BOOST_TEST_EQ(what, 1);
+    }
+
+    {
+        auto r = f();
+        int what = leaf::try_handle_all(
+            [&r]() -> leaf::result<int>
+            {
+                BOOST_LEAF_CHECK(std::move(r));
+                return 0;
+            },
+            []( info<2> const & x )
+            {
+                BOOST_TEST_EQ(x.value, 2);
+                return 1;
+            },
+            []
+            {
+                return 2;
+            } );
+        BOOST_TEST_EQ(what, 2);
+    }
+}
+
+int main()
+{
+    test( []
+    {
+        return leaf::try_capture_all(
+            []() -> int
+            {
+                leaf::throw_exception(errc_a::a0, info<1>{1}, info<3>{3});
+            } );
+    } );
+
+    test( []
+    {
+        return leaf::try_capture_all(
+            []() -> void
+            {
+                leaf::throw_exception(errc_a::a0, info<1>{1}, info<3>{3});
+            } );
+    } );
+
+    test( []
+    {
+        return leaf::try_capture_all(
+            []() -> int
+            {
+                auto load = leaf::on_error(errc_a::a0, info<1>{1}, info<3>{3});
+                leaf::throw_exception();
+            } );
+    } );
+
+    test( []
+    {
+        return leaf::try_capture_all(
+            []() -> void
+            {
+                auto load = leaf::on_error(errc_a::a0, info<1>{1}, info<3>{3});
+                leaf::throw_exception();
+            } );
+    } );
+
+    test( []
+    {
+        return leaf::try_capture_all(
+            []() -> int
+            {
+                auto load = leaf::on_error(errc_a::a0, info<1>{1}, info<3>{3});
+                throw std::exception();
+            } );
+    } );
+
+    test( []
+    {
+        return leaf::try_capture_all(
+            []() -> void
+            {
+                auto load = leaf::on_error(errc_a::a0, info<1>{1}, info<3>{3});
+                throw std::exception();
+            } );
+    } );
+
+    return boost::report_errors();
+}
+
+#endif
diff --git a/test/capture_exception_state_test.cpp b/test/capture_exception_state_test.cpp
index 9e3b9cfa..5983e5cb 100644
--- a/test/capture_exception_state_test.cpp
+++ b/test/capture_exception_state_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -20,18 +19,23 @@ 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>
 #endif
 
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
 #include "lightweight_test.hpp"
 
 namespace leaf = boost::leaf;
 
 int count = 0;
 
-template <int>
+template <int N>
 struct info
 {
     info() noexcept
@@ -48,45 +52,55 @@ struct info
     {
         --count;
     }
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, info const & )
+    {
+        return os << "info<" << N << "> instance";
+    }
 };
 
 int main()
 {
-    auto error_handlers = std::make_tuple(
-        []( info<1>, info<3> )
-        {
-            return 1;
-        },
-        []
-        {
-            return 2;
-        } );
-    BOOST_TEST_EQ(count, 0);
-    std::exception_ptr ep;
-    try
     {
-        leaf::capture(
-            leaf::make_shared_context(error_handlers),
+        leaf::result<int> r = leaf::try_capture_all(
+            []() -> int
+            {
+                leaf::throw_exception(info<1>{}, info<3>{});
+            });
+        BOOST_TEST_EQ(count, 2);
+
+    #if BOOST_LEAF_CFG_STD_STRING
+        {
+            std::ostringstream st;
+            st << r;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS )
+            {
+                BOOST_TEST_NE(s.find("info<1> instance"), s.npos);
+                BOOST_TEST_NE(s.find("info<3> instance"), s.npos);
+            }
+        }
+    #endif
+
+        int ret = leaf::try_catch(
+            [&]
+            {
+                return r.value();
+            },
+            []( info<1>, info<3> )
+            {
+                return 42;
+            },
             []
             {
-                throw leaf::exception(info<1>{}, info<3>{});
+                return -42;
             } );
-        BOOST_TEST(false);
-    }
-    catch(...)
-    {
-        ep = std::current_exception();
+        BOOST_TEST_EQ(ret, 42);
     }
-    BOOST_TEST_EQ(count, 2);
-    int r = leaf::try_catch(
-        [&]() -> int
-        {
-            std::rethrow_exception(ep);
-        },
-        error_handlers );
-    BOOST_TEST_EQ(r, 1);
-    ep = std::exception_ptr();
     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 c784c831..811dda9d 100644
--- a/test/capture_exception_unload_test.cpp
+++ b/test/capture_exception_unload_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -20,43 +19,29 @@ 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>
+#   include <boost/leaf/exception.hpp>
 #endif
 
+#include "_test_ec.hpp"
 #include "lightweight_test.hpp"
 
 namespace leaf = boost::leaf;
 
 template <int> struct info { int value; };
 
-template <class... E, class F>
-void test( F f_ )
+template <class F>
+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();
-            }
-        };
-
     {
         int c=0;
-        auto ep = f();
+        auto r = f();
         leaf::try_catch(
-            [&ep]
+            [&r]
             {
-                return std::rethrow_exception(ep);
+                (void) r.value();
             },
             [&c]( info<1> const & x )
             {
@@ -74,11 +59,11 @@ void test( F f_ )
 
     {
         int c=0;
-        auto ep = f();
+        auto r = f();
         leaf::try_catch(
-            [&ep]
+            [&r]
             {
-                return std::rethrow_exception(ep);
+                (void) r.value();
             },
             [&c]( info<2> const & x )
             {
@@ -95,11 +80,12 @@ void test( F f_ )
     }
 
     {
-        auto ep = f();
+        auto 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 +100,12 @@ void test( F f_ )
     }
 
     {
-        auto ep = f();
+        auto r = f();
         int what = leaf::try_catch(
-            [&ep]
+            [&r]
             {
-                std::rethrow_exception(ep); return 0;
+                (void) r.value();
+                return 0;
             },
             []( info<2> const & x )
             {
@@ -131,83 +118,68 @@ void test( F f_ )
             } );
         BOOST_TEST_EQ(what, 2);
     }
+}
 
+int main()
+{
+    test( []
     {
-        auto ep = f();
-        bool what = leaf::try_catch(
-            [&ep]
-            {
-                std::rethrow_exception(ep); return true;
-            },
-            []( info<1> const & x, info<2> const & )
+        return leaf::try_capture_all(
+            []() -> int
             {
-                return true;
-            },
-            []( info<1> const & x, info<3> const & y )
-            {
-                BOOST_TEST_EQ(x.value, 1);
-                BOOST_TEST_EQ(y.value, 3);
-                return false;
-            },
-            []( info<1> const & x )
-            {
-                return true;
-            },
-            []
-            {
-                return true;
+                leaf::throw_exception(errc_a::a0, info<1>{1}, info<3>{3});
             } );
-        BOOST_TEST(!what);
-    }
+    } );
 
+    test( []
     {
-        auto ep = f();
-        bool what = leaf::try_catch(
-            [&ep]
+        return leaf::try_capture_all(
+            []() -> void
             {
-                std::rethrow_exception(ep); return false;
-            },
-            []( info<1> const & x, info<2> const & )
+                leaf::throw_exception(errc_a::a0, info<1>{1}, info<3>{3});
+            } );
+    } );
+
+    test( []
+    {
+        return leaf::try_capture_all(
+            []() -> int
             {
-                return false;
-            },
-            []( info<1> const & x, info<3> const & y )
+                auto load = leaf::on_error(errc_a::a0, info<1>{1}, info<3>{3});
+                leaf::throw_exception();
+            } );
+    } );
+
+    test( []
+    {
+        return leaf::try_capture_all(
+            []() -> void
             {
-                BOOST_TEST_EQ(x.value, 1);
-                BOOST_TEST_EQ(y.value, 3);
-                return true;
-            },
-            []( info<1> const & x )
+                auto load = leaf::on_error(errc_a::a0, info<1>{1}, info<3>{3});
+                leaf::throw_exception();
+            } );
+    } );
+
+    test( []
+    {
+        return leaf::try_capture_all(
+            []() -> int
             {
-                return false;
-            },
-            []
+                auto load = leaf::on_error(errc_a::a0, info<1>{1}, info<3>{3});
+                throw std::exception();
+            } );
+    } );
+
+    test( []
+    {
+        return leaf::try_capture_all(
+            []() -> void
             {
-                return false;
+                auto load = leaf::on_error(errc_a::a0, info<1>{1}, info<3>{3});
+                throw std::exception();
             } );
-        BOOST_TEST(what);
-    }
-}
+    } );
 
-int main()
-{
-    test<info<1>, info<2>, info<3>>(
-        []
-        {
-            throw leaf::exception(info<1>{1}, info<3>{3}); // Derives from leaf::leaf::error_id
-        } );
-    test<info<1>, info<2>, info<3>>(
-        []
-        {
-            auto load = leaf::on_error( info<1>{1}, info<3>{3} );
-            throw leaf::exception(); // Derives from leaf::leaf::error_id
-        } );
-    test<info<1>, info<2>, info<3>>(
-        []
-        {
-            auto load = leaf::on_error( info<1>{1}, info<3>{3} );
-            throw std::exception(); // Does not derive from leaf::leaf::error_id
-        } );
     return boost::report_errors();
 }
 
diff --git a/test/capture_result_async_test.cpp b/test/capture_result_async_test.cpp
index c6166dc5..8067a0df 100644
--- a/test/capture_result_async_test.cpp
+++ b/test/capture_result_async_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -20,7 +19,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 +42,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 +56,11 @@ 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_capture_all(
+                        [&]() -> leaf::result<int>
+                        {
+                            return f(a, b, res);
+                        } );
                 } ) };
         } );
     return fut;
@@ -66,9 +68,20 @@ std::vector<fut_info> launch_tasks( int task_count, F f )
 
 int main()
 {
+    int const task_count = 100;
     int received_a, received_b;
+
+    auto task =
+        []( int a, int b, int res ) -> leaf::result<int>
+        {
+            if( res >= 0 )
+                return res;
+            else
+                return leaf::new_error( info<1>{a}, info<2>{b}, info<3>{} );
+        };
+
     auto error_handlers = std::make_tuple(
-        [&received_a, &received_b]( info<1> const & x1, info<2> const & x2, info<4> const & x4 )
+        [&]( info<1> const & x1, info<2> const & x2, info<4> const & )
         {
             received_a = x1.value;
             received_b = x2.value;
@@ -80,26 +93,19 @@ int main()
         } );
 
     {
-        std::vector<fut_info> fut = launch_tasks<decltype(error_handlers)>(
-            100,
-            []( int a, int b, int res ) -> leaf::result<int>
-            {
-                if( res >= 0 )
-                    return res;
-                else
-                    return leaf::new_error( info<1>{a}, info<2>{b}, info<3>{} );
-            } );
+        std::vector<fut_info> fut = launch_tasks(task_count, task);
 
         for( auto & f : fut )
         {
             f.fut.wait();
+            received_a = received_b = 0;
             int r = leaf::try_handle_all(
                 [&]
                 {
                     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,19 +120,12 @@ int main()
     }
 
     {
-        std::vector<fut_info> fut = launch_tasks<decltype(error_handlers)>(
-            100,
-            []( int a, int b, int res ) -> leaf::result<int>
-            {
-                if( res >= 0 )
-                    return res;
-                else
-                    return leaf::new_error( info<1>{a}, info<2>{b}, info<3>{} );
-            } );
+        std::vector<fut_info> fut = launch_tasks(task_count, task);
 
         for( auto & f : fut )
         {
             f.fut.wait();
+            received_a = received_b = 0;
             int r = leaf::try_handle_all(
                 [&]
                 {
@@ -135,8 +134,6 @@ int main()
                     return leaf::try_handle_some(
                         [&]
                         {
-                            // 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();
                         },
                         []( leaf::error_info const & err )
diff --git a/test/capture_result_state_test.cpp b/test/capture_result_state_test.cpp
index 1d116231..41125aa9 100644
--- a/test/capture_result_state_test.cpp
+++ b/test/capture_result_state_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -20,18 +19,22 @@ 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
 
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
 #include "lightweight_test.hpp"
 
 namespace leaf = boost::leaf;
 
 int count = 0;
 
-template <int>
+template <int N>
 struct info
 {
     info() noexcept
@@ -48,36 +51,52 @@ struct info
     {
         --count;
     }
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, info const & )
+    {
+        return os << "info<" << N << "> instance";
+    }
 };
 
 int main()
 {
-    auto error_handlers = std::make_tuple(
-        []( info<1>, info<3> )
-        {
-            return 42;
-        },
-        []
-        {
-            return -42;
-        } );
-
     {
-        auto r = leaf::capture(
-            leaf::make_shared_context(error_handlers),
+        leaf::result<int> r = leaf::try_capture_all(
             []() -> leaf::result<int>
             {
                 return leaf::new_error( info<1>{}, info<3>{} );
             } );
         BOOST_TEST_EQ(count, 2);
 
-        int answer = leaf::try_handle_all(
-            [&r]
+#if BOOST_LEAF_CFG_STD_STRING
+        {
+            std::ostringstream st;
+            st << r;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS )
+            {
+                BOOST_TEST_NE(s.find("info<1> instance"), s.npos);
+                BOOST_TEST_NE(s.find("info<3> instance"), s.npos);
+            }
+        }
+#endif
+
+        int ret = leaf::try_handle_all(
+            [&]
             {
                 return std::move(r);
             },
-            error_handlers);
-        BOOST_TEST_EQ(answer, 42);
+            []( info<1>, info<3> )
+            {
+                return 42;
+            },
+            []
+            {
+                return -42;
+            } );
+        BOOST_TEST_EQ(ret, 42);
     }
     BOOST_TEST_EQ(count, 0);
 
diff --git a/test/capture_result_unload_test.cpp b/test/capture_result_unload_test.cpp
index add325c0..91ac63e9 100644
--- a/test/capture_result_unload_test.cpp
+++ b/test/capture_result_unload_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -20,9 +19,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 "_test_ec.hpp"
@@ -126,8 +125,7 @@ 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_capture_all(
             []() -> leaf::result<int>
             {
                 return leaf::new_error(errc_a::a0, info<1>{1}, info<3>{3});
@@ -136,14 +134,33 @@ 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_capture_all(
             []() -> leaf::result<void>
             {
                 return leaf::new_error(errc_a::a0, info<1>{1}, info<3>{3});
             } );
      } );
 
+    test( []
+    {
+        return leaf::try_capture_all(
+            []() -> leaf::result<int>
+            {
+                auto load = leaf::on_error(errc_a::a0, info<1>{1}, info<3>{3});
+                return leaf::new_error();
+            } );
+     } );
+
+    test( []
+    {
+        return leaf::try_capture_all(
+            []() -> leaf::result<void>
+            {
+                auto load = leaf::on_error(errc_a::a0, info<1>{1}, info<3>{3});
+                return leaf::new_error();
+            } );
+     } );
+
     return boost::report_errors();
 }
 
diff --git a/test/context_activator_test.cpp b/test/context_activator_test.cpp
index 5639c067..357eaca1 100644
--- a/test/context_activator_test.cpp
+++ b/test/context_activator_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -33,7 +32,7 @@ int main()
     auto error_handlers = std::make_tuple(
         []( info<1> x )
         {
-            BOOST_TEST(x.value==1);
+            BOOST_TEST_EQ(x.value, 1);
             return 1;
         },
         []
@@ -45,13 +44,13 @@ int main()
         [&]
         {
             auto ctx = leaf::make_context(error_handlers);
-            leaf::result<int> r;
+            leaf::result<int> r1;
             {
                 auto active_context = activate_context(ctx);
-                r = f(ctx);
+                r1 = f(ctx);
             }
-            ctx.propagate(r.error());
-            return r;
+            ctx.unload(r1.error());
+            return r1;
         },
         error_handlers );
     BOOST_TEST_EQ(r, 1);
diff --git a/test/context_deduction_test.cpp b/test/context_deduction_test.cpp
index 893f5832..f9908c11 100644
--- a/test/context_deduction_test.cpp
+++ b/test/context_deduction_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -9,7 +8,7 @@
 #   include <boost/leaf/config.hpp>
 #   include <boost/leaf/context.hpp>
 #   include <boost/leaf/pred.hpp>
-#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/diagnostics.hpp>
 #endif
 
 #include "_test_ec.hpp"
@@ -37,10 +36,10 @@ typename unwrap_tuple<typename std::decay<decltype(std::declval<typename leaf::c
     return 0;
 }
 
-template <class T, class U>
+template <class... T, class U>
 void test( U * )
 {
-    static_assert(std::is_same<T,U>::value,"context deduction");
+    static_assert(std::is_same<std::tuple<T...>, U>::value,"context deduction");
 }
 
 template <int> struct info { int value; };
@@ -71,87 +70,84 @@ namespace std
 
 void not_called_on_purpose()
 {
-    test< std::tuple<> >( expd([]( leaf::error_info const & ){ }) );
-
-    test< std::tuple<info<1>> >( expd([]( info<1> ){ }) );
-    test< std::tuple<info<1>> >( expd([]( info<1> const ){ }) );
-    test< std::tuple<info<1>> >( expd([]( info<1> const & ){ }) );
-    test< std::tuple<info<1>> >( expd([]( info<1>, leaf::error_info const & ){ }) );
-
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1> ){ }, []( info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1> ){ }, []( info<1>, info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, info<2> ){ }, []( info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, info<2> ){ }, []( info<1>, info<2> ){ }) );
-
-    test< std::tuple<info<1>,info<2>> >( expd([]( leaf::error_info const &, info<1> ){ }, []( info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( leaf::error_info const &, info<1> ){ }, []( info<1>, info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( leaf::error_info const &, info<1>, info<2> ){ }, []( info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( leaf::error_info const &, info<1>, info<2> ){ }, []( info<1>, info<2> ){ }) );
-
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, leaf::error_info const & ){ }, []( info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, leaf::error_info const & ){ }, []( info<1>, info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, leaf::error_info const &, info<2> ){ }, []( info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, leaf::error_info const &, info<2> ){ }, []( info<1>, info<2> ){ }) );
-
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1> ){ }, []( leaf::error_info const &, info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1> ){ }, []( leaf::error_info const &, info<1>, info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, info<2> ){ }, []( leaf::error_info const &, info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, info<2> ){ }, []( leaf::error_info const &, info<1>, info<2> ){ }) );
-
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1> ){ }, []( info<2>, leaf::error_info const & ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1> ){ }, []( info<1>, leaf::error_info const &, info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, info<2> ){ }, []( info<2>, leaf::error_info const & ){ }) );
-    test< std::tuple<info<1>,info<2>> >( expd([]( info<1>, info<2> ){ }, []( info<1>, leaf::error_info const &, info<2> ){ }) );
-
-    test< std::tuple<info<1>,info<2>,info<3>> >( expd([]( info<1> ){ }, []( info<2> ){ }, []( info<3> ){ }) );
-    test< std::tuple<info<1>,info<2>,info<3>> >( expd([]( info<1> ){ }, []( info<1>, info<2> ){ }, []( info<1>, info<3> ){ }) );
-    test< std::tuple<info<1>,info<2>,info<3>> >( expd([]( info<1> ){ }, []( info<1>, info<2> ){ }, []( info<1>, info<3> ){ }) );
-    test< std::tuple<info<1>,info<2>,info<3>> >( expd([]( info<1>, info<2> ){ }, []( info<2> ){ }, []( info<3> ){ }) );
-    test< std::tuple<info<1>,info<2>,info<3>> >( expd([]( info<1>, info<2> ){ }, []( info<2> ){ }, []( info<3> ){ }) );
-    test< std::tuple<info<1>,info<2>,info<3>> >( expd([]( info<1> ){ }, []( info<2> ){ }, []( info<3>, info<2> ){ }) );
-    test< std::tuple<info<1>,info<2>,info<3>> >( expd([]( info<1> ){ }, []( info<2> ){ }, []( info<3>, info<2> ){ }) );
-    test< std::tuple<info<1>,info<3>,info<2>> >( expd([]( info<1>, info<3> ){ }, []( info<2> ){ }, []( info<3> ){ }) );
-    test< std::tuple<info<1>,info<3>,info<2>> >( expd([]( info<1>, info<3> ){ }, []( info<2> ){ }, []( info<3> ){ }) );
-    test< std::tuple<info<1>,info<2>,info<3>> >( expd([]( info<1> ){ }, []( info<2>, info<3> ){ }, []( info<3> ){ }) );
-    test< std::tuple<info<1>,info<2>,info<3>> >( expd([]( info<1> ){ }, []( info<2>, info<3> ){ }, []( info<3> ){ }) );
-
-    test< std::tuple<my_error_code> >( expd([]( leaf::match<my_error_code, my_error_code::error1> ){ }) );
+    test<>( expd([]( leaf::error_info const & ){ }) );
+
+    test<info<1>>( expd([]( info<1> ){ }) );
+    test<info<1>>( expd([]( info<1> const ){ }) );
+    test<info<1>>( expd([]( info<1> const & ){ }) );
+    test<info<1>>( expd([]( info<1>, leaf::error_info const & ){ }) );
+
+    test<info<1>, info<2>>( expd([]( info<1> ){ }, []( info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( info<1> ){ }, []( info<1>, info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( info<1>, info<2> ){ }, []( info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( info<1>, info<2> ){ }, []( info<1>, info<2> ){ }) );
+
+    test<info<1>, info<2>>( expd([]( leaf::error_info const &, info<1> ){ }, []( info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( leaf::error_info const &, info<1> ){ }, []( info<1>, info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( leaf::error_info const &, info<1>, info<2> ){ }, []( info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( leaf::error_info const &, info<1>, info<2> ){ }, []( info<1>, info<2> ){ }) );
+
+    test<info<1>, info<2>>( expd([]( info<1>, leaf::error_info const & ){ }, []( info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( info<1>, leaf::error_info const & ){ }, []( info<1>, info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( info<1>, leaf::error_info const &, info<2> ){ }, []( info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( info<1>, leaf::error_info const &, info<2> ){ }, []( info<1>, info<2> ){ }) );
+
+    test<info<1>, info<2>>( expd([]( info<1> ){ }, []( leaf::error_info const &, info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( info<1> ){ }, []( leaf::error_info const &, info<1>, info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( info<1>, info<2> ){ }, []( leaf::error_info const &, info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( info<1>, info<2> ){ }, []( leaf::error_info const &, info<1>, info<2> ){ }) );
+
+    test<info<1>, info<2>>( expd([]( info<1> ){ }, []( info<2>, leaf::error_info const & ){ }) );
+    test<info<1>, info<2>>( expd([]( info<1> ){ }, []( info<1>, leaf::error_info const &, info<2> ){ }) );
+    test<info<1>, info<2>>( expd([]( info<1>, info<2> ){ }, []( info<2>, leaf::error_info const & ){ }) );
+    test<info<1>, info<2>>( expd([]( info<1>, info<2> ){ }, []( info<1>, leaf::error_info const &, info<2> ){ }) );
+
+    test<info<1>, info<2>, info<3>>( expd([]( info<1> ){ }, []( info<2> ){ }, []( info<3> ){ }) );
+    test<info<1>, info<2>, info<3>>( expd([]( info<1> ){ }, []( info<1>, info<2> ){ }, []( info<1>, info<3> ){ }) );
+    test<info<1>, info<2>, info<3>>( expd([]( info<1> ){ }, []( info<1>, info<2> ){ }, []( info<1>, info<3> ){ }) );
+    test<info<1>, info<2>, info<3>>( expd([]( info<1>, info<2> ){ }, []( info<2> ){ }, []( info<3> ){ }) );
+    test<info<1>, info<2>, info<3>>( expd([]( info<1>, info<2> ){ }, []( info<2> ){ }, []( info<3> ){ }) );
+    test<info<1>, info<2>, info<3>>( expd([]( info<1> ){ }, []( info<2> ){ }, []( info<3>, info<2> ){ }) );
+    test<info<1>, info<2>, info<3>>( expd([]( info<1> ){ }, []( info<2> ){ }, []( info<3>, info<2> ){ }) );
+    test<info<1>, info<3>, info<2>>( expd([]( info<1>, info<3> ){ }, []( info<2> ){ }, []( info<3> ){ }) );
+    test<info<1>, info<3>, info<2>>( expd([]( info<1>, info<3> ){ }, []( info<2> ){ }, []( info<3> ){ }) );
+    test<info<1>, info<2>, info<3>>( expd([]( info<1> ){ }, []( info<2>, info<3> ){ }, []( info<3> ){ }) );
+    test<info<1>, info<2>, info<3>>( expd([]( info<1> ){ }, []( info<2>, info<3> ){ }, []( info<3> ){ }) );
+
+    test<my_error_code>( expd([]( leaf::match<my_error_code, my_error_code::error1> ){ }) );
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
-    test< std::tuple<std::error_code> >( expd([]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ){ }) );
+    test<std::error_code>( expd([]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ){ }) );
 #endif
 
-    test< std::tuple<info<1>> >( expd([]( leaf::match_value<info<1>,42> ){ }) );
+    test<info<1>>( expd([]( leaf::match_value<info<1>,42> ){ }) );
 
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
-    test< std::tuple<std::error_code> >( expd([]( leaf::match<leaf::condition<my_error_condition>, my_error_condition::cond1> ){ }) );
+    test<std::error_code>( expd([]( leaf::match<leaf::condition<my_error_condition>, my_error_condition::cond1> ){ }) );
 #if __cplusplus >= 201703L
-    test< std::tuple<std::error_code> >( expd([]( leaf::match<std::error_code, my_error_code::error1> ){ }) );
-    test< std::tuple<std::error_code> >( expd([]( leaf::match<std::error_code, my_error_condition::cond1> ){ }) );
+    test<std::error_code>( expd([]( leaf::match<std::error_code, my_error_code::error1> ){ }) );
+    test<std::error_code>( expd([]( leaf::match<std::error_code, my_error_condition::cond1> ){ }) );
 #endif
 #endif
 
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
-    test< std::tuple<info<1>> >( expd([]( leaf::catch_<std::exception>, info<1> ){ }) );
+    test<info<1>>( expd([]( leaf::catch_<std::exception>, info<1> ){ }) );
 #endif
 
-    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<info<1>, info<2>, info<3>>( expd([]( info<1> const *, info<2> ){ }, []( info<1>, info<3> const * ){ }) );
+    test<info<1>, info<2>, info<3>>( expd([]( info<1> const, info<2> ){ }, []( info<1> const *, info<3> ){ }) );
 
-#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<info<1>, info<2>, leaf::e_source_location>( expd([]( info<1>, info<2>, leaf::diagnostic_info const & ){ }, []( info<1>, info<2> ){ }) );
+#if BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE
+    test<info<1>, info<2>, leaf::e_source_location, leaf::detail::dynamic_allocator>( expd([]( info<1>, info<2>, leaf::diagnostic_details 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> ){ }) );
+    test<info<1>, info<2>, leaf::e_source_location>( expd([]( info<1>, info<2>, leaf::diagnostic_details const & ){ }, []( info<1>, info<2> ){ }) );
 #endif
 
     {
         auto error_handlers = std::make_tuple(
             []( info<2> ) { },
             []( info<3> ) { } );
-        test< std::tuple<info<1>, info<2>, info<3>, info<4>, info<5>>>( expd(
+        test<info<1>, info<2>, info<3>, info<4>, info<5>>( expd(
             []( info<1> ) { },
             error_handlers,
             []( info<4>, info<5> ) { } ) );
@@ -165,7 +161,7 @@ void not_called_on_purpose()
             []( info<2> ) { },
             []( info<3> ) { },
             error_handlers1 );
-        test< std::tuple<info<1>, info<2>, info<3>, info<4>, info<5>, info<6>>>( expd(
+        test<info<1>, info<2>, info<3>, info<4>, info<5>, info<6>>( expd(
             []( info<1> ) { },
             error_handlers2,
             []( info<4>, info<5> ) { },
diff --git a/test/ctx_handle_all_test.cpp b/test/ctx_handle_all_test.cpp
index 1357a8b6..15ed9d49 100644
--- a/test/ctx_handle_all_test.cpp
+++ b/test/ctx_handle_all_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -7,7 +6,7 @@
 #   include "leaf.hpp"
 #else
 #   include <boost/leaf/context.hpp>
-#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/diagnostics.hpp>
 #   include <boost/leaf/result.hpp>
 #endif
 
@@ -31,7 +30,7 @@ leaf::result<int> f( Ctx & ctx )
 
 int main()
 {
-    leaf::context<info<1>, leaf::verbose_diagnostic_info const &> ctx;
+    leaf::context<info<1>, leaf::diagnostic_details const &> ctx;
 
     {
         leaf::result<int> r1 = f(ctx);
@@ -41,10 +40,10 @@ int main()
             r1.error(),
             []( info<1> x )
             {
-                BOOST_TEST(x.value==1);
+                BOOST_TEST_EQ(x.value, 1);
                 return 1;
             },
-            []( leaf::verbose_diagnostic_info const & info )
+            []( leaf::diagnostic_details const & info )
             {
                 std::cout << info;
                 return 2;
diff --git a/test/ctx_handle_some_test.cpp b/test/ctx_handle_some_test.cpp
index 099ed215..1c43a720 100644
--- a/test/ctx_handle_some_test.cpp
+++ b/test/ctx_handle_some_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -40,7 +39,7 @@ int main()
             r1.error(),
             []( info<1> x ) -> leaf::result<int>
             {
-                BOOST_TEST(x.value==1);
+                BOOST_TEST_EQ(x.value, 1);
                 return 1;
             },
             [&r1]
diff --git a/test/ctx_remote_handle_all_test.cpp b/test/ctx_remote_handle_all_test.cpp
index 71ceb345..05f6f61d 100644
--- a/test/ctx_remote_handle_all_test.cpp
+++ b/test/ctx_remote_handle_all_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -7,7 +6,7 @@
 #   include "leaf.hpp"
 #else
 #   include <boost/leaf/context.hpp>
-#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/diagnostics.hpp>
 #   include <boost/leaf/result.hpp>
 #endif
 
@@ -34,10 +33,10 @@ int main()
     auto handlers = std::make_tuple(
         []( info<1> x )
         {
-            BOOST_TEST(x.value==1);
+            BOOST_TEST_EQ(x.value, 1);
             return 1;
         },
-        []( leaf::verbose_diagnostic_info const & info )
+        []( leaf::diagnostic_details const & info )
         {
             std::cout << info;
             return 2;
@@ -49,6 +48,8 @@ int main()
         leaf::result<int> r1 = f(ctx);
         BOOST_TEST(!r1);
 
+        std::cout << "ctx contents:" << std::endl << ctx;
+
         int r2 = ctx.handle_error<int>(
             r1.error(),
             std::move(handlers));
diff --git a/test/ctx_remote_handle_some_test.cpp b/test/ctx_remote_handle_some_test.cpp
index fd5f8bad..f41e1ed9 100644
--- a/test/ctx_remote_handle_some_test.cpp
+++ b/test/ctx_remote_handle_some_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -33,7 +32,7 @@ int main()
     auto handle_error = std::make_tuple(
         []( info<1> x )
         {
-            BOOST_TEST(x.value==1);
+            BOOST_TEST_EQ(x.value, 1);
             return 1;
         },
         []( leaf::error_info const & ei )
diff --git a/test/diagnostic_info_test.cpp b/test/diagnostic_info_test.cpp
deleted file mode 100644
index cbc9afe0..00000000
--- a/test/diagnostic_info_test.cpp
+++ /dev/null
@@ -1,375 +0,0 @@
-// Copyright 2018-2022 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)
-
-#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
-#   include "leaf.hpp"
-#else
-#   include <boost/leaf/config.hpp>
-#   include <boost/leaf/handle_errors.hpp>
-#   include <boost/leaf/result.hpp>
-#   include <boost/leaf/common.hpp>
-#endif
-
-#include "lightweight_test.hpp"
-#include <sstream>
-
-namespace leaf = boost::leaf;
-
-enum class enum_class_payload
-{
-    value
-};
-
-template <int A>
-struct unexpected_test
-{
-    int value;
-};
-
-struct my_exception:
-    virtual std::exception
-{
-    char const * what() const noexcept
-    {
-        return "my_exception";
-    }
-};
-
-struct printable_payload
-{
-    friend std::ostream & operator<<( std::ostream & os, printable_payload const & x )
-    {
-        return os << "printed printable_payload";
-    }
-};
-
-struct non_printable_payload
-{
-};
-
-struct printable_info_printable_payload
-{
-    printable_payload value;
-
-    friend std::ostream & operator<<( std::ostream & os, printable_info_printable_payload const & x )
-    {
-        return os << "*** printable_info_printable_payload " << x.value << " ***";
-    }
-};
-
-struct printable_info_non_printable_payload
-{
-    non_printable_payload value;
-
-    friend std::ostream & operator<<( std::ostream & os, printable_info_non_printable_payload const & x )
-    {
-        return os << "*** printable_info_non_printable_payload ***";
-    }
-};
-
-struct non_printable_info_printable_payload
-{
-    printable_payload value;
-};
-
-struct non_printable_info_non_printable_payload
-{
-    non_printable_payload value;
-};
-
-int main()
-{
-    leaf::try_handle_all(
-        []() -> leaf::result<void>
-        {
-            return BOOST_LEAF_NEW_ERROR(
-                printable_info_printable_payload(),
-                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} );
-        },
-        [](
-            leaf::e_source_location,
-            printable_info_printable_payload,
-            printable_info_non_printable_payload,
-            non_printable_info_printable_payload,
-            non_printable_info_non_printable_payload,
-            enum_class_payload,
-            leaf::e_errno,
-            leaf::error_info const & unmatched )
-        {
-#if BOOST_LEAF_CFG_STD_STRING
-            std::ostringstream st;
-            st << unmatched;
-            std::string s = st.str();
-            BOOST_TEST_NE(s.find("leaf::error_info: Error ID = "), s.npos);
-            std::cout << s;
-#endif
-        },
-        []()
-        {
-            BOOST_ERROR("Bad error dispatch");
-        } );
-
-    std::cout << __LINE__  << " ----\n";
-
-    leaf::try_handle_all(
-        []() -> leaf::result<void>
-        {
-            return BOOST_LEAF_NEW_ERROR(
-                printable_info_printable_payload(),
-                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} );
-        },
-        [](
-            leaf::e_source_location,
-            printable_info_printable_payload,
-            printable_info_non_printable_payload,
-            non_printable_info_printable_payload,
-            non_printable_info_non_printable_payload,
-            enum_class_payload,
-            leaf::e_errno,
-            leaf::diagnostic_info const & unmatched )
-        {
-#if BOOST_LEAF_CFG_STD_STRING
-            std::ostringstream st;
-            st << unmatched;
-            std::string s = st.str();
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-            BOOST_TEST_NE(s.find("leaf::diagnostic_info for Error ID = "), s.npos);
-            BOOST_TEST_NE(s.find("e_source_location"), s.npos);
-            BOOST_TEST_NE(s.find("*** printable_info_printable_payload printed printable_payload ***"), s.npos);
-            BOOST_TEST_NE(s.find("*** printable_info_non_printable_payload ***"), s.npos);
-            BOOST_TEST_NE(s.find(": printed printable_payload"), s.npos);
-            BOOST_TEST_NE(s.find(": {Non-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);
-#endif
-            std::cout << s;
-#endif
-        },
-        []()
-        {
-            BOOST_ERROR("Bad error dispatch");
-        } );
-
-    std::cout << __LINE__  << " ----\n";
-
-    leaf::try_handle_all(
-        []() -> leaf::result<void>
-        {
-            return BOOST_LEAF_NEW_ERROR(
-                printable_info_printable_payload(),
-                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} );
-        },
-        [](
-            leaf::e_source_location,
-            printable_info_printable_payload,
-            printable_info_non_printable_payload,
-            non_printable_info_printable_payload,
-            non_printable_info_non_printable_payload,
-            enum_class_payload,
-            leaf::e_errno,
-            leaf::verbose_diagnostic_info const & di )
-        {
-#if BOOST_LEAF_CFG_STD_STRING
-            std::ostringstream st;
-            st << di;
-            std::string s = st.str();
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-            BOOST_TEST_NE(s.find("leaf::verbose_diagnostic_info for Error ID = "), s.npos);
-            BOOST_TEST_NE(s.find("e_source_location"), s.npos);
-            BOOST_TEST_NE(s.find("*** printable_info_printable_payload printed printable_payload ***"), s.npos);
-            BOOST_TEST_NE(s.find("*** printable_info_non_printable_payload ***"), s.npos);
-            BOOST_TEST_NE(s.find(": printed printable_payload"), s.npos);
-            BOOST_TEST_NE(s.find(": {Non-Printable}"), s.npos);
-            BOOST_TEST_NE(s.find("enum_class"), s.npos);
-            BOOST_TEST_NE(s.find("Unhandled error objects:"), s.npos);
-            BOOST_TEST_NE(s.find("unexpected_test<1>"), s.npos);
-            BOOST_TEST_NE(s.find("unexpected_test<2>"), s.npos);
-            BOOST_TEST_NE(s.find(": 1"), s.npos);
-            BOOST_TEST_NE(s.find(": 2"), s.npos);
-#else
-            BOOST_TEST_NE(s.find("leaf::verbose_diagnostic_info requires #define BOOST_LEAF_CFG_DIAGNOSTICS 1"), s.npos);
-            BOOST_TEST_NE(s.find("leaf::error_info: Error ID = "), s.npos);
-#endif
-            std::cout << s;
-#endif
-        },
-        []()
-        {
-            BOOST_ERROR("Bad error dispatch");
-        } );
-
-    ///////////////////////////////////
-
-#ifndef BOOST_LEAF_NO_EXCEPTIONS
-
-    std::cout << __LINE__  << " ----\n";
-
-    leaf::try_catch(
-        []
-        {
-            BOOST_LEAF_THROW_EXCEPTION( my_exception(),
-                printable_info_printable_payload(),
-                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} );
-        },
-        [](
-            leaf::e_source_location,
-            printable_info_printable_payload,
-            printable_info_non_printable_payload,
-            non_printable_info_printable_payload,
-            non_printable_info_non_printable_payload,
-            enum_class_payload,
-            leaf::e_errno,
-            leaf::error_info const & unmatched )
-        {
-#if BOOST_LEAF_CFG_STD_STRING
-            std::ostringstream st;
-            st << unmatched;
-            std::string s = st.str();
-            BOOST_TEST_NE(s.find("leaf::error_info: Error ID = "), s.npos);
-            BOOST_TEST_NE(s.find("Exception dynamic type: "), s.npos);
-            BOOST_TEST_NE(s.find("std::exception::what(): my_exception"), s.npos);
-            std::cout << s;
-#endif
-        } );
-
-    std::cout << __LINE__  << " ----\n";
-
-    leaf::try_catch(
-        []
-        {
-            BOOST_LEAF_THROW_EXCEPTION( my_exception(),
-                printable_info_printable_payload(),
-                printable_info_non_printable_payload(),
-                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} );
-        },
-        [](
-            leaf::e_source_location,
-            printable_info_printable_payload,
-            printable_info_non_printable_payload,
-            non_printable_info_printable_payload,
-            non_printable_info_non_printable_payload,
-            enum_class_payload,
-            leaf::e_errno,
-            leaf::diagnostic_info const & unmatched )
-        {
-#if BOOST_LEAF_CFG_STD_STRING
-            std::ostringstream st;
-            st << unmatched;
-            std::string s = st.str();
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-            BOOST_TEST_NE(s.find("leaf::diagnostic_info for Error ID = "), s.npos);
-            BOOST_TEST_NE(s.find("Exception dynamic type: "), s.npos);
-            BOOST_TEST_NE(s.find("std::exception::what(): my_exception"), s.npos);
-            BOOST_TEST_NE(s.find("e_source_location"), s.npos);
-            BOOST_TEST_NE(s.find("*** printable_info_printable_payload printed printable_payload ***"), s.npos);
-            BOOST_TEST_NE(s.find("*** printable_info_non_printable_payload ***"), s.npos);
-            BOOST_TEST_NE(s.find(": printed printable_payload"), s.npos);
-            BOOST_TEST_NE(s.find(": {Non-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);
-            BOOST_TEST_NE(s.find("Exception dynamic type: "), s.npos);
-            BOOST_TEST_NE(s.find("std::exception::what(): my_exception"), s.npos);
-#endif
-            std::cout << s;
-#endif
-        } );
-
-    std::cout << __LINE__  << " ----\n";
-
-    leaf::try_catch(
-        []
-        {
-            BOOST_LEAF_THROW_EXCEPTION( my_exception(),
-                printable_info_printable_payload(),
-                printable_info_non_printable_payload(),
-                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} );
-        },
-        [](
-            leaf::e_source_location,
-            printable_info_printable_payload,
-            printable_info_non_printable_payload,
-            non_printable_info_printable_payload,
-            non_printable_info_non_printable_payload,
-            enum_class_payload,
-            leaf::e_errno,
-            leaf::verbose_diagnostic_info const & di )
-        {
-#if BOOST_LEAF_CFG_STD_STRING
-            std::ostringstream st;
-            st << di;
-            std::string s = st.str();
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-            BOOST_TEST_NE(s.find("leaf::verbose_diagnostic_info for Error ID = "), s.npos);
-            BOOST_TEST_NE(s.find("Exception dynamic type: "), s.npos);
-            BOOST_TEST_NE(s.find("std::exception::what(): my_exception"), s.npos);
-            BOOST_TEST_NE(s.find("e_source_location"), s.npos);
-            BOOST_TEST_NE(s.find("*** printable_info_printable_payload printed printable_payload ***"), s.npos);
-            BOOST_TEST_NE(s.find("*** printable_info_non_printable_payload ***"), s.npos);
-            BOOST_TEST_NE(s.find(": printed printable_payload"), s.npos);
-            BOOST_TEST_NE(s.find(": {Non-Printable}"), s.npos);
-            BOOST_TEST_NE(s.find("enum_class_payload"), s.npos);
-            BOOST_TEST_NE(s.find("Unhandled error objects:"), s.npos);
-            BOOST_TEST_NE(s.find("unexpected_test<1>"), s.npos);
-            BOOST_TEST_NE(s.find("unexpected_test<2>"), s.npos);
-            BOOST_TEST_NE(s.find(": 1"), s.npos);
-            BOOST_TEST_NE(s.find(": 2"), s.npos);
-#else
-            BOOST_TEST_NE(s.find("leaf::verbose_diagnostic_info requires #define BOOST_LEAF_CFG_DIAGNOSTICS 1"), s.npos);
-            BOOST_TEST_NE(s.find("leaf::error_info: Error ID = "), s.npos);
-            BOOST_TEST_NE(s.find("Exception dynamic type: "), s.npos);
-            BOOST_TEST_NE(s.find("std::exception::what(): my_exception"), s.npos);
-#endif
-            std::cout << s;
-#endif
-        } );
-
-#endif
-
-    return boost::report_errors();
-}
diff --git a/test/diagnostics_test1.cpp b/test/diagnostics_test1.cpp
new file mode 100644
index 00000000..9ec183e5
--- /dev/null
+++ b/test/diagnostics_test1.cpp
@@ -0,0 +1,795 @@
+// Copyright 2018-2024 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)
+
+#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
+#   include "leaf.hpp"
+#else
+#   include <boost/leaf/config.hpp>
+#   include <boost/leaf/diagnostics.hpp>
+#   include <boost/leaf/result.hpp>
+#   include <boost/leaf/common.hpp>
+#endif
+
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
+#include <algorithm>
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+enum class enum_class
+{
+    enum0,
+    enum1
+};
+
+template <int A>
+struct unexpected_test
+{
+    int value;
+};
+
+struct my_exception:
+    virtual std::exception
+{
+    char const * what() const noexcept
+    {
+        return "my_exception what";
+    }
+};
+
+struct printable_value
+{
+    friend std::ostream & operator<<( std::ostream & os, printable_value const & )
+    {
+        return os << "printed printable_value";
+    }
+};
+
+struct non_printable_value
+{
+};
+
+struct printable_info_printable_value
+{
+    printable_value value;
+
+    friend std::ostream & operator<<( std::ostream & os, printable_info_printable_value const & x )
+    {
+        return os << x.value;
+    }
+};
+
+struct printable_info_non_printable_value
+{
+    non_printable_value value;
+
+    friend std::ostream & operator<<( std::ostream & os, printable_info_non_printable_value const & )
+    {
+        return os << "*** printable_info non_printable_value ***";
+    }
+};
+
+class non_printable_info_printable_value
+{
+public:
+    printable_value value;
+};
+
+struct non_printable_info_non_printable_value
+{
+    non_printable_value value;
+};
+
+struct hidden_printable_info_printable_value
+{
+    printable_value value;
+
+    friend std::ostream & operator<<( std::ostream & os, hidden_printable_info_printable_value const & x )
+    {
+        return os << x.value << " ***";
+    }
+};
+
+struct hidden_non_printable_info_printable_value
+{
+    printable_value value;
+};
+
+struct value_nullptr
+{
+    char const * value = nullptr;
+};
+
+struct value_ptr
+{
+    char const * value = "\"value\"";
+};
+
+namespace boost { namespace leaf {
+
+template <> struct show_in_diagnostics<hidden_printable_info_printable_value>: std::false_type { };
+template <> struct show_in_diagnostics<hidden_non_printable_info_printable_value>: std::false_type { };
+
+} }
+
+#if BOOST_LEAF_CFG_STD_STRING
+namespace
+{
+    void remove_value(std::string & s, std::string const & search_prefix, std::string const & search_suffix)
+    {
+        auto search_prefix_size = search_prefix.size();
+        auto s1 = s.find(search_prefix);
+        if( s1 == s.npos )
+            return;
+        auto search_prefix_end = s1 + search_prefix_size;
+        auto s2 = s.find(search_suffix, search_prefix_end);
+        if( s2 == s.npos )
+            return;
+        s.replace(search_prefix_end, s2 - search_prefix_end, "<removed variance>");
+    }
+
+    void remove_variance(std::string & s)
+    {
+        s.erase(std::remove(s.begin(), s.end(), '\r'), s.end());
+        remove_value(s, " reported at ", "\n");
+        remove_value(s, "Caught:" BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER, ": \"my_exception what\"");
+    }
+
+    bool cmp(std::string a, std::string const & b) noexcept
+    {
+        remove_variance(a);
+        auto i = a.begin();
+        auto j = b.begin();
+        for( auto e = i + std::min(a.size(), b.size()); i != e; ++i, ++j )
+            if( *i != *j )
+            {
+                std::cout <<
+                    "a =\n----\n" << a << "----\n\n"
+                    "b =\n----\n" << b << "----\n\n"
+                    "Difference immediately after:\n" << std::string(a.begin(), i) << '\n';
+                return false;
+            }
+        return i == a.end() && j == b.end();
+    }
+}
+#endif
+
+#define BOOST_LEAF_DIAGNOSTIC_INFO_NO_BOOST_LEAF_CFG_DIAGNOSTICS "\nboost::leaf::diagnostic_info N/A due to BOOST_LEAF_CFG_DIAGNOSTICS=0"
+#define BOOST_LEAF_DIAGNOSTIC_DETAILS_NO_BOOST_LEAF_CFG_CAPTURE "\nboost::leaf::diagnostic_details N/A due to BOOST_LEAF_CFG_CAPTURE=0"
+#define BOOST_LEAF_DIAGNOSTIC_DETAILS_NO_BOOST_LEAF_CFG_DIAGNOSTICS "\nboost::leaf::diagnostic_details N/A due to BOOST_LEAF_CFG_DIAGNOSTICS=0"
+
+int main()
+{
+    std::cout << __LINE__  << " ---- result / error_info / no e_source_location\n";
+    leaf::try_handle_all(
+        []() -> leaf::result<void>
+        {
+            return BOOST_LEAF_NEW_ERROR(
+                value_nullptr(),
+                value_ptr(),
+                42,
+                printable_info_printable_value(),
+                printable_info_non_printable_value(),
+                non_printable_info_printable_value(),
+                non_printable_info_non_printable_value(),
+                hidden_printable_info_printable_value(),
+                hidden_non_printable_info_printable_value(),
+                enum_class::enum0,
+                leaf::e_errno{ENOENT} );
+        },
+        [](
+            value_nullptr,
+            value_ptr,
+            int,
+            printable_info_printable_value,
+            printable_info_non_printable_value,
+            non_printable_info_printable_value,
+            non_printable_info_non_printable_value,
+            hidden_printable_info_printable_value,
+            hidden_non_printable_info_printable_value,
+            enum_class,
+            leaf::e_errno,
+            leaf::error_info const & unmatched )
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            std::ostringstream st;
+            st << unmatched;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            BOOST_TEST(cmp(s,
+                "Error with serial #1"
+                "\n"
+            ));
+
+#endif
+        },
+        []()
+        {
+            BOOST_ERROR("Bad error dispatch");
+        } );
+
+    std::cout << __LINE__  << " ---- result / error_info\n";
+    leaf::try_handle_all(
+        []() -> leaf::result<void>
+        {
+            return BOOST_LEAF_NEW_ERROR(
+                value_nullptr(),
+                value_ptr(),
+                42,
+                printable_info_printable_value(),
+                printable_info_non_printable_value(),
+                non_printable_info_printable_value(),
+                non_printable_info_non_printable_value(),
+                hidden_printable_info_printable_value(),
+                hidden_non_printable_info_printable_value(),
+                enum_class::enum0,
+                leaf::e_errno{ENOENT} );
+        },
+        [](
+            value_nullptr,
+            value_ptr,
+            int,
+            leaf::e_source_location,
+            printable_info_printable_value,
+            printable_info_non_printable_value,
+            non_printable_info_printable_value,
+            non_printable_info_non_printable_value,
+            hidden_printable_info_printable_value,
+            hidden_non_printable_info_printable_value,
+            enum_class,
+            leaf::e_errno,
+            leaf::error_info const & unmatched )
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            std::ostringstream st;
+            st << unmatched;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            BOOST_TEST(cmp(s,
+                "Error with serial #2 reported at <removed variance>"
+                "\n"
+            ));
+
+#endif
+        },
+        []()
+        {
+            BOOST_ERROR("Bad error dispatch");
+        } );
+
+    std::cout << __LINE__  << " ---- result / diagnostic_info\n";
+    leaf::try_handle_all(
+        []() -> leaf::result<void>
+        {
+            return BOOST_LEAF_NEW_ERROR(
+                value_nullptr(),
+                value_ptr(),
+                42,
+                printable_info_printable_value(),
+                printable_info_non_printable_value(),
+                non_printable_info_printable_value(),
+                non_printable_info_non_printable_value(),
+                hidden_printable_info_printable_value(),
+                hidden_non_printable_info_printable_value(),
+                enum_class::enum1,
+                leaf::e_errno{ENOENT} );
+        },
+        [](
+            value_nullptr,
+            value_ptr,
+            int,
+            leaf::e_source_location,
+            printable_info_printable_value,
+            printable_info_non_printable_value,
+            non_printable_info_printable_value,
+            non_printable_info_non_printable_value,
+            hidden_printable_info_printable_value,
+            hidden_non_printable_info_printable_value,
+            enum_class,
+            leaf::e_errno,
+            leaf::diagnostic_info const & unmatched )
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            std::ostringstream st;
+            st << unmatched;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS )
+                BOOST_TEST(cmp(s,
+                    "Error with serial #3 reported at <removed variance>"
+                    "\nCaught:"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "value_nullptr: <nullptr>"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "value_ptr: \"value\""
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "int: 42"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_printable_value: printed printable_value"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_non_printable_value: *** printable_info non_printable_value ***"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_printable_value: printed printable_value"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_non_printable_value"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "enum_class: 1"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "boost::leaf::e_errno: 2, \"No such file or directory\""
+                    "\n"
+                ));
+            else
+                BOOST_TEST(cmp(s,
+                    "Error with serial #3 reported at <removed variance>"
+                    BOOST_LEAF_DIAGNOSTIC_INFO_NO_BOOST_LEAF_CFG_DIAGNOSTICS
+                    "\n"
+                ));
+#endif
+        },
+        []()
+        {
+            BOOST_ERROR("Bad error dispatch");
+        } );
+
+    std::cout << __LINE__  << " ---- result / diagnostic_details\n";
+    leaf::try_handle_all(
+        []() -> leaf::result<void>
+        {
+            return BOOST_LEAF_NEW_ERROR(
+                value_nullptr(),
+                value_ptr(),
+                42,
+                printable_info_printable_value(),
+                printable_info_non_printable_value(),
+                non_printable_info_printable_value(),
+                non_printable_info_non_printable_value(),
+                hidden_printable_info_printable_value(),
+                hidden_non_printable_info_printable_value(),
+                unexpected_test<1>{1},
+                unexpected_test<2>{2},
+                enum_class::enum0,
+                leaf::e_errno{ENOENT} );
+        },
+        [](
+            value_nullptr,
+            value_ptr,
+            int,
+            leaf::e_source_location,
+            printable_info_printable_value,
+            printable_info_non_printable_value,
+            non_printable_info_printable_value,
+            non_printable_info_non_printable_value,
+            hidden_printable_info_printable_value,
+            hidden_non_printable_info_printable_value,
+            enum_class,
+            leaf::e_errno,
+            leaf::diagnostic_details const & di )
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            std::ostringstream st;
+            st << di;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS )
+                if( BOOST_LEAF_CFG_CAPTURE )
+                    BOOST_TEST(cmp(s,
+                        "Error with serial #4 reported at <removed variance>"
+                        "\nCaught:"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "value_nullptr: <nullptr>"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "value_ptr: \"value\""
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "int: 42"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_printable_value: printed printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_non_printable_value: *** printable_info non_printable_value ***"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_printable_value: printed printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_non_printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "enum_class: 0"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "boost::leaf::e_errno: 2, \"No such file or directory\""
+                        "\nDiagnostic details:"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "unexpected_test<1>: 1"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "unexpected_test<2>: 2"
+                        "\n"
+                    ));
+                else
+                    BOOST_TEST(cmp(s,
+                        "Error with serial #4 reported at <removed variance>"
+                        "\nCaught:"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "value_nullptr: <nullptr>"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "value_ptr: \"value\""
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "int: 42"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_printable_value: printed printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_non_printable_value: *** printable_info non_printable_value ***"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_printable_value: printed printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_non_printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "enum_class: 0"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "boost::leaf::e_errno: 2, \"No such file or directory\""
+                        BOOST_LEAF_DIAGNOSTIC_DETAILS_NO_BOOST_LEAF_CFG_CAPTURE
+                        "\n"
+                    ));
+            else
+                BOOST_TEST(cmp(s,
+                    "Error with serial #4 reported at <removed variance>"
+                    BOOST_LEAF_DIAGNOSTIC_DETAILS_NO_BOOST_LEAF_CFG_DIAGNOSTICS
+                    "\n"
+                ));
+#endif
+        },
+        []()
+        {
+            BOOST_ERROR("Bad error dispatch");
+        } );
+
+    std::cout << __LINE__  << " ---- result / diagnostic_details / nothing caught\n";
+    leaf::try_handle_all(
+        []() -> leaf::result<void>
+        {
+            return BOOST_LEAF_NEW_ERROR(
+                value_nullptr(),
+                value_ptr(),
+                42,
+                printable_info_printable_value(),
+                printable_info_non_printable_value(),
+                non_printable_info_printable_value(),
+                non_printable_info_non_printable_value(),
+                hidden_printable_info_printable_value(),
+                hidden_non_printable_info_printable_value(),
+                unexpected_test<1>{1},
+                unexpected_test<2>{2},
+                enum_class::enum0,
+                leaf::e_errno{ENOENT} );
+        },
+        []( leaf::diagnostic_details const & di )
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            std::ostringstream st;
+            st << di;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS )
+                if( BOOST_LEAF_CFG_CAPTURE )
+                    BOOST_TEST(cmp(s,
+                        "Error with serial #5 reported at <removed variance>"
+                        "\nDiagnostic details:"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "value_nullptr: <nullptr>"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "value_ptr: \"value\""
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "int: 42"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_printable_value: printed printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_non_printable_value: *** printable_info non_printable_value ***"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_printable_value: printed printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_non_printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "unexpected_test<1>: 1"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "unexpected_test<2>: 2"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "enum_class: 0"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "boost::leaf::e_errno: 2, \"No such file or directory\""
+                        "\n"
+                    ));
+                else
+                    BOOST_TEST(cmp(s,
+                        "Error with serial #5 reported at <removed variance>"
+                        BOOST_LEAF_DIAGNOSTIC_DETAILS_NO_BOOST_LEAF_CFG_CAPTURE
+                        "\n"
+                    ));
+            else
+                BOOST_TEST(cmp(s,
+                    "Error with serial #5 reported at <removed variance>"
+                    BOOST_LEAF_DIAGNOSTIC_DETAILS_NO_BOOST_LEAF_CFG_DIAGNOSTICS
+                    "\n"
+                ));
+#endif
+        },
+        []()
+        {
+            BOOST_ERROR("Bad error dispatch");
+        } );
+
+    ////////////////////////////////////////
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+
+    std::cout << __LINE__  << " ---- exception / error_info / no e_source_location\n";
+    leaf::try_catch(
+        []
+        {
+            BOOST_LEAF_THROW_EXCEPTION( my_exception(),
+                value_nullptr(),
+                value_ptr(),
+                42,
+                printable_info_printable_value(),
+                printable_info_non_printable_value(),
+                non_printable_info_printable_value(),
+                non_printable_info_non_printable_value(),
+                hidden_printable_info_printable_value(),
+                hidden_non_printable_info_printable_value(),
+                enum_class::enum1,
+                leaf::e_errno{ENOENT} );
+        },
+        [](
+            value_nullptr,
+            value_ptr,
+            int,
+            printable_info_printable_value,
+            printable_info_non_printable_value,
+            non_printable_info_printable_value,
+            non_printable_info_non_printable_value,
+            hidden_printable_info_printable_value,
+            hidden_non_printable_info_printable_value,
+            enum_class,
+            leaf::e_errno,
+            leaf::error_info const & unmatched )
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            std::ostringstream st;
+            st << unmatched;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            BOOST_TEST(cmp(s,
+                "Error with serial #6"
+                "\nCaught:"
+                BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "<removed variance>: \"my_exception what\""
+                "\n"
+            ));
+#endif
+        } );
+
+    std::cout << __LINE__  << " ---- exception / error_info\n";
+    leaf::try_catch(
+        []
+        {
+            BOOST_LEAF_THROW_EXCEPTION( my_exception(),
+                value_nullptr(),
+                value_ptr(),
+                42,
+                printable_info_printable_value(),
+                printable_info_non_printable_value(),
+                non_printable_info_printable_value(),
+                non_printable_info_non_printable_value(),
+                hidden_printable_info_printable_value(),
+                hidden_non_printable_info_printable_value(),
+                enum_class::enum1,
+                leaf::e_errno{ENOENT} );
+        },
+        [](
+            value_nullptr,
+            value_ptr,
+            int,
+            leaf::e_source_location,
+            printable_info_printable_value,
+            printable_info_non_printable_value,
+            non_printable_info_printable_value,
+            non_printable_info_non_printable_value,
+            hidden_printable_info_printable_value,
+            hidden_non_printable_info_printable_value,
+            enum_class,
+            leaf::e_errno,
+            leaf::error_info const & unmatched )
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            std::ostringstream st;
+            st << unmatched;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            BOOST_TEST(cmp(s,
+                "Error with serial #7 reported at <removed variance>"
+                "\nCaught:"
+                BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "<removed variance>: \"my_exception what\""
+                "\n"
+            ));
+#endif
+        } );
+
+    std::cout << __LINE__  << " ---- exception / diagnostic_info\n";
+    leaf::try_catch(
+        []
+        {
+            BOOST_LEAF_THROW_EXCEPTION( my_exception(),
+                value_nullptr(),
+                value_ptr(),
+                42,
+                printable_info_printable_value(),
+                printable_info_non_printable_value(),
+                non_printable_info_printable_value(),
+                non_printable_info_non_printable_value(),
+                hidden_printable_info_printable_value(),
+                hidden_non_printable_info_printable_value(),
+                enum_class::enum0,
+                leaf::e_errno{ENOENT} );
+        },
+        [](
+            value_nullptr,
+            value_ptr,
+            int,
+            leaf::e_source_location,
+            printable_info_printable_value,
+            printable_info_non_printable_value,
+            non_printable_info_printable_value,
+            non_printable_info_non_printable_value,
+            hidden_printable_info_printable_value,
+            hidden_non_printable_info_printable_value,
+            enum_class,
+            leaf::e_errno,
+            leaf::diagnostic_info const & unmatched )
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            std::ostringstream st;
+            st << unmatched;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS )
+                BOOST_TEST(cmp(s,
+                    "Error with serial #8 reported at <removed variance>"
+                    "\nCaught:"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "<removed variance>: \"my_exception what\""
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "value_nullptr: <nullptr>"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "value_ptr: \"value\""
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "int: 42"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_printable_value: printed printable_value"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_non_printable_value: *** printable_info non_printable_value ***"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_printable_value: printed printable_value"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_non_printable_value"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "enum_class: 0"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "boost::leaf::e_errno: 2, \"No such file or directory\""
+                    "\n"
+                ));
+            else
+                BOOST_TEST(cmp(s,
+                    "Error with serial #8 reported at <removed variance>"
+                    "\nCaught:"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "<removed variance>: \"my_exception what\""
+                    BOOST_LEAF_DIAGNOSTIC_INFO_NO_BOOST_LEAF_CFG_DIAGNOSTICS
+                    "\n"
+                ));
+#endif
+        } );
+
+    std::cout << __LINE__  << " ---- exception / diagnostic_details\n";
+    leaf::try_catch(
+        []
+        {
+            BOOST_LEAF_THROW_EXCEPTION( my_exception(),
+                value_nullptr(),
+                value_ptr(),
+                42,
+                printable_info_printable_value(),
+                printable_info_non_printable_value(),
+                non_printable_info_printable_value(),
+                non_printable_info_non_printable_value(),
+                hidden_printable_info_printable_value(),
+                hidden_non_printable_info_printable_value(),
+                enum_class::enum1,
+                unexpected_test<1>{1},
+                unexpected_test<2>{2},
+                leaf::e_errno{ENOENT} );
+        },
+        [](
+            value_nullptr,
+            value_ptr,
+            int,
+            leaf::e_source_location,
+            printable_info_printable_value,
+            printable_info_non_printable_value,
+            non_printable_info_printable_value,
+            non_printable_info_non_printable_value,
+            hidden_printable_info_printable_value,
+            hidden_non_printable_info_printable_value,
+            enum_class,
+            leaf::e_errno,
+            leaf::diagnostic_details const & di )
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            std::ostringstream st;
+            st << di;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS )
+                if( BOOST_LEAF_CFG_CAPTURE )
+                    BOOST_TEST(cmp(s,
+                        "Error with serial #9 reported at <removed variance>"
+                        "\nCaught:"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "<removed variance>: \"my_exception what\""
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "value_nullptr: <nullptr>"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "value_ptr: \"value\""
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "int: 42"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_printable_value: printed printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_non_printable_value: *** printable_info non_printable_value ***"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_printable_value: printed printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_non_printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "enum_class: 1"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "boost::leaf::e_errno: 2, \"No such file or directory\""
+                        "\nDiagnostic details:"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "unexpected_test<1>: 1"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "unexpected_test<2>: 2"
+                        "\n"
+                    ));
+                else
+                    BOOST_TEST(cmp(s,
+                        "Error with serial #9 reported at <removed variance>"
+                        "\nCaught:"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "<removed variance>: \"my_exception what\""
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "value_nullptr: <nullptr>"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "value_ptr: \"value\""
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "int: 42"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_printable_value: printed printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_non_printable_value: *** printable_info non_printable_value ***"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_printable_value: printed printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_non_printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "enum_class: 1"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "boost::leaf::e_errno: 2, \"No such file or directory\""
+                        BOOST_LEAF_DIAGNOSTIC_DETAILS_NO_BOOST_LEAF_CFG_CAPTURE
+                        "\n"
+                    ));
+            else
+                BOOST_TEST(cmp(s,
+                    "Error with serial #9 reported at <removed variance>"
+                    "\nCaught:"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "<removed variance>: \"my_exception what\""
+                    BOOST_LEAF_DIAGNOSTIC_DETAILS_NO_BOOST_LEAF_CFG_DIAGNOSTICS
+                    "\n"
+                ));
+#endif
+        } );
+
+    std::cout << __LINE__  << " ---- exception / diagnostic_details / nothing caught\n";
+    leaf::try_catch(
+        []
+        {
+            BOOST_LEAF_THROW_EXCEPTION( my_exception(),
+                value_nullptr(),
+                value_ptr(),
+                42,
+                printable_info_printable_value(),
+                printable_info_non_printable_value(),
+                non_printable_info_printable_value(),
+                non_printable_info_non_printable_value(),
+                hidden_printable_info_printable_value(),
+                hidden_non_printable_info_printable_value(),
+                enum_class::enum1,
+                unexpected_test<1>{1},
+                unexpected_test<2>{2},
+                leaf::e_errno{ENOENT} );
+        },
+        []( leaf::diagnostic_details const & di )
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            std::ostringstream st;
+            st << di;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS )
+                if( BOOST_LEAF_CFG_CAPTURE )
+                    BOOST_TEST(cmp(s,
+                        "Error with serial #10 reported at <removed variance>"
+                        "\nCaught:"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "<removed variance>: \"my_exception what\""
+                        "\nDiagnostic details:"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "value_nullptr: <nullptr>"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "value_ptr: \"value\""
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "int: 42"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_printable_value: printed printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "printable_info_non_printable_value: *** printable_info non_printable_value ***"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_printable_value: printed printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "non_printable_info_non_printable_value"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "enum_class: 1"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "unexpected_test<1>: 1"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "unexpected_test<2>: 2"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_DELIMITER "boost::leaf::e_errno: 2, \"No such file or directory\""
+                        "\n"
+                    ));
+                else
+                    BOOST_TEST(cmp(s,
+                        "Error with serial #10 reported at <removed variance>"
+                        "\nCaught:"
+                        BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "<removed variance>: \"my_exception what\""
+                        BOOST_LEAF_DIAGNOSTIC_DETAILS_NO_BOOST_LEAF_CFG_CAPTURE
+                        "\n"
+                    ));
+            else
+                BOOST_TEST(cmp(s,
+                    "Error with serial #10 reported at <removed variance>"
+                    "\nCaught:"
+                    BOOST_LEAF_CFG_DIAGNOSTICS_FIRST_DELIMITER "<removed variance>: \"my_exception what\""
+                    BOOST_LEAF_DIAGNOSTIC_DETAILS_NO_BOOST_LEAF_CFG_DIAGNOSTICS
+                    "\n"
+                ));
+#endif
+        } );
+
+#endif
+
+    return boost::report_errors();
+}
diff --git a/test/diagnostic_info_test2.cpp b/test/diagnostics_test2.cpp
similarity index 73%
rename from test/diagnostic_info_test2.cpp
rename to test/diagnostics_test2.cpp
index fbbae7af..2024f1ae 100644
--- a/test/diagnostic_info_test2.cpp
+++ b/test/diagnostics_test2.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -7,19 +6,24 @@
 #   include "leaf.hpp"
 #else
 #   include <boost/leaf/config.hpp>
-#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/diagnostics.hpp>
+#   include <boost/leaf/on_error.hpp>
 #   include <boost/leaf/result.hpp>
 #endif
 
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
 #include "lightweight_test.hpp"
-#include <sstream>
 
 namespace leaf = boost::leaf;
 
 template <int I>
 struct info
 {
-    friend std::ostream & operator<<( std::ostream & os, info const & x )
+    friend std::ostream & operator<<( std::ostream & os, info const & )
     {
         return os << "printed info<" << I << '>';
     }
@@ -47,16 +51,15 @@ int main()
                 {
                 } );
         },
-        []( leaf::verbose_diagnostic_info const & di )
+        []( leaf::diagnostic_details const & di )
         {
 #if BOOST_LEAF_CFG_STD_STRING
             std::ostringstream st;
             st << di;
             std::string s = st.str();
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-            BOOST_TEST_NE(s.find("info<2>"), s.npos);
-#endif
-            std::cout << s;
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+                BOOST_TEST_NE(s.find("info<2>"), s.npos);
 #endif
         } );
 
@@ -73,27 +76,26 @@ int main()
                     leaf::try_catch(
                         []
                         {
-                            throw leaf::exception(info<1>{});
+                            leaf::throw_exception(info<1>{});
                         },
                         []
                         {
                         } );
-                    throw leaf::exception(info<2>{});
+                    leaf::throw_exception(info<2>{});
                 },
                 []( info<1> )
                 {
                 } );
         },
-        []( leaf::verbose_diagnostic_info const & di )
+        []( leaf::diagnostic_details const & di )
         {
 #if BOOST_LEAF_CFG_STD_STRING
             std::ostringstream st;
             st << di;
             std::string s = st.str();
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-            BOOST_TEST_NE(s.find("info<2>"), s.npos);
-#endif
-            std::cout << s;
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+                BOOST_TEST_NE(s.find("info<2>"), s.npos);
 #endif
         } );
 
@@ -121,16 +123,15 @@ int main()
                 {
                 } );
         },
-        []( leaf::verbose_diagnostic_info const & di )
+        []( leaf::diagnostic_details const & di )
         {
 #if BOOST_LEAF_CFG_STD_STRING
             std::ostringstream st;
             st << di;
             std::string s = st.str();
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-            BOOST_TEST_NE(s.find("info<2>"), s.npos);
-#endif
-            std::cout << s;
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+                BOOST_TEST_NE(s.find("info<2>"), s.npos);
 #endif
         } );
 
diff --git a/test/diagnostics_test3.cpp b/test/diagnostics_test3.cpp
new file mode 100644
index 00000000..c38b0d5d
--- /dev/null
+++ b/test/diagnostics_test3.cpp
@@ -0,0 +1,59 @@
+// Copyright 2018-2024 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)
+
+#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
+#   include "leaf.hpp"
+#else
+#   include <boost/leaf/config.hpp>
+#   include <boost/leaf/diagnostics.hpp>
+#   include <boost/leaf/on_error.hpp>
+#   include <boost/leaf/result.hpp>
+#endif
+
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+struct info { int value; };
+
+leaf::result<void> f1()
+{
+    return leaf::new_error(info{41});
+}
+
+leaf::result<void> f2()
+{
+    auto load = leaf::on_error(info{42});
+    return f1();
+}
+
+int main()
+{
+    leaf::try_handle_all(
+        []() -> leaf::result<void>
+        {
+            return f2();
+        },
+        []( leaf::diagnostic_details const & di )
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            std::ostringstream st;
+            st << di;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+            {
+                BOOST_TEST_NE(s.find("41"), s.npos);
+                BOOST_TEST_EQ(s.find("42"), s.npos);
+            }
+#endif
+        } );
+
+    return boost::report_errors();
+}
diff --git a/test/diagnostics_test4.cpp b/test/diagnostics_test4.cpp
new file mode 100644
index 00000000..c6bbad06
--- /dev/null
+++ b/test/diagnostics_test4.cpp
@@ -0,0 +1,75 @@
+// Copyright 2018-2024 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)
+
+#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
+#   include "leaf.hpp"
+#else
+#   include <boost/leaf/config.hpp>
+#   include <boost/leaf/diagnostics.hpp>
+#   include <boost/leaf/on_error.hpp>
+#   include <boost/leaf/result.hpp>
+#endif
+
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
+#include <vector>
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+struct my_error
+{
+    std::vector<int> vec;
+    void append(int x)
+    {
+       vec.push_back(x);
+    }
+    friend std::ostream & operator<<( std::ostream & os, my_error const & x )
+    {
+        for( auto const & e : x.vec )
+            os << "appended: " << e << std::endl;
+        return os;
+    }
+};
+
+leaf::result<void> f1()
+{
+    auto ctx_ = leaf::on_error([](my_error & e) {e.append(42);});
+    return leaf::new_error("new_error");
+}
+
+leaf::result<void> f2()
+{
+    auto ctx_ = leaf::on_error([](my_error & e) {e.append(43);});
+    return f1();
+}
+
+int main()
+{
+    leaf::try_handle_all([]() -> leaf::result<void>
+    {
+        return f2();
+    },
+    [](leaf::diagnostic_details const & e)
+    {
+#if BOOST_LEAF_CFG_STD_STRING
+        std::ostringstream st;
+        st << e;
+        std::string s = st.str();
+        std::cout << s << std::endl;
+        if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+        {
+            BOOST_TEST_NE(s.find("new_error"), s.npos);
+            BOOST_TEST_NE(s.find("appended: 42"), s.npos);
+            BOOST_TEST_NE(s.find("appended: 43"), s.npos);
+        }
+#endif
+    } );
+
+    return boost::report_errors();
+}
diff --git a/test/diagnostics_test5.cpp b/test/diagnostics_test5.cpp
new file mode 100644
index 00000000..2f554125
--- /dev/null
+++ b/test/diagnostics_test5.cpp
@@ -0,0 +1,129 @@
+// Copyright 2018-2024 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)
+
+#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
+#   include "leaf.hpp"
+#else
+#   include <boost/leaf/config.hpp>
+#   include <boost/leaf/diagnostics.hpp>
+#   include <boost/leaf/on_error.hpp>
+#   include <boost/leaf/result.hpp>
+#endif
+
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+namespace
+{
+    int counter = 0;
+}
+
+template <int N>
+struct info
+{
+    info(info const &) = delete;
+    info & operator=(info const &) = delete;
+    int acc = 0;
+    info()
+    {
+        ++counter;
+    }
+    info( info && x ):
+        acc(x.acc)
+    {
+        ++counter;
+    }
+    ~info()
+    {
+        --counter;
+    }
+    void accumulate()
+    {
+        ++acc;
+    }
+    friend std::ostream & operator<<( std::ostream & os, info const & x )
+    {
+        return os << "info<" << N << ">: acc=" << x.acc;
+    }
+};
+
+leaf::result<void> f1()
+{
+    return leaf::new_error(info<1>(), [](info<4> & x){ x.accumulate(); });
+}
+
+leaf::result<void> f2()
+{
+    auto load = leaf::on_error(info<2>{}, [](){ return info<3>(); }, [](info<4> & x){ x.accumulate(); });
+    return f1();
+}
+
+leaf::result<void> f3()
+{
+    return leaf::try_handle_some(
+        []() -> leaf::result<void>
+        {
+            return f2();
+        },
+        []( leaf::diagnostic_details const & e )
+        {
+            return e.error();
+        } );
+}
+
+int main()
+{
+    BOOST_TEST_EQ(counter, 0);
+    leaf::try_handle_all(
+        []() -> leaf::result<void>
+        {
+            return f3();
+        },
+        []( info<1> const &, leaf::diagnostic_details const & di )
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            std::ostringstream st;
+            st << di;
+            std::string s = st.str();
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+            {
+                auto const n1 = s.find("info<1>: acc=0");
+                auto const n2 = s.find("info<2>: acc=0");
+                auto const n3 = s.find("info<3>: acc=0");
+                auto const n4 = s.find("info<4>: acc=2");
+                BOOST_TEST_NE(n1, s.npos);
+                BOOST_TEST_NE(n2, s.npos);
+                BOOST_TEST_NE(n3, s.npos);
+                BOOST_TEST_NE(n4, s.npos);
+                BOOST_TEST_EQ(counter, 4);
+            }
+            else
+            BOOST_TEST_EQ(counter, 1);
+#endif
+        },
+        []
+        {
+            std::abort();
+        } );
+    BOOST_TEST_EQ(counter, 0);
+
+    leaf::try_handle_all(
+        []() -> leaf::result<void>
+        {
+            return f2();
+        },
+        []
+        {
+            BOOST_TEST_EQ(counter, 0);
+        } );
+
+    return boost::report_errors();
+}
diff --git a/test/diagnostics_test6.cpp b/test/diagnostics_test6.cpp
new file mode 100644
index 00000000..c32759d4
--- /dev/null
+++ b/test/diagnostics_test6.cpp
@@ -0,0 +1,134 @@
+// Copyright 2018-2024 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)
+
+#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
+#   include "leaf.hpp"
+#else
+#   include <boost/leaf/config.hpp>
+#   include <boost/leaf/diagnostics.hpp>
+#   include <boost/leaf/on_error.hpp>
+#   include <boost/leaf/result.hpp>
+#endif
+
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
+#include <vector>
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+template <int> struct info { int value; };
+
+leaf::result<void> f1()
+{
+    return leaf::new_error(info<1>{11}, info<2>{21});
+}
+
+leaf::result<void> f2()
+{
+    return leaf::try_handle_some(
+        []
+        {
+            return f1();
+        },
+        []
+        {
+            return leaf::new_error(info<1>{12});
+        } );
+}
+
+leaf::result<void> f3()
+{
+    return leaf::try_handle_some(
+        []
+        {
+            return f1();
+        },
+        [](leaf::diagnostic_details const &)
+        {
+            return leaf::new_error(info<1>{13});
+        } );
+}
+
+leaf::result<void> f4()
+{
+    return leaf::try_handle_some(
+        []
+        {
+            return f1();
+        },
+        [](leaf::diagnostic_details const & e)
+        {
+            return e.error().load(info<1>{14});
+        } );
+}
+
+int main()
+{
+    leaf::try_handle_all([]() -> leaf::result<void>
+    {
+        return f2();
+    },
+    [](leaf::diagnostic_details const & e)
+    {
+#if BOOST_LEAF_CFG_STD_STRING
+        std::ostringstream st;
+        st << e;
+        std::string s = st.str();
+        std::cout << s << std::endl;
+        if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+        {
+            BOOST_TEST_EQ(s.find(": 11"), s.npos);
+            BOOST_TEST_NE(s.find(": 12"), s.npos);
+            BOOST_TEST_EQ(s.find(": 21"), s.npos);
+        }
+#endif
+    } );
+
+    leaf::try_handle_all([]() -> leaf::result<void>
+    {
+        return f3();
+    },
+    [](leaf::diagnostic_details const & e)
+    {
+#if BOOST_LEAF_CFG_STD_STRING
+        std::ostringstream st;
+        st << e;
+        std::string s = st.str();
+        std::cout << s << std::endl;
+        if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+        {
+            BOOST_TEST_EQ(s.find(": 11"), s.npos);
+            BOOST_TEST_NE(s.find(": 13"), s.npos);
+            BOOST_TEST_EQ(s.find(": 21"), s.npos);
+        }
+#endif
+    } );
+
+    leaf::try_handle_all([]() -> leaf::result<void>
+    {
+        return f4();
+    },
+    [](leaf::diagnostic_details const & e)
+    {
+#if BOOST_LEAF_CFG_STD_STRING
+        std::ostringstream st;
+        st << e;
+        std::string s = st.str();
+        std::cout << s << std::endl;
+        if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+        {
+            BOOST_TEST_EQ(s.find(": 12"), s.npos);
+            BOOST_TEST_NE(s.find(": 14"), s.npos);
+            BOOST_TEST_NE(s.find(": 21"), s.npos);
+        }
+#endif
+    } );
+
+    return boost::report_errors();
+}
diff --git a/test/e_LastError_test.cpp b/test/e_LastError_test.cpp
index ff8ffc03..a8d1cc0c 100644
--- a/test/e_LastError_test.cpp
+++ b/test/e_LastError_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -25,8 +24,12 @@ int main()
 #   include <boost/leaf/result.hpp>
 #endif
 
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
 #include "lightweight_test.hpp"
-#include <sstream>
 
 namespace leaf = boost::leaf;
 
@@ -34,9 +37,13 @@ int main()
 {
     SetLastError(ERROR_FILE_NOT_FOUND);
 #if BOOST_LEAF_CFG_STD_STRING
-    std::stringstream ss;
+    std::ostringstream ss;
     ss << leaf::windows::e_LastError{};
-    BOOST_TEST(ss.str().find("The system cannot find the file specified") != std::string::npos);
+    std::string s = ss.str();
+    std::cout << s << std::endl;
+#if BOOST_LEAF_CFG_DIAGNOSTICS
+    BOOST_TEST_NE(ss.str().find("The system cannot find the file specified"), std::string::npos);
+#endif
 #endif
 
     int r = leaf::try_handle_all(
diff --git a/test/e_errno_test.cpp b/test/e_errno_test.cpp
index f8e60a15..d59faeab 100644
--- a/test/e_errno_test.cpp
+++ b/test/e_errno_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -11,8 +10,12 @@
 #   include <boost/leaf/result.hpp>
 #endif
 
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
 #include "lightweight_test.hpp"
-#include <sstream>
 
 namespace leaf = boost::leaf;
 
@@ -20,9 +23,13 @@ int main()
 {
     errno = ENOENT;
 #if BOOST_LEAF_CFG_STD_STRING
-    std::stringstream ss;
+    std::ostringstream ss;
     ss << leaf::e_errno{};
-    BOOST_TEST(ss.str().find(std::strerror(ENOENT)) != std::string::npos);
+    std::string s = ss.str();
+    std::cout << s << std::endl;
+#if BOOST_LEAF_CFG_STD_DIAGNOSTICS
+    BOOST_TEST_NE(s.find(std::strerror(ENOENT)), std::string::npos);
+#endif
 #endif
 
     int r = leaf::try_handle_all(
diff --git a/test/error_code_test.cpp b/test/error_code_test.cpp
index 1a3ec3e8..668445bf 100644
--- a/test/error_code_test.cpp
+++ b/test/error_code_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -20,7 +19,7 @@ int main()
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
 #else
-#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/diagnostics.hpp>
 #   include <boost/leaf/pred.hpp>
 #   include <boost/leaf/result.hpp>
 #endif
@@ -28,6 +27,11 @@ int main()
 #include "_test_res.hpp"
 #include "lightweight_test.hpp"
 
+#include "boost/system/result.hpp"
+namespace boost { namespace leaf {
+    template <class T> struct is_result_type<boost::system::result<T, std::error_code>>: std::true_type { };
+} }
+
 namespace leaf = boost::leaf;
 
 struct e_wrapped_error_code { std::error_code value; };
@@ -179,7 +183,7 @@ void test()
             {
                 std::error_code const & ec = cond.matched;
                 BOOST_TEST_EQ(ec, errc_a::a0);
-                BOOST_TEST(ec==make_error_condition(cond_x::x00));
+                BOOST_TEST(ec == make_error_condition(cond_x::x00));
                 return 42;
             },
             []
@@ -199,7 +203,7 @@ void test()
             {
                 std::error_code const & ec = cond.matched;
                 BOOST_TEST_EQ(ec, errc_a::a0);
-                BOOST_TEST(ec==make_error_condition(cond_x::x00));
+                BOOST_TEST(ec == make_error_condition(cond_x::x00));
                 return 42;
             },
             []
@@ -214,7 +218,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 leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } );
             },
             []( e_wrapped_error_code const & wec )
             {
@@ -232,7 +236,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 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 +256,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 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,14 +276,14 @@ 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 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 )
             {
                 e_wrapped_error_code const & wec = cond.matched;
                 std::error_code const & ec = wec.value;
                 BOOST_TEST_EQ(ec, errc_a::a0);
-                BOOST_TEST(ec==make_error_condition(cond_x::x00));
+                BOOST_TEST(ec == make_error_condition(cond_x::x00));
                 return 42;
             },
             []
@@ -293,14 +297,14 @@ 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 leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } );
             },
             []( leaf::match_value<e_wrapped_error_code, cond_x::x00> cond )
             {
                 e_wrapped_error_code const & wec = cond.matched;
                 std::error_code const & ec = wec.value;
                 BOOST_TEST_EQ(ec, errc_a::a0);
-                BOOST_TEST(ec==make_error_condition(cond_x::x00));
+                BOOST_TEST(ec == make_error_condition(cond_x::x00));
                 return 42;
             },
             []
@@ -467,7 +471,7 @@ void test_void()
             {
                 std::error_code const & ec = cond.matched;
                 BOOST_TEST_EQ(ec, errc_a::a0);
-                BOOST_TEST(ec==make_error_condition(cond_x::x00));
+                BOOST_TEST(ec == make_error_condition(cond_x::x00));
                 r = 42;
             },
             [&]
@@ -488,7 +492,7 @@ void test_void()
             {
                 std::error_code const & ec = cond.matched;
                 BOOST_TEST_EQ(ec, errc_a::a0);
-                BOOST_TEST(ec==make_error_condition(cond_x::x00));
+                BOOST_TEST(ec == make_error_condition(cond_x::x00));
                 r = 42;
             },
             [&]
@@ -504,7 +508,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 leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } );
             },
             [&]( e_wrapped_error_code const & wec )
             {
@@ -523,7 +527,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 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 +548,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 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,14 +569,14 @@ 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 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 )
             {
                 e_wrapped_error_code const & wec = cond.matched;
                 std::error_code const & ec = wec.value;
                 BOOST_TEST_EQ(ec, errc_a::a0);
-                BOOST_TEST(ec==make_error_condition(cond_x::x00));
+                BOOST_TEST(ec == make_error_condition(cond_x::x00));
                 r = 42;
             },
             [&]
@@ -587,14 +591,14 @@ 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 leaf::new_error( e_wrapped_error_code { make_error_code(errc_a::a0) } );
             },
             [&]( leaf::match_value<e_wrapped_error_code, cond_x::x00> cond )
             {
                 e_wrapped_error_code const & wec = cond.matched;
                 std::error_code const & ec = wec.value;
                 BOOST_TEST_EQ(ec, errc_a::a0);
-                BOOST_TEST(ec==make_error_condition(cond_x::x00));
+                BOOST_TEST(ec == make_error_condition(cond_x::x00));
                 r = 42;
             },
             [&]
@@ -612,6 +616,7 @@ int main()
     test<test_res<int, std::error_code>>();
     test_void<leaf::result<void>>();
     test_void<test_res<void, std::error_code>>();
+    test<boost::system::result<int, std::error_code>>();
     return boost::report_errors();
 }
 
diff --git a/test/error_id_test.cpp b/test/error_id_test.cpp
index 904aecd7..de0395b8 100644
--- a/test/error_id_test.cpp
+++ b/test/error_id_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -25,10 +24,10 @@ std::vector<int> generate_ids()
     ids.reserve(ids_per_thread);
     for(int i=0; i!=ids_per_thread-1; ++i)
     {
-        int id = leaf::leaf_detail::new_id();
+        int id = leaf::detail::new_id();
         BOOST_TEST_NE(id&1, 0);
-        int last = leaf::leaf_detail::current_id();
-        BOOST_TEST_EQ(last, leaf::leaf_detail::current_id());
+        int last = leaf::detail::current_id();
+        BOOST_TEST_EQ(last, leaf::detail::current_id());
         BOOST_TEST_NE(last&1, 0);
         BOOST_TEST_EQ(last, id);
         ids.push_back(id);
@@ -45,10 +44,10 @@ int main()
         BOOST_TEST_EQ(e1.value(), 0);
         BOOST_TEST(!e2);
         BOOST_TEST_EQ(e2.value(), 0);
-        BOOST_TEST(e1==e2);
-        BOOST_TEST(!(e1!=e2));
-        BOOST_TEST(!(e1<e2));
-        BOOST_TEST(!(e2<e1));
+        BOOST_TEST(e1 == e2);
+        BOOST_TEST(!(e1 != e2));
+        BOOST_TEST(!(e1 < e2));
+        BOOST_TEST(!(e2 < e1));
     }
     {
         leaf::error_id e1;
@@ -56,47 +55,47 @@ int main()
         BOOST_TEST(!e1);
         BOOST_TEST_EQ(e1.value(), 0);
         BOOST_TEST(e2);
-        BOOST_TEST_EQ(e2.value(), 1);
-        BOOST_TEST(!(e1==e2));
-        BOOST_TEST(e1!=e2);
-        BOOST_TEST(e1<e2);
-        BOOST_TEST(!(e2<e1));
+        BOOST_TEST_EQ(e2.value(), 5);
+        BOOST_TEST(!(e1 == e2));
+        BOOST_TEST(e1 != e2);
+        BOOST_TEST(e1 < e2);
+        BOOST_TEST(!(e2 < e1));
     }
     {
         leaf::error_id e1 = leaf::new_error();
         leaf::error_id e2 = leaf::new_error();
         BOOST_TEST(e1);
-        BOOST_TEST_EQ(e1.value(), 5);
+        BOOST_TEST_EQ(e1.value(), 9);
         BOOST_TEST(e2);
-        BOOST_TEST_EQ(e2.value(), 9);
-        BOOST_TEST(!(e1==e2));
-        BOOST_TEST(e1!=e2);
-        BOOST_TEST(e1<e2);
-        BOOST_TEST(!(e2<e1));
+        BOOST_TEST_EQ(e2.value(), 13);
+        BOOST_TEST(!(e1 == e2));
+        BOOST_TEST(e1 != e2);
+        BOOST_TEST(e1 < e2);
+        BOOST_TEST(!(e2 < e1));
     }
     {
         leaf::error_id e1 = leaf::new_error();
         leaf::error_id e2 = e1;
         BOOST_TEST(e1);
-        BOOST_TEST_EQ(e1.value(), 13);
+        BOOST_TEST_EQ(e1.value(), 17);
         BOOST_TEST(e2);
-        BOOST_TEST_EQ(e2.value(), 13);
-        BOOST_TEST(e1==e2);
-        BOOST_TEST(!(e1!=e2));
-        BOOST_TEST(!(e1<e2));
-        BOOST_TEST(!(e2<e1));
+        BOOST_TEST_EQ(e2.value(), 17);
+        BOOST_TEST(e1 == e2);
+        BOOST_TEST(!(e1 != e2));
+        BOOST_TEST(!(e1 < e2));
+        BOOST_TEST(!(e2 < e1));
     }
     {
         leaf::error_id e1 = leaf::new_error();
         leaf::error_id e2; e2 = e1;
         BOOST_TEST(e1);
-        BOOST_TEST_EQ(e1.value(), 17);
+        BOOST_TEST_EQ(e1.value(), 21);
         BOOST_TEST(e2);
-        BOOST_TEST_EQ(e2.value(), 17);
-        BOOST_TEST(e1==e2);
-        BOOST_TEST(!(e1!=e2));
-        BOOST_TEST(!(e1<e2));
-        BOOST_TEST(!(e2<e1));
+        BOOST_TEST_EQ(e2.value(), 21);
+        BOOST_TEST(e1 == e2);
+        BOOST_TEST(!(e1 != e2));
+        BOOST_TEST(!(e1 < e2));
+        BOOST_TEST(!(e2 < e1));
     }
 #ifdef BOOST_LEAF_NO_THREADS
     std::vector<int> all_ids = generate_ids();
@@ -121,7 +120,7 @@ int main()
 #endif
     std::sort(all_ids.begin(), all_ids.end());
     auto u = std::unique(all_ids.begin(), all_ids.end());
-    BOOST_TEST(u==all_ids.end());
+    BOOST_TEST(u == all_ids.end());
 
     return boost::report_errors();
 }
diff --git a/test/exception_test.cpp b/test/exception_test.cpp
index 50949b54..3cd926d2 100644
--- a/test/exception_test.cpp
+++ b/test/exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -20,7 +19,7 @@ int main()
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
 #else
-#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/diagnostics.hpp>
 #   include <boost/leaf/pred.hpp>
 #   include <boost/leaf/exception.hpp>
 #   include <boost/leaf/on_error.hpp>
@@ -43,7 +42,7 @@ struct my_exception:
     abstract_base_exception
 {
     int val;;
-    explicit my_exception(int val): val{val} { }
+    explicit my_exception(int v): val{v} { }
     int get_val() const { return val; }
 };
 
@@ -82,7 +81,7 @@ int test( F && f )
             BOOST_TEST_EQ(get_val(ex), 42);
             return 20;
         },
-        []( Ex ex, leaf::match_value<info,42>, info x )
+        []( Ex ex, leaf::match_value<info,42>, info )
         {
             BOOST_TEST_EQ(get_val(ex), 42);
             return 21;
@@ -101,7 +100,7 @@ int test( F && f )
         {
             return 40;
         },
-        []( leaf::match_value<info,42>, info x )
+        []( leaf::match_value<info,42>, info )
         {
             return 41;
         },
@@ -118,92 +117,76 @@ int test( F && f )
 int main()
 {
     BOOST_TEST_EQ(20, test<leaf::catch_<my_exception>>([]{ BOOST_LEAF_THROW_EXCEPTION(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(20, test<leaf::catch_<my_exception>>([]{ throw BOOST_LEAF_EXCEPTION(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(21, test<leaf::catch_<my_exception>>([]{ throw leaf::exception(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(21, test<leaf::catch_<my_exception>>([]{ my_exception exc(42); throw leaf::exception(exc, info{42}); }));
-    BOOST_TEST_EQ(21, test<leaf::catch_<my_exception>>([]{ my_exception const exc(42); throw leaf::exception(exc, info{42}); }));
+    BOOST_TEST_EQ(21, test<leaf::catch_<my_exception>>([]{ leaf::throw_exception(my_exception(42), info{42}); }));
+    BOOST_TEST_EQ(21, test<leaf::catch_<my_exception>>([]{ my_exception exc(42); leaf::throw_exception(exc, info{42}); }));
+    BOOST_TEST_EQ(21, test<leaf::catch_<my_exception>>([]{ my_exception const exc(42); leaf::throw_exception(exc, info{42}); }));
     BOOST_TEST_EQ(22, test<leaf::catch_<my_exception>>([]{ BOOST_LEAF_THROW_EXCEPTION(my_exception(42)); }));
-    BOOST_TEST_EQ(22, test<leaf::catch_<my_exception>>([]{ throw BOOST_LEAF_EXCEPTION(my_exception(42)); }));
-    BOOST_TEST_EQ(23, test<leaf::catch_<my_exception>>([]{ throw leaf::exception(my_exception(42)); }));
-    BOOST_TEST_EQ(23, test<leaf::catch_<my_exception>>([]{ my_exception exc(42); throw leaf::exception(exc); }));
-    BOOST_TEST_EQ(23, test<leaf::catch_<my_exception>>([]{ my_exception const exc(42); throw leaf::exception(exc); }));
+    BOOST_TEST_EQ(23, test<leaf::catch_<my_exception>>([]{ leaf::throw_exception(my_exception(42)); }));
+    BOOST_TEST_EQ(23, test<leaf::catch_<my_exception>>([]{ my_exception exc(42); leaf::throw_exception(exc); }));
+    BOOST_TEST_EQ(23, test<leaf::catch_<my_exception>>([]{ my_exception const exc(42); leaf::throw_exception(exc); }));
 
     BOOST_TEST_EQ(20, test<my_exception const &>([]{ BOOST_LEAF_THROW_EXCEPTION(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(20, test<my_exception const &>([]{ throw BOOST_LEAF_EXCEPTION(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(21, test<my_exception const &>([]{ throw leaf::exception(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(21, test<my_exception const &>([]{ my_exception exc(42); throw leaf::exception(exc, info{42}); }));
-    BOOST_TEST_EQ(21, test<my_exception const &>([]{ my_exception const exc(42); throw leaf::exception(exc, info{42}); }));
+    BOOST_TEST_EQ(21, test<my_exception const &>([]{ leaf::throw_exception(my_exception(42), info{42}); }));
+    BOOST_TEST_EQ(21, test<my_exception const &>([]{ my_exception exc(42); leaf::throw_exception(exc, info{42}); }));
+    BOOST_TEST_EQ(21, test<my_exception const &>([]{ my_exception const exc(42); leaf::throw_exception(exc, info{42}); }));
     BOOST_TEST_EQ(22, test<my_exception const &>([]{ BOOST_LEAF_THROW_EXCEPTION(my_exception(42)); }));
-    BOOST_TEST_EQ(22, test<my_exception const &>([]{ throw BOOST_LEAF_EXCEPTION(my_exception(42)); }));
-    BOOST_TEST_EQ(23, test<my_exception const &>([]{ throw leaf::exception(my_exception(42)); }));
-    BOOST_TEST_EQ(23, test<my_exception const &>([]{ my_exception exc(42); throw leaf::exception(exc); }));
-    BOOST_TEST_EQ(23, test<my_exception const &>([]{ my_exception const exc(42); throw leaf::exception(exc); }));
+    BOOST_TEST_EQ(23, test<my_exception const &>([]{ leaf::throw_exception(my_exception(42)); }));
+    BOOST_TEST_EQ(23, test<my_exception const &>([]{ my_exception exc(42); leaf::throw_exception(exc); }));
+    BOOST_TEST_EQ(23, test<my_exception const &>([]{ my_exception const exc(42); leaf::throw_exception(exc); }));
 
     BOOST_TEST_EQ(40, test<my_exception &>([]{ BOOST_LEAF_THROW_EXCEPTION(info{42}); }));
-    BOOST_TEST_EQ(40, test<my_exception &>([]{ throw BOOST_LEAF_EXCEPTION(info{42}); }));
-    BOOST_TEST_EQ(41, test<my_exception &>([]{ throw leaf::exception(info{42}); }));
-    BOOST_TEST_EQ(41, test<my_exception &>([]{ info inf{42}; throw leaf::exception(inf); }));
-    BOOST_TEST_EQ(41, test<my_exception &>([]{ info const inf{42}; throw leaf::exception(inf); }));
+    BOOST_TEST_EQ(41, test<my_exception &>([]{ leaf::throw_exception(info{42}); }));
+    BOOST_TEST_EQ(41, test<my_exception &>([]{ info inf{42}; leaf::throw_exception(inf); }));
+    BOOST_TEST_EQ(41, test<my_exception &>([]{ info const inf{42}; leaf::throw_exception(inf); }));
     BOOST_TEST_EQ(42, test<my_exception &>([]{ BOOST_LEAF_THROW_EXCEPTION(); }));
-    BOOST_TEST_EQ(42, test<my_exception &>([]{ throw BOOST_LEAF_EXCEPTION(); }));
-    BOOST_TEST_EQ(43, test<my_exception &>([]{ throw leaf::exception(); }));
-    BOOST_TEST_EQ(23, test<my_exception &>([]{ my_exception exc(42); throw leaf::exception(exc); }));
-    BOOST_TEST_EQ(23, test<my_exception &>([]{ my_exception const exc(42); throw leaf::exception(exc); }));
+    BOOST_TEST_EQ(43, test<my_exception &>([]{ leaf::throw_exception(); }));
+    BOOST_TEST_EQ(23, test<my_exception &>([]{ my_exception exc(42); leaf::throw_exception(exc); }));
+    BOOST_TEST_EQ(23, test<my_exception &>([]{ my_exception const exc(42); leaf::throw_exception(exc); }));
 
     BOOST_TEST_EQ(20, test<my_exception const>([]{ BOOST_LEAF_THROW_EXCEPTION(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(20, test<my_exception const>([]{ throw BOOST_LEAF_EXCEPTION(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(21, test<my_exception const>([]{ throw leaf::exception(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(21, test<my_exception const>([]{ my_exception exc(42); throw leaf::exception(exc, info{42}); }));
-    BOOST_TEST_EQ(21, test<my_exception const>([]{ my_exception const exc(42); throw leaf::exception(exc, info{42}); }));
+    BOOST_TEST_EQ(21, test<my_exception const>([]{ leaf::throw_exception(my_exception(42), info{42}); }));
+    BOOST_TEST_EQ(21, test<my_exception const>([]{ my_exception exc(42); leaf::throw_exception(exc, info{42}); }));
+    BOOST_TEST_EQ(21, test<my_exception const>([]{ my_exception const exc(42); leaf::throw_exception(exc, info{42}); }));
     BOOST_TEST_EQ(22, test<my_exception const>([]{ BOOST_LEAF_THROW_EXCEPTION(my_exception(42)); }));
-    BOOST_TEST_EQ(22, test<my_exception const>([]{ throw BOOST_LEAF_EXCEPTION(my_exception(42)); }));
-    BOOST_TEST_EQ(23, test<my_exception const>([]{ throw leaf::exception(my_exception(42)); }));
-    BOOST_TEST_EQ(23, test<my_exception const>([]{ my_exception exc(42); throw leaf::exception(exc); }));
-    BOOST_TEST_EQ(23, test<my_exception const>([]{ my_exception const exc(42); throw leaf::exception(exc); }));
+    BOOST_TEST_EQ(23, test<my_exception const>([]{ leaf::throw_exception(my_exception(42)); }));
+    BOOST_TEST_EQ(23, test<my_exception const>([]{ my_exception exc(42); leaf::throw_exception(exc); }));
+    BOOST_TEST_EQ(23, test<my_exception const>([]{ my_exception const exc(42); leaf::throw_exception(exc); }));
 
     BOOST_TEST_EQ(40, test<my_exception>([]{ BOOST_LEAF_THROW_EXCEPTION(info{42}); }));
-    BOOST_TEST_EQ(40, test<my_exception>([]{ throw BOOST_LEAF_EXCEPTION(info{42}); }));
-    BOOST_TEST_EQ(41, test<my_exception>([]{ throw leaf::exception(info{42}); }));
-    BOOST_TEST_EQ(41, test<my_exception>([]{ info inf{42}; throw leaf::exception(inf); }));
-    BOOST_TEST_EQ(41, test<my_exception>([]{ info const inf{42}; throw leaf::exception(inf); }));
+    BOOST_TEST_EQ(41, test<my_exception>([]{ leaf::throw_exception(info{42}); }));
+    BOOST_TEST_EQ(41, test<my_exception>([]{ info inf{42}; leaf::throw_exception(inf); }));
+    BOOST_TEST_EQ(41, test<my_exception>([]{ info const inf{42}; leaf::throw_exception(inf); }));
     BOOST_TEST_EQ(42, test<my_exception>([]{ BOOST_LEAF_THROW_EXCEPTION(); }));
-    BOOST_TEST_EQ(42, test<my_exception>([]{ throw BOOST_LEAF_EXCEPTION(); }));
-    BOOST_TEST_EQ(43, test<my_exception>([]{ throw leaf::exception(); }));
-    BOOST_TEST_EQ(23, test<my_exception>([]{ my_exception exc(42); throw leaf::exception(exc); }));
-    BOOST_TEST_EQ(23, test<my_exception>([]{ my_exception const exc(42); throw leaf::exception(exc); }));
+    BOOST_TEST_EQ(43, test<my_exception>([]{ leaf::throw_exception(); }));
+    BOOST_TEST_EQ(23, test<my_exception>([]{ my_exception exc(42); leaf::throw_exception(exc); }));
+    BOOST_TEST_EQ(23, test<my_exception>([]{ my_exception const exc(42); leaf::throw_exception(exc); }));
 
     BOOST_TEST_EQ(20, test<leaf::catch_<abstract_base_exception>>([]{ BOOST_LEAF_THROW_EXCEPTION(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(20, test<leaf::catch_<abstract_base_exception>>([]{ throw BOOST_LEAF_EXCEPTION(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(21, test<leaf::catch_<abstract_base_exception>>([]{ throw leaf::exception(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(21, test<leaf::catch_<abstract_base_exception>>([]{ my_exception exc(42); throw leaf::exception(exc, info{42}); }));
-    BOOST_TEST_EQ(21, test<leaf::catch_<abstract_base_exception>>([]{ my_exception const exc(42); throw leaf::exception(exc, info{42}); }));
+    BOOST_TEST_EQ(21, test<leaf::catch_<abstract_base_exception>>([]{ leaf::throw_exception(my_exception(42), info{42}); }));
+    BOOST_TEST_EQ(21, test<leaf::catch_<abstract_base_exception>>([]{ my_exception exc(42); leaf::throw_exception(exc, info{42}); }));
+    BOOST_TEST_EQ(21, test<leaf::catch_<abstract_base_exception>>([]{ my_exception const exc(42); leaf::throw_exception(exc, info{42}); }));
     BOOST_TEST_EQ(22, test<leaf::catch_<abstract_base_exception>>([]{ BOOST_LEAF_THROW_EXCEPTION(my_exception(42)); }));
-    BOOST_TEST_EQ(22, test<leaf::catch_<abstract_base_exception>>([]{ throw BOOST_LEAF_EXCEPTION(my_exception(42)); }));
-    BOOST_TEST_EQ(23, test<leaf::catch_<abstract_base_exception>>([]{ throw leaf::exception(my_exception(42)); }));
-    BOOST_TEST_EQ(23, test<leaf::catch_<abstract_base_exception>>([]{ my_exception exc(42); throw leaf::exception(exc); }));
-    BOOST_TEST_EQ(23, test<leaf::catch_<abstract_base_exception>>([]{ my_exception const exc(42); throw leaf::exception(exc); }));
+    BOOST_TEST_EQ(23, test<leaf::catch_<abstract_base_exception>>([]{ leaf::throw_exception(my_exception(42)); }));
+    BOOST_TEST_EQ(23, test<leaf::catch_<abstract_base_exception>>([]{ my_exception exc(42); leaf::throw_exception(exc); }));
+    BOOST_TEST_EQ(23, test<leaf::catch_<abstract_base_exception>>([]{ my_exception const exc(42); leaf::throw_exception(exc); }));
 
     BOOST_TEST_EQ(20, test<abstract_base_exception const &>([]{ BOOST_LEAF_THROW_EXCEPTION(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(20, test<abstract_base_exception const &>([]{ throw BOOST_LEAF_EXCEPTION(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(21, test<abstract_base_exception const &>([]{ throw leaf::exception(my_exception(42), info{42}); }));
-    BOOST_TEST_EQ(21, test<abstract_base_exception const &>([]{ my_exception exc(42); throw leaf::exception(exc, info{42}); }));
-    BOOST_TEST_EQ(21, test<abstract_base_exception const &>([]{ my_exception const exc(42); throw leaf::exception(exc, info{42}); }));
+    BOOST_TEST_EQ(21, test<abstract_base_exception const &>([]{ leaf::throw_exception(my_exception(42), info{42}); }));
+    BOOST_TEST_EQ(21, test<abstract_base_exception const &>([]{ my_exception exc(42); leaf::throw_exception(exc, info{42}); }));
+    BOOST_TEST_EQ(21, test<abstract_base_exception const &>([]{ my_exception const exc(42); leaf::throw_exception(exc, info{42}); }));
     BOOST_TEST_EQ(22, test<abstract_base_exception const &>([]{ BOOST_LEAF_THROW_EXCEPTION(my_exception(42)); }));
-    BOOST_TEST_EQ(22, test<abstract_base_exception const &>([]{ throw BOOST_LEAF_EXCEPTION(my_exception(42)); }));
-    BOOST_TEST_EQ(23, test<abstract_base_exception const &>([]{ throw leaf::exception(my_exception(42)); }));
-    BOOST_TEST_EQ(23, test<abstract_base_exception const &>([]{ my_exception exc(42); throw leaf::exception(exc); }));
-    BOOST_TEST_EQ(23, test<abstract_base_exception const &>([]{ my_exception const exc(42); throw leaf::exception(exc); }));
+    BOOST_TEST_EQ(23, test<abstract_base_exception const &>([]{ leaf::throw_exception(my_exception(42)); }));
+    BOOST_TEST_EQ(23, test<abstract_base_exception const &>([]{ my_exception exc(42); leaf::throw_exception(exc); }));
+    BOOST_TEST_EQ(23, test<abstract_base_exception const &>([]{ my_exception const exc(42); leaf::throw_exception(exc); }));
 
     BOOST_TEST_EQ(40, test<abstract_base_exception &>([]{ BOOST_LEAF_THROW_EXCEPTION(info{42}); }));
-    BOOST_TEST_EQ(40, test<abstract_base_exception &>([]{ throw BOOST_LEAF_EXCEPTION(info{42}); }));
-    BOOST_TEST_EQ(41, test<abstract_base_exception &>([]{ throw leaf::exception(info{42}); }));
-    BOOST_TEST_EQ(41, test<abstract_base_exception &>([]{ info inf{42}; throw leaf::exception(inf); }));
-    BOOST_TEST_EQ(41, test<abstract_base_exception &>([]{ info const inf{42}; throw leaf::exception(inf); }));
+    BOOST_TEST_EQ(41, test<abstract_base_exception &>([]{ leaf::throw_exception(info{42}); }));
+    BOOST_TEST_EQ(41, test<abstract_base_exception &>([]{ info inf{42}; leaf::throw_exception(inf); }));
+    BOOST_TEST_EQ(41, test<abstract_base_exception &>([]{ info const inf{42}; leaf::throw_exception(inf); }));
     BOOST_TEST_EQ(42, test<abstract_base_exception &>([]{ BOOST_LEAF_THROW_EXCEPTION(); }));
-    BOOST_TEST_EQ(42, test<abstract_base_exception &>([]{ throw BOOST_LEAF_EXCEPTION(); }));
-    BOOST_TEST_EQ(43, test<abstract_base_exception &>([]{ throw leaf::exception(); }));
-    BOOST_TEST_EQ(23, test<abstract_base_exception &>([]{ my_exception exc(42); throw leaf::exception(exc); }));
-    BOOST_TEST_EQ(23, test<abstract_base_exception &>([]{ my_exception const exc(42); throw leaf::exception(exc); }));
+    BOOST_TEST_EQ(43, test<abstract_base_exception &>([]{ leaf::throw_exception(); }));
+    BOOST_TEST_EQ(23, test<abstract_base_exception &>([]{ my_exception exc(42); leaf::throw_exception(exc); }));
+    BOOST_TEST_EQ(23, test<abstract_base_exception &>([]{ my_exception const exc(42); leaf::throw_exception(exc); }));
 
     {
         char const * wh = 0;
@@ -216,33 +199,33 @@ int main()
             {
                 wh = ex.what();
             } );
-        BOOST_TEST(wh!=0 || !strcmp(wh,"Test"));
+        BOOST_TEST(wh != 0 || !strcmp(wh,"Test"));
     }
 
     {
-        int const id = leaf::leaf_detail::current_id();
+        int const id = leaf::detail::current_id();
         BOOST_TEST_EQ( 21, test<my_exception const &>( []
         {
             auto load = leaf::on_error(info{42});
             throw my_exception(42);
         } ) );
-        BOOST_TEST_NE(id, leaf::leaf_detail::current_id());
+        BOOST_TEST_NE(id, leaf::detail::current_id());
     }
 
     {
-        int const id = leaf::leaf_detail::current_id();
+        int const id = leaf::detail::current_id();
         BOOST_TEST_EQ( 21, test<my_exception &>( []
         {
             auto load = leaf::on_error(info{42});
             throw my_exception(42);
         } ) );
-        BOOST_TEST_NE(id, leaf::leaf_detail::current_id());
+        BOOST_TEST_NE(id, leaf::detail::current_id());
     }
 
     {
         BOOST_TEST_EQ( 23, test<my_exception const &>( []
         {
-            int const id = leaf::leaf_detail::current_id();
+            int const id = leaf::detail::current_id();
             try
             {
                 leaf::try_catch(
@@ -253,7 +236,7 @@ int main()
             }
             catch(...)
             {
-                BOOST_TEST_EQ(id, leaf::leaf_detail::current_id());
+                BOOST_TEST_EQ(id, leaf::detail::current_id());
                 throw;
             }
         } ) );
@@ -262,7 +245,7 @@ int main()
     {
         BOOST_TEST_EQ( 23, test<my_exception &>( []
         {
-            int const id = leaf::leaf_detail::current_id();
+            int const id = leaf::detail::current_id();
             try
             {
                 leaf::try_catch(
@@ -273,7 +256,7 @@ int main()
             }
             catch(...)
             {
-                BOOST_TEST_EQ(id, leaf::leaf_detail::current_id());
+                BOOST_TEST_EQ(id, leaf::detail::current_id());
                 throw;
             }
         } ) );
@@ -283,7 +266,7 @@ int main()
         leaf::try_catch(
             []
             {
-                throw leaf::exception( info{42} );
+                leaf::throw_exception( info{42} );
             },
             []( info x )
             {
@@ -294,7 +277,7 @@ int main()
             {
                 throw std::exception();
             },
-            []( info x )
+            []( info )
             {
                 return -1;
             },
diff --git a/test/exception_to_result_test.cpp b/test/exception_to_result_test.cpp
index c5838755..d624e41e 100644
--- a/test/exception_to_result_test.cpp
+++ b/test/exception_to_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/function_traits_test.cpp b/test/function_traits_test.cpp
index e8b8ce5b..d7fa9ea2 100644
--- a/test/function_traits_test.cpp
+++ b/test/function_traits_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -16,9 +15,9 @@ namespace leaf = boost::leaf;
 template <class F>
 void check_traits( F )
 {
-    using namespace leaf::leaf_detail;
+    using namespace leaf::detail;
     using leaf::leaf_detail_mp11::mp_list;
-    static_assert(function_traits<F>::arity==4,"arity");
+    static_assert(function_traits<F>::arity == 4,"arity");
     static_assert(std::is_same<fn_return_type<F>,double>::value,"return_type");
     static_assert(std::is_same<fn_arg_type<F,0>,int>::value,"arg<0>");
     static_assert(std::is_same<fn_arg_type<F,1>,float>::value,"arg<1>");
@@ -44,6 +43,6 @@ int main()
         {
             return 42;
         } );
-    static_assert(leaf::leaf_detail::function_traits<int>::arity==-1, "int arity");
+    static_assert(leaf::detail::function_traits<int>::arity == -1, "int arity");
     return 0;
 }
diff --git a/test/github_issue53_test.cpp b/test/github_issue53_test.cpp
new file mode 100644
index 00000000..acc92325
--- /dev/null
+++ b/test/github_issue53_test.cpp
@@ -0,0 +1,76 @@
+// Copyright 2018-2024 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)
+
+#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
+#   include "leaf.hpp"
+#else
+#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/result.hpp>
+#   include <boost/leaf/pred.hpp>
+#endif
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+enum class ErrorCode
+{
+    E_GENERIC_UNEXPECTED,
+    E_GENERIC_PARSE
+};
+
+leaf::result<int> test1( int a )
+{
+    if( a == 1 )
+        return leaf::new_error(ErrorCode::E_GENERIC_UNEXPECTED);
+    return 32;
+}
+
+leaf::result<float> test2(int a)
+{
+    return leaf::try_handle_some(
+        [&]() -> leaf::result<float>
+        {
+            BOOST_LEAF_AUTO(val, test1(a));
+            (void) val;
+            return 4.5;
+        },
+        [](leaf::match<ErrorCode,ErrorCode::E_GENERIC_UNEXPECTED>) -> leaf::result<float>
+        {
+            return leaf::new_error(ErrorCode::E_GENERIC_PARSE);
+        }
+    );
+}
+
+void test3(int a)
+{
+    int x = 0;
+    leaf::try_handle_all(
+        [&]() -> leaf::result<void>
+        {
+            BOOST_LEAF_AUTO(val, test2(a));
+            (void) val;
+            return {};
+        },
+        [&](leaf::match<ErrorCode, ErrorCode::E_GENERIC_PARSE>)
+        {
+            x = 1;
+        },
+        [&](ErrorCode e)
+        {
+            x = 2;
+        },
+        [&]()
+        {
+            x = 3;
+        }
+    );
+    BOOST_TEST_EQ(x, 1);
+}
+
+int main()
+{
+    test3(1);
+    return boost::report_errors();
+}
diff --git a/test/github_issue53x_test.cpp b/test/github_issue53x_test.cpp
new file mode 100644
index 00000000..1c361e64
--- /dev/null
+++ b/test/github_issue53x_test.cpp
@@ -0,0 +1,93 @@
+// Copyright 2018-2024 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>
+
+#ifdef BOOST_LEAF_NO_EXCEPTIONS
+
+#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/handle_errors.hpp>
+#   include <boost/leaf/exception.hpp>
+#   include <boost/leaf/pred.hpp>
+#endif
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+enum class ErrorCode
+{
+    E_GENERIC_UNEXPECTED,
+    E_GENERIC_PARSE
+};
+
+int test1( int a )
+{
+    if( a == 1 )
+        BOOST_LEAF_THROW_EXCEPTION(ErrorCode::E_GENERIC_UNEXPECTED);
+    return 32;
+}
+
+float test2(int a)
+{
+    return leaf::try_catch(
+        [&]
+        {
+            auto val = test1(a);
+            (void) val;
+            return 4.5;
+        },
+        [](leaf::match<ErrorCode,ErrorCode::E_GENERIC_UNEXPECTED>)
+        {
+            BOOST_LEAF_THROW_EXCEPTION(ErrorCode::E_GENERIC_PARSE);
+            return 0;
+        }
+    );
+}
+
+void test3(int a)
+{
+    int x = 0;
+    leaf::try_catch(
+        [&]
+        {
+            auto val = test2(a);
+            (void) val;
+        },
+        [&](leaf::match<ErrorCode, ErrorCode::E_GENERIC_PARSE>)
+        {
+            x = 1;
+        },
+        [&](ErrorCode e)
+        {
+            x = 2;
+        },
+        [&]()
+        {
+            x = 3;
+        }
+    );
+    BOOST_TEST_EQ(x, 1);
+}
+
+int main()
+{
+    test3(1);
+    return boost::report_errors();
+}
+
+#endif
diff --git a/test/handle_all_other_result_test.cpp b/test/handle_all_other_result_test.cpp
index 5520dc25..a5d3a353 100644
--- a/test/handle_all_other_result_test.cpp
+++ b/test/handle_all_other_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -45,7 +44,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 leaf::error_id(r.error()).load(info<42>{42});
 }
 
 template <class ResType>
@@ -67,12 +66,12 @@ void test()
         int r = leaf::try_handle_all(
             [&]
             {
-                auto r = g<ResType>(false);
-                BOOST_TEST(!r);
-                auto ec = r.error();
+                auto r1 = g<ResType>(false);
+                BOOST_TEST(!r1);
+                auto ec = r1.error();
                 BOOST_TEST_EQ(ec.message(), "LEAF error");
                 BOOST_TEST(!std::strcmp(ec.category().name(),"LEAF error"));
-                return r;
+                return r1;
             },
             []( info<42> const & x, std::error_code const & ec )
             {
diff --git a/test/handle_all_test.cpp b/test/handle_all_test.cpp
index 53d6c54d..2a89f010 100644
--- a/test/handle_all_test.cpp
+++ b/test/handle_all_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -35,7 +34,7 @@ struct e_std_error_code { std::error_code value; };
 template <class R>
 leaf::result<R> f( my_error_code ec )
 {
-    if( ec==my_error_code::ok )
+    if( ec == my_error_code::ok )
         return R(42);
     else
         return leaf::new_error(ec, e_my_error_code{ec}, info<1>{1}, info<2>{2}, info<3>{3});
@@ -57,7 +56,7 @@ leaf::result<R> f_errc_wrapped( Errc ec )
 
 struct move_only
 {
-    explicit move_only( int value ): value(value) { }
+    explicit move_only( int val ): value(val) { }
     int value;
 
 #ifndef BOOST_LEAF_NO_CXX11_REF_QUALIFIERS
@@ -98,7 +97,7 @@ int main()
             },
             [&c]( my_error_code ec, info<1> const & x,info<2> y )
             {
-                BOOST_TEST(ec==my_error_code::error1);
+                BOOST_TEST(ec == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
@@ -195,7 +194,7 @@ int main()
             },
             [&c]( leaf::match<my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
@@ -226,7 +225,7 @@ int main()
             },
             [&c]( leaf::match<my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
@@ -257,7 +256,7 @@ int main()
             },
             [&c]( leaf::match_value<e_my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
@@ -288,7 +287,7 @@ int main()
             },
             [&c]( leaf::match_value<e_my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
@@ -302,7 +301,7 @@ int main()
         BOOST_TEST_EQ(c, 2);
     }
 
-    //////////////////////////////////////
+    ////////////////////////////////////////
 
     // int, try_handle_all (success)
     {
@@ -329,7 +328,7 @@ int main()
             },
             []( my_error_code ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec==my_error_code::error1);
+                BOOST_TEST(ec == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 1;
@@ -411,7 +410,7 @@ int main()
             },
             []( leaf::match<my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -437,7 +436,7 @@ int main()
             },
             []( leaf::match<my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -463,7 +462,7 @@ int main()
             },
             []( leaf::match_value<e_my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -489,7 +488,7 @@ int main()
             },
             []( leaf::match_value<e_my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -501,7 +500,7 @@ int main()
         BOOST_TEST_EQ(r, 2);
     }
 
-    //////////////////////////////////////
+    ////////////////////////////////////////
 
     // move_only, try_handle_all (success)
     {
@@ -528,7 +527,7 @@ int main()
             },
             []( my_error_code ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec==my_error_code::error1);
+                BOOST_TEST(ec == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return move_only(1);
@@ -610,7 +609,7 @@ int main()
             },
             []( leaf::match<my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return move_only(2);
@@ -636,7 +635,7 @@ int main()
             },
             []( leaf::match<my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return move_only(2);
@@ -662,7 +661,7 @@ int main()
             },
             []( leaf::match_value<e_my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return move_only(2);
@@ -688,7 +687,7 @@ int main()
             },
             []( leaf::match_value<e_my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return move_only(2);
diff --git a/test/handle_basic_test.cpp b/test/handle_basic_test.cpp
index 053c6f0b..6423c23d 100644
--- a/test/handle_basic_test.cpp
+++ b/test/handle_basic_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -46,7 +45,7 @@ leaf::result<int> compute_answer( int what_to_do ) noexcept
     case 5:
         return leaf::new_error(error2_tag{}, error_code::error2);
     default:
-        BOOST_LEAF_ASSERT(what_to_do==6);
+        BOOST_LEAF_ASSERT(what_to_do == 6);
         return leaf::new_error(error3_tag{}, error_code::error3);
     }
 }
@@ -172,7 +171,7 @@ int main()
         BOOST_TEST_EQ(r, 1);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     BOOST_TEST_EQ(handle_some_errors(0).value(), 42);
     BOOST_TEST_EQ(handle_some_errors(1).value(), -2);
@@ -196,7 +195,7 @@ int main()
         BOOST_TEST_EQ(r, 1);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     BOOST_TEST_EQ(handle_some_errors_float(0).value(), 42.0f);
     BOOST_TEST_EQ(handle_some_errors_float(2).value(), -2.0f);
@@ -220,7 +219,7 @@ int main()
         BOOST_TEST_EQ(r, 1);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     BOOST_TEST(handle_some_errors_void(0));
     BOOST_TEST(handle_some_errors_void(3));
@@ -242,7 +241,7 @@ int main()
         BOOST_TEST_EQ(r, 1);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
     {
@@ -264,7 +263,7 @@ int main()
     }
 #endif
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     {
         int r = leaf::try_handle_all(
@@ -275,7 +274,7 @@ int main()
             []( info<1> const & i1 )
             {
                 BOOST_TEST_EQ(i1.value, 42);
-                int r = leaf::try_handle_all(
+                int r1 = leaf::try_handle_all(
                     []() -> leaf::result<int>
                     {
                         return leaf::new_error( info<1>{43} );
@@ -284,7 +283,7 @@ int main()
                     {
                         return -1;
                     } );
-                BOOST_TEST_EQ(r, -1);
+                BOOST_TEST_EQ(r1, -1);
                 BOOST_TEST_EQ(i1.value, 42);
                 return 0;
             },
@@ -295,7 +294,7 @@ int main()
         BOOST_TEST_EQ(r, 0);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     {
         int r = leaf::try_handle_all(
@@ -306,21 +305,21 @@ int main()
             []( info<1> const & i1 )
             {
                 BOOST_TEST_EQ(i1.value, 42);
-                int r = leaf::try_handle_all(
+                int r1 = leaf::try_handle_all(
                     []() -> leaf::result<int>
                     {
                         return leaf::new_error( info<1>{43} );
                     },
-                    []( info<1> const & i1 )
+                    []( info<1> const & i1_ )
                     {
-                        BOOST_TEST_EQ(i1.value, 43);
+                        BOOST_TEST_EQ(i1_.value, 43);
                         return -1;
                     },
                     []()
                     {
                         return -2;
                     } );
-                BOOST_TEST_EQ(r, -1);
+                BOOST_TEST_EQ(r1, -1);
                 BOOST_TEST_EQ(i1.value, 42);
                 return 0;
             },
@@ -331,7 +330,7 @@ int main()
         BOOST_TEST_EQ(r, 0);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     {
         int r = leaf::try_handle_all(
@@ -363,7 +362,7 @@ int main()
         BOOST_TEST_EQ(r, 0);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     {
         int r = leaf::try_handle_all(
@@ -395,7 +394,7 @@ int main()
         BOOST_TEST_EQ(r, 0);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     return boost::report_errors();
 }
diff --git a/test/handle_some_other_result_test.cpp b/test/handle_some_other_result_test.cpp
index d42e0292..c955d4e4 100644
--- a/test/handle_some_other_result_test.cpp
+++ b/test/handle_some_other_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -46,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 leaf::error_id(r.error()).load(info<42>{42});
 }
 
 template <class ResType>
@@ -66,12 +65,12 @@ void test()
         ResType r = leaf::try_handle_some(
             [&]
             {
-                auto r = g<ResType>(false);
-                BOOST_TEST(!r);
-                auto ec = r.error();
+                auto r1 = g<ResType>(false);
+                BOOST_TEST(!r1);
+                auto ec = r1.error();
                 BOOST_TEST_EQ(ec.message(), "LEAF error");
                 BOOST_TEST(!std::strcmp(ec.category().name(),"LEAF error"));
-                return r;
+                return r1;
             },
             [&]( info<42> const & x, leaf::match<leaf::condition<cond_x>, cond_x::x00> ec )
             {
diff --git a/test/handle_some_test.cpp b/test/handle_some_test.cpp
index 4801f16a..ba02e8a4 100644
--- a/test/handle_some_test.cpp
+++ b/test/handle_some_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -35,7 +34,7 @@ struct e_std_error_code { std::error_code value; };
 template <class R>
 leaf::result<R> f( my_error_code ec )
 {
-    if( ec==my_error_code::ok )
+    if( ec == my_error_code::ok )
         return R(42);
     else
         return leaf::new_error(ec, e_my_error_code{ec}, info<1>{1}, info<2>{2}, info<3>{3});
@@ -89,7 +88,7 @@ int main()
             },
             [&c]( my_error_code ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec==my_error_code::error1);
+                BOOST_TEST(ec == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
@@ -164,7 +163,7 @@ int main()
             },
             [&c]( leaf::match<my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
@@ -191,7 +190,7 @@ int main()
             },
             [&c]( leaf::match<my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
@@ -218,7 +217,7 @@ int main()
             },
             [&c]( leaf::match_value<e_my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
@@ -245,7 +244,7 @@ int main()
             },
             [&c]( leaf::match_value<e_my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
@@ -279,13 +278,13 @@ int main()
             },
             [&c]( my_error_code ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec==my_error_code::error1);
+                BOOST_TEST(ec == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -324,7 +323,7 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -364,7 +363,7 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -397,13 +396,13 @@ int main()
             },
             [&c]( leaf::match<my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -435,13 +434,13 @@ int main()
             },
             [&c]( leaf::match<my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -473,13 +472,13 @@ int main()
             },
             [&c]( leaf::match_value<e_my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -511,13 +510,13 @@ int main()
             },
             [&c]( leaf::match_value<e_my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -540,7 +539,7 @@ int main()
                     },
                     [&c]( my_error_code ec, info<1> const & x, info<2> y )
                     {
-                        BOOST_TEST(ec==my_error_code::error1);
+                        BOOST_TEST(ec == my_error_code::error1);
                         BOOST_TEST_EQ(x.value, 1);
                         BOOST_TEST_EQ(y.value, 2);
                         BOOST_TEST_EQ(c, 0);
@@ -555,7 +554,7 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -594,7 +593,7 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -634,7 +633,7 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -658,7 +657,7 @@ int main()
                     },
                     [&c]( leaf::match<my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
                     {
-                        BOOST_TEST(ec.matched==my_error_code::error1);
+                        BOOST_TEST(ec.matched == my_error_code::error1);
                         BOOST_TEST_EQ(x.value, 1);
                         BOOST_TEST_EQ(y.value, 2);
                         BOOST_TEST_EQ(c, 0);
@@ -673,7 +672,7 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -696,7 +695,7 @@ int main()
                     },
                     [&c]( leaf::match<my_error_code, my_error_code::error2, my_error_code::error1> ec, info<1> const & x, info<2> y )
                     {
-                        BOOST_TEST(ec.matched==my_error_code::error1);
+                        BOOST_TEST(ec.matched == my_error_code::error1);
                         BOOST_TEST_EQ(x.value, 1);
                         BOOST_TEST_EQ(y.value, 2);
                         BOOST_TEST_EQ(c, 0);
@@ -711,7 +710,7 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -734,7 +733,7 @@ int main()
                     },
                     [&c]( leaf::match_value<e_my_error_code, my_error_code::error1> ec, info<1> const & x, info<2> y )
                     {
-                        BOOST_TEST(ec.matched.value==my_error_code::error1);
+                        BOOST_TEST(ec.matched.value == my_error_code::error1);
                         BOOST_TEST_EQ(x.value, 1);
                         BOOST_TEST_EQ(y.value, 2);
                         BOOST_TEST_EQ(c, 0);
@@ -749,7 +748,7 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -772,7 +771,7 @@ int main()
                     },
                     [&c]( leaf::match_value<e_my_error_code, my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
                     {
-                        BOOST_TEST(ec.matched.value==my_error_code::error1);
+                        BOOST_TEST(ec.matched.value == my_error_code::error1);
                         BOOST_TEST_EQ(x.value, 1);
                         BOOST_TEST_EQ(y.value, 2);
                         BOOST_TEST_EQ(c, 0);
@@ -787,7 +786,7 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
@@ -795,7 +794,7 @@ int main()
         BOOST_TEST_EQ(c, 1);
     }
 
-    //////////////////////////////////////
+    ////////////////////////////////////////
 
     // int, try_handle_some (success)
     {
@@ -822,7 +821,7 @@ int main()
             },
             []( my_error_code ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec==my_error_code::error1);
+                BOOST_TEST(ec == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 1;
@@ -870,7 +869,7 @@ int main()
             },
             []( leaf::match<my_error_code,my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -893,7 +892,7 @@ int main()
             },
             []( leaf::match<my_error_code,my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -916,7 +915,7 @@ int main()
             },
             []( leaf::match_value<e_my_error_code,my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -939,7 +938,7 @@ int main()
             },
             []( leaf::match_value<e_my_error_code,my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -953,7 +952,7 @@ int main()
         int r = leaf::try_handle_all(
             []
             {
-                leaf::result<int> r = leaf::try_handle_some(
+                leaf::result<int> r1 = leaf::try_handle_some(
                     []() -> leaf::result<int>
                     {
                         BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
@@ -963,12 +962,12 @@ int main()
                     {
                         return 1;
                     } );
-                BOOST_TEST(!r);
-                return r;
+                BOOST_TEST(!r1);
+                return r1;
             },
             []( my_error_code ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec==my_error_code::error1);
+                BOOST_TEST(ec == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -986,7 +985,7 @@ int main()
         int r = leaf::try_handle_all(
             []
             {
-                leaf::result<int> r = leaf::try_handle_some(
+                leaf::result<int> r1 = leaf::try_handle_some(
                     []() -> leaf::result<int>
                     {
                         BOOST_LEAF_AUTO(answer, f_errc<int>(errc_a::a0));
@@ -996,8 +995,8 @@ int main()
                     {
                         return 1;
                     } );
-                BOOST_TEST(!r);
-                return r;
+                BOOST_TEST(!r1);
+                return r1;
             },
             []( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
             {
@@ -1014,12 +1013,46 @@ int main()
     }
 #endif
 
+#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+    // int, try_handle_some (failure, initially not matched), match cond_x (wrapped std::error_code)
+    {
+        int r = leaf::try_handle_all(
+            []
+            {
+                leaf::result<int> r1 = leaf::try_handle_some(
+                    []() -> leaf::result<int>
+                    {
+                        BOOST_LEAF_AUTO(answer, f_errc_wrapped<int>(errc_a::a0));
+                        return answer;
+                    },
+                    []( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x11> )
+                    {
+                        return 1;
+                    } );
+                BOOST_TEST(!r1);
+                return r1;
+            },
+            []( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
+            {
+                BOOST_TEST_EQ(ec.matched.value, make_error_code(errc_a::a0));
+                BOOST_TEST_EQ(x.value, 1);
+                BOOST_TEST_EQ(y.value, 2);
+                return 2;
+            },
+            []
+            {
+                return 3;
+            } );
+        BOOST_TEST_EQ(r, 2);
+    }
+#endif
+
     // int, try_handle_some (failure, initially not matched), match enum (single enum value)
     {
         int r = leaf::try_handle_all(
             []
             {
-                leaf::result<int> r = leaf::try_handle_some(
+                leaf::result<int> r1 = leaf::try_handle_some(
                     []() -> leaf::result<int>
                     {
                         BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
@@ -1029,12 +1062,12 @@ int main()
                     {
                         return 1;
                     } );
-                BOOST_TEST(!r);
-                return r;
+                BOOST_TEST(!r1);
+                return r1;
             },
             []( leaf::match<my_error_code,my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -1051,7 +1084,7 @@ int main()
         int r = leaf::try_handle_all(
             []
             {
-                leaf::result<int> r = leaf::try_handle_some(
+                leaf::result<int> r1 = leaf::try_handle_some(
                     []() -> leaf::result<int>
                     {
                         BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
@@ -1061,12 +1094,12 @@ int main()
                     {
                         return 1;
                     } );
-                BOOST_TEST(!r);
-                return r;
+                BOOST_TEST(!r1);
+                return r1;
             },
             []( leaf::match<my_error_code,my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched==my_error_code::error1);
+                BOOST_TEST(ec.matched == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -1083,7 +1116,7 @@ int main()
         int r = leaf::try_handle_all(
             []
             {
-                leaf::result<int> r = leaf::try_handle_some(
+                leaf::result<int> r1 = leaf::try_handle_some(
                     []() -> leaf::result<int>
                     {
                         BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
@@ -1093,12 +1126,12 @@ int main()
                     {
                         return 1;
                     } );
-                BOOST_TEST(!r);
-                return r;
+                BOOST_TEST(!r1);
+                return r1;
             },
             []( leaf::match_value<e_my_error_code,my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -1115,7 +1148,7 @@ int main()
         int r = leaf::try_handle_all(
             []
             {
-                leaf::result<int> r = leaf::try_handle_some(
+                leaf::result<int> r1 = leaf::try_handle_some(
                     []() -> leaf::result<int>
                     {
                         BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
@@ -1125,12 +1158,12 @@ int main()
                     {
                         return 1;
                     } );
-                BOOST_TEST(!r);
-                return r;
+                BOOST_TEST(!r1);
+                return r1;
             },
             []( leaf::match_value<e_my_error_code,my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
             {
-                BOOST_TEST(ec.matched.value==my_error_code::error1);
+                BOOST_TEST(ec.matched.value == my_error_code::error1);
                 BOOST_TEST_EQ(x.value, 1);
                 BOOST_TEST_EQ(y.value, 2);
                 return 2;
@@ -1147,7 +1180,7 @@ int main()
         int r = leaf::try_handle_all(
             []
             {
-                leaf::result<int> r = leaf::try_handle_some(
+                leaf::result<int> r1 = leaf::try_handle_some(
                     []() -> leaf::result<int>
                     {
                         BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
@@ -1155,13 +1188,13 @@ int main()
                     },
                     []( my_error_code ec, info<1> const & x, info<2> y )
                     {
-                        BOOST_TEST(ec==my_error_code::error1);
+                        BOOST_TEST(ec == my_error_code::error1);
                         BOOST_TEST_EQ(x.value, 1);
                         BOOST_TEST_EQ(y.value, 2);
                         return 1;
                     } );
-                BOOST_TEST(r);
-                return r;
+                BOOST_TEST(r1);
+                return r1;
             },
             []( info<4> )
             {
@@ -1174,12 +1207,80 @@ int main()
         BOOST_TEST_EQ(r, 1);
     }
 
+#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+    // int, try_handle_some (failure, initially matched), match cond_x (single enum value)
+    {
+        int r = leaf::try_handle_all(
+            []
+            {
+                leaf::result<int> r1 = leaf::try_handle_some(
+                    []() -> leaf::result<int>
+                    {
+                        BOOST_LEAF_AUTO(answer, f_errc<int>(errc_a::a0));
+                        return answer;
+                    },
+                    []( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
+                    {
+                        BOOST_TEST_EQ(ec.matched, make_error_code(errc_a::a0));
+                        BOOST_TEST_EQ(x.value, 1);
+                        BOOST_TEST_EQ(y.value, 2);
+                        return 1;
+                    } );
+                BOOST_TEST(r1);
+                return r1;
+            },
+            []( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
+            {
+                return 2;
+            },
+            []
+            {
+                return 3;
+            } );
+        BOOST_TEST_EQ(r, 1);
+    }
+#endif
+
+#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+    // int, try_handle_some (failure, initially matched), match cond_x (wrapped std::error_code)
+    {
+        int r = leaf::try_handle_all(
+            []
+            {
+                leaf::result<int> r1 = leaf::try_handle_some(
+                    []() -> leaf::result<int>
+                    {
+                        BOOST_LEAF_AUTO(answer, f_errc_wrapped<int>(errc_a::a0));
+                        return answer;
+                    },
+                    []( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
+                    {
+                        BOOST_TEST_EQ(ec.matched.value, make_error_code(errc_a::a0));
+                        BOOST_TEST_EQ(x.value, 1);
+                        BOOST_TEST_EQ(y.value, 2);
+                        return 1;
+                    } );
+                BOOST_TEST(r1);
+                return r1;
+            },
+            []( leaf::match_value<leaf::condition<e_std_error_code, cond_x>, cond_x::x11> )
+            {
+                return 2;
+            },
+            []
+            {
+                return 3;
+            } );
+        BOOST_TEST_EQ(r, 1);
+    }
+#endif
+
     // int, try_handle_some (failure, initially matched), match enum (single enum value)
     {
         int r = leaf::try_handle_all(
             []
             {
-                leaf::result<int> r = leaf::try_handle_some(
+                leaf::result<int> r1 = leaf::try_handle_some(
                     []() -> leaf::result<int>
                     {
                         BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
@@ -1187,13 +1288,13 @@ int main()
                     },
                     []( leaf::match<my_error_code,my_error_code::error1> ec, info<1> const & x, info<2> y )
                     {
-                        BOOST_TEST(ec.matched==my_error_code::error1);
+                        BOOST_TEST(ec.matched == my_error_code::error1);
                         BOOST_TEST_EQ(x.value, 1);
                         BOOST_TEST_EQ(y.value, 2);
                         return 1;
                     } );
-                BOOST_TEST(r);
-                return r;
+                BOOST_TEST(r1);
+                return r1;
             },
             []( leaf::match<my_error_code,my_error_code::error2> )
             {
@@ -1211,7 +1312,7 @@ int main()
         int r = leaf::try_handle_all(
             []
             {
-                leaf::result<int> r = leaf::try_handle_some(
+                leaf::result<int> r1 = leaf::try_handle_some(
                     []() -> leaf::result<int>
                     {
                         BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
@@ -1219,13 +1320,13 @@ int main()
                     },
                     []( leaf::match<my_error_code,my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
                     {
-                        BOOST_TEST(ec.matched==my_error_code::error1);
+                        BOOST_TEST(ec.matched == my_error_code::error1);
                         BOOST_TEST_EQ(x.value, 1);
                         BOOST_TEST_EQ(y.value, 2);
                         return 1;
                     } );
-                BOOST_TEST(r);
-                return r;
+                BOOST_TEST(r1);
+                return r1;
             },
             []( leaf::match<my_error_code,my_error_code::error2> )
             {
@@ -1243,7 +1344,7 @@ int main()
         int r = leaf::try_handle_all(
             []
             {
-                leaf::result<int> r = leaf::try_handle_some(
+                leaf::result<int> r1 = leaf::try_handle_some(
                     []() -> leaf::result<int>
                     {
                         BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
@@ -1251,13 +1352,13 @@ int main()
                     },
                     []( leaf::match_value<e_my_error_code,my_error_code::error1> ec, info<1> const & x, info<2> y )
                     {
-                        BOOST_TEST(ec.matched.value==my_error_code::error1);
+                        BOOST_TEST(ec.matched.value == my_error_code::error1);
                         BOOST_TEST_EQ(x.value, 1);
                         BOOST_TEST_EQ(y.value, 2);
                         return 1;
                     } );
-                BOOST_TEST(r);
-                return r;
+                BOOST_TEST(r1);
+                return r1;
             },
             []( leaf::match_value<e_my_error_code,my_error_code::error2> )
             {
@@ -1275,7 +1376,7 @@ int main()
         int r = leaf::try_handle_all(
             []
             {
-                leaf::result<int> r = leaf::try_handle_some(
+                leaf::result<int> r1 = leaf::try_handle_some(
                     []() -> leaf::result<int>
                     {
                         BOOST_LEAF_AUTO(answer, f<int>(my_error_code::error1));
@@ -1283,13 +1384,13 @@ int main()
                     },
                     []( leaf::match_value<e_my_error_code,my_error_code::error2,my_error_code::error1> ec, info<1> const & x, info<2> y )
                     {
-                        BOOST_TEST(ec.matched.value==my_error_code::error1);
+                        BOOST_TEST(ec.matched.value == my_error_code::error1);
                         BOOST_TEST_EQ(x.value, 1);
                         BOOST_TEST_EQ(y.value, 2);
                         return 1;
                     } );
-                BOOST_TEST(r);
-                return r;
+                BOOST_TEST(r1);
+                return r1;
             },
             []( leaf::match_value<e_my_error_code,my_error_code::error2> )
             {
@@ -1302,5 +1403,113 @@ int main()
         BOOST_TEST_EQ(r, 1);
     }
 
+    ////////////////////////////////////////
+
+    // no exception caught, error handled
+    {
+        int handle_some_handler_called = 0;
+        leaf::result<int> r = leaf::try_handle_some(
+            []() -> leaf::result<int>
+            {
+                return leaf::new_error( info<0>{1} );
+            },
+            [&]( info<0> & x )
+            {
+                BOOST_TEST_EQ(x.value, 1);
+                ++handle_some_handler_called;
+                return 1;
+            } );
+        BOOST_TEST_EQ(r.value(), 1);
+        BOOST_TEST_EQ(handle_some_handler_called, 1);
+    }
+
+    // no exception caught, error not handled
+    {
+        int handle_some_handler_called = 0;
+        int r = leaf::try_handle_all(
+            [&]
+            {
+                leaf::result<int> r1 = leaf::try_handle_some(
+                    []() -> leaf::result<int>
+                    {
+                        return leaf::new_error( info<0>{1} );
+                    },
+                    [&]( leaf::error_info const & e, info<0> & x ) -> leaf::result<int>
+                    {
+                        BOOST_TEST_EQ(x.value, 1);
+                        ++handle_some_handler_called;
+                        return e.error();
+                    } );
+                BOOST_TEST(!r1);
+                BOOST_TEST_EQ(handle_some_handler_called, 1);
+                return r1;
+            },
+            [](info<0> & x)
+            {
+                BOOST_TEST_EQ(x.value, 1);
+                return 1;
+            },
+            []
+            {
+                return 2;
+            });
+        BOOST_TEST_EQ(r, 1);
+    }
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+    // exception caught, error handled
+    {
+        int handle_some_handler_called = 0;
+        leaf::result<int> r = leaf::try_handle_some(
+            []() -> leaf::result<int>
+            {
+                BOOST_LEAF_THROW_EXCEPTION( info<0>{1} );
+            },
+            [&]( info<0> & x ) -> leaf::result<int>
+            {
+                BOOST_TEST_EQ(x.value, 1);
+                ++handle_some_handler_called;
+                return 1;
+            } );
+        BOOST_TEST_EQ(r.value(), 1);
+        BOOST_TEST_EQ(handle_some_handler_called, 1);
+    }
+#endif
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+    // exception caught, error not handled
+    {     
+        int handle_some_handler_called = 0;
+        int r = leaf::try_handle_all(
+            [&]
+            {
+                leaf::result<int> r = leaf::try_handle_some(
+                    []() -> leaf::result<int>
+                    {
+                        BOOST_LEAF_THROW_EXCEPTION( info<0>{1} );
+                    },
+                    [&]( leaf::error_info const & e, info<0> & x ) -> leaf::result<int>
+                    {
+                        BOOST_TEST_EQ(x.value, 1);
+                        ++handle_some_handler_called;
+                        return e.error();
+                    } );
+                BOOST_TEST(!r);
+                BOOST_TEST_EQ(handle_some_handler_called, 1);
+                return r;
+            },
+            []( info<0> & x )
+            {
+                BOOST_TEST_EQ(x.value, 1);
+                return 1;
+            },
+            []
+            {
+                return 2;
+            });
+        BOOST_TEST_EQ(r, 1);
+    }
+#endif
+
     return boost::report_errors();
 }
diff --git a/test/lightweight_test.hpp b/test/lightweight_test.hpp
index 7b7ffd47..2e060d24 100644
--- a/test/lightweight_test.hpp
+++ b/test/lightweight_test.hpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -10,10 +9,16 @@
 #ifdef BOOST_LEAF_NO_EXCEPTIONS
 namespace boost
 {
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e )
+    [[noreturn]] void throw_exception( std::exception const & e )
     {
         std::cerr << "Terminating due to a C++ exception under BOOST_LEAF_NO_EXCEPTIONS: " << e.what();
         std::terminate();
     }
+
+    struct source_location;
+    [[noreturn]] void throw_exception( std::exception const & e, boost::source_location const & )
+    {
+        throw_exception(e);
+    }
 }
 #endif
diff --git a/test/match_member_test.cpp b/test/match_member_test.cpp
index 350c3d6f..8ab4e28d 100644
--- a/test/match_member_test.cpp
+++ b/test/match_member_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/match_test.cpp b/test/match_test.cpp
index 3592d982..2c7f0fde 100644
--- a/test/match_test.cpp
+++ b/test/match_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -164,7 +163,7 @@ int main()
                 return 1;
             },
 
-            []( my_error e )
+            []( my_error )
             {
                 return 2;
             },
@@ -188,7 +187,7 @@ int main()
                 return 1;
             },
 
-            []( my_error e )
+            []( my_error )
             {
                 return 2;
             },
@@ -246,7 +245,7 @@ int main()
                 return leaf::new_error(e_my_error{42});
             },
 
-            []( leaf::match<e_my_error, e_my_error_gt<41>> m )
+            []( leaf::match<e_my_error, e_my_error_gt<41>> )
             {
                 return 1;
             },
@@ -265,7 +264,7 @@ int main()
                 return leaf::new_error(e_my_error{42});
             },
 
-            []( leaf::match<e_my_error, e_my_error_gt<42>> m )
+            []( leaf::match<e_my_error, e_my_error_gt<42>> )
             {
                 return 1;
             },
diff --git a/test/match_value_test.cpp b/test/match_value_test.cpp
index 41054235..1ee3d8c1 100644
--- a/test/match_value_test.cpp
+++ b/test/match_value_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/multiple_errors_test.cpp b/test/multiple_errors_test.cpp
index da1e74ea..8f36d1bd 100644
--- a/test/multiple_errors_test.cpp
+++ b/test/multiple_errors_test.cpp
@@ -1,10 +1,10 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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/handle_errors.hpp>
+#include <boost/leaf/on_error.hpp>
 
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
@@ -68,7 +68,7 @@ int main()
             {
                 try
                 {
-                    throw leaf::exception(info<4>{4});
+                    leaf::throw_exception(info<4>{4});
                 }
                 catch(...)
                 {
@@ -85,6 +85,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/accumulate_basic_test.cpp b/test/on_error_accumulate_basic_test.cpp
similarity index 93%
rename from test/accumulate_basic_test.cpp
rename to test/on_error_accumulate_basic_test.cpp
index 928d7025..161855d8 100644
--- a/test/accumulate_basic_test.cpp
+++ b/test/on_error_accumulate_basic_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -18,7 +17,7 @@ namespace leaf = boost::leaf;
 template <int>
 struct info
 {
-    int value;
+    int value = 0;
 };
 
 leaf::error_id g()
diff --git a/test/accumulate_nested_error_exception_test.cpp b/test/on_error_accumulate_nested_error_exception_test.cpp
similarity index 93%
rename from test/accumulate_nested_error_exception_test.cpp
rename to test/on_error_accumulate_nested_error_exception_test.cpp
index 163be9ac..b45c56c8 100644
--- a/test/accumulate_nested_error_exception_test.cpp
+++ b/test/on_error_accumulate_nested_error_exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -38,7 +37,7 @@ struct info
 void f0()
 {
     auto load = leaf::on_error( []( info<0> & ) { } );
-    throw leaf::exception(info<2>{2});
+    leaf::throw_exception(info<2>{2});
 }
 
 void f1()
diff --git a/test/accumulate_nested_error_result_test.cpp b/test/on_error_accumulate_nested_error_result_test.cpp
similarity index 77%
rename from test/accumulate_nested_error_result_test.cpp
rename to test/on_error_accumulate_nested_error_result_test.cpp
index f5896b44..73bd59ee 100644
--- a/test/accumulate_nested_error_result_test.cpp
+++ b/test/on_error_accumulate_nested_error_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -15,27 +14,35 @@
 
 namespace leaf = boost::leaf;
 
-template <int>
+template <int A>
 struct info
 {
     int value;
+    info():
+        value(0)
+    {
+    }
+    explicit info(int value):
+        value(value)
+    {
+    }
 };
 
 leaf::error_id f0()
 {
     auto load = leaf::on_error( []( info<0> & ) { } );
-    return leaf::new_error( info<2>{2} );
+    return leaf::new_error( info<2>(2) );
 }
 
 leaf::error_id f1()
 {
-    auto load = leaf::on_error( info<0>{-1}, info<2>{-1}, []( info<1> & x ) {++x.value;} );
+    auto load = leaf::on_error( info<0>(-1), info<2>(-1), []( info<1> & x ) {++x.value;} );
     return f0();
 }
 
 leaf::error_id f2()
 {
-    return f1().load( info<3>{3} );
+    return f1().load( info<3>(3) );
 }
 
 int main()
diff --git a/test/accumulate_nested_new_error_exception_test.cpp b/test/on_error_accumulate_nested_new_error_exception_test.cpp
similarity index 76%
rename from test/accumulate_nested_new_error_exception_test.cpp
rename to test/on_error_accumulate_nested_new_error_exception_test.cpp
index 91b29971..c14ba861 100644
--- a/test/accumulate_nested_new_error_exception_test.cpp
+++ b/test/on_error_accumulate_nested_new_error_exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -33,19 +32,27 @@ template <int A>
 struct info
 {
     int value;
+    info():
+        value(0)
+    {
+    }
+    explicit info(int value):
+        value(value)
+    {
+    }
 };
 
 void f0()
 {
-    auto load = leaf::on_error( info<0>{-1} );
-    throw leaf::exception(info<1>{-1});
+    auto load = leaf::on_error( info<0>(-1) );
+    leaf::throw_exception(info<1>(-1));
 }
 
 void f1()
 {
-    auto load = leaf::on_error( []( info<0> & x ) { }, []( info<1> & x ) { ++x.value; }, []( info<2> & x ) { ++x.value; } );
+    auto load = leaf::on_error( []( info<0> & ) { }, []( info<1> & x ) { ++x.value; }, []( info<2> & x ) { ++x.value; } );
     try { f0(); } catch(...) { }
-    throw leaf::exception();
+    leaf::throw_exception();
 }
 
 leaf::error_id f2()
@@ -57,7 +64,7 @@ leaf::error_id f2()
     }
     catch( leaf::error_id const & err )
     {
-        err.load( info<3>{3} );
+        err.load( info<3>(3) );
         throw;
     }
     catch(...)
diff --git a/test/accumulate_nested_new_error_result_test.cpp b/test/on_error_accumulate_nested_new_error_result_test.cpp
similarity index 72%
rename from test/accumulate_nested_new_error_result_test.cpp
rename to test/on_error_accumulate_nested_new_error_result_test.cpp
index 59c8cef3..0f330285 100644
--- a/test/accumulate_nested_new_error_result_test.cpp
+++ b/test/on_error_accumulate_nested_new_error_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -19,24 +18,32 @@ template <int A>
 struct info
 {
     int value;
+    info():
+        value(0)
+    {
+    }
+    explicit info(int value):
+        value(value)
+    {
+    }
 };
 
 leaf::error_id f0()
 {
-    auto load = leaf::on_error( info<0>{-1} );
-    return leaf::new_error( info<1>{-1} );
+    auto load = leaf::on_error( info<0>(-1) );
+    return leaf::new_error( info<1>(-1) );
 }
 
 leaf::error_id f1()
 {
-    auto load = leaf::on_error( []( info<0> & x ) { }, []( info<1> & x ) { ++x.value; }, []( info<2> & x ) { ++x.value; } );
+    auto load = leaf::on_error( []( info<0> & ) { }, []( info<1> & x ) { ++x.value; }, []( info<2> & x ) { ++x.value; } );
     (void) f0();
     return leaf::new_error();
 }
 
 leaf::error_id f2()
 {
-    return f1().load( info<3>{3} );
+    return f1().load( info<3>(3) );
 }
 
 int main()
diff --git a/test/accumulate_nested_success_exception_test.cpp b/test/on_error_accumulate_nested_success_exception_test.cpp
similarity index 94%
rename from test/accumulate_nested_success_exception_test.cpp
rename to test/on_error_accumulate_nested_success_exception_test.cpp
index ad8edc66..a85f2beb 100644
--- a/test/accumulate_nested_success_exception_test.cpp
+++ b/test/on_error_accumulate_nested_success_exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/accumulate_nested_success_result_test.cpp b/test/on_error_accumulate_nested_success_result_test.cpp
similarity index 94%
rename from test/accumulate_nested_success_result_test.cpp
rename to test/on_error_accumulate_nested_success_result_test.cpp
index fe068eb1..544497a7 100644
--- a/test/accumulate_nested_success_result_test.cpp
+++ b/test/on_error_accumulate_nested_success_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/defer_basic_test.cpp b/test/on_error_defer_basic_test.cpp
similarity index 63%
rename from test/defer_basic_test.cpp
rename to test/on_error_defer_basic_test.cpp
index 0f460f80..50ee5654 100644
--- a/test/defer_basic_test.cpp
+++ b/test/on_error_defer_basic_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -7,15 +6,21 @@
 #   include "leaf.hpp"
 #else
 #   include <boost/leaf/on_error.hpp>
-#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/diagnostics.hpp>
 #   include <boost/leaf/result.hpp>
 #endif
 
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
 #include "lightweight_test.hpp"
-#include <sstream>
 
 namespace leaf = boost::leaf;
 
+int cleanup_count;
+
 int global;
 
 int get_global() noexcept
@@ -32,13 +37,14 @@ struct info
 leaf::error_id g()
 {
     global = 0;
-    auto load = leaf::on_error( []{ return info<42>{get_global()}; }, []{ return info<-42>{-42}; } );
+    auto load = leaf::on_error( []{++cleanup_count;}, []{ return info<42>{get_global()}; }, []{ return info<-42>{-42}; } );
     global = 42;
     return leaf::new_error();
 }
 
 leaf::error_id f()
 {
+    auto load = leaf::on_error([]{++cleanup_count;});
     return g();
 }
 
@@ -53,14 +59,12 @@ int main()
         {
             BOOST_TEST_EQ(i42.value, 42);
 #if BOOST_LEAF_CFG_STD_STRING
-            std::stringstream ss; ss << di;
+            std::ostringstream ss;
+            ss << di;
             std::string s = ss.str();
-            std::cout << s;
-#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
+            std::cout << s << std::endl;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS )
+                BOOST_TEST_NE(s.find("info<42>"), s.npos);
 #endif
             return 1;
         },
@@ -69,5 +73,6 @@ int main()
             return 2;
         } );
     BOOST_TEST_EQ(r, 1);
+    BOOST_TEST_EQ(cleanup_count, 2);
     return boost::report_errors();
 }
diff --git a/test/defer_nested_error_exception_test.cpp b/test/on_error_defer_nested_error_exception_test.cpp
similarity index 93%
rename from test/defer_nested_error_exception_test.cpp
rename to test/on_error_defer_nested_error_exception_test.cpp
index b85d3b60..eab9a2bc 100644
--- a/test/defer_nested_error_exception_test.cpp
+++ b/test/on_error_defer_nested_error_exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -38,7 +37,7 @@ struct info
 void f0()
 {
     auto load = leaf::on_error( [] { return info<0>{0}; } );
-    throw leaf::exception(info<2>{2});
+    leaf::throw_exception(info<2>{2});
 }
 
 void f1()
diff --git a/test/defer_nested_error_result_test.cpp b/test/on_error_defer_nested_error_result_test.cpp
similarity index 95%
rename from test/defer_nested_error_result_test.cpp
rename to test/on_error_defer_nested_error_result_test.cpp
index 5d2a7dcc..1abac0e5 100644
--- a/test/defer_nested_error_result_test.cpp
+++ b/test/on_error_defer_nested_error_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/defer_nested_new_error_exception_test.cpp b/test/on_error_defer_nested_new_error_exception_test.cpp
similarity index 92%
rename from test/defer_nested_new_error_exception_test.cpp
rename to test/on_error_defer_nested_new_error_exception_test.cpp
index 928d556a..45efe6be 100644
--- a/test/defer_nested_new_error_exception_test.cpp
+++ b/test/on_error_defer_nested_new_error_exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -38,14 +37,14 @@ struct info
 void f0()
 {
     auto load = leaf::on_error( [] { return info<0>{-1}; } );
-    throw leaf::exception(info<1>{-1});
+    leaf::throw_exception(info<1>{-1});
 }
 
 void f1()
 {
     auto load = leaf::on_error( [] { return info<0>{0}; }, [] { return info<1>{1}; }, [] { return info<2>{2}; } );
     try { f0(); } catch(...) { }
-    throw leaf::exception();
+    leaf::throw_exception();
 }
 
 leaf::error_id f2()
diff --git a/test/defer_nested_new_error_result_test.cpp b/test/on_error_defer_nested_new_error_result_test.cpp
similarity index 95%
rename from test/defer_nested_new_error_result_test.cpp
rename to test/on_error_defer_nested_new_error_result_test.cpp
index 9ba7f4d8..b6f48635 100644
--- a/test/defer_nested_new_error_result_test.cpp
+++ b/test/on_error_defer_nested_new_error_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/defer_nested_success_exception_test.cpp b/test/on_error_defer_nested_success_exception_test.cpp
similarity index 94%
rename from test/defer_nested_success_exception_test.cpp
rename to test/on_error_defer_nested_success_exception_test.cpp
index 2e559890..e471dbb1 100644
--- a/test/defer_nested_success_exception_test.cpp
+++ b/test/on_error_defer_nested_success_exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/defer_nested_success_result_test.cpp b/test/on_error_defer_nested_success_result_test.cpp
similarity index 94%
rename from test/defer_nested_success_result_test.cpp
rename to test/on_error_defer_nested_success_result_test.cpp
index 37c3c282..d5b34294 100644
--- a/test/defer_nested_success_result_test.cpp
+++ b/test/on_error_defer_nested_success_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/preload_basic_test.cpp b/test/on_error_preload_basic_test.cpp
similarity index 77%
rename from test/preload_basic_test.cpp
rename to test/on_error_preload_basic_test.cpp
index e374083d..e700be3a 100644
--- a/test/preload_basic_test.cpp
+++ b/test/on_error_preload_basic_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -7,12 +6,11 @@
 #   include "leaf.hpp"
 #else
 #   include <boost/leaf/on_error.hpp>
-#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/diagnostics.hpp>
 #   include <boost/leaf/result.hpp>
 #endif
 
 #include "lightweight_test.hpp"
-#include <sstream>
 
 namespace leaf = boost::leaf;
 
@@ -39,16 +37,6 @@ void test( G && g )
         []( info<42> const & i42, leaf::diagnostic_info const & di )
         {
             BOOST_TEST_EQ(i42.value, 42);
-#if BOOST_LEAF_CFG_STD_STRING
-            std::stringstream ss; ss << di;
-            std::string s = ss.str();
-            std::cout << s;
-#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/preload_exception_test.cpp b/test/on_error_preload_exception_test.cpp
similarity index 91%
rename from test/preload_exception_test.cpp
rename to test/on_error_preload_exception_test.cpp
index 8008d140..881ee4a7 100644
--- a/test/preload_exception_test.cpp
+++ b/test/on_error_preload_exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -67,12 +66,12 @@ int main()
         leaf::try_catch(
             []
             {
-                f1( [] { throw leaf::exception(); } );
+                f1( [] { leaf::throw_exception(); } );
                 return 0;
             },
             []( leaf::error_info const & err, info<1> )
             {
-                BOOST_TEST_EQ(err.error().value(), 1);
+                BOOST_TEST_EQ(err.error().value(), 5);
                 return 1;
             },
             []( info<2> )
@@ -88,7 +87,7 @@ int main()
         leaf::try_catch(
             []
             {
-                f2( [] { throw leaf::exception(); } );
+                f2( [] { leaf::throw_exception(); } );
                 return 0;
             },
             []( info<1> )
@@ -114,7 +113,7 @@ int main()
             },
             []( leaf::error_info const & err, info<1> )
             {
-                BOOST_TEST_EQ(err.error().value(), 17);
+                BOOST_TEST_EQ(err.error().value(), 13);
                 return 1;
             },
             []( info<2> )
@@ -139,7 +138,7 @@ int main()
             },
             []( leaf::error_info const & err, info<2>, info<3> )
             {
-                BOOST_TEST_EQ(err.error().value(), 21);
+                BOOST_TEST_EQ(err.error().value(), 17);
                 return 2;
             },
             []( info<1>, info<2> )
diff --git a/test/preload_nested_error_exception_test.cpp b/test/on_error_preload_nested_error_exception_test.cpp
similarity index 93%
rename from test/preload_nested_error_exception_test.cpp
rename to test/on_error_preload_nested_error_exception_test.cpp
index 301daae8..1eb0843a 100644
--- a/test/preload_nested_error_exception_test.cpp
+++ b/test/on_error_preload_nested_error_exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -38,7 +37,7 @@ struct info
 void f0()
 {
     auto load = leaf::on_error( info<0>{0} );
-    throw leaf::exception(info<2>{2});
+    leaf::throw_exception(info<2>{2});
 }
 
 void f1()
diff --git a/test/preload_nested_error_result_test.cpp b/test/on_error_preload_nested_error_result_test.cpp
similarity index 95%
rename from test/preload_nested_error_result_test.cpp
rename to test/on_error_preload_nested_error_result_test.cpp
index 1689e921..d5abc3dc 100644
--- a/test/preload_nested_error_result_test.cpp
+++ b/test/on_error_preload_nested_error_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/preload_nested_new_error_exception_test.cpp b/test/on_error_preload_nested_new_error_exception_test.cpp
similarity index 92%
rename from test/preload_nested_new_error_exception_test.cpp
rename to test/on_error_preload_nested_new_error_exception_test.cpp
index 4a593e86..a46b5b56 100644
--- a/test/preload_nested_new_error_exception_test.cpp
+++ b/test/on_error_preload_nested_new_error_exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -38,14 +37,14 @@ struct info
 void f0()
 {
     auto load = leaf::on_error( info<0>{-1} );
-    throw leaf::exception(info<1>{-1});
+    leaf::throw_exception(info<1>{-1});
 }
 
 void f1()
 {
     auto load = leaf::on_error( info<0>{}, info<1>{1}, info<2>{2} );
     try { f0(); } catch(...) { }
-    throw leaf::exception();
+    leaf::throw_exception();
 }
 
 leaf::error_id f2()
diff --git a/test/preload_nested_new_error_result_test.cpp b/test/on_error_preload_nested_new_error_result_test.cpp
similarity index 95%
rename from test/preload_nested_new_error_result_test.cpp
rename to test/on_error_preload_nested_new_error_result_test.cpp
index 3066c349..ddd0c652 100644
--- a/test/preload_nested_new_error_result_test.cpp
+++ b/test/on_error_preload_nested_new_error_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/preload_nested_success_exception_test.cpp b/test/on_error_preload_nested_success_exception_test.cpp
similarity index 94%
rename from test/preload_nested_success_exception_test.cpp
rename to test/on_error_preload_nested_success_exception_test.cpp
index 86f509e6..103ee86c 100644
--- a/test/preload_nested_success_exception_test.cpp
+++ b/test/on_error_preload_nested_success_exception_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/preload_nested_success_result_test.cpp b/test/on_error_preload_nested_success_result_test.cpp
similarity index 94%
rename from test/preload_nested_success_result_test.cpp
rename to test/on_error_preload_nested_success_result_test.cpp
index f5026872..fe73c759 100644
--- a/test/preload_nested_success_result_test.cpp
+++ b/test/on_error_preload_nested_success_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/optional_test.cpp b/test/optional_test.cpp
index f3178c86..18614495 100644
--- a/test/optional_test.cpp
+++ b/test/optional_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -24,8 +23,8 @@ class my_info
 
     int value;
 
-    explicit my_info( int value ):
-        value(value)
+    explicit my_info( int val ):
+        value(val)
     {
         BOOST_TEST(++object_count>0);
         BOOST_TEST(++value_count>0);
@@ -47,7 +46,7 @@ class my_info
     ~my_info()
     {
         BOOST_TEST(--object_count>=0);
-        if( value!=-1 )
+        if( value != -1 )
             BOOST_TEST(--value_count>=0);
     }
 };
@@ -85,7 +84,7 @@ class throws_on_copy
 
 void run_tests()
 {
-    using leaf::leaf_detail::optional;
+    using leaf::detail::optional;
     {
         optional<my_info> x;
         BOOST_TEST(x.empty());
@@ -300,7 +299,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 +315,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 +328,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 +343,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/parse_name_test.cpp b/test/parse_name_test.cpp
new file mode 100644
index 00000000..3c786ace
--- /dev/null
+++ b/test/parse_name_test.cpp
@@ -0,0 +1,73 @@
+// Copyright 2018-2024 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)
+
+#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
+#   include "leaf.hpp"
+#else
+#   include <boost/leaf/detail/demangle.hpp>
+#endif
+
+#include <cstring>
+#include <cstdint>
+
+namespace leaf = boost::leaf;
+
+#include "lightweight_test.hpp"
+
+namespace leaf_test
+{
+    class class_ { };
+    struct struct_ { };
+    enum enum_ { };
+    template <int> class class_template1 { };
+    template <int> struct struct_template1 { };
+    template <class> class class_template2 { };
+    template <class> struct struct_template2 { };
+}
+
+namespace boost { namespace leaf {
+    struct in_namespace_boost_leaf { };
+} }
+
+class class_ { };
+struct struct_ { };
+enum enum_ { };
+template <int> class class_template1 { };
+template <int> struct struct_template1 { };
+template <class> class class_template2 { };
+template <class> struct struct_template2 { };
+
+bool test(leaf::parsed const & pn, char const * correct)
+{
+    return
+        std::strlen(correct) == pn.len &&
+        std::memcmp(correct, pn.name, pn.len) == 0;
+}
+
+int main()
+{
+    using leaf::parse;
+
+    BOOST_TEST(test(parse<leaf::in_namespace_boost_leaf>(), "boost::leaf::in_namespace_boost_leaf"));
+
+    BOOST_TEST(test(parse<int>(), "int"));
+
+    BOOST_TEST(test(parse<leaf_test::class_>(), "leaf_test::class_"));
+    BOOST_TEST(test(parse<leaf_test::struct_>(), "leaf_test::struct_"));
+    BOOST_TEST(test(parse<leaf_test::enum_>(), "leaf_test::enum_"));
+    BOOST_TEST(test(parse<leaf_test::class_template1<42>>(), "leaf_test::class_template1<42>"));
+    BOOST_TEST(test(parse<leaf_test::struct_template1<42>>(), "leaf_test::struct_template1<42>"));
+    BOOST_TEST(test(parse<leaf_test::class_template2<int>>(), "leaf_test::class_template2<int>"));
+    BOOST_TEST(test(parse<leaf_test::struct_template2<int>>(), "leaf_test::struct_template2<int>"));
+
+    BOOST_TEST(test(parse<class_>(), "class_"));
+    BOOST_TEST(test(parse<struct_>(), "struct_"));
+    BOOST_TEST(test(parse<enum_>(), "enum_"));
+    BOOST_TEST(test(parse<class_template1<42>>(), "class_template1<42>"));
+    BOOST_TEST(test(parse<struct_template1<42>>(), "struct_template1<42>"));
+    BOOST_TEST(test(parse<class_template2<int>>(), "class_template2<int>"));
+    BOOST_TEST(test(parse<struct_template2<int>>(), "struct_template2<int>"));
+
+    return boost::report_errors();
+}
diff --git a/test/print_test.cpp b/test/print_test.cpp
index e9ed0e35..9ddfc4d6 100644
--- a/test/print_test.cpp
+++ b/test/print_test.cpp
@@ -1,11 +1,10 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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_DIAGNOSTICS
+#if !BOOST_LEAF_CFG_DIAGNOSTICS || !BOOST_LEAF_CFG_STD_STRING
 
 #include <iostream>
 
@@ -23,8 +22,10 @@ int main()
 #   include <boost/leaf/detail/print.hpp>
 #endif
 
-#include "lightweight_test.hpp"
 #include <sstream>
+#include <iostream>
+
+#include "lightweight_test.hpp"
 
 namespace leaf = boost::leaf;
 
@@ -32,7 +33,7 @@ struct c0
 {
     friend std::ostream & operator<<( std::ostream & os, c0 const & )
     {
-        return os << "c0";
+        return os << "info";
     }
 };
 
@@ -40,9 +41,9 @@ struct c1
 {
     int value;
 
-    friend std::ostream & operator<<( std::ostream & os, c1 const & )
+    friend std::ostream & operator<<( std::ostream & os, c1 const & x )
     {
-        return os << "c1";
+        return os << "value " << x.value;
     }
 };
 
@@ -51,9 +52,9 @@ struct c2
     int value;
 };
 
-std::ostream & operator<<( std::ostream & os, c2 const & )
+std::ostream & operator<<( std::ostream & os, c2 const & x )
 {
-    return os << "c2";
+    return os << "value " << x.value;
 }
 
 struct c3
@@ -67,59 +68,49 @@ struct c4
     unprintable value;;
 };
 
-template <class T>
-bool check( T const & x, char const * sub )
+template <int Line, class T>
+std::string print(T const & x, char const * prefix, char const * delimiter)
 {
-    using namespace leaf::leaf_detail;
+    using namespace leaf::detail;
     std::ostringstream s;
-    diagnostic<T>::print(s,x);
+    diagnostic<T>::print(s, prefix, delimiter, x);
+    diagnostic<T>::print(s, prefix, delimiter, x);
     std::string q = s.str();
-    return q.find(sub)!=q.npos;
+    std::cout << "[LINE " << Line << "] " << q << '\n';
+    return q;
 }
 
 struct my_exception: std::exception
 {
-    char const * what() const noexcept override { return "my_exception_what"; }
+    char const * what() const noexcept override { return "my_exception what"; }
 };
 
 int main()
 {
-    BOOST_TEST(check(c0{ },"c0"));
-    BOOST_TEST(check(c1{42},"c1"));
     {
-        c1 x;
-        c1 & y = x;
-        BOOST_TEST(check(x,"c1"));
-        BOOST_TEST(check(y,"c1"));
+        std::string out = print<__LINE__>(c0{}, "Title " , ", ");
+        BOOST_TEST_EQ(out, "Title c0: info, c0: info");
+    }
+    {
+        std::string out = print<__LINE__>(c1{42}, "Title ", ", ");
+        BOOST_TEST_EQ(out, "Title c1: value 42, c1: value 42");
+    }
+    {
+        std::string out = print<__LINE__>(c2{42}, "Title ", ", ");
+        BOOST_TEST_EQ(out, "Title c2: value 42, c2: value 42");
     }
-    BOOST_TEST(check(c2{42},"c2"));
     {
-        c2 x = {42};
-        c2 & y = x;
-        BOOST_TEST(check(x,"c2"));
-        BOOST_TEST(check(y,"c2"));
+        std::string out = print<__LINE__>(c3{42}, "Title ", ", ");
+        BOOST_TEST_EQ(out, "Title c3: 42, c3: 42");
     }
-    BOOST_TEST(check(c3{42},"c3"));
-    BOOST_TEST(check(c3{42},"42"));
     {
-        c3 x = {42};
-        c3 & y = x;
-        BOOST_TEST(check(x,"c3"));
-        BOOST_TEST(check(x,"42"));
-        BOOST_TEST(check(y,"c3"));
-        BOOST_TEST(check(y,"42"));
+        std::string out = print<__LINE__>(c4{}, "Title ", ", ");
+        BOOST_TEST_EQ(out, "Title c4, c4");
     }
-    BOOST_TEST(check(c4(),"c4"));
-    BOOST_TEST(check(c4(),"{Non-Printable}"));
     {
-        c4 x;
-        c4 & y = x;
-        BOOST_TEST(check(x,"c4"));
-        BOOST_TEST(check(x,"{Non-Printable}"));
-        BOOST_TEST(check(y,"c4"));
-        BOOST_TEST(check(y,"{Non-Printable}"));
+        std::string out = print<__LINE__>(my_exception{}, "Title ", ", ");
+        BOOST_TEST_EQ(out, "Title my_exception: \"my_exception what\", my_exception: \"my_exception what\"");
     }
-    BOOST_TEST(check(my_exception{}, "std::exception::what(): my_exception_what"));
     return boost::report_errors();
 }
 
diff --git a/test/result_bad_result_test.cpp b/test/result_bad_result_test.cpp
index 519c61ca..4f464a06 100644
--- a/test/result_bad_result_test.cpp
+++ b/test/result_bad_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -49,8 +48,8 @@ int main()
         int r = leaf::try_catch(
             []
             {
-                leaf::result<int> r = leaf::new_error(e_test{42});
-                (void) r.value();
+                leaf::result<int> r1 = leaf::new_error(e_test{42});
+                (void) r1.value();
                 return 0;
             },
             check );
@@ -61,8 +60,8 @@ int main()
         int r = leaf::try_catch(
             []
             {
-                leaf::result<int> const r = leaf::new_error(e_test{42});
-                (void) r.value();
+                leaf::result<int> const r1 = leaf::new_error(e_test{42});
+                (void) r1.value();
                 return 0;
             },
             check );
@@ -70,21 +69,21 @@ int main()
     }
 #endif
     {
-        leaf::result<res> r = leaf::new_error(e_test{42});
-        BOOST_TEST(r.operator->()==0);
+        leaf::result<res> r1 = leaf::new_error(e_test{42});
+        BOOST_TEST(!r1.operator->());
     }
 #if !BOOST_WORKAROUND( BOOST_GCC, < 50000 )
     {
-        leaf::result<res> const r = leaf::new_error(e_test{42});
-        BOOST_TEST(r.operator->()==0);
+        leaf::result<res> const r1 = leaf::new_error(e_test{42});
+        BOOST_TEST(!r1.operator->());
     }
 #endif
     {
         int r = leaf::try_catch(
             []
             {
-                leaf::result<void> r = leaf::new_error(e_test{42});
-                (void) r.value();
+                leaf::result<void> r1 = leaf::new_error(e_test{42});
+                (void) r1.value();
                 return 0;
             },
             check );
@@ -95,8 +94,8 @@ int main()
         int r = leaf::try_catch(
             []
             {
-                leaf::result<void> const r = leaf::new_error(e_test{42});
-                (void) r.value();
+                leaf::result<void> const r1 = leaf::new_error(e_test{42});
+                (void) r1.value();
                 return 0;
             },
             check );
diff --git a/test/result_implicit_conversion_test.cpp b/test/result_implicit_conversion_test.cpp
index 7ba7077c..d89a8344 100644
--- a/test/result_implicit_conversion_test.cpp
+++ b/test/result_implicit_conversion_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -21,8 +20,8 @@ struct A
     {
     }
 
-    A( int x ) noexcept:
-        x(x)
+    A( int x_ ) noexcept:
+        x(x_)
     {
     }
 };
diff --git a/test/result_load_test.cpp b/test/result_load_test.cpp
index 45c8555b..eea2d2b1 100644
--- a/test/result_load_test.cpp
+++ b/test/result_load_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
diff --git a/test/result_print_test.cpp b/test/result_print_test.cpp
new file mode 100644
index 00000000..2f0a0401
--- /dev/null
+++ b/test/result_print_test.cpp
@@ -0,0 +1,113 @@
+// Copyright 2018-2024 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)
+
+#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()
+{
+    {
+        leaf::result<int> r = 42;
+        BOOST_TEST(r);
+#if BOOST_LEAF_CFG_STD_STRING
+        std::ostringstream ss;
+        ss << r;
+        std::string s = ss.str();
+        std::cout << s << std::endl;
+        if( BOOST_LEAF_CFG_DIAGNOSTICS )
+            BOOST_TEST_EQ(s, "42");
+#endif
+    }
+
+    {
+        leaf::result<non_printable_value> r;
+        BOOST_TEST(r);
+#if BOOST_LEAF_CFG_STD_STRING
+        std::ostringstream ss;
+        ss << r;
+        std::string s = ss.str();
+        std::cout << s << std::endl;
+        if( BOOST_LEAF_CFG_DIAGNOSTICS )
+            BOOST_TEST_EQ(s, "{not printable}");
+#endif
+    }
+
+    {
+        leaf::result<void> r;
+        BOOST_TEST(r);
+#if BOOST_LEAF_CFG_STD_STRING
+        std::ostringstream ss;
+        ss << r;
+        std::string s = ss.str();
+        std::cout << s << std::endl;
+        if( BOOST_LEAF_CFG_DIAGNOSTICS )
+            BOOST_TEST_EQ(s, "No error");
+#endif
+    }
+
+    {
+        leaf::result<int> r = leaf::new_error(e_err{ });
+        BOOST_TEST(!r);
+#if BOOST_LEAF_CFG_STD_STRING
+        std::ostringstream ss;
+        ss << r;
+        std::string s = ss.str();
+        std::cout << s << std::endl;
+        leaf::error_id err = r.error();
+        if( BOOST_LEAF_CFG_DIAGNOSTICS )
+            BOOST_TEST_EQ(s, "Error serial #" + std::to_string(err.value()/4));
+#endif
+    }
+
+#if BOOST_LEAF_CFG_CAPTURE
+    {
+        leaf::result<int> r = leaf::try_capture_all(
+            []() -> leaf::result<int>
+            {
+                return leaf::new_error(e_err{ });
+            } );
+#if BOOST_LEAF_CFG_STD_STRING
+        std::ostringstream 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 serial #" + std::to_string(err.value()/4)), s.npos);
+        if( BOOST_LEAF_CFG_DIAGNOSTICS )
+        {
+            BOOST_TEST_NE(s.find("Captured:"), s.npos);
+            BOOST_TEST_NE(s.find("e_err: e_err"), s.npos);
+        }
+#endif
+    }
+#endif
+
+    return boost::report_errors();
+}
diff --git a/test/result_ref_test.cpp b/test/result_ref_test.cpp
index 819ddef9..ac17cdbd 100644
--- a/test/result_ref_test.cpp
+++ b/test/result_ref_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -7,7 +6,6 @@
 #   include "leaf.hpp"
 #else
 #   include <boost/leaf/result.hpp>
-#   include <boost/leaf/capture.hpp>
 #   include <boost/leaf/handle_errors.hpp>
 #endif
 
@@ -21,7 +19,7 @@ struct val
 
     friend bool operator==( val const & a, val const & b )
     {
-        return a.id==b.id;
+        return a.id == b.id;
     }
 
     friend std::ostream & operator<<( std::ostream & os, val const & v )
diff --git a/test/result_state_test.cpp b/test/result_state_test.cpp
index 591721f5..f323a82c 100644
--- a/test/result_state_test.cpp
+++ b/test/result_state_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -7,7 +6,6 @@
 #   include "leaf.hpp"
 #else
 #   include <boost/leaf/result.hpp>
-#   include <boost/leaf/capture.hpp>
 #   include <boost/leaf/handle_errors.hpp>
 #endif
 
@@ -15,41 +13,57 @@
 
 namespace leaf = boost::leaf;
 
+static_assert(std::is_same<void, leaf::result<void>::value_type>::value, "Bad value_type");
+static_assert(std::is_same<int, leaf::result<int>::value_type>::value, "Bad value_type");
+static_assert(std::is_same<int const, leaf::result<int const>::value_type>::value, "Bad value_type");
+static_assert(std::is_same<int &, leaf::result<int &>::value_type>::value, "Bad value_type");
+static_assert(std::is_same<int const &, leaf::result<int const &>::value_type>::value, "Bad value_type");
+
 struct val
 {
     static int id_count;
     static int count;
     int id;
+    float a = 0;
+    int b = 0;
+
+    val( float a, int b ) noexcept:
+        id(++id_count),
+        a(a),
+        b(b)
+    {
+        ++count;
+    }
 
-    val():
+    val() noexcept:
         id(++id_count)
     {
         ++count;
     }
 
-    val( val const & x ):
+    val( val const & x ) noexcept:
         id(x.id)
     {
         ++count;
     }
 
-    val( val && x ):
+    val( val && x ) noexcept:
         id(x.id)
     {
         ++count;
     }
 
-    ~val()
+    ~val() noexcept
     {
         --count;
     }
 
-    friend bool operator==( val const & a, val const & b )
+    friend bool operator==( val const & a, val const & b ) noexcept
     {
-        return a.id==b.id;
+        return a.id == b.id;
     }
 
-    friend std::ostream & operator<<( std::ostream & os, val const & v )
+    friend std::ostream & operator<<( std::ostream & os, val const & v ) noexcept
     {
         return os << v.id;
     }
@@ -89,12 +103,12 @@ bool eq_value( leaf::result<val> & r, val v )
     leaf::result<val> const & cr = r;
     val const & cv = v;
     return
-        r.value()==v &&
-        cr.value()==cv &&
-        *r.operator->()==v &&
-        *cr.operator->()==cv &&
-        *r==v &&
-        *cr==cv;
+        r.value() == v &&
+        cr.value() == cv &&
+        *r.operator->() == v &&
+        *cr.operator->() == cv &&
+        *r == v &&
+        *cr == cv;
 }
 
 int main()
@@ -138,6 +152,20 @@ int main()
     }
     BOOST_TEST_EQ(err::count, 0);
     BOOST_TEST_EQ(val::count, 0);
+    { // value emplace -> move
+        leaf::result<val> r1 = { 42.0f, 42 };
+        BOOST_TEST(r1);
+        BOOST_TEST_EQ(r1.value().a, 42.0f);
+        BOOST_TEST_EQ(r1.value().b, 42);
+        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 -> assign-move
         leaf::result<val> r1;
@@ -178,49 +206,8 @@ 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>(); } );
+    { // value emplace -> assign-move
+        leaf::result<val> r1 = { 42.0f, 42 };
         BOOST_TEST(r1);
         BOOST_TEST_EQ(err::count, 0);
         BOOST_TEST_EQ(val::count, 1);
@@ -231,37 +218,12 @@ int main()
     }
     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);
@@ -276,7 +238,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;
@@ -293,7 +255,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();
@@ -315,7 +277,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;
@@ -333,7 +295,11 @@ 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_capture_all(
+            []()->leaf::result<val>
+            {
+                return leaf::new_error(e_err{ });
+            });
         BOOST_TEST(!r1);
         BOOST_TEST_EQ(err::count, 1);
         BOOST_TEST_EQ(val::count, 0);
@@ -347,7 +313,12 @@ 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_capture_all(
+            []()->leaf::result<val>
+            {
+                leaf::error_id err = leaf::new_error( e_err{ } );
+                return leaf::result<val>(err);
+            });
         BOOST_TEST(!r1);
         BOOST_TEST_EQ(err::count, 1);
         BOOST_TEST_EQ(val::count, 0);
@@ -362,7 +333,11 @@ 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_capture_all(
+            []()->leaf::result<val>
+            {
+                return leaf::new_error(e_err{ });
+            });
         BOOST_TEST(!r1);
         BOOST_TEST_EQ(err::count, 1);
         BOOST_TEST_EQ(val::count, 0);
@@ -376,7 +351,12 @@ 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_capture_all(
+            []()->leaf::result<val>
+            {
+                leaf::error_id err = leaf::new_error( e_err{ } );
+                return leaf::result<val>(err);
+            });
         BOOST_TEST(!r1);
         BOOST_TEST_EQ(err::count, 1);
         BOOST_TEST_EQ(val::count, 0);
@@ -393,7 +373,7 @@ int main()
 
     // ^^ result<T> ^^
 
-    /////////////////////////////////////////////////////////////
+    ////////////////////////////////////////
 
     // vv result<void> vv
 
@@ -401,12 +381,12 @@ int main()
         leaf::result<void> r1;
         BOOST_TEST(r1);
         r1.value();
-        BOOST_TEST(r1.operator->() != 0);
+        BOOST_TEST(r1.operator->());
         *r1;
         leaf::result<void> r2 = std::move(r1);
         BOOST_TEST(r2);
         r2.value();
-        BOOST_TEST(r2.operator->() != 0);
+        BOOST_TEST(r2.operator->());
         *r2;
     }
 
@@ -414,51 +394,24 @@ int main()
         leaf::result<void> r1;
         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;
-    }
-
-#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);
+        BOOST_TEST(r1.operator->());
         *r1;
         leaf::result<void> r2; r2=std::move(r1);
         BOOST_TEST(r2);
         r2.value();
-        BOOST_TEST(r2.operator->() != 0);
+        BOOST_TEST(r2.operator->());
         *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);
-        BOOST_TEST(r1.operator->() == 0);
+        BOOST_TEST(!r1.operator->());
         BOOST_TEST_EQ(err::count, 1);
         leaf::error_id r1e = r1.error();
         leaf::result<void> r2 = std::move(r1);
@@ -469,12 +422,12 @@ 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;
         BOOST_TEST(!r1);
-        BOOST_TEST(r1.operator->() == 0);
+        BOOST_TEST(!r1.operator->());
         BOOST_TEST_EQ(err::count, 1);
         leaf::error_id r1e = r1.error();
         leaf::result<void> r2 = std::move(r1);
@@ -486,12 +439,12 @@ 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();
         BOOST_TEST(!r1);
-        BOOST_TEST(r1.operator->() == 0);
+        BOOST_TEST(!r1.operator->());
         BOOST_TEST_EQ(err::count, 1);
         leaf::error_id r1e = r1.error();
         leaf::result<void> r2; r2=std::move(r1);
@@ -504,12 +457,12 @@ 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;
         BOOST_TEST(!r1);
-        BOOST_TEST(r1.operator->() == 0);
+        BOOST_TEST(!r1.operator->());
         BOOST_TEST_EQ(err::count, 1);
         leaf::error_id r1e = r1.error();
         leaf::result<void> r2; r2=std::move(r1);
@@ -522,9 +475,13 @@ 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_capture_all(
+            []()->leaf::result<void>
+            {
+                return leaf::new_error(e_err{ });
+            });
         BOOST_TEST(!r1);
-        BOOST_TEST(r1.operator->() == 0);
+        BOOST_TEST(!r1.operator->());
         BOOST_TEST_EQ(err::count, 1);
         leaf::error_id r1e = r1.error();
         leaf::result<void> r2 = std::move(r1);
@@ -535,9 +492,14 @@ 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_capture_all(
+            []()->leaf::result<void>
+            {
+                leaf::error_id err = leaf::new_error( e_err{ } );
+                return leaf::result<void>(err);
+            });
         BOOST_TEST(!r1);
-        BOOST_TEST(r1.operator->() == 0);
+        BOOST_TEST(!r1.operator->());
         BOOST_TEST_EQ(err::count, 1);
         leaf::error_id r1e = r1.error();
         leaf::result<void> r2 = std::move(r1);
@@ -549,9 +511,13 @@ 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_capture_all(
+            []()->leaf::result<void>
+            {
+                return leaf::new_error(e_err{ });
+            });
         BOOST_TEST(!r1);
-        BOOST_TEST(r1.operator->() == 0);
+        BOOST_TEST(!r1.operator->());
         BOOST_TEST_EQ(err::count, 1);
         leaf::error_id r1e = r1.error();
         leaf::result<void> r2; r2=std::move(r1);
@@ -562,9 +528,14 @@ 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_capture_all(
+            []()->leaf::result<void>
+            {
+                leaf::error_id err = leaf::new_error( e_err{ } );
+                return leaf::result<void>(err);
+            });
         BOOST_TEST(!r1);
-        BOOST_TEST(r1.operator->() == 0);
+        BOOST_TEST(!r1.operator->());
         BOOST_TEST_EQ(err::count, 1);
         leaf::error_id r1e = r1.error();
         leaf::result<void> r2; r2=std::move(r1);
diff --git a/test/tls_array_alloc_test1.cpp b/test/tls_array_alloc_test1.cpp
index d550bd19..ebf4150a 100644
--- a/test/tls_array_alloc_test1.cpp
+++ b/test/tls_array_alloc_test1.cpp
@@ -1,15 +1,26 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
-#define BOOST_LEAF_NO_EXCEPTIONS
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+#   define BOOST_LEAF_NO_EXCEPTIONS
+#endif
+
+#ifdef BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+#   undef BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+#endif
 #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
+
+#ifdef BOOST_LEAF_CFG_CAPTURE
+#   undef BOOST_LEAF_CFG_CAPTURE
+#endif
+#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 870d6229..a31c2ef4 100644
--- a/test/tls_array_alloc_test2.cpp
+++ b/test/tls_array_alloc_test2.cpp
@@ -1,15 +1,26 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
-#define BOOST_LEAF_NO_EXCEPTIONS
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+#   define BOOST_LEAF_NO_EXCEPTIONS
+#endif
+
+#ifdef BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+#   undef BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+#endif
 #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
+
+#ifdef BOOST_LEAF_CFG_CAPTURE
+#   undef BOOST_LEAF_CFG_CAPTURE
+#endif
+#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 cfcafbfe..0f021874 100644
--- a/test/tls_array_alloc_test3.cpp
+++ b/test/tls_array_alloc_test3.cpp
@@ -1,15 +1,26 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
-#define BOOST_LEAF_NO_EXCEPTIONS
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+#   define BOOST_LEAF_NO_EXCEPTIONS
+#endif
+
+#ifdef BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+#   undef BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+#endif
 #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
+
+#ifdef BOOST_LEAF_CFG_CAPTURE
+#   undef BOOST_LEAF_CFG_CAPTURE
+#endif
+#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_test.cpp b/test/tls_array_test.cpp
index 5e6e650f..548e700d 100644
--- a/test/tls_array_test.cpp
+++ b/test/tls_array_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -62,7 +61,7 @@ struct my_error_info
 {
 };
 
-// Mirroring boost::leaf::leaf_detail::optional<T>, to verify correctness of TLS pointers
+// Mirroring boost::leaf::detail::optional<T>, to verify correctness of TLS pointers
 template <class T>
 struct optional
 {
diff --git a/test/to_variant_test.cpp b/test/to_variant_test.cpp
index f2d6fc29..81873094 100644
--- a/test/to_variant_test.cpp
+++ b/test/to_variant_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -35,17 +34,17 @@ int main()
 #if !defined(__clang__) || __clang_major__ < 5 || __clang_major__ > 7 // See https://github.com/llvm/llvm-project/issues/32569
     {
         auto v = leaf::to_variant<E1, E2, E3>(
-            [ ]() -> leaf::result<int>
+            []() -> leaf::result<int>
             {
                 return 42;
             } );
-        BOOST_TEST(v.index() == 0);
-        BOOST_TEST(std::get<0>(v) == 42);
+        BOOST_TEST_EQ(v.index(), 0);
+        BOOST_TEST_EQ(std::get<0>(v), 42);
     }
 
     {
         auto v = leaf::to_variant<E1, E2, E3>(
-            [ ]() -> leaf::result<int>
+            []() -> leaf::result<int>
             {
                 return leaf::new_error(E1::e12, E3::e31);
             } );
diff --git a/test/try_capture_all_test.cpp b/test/try_capture_all_test.cpp
new file mode 100644
index 00000000..c3254c95
--- /dev/null
+++ b/test/try_capture_all_test.cpp
@@ -0,0 +1,150 @@
+// Copyright 2018-2024 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_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
+#if !BOOST_LEAF_CFG_CAPTURE
+
+#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
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+namespace
+{
+    template <int>
+    struct err
+    {
+        static int count;
+        static int move_count;
+
+        err()
+        {
+            ++count;
+        }
+
+        err( err const & )
+        {
+            ++count;
+        }
+
+        err( err && )
+        {
+            ++count;
+            ++move_count;
+        }
+
+        ~err()
+        {
+            --count;
+        }
+    };
+    template <int N> int err<N>::count = 0;
+    template <int N> int err<N>::move_count = 0;
+}
+
+int main()
+{
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+    {
+        leaf::result<void> r = leaf::try_capture_all([]() { throw std::runtime_error("x"); });
+        BOOST_TEST(!r);
+        int r1 = leaf::try_handle_all(
+            [&]() -> leaf::result<int>
+            {
+                BOOST_LEAF_CHECK(r);
+                return 0;
+            },
+            [](std::runtime_error const &)
+            {
+                return 1;
+            },
+            []
+            {
+                return 2;
+            } );
+        BOOST_TEST_EQ(r1, 1);
+    }
+#endif
+    {
+        leaf::result<void> r = leaf::try_capture_all(
+            []() -> leaf::result<void>
+            {
+                return leaf::new_error(err<1>{}, err<2>{});
+            });
+        BOOST_TEST_EQ(err<1>::count, 1);
+        BOOST_TEST_EQ(err<2>::count, 1);
+        BOOST_TEST(!r);
+        int r1 = leaf::try_handle_all(
+            [&]() -> leaf::result<int>
+            {
+                BOOST_LEAF_CHECK(r);
+                return 0;
+            },
+            [](err<1>, err<2>)
+            {
+                return 1;
+            },
+            []
+            {
+                return 2;
+            } );
+        BOOST_TEST_EQ(r1, 1);
+    }
+    BOOST_TEST_EQ(err<1>::count, 0);
+    BOOST_TEST_EQ(err<2>::count, 0);
+
+    {
+        leaf::result<int> r = leaf::try_capture_all(
+            []() -> leaf::result<int>
+            {
+                return leaf::new_error(err<1>{}, err<2>{});
+            });
+        BOOST_TEST(!r);
+        BOOST_TEST_EQ(err<1>::count, 1);
+        BOOST_TEST_EQ(err<2>::count, 1);
+        int r1 = leaf::try_handle_all(
+            [&]() -> leaf::result<int>
+            {
+                BOOST_LEAF_CHECK(r);
+                return 0;
+            },
+            [](err<1>, err<2>)
+            {
+                return 1;
+            },
+            []
+            {
+                return 2;
+            } );
+        BOOST_TEST_EQ(r1, 1);
+    }
+    BOOST_TEST_EQ(err<1>::count, 0);
+    BOOST_TEST_EQ(err<2>::count, 0);
+
+    return boost::report_errors();
+}
+
+#endif
diff --git a/test/try_catch_error_id_test.cpp b/test/try_catch_error_id_test.cpp
index 5b32875c..1c14305b 100644
--- a/test/try_catch_error_id_test.cpp
+++ b/test/try_catch_error_id_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -38,11 +37,11 @@ int main()
     int r = leaf::try_catch(
         []() -> int
         {
-            throw leaf::exception( my_error(), info{42} );
+            leaf::throw_exception( my_error(), info{42} );
         },
-        []( my_error const & x, leaf::catch_<leaf::error_id> id )
+        []( my_error const &, leaf::catch_<leaf::error_id> id )
         {
-            BOOST_TEST(dynamic_cast<leaf::error_id const *>(&id.matched)!=0 && dynamic_cast<leaf::error_id const *>(&id.matched)->value()==1);
+            BOOST_TEST(dynamic_cast<leaf::error_id const *>(&id.matched) != 0 && dynamic_cast<leaf::error_id const *>(&id.matched)->value() == 5);
             return 1;
         },
         []
diff --git a/test/try_catch_system_error_test.cpp b/test/try_catch_system_error_test.cpp
index 2ece5fd9..012bffb4 100644
--- a/test/try_catch_system_error_test.cpp
+++ b/test/try_catch_system_error_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -22,6 +21,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
 
@@ -38,7 +38,7 @@ int main()
         int r = leaf::try_catch(
             []() -> int
             {
-                throw leaf::exception( std::system_error(make_error_code(errc_a::a0)), info{42} );
+                leaf::throw_exception( std::system_error(make_error_code(errc_a::a0)), info{42} );
             },
             []( std::system_error const & se, leaf::match_value<info, 42> )
             {
@@ -74,7 +74,7 @@ int main()
         int r = leaf::try_catch(
             []() -> int
             {
-                throw leaf::exception( std::system_error(make_error_code(errc_a::a0)), info{42} );
+                leaf::throw_exception( std::system_error(make_error_code(errc_a::a0)), info{42} );
             },
             []( leaf::match<leaf::condition<errc_a>, errc_a::a0> code, leaf::match_value<info, 42> )
             {
@@ -112,7 +112,7 @@ int main()
         int r = leaf::try_catch(
             []() -> int
             {
-                throw leaf::exception( std::system_error(make_error_code(errc_a::a0)), info{42} );
+                leaf::throw_exception( std::system_error(make_error_code(errc_a::a0)), info{42} );
             },
             []( std::error_code const & ec, leaf::match_value<info, 42> )
             {
diff --git a/test/try_catch_test.cpp b/test/try_catch_test.cpp
index d14740f4..a31f9ca7 100644
--- a/test/try_catch_test.cpp
+++ b/test/try_catch_test.cpp
@@ -1,29 +1,17 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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/handle_errors.hpp>
-#include "lightweight_test.hpp"
-
-namespace leaf = boost::leaf;
+#include <boost/leaf/config.hpp>
 
 #ifdef BOOST_LEAF_NO_EXCEPTIONS
 
+#include <iostream>
+
 int main()
 {
-    int r = leaf::try_catch(
-        []
-        {
-            return 42;
-        },
-        []
-        {
-            return 1;
-        } );
-    BOOST_TEST_EQ(r, 42);
-
-    return boost::report_errors();
+    std::cout << "Unit test not applicable." << std::endl;
+    return 0;
 }
 
 #else
@@ -31,9 +19,15 @@ int main()
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
 #else
+#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/exception.hpp>
 #   include <boost/leaf/pred.hpp>
 #endif
 
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
 template <int> struct info { int value; };
 
 struct error1: std::exception { };
@@ -45,7 +39,7 @@ struct exc_val: std::exception { int value; explicit exc_val(int v): value(v) {
 template <class R,class Ex>
 R failing( Ex && ex )
 {
-    throw leaf::exception(std::move(ex), info<1>{1}, info<2>{2}, info<3>{3});
+    leaf::throw_exception(std::move(ex), info<1>{1}, info<2>{2}, info<3>{3});
 }
 
 template <class R>
@@ -184,7 +178,7 @@ int main()
         BOOST_TEST_EQ(c, 2);
     }
 
-    //////////////////////////////////////
+    ////////////////////////////////////////
 
     // void, handle_some (failure, initially not matched), match_enum (single enum value)
     {
@@ -316,7 +310,7 @@ int main()
         BOOST_TEST_EQ(c, 1);
     }
 
-    //////////////////////////////////////
+    ////////////////////////////////////////
 
     // int, try_catch (success)
     {
@@ -380,7 +374,7 @@ int main()
         BOOST_TEST_EQ(r, 2);
     }
 
-    //////////////////////////////////////
+    ////////////////////////////////////////
 
     // int, handle_some (failure, matched), match_enum (single enum value)
     {
@@ -427,7 +421,7 @@ int main()
         int r = leaf::try_catch(
             []
             {
-                int r = leaf::try_catch(
+                int r1 = leaf::try_catch(
                     []
                     {
                         return failing<int>(error1());
@@ -437,7 +431,7 @@ int main()
                         return 1;
                     } );
                 BOOST_TEST(false);
-                return r;
+                return r1;
             },
             []( error1 const &, info<1> const & x, info<2> y )
             {
@@ -457,7 +451,7 @@ int main()
         int r = leaf::try_catch(
             []
             {
-                int r = leaf::try_catch(
+                int r1 = leaf::try_catch(
                     []
                     {
                         return failing<int>(error1());
@@ -467,7 +461,7 @@ int main()
                         return 1;
                     } );
                 BOOST_TEST(false);
-                return r;
+                return r1;
             },
             []( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
             {
@@ -487,7 +481,7 @@ int main()
         int r = leaf::try_catch(
             []
             {
-                int r = leaf::try_catch(
+                int r1 = leaf::try_catch(
                     []
                     {
                         return failing<int>(error1());
@@ -498,8 +492,8 @@ int main()
                         BOOST_TEST_EQ(y.value, 2);
                         return 1;
                     } );
-                BOOST_TEST_EQ(r, 1);
-                return r;
+                BOOST_TEST_EQ(r1, 1);
+                return r1;
             },
             []( error1 const & )
             {
@@ -517,7 +511,7 @@ int main()
         int r = leaf::try_catch(
             []
             {
-                int r = leaf::try_catch(
+                int r1 = leaf::try_catch(
                     []
                     {
                         return failing<int>(error1());
@@ -528,8 +522,8 @@ int main()
                         BOOST_TEST_EQ(y.value, 2);
                         return 1;
                     } );
-                BOOST_TEST_EQ(r, 1);
-                return r;
+                BOOST_TEST_EQ(r1, 1);
+                return r1;
             },
             []( error1 const & )
             {
@@ -542,14 +536,14 @@ int main()
         BOOST_TEST_EQ(r, 1);
     }
 
-    //////////////////////////////////////
+    ////////////////////////////////////////
 
     // match<> with exceptions
     {
         int r = leaf::try_catch(
             []
             {
-                throw leaf::exception(exc_val{42});
+                leaf::throw_exception(exc_val{42});
                 return 0;
             },
             []( leaf::match_value<exc_val, 42> )
@@ -566,7 +560,7 @@ int main()
         int r = leaf::try_catch(
             []
             {
-                throw leaf::exception(exc_val{42});
+                leaf::throw_exception(exc_val{42});
                 return 0;
             },
             []( leaf::match_value<exc_val, 41> )
@@ -614,7 +608,7 @@ int main()
         BOOST_TEST_EQ(r, 2);
     }
 
-    //////////////////////////////////////
+    ////////////////////////////////////////
 
     return boost::report_errors();
 }
diff --git a/test/try_exception_and_result_test.cpp b/test/try_exception_and_result_test.cpp
index 954ab091..29333114 100644
--- a/test/try_exception_and_result_test.cpp
+++ b/test/try_exception_and_result_test.cpp
@@ -1,5 +1,4 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -65,7 +64,7 @@ int main()
         leaf::result<int> r = leaf::try_handle_some(
             []() -> leaf::result<int>
             {
-                throw leaf::exception( my_exception(), info<1>{1} );
+                leaf::throw_exception( my_exception(), info<1>{1} );
             },
             []( my_exception const &, info<1> const & x )
             {
@@ -79,7 +78,7 @@ int main()
         leaf::result<int> r = leaf::try_handle_some(
             []() -> leaf::result<int>
             {
-                throw leaf::exception( info<1>{1} );
+                leaf::throw_exception( info<1>{1} );
             },
             []( info<1> const & x )
             {
@@ -104,7 +103,7 @@ int main()
         BOOST_TEST_EQ(r.value(), 1);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     {
         auto error_handlers = std::make_tuple(
@@ -132,7 +131,7 @@ int main()
             leaf::result<int> r = leaf::try_handle_some(
                 []() -> leaf::result<int>
                 {
-                    throw leaf::exception( my_exception(), info<1>{1} );
+                    leaf::throw_exception( my_exception(), info<1>{1} );
                 },
                 error_handlers );
             BOOST_TEST(r);
@@ -142,7 +141,7 @@ int main()
             leaf::result<int> r = leaf::try_handle_some(
                 []() -> leaf::result<int>
                 {
-                    throw leaf::exception( info<1>{1} );
+                    leaf::throw_exception( info<1>{1} );
                 },
                 error_handlers );
             BOOST_TEST(r);
@@ -160,7 +159,7 @@ int main()
         }
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     {
         int r = leaf::try_handle_all(
@@ -178,7 +177,7 @@ int main()
         int r = leaf::try_handle_all(
             []() -> leaf::result<int>
             {
-                throw leaf::exception( my_exception(), info<1>{1} );
+                leaf::throw_exception( my_exception(), info<1>{1} );
             },
             []( my_exception const &, info<1> const & x )
             {
@@ -195,7 +194,7 @@ int main()
         int r = leaf::try_handle_all(
             []() -> leaf::result<int>
             {
-                throw leaf::exception( info<1>{1} );
+                leaf::throw_exception( info<1>{1} );
             },
             []( info<1> const & x )
             {
@@ -226,7 +225,7 @@ int main()
         BOOST_TEST_EQ(r, 1);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     {
         auto error_handlers = std::make_tuple(
@@ -257,7 +256,7 @@ int main()
             int r = leaf::try_handle_all(
                 []() -> leaf::result<int>
                 {
-                    throw leaf::exception( my_exception(), info<1>{1} );
+                    leaf::throw_exception( my_exception(), info<1>{1} );
                 },
                 error_handlers );
             BOOST_TEST_EQ(r, 1);
@@ -266,7 +265,7 @@ int main()
             int r = leaf::try_handle_all(
                 []() -> leaf::result<int>
                 {
-                    throw leaf::exception( info<1>{1} );
+                    leaf::throw_exception( info<1>{1} );
                 },
                 error_handlers );
             BOOST_TEST_EQ(r, 2);
@@ -282,7 +281,7 @@ int main()
         }
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     {
         int r = leaf::try_handle_all(
@@ -352,7 +351,7 @@ int main()
         BOOST_TEST_EQ(r, 4);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     {
         auto error_handlers = std::make_tuple(
@@ -427,7 +426,7 @@ int main()
         BOOST_TEST_EQ(r, 4);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     {
         int r = leaf::try_handle_all(
@@ -498,7 +497,7 @@ int main()
         BOOST_TEST_EQ(r, 5);
     }
 
-    ///////////////////////////
+    ////////////////////////////////////////
 
     {
         auto error_handlers = std::make_tuple(
@@ -573,14 +572,14 @@ int main()
         BOOST_TEST_EQ(r, 5);
     }
 
-    //////////////////////////////////////
+    ////////////////////////////////////////
 
     // match_value<> with exceptions, try_handle_some
     {
         leaf::result<int> r = leaf::try_handle_some(
             []() -> leaf::result<int>
             {
-                throw leaf::exception( my_exception(42) );
+                leaf::throw_exception( my_exception(42) );
             },
             []( leaf::match_value<my_exception, 42> m )
             {
@@ -606,7 +605,7 @@ int main()
         leaf::result<int> r = leaf::try_handle_some(
             []() -> leaf::result<int>
             {
-                throw leaf::exception( my_exception(42) );
+                leaf::throw_exception( my_exception(42) );
             },
             []( leaf::match_value<my_exception, 41> m )
             {
@@ -635,14 +634,14 @@ int main()
         BOOST_TEST(!r);
     }
 
-    //////////////////////////////////////
+    ////////////////////////////////////////
 
     // match_value<> with exceptions, try_handle_all
     {
         int r = leaf::try_handle_all(
             []() -> leaf::result<int>
             {
-                throw leaf::exception( my_exception(42) );
+                leaf::throw_exception( my_exception(42) );
             },
             []( leaf::match_value<my_exception, 42> m )
             {
@@ -674,7 +673,7 @@ int main()
         int r = leaf::try_handle_all(
             []() -> leaf::result<int>
             {
-                throw leaf::exception( my_exception(42) );
+                leaf::throw_exception( my_exception(42) );
             },
             []( leaf::match_value<my_exception, 41> m )
             {
diff --git a/test/visibility_test.cpp b/test/visibility_test.cpp
index d3d58fe9..8b9bb0e9 100644
--- a/test/visibility_test.cpp
+++ b/test/visibility_test.cpp
@@ -1,18 +1,22 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
 #else
-#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/diagnostics.hpp>
 #   include <boost/leaf/result.hpp>
 #endif
 
 #include "visibility_test_lib.hpp"
+
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
 #include "lightweight_test.hpp"
-#include <sstream>
 
 namespace leaf = boost::leaf;
 
@@ -28,28 +32,25 @@ int main()
                 BOOST_LEAF_CHECK(hidden_result());
                 return 0;
             },
-            []( my_info<1> x1, my_info<2> x2, leaf::diagnostic_info const & info, leaf::verbose_diagnostic_info const & vinfo )
+            []( my_info<1> x1, my_info<2> x2, leaf::diagnostic_details const & info, leaf::diagnostic_details const & vinfo )
             {
                 BOOST_TEST_EQ(x1.value, 1);
                 BOOST_TEST_EQ(x2.value, 2);
                 if( BOOST_LEAF_CFG_DIAGNOSTICS )
                 {
 #if BOOST_LEAF_CFG_STD_STRING
-                    std::stringstream ss; ss << info;
-                    BOOST_TEST_NE(ss.str().find("1 attempt to communicate an unexpected error object"), std::string::npos);
-#endif
-                }
-                if( BOOST_LEAF_CFG_DIAGNOSTICS )
-                {
-#if BOOST_LEAF_CFG_STD_STRING
-                    std::stringstream ss; ss << vinfo;
-                    BOOST_TEST_NE(ss.str().find("Test my_info<3>::value = 3"), std::string::npos);
+                    std::ostringstream ss; ss << vinfo;
+                    std::string s = ss.str();
+                    std::cout << s << std::endl;
+                    if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+                        BOOST_TEST_NE(s.find("Test my_info<3>::value = 3"), std::string::npos);
 #endif
                 }
                 return 1;
             },
-            []
+            [](leaf::diagnostic_details const & vinfo)
             {
+                std::cout << "Test is failing\n" << vinfo;
                 return 2;
             } );
         BOOST_TEST_EQ(r, 1);
@@ -63,28 +64,25 @@ int main()
                 hidden_throw();
                 return 0;
             },
-            []( my_info<1> x1, my_info<2> x2, leaf::diagnostic_info const & info, leaf::verbose_diagnostic_info const & vinfo )
+            []( my_info<1> x1, my_info<2> x2, leaf::diagnostic_details const & info, leaf::diagnostic_details const & vinfo )
             {
                 BOOST_TEST_EQ(x1.value, 1);
                 BOOST_TEST_EQ(x2.value, 2);
                 if( BOOST_LEAF_CFG_DIAGNOSTICS )
                 {
 #if BOOST_LEAF_CFG_STD_STRING
-                    std::stringstream ss; ss << info;
-                    BOOST_TEST_NE(ss.str().find("1 attempt to communicate an unexpected error object"), std::string::npos);
-#endif
-                }
-                if( BOOST_LEAF_CFG_DIAGNOSTICS )
-                {
-#if BOOST_LEAF_CFG_STD_STRING
-                    std::stringstream ss; ss << vinfo;
-                    BOOST_TEST_NE(ss.str().find("Test my_info<3>::value = 3"), std::string::npos);
+                    std::ostringstream ss; ss << vinfo;
+                    std::string s = ss.str();
+                    std::cout << s << std::endl;
+                    if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+                        BOOST_TEST_NE(s.find("Test my_info<3>::value = 3"), std::string::npos);
 #endif
                 }
                 return 1;
             },
-            []
+            [](leaf::diagnostic_details const & vinfo)
             {
+                std::cout << "Test is failing\n" << vinfo;
                 return 2;
             } );
         BOOST_TEST_EQ(r, 1);
diff --git a/test/visibility_test_lib.cpp b/test/visibility_test_lib.cpp
index 2c4a0ac3..dd90bacc 100644
--- a/test/visibility_test_lib.cpp
+++ b/test/visibility_test_lib.cpp
@@ -1,12 +1,16 @@
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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 "visibility_test_lib.hpp"
-#include <boost/leaf/exception.hpp>
-#include <boost/leaf/result.hpp>
-#include <boost/leaf/on_error.hpp>
+
+#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
+#   include "leaf.hpp"
+#else
+#   include <boost/leaf/exception.hpp>
+#   include <boost/leaf/result.hpp>
+#   include <boost/leaf/on_error.hpp>
+#endif
 
 namespace leaf = boost::leaf;
 
@@ -21,7 +25,7 @@ leaf::result<void> BOOST_SYMBOL_VISIBLE hidden_result()
 void BOOST_SYMBOL_VISIBLE hidden_throw()
 {
     auto load = leaf::on_error( my_info<1>{1}, my_info<3>{3} );
-    throw leaf::exception( my_info<2>{2} );
+    leaf::throw_exception( my_info<2>{2} );
 }
 
 #endif
diff --git a/test/visibility_test_lib.hpp b/test/visibility_test_lib.hpp
index bd924c3f..a314d6be 100644
--- a/test/visibility_test_lib.hpp
+++ b/test/visibility_test_lib.hpp
@@ -1,8 +1,7 @@
 #ifndef VISIBILITY_TEST_LIB_HPP_INCLUDED
 #define VISIBILITY_TEST_LIB_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2024 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)
 
@@ -15,7 +14,7 @@ struct BOOST_SYMBOL_VISIBLE my_info
     int value;
 
     template <class CharT, class Traits>
-    friend std::basic_ostream<CharT, Traits> & operator<<( std::basic_ostream<CharT, Traits> & os, my_info const & x )
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, my_info const & x )
     {
         return os << "Test my_info<" << Tag << ">::value = " << x.value;
     }
diff --git a/wasm.txt b/wasm.txt
index 82e568fe..7bcd432d 100644
--- a/wasm.txt
+++ b/wasm.txt
@@ -1,4 +1,4 @@
-# Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
+# Copyright 2018-2024 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)