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..f466d778 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -16,173 +16,324 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        include:
-          - toolset: gcc-4.8
-            cxxstd: "11"
-            os: ubuntu-18.04
-            install: g++-4.8
+        config:
+          - variant: "debug,release"
+          - name: No capture
+            variant: "leaf_debug_capture0,leaf_release_capture0"
+          - name: No diagnostics
+            variant: "leaf_debug_diag0,leaf_release_diag0"
+          - name: Embedded
+            variant: "leaf_debug_embedded,leaf_release_embedded"
+          - name: Single header
+            variant: "leaf_debug_single_header,leaf_release_single_header"
+        platform:
           - toolset: gcc-5
             cxxstd: "11,14,1z"
-            os: ubuntu-18.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
             install: g++-5
           - toolset: gcc-6
             cxxstd: "11,14,1z"
-            os: ubuntu-18.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
             install: g++-6
           - toolset: gcc-7
             cxxstd: "11,14"
-            os: ubuntu-18.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
           - toolset: gcc-8
             cxxstd: "11,14,17,2a"
-            os: ubuntu-18.04
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: g++-8
           - toolset: gcc-9
             cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            container: ubuntu:20.04
+            os: ubuntu-latest
           - toolset: gcc-10
             cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: g++-10
           - toolset: gcc-11
             cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: g++-11
+            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: gcc-15
+            cxxstd: "11,14,17,20,23,2c"
+            os: ubuntu-latest
+            container: ubuntu:25.04
+            install: g++-15
           - 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
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: clang-6.0
           - toolset: clang
             compiler: clang++-7
             cxxstd: "11,14,17"
-            os: ubuntu-18.04
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: clang-7
           - toolset: clang
             compiler: clang++-8
             cxxstd: "11,14,17"
-            os: ubuntu-20.04
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: clang-8
           - toolset: clang
             compiler: clang++-9
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17"
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: clang-9
           - toolset: clang
             compiler: clang++-10
             cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: clang-10
           - toolset: clang
             compiler: clang++-11
             cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: clang-11
           - toolset: clang
             compiler: clang++-12
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17,20"
+            container: ubuntu:20.04
+            os: ubuntu-latest
             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.04
+            os: ubuntu-latest
+            install: clang-19
+          - toolset: clang
+            compiler: clang++-20
+            cxxstd: "11,14,17,20,23,2c"
+            container: ubuntu:25.04
+            os: ubuntu-latest
+            install: clang-20
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-14
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-15
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-26
+
+    name: ${{matrix.platform.os}} / ${{matrix.platform.compiler || matrix.platform.toolset}}${{matrix.config.name && format(' / {0}', matrix.config.name) || ''}}
+
+    runs-on: ${{matrix.platform.os}}
 
-    runs-on: ${{matrix.os}}
+    container:
+      image: ${{matrix.platform.container}}
+      volumes:
+        - /node20217:/node20217:rw,rshared
+        - ${{ startsWith(matrix.platform.container, 'ubuntu:1') && '/node20217:/__e/node20:ro,rshared' || ' ' }}
+
+    defaults:
+      run:
+        shell: bash
 
     steps:
-      - uses: actions/checkout@v2
+      - name: Setup container environment
+        if: matrix.platform.container
+        run: |
+          apt-get update
+          apt-get -y install sudo python3 git g++ curl xz-utils
+
+      - name: Install nodejs20glibc2.17
+        if: ${{ startsWith( matrix.platform.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}}
+        if: matrix.platform.install
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ${{matrix.platform.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
 
       - name: Create user-config.jam
-        if: matrix.compiler
+        if: matrix.platform.compiler
         run: |
-          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
+          echo "using ${{matrix.platform.toolset}} : : ${{matrix.platform.compiler}} ;" > ~/user-config.jam
 
       - 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.platform.toolset}} cxxstd=${{matrix.platform.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} link=shared,static variant=${{matrix.config.variant}}
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.platform.toolset}} cxxstd=${{matrix.platform.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} link=shared,static variant=${{matrix.config.variant}} exception-handling=off rtti=off
 
   windows:
     strategy:
       fail-fast: false
       matrix:
-        include:
-          - toolset: msvc-14.1
-            cxxstd: "14,17,latest"
+        config:
+          - variant: "debug,release"
+          - name: No capture
+            variant: "leaf_debug_capture0,leaf_release_capture0"
+          - name: No diagnostics
+            variant: "leaf_debug_diag0,leaf_release_diag0"
+          - name: Embedded
+            variant: "leaf_debug_embedded,leaf_release_embedded"
+          - name: Single header
+            variant: "leaf_debug_single_header,leaf_release_single_header"
+        platform:
+          - toolset: msvc-14.3
+            cxxstd: "14,17,20,latest"
             addrmd: 32,64
-            os: windows-2016
-          - toolset: msvc-14.2
-            cxxstd: "14,17,latest"
-            addrmd: 32,64
-            os: windows-2019
+            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
-            os: windows-2019
+            os: windows-2022
+
+    name: ${{matrix.platform.os}} / ${{matrix.platform.compiler || matrix.platform.toolset}}${{matrix.config.name && format(' / {0}', matrix.config.name) || ''}}
 
-    runs-on: ${{matrix.os}}
+    runs-on: ${{matrix.platform.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 --abbreviate-paths libs/%LIBRARY%/test toolset=${{matrix.platform.toolset}} cxxstd=${{matrix.platform.cxxstd}} address-model=${{matrix.platform.addrmd}} link=shared,static variant=${{matrix.config.variant}}
+          b2 -j3 --abbreviate-paths libs/%LIBRARY%/test toolset=${{matrix.platform.toolset}} cxxstd=${{matrix.platform.cxxstd}} address-model=${{matrix.platform.addrmd}} link=shared,static variant=${{matrix.config.variant}} exception-handling=off rtti=off
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..d366525b 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_available=true -D leaf_enable_examples=true _bld/debug && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D leaf_single_header=true _bld/debug_single_header && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true _bld/release --buildtype release && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D leaf_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 leaf_boost_available=true -D leaf_enable_examples=true -D cpp_eh=none _bld/debug && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D leaf_single_header=true -D cpp_eh=none _bld/debug_single_header && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D cpp_eh=none _bld/release --buildtype release && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D leaf_single_header=true -D cpp_eh=none _bld/release_single_header --buildtype release",
+            "problemMatcher": []
+        },
+        {
+            "label": "Setup Meson build directories (no diagnostics)",
+            "type": "shell",
+            "command": "cd ${workspaceRoot} && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D leaf_diagnostics=0 _bld/debug && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D leaf_single_header=true -D leaf_diagnostics=0 _bld/debug_single_header && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D leaf_diagnostics=0 _bld/release --buildtype release && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D leaf_single_header=true -D leaf_diagnostics=0 _bld/release_single_header --buildtype release",
+            "problemMatcher": []
+        },
+        {
+            "label": "Setup Meson build directories (no capture)",
+            "type": "shell",
+            "command": "cd ${workspaceRoot} && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D leaf_capture=0 _bld/debug && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D leaf_single_header=true -D leaf_capture=0 _bld/debug_single_header && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D leaf_capture=0 _bld/release --buildtype release && meson setup -D leaf_boost_available=true -D leaf_enable_examples=true -D leaf_single_header=true -D leaf_capture=0 _bld/release_single_header --buildtype release",
+            "problemMatcher": []
+        },
+        {
+            "label": "Setup Meson build directories (no Boost)",
+            "type": "shell",
+            "command": "cd ${workspaceRoot} && meson setup -D leaf_boost_available=false -D leaf_enable_examples=true _bld/debug && meson setup -D leaf_boost_available=false -D leaf_enable_examples=true -D leaf_single_header=true _bld/debug_single_header && meson setup -D leaf_boost_available=false -D leaf_enable_examples=true _bld/release --buildtype release && meson setup -D leaf_boost_available=false -D leaf_enable_examples=true -D leaf_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 leaf_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 leaf_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 leaf_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 leaf_single_header=true _bld/release_single_header --buildtype release",
             "problemMatcher": []
         },
         {
@@ -28,13 +58,22 @@
             },
             "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"
                 ]
+            },
+            "windows": {
+                "problemMatcher": {
+                    "base": "$msCompile",
+                    "fileLocation": [
+                        "relative",
+                        "${workspaceRoot}/_bld/debug"
+                    ]
+                }
             }
         },
         {
@@ -44,13 +83,22 @@
             "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"
                 ]
+            },
+            "windows": {
+                "problemMatcher": {
+                    "base": "$msCompile",
+                    "fileLocation": [
+                        "relative",
+                        "${workspaceRoot}/_bld/debug"
+                    ]
+                }
             }
         },
         {
@@ -60,13 +108,22 @@
             "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"
                 ]
+            },
+            "windows": {
+                "problemMatcher": {
+                    "base": "$msCompile",
+                    "fileLocation": [
+                        "relative",
+                        "${workspaceRoot}/_bld/release"
+                    ]
+                }
             }
         },
         {
@@ -76,16 +133,23 @@
             "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",
-            "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 --abbreviate-paths 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 --abbreviate-paths 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",
             "problemMatcher": {
                 "base": "$gcc",
                 "fileLocation": [
                     "relative",
-                    "${workspaceRoot}/bld/release"
+                    "${workspaceRoot}/_bld/release"
                 ]
+            },
+            "windows": {
+                "command": "..\\..\\b2 --abbreviate-paths 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 --abbreviate-paths 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": "$msCompile",
+                    "fileLocation": [
+                        "relative",
+                        "${workspaceRoot}/_bld/release"
+                    ]
+                }
             }
         },
         {
@@ -95,13 +159,26 @@
             },
             "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} || type .\\meson-logs\\testlog.txt)",
+            },
             "problemMatcher": {
                 "base": "$gcc",
                 "fileLocation": [
                     "relative",
-                    "${workspaceRoot}/bld/debug"
+                    "${workspaceRoot}/_bld/debug"
                 ]
+            },
+            "windows": {
+                "command": "cd ${workspaceRoot}/_bld/debug && ninja && (meson test ${fileBasenameNoExtension} || type .\\meson-logs\\testlog.txt)",
+                "problemMatcher": {
+                    "base": "$msCompile",
+                    "fileLocation": [
+                        "relative",
+                        "${workspaceRoot}/_bld/debug"
+                    ]
+                }
             }
         }
     ]
diff --git a/README.md b/README.md
index a8241876..53ca5f84 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-2025 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/build.jam b/build.jam
new file mode 100644
index 00000000..0fcce930
--- /dev/null
+++ b/build.jam
@@ -0,0 +1,17 @@
+# Copyright René Ferdinand Rivera Morell 2023-2024
+# 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)
+
+require-b2 5.2 ;
+
+project /boost/leaf
+    ;
+
+explicit
+    [ alias boost_leaf : : : : <include>include ]
+    [ alias all : boost_leaf test ]
+    ;
+
+call-if : boost-library leaf
+    ;
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..c01f4634 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,38 +61,38 @@ 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.
 
 [[tutorial]]
 == Tutorial
 
-What is a failure? It is simply the inability of a function to return a valid result, instead producing an error object describing the reason for the failure.
+Typically, error handling libraries define a variant result type, e.g. `result<T, E>`. In LEAF we drop the `E`, using just `result<T>`.
 
-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`.
+In case of success, access to the value `T` is immediate and direct, and we can easily bail out in case of a failure.
 
-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.
+To handle errors, we use a special syntax, which enables error objects to be transported directly to the error handling scopes that need them. This is more efficient than holding them in result types, and it also allows any given handler to access multiple error objects associated with the same failure.
 
-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.
-
-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.
+LEAF is also compatible with exception handling, providing identical functionality but without needing a result type.
 
 === Reporting Errors
 
-A function that reports an error is pretty straight-forward:
+Let's introduce the `result<T>`-based interface first.
+
+Report errors with `leaf::new_error`:
 
 [source,c++]
 ----
-enum class err1 { e1, e2, e3 };
+enum class api_error { connect_failed, invalid_request, timeout };
 
-leaf::result<T> f()
+leaf::result<connection> connect()
 {
   ....
-  if( error_detected )
-    return leaf::new_error( err1::e1 ); // Pass an error object of any type
+  if( <<connection-failure-detected>> )
+    return leaf::new_error( api_error::connect_failed ); // Pass error objects of any type
 
-  // Produce and return a T.
+  // Produce and return a connection object.
 }
 ----
 [.text-right]
@@ -106,65 +103,65 @@ leaf::result<T> f()
 [[checking_for_errors]]
 === Checking for Errors
 
-Checking for errors communicated by a `leaf::result<T>` works as expected:
+To bail out on failure, return `result::error()`:
 
 [source,c++]
 ----
-leaf::result<U> g()
+leaf::result<data> connect_and_fetch_data()
 {
-  leaf::result<T> r = f();
-  if( !r )
-    return r.error();
+  leaf::result<connection> cr = connect();
+  if( !cr )
+    return cr.error();
+
+  connection & c = cr.value();
 
-  T const & v = r.value();
-  // Use v to produce a valid U
+  // Use c to fetch and return data
 }
 ----
 [.text-right]
 <<result>>
 
-TIP: The the result of `r.error()` is compatible with any instance of the `leaf::result` template. In the example above, note that `g` returns a `leaf::result<U>`, while `r` is of type `leaf::result<T>`.
-
-The boilerplate `if` statement can be avoided using `BOOST_LEAF_AUTO`:
+Use `BOOST_LEAF_AUTO` to avoid the boilerplate `if` statement:
 
 [source,c++]
 ----
-leaf::result<U> g()
+leaf::result<data> connect_and_fetch_data()
 {
-  BOOST_LEAF_AUTO(v, f()); // Bail out on error
+  BOOST_LEAF_AUTO(c, connect()); // Bail out on error
 
-  // Use v to produce a valid U
+  // Use c to fetch and return data
 }
 ----
 [.text-right]
 <<BOOST_LEAF_AUTO>>
 
-`BOOST_LEAF_AUTO` can not be used with `void` results; in that case, to avoid the boilerplate `if` statement, use `BOOST_LEAF_CHECK`:
+Use `BOOST_LEAF_CHECK` in case of `void` results:
 
 [source,c++]
 ----
-leaf::result<void> f();
+leaf::result<void> flush(connection & c);
+leaf::result<std::size_t> bytes_sent(connection & c);
 
-leaf::result<int> g()
+leaf::result<std::size_t> flush_and_get_bytes_sent(connection & c)
 {
-  BOOST_LEAF_CHECK(f()); // Bail out on error
-  return 42;
+  BOOST_LEAF_CHECK(flush(c)); // Bail out on error
+  return bytes_sent(c);
 }
 ----
 [.text-right]
 <<BOOST_LEAF_CHECK>>
 
-On implementations that define `pass:[__GNUC__]` (e.g. GCC/clang), the `BOOST_LEAF_CHECK` macro definition takes advantage of https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html[GNU C statement expressions]. In this case, in addition to its portable usage with `result<void>`, `BOOST_LEAF_CHECK` can be used in expressions with non-`void` result types:
+On implementations that define `pass:[__GNUC__]` (e.g. GCC/clang), `BOOST_LEAF_CHECK` is compatible with non-`void` results as well:
 
 [source,c++]
 ----
-leaf::result<int> f();
+leaf::result<int> count_rows();
 
-float g(int x);
+float update_average(int n);
 
-leaf::result<float> t()
+leaf::result<float> average_row_count()
 {
-  return g( BOOST_LEAF_CHECK(f()) );
+  return update_average( BOOST_LEAF_CHECK(count_rows()) );
 }
 ----
 
@@ -172,10 +169,10 @@ The following is the portable alternative:
 
 [source,c++]
 ----
-leaf::result<float> t()
+leaf::result<float> average_row_count()
 {
-  BOOST_LEAF_AUTO(x, f());
-  return g(x);
+  BOOST_LEAF_AUTO(n, count_rows());
+  return update_average(n);
 }
 ----
 
@@ -184,88 +181,82 @@ leaf::result<float> t()
 [[tutorial-error_handling]]
 === Error Handling
 
-Error handling scopes must use a special syntax to indicate that they need to access error objects. The following excerpt attempts several operations and handles errors of type `err1`:
+Error handling scopes use a special syntax to indicate that they need to access error objects:
 
 [source,c++]
 ----
-leaf::result<U> r = leaf::try_handle_some(
+leaf::result<data> r = leaf::try_handle_some(
 
-  []() -> leaf::result<U>
+  []() -> leaf::result<data>
   {
-    BOOST_LEAF_AUTO(v1, f1());
-    BOOST_LEAF_AUTO(v2, f2());
-
-    return g(v1, v2);
+    BOOST_LEAF_AUTO(c, connect());
+    return fetch(c);
   },
 
-  []( err1 e ) -> leaf::result<U>
+  []( api_error e ) -> leaf::result<data>
   {
-    if( e == err1::e1 )
-      .... // Handle err1::e1
+    if( e == api_error::connect_failed )
+      .... // Handle api_error::connect_failed
     else
-      .... // Handle any other err1 value
+      .... // Handle any other api_error value
   } );
 ----
 [.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<data>`, 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 `api_error`. 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 `api_error`). Error handlers passed to `leaf::try_handle_some` can return a valid `leaf::result` 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++]
 ----
-leaf::result<U> r = leaf::try_handle_some(
+leaf::result<data> r = leaf::try_handle_some(
 
-  []() -> leaf::result<U>
+  []() -> leaf::result<data>
   {
-    BOOST_LEAF_AUTO(v1, f1());
-    BOOST_LEAF_AUTO(v2, f2());
-
-    return g(v1. v2);
+    BOOST_LEAF_AUTO(c, connect());
+    return fetch(c);
   },
 
-  []( leaf::match<err1, err1::e1, err1::e3> ) -> leaf::result<U>
+  []( leaf::match<api_error, api_error::connect_failed, api_error::timeout> ) -> leaf::result<data>
   {
-    // Handle err::e1
+    // Handle api_error::connect_failed or api_error::timeout
   },
 
-  []( err1 e ) -> leaf::result<U>
+  []( api_error e ) -> leaf::result<data>
   {
-    // Handle any other err1 value
+    // Handle any other api_error value
   } );
 ----
 [.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 `api_error` is available, and its value is either `api_error::connect_failed` or `api_error::timeout`.
 
-* 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 `api_error` 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++]
 ----
-leaf::result<U> r = leaf::try_handle_some(
+leaf::result<data> r = leaf::try_handle_some(
 
-  []() -> leaf::result<U>
+  []() -> leaf::result<data>
   {
-    BOOST_LEAF_AUTO(v1, f1());
-    BOOST_LEAF_AUTO(v2, f2());
-
-    return g(v1. v2);
+    BOOST_LEAF_AUTO(c, connect());
+    return fetch(c);
   },
 
-  []( err1 e, leaf::error_info const & ei ) -> leaf::result<U>
+  []( api_error e, leaf::error_info const & ei ) -> leaf::result<data>
   {
-    if( <<condition>> )
-      return valid_U;
+    if( e == api_error::timeout )
+      return cached_data();
     else
       return ei.error();
   } );
@@ -281,27 +272,25 @@ If we want to ensure that all possible failures are handled, we use `leaf::try_h
 
 [source,c++]
 ----
-U r = leaf::try_handle_all(
+data r = leaf::try_handle_all(
 
-  []() -> leaf::result<U>
+  []() -> leaf::result<data>
   {
-    BOOST_LEAF_AUTO(v1, f1());
-    BOOST_LEAF_AUTO(v2, f2());
-
-    return g(v1. v2);
+    BOOST_LEAF_AUTO(c, connect());
+    return fetch(c);
   },
 
-  []( leaf::match<err1, err1::e1> ) -> U
+  []( leaf::match<api_error, api_error::connect_failed> ) -> data
   {
-    // Handle err::e1
+    // Handle api_error::connect_failed
   },
 
-  []( err1 e ) -> U
+  []( api_error e ) -> data
   {
-    // Handle any other err1 value
+    // Handle any other api_error value
   },
 
-  []() -> U
+  []() -> data
   {
     // Handle any other failure
   } );
@@ -309,7 +298,7 @@ U r = leaf::try_handle_all(
 [.text-right]
 <<try_handle_all>>
 
-The `leaf::try_handle_all` function enforces at compile time that at least one of the supplied error handlers takes no arguments (and therefore is able to handle any failure). In addition, all error handlers are forced to return a valid `U`, rather than a `leaf::result<U>`, so that `leaf::try_handle_all` is guaranteed to succeed, always.
+The `leaf::try_handle_all` function enforces at compile time that at least one of the supplied error handlers takes no arguments (and therefore is able to handle any failure). In addition, all error handlers are forced to return a valid object rather than a `leaf::result`, so that `leaf::try_handle_all` is guaranteed to succeed.
 
 '''
 
@@ -319,38 +308,36 @@ It is of course possible to provide different handlers for different error types
 
 [source,c++]
 ----
-enum class err1 { e1, e2, e3 };
-enum class err2 { e1, e2 };
+enum class api_error { connect_failed, invalid_request, timeout };
+enum class auth_error { unauthorized, forbidden };
 
 ....
 
-leaf::result<U> r = leaf::try_handle_some(
+leaf::result<data> r = leaf::try_handle_some(
 
-  []() -> leaf::result<U>
+  []() -> leaf::result<data>
   {
-    BOOST_LEAF_AUTO(v1, f1());
-    BOOST_LEAF_AUTO(v2, f2());
-
-    return g(v1, v2);
+    BOOST_LEAF_AUTO(c, connect());
+    return fetch(c);
   },
 
-  []( err1 e ) -> leaf::result<U>
+  []( api_error e ) -> leaf::result<data>
   {
-    // Handle errors of type `err1`.
+    // Handle errors of type `api_error`.
   },
 
-  []( err2 e ) -> leaf::result<U>
+  []( auth_error e ) -> leaf::result<data>
   {
-    // Handle errors of type `err2`.
+    // Handle errors of type `auth_error`.
   } );
 ----
 [.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;
+* The first error handler will be used if an error object of type `api_error` is available;
+* otherwise, the second error handler will be used if an error object of type `auth_error` is available;
 * otherwise, `leaf::try_handle_some` fails.
 
 '''
@@ -363,7 +350,7 @@ The `leaf::new_error` function can be invoked with multiple error objects, for e
 ----
 enum class io_error { open_error, read_error, write_error };
 
-struct e_file_name { std::string value; }
+struct e_file_name { std::string value; };
 
 leaf::result<File> open_file( char const * name )
 {
@@ -380,20 +367,20 @@ Similarly, error handlers may take multiple error objects as arguments:
 
 [source,c++]
 ----
-leaf::result<U> r = leaf::try_handle_some(
+leaf::result<T> r = leaf::try_handle_some(
 
-  []() -> leaf::result<U>
+  []() -> leaf::result<T>
   {
     BOOST_LEAF_AUTO(f, open_file(fn));
     ....
   },
 
-  []( io_error ec, e_file_name fn ) -> leaf::result<U>
+  []( io_error ec, e_file_name fn ) -> leaf::result<T>
   {
-    // 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>
+  []( io_error ec ) -> leaf::result<T>
   {
     // Handle I/O errors when no file name is available.
   } );
@@ -403,26 +390,26 @@ leaf::result<U> r = leaf::try_handle_some(
 
 Once again, error handlers are considered in order:
 
-* The first error handler will be used if an error object of type `io_error` _and_ and error_object of type `e_file_name` are available;
-* otherwise, the second error handler will be used if an error object of type `io_error` is avaliable;
-* otherwise, `leaf_try_handle_some` fails.
+* The first error handler will be used if an error object of type `io_error` _and_ an error object of type `e_file_name` are available;
+* otherwise, the second error handler will be used if an error object of type `io_error` is available;
+* otherwise, `leaf::try_handle_some` fails.
  
 An alternative way to write the above is to provide a single error handler that takes the `e_file_name` argument as a pointer:
 
 [source,c++]
 ----
-leaf::result<U> r = leaf::try_handle_some(
+leaf::result<T> r = leaf::try_handle_some(
 
-  []() -> leaf::result<U>
+  []() -> leaf::result<T>
   {
     BOOST_LEAF_AUTO(f, open_file(fn));
     ....
   },
 
-  []( io_error ec, e_file_name const * fn ) -> leaf::result<U>
+  []( io_error ec, e_file_name const * fn ) -> leaf::result<T>
   {
     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,14 +417,14 @@ 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
 
-Let's say we have a function `parse_line` which could fail due to an `io_error` or  a `parse_error`:
+Let's say we have a function `parse_line` which could fail due to an `io_error` or a `parse_error`:
 
 [source,c++]
 ----
@@ -469,7 +456,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:
 
@@ -518,7 +505,7 @@ leaf::result<void> r = leaf::try_handle_some(
 
   []( io_error e, e_line const * current_line )
   {
-    std::cerr << "Parse error";
+    std::cerr << "I/O error";
     if( current_line )
       std::cerr << " at line " << current_line->value;
     std::cerr << std::endl;
@@ -530,7 +517,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++]
 ----
@@ -553,7 +540,7 @@ leaf::result<void> r = leaf::try_handle_some(
 
   []( io_error e, e_line const * l )
   {
-    std::cerr << "Parse error";
+    std::cerr << "I/O error";
     if( l )
       std::cerr << " at line " << l.value;
     std::cerr << std::endl;
@@ -587,7 +574,7 @@ leaf::try_catch(
 
   []( io_error e, e_line const * l )
   {
-    std::cerr << "Parse error";
+    std::cerr << "I/O error";
     if( l )
       std::cerr << " at line " << l.value;
     std::cerr << std::endl;
@@ -596,14 +583,14 @@ 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 would `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++]
 ----
-enum class err1 { e1, e2, e3 };
-enum class err2 { e1, e2 };
+enum class api_error { connect_failed, invalid_request, timeout };
+enum class auth_error { unauthorized, forbidden };
 
 ....
 
@@ -611,7 +598,7 @@ leaf::result<T> f()
 {
   ....
   if( error_detected )
-    return leaf::new_error(err1::e1, err2::e2);
+    return leaf::new_error(api_error::connect_failed, auth_error::forbidden);
 
   // Produce and return a T.
 }
@@ -623,30 +610,30 @@ When using exception handling this becomes:
 
 [source,c++]
 ----
-enum class err1 { e1, e2, e3 };
-enum class err2 { e1, e2 };
+enum class api_error { connect_failed, invalid_request, timeout };
+enum class auth_error { unauthorized, forbidden };
 
 T f()
 {
   if( error_detected )
-    throw leaf::exception(err1::e1, err2::e2);
+    leaf::throw_exception(api_error::connect_failed, auth_error::forbidden);
 
   // 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 standard 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!"), api_error::connect_failed, auth_error::forbidden);
 ----
 
-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 a 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 +688,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++]
 ----
@@ -721,7 +708,6 @@ leaf::result<int> r = leaf::try_handle_some(
   {
     // Handle lib2::error_code
   } );
-}
 ----
 [.text-right]
 <<try_handle_some>> | <<result>>
@@ -756,7 +742,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 )
@@ -792,54 +778,22 @@ lib3::result<int> r = leaf::try_handle_some(
   {
     // Handle lib2::error_code
   } );
-}
 ----
 [.text-right]
 <<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, an 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`.
+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 low level library throws an exception, which is unlikely to be able to carry an `error_id`.
 
 To support this tricky use case, LEAF provides the function <<current_error>>, which returns the error ID returned by the most recent call (from this thread) to <<new_error>>. One possible approach to solving the problem is to use the following logic (implemented by the <<error_monitor>> type):
 
@@ -852,14 +806,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_some`, `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 +849,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 +878,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 reference 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 +921,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,65 +945,65 @@ 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:
 
 [source,c++]
 ----
-enum class my_error
+enum class validation_error
 {
-  e1=1,
-  e2,
-  e3
+  empty_field = 1,
+  invalid_format,
+  out_of_range
 };
 ----
 
-We could handle `my_error` errors like so:
+We could handle `validation_error` errors like so:
 
 [source,c++]
 ----
@@ -1059,31 +1011,28 @@ return leaf::try_handle_some(
 
   []
   {
-    return f(); // returns leaf::result<T>
+    return validate_input(); // Returns leaf::result<input>
   },
 
-  []( my_error e )
-  { <1>
+  []( validation_error e )
+  {
     switch(e)
     {
-      case my_error::e1:
-        ....; <2>
+      case validation_error::empty_field:
+        ....; // Handle empty_field errors
         break;
-      case my_error::e2:
-      case my_error::e3:
-        ....; <3>
+      case validation_error::invalid_format:
+      case validation_error::out_of_range:
+        ....; // Handle invalid_format and out_of_range errors
         break;
       default:
-        ....; <4>
+        ....; // Handle unexpected validation_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 `validation_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:
 
@@ -1093,29 +1042,26 @@ return leaf::try_handle_some(
 
   []
   {
-    return f(); // returns leaf::result<T>
+    return validate_input(); // Returns leaf::result<input>
   },
 
-  []( leaf::match<my_error, my_error::e1> m )
-  { <1>
-    assert(m.matched == my_error::e1);
+  []( leaf::match<validation_error, validation_error::empty_field> m )
+  {
+    assert(m.matched == validation_error::empty_field);
     ....;
   },
 
-  []( leaf::match<my_error, my_error::e2, my_error::e3> m )
-  { <2>
-    assert(m.matched == my_error::e2 || m.matched == my_error::e3);
+  []( leaf::match<validation_error, validation_error::invalid_format, validation_error::out_of_range> m )
+  {
+    assert(m.matched == validation_error::invalid_format || m.matched == validation_error::out_of_range);
     ....;
   },
 
-  []( my_error e )
-  { <3>
+  []( validation_error e )
+  {
     ....;
   } );
 ----
-<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 +1074,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,11 +1083,11 @@ 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++]
 ----
-[]( std::error_code, leaf::category<std::errc>> )
+[]( std::error_code, leaf::category<std::errc> )
 {
 }
 ----
@@ -1152,140 +1098,140 @@ 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.
+* <<match_member>>: similar to `match_value`, but takes a pointer to the data member to compare; that is, `match_member<&E::value, V...>` is equivalent to `match_value<E, V...>`. Note, however, that `match_member` requires {CPP}17 or newer, while `match_value` does not.
+* `<<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:
 
 [source,c++]
 ----
-leaf::try_handle_all(
+config cfg = leaf::try_handle_all(
 
   [&]
   {
-    return f(); // returns leaf::result<T>
+    return load_config_file(config_path); // returns leaf::result<config>
   },
 
-  [](my_error_enum x)
+  [](api_error e) -> config
   {
-    ...
+    ....
   },
 
-  [](read_file_error_enum y, e_file_name const & fn)
+  [](io_error e, e_file_name const & fn) -> config
   {
-    ...
+    ....
   },
 
-  []
+  []() -> config
   {
-    ...
+    ....
   });
 ----
 
 [.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++]
 ----
-leaf::try_handle_all(
+config cfg = leaf::try_handle_all(
 
   [&]
   {
-    return g(); // returns leaf::result<T>
+    return load_config_file(fallback_path); // returns leaf::result<config>
   },
 
-  [](my_error_enum x)
+  [](api_error e) -> config
   {
-    ...
+    ....
   },
 
-  [](read_file_error_enum y, e_file_name const & fn)
+  [](io_error e, e_file_name const & fn) -> config
   {
-    ...
+    ....
   },
 
-  []
+  []() -> config
   {
-    ...
+    ....
   });
 ----
 
-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++]
 ----
-auto error_handlers = std::make_tuple(
+auto load_config_error_handlers = std::make_tuple(
 
-  [](my_error_enum x)
+  [](api_error e) -> config
   {
-    ...
+    ....
   },
 
-  [](read_file_error_enum y, e_file_name const & fn)
+  [](io_error e, e_file_name const & fn) -> config
   {
-    ...
+    ....
   },
 
-  []
+  []() -> config
   {
-    ...
+    ....
   });
 ----
 
-The `error_handlers` tuple can later be used with any error handling function:
+The `load_config_error_handlers` tuple can later be used with any error handling function:
 
 [source,c++]
 ----
-leaf::try_handle_all(
+config cfg1 = leaf::try_handle_all(
 
   [&]
   {
-    // Operations which may fail <1>
+    return load_config_file(config_path); // <1>
   },
 
-  error_handlers );
+  load_config_error_handlers );
 
-leaf::try_handle_all(
+config cfg2 = leaf::try_handle_all(
 
   [&]
   {
-    // Different operations which may fail <2>
+    return load_config_file(fallback_path); // <2>
   },
 
-  error_handlers ); <3>
+  load_config_error_handlers ); // <3>
 ----
 [.text-right]
 <<try_handle_all>> | <<error_info>>
 
 <1> One set of operations which may fail...
 <2> A different set of operations which may fail...
-<3> ... both using the same `error_handlers`.
+<3> ... both using the same `load_config_error_handlers`.
 
 Error handling functions accept a `std::tuple` of error handlers in place of any error handler. The behavior is as if the tuple is unwrapped in-place.
 
 '''
 
 [[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 +1240,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 +1250,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++]
 ----
@@ -1356,35 +1271,9 @@ return leaf::try_handle_some(
   {
     BOOST_LEAF_AUTO(r, fut.get());
     //Success!
-    return { }
+    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 +1289,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 +1393,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 +1476,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 +1487,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`:
 
@@ -1605,68 +1517,31 @@ Remarkably, because the classification of the failure does not depend on error c
 [[tutorial-exception_to_result]]
 === Converting Exceptions to `result<T>`
 
-It is sometimes necessary to catch exceptions thrown by a lower-level library function, and report the error through different means, to a higher-level library which may not use exception handling.
-
-TIP: Error handlers that take arguments of types that derive from `std::exception` work correctly -- regardless of whether the error object itself is thrown as an exception, or <<tutorial-loading,loaded>> into a <<context>>. The technique described here is only needed when the exception must be communicated through functions which are not exception-safe, or are compiled with exception handling disabled.
-
-Suppose we have an exception type hierarchy and a function `compute_answer_throws`:
+When integrating a library that throws exceptions into code that uses `result<T>`, use `exception_to_result` to convert exceptions at the boundary:
 
 [source,c++]
 ----
-class error_base: public std::exception { };
-class error_a: public error_base { };
-class error_b: public error_base { };
-class error_c: public error_base { };
-
-int compute_answer_throws()
-{
-  switch( rand()%4 )
-  {
-    default: return 42;
-    case 1: throw error_a();
-    case 2: throw error_b();
-    case 3: throw error_c();
-  }
-}
-----
+struct parse_error: std::exception { };
+struct syntax_error: parse_error { };
+struct encoding_error: parse_error { };
 
-We can write a simple wrapper using `exception_to_result`, which calls `compute_answer_throws` and switches to `result<int>` for error handling:
+json_value parse_json(char const * str); // Throws parse_error
 
-[source,c++]
-----
-leaf::result<int> compute_answer() noexcept
+leaf::result<json_value> safe_parse_json(char const * str) noexcept
 {
-  return leaf::exception_to_result<error_a, error_b>(
-    []
+  return leaf::exception_to_result<syntax_error, encoding_error>(
+    [&]
     {
-      return compute_answer_throws();
+      return parse_json(str);
     } );
 }
 ----
-
 [.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.
-
-(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`).
-
-Here is a simple function which prints successfully computed answers, forwarding any error (originally reported by throwing an exception) to its caller:
-
-[source,c++]
-----
-leaf::result<void> print_answer() noexcept
-{
-  BOOST_LEAF_AUTO(answer, compute_answer());
-  std::cout << "Answer: " << answer << std::endl;
-  return { };
-}
-----
-
-[.text-right]
-<<result>> | <<BOOST_LEAF_AUTO>>
+The template arguments specify which exception types to capture as error objects. All exceptions are caught, and for each type listed, LEAF attempts a `dynamic_cast` and loads a copy of that slice. The `std::current_exception()` is also captured, so unlisted exception types can still be handled.
 
-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.
+Errors can then be handled normally:
 
 [source,c++]
 ----
@@ -1674,191 +1549,77 @@ leaf::try_handle_all(
 
   []() -> leaf::result<void>
   {
-    BOOST_LEAF_CHECK(print_answer());
+    BOOST_LEAF_AUTO(doc, safe_parse_json(input));
+    process(doc);
     return { };
   },
 
-  [](error_a const & e)
+  [](syntax_error const &)
   {
-    std::cerr << "Error A!" << std::endl;
+    std::cerr << "JSON syntax error" << std::endl;
   },
 
-  [](error_b const & e)
+  [](encoding_error const &)
   {
-    std::cerr << "Error B!" << std::endl;
+    std::cerr << "Invalid encoding" << std::endl;
   },
 
   []
   {
-    std::cerr << "Unknown error!" << std::endl;
+    std::cerr << "Unknown error" << std::endl;
   } );
 ----
-
 [.text-right]
-<<try_handle_all>> | <<result>> | <<BOOST_LEAF_CHECK>>
+<<try_handle_all>> | <<result>> | <<BOOST_LEAF_AUTO>>
 
-NOTE: The complete program illustrating this technique is available https://github.com/boostorg/leaf/blob/master/example/exception_to_result.cpp?ts=4[here].
+TIP: Handlers that take exception types work the same way whether the object was thrown or loaded via `exception_to_result`.
 
 '''
 
 [[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.
+=== Using `error_monitor` to Report Errors from C Callbacks
 
-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.
+C callbacks have fixed signatures that cannot return {CPP} types like `leaf::result<T>`. The <<error_monitor>> class solves this problem.
 
-C/{CPP} functions designed to be invoked from a Lua program must use the following signature:
-
-[source,c]
-----
-int do_work( lua_State * L ) ;
-----
-
-Arguments are passed on the Lua stack (which is accessible through `L`). Results too are pushed onto the Lua stack.
-
-First, let's initialize the Lua interpreter and register a function, `do_work`, as a C callback available for Lua programs to call:
-
-[source,c++]
-----
-std::shared_ptr<lua_State> init_lua_state() noexcept
-{
-  std::shared_ptr<lua_State> L(lua_open(), &lua_close); //<1>
-
-  lua_register(&*L, "do_work", &do_work); //<2>
-
-  luaL_dostring(&*L, "\ //<3>
-\n      function call_do_work()\
-\n          return do_work()\
-\n      end");
-
-  return L;
-}
-----
-<1> Create a new `lua_State`. We'll use `std::shared_ptr` for automatic cleanup.
-<2> Register the `do_work` {CPP} function as a C callback, under the global name `do_work`. With this, calls from Lua programs to `do_work` will land in the `do_work` {CPP} function.
-<3> Pass some Lua code as a `C` string literal to Lua. This creates a global Lua function called `call_do_work`, which we will later ask Lua to execute.
-
-Next, let's define our `enum` used to communicate `do_work` failures:
+Consider a C library that invokes a user-provided callback:
 
 [source,c++]
 ----
-enum do_work_error_code
-{
-  ec1=1,
-  ec2
-};
-----
+enum class parse_error { unexpected_token, invalid_syntax };
 
-We're now ready to define the `do_work` callback function:
-
-[source,c++]
-----
-int do_work( lua_State * L ) noexcept
+int on_element(void * ctx, char const * data)
 {
-  bool success = rand() % 2; <1>
-  if( success )
-  {
-    lua_pushnumber(L, 42); <2>
-    return 1;
-  }
-  else
+  if( <<error-detected>> )
   {
-    (void) leaf::new_error(ec1); <3>
-    return luaL_error(L, "do_work_error"); <4>
+    leaf::new_error(parse_error::unexpected_token);
+    return -1;
   }
+  return 0;
 }
 ----
 [.text-right]
-<<new_error>> | <<error_id::load>>
-
-<1> "Sometimes" `do_work` fails.
-<2> In case of success, push the result on the Lua stack, return back to Lua.
-<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.
+<<new_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,result>><int>`, so that our caller can get the answer in case of success, or an error:
+The callback calls `new_error` to associate error objects with the failure, then returns an error code to the C library. The wrapper function uses `error_monitor` to retrieve the `error_id`:
 
 [source,c++]
 ----
-leaf::result<int> call_lua( lua_State * L )
+leaf::result<document> parse(char const * input)
 {
-  lua_getfield(L, LUA_GLOBALSINDEX, "call_do_work");
-
-  error_monitor cur_err;
-  if( int err = lua_pcall(L, 0, 1, 0) ) <1>
-  {
-    auto load = leaf::on_error(e_lua_error_message{lua_tostring(L,1)}); <2>
-    lua_pop(L,1);
+  leaf::error_monitor cur_err;
 
-    return cur_err.assigned_error_id().load(e_lua_pcall_error{err}); <3>
-  }
+  if( c_library_parse(input, &on_element, nullptr) != 0 )
+    return cur_err.assigned_error_id();
   else
-  {
-    int answer = lua_tonumber(L, -1); <4>
-    lua_pop(L, 1);
-    return answer;
-  }
+    return make_document();
 }
 ----
 [.text-right]
-<<result>> | <<on_error>> | <<error_monitor>>
+<<result>> | <<error_monitor>>
 
-<1> Ask the Lua interpreter to call the global Lua function `call_do_work`.
-<2> `on_error` works as usual.
-<3> `load` will use the `error_id` generated in our Lua callback. This is the same `error_id` the `on_error` uses as well.
-<4> Success! Just return the `int` answer.
+If `new_error` was called inside the callback, `assigned_error_id` returns that `error_id`. Otherwise, it calls `new_error` and returns a fresh `error_id`. Either way, the caller can handle the failure normally.
 
-Finally, here is the `main` function which exercises `call_lua`, each time handling any failure:
-
-[source,c++]
-----
-int main() noexcept
-{
-  std::shared_ptr<lua_State> L=init_lua_state();
-
-  for( int i=0; i!=10; ++i )
-  {
-    leaf::try_handle_all(
-
-      [&]() -> leaf::result<void>
-      {
-        BOOST_LEAF_AUTO(answer, call_lua(&*L));
-        std::cout << "do_work succeeded, answer=" << answer << '\n'; <1>
-        return { };
-      },
-
-      [](do_work_error_code e) <2>
-      {
-        std::cout << "Got do_work_error_code = " << e <<  "!\n";
-      },
-
-      [](e_lua_pcall_error const & err, e_lua_error_message const & msg) <3>
-      {
-        std::cout << "Got e_lua_pcall_error, Lua error code = " << err.value << ", " << msg.value << "\n";
-      },
-
-      [](leaf::error_info const & unmatched)
-      {
-        std::cerr <<
-          "Unknown failure detected" << std::endl <<
-          "Cryptic diagnostic information follows" << std::endl <<
-          unmatched;
-      } );
-  }
-----
-[.text-right]
-<<try_handle_all>> | <<result>> | <<BOOST_LEAF_AUTO>> | <<error_info>>
-
-<1> If the call to `call_lua` succeeded, just print the answer.
-<2> Handle `do_work` failures.
-<3> Handle all other `lua_pcall` failures.
-
-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].
-
-''''
+'''
 
 [[tutorial-diagnostic_information]]
 === Diagnostic Information
@@ -1879,7 +1640,7 @@ leaf::try_handle_all(
 
   []() -> leaf::result<void> <1>
   {
-    ...
+    ....
     return leaf::new_error( error_code::write_error, leaf::e_file_name{ "file.txt" } );
   },
 
@@ -1888,25 +1649,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 +1683,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).
+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++]
 ----
@@ -1936,7 +1700,7 @@ leaf::try_handle_all(
 
   []() -> leaf::result<void>
   {
-    ...
+    ....
     return leaf::new_error( error_code::write_error, leaf::e_file_name{ "file.txt" } );
   },
 
@@ -1947,22 +1711,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 +1735,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>`.
 
@@ -1979,35 +1743,35 @@ Let's say we have this `enum`:
 
 [source,c++]
 ----
-enum class libfoo_error
+enum class file_error
 {
-  e1 = 1,
-  e2,
-  e3
+  not_found = 1,
+  permission_denied,
+  disk_full
 };
 ----
 
-We want to be able to transport `libfoo_error` values in `std::error_code` objects. This erases their static type, which enables them to travel freely across API boundaries. To this end, we must define a `std::error_category` that represents our `libfoo_error` type:
+We want to be able to transport `file_error` values in `std::error_code` objects. This erases their static type, which enables them to travel freely across API boundaries. To this end, we must define a `std::error_category` that represents our `file_error` type:
 
 [source,c++]
 ----
-std::error_category const & libfoo_error_category()
+std::error_category const & file_error_category()
 {
   struct category: std::error_category
   {
     char const * name() const noexcept override
     {
-      return "libfoo";
+      return "file_error";
     }
 
     std::string message(int code) const override
     {
-      switch( libfoo_error(code) )
+      switch( file_error(code) )
       {
-        case libfoo_error::e1: return "e1";
-        case libfoo_error::e2: return "e2";
-        case libfoo_error::e3: return "e3";
-        default: return "error";
+        case file_error::not_found: return "file not found";
+        case file_error::permission_denied: return "permission denied";
+        case file_error::disk_full: return "disk full";
+        default: return "unknown file error";
       }
     }
   };
@@ -2017,39 +1781,39 @@ std::error_category const & libfoo_error_category()
 }
 ----
 
-We also need to inform the standard library that `libfoo_error` is compatible with `std::error_code`, and provide a factory function which can be used to make `std::error_code` objects out of `libfoo_error` values:
+We also need to inform the standard library that `file_error` is compatible with `std::error_code`, and provide a factory function which can be used to make `std::error_code` objects out of `file_error` values:
 
 [source,c++]
 ----
 namespace std
 {
   template <>
-  struct is_error_code_enum<libfoo_error>: std::true_type
+  struct is_error_code_enum<file_error>: std::true_type
   {
   };
 }
 
-std::error_code make_error_code(libfoo_error e)
+std::error_code make_error_code(file_error e)
 {
-  return std::error_code(int(e), libfoo_error_category());
+  return std::error_code(int(e), file_error_category());
 }
 ----
 
-With this in place, if we receive a `std::error_code`, we can easily check if it represents some of the `libfoo_error` values we're interested in:
+With this in place, if we receive a `std::error_code`, we can easily check if it represents some of the `file_error` values we're interested in:
 
 [source,c++]
 ----
-std::error_code f();
+std::error_code read_file();
 
 ....
-auto ec = f();
-if( ec == libfoo_error::e1 || ec == libfoo_error::e2 )
+auto ec = read_file();
+if( ec == file_error::not_found || ec == file_error::permission_denied )
 {
-  // We got either a libfoo_error::e1 or a libfoo_error::e2
+  // We got either file_error::not_found or file_error::permission_denied
 }
 ----
 
-This works because the standard library detects that `std::is_error_code_enum<libfoo_error>::value` is `true`, and then uses `make_error_code` to create a `std::error_code` object it actually uses to compare to `ec`.
+This works because the standard library detects that `std::is_error_code_enum<file_error>::value` is `true`, and then uses `make_error_code` to create a `std::error_code` object it actually uses to compare to `ec`.
 
 So far so good, but remember, the standard library defines another type also, `std::error_condition`. The first confusing thing is that in terms of its physical representation, `std::error_condition` is identical to `std::error_code`; that is, it is also like a pair of `std::error_category` reference and an `int`. Why do we need two different types which use identical physical representation?
 
@@ -2057,67 +1821,66 @@ The key to answering this question is to understand that `std::error_code` objec
 
 This leads us to the second confusing thing about `std::error_condition`: it uses the same `std::error_category` type, but for a completely different purpose: to specify what `std::error_code` values are equivalent to what `std::error_condition` values.
 
-Let's say that in addition to `libfoo`, our program uses another library, `libbar`, which communicates failures in terms of `std::error_code` with a different error category. Perhaps `libbar_error` looks like this:
+Let's say that in addition to `file_error`, our program uses a network library which communicates failures in terms of `std::error_code` with a different error category:
 
 [source,c++]
 ----
-enum class libbar_error
+enum class net_error
 {
-  e1 = 1,
-  e2,
-  e3,
-  e4
+  connection_refused = 1,
+  timeout,
+  host_unreachable,
+  dns_failed
 };
 
 // Boilerplate omitted:
-// - libbar_error_category()
+// - net_error_category()
 // - specialization of std::is_error_code_enum
-// - make_error_code factory function for libbar_error.
+// - make_error_code factory function for net_error.
 ----
 
-We can now use `std::error_condition` to define the _logical_ error conditions represented by the `std::error_code` values communicated by `libfoo` and `libbar`:
+We can now use `std::error_condition` to define _logical_ error conditions that group related `std::error_code` values from both libraries:
 
 [source,c++]
 ----
-enum class my_error_condition <1>
+enum class resource_condition <1>
 {
-  c1 = 1,
-  c2
+  unavailable = 1,
+  access_denied
 };
 
-std::error_category const & libfoo_error_category() <2>
+std::error_category const & resource_condition_category() <2>
 {
   struct category: std::error_category
   {
     char const * name() const noexcept override
     {
-      return "my_error_condition";
+      return "resource_condition";
     }
 
     std::string message(int cond) const override
     {
-      switch( my_error_condition(code) )
+      switch( resource_condition(cond) )
       {
-        case my_error_condition::c1: return "c1";
-        case my_error_condition::c2: return "c2";
-        default: return "error";
+        case resource_condition::unavailable: return "resource unavailable";
+        case resource_condition::access_denied: return "access denied";
+        default: return "unknown condition";
       }
     }
 
     bool equivalent(std::error_code const & code, int cond) const noexcept
     {
-      switch( my_error_condition(cond) )
+      switch( resource_condition(cond) )
       {
-        case my_error_condition::c1: <3>
+        case resource_condition::unavailable: <3>
           return
-            code == libfoo_error::e1 ||
-            code == libbar_error::e3 ||
-            code == libbar_error::e4;
-        case my_error_condition::c2: <4>
+            code == file_error::not_found ||
+            code == net_error::host_unreachable ||
+            code == net_error::dns_failed;
+        case resource_condition::access_denied: <4>
           return
-            code == libfoo_error::e2 ||
-            code == libbar_error::e1 ||
-            code == libbar_error::e2;
+            code == file_error::permission_denied ||
+            code == net_error::connection_refused;
         default:
           return false;
       }
@@ -2131,40 +1894,40 @@ std::error_category const & libfoo_error_category() <2>
 namespace std
 {
   template <> <5>
-  class is_error_condition_enum<my_error_condition>: std::true_type
+  class is_error_condition_enum<resource_condition>: std::true_type
   {
   };
 }
 
-std::error_condition make_error_condition(my_error_condition e) <6>
+std::error_condition make_error_condition(resource_condition e) <6>
 {
-  return std::error_condition(int(e), my_error_condition_error_category());
+  return std::error_condition(int(e), resource_condition_category());
 }
 ----
-<1> Enumeration of the two logical error conditions, `c1` and `c2`.
-<2> Define the `std::error_category` for `std::error_condition` objects that represent a `my_error_condition`.
-<3> Here we specify that any of `libfoo:error::e1`, `libbar_error::e3` and `libbar_error::e4` are logically equivalent to `my_error_condition::c1`, and that...
-<4> ...any of `libfoo:error::e2`, `libbar_error::e1` and `libbar_error::e2` are logically equivalent to `my_error_condition::c2`.
-<5> This specialization tells the standard library that the `my_error_condition` enum is designed to be used with `std::error_condition`.
-<6> The factory function to make `std::error_condition` objects out of `my_error_condition` values.
+<1> Enumeration of the two logical conditions: `unavailable` and `access_denied`.
+<2> Define the `std::error_category` for `std::error_condition` objects that represent a `resource_condition`.
+<3> Here we specify that `file_error::not_found`, `net_error::host_unreachable`, and `net_error::dns_failed` are all logically equivalent to `resource_condition::unavailable`, and that...
+<4> ...`file_error::permission_denied` and `net_error::connection_refused` are logically equivalent to `resource_condition::access_denied`.
+<5> This specialization tells the standard library that the `resource_condition` enum is designed to be used with `std::error_condition`.
+<6> The factory function to make `std::error_condition` objects out of `resource_condition` values.
 
 Phew!
 
-Now, if we have a `std::error_code` object `ec`, we can easily check if it is equivalent to `my_error_condition::c1` like so:
+Now, if we have a `std::error_code` object `ec`, we can easily check if it is equivalent to `resource_condition::unavailable` like so:
 
 [source,c++]
 ----
-if( ec == my_error_condition::c1 )
+if( ec == resource_condition::unavailable )
 {
-  // We have a c1 in our hands
+  // The resource is unavailable (file not found, host unreachable, or DNS failed)
 }
 ----
 
-Again, remember that beyond defining the `std::error_category` for `std::error_condition` objects initialized with a `my_error_condition` value, we don't need to interact with the actual `std::error_condition` instances: they're created when needed to compare to a `std::error_code`, and that's pretty much all they're good for.
+Again, remember that beyond defining the `std::error_category` for `std::error_condition` objects initialized with a `resource_condition` value, we don't need to interact with the actual `std::error_condition` instances: they're created when needed to compare to a `std::error_code`, and that's pretty much all they're good for.
 
 ==== Support in LEAF
 
-The `match` predicate can be used as an argument to a LEAF error handler to match a `std::error_code` with a given error condition. For example, to handle `my_error_condition::c1` (see above), we could use:
+The `match` predicate can be used as an argument to a LEAF error handler to match a `std::error_code` with a given error condition. For example, to handle `resource_condition::unavailable` (see above), we could use:
 
 [source,c++]
 ----
@@ -2172,12 +1935,12 @@ leaf::try_handle_some(
 
   []
   {
-    return f(); // returns leaf::result<T>
+    return open_resource(); // returns leaf::result<resource>
   },
 
-  []( leaf::match<std::error_code, my_error_condition::c1> m )
+  []( leaf::match<std::error_code, resource_condition::unavailable> m )
   {
-    assert(m.matched == my_error_condition::c1);
+    assert(m.matched == resource_condition::unavailable);
     ....
   } );
 ----
@@ -2281,69 +2044,100 @@ A standalone single-header option is available; please see <<distribution>>.
 [[synopsis-reporting]]
 === Error Reporting
 
-[[error.hpp]]
-==== `error.hpp`
+[[common.hpp]]
+==== `common.hpp`
 
 ====
-.#include <boost/leaf/error.hpp>
+.#include <boost/leaf/common.hpp>
 [source,c++]
 ----
 namespace boost { namespace leaf {
 
-  class error_id
-  {
-  public:
-
-    error_id() noexcept;
-
-    template <class Enum>
-    error_id( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type * = 0 ) noexcept;
-
-    error_id( std::error_code const & ec ) noexcept;
+  struct e_api_function { char const * value; };
 
-    int value() const noexcept;
-    explicit operator bool() const noexcept;
+  struct e_file_name { std::string value; };
 
-    std::error_code to_error_code() const noexept;
+  struct e_type_info_name { char const * value; };
 
-    friend bool operator==( error_id a, error_id b ) noexcept;
-    friend bool operator!=( error_id a, error_id b ) noexcept;
-    friend bool operator<( error_id a, error_id b ) noexcept;
+  struct e_at_line { int value; };
 
-    template <class... Item>
-    error_id load( Item && ... item ) const noexcept;
+  struct e_errno
+  {
+    int value;
+    explicit e_errno(int value=errno);
 
-    friend std::ostream & operator<<( std::ostream & os, error_id x );
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, e_errno const &);
   };
 
-  bool is_error_id( std::error_code const & ec ) noexcept;
+  namespace windows
+  {
+    struct e_LastError
+    {
+      unsigned value;
 
-  template <class... Item>
-  error_id new_error( Item && ... item ) noexcept;
+      explicit e_LastError(unsigned value);
 
-  error_id current_error() noexcept;
+#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
+    };
+  }
 
-  //////////////////////////////////////////
+} }
+----
 
-  class polymorphic_context
-  {
-  protected:
+[.text-right]
+Reference: <<e_api_function>> | <<e_file_name>> | <<e_at_line>> | <<e_type_info_name>> | <<e_source_location>> | <<e_errno>> | <<e_LastError>>
+====
 
-    polymorphic_context() noexcept = default;
-    ~polymorphic_context() noexcept = default;
+[[error.hpp]]
+==== `error.hpp`
+
+====
+.#include <boost/leaf/error.hpp>
+[source,c++]
+----
+namespace boost { namespace leaf {
 
+  class error_id
+  {
   public:
 
-    virtual void activate() noexcept = 0;
-    virtual void deactivate() noexcept = 0;
-    virtual bool is_active() const noexcept = 0;
+    error_id() noexcept;
+
+    template <class Enum>
+    error_id( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type * = 0 ) noexcept;
+
+    error_id( std::error_code const & ec ) noexcept;
+
+    int value() const noexcept;
+    explicit operator bool() const noexcept;
+
+    std::error_code to_error_code() const noexcept;
+
+    friend bool operator==( error_id a, error_id b ) noexcept;
+    friend bool operator!=( error_id a, error_id b ) noexcept;
+    friend bool operator<( error_id a, error_id b ) noexcept;
 
-    virtual void propagate( error_id ) noexcept = 0;
+    template <class... Item>
+    error_id load( Item && ... item ) const noexcept;
 
-    virtual void print( std::ostream & ) const = 0;
+    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;
+
+  template <class... Item>
+  error_id new_error( Item && ... item ) noexcept;
+
+  error_id current_error() noexcept;
+
+  ////////////////////////////////////////
 
   template <class Ctx>
   class context_activator
@@ -2382,64 +2176,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 +2287,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 +2354,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 +2409,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 +2440,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 +2460,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 +2520,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 +2537,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]]
@@ -2828,7 +2592,7 @@ namespace boost { namespace leaf {
   struct match_member;
 
   template <class E, class T, T E::* P, auto... V>
-  struct member<P, V...>
+  struct match_member<P, V...>
   {
     E matched;
 
@@ -2887,6 +2651,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 +2708,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 +2716,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`
 
@@ -3002,7 +2750,7 @@ leaf::context_type_from_handlers<decltype(error_handlers)> ctx; <1>
 ----
 <1> `ctx` will be of type `context<e_this, e_that>`, deduced automatically from the specified error handlers.
 
-TIP: Alternatively, a suitable context may be created by calling <<make_context>>, or allocated dynamically by calling <<make_shared_context>>.
+TIP: Alternatively, a suitable context may be created by calling <<make_context>>.
 
 '''
 
@@ -3025,82 +2773,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 +2787,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>`.
 
@@ -3134,7 +2806,11 @@ int compute_answer_throws();
 //Call compute_answer, convert exceptions to result<int>
 leaf::result<int> compute_answer()
 {
-  return leaf::exception_to_result<ex_type1, ex_type2>(compute_answer_throws());
+  return leaf::exception_to_result<ex_type1, ex_type2>(
+    []
+    {
+      return compute_answer_throws();
+    } );
 }
 ----
 
@@ -3144,7 +2820,7 @@ At a later time we can invoke <<try_handle_some>> / <<try_handle_all>> as usual,
 ----
 return leaf::try_handle_some(
 
-  [] -> leaf::result<void>
+  []() -> leaf::result<void>
   {
     BOOST_LEAF_AUTO(answer, compute_answer());
     //Use answer
@@ -3220,36 +2896,6 @@ auto ctx = leaf::make_context( <1>
 
 '''
 
-[[make_shared_context]]
-=== `make_shared_context`
-
-.#include <boost/leaf/context.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`
 
@@ -3323,6 +2969,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 function 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 `throw_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`
 
@@ -3333,7 +3055,7 @@ namespace boost { namespace leaf {
 
   template <class... E, class TryBlock>
   std::variant<
-    typename std::decay<decltype(std::declval<TryBlock>()().value())>::type
+    typename std::decay<decltype(std::declval<TryBlock>()().value())>::type,
     std::tuple<
       std::optional<E>...>>
   to_variant( TryBlock && try_block );
@@ -3345,7 +3067,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 +3100,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 +3200,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.
@@ -3527,7 +3282,6 @@ try_handle_some(
 
     return 1;
   } );
-}
 ----
 +
 [.text-right]
@@ -3536,7 +3290,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 +3312,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 +3339,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 +3351,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 +3364,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 +3410,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 +3425,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 +3435,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 +3484,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 +3511,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 +3572,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 +3586,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 +3595,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: ::
 
@@ -3873,53 +3634,89 @@ namespace boost { namespace leaf {
 
 `context_activator` is a simple class that activates and deactivates a <<context>> using RAII:
 
-If `<<context::is_active,ctx.is_active>>`() is `true` at the time the `context_activator` is initialized, the constructor and the destructor have no effects. Otherwise:
+If `ctx.<<context::is_active>>()` is `true` at the time the `context_activator` is initialized, the constructor and the destructor have no effects. Otherwise:
 
-* The constructor stores a reference to `ctx` in `*this` and calls `<<context::activate,ctx.activate>>`().
+* The constructor stores a reference to `ctx` in `*this` and calls `ctx.<<context::activate>>()`.
 * The destructor:
 ** Has no effects if `ctx.is_active()` is `false` (that is, it is valid to call <<context::deactivate>> manually, before the `context_activator` object expires);
-** Otherwise, calls `<<context::deactivate,ctx.deactivate>>`().
+** Otherwise, calls `ctx.<<context::deactivate>>()`.
 
 For automatic deduction of `Ctx`, use <<activate_context>>.
 
 '''
 
-[[diagnostic_info]]
-=== `diagnostic_info`
+[[diagnostic_details]]
+=== `diagnostic_details`
 
-.#include <boost/leaf/handle_errors.hpp>
+.#include <boost/leaf/diagnostics.hpp>
 [source,c++]
 ----
 namespace boost { namespace leaf {
 
-  class diagnostic_info: public error_info
+  class diagnostic_details: public error_info
   {
     //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_details const & );
   };
 
 } }
 ----
 
-Handlers passed to <<try_handle_some>>, <<try_handle_all>> or <<try_catch>> may take an argument of type `diagnostic_info const &` if they need to print diagnostic information about the error.
+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 basic 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 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 is limited to the type name of the first such error object, as well as their total count.
+The additional information includes the types and the values of all such error objects (but see  <<show_in_diagnostics>>).
 
 [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_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_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).
+* 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`.
+
 '''
 
-[[error_id]]
-=== `error_id`
+[[diagnostic_info]]
+=== `diagnostic_info`
+
+.#include <boost/leaf/diagnostics.hpp>
+[source,c++]
+----
+namespace boost { namespace leaf {
+
+  class diagnostic_info: public error_info
+  {
+    //Constructors unspecified
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> &, diagnostic_info const & );
+  };
+
+} }
+----
+
+Handlers passed to <<try_handle_some>>, <<try_handle_all>> or <<try_catch>> may take an argument of type `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 basic 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 is limited to the type name of the first such error object, as well as their total count.
+
+[NOTE]
+--
+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`
 
 .#include <boost/leaf/error.hpp>
 [source,c++]
@@ -3933,7 +3730,7 @@ namespace boost { namespace leaf {
     error_id() noexcept;
 
     template <class Enum>
-    result( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type * = 0 ) noexcept;
+    error_id( Enum e, typename std::enable_if<std::is_error_code_enum<Enum>::value, Enum>::type * = 0 ) noexcept;
 
     error_id( std::error_code const & ec ) noexcept;
 
@@ -3949,7 +3746,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 +3796,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 +3835,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`.
@@ -4070,7 +3868,7 @@ namespace boost { namespace leaf {
 
 These functions have the usual semantics, comparing `a.value()` and `b.value()`.
 
-NOTE: The exact strict weak ordering implemented by `operator<` is not specified. In particular, if for two `error_id` objects `a` and `b`, `a < b` is true, it does not follow that the failure identified by `a` ocurred earlier than the one identified by `b`.
+NOTE: The exact strict weak ordering implemented by `operator<` is not specified. In particular, if for two `error_id` objects `a` and `b`, `a < b` is true, it does not follow that the failure identified by `a` occurred earlier than the one identified by `b`.
 
 '''
 
@@ -4161,7 +3959,7 @@ The common usage of this class is as follows:
 ----
 error_code compute_value( int * out_value ) noexcept; <1>
 
-leaf::error<int> augmenter() noexcept
+leaf::result<int> augmenter() noexcept
 {
   leaf::error_monitor cur_err; <2>
 
@@ -4236,7 +4034,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 +4083,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 +4111,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 +4158,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 +4179,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 +4192,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 +4259,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 +4317,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 +4334,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 +4389,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 +4553,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 synonym 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 +4619,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 +4669,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 &`;
@@ -4868,7 +4691,7 @@ struct my_pred
   static bool evaluate(my_error) noexcept; <2>
 
   my_error matched; <3>
-}
+};
 
 namespace boost { namespace leaf {
 
@@ -4893,7 +4716,7 @@ struct my_pred
   static bool evaluate(leaf::e_errno const &) noexcept; <2>
 
   leaf::e_errno const & matched; <3>
-}
+};
 
 namespace boost { namespace leaf {
 
@@ -5178,7 +5001,7 @@ leaf::try_handle_some(
   []( leaf::match<std::error_code, leaf::category<enum_a>, enum_b::b2> m )
   { <1>
     static_assert(std::is_same<std::error_code const &, decltype(m.matched)>::value);
-    assert(&m.matched.category() == &std::error_code(enum_{}).category() || m.matched == enum_b::b2);
+    assert(&m.matched.category() == &std::error_code(enum_a{}).category() || m.matched == enum_b::b2);
     ....
   } );
 ----
@@ -5217,7 +5040,7 @@ Instead of a set of values, the `match` template can be given pointers to functi
 .Example 5: Handling of failures with severity::value greater than a specified threshold (requires at least {CPP}17).
 [source,c++]
 ----
-struct severity { int value; }
+struct severity { int value; };
 
 template <int S>
 constexpr bool severity_greater_than( severity const & e ) noexcept
@@ -5342,7 +5165,7 @@ TIP: The contents of each Reference section are organized alphabetically.
 === `is_predicate`
 
 [source,c++]
-.#include <boost/leaf/pred.hpp>>
+.#include <boost/leaf/pred.hpp>
 ----
 namespace boost { namespace leaf {
 
@@ -5362,7 +5185,7 @@ The `is_predicate` template is used by the <<handler_selection_procedure,handler
 === `is_result_type`
 
 [source,c++]
-.#include <boost/leaf/error.hpp>>
+.#include <boost/leaf/error.hpp>
 ----
 namespace boost { namespace leaf {
 
@@ -5381,7 +5204,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 +5347,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,28 +5366,139 @@ 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:
+
+* `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`).
+
+* `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 <<try_capture_all>>, which (only if used) allocates memory dynamically (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`: This macro controls the use of Win32 APIs. If left undefined, LEAF defines it as `0` (even on Windows, since including `windows.h` is generally not desirable). The possible values are:
+** `0`: Disables all Win32-specific features.
+** `1`: Includes `windows.h` and enables <<e_LastError>> support, which is otherwise stubbed out.
+** `2`: In addition, switches LEAF to using the Win32 TLS API instead of {CPP}11 `thread_local`, enabling error objects to be used across DLL boundaries.
+
+* `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. The available TLS implementations are:
+
+** {CPP}11 `thread_local` keyword (the default).
+** Win32 TLS API: selected by defining `BOOST_LEAF_CFG_WIN32=2`. This enables error objects to be used across DLL boundaries.
+** Custom TLS array: selected by defining `BOOST_LEAF_USE_TLS_ARRAY`. This is intended for <<embedded_platforms,embedded platforms>> where the {CPP}11 `thread_local` keyword is not available or not suitable.
+
+When using `BOOST_LEAF_USE_TLS_ARRAY`, the user is required to define the following two functions to implement the required TLS access:
 
 [source,c++]
-.#include <boost/leaf/exception.hpp>
 ----
-#define BOOST_LEAF_THROW_EXCEPTION throw BOOST_LEAF_EXCEPTION
+namespace boost { namespace leaf {
+
+namespace tls
+{
+    void * read_void_ptr( int tls_index ) noexcept;
+    void write_void_ptr( int tls_index, void * p ) noexcept;
+}
+
+} }
 ----
 
-Effects: :: Throws the exception object returned by <<BOOST_LEAF_EXCEPTION>>.
+TIP: For efficiency, `read_void_ptr` and `write_void_ptr` should be defined `inline`.
 
-[[rationale]]
-== Design
+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: TLS slots are allocated only for types used in error handlers. 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, define `BOOST_LEAF_TLS_FREERTOS` (in which case LEAF automatically defines `BOOST_LEAF_EMBEDDED`, if it is not defined already).
+
+For other embedded platforms, 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.
+
+== 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 setup _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
+[[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.
 
@@ -5575,7 +5509,7 @@ Definition: :: Depending on their interaction with error objects, functions can
 * *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.
+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.
 
@@ -5597,499 +5531,77 @@ Fact: ::
 
 For example, if a library function is able to communicate an error code but the program does not need to know the exact error code, then that information may be ignored at the time the library function attempts to communicate it. On the other hand, if an _error handling_ function needs that information, the memory needed to store it can be reserved statically in its scope.
 
-The LEAF functions <<try_handle_some>>, <<try_handle_all>> and <<try_catch>> implement this idea. Users provide error handling lambda functions, each taking arguments of the types it needs in order to recover from a particular error condition. LEAF simply provides the space needed to store these types (in the form of a `std::tuple`, using automatic storage duration) until they are passed to a suitable handler.
+The LEAF functions <<try_handle_some>>, <<try_handle_all>> and <<try_catch>> implement this idea. Users provide error handling lambda functions, each taking arguments of the types it needs in order to recover from a particular error condition. LEAF reserves storage for these types (using automatic storage duration) until they are passed to a suitable handler.
+
+When an error is reported, LEAF checks if storage is available for each error object type:
 
-At the time this space is reserved in the scope of an error handling function, `thread_local` pointers of the required error types are set to point to the corresponding objects within it. Later on, _error initiating_ or _error neutral_ functions wanting to communicate an error object of a given type `E` use the corresponding `thread_local` pointer to detect if there is currently storage available for this type:
+* If storage is available, the object is stored directly in the error handling scope, bypassing all _error neutral_ functions in between.
+* If storage is not available, the error object is discarded, since no error handling function makes any use of it -- saving resources.
 
-* If the pointer is not null, storage is available and the object is moved into the pointed storage, exactly once -- regardless of how many levels of function calls must unwind before an _error handling_ function is reached.
-* If the pointer is null, storage is not available and the error object is discarded, since no error handling function makes any use of it in this program -- saving resources.
+Each error occurrence is assigned a unique <<error_id>>, which prevents handlers from accessing stale error objects from previous failures. To handle a failure, LEAF matches the available error objects (by their `error_id`) with the argument types required by each handler.
 
-This almost works, except we need to make sure that _error handling_ functions are protected from accessing stale error objects stored in response to previous failures, which would be a serious logic error. To this end, each occurrence of an error is assigned a unique <<error_id>>. Each of the `E...` objects stored in error handling scopes is assigned an `error_id` as well, permanently associating it with a particular failure.
+== Dynamic Linking
 
-Thus, to handle a failure we simply match the available error objects (associated with its unique `error_id`) with the argument types required by each user-provided error handling function. In terms of {CPP} exception handling, it is as if we could write something like:
+=== POSIX
+
+When compiling with `-fvisibility=hidden`, error types must be declared with `default` visibility. It is recommended to use `BOOST_LEAF_SYMBOL_VISIBLE`, which expands to the appropriate attribute on POSIX and to nothing on Windows:
 
 [source,c++]
 ----
-try
+struct BOOST_LEAF_SYMBOL_VISIBLE my_error_info
 {
-  auto r = process_file();
+    int value;
+};
+----
 
-  //Success, use r:
-  ....
-}
+LEAF declares the following types with `BOOST_LEAF_SYMBOL_VISIBLE`: `error_id`, `error_info`, `diagnostic_info`, `diagnostic_details`, `e_api_function`, `e_file_name`, `e_errno`, `e_type_info_name`, `e_at_line`, `e_source_location`, `bad_result`, `result<T>`.
 
-catch(file_read_error &, e_file_name const & fn, e_errno const & err)
-{
-  std::cerr <<
-    "Could not read " << fn << ", errno=" << err << std::endl;
-}
+=== Windows
 
-catch(file_read_error &, e_errno const & err)
-{
-  std::cerr <<
-    "File read error, errno=" << err << std::endl;
-}
+To use error objects across DLL boundaries, define `BOOST_LEAF_CFG_WIN32=2`. This switches LEAF to using the Win32 TLS API instead of {CPP}11 `thread_local`. Dynamic unloading of DLLs is not supported.
 
-catch(file_read_error &)
-{
-  std::cerr << "File read error!" << std::endl;
-}
-----
-
-Of course this syntax is not valid, so LEAF uses lambda functions to express the same idea:
-
-[source,c++]
-----
-leaf::try_catch(
-
-  []
-  {
-    auto r = process_file(); //Throws in case of failure, error objects stored inside the try_catch scope
-
-    //Success, use r:
-    ....
-  }
-
-  [](file_read_error &, e_file_name const & fn, e_errno const & err)
-  {
-    std::cerr <<
-      "Could not read " << fn << ", errno=" << err << std::endl;
-  },
-
-  [](file_read_error &, e_errno const & err)
-  {
-    std::cerr <<
-      "File read error, errno=" << err << std::endl;
-  },
-
-  [](file_read_error &)
-  {
-    std::cerr << "File read error!" << std::endl;
-  } );
-----
-
-[.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>`:
-
-[source,c++]
-----
-return leaf::try_handle_some(
-
-  []() -> leaf::result<void>
-  {
-    BOOST_LEAF_AUTO(r, process_file()); //In case of errors, error objects are stored inside the try_handle_some scope
-
-    //Success, use r:
-    ....
-
-    return { };
-  }
-
-  [](leaf::match<error_enum, file_read_error>, e_file_name const & fn, e_errno const & err)
-  {
-    std::cerr <<
-      "Could not read " << fn << ", errno=" << err << std::endl;
-  },
-
-  [](leaf::match<error_enum, file_read_error>, e_errno const & err)
-  {
-    std::cerr <<
-      "File read error, errno=" << err << std::endl;
-  },
-
-  [](leaf::match<error_enum, file_read_error>)
-  {
-    std::cerr << "File read error!" << std::endl;
-  } );
-----
-
-[.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.
-
-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:
-
-[source,c++]
-----
-struct attempted_location
-{
-  std::string path;
-  error ec;
-};
-
-struct config_error
-{
-  attempted_location current_dir, user_dir, app_dir;
-};
-
-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.
-
-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.
+Modules linked against different CRT configurations (static or dynamic) can share LEAF error objects. However, for two modules to share error objects, they must be compiled with the same compiler (not necessarily the same compiler version). For example, if one module is compiled with MSVC and another with GCC, error objects will not be shared between them.
 
 == Alternatives to LEAF
 
-* https://www.boost.org/doc/libs/release/libs/exception/doc/boost-exception.html[Boost Exception]
+* https://en.cppreference.com/w/cpp/utility/expected[`std::expected`] (C++23)
 * https://ned14.github.io/outcome[Boost Outcome]
-* https://github.com/TartanLlama/expected[`tl::expected`]
-
-Below we offer a comparison of Boost LEAF to Boost Exception and to Boost Outcome.
-
-[[boost_exception]]
-=== Comparison to Boost Exception
-
-While LEAF can be used without exception handling, in the use case when errors are communicated by throwing exceptions, it can be viewed as a better, more efficient alternative to Boost Exception. LEAF has the following advantages over Boost Exception:
-
-* LEAF does not allocate memory dynamically;
-* LEAF does not waste system resources communicating error objects not used by specific error handling functions;
-* LEAF does not store the error objects in the exception object, and therefore it is able to augment exceptions thrown by external libraries (Boost Exception can only augment exceptions of types that derive from `boost::exception`).
-
-The following tables outline the differences between the two libraries which should be considered when code that uses Boost Exception is refactored to use LEAF instead.
-
-NOTE: It is possible to access Boost Exception error information using the LEAF error handling interface. See <<tutorial-boost_exception_integration>>.
-
-.Defining a custom type for transporting values of type T
-[cols="1a,1a",options="header",stripes=none]
-|====
-| Boost Exception | LEAF
-|
-[source,c++,options="nowrap"]
-----
-typedef error_info<struct my_info_,T> my_info;
-----
-[.text-right]
-https://www.boost.org/doc/libs/release/libs/exception/doc/error_info.html[`boost::error_info`]
-|
-[source,c++,options="nowrap"]
-----
-struct my_info { T value; };
-----
-|====
-
-.Passing arbitrary info at the point of the throw
-[cols="1a,1a",options="header",stripes=none]
-|====
-| Boost Exception | LEAF
-|
-[source,c++,options="nowrap"]
-----
-throw my_exception() <<
-  my_info(x) <<
-  my_info(y);
-----
-[.text-right]
-https://www.boost.org/doc/libs/release/libs/exception/doc/exception_operator_shl.html[`operator<<`]
-|
-[source,c++,options="nowrap"]
-----
-throw leaf::exception( my_exception(),
-  my_info{x},
-  my_info{y} );
-----
-[.text-right]
-<<exception>>
-|====
-
-.Augmenting exceptions in error neutral contexts
-[cols="1a,1a",options="header",stripes=none]
-|====
-| Boost Exception | LEAF
-|
-[source,c++,options="nowrap"]
-----
-try
-{
-  f();
-}
-catch( boost::exception & e )
-{
-  e << my_info(x);
-  throw;
-}
-----
-[.text-right]
-https://www.boost.org/doc/libs/release/libs/exception/doc/exception.html[`boost::exception`] \| https://www.boost.org/doc/libs/release/libs/exception/doc/exception_operator_shl.html[`operator<<`]
-|
-[source,c++,options="nowrap"]
-----
-auto load = leaf::on_error( my_info{x} );
-
-f();
-----
-[.text-right]
-<<on_error>>
-|====
+* https://www.boost.org/doc/libs/release/libs/exception/doc/boost-exception.html[Boost Exception]
 
-.Obtaining arbitrary info at the point of the catch
-[cols="1a,1a",options="header",stripes=none]
-|====
-| Boost Exception | LEAF
-|
-[source,c++,options="nowrap"]
-----
-try
-{
-  f();
-}
-catch( my_exception & e )
-{
-  if( T * v = get_error_info<my_info>(e) )
-  {
-    //my_info is available in e.
-  }
-}
-----
-[.text-right]
-https://www.boost.org/doc/libs/release/libs/exception/doc/get_error_info.html[`boost::get_error_info`]
-|
-[source,c++,options="nowrap"]
-----
-leaf::try_catch(
-  []
-  {
-    f(); // throws
-  }
-  [](my_exception &, my_info const & x)
-  {
-    //my_info is available with
-    //the caught exception.
-  } );
-----
-[.text-right]
-<<try_catch>>
-|====
+Below we offer a comparison of Boost LEAF to these alternatives.
 
-.Transporting of error objects
-[cols="1a,1a",options="header",stripes=none]
-|====
-| Boost Exception | LEAF
-| All supplied https://www.boost.org/doc/libs/release/libs/exception/doc/error_info.html[`boost::error_info`] objects are allocated dynamically and stored in the https://www.boost.org/doc/libs/release/libs/exception/doc/exception.html[`boost::exception`] subobject of exception objects.
-|  User-defined error objects are stored statically in the scope of <<try_catch>>, but only if their types are needed to handle errors; otherwise they are discarded.
-|====
+[[std_expected]]
+=== Comparison to `std::expected`
 
-.Transporting of error objects across thread boundaries
-[cols="1a,1a",options="header",stripes=none]
-|====
-| Boost Exception | LEAF
-| https://www.boost.org/doc/libs/release/libs/exception/doc/exception_ptr.html[`boost::exception_ptr`] automatically captures https://www.boost.org/doc/libs/release/libs/exception/doc/error_info.html[`boost::error_info`] objects stored in a `boost::exception` and can transport them across thread boundaries.
-| Transporting error objects across thread boundaries requires the use of <<capture>>.
-|====
+`std::expected<T, E>`, introduced in C++23, is a vocabulary type for functions that return either a value of type `T` or an error of type `E`. It is similar to `leaf::result<T>` in purpose but differs in design:
 
-.Printing of error objects in automatically-generated diagnostic information messages
-[cols="1a,1a",options="header",stripes=none]
-|====
-| Boost Exception | LEAF
-| `boost::error_info` types may define conversion to `std::string` by providing `to_string` overloads *or* by overloading `operator<<` for `std::ostream`.
-| LEAF does not use `to_string`. Error types may define `operator<<` overloads for `std::ostream`.
-|====
+* `std::expected<T, E>` encodes the error type `E` in the function signature. `leaf::result<T>` does not specify an error type; error objects are transported separately.
+* With `std::expected`, a function can only return a single error object of type `E`. LEAF allows associating multiple error objects of different types with a single failure.
+* LEAF's <<on_error>> allows intermediate functions to attach additional context as errors propagate, without modifying function signatures.
 
-[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`].
-
-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.
-====
+The choice between them depends on whether encoding error types in function signatures is desired, and whether associating multiple error objects with a single failure is needed.
 
 '''
 
 [[boost_outcome]]
 === Comparison to Boost Outcome
 
-==== Design Differences
-
-Like LEAF, the https://ned14.github.io/outcome[Boost Outcome] library is designed to work in low latency environments. It provides two class templates, `result<>` and `outcome<>`:
-
-* `result<T,EC,NVP>` can be used as the return type in `noexcept` functions which may fail, where `T` specifies the type of the return value in case of success, while `EC` is an "error code" type. Semantically, `result<T,EC>` is similar to `std::variant<T,EC>`. Naturally, `EC` defaults to `std::error_code`.
-* `outcome<T,EC,EP,NVP>` is similar to `result<>`, but in case of failure, in addition to the "error code" type `EC` it can hold a "pointer" object of type `EP`, which defaults to `std::exception_ptr`.
-
-NOTE: `NVP` is a policy type used to customize the behavior of `.value()` when the `result<>` or the `outcome<>` object contains an error.
-
-The idea is to use `result<>` to communicate failures which can be fully specified by an "error code", and `outcome<>` to communicate failures that require additional information.
-
-Another way to describe this design is that `result<>` is used when it suffices to return an error object of some static type `EC`, while `outcome<>` can also transport a polymorphic error object, using the pointer type `EP`.
+Like LEAF, https://ned14.github.io/outcome[Boost Outcome] is designed for low latency environments. It provides `result<T,EC,NVP>` and `outcome<T,EC,EP,NVP>`, where `EC` is an error code type (defaulting to `std::error_code`) and `EP` is a pointer type for additional error information (defaulting to `std::exception_ptr`).
 
-NOTE: In the default configuration of `outcome<T>` the additional information -- or the additional polymorphic object -- is an exception object held by `std::exception_ptr`. This targets the use case when an exception thrown by a lower-level library function needs to be transported through some intermediate contexts that are not exception-safe, to a higher-level context able to handle it. LEAF directly supports this use as well, see <<exception_to_result>>.
+The key design difference is in how error information is transported:
 
-Similar reasoning drives the design of LEAF as well. The difference is that while both libraries recognize the need to transport "something else" in addition to an "error code", LEAF provides an efficient solution to this problem, while Outcome shifts this burden to the user.
-
-The `leaf::result<>` template deletes both `EC` and `EP`, which decouples it from the type of the error objects that are transported in case of a failure. This enables lower-level functions to freely communicate anything and everything they "know" about the failure: error code, even multiple error codes, file names, URLs, port numbers, etc. At the same time, the higher-level error handling functions control which of this information is needed in a specific client program and which is not. This is ideal, because:
-
-* Authors of lower-level library functions lack context to determine which of the information that is both relevant to the error _and_ naturally available to them needs to be communicated in order for a particular client program to recover from that error;
-* Authors of higher-level error handling functions can easily and confidently make this determination, which they communicate naturally to LEAF, by simply writing the different error handlers. LEAF will transport the needed error objects while discarding the ones handlers don't care to use, saving resources.
+* Outcome encodes error types in function signatures via the `EC` and `EP` template parameters, giving callers explicit visibility of possible error types.
+* LEAF decouples `leaf::result<T>` from error types entirely. Error objects are transported separately to error handling scopes, where the handlers determine which types are needed.
 
 TIP: The LEAF examples include an adaptation of the program from the https://ned14.github.io/outcome/tutorial/essential/result/[Boost Outcome `result<>` tutorial]. You can https://github.com/boostorg/leaf/blob/master/example/print_half.cpp?ts=4[view it on GitHub].
 
-NOTE: Programs using LEAF for error handling are not required to use `leaf::result<T>`; for example, it is possible to use `outcome::result<T>` with LEAF.
+NOTE: LEAF is compatible with `outcome::result<T>`; you don't have to use `leaf::result<T>`.
 
 [[interoperability]]
 ==== The Interoperability Problem
 
-The Boost Outcome documentation discusses the important problem of bringing together multiple libraries -- each using its own error reporting mechanism -- and incorporating them in a robust error handling infrastructure in a client program.
-
-Users are advised that whenever possible they should use a common error handling system throughout their entire codebase, but because this is not practical, both the `result<>` and the `outcome<>` templates can carry user-defined "payloads".
+The Boost Outcome documentation discusses the challenge of integrating multiple libraries with different error types:
 
-The following analysis is from the Boost Outcome documentation:
 ====
 If library A uses `result<T, libraryA::failure_info>`, and library B uses `result<T, libraryB::error_info>` and so on, there becomes a problem for the application writer who is bringing in these third party dependencies and tying them together into an application. As a general rule, each third party library author will not have built in explicit interoperation support for unknown other third party libraries. The problem therefore lands with the application writer.
 
@@ -6097,157 +5609,27 @@ The application writer has one of three choices:
 
 . In the application, the form of result used is `result<T, std::variant<E1, E2, ...>>` where `E1, E2 …` are the failure types for every third party library in use in the application. This has the advantage of preserving the original information exactly, but comes with a certain amount of use inconvenience and maybe excessive coupling between high level layers and implementation detail.
 
-. One can translate/map the third party’s failure type into the application’s failure type at the point of the failure exiting the third party library and entering the application. One might do this, say, with a C preprocessor macro wrapping every invocation of the third party API from the application. This approach may lose the original failure detail, or mis-map under certain circumstances if the mapping between the two systems is not one-one.
+. One can translate/map the third party's failure type into the application's failure type at the point of the failure exiting the third party library and entering the application. One might do this, say, with a C preprocessor macro wrapping every invocation of the third party API from the application. This approach may lose the original failure detail, or mis-map under certain circumstances if the mapping between the two systems is not one-one.
 
-. One can type erase the third party’s failure type into some application failure type, which can later be reconstituted if necessary. *This is the cleanest solution with the least coupling issues and no problems with mis-mapping*, but it almost certainly requires the use of `malloc` which the previous two did not.
+. One can type erase the third party's failure type into some application failure type, which can later be reconstituted if necessary. *This is the cleanest solution with the least coupling issues and no problems with mis-mapping*, but it almost certainly requires the use of `malloc` which the previous two did not.
 ====
 
-The analysis above (emphasis added) is clear and precise, but LEAF and Boost Outcome tackle the interoperability problem differently:
-
-* The Boost Outcome design asserts that the "cleanest" solution based on type-erasure is suboptimal ("almost certainly requires the use of `malloc`pass:[]"), and instead provides a system for injecting custom converters into the `outcome::convert` namespace, used to translate between library-specific and program-wide error types, even though this approach "may lose the original failure detail".
-
-* The LEAF design asserts that coupling the signatures of <<rationale,error neutral>> functions with the static types of the error objects they need to forward to the caller <<translation,does not scale>>, and instead transports error objects directly to error handling scopes where they are stored statically, effectively implementing the third choice outlined above (without the use of `malloc`).
-
-Further, consider that Outcome aims to hopefully become _the_ one error handling API all libraries would use, and in theory everyone would benefit from uniformity and standardization. But the reality is that this is wishful thinking. In fact, that reality is reflected in the design of `outcome::result<>`, in its lack of commitment to using `std::error_code` for its intended purpose: to be _the_ standard type for transporting error codes. The fact is that `std::error_code` became _yet another_ error code type programmers need to understand and support.
-
-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 Outcome addresses this by providing converters in the `outcome::convert` namespace to translate between error types (option 2).
 
-* `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.
+LEAF takes a different approach: error objects are transported directly to error handling scopes where storage is allocated statically, implementing option 3 without dynamic allocation.
 
-[[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.:
+[[boost_exception]]
+=== Comparison to Boost Exception
 
-[source,c++]
-----
-struct __attribute__ ((visibility ("default"))) my_error_info
-{
-    int value;
-};
-----
+Both LEAF and https://www.boost.org/doc/libs/release/libs/exception/doc/boost-exception.html[Boost Exception] allow transporting arbitrary error information with exceptions. The key design differences:
 
-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>>.
+* Boost Exception stores error objects in the exception object itself (requiring dynamic allocation). LEAF stores error objects in the error handling scope, discarding those not needed by handlers.
+* Boost Exception can only augment exceptions deriving from `boost::exception`. LEAF can augment any exception type.
+* Boost Exception automatically captures error objects across thread boundaries via `boost::exception_ptr`. LEAF requires explicit use of <<capture>>.
 
-TIP: When using dynamic linking, it is always best to define module interfaces in terms of C (and implement them in {CPP} if appropriate).
+NOTE: LEAF can access Boost Exception error information using its error handling interface. See <<tutorial-boost_exception_integration>>.
 
 == Acknowledgements
 
diff --git a/doc/whitepaper.md b/doc/whitepaper.md
index 6af95b31..d7e49cfe 100644
--- a/doc/whitepaper.md
+++ b/doc/whitepaper.md
@@ -241,7 +241,7 @@ The above function computes a `float` value based on the contents of the specifi
 
 In case of failure to `open()`, our function stays out of the way: the error code is communicated from `open()` (which sets the `errno`) *directly* to an *error handling* function up the call stack (which examines the `errno` in order to understand the failure), while the return value of each intermediate function needs only communicate a single bit of data (the *failure flag*).
 
-The major drawback of this appoach is that the *failure flag* is not communicated uniformly, which means that *error neutral* functions can't check for errors generically (e.g. each layer needs to know about the different `INVALID_VALUE`s).
+The major drawback of this approach is that the *failure flag* is not communicated uniformly, which means that *error neutral* functions can't check for errors generically (e.g. each layer needs to know about the different `INVALID_VALUE`s).
 
 ### 6.2. C++ Exceptions
 
@@ -357,7 +357,7 @@ Using LEAF, *error handling* functions match error objects similarly to the way
 * Each handler can specify multiple objects to be matched by type, rather than only one.
 * The error objects are matched dynamically, but solely based on their static type. This allows *all* error objects to be allocated on the stack, using automatic storage duration.
 
-Whithout exception handling, this is achieved using the following syntax:
+Without exception handling, this is achieved using the following syntax:
 
 ```c++
 leaf::handle_all(
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..b64e8aa0 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-2025 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..0bba6ba5 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-2025 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..16c18ef0 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-2025 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..fae54a28 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-2025 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..db4d510b 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-2025 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..e235153e 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-2025 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..4c670696 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-2025 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..468e115a 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-2025 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..702580ef 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 implementation.
 
-* [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..71bda06e 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-2025 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..d783ac67 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 implementation.
 
-* [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..91a8c6f5 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-2025 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..d2d17b80 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-2025 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..5eed44e6 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-2025 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-2025 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..84aa7bec 100644
--- a/include/boost/leaf.hpp
+++ b/include/boost/leaf.hpp
@@ -1,11 +1,10 @@
 #ifndef BOOST_LEAF_HPP_INCLUDED
 #define BOOST_LEAF_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2025 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/detail/all.hpp>
 
-#endif
+#endif // #ifndef BOOST_LEAF_HPP_INCLUDED
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..4eac22e0 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-2025 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,13 +9,15 @@
 #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>
 #   ifdef min
 #       undef min
 #   endif
@@ -27,41 +28,41 @@
 
 namespace boost { namespace leaf {
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_api_function { char const * value; };
+struct e_api_function { char const * value; };
 
 #if BOOST_LEAF_CFG_STD_STRING
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_file_name
+struct e_file_name
 {
     std::string value;
 };
 
 #else
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_file_name
+struct e_file_name
 {
-    constexpr static char const * const value = "<unavailable>";
+    char const * value = "<unavailable>";
     BOOST_LEAF_CONSTEXPR explicit e_file_name( char const * ) { }
 };
 
 #endif
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_errno
+struct 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) << '"';
     }
 };
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_type_info_name { char const * value; };
+struct e_type_info_name { char const * value; };
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_at_line { int value; };
+struct e_at_line { int value; };
 
 namespace windows
 {
@@ -69,13 +70,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
             {
@@ -95,18 +96,18 @@ namespace windows
             {
                 BOOST_LEAF_ASSERT(mb.p != nullptr);
                 char * z = std::strchr((LPSTR)mb.p,0);
-                if( z[-1] == '\n' )
+                if( z != (LPSTR)mb.p && z[-1] == '\n' )
                     *--z = 0;
-                if( z[-1] == '\r' )
+                if( z != (LPSTR)mb.p && z[-1] == '\r' )
                     *--z = 0;
-                return os << type<e_LastError>() << ": " << err.value << ", \"" << (LPCSTR)mb.p << '"';
+                return os << err.value << ", \"" << (LPCSTR)mb.p << '"';
             }
             return os;
         }
-#endif
+#endif // #if BOOST_LEAF_CFG_WIN32
     };
-}
+} // namespace windows
 
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef BOOST_LEAF_COMMON_HPP_INCLUDED
diff --git a/include/boost/leaf/config.hpp b/include/boost/leaf/config.hpp
index 7c7e7d2b..87a4e123 100644
--- a/include/boost/leaf/config.hpp
+++ b/include/boost/leaf/config.hpp
@@ -1,59 +1,39 @@
 #ifndef BOOST_LEAF_CONFIG_HPP_INCLUDED
 #define BOOST_LEAF_CONFIG_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2025 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
-
-////////////////////////////////////////
+#include <utility>
+#include <exception>
 
 #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 // #ifdef BOOST_LEAF_EMBEDDED
 
+////////////////////////////////////////
+
+#ifndef BOOST_LEAF_ASSERT
+#   include <cassert>
+#   define BOOST_LEAF_ASSERT assert
 #endif
 
 ////////////////////////////////////////
@@ -86,135 +66,103 @@
 #   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_DIAGNOSTICS && !BOOST_LEAF_CFG_STD_STRING
-#   error BOOST_LEAF_CFG_DIAGNOSTICS requires the use of std::string
+#if BOOST_LEAF_CFG_WIN32 != 0 && BOOST_LEAF_CFG_WIN32 != 1 && BOOST_LEAF_CFG_WIN32 != 2
+#   error BOOST_LEAF_CFG_WIN32 must be 0 or 1 or 2.
 #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_WIN32 && !defined(_WIN32)
+#   warning "Ignoring BOOST_LEAF_CFG_WIN32 because _WIN32 is not defined"
+#   define BOOST_LEAF_CFG_WIN32 0
 #endif
 
-#if BOOST_LEAF_CFG_GNUC_STMTEXPR!=0 && BOOST_LEAF_CFG_GNUC_STMTEXPR!=1
+#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 BOOST_LEAF_CFG_STD_STRING, which has been disabled.
+#endif
+
+#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
+
 ////////////////////////////////////////
 
-// Configure BOOST_LEAF_NO_EXCEPTIONS, unless already #defined
-#ifndef BOOST_LEAF_NO_EXCEPTIONS
+#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
+
+////////////////////////////////////////
 
+#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
 #   endif
 
-#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
+#endif // #ifndef BOOST_LEAF_NO_EXCEPTIONS
 
 ////////////////////////////////////////
 
@@ -226,13 +174,19 @@
 
 ////////////////////////////////////////
 
-#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,8 +200,17 @@
 
 ////////////////////////////////////////
 
+#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)
 #       define BOOST_LEAF_STD_UNCAUGHT_EXCEPTIONS 1
 #   else
@@ -258,11 +221,13 @@
 ////////////////////////////////////////
 
 #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
 
+#include <boost/leaf/config/visibility.hpp>
+
 ////////////////////////////////////////
 
 #if defined(__GNUC__) && !(defined(__clang__) || defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && (__GNUC__ * 100 + __GNUC_MINOR__) < 409
@@ -273,9 +238,36 @@
 
 ////////////////////////////////////////
 
-// Configure TLS access
-#include <boost/leaf/config/tls.hpp>
+#ifdef _MSC_VER
+#   define BOOST_LEAF_UNREACHABLE __assume(0)
+#else
+#   define BOOST_LEAF_UNREACHABLE __builtin_unreachable()
+#endif
 
 ////////////////////////////////////////
 
+namespace boost
+{
+    [[noreturn]] void throw_exception( std::exception const & ); // user defined
+}
+
+namespace boost { namespace leaf {
+
+template <class T>
+[[noreturn]] void throw_exception_( T && e )
+{
+#ifdef BOOST_LEAF_NO_EXCEPTIONS
+    ::boost::throw_exception(std::move(e));
+#else
+    throw std::move(e);
 #endif
+}
+
+} }
+
+////////////////////////////////////////
+
+// Configure TLS access
+#include <boost/leaf/config/tls.hpp>
+
+#endif // #ifndef BOOST_LEAF_CONFIG_HPP_INCLUDED
diff --git a/include/boost/leaf/config/tls.hpp b/include/boost/leaf/config/tls.hpp
index 279bafb2..a495383b 100644
--- a/include/boost/leaf/config/tls.hpp
+++ b/include/boost/leaf/config/tls.hpp
@@ -1,13 +1,68 @@
 #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-2025 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)
 
+namespace boost { namespace leaf {
+
+// The following declarations specify the thread local storage API used
+// internally by LEAF. To port LEAF to a new TLS API, provide definitions for
+// each of these functions.
+namespace tls
+{
+    // Generate the next unique error_id. Values start at 1 and increment by 4.
+    // Error ids must be unique for the lifetime of the process, and this
+    // function must be thread-safe. Postcondition: (id & 3) == 1 && id != 0.
+    //
+    // This function may not fail.
+    unsigned generate_next_error_id() noexcept;
+
+    // Write x to the TLS for the current error_id. The initial value for each
+    // thread must be 0. Precondition: x == 0 or (x & 3) == 1.
+    //
+    // This function may not fail.
+    void write_current_error_id( unsigned x ) noexcept;
+
+    // Read the current error_id for this thread. The initial value for each
+    // thread must be 0.
+    //
+    // This function may not fail.
+    unsigned read_current_error_id() noexcept;
+
+    // Reserve TLS storage for T. The TLS may be allocated dynamically on the
+    // first call to reserve_ptr<T>, but subsequent calls must reuse the same
+    // TLS. On platforms where allocation is not needed, this function is
+    // still defined but does nothing.
+    //
+    // This function may throw on allocation failure.
+    template <class T>
+    void reserve_ptr();
+
+    // Write p to the TLS previously reserved for T by a call to reserve_ptr<T>.
+    // It is illegal to call write_ptr<T> without a prior successful call to
+    // reserve_ptr<T>.
+    //
+    // This function may not fail.
+    template <class T>
+    void write_ptr( T * p ) noexcept;
+
+    // Read the T * value previously written in the TLS for T. Returns nullptr
+    // if TLS for T has not yet been reserved.
+    //
+    // This function may not fail.
+    template <class T>
+    T * read_ptr() noexcept;
+} // namespace tls
+
+} } // namespace boost::leaf
+
 #if defined(BOOST_LEAF_TLS_FREERTOS)
 #   include <boost/leaf/config/tls_freertos.hpp>
+#   ifndef BOOST_LEAF_USE_TLS_ARRAY
+#       define BOOST_LEAF_USE_TLS_ARRAY
+#   endif
 #endif
 
 #ifndef BOOST_LEAF_USE_TLS_ARRAY
@@ -24,10 +79,12 @@
 
 #if defined BOOST_LEAF_USE_TLS_ARRAY
 #   include <boost/leaf/config/tls_array.hpp>
+#elif BOOST_LEAF_CFG_WIN32 == 2
+#   include <boost/leaf/config/tls_win32.hpp>
 #elif defined(BOOST_LEAF_NO_THREADS)
 #   include <boost/leaf/config/tls_globals.hpp>
 #else
 #   include <boost/leaf/config/tls_cpp11.hpp>
 #endif
 
-#endif
+#endif // #ifndef BOOST_LEAF_CONFIG_TLS_HPP_INCLUDED
\ No newline at end of file
diff --git a/include/boost/leaf/config/tls_array.hpp b/include/boost/leaf/config/tls_array.hpp
index f194c56c..a595022e 100644
--- a/include/boost/leaf/config/tls_array.hpp
+++ b/include/boost/leaf/config/tls_array.hpp
@@ -1,16 +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-2025 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.
+// Copyright (c) 2022 Khalil Estell
 
-// This header implements thread local storage for pointers and for uint32_t
-// values for platforms that support thread local pointers by index.
+// This header implements the TLS API specified in tls.hpp for platforms that
+// provide TLS by indexing an array (this is typical for embedded platforms).
+// The array is accessed via user-defined functions.
 
 namespace boost { namespace leaf {
 
@@ -26,8 +25,8 @@ namespace tls
 
 ////////////////////////////////////////
 
-#include <limits>
 #include <atomic>
+#include <limits>
 #include <cstdint>
 #include <type_traits>
 
@@ -53,29 +52,44 @@ 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>;
-}
 
-namespace tls
-{
+    template <class=void>
+    struct BOOST_LEAF_SYMBOL_VISIBLE id_factory
+    {
+        static atomic_unsigned_int counter;
+    };
+
+    template <class T>
+    atomic_unsigned_int id_factory<T>::counter(1);
+
     template <class=void>
     class BOOST_LEAF_SYMBOL_VISIBLE index_counter
     {
         static int c_;
 
-    public:
-
-        static BOOST_LEAF_CFG_TLS_INDEX_TYPE next()
+        BOOST_LEAF_ALWAYS_INLINE 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_START_INDEX + 1));
             BOOST_LEAF_ASSERT(idx < (BOOST_LEAF_CFG_TLS_ARRAY_SIZE));
             return idx;
         }
+
+    public:
+
+        template <class T>
+        BOOST_LEAF_ALWAYS_INLINE static BOOST_LEAF_CFG_TLS_INDEX_TYPE next() noexcept
+        {
+            return next_();
+        }
     };
 
+    template <class T>
+    int index_counter<T>::c_ = BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1;
+
     template <class T>
     struct BOOST_LEAF_SYMBOL_VISIBLE tls_index
     {
@@ -83,70 +97,72 @@ namespace tls
     };
 
     template <class T>
-    struct BOOST_LEAF_SYMBOL_VISIBLE alloc_tls_index
+    BOOST_LEAF_CFG_TLS_INDEX_TYPE tls_index<T>::idx = BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1;
+
+    template <class T>
+    struct BOOST_LEAF_SYMBOL_VISIBLE reserve_tls_index
     {
         static BOOST_LEAF_CFG_TLS_INDEX_TYPE const idx;
     };
 
     template <class T>
-    int index_counter<T>::c_ = BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX;
+    BOOST_LEAF_CFG_TLS_INDEX_TYPE const reserve_tls_index<T>::idx = tls_index<T>::idx = index_counter<>::next<T>();
+} // namespace detail
 
-    template <class T>
-    BOOST_LEAF_CFG_TLS_INDEX_TYPE tls_index<T>::idx = BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX;
+} } // namespace boost::leaf
 
-    template <class T>
-    BOOST_LEAF_CFG_TLS_INDEX_TYPE const alloc_tls_index<T>::idx = tls_index<T>::idx = index_counter<>::next();
+////////////////////////////////////////
 
-    ////////////////////////////////////////
+namespace boost { namespace leaf {
 
-    template <class T>
-    T * read_ptr() noexcept
+namespace tls
+{
+    BOOST_LEAF_ALWAYS_INLINE unsigned generate_next_error_id() noexcept
     {
-        int tls_idx = tls_index<T>::idx;
-        if( tls_idx == (BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX) )
-            return nullptr;
-        --tls_idx;
-        return reinterpret_cast<T *>(read_void_ptr(tls_idx));
+        unsigned id = (detail::id_factory<>::counter += 4);
+        BOOST_LEAF_ASSERT((id&3) == 1);
+        return id;
     }
 
-    template <class T>
-    void write_ptr( T * p ) noexcept
+    BOOST_LEAF_ALWAYS_INLINE void write_current_error_id( unsigned x ) noexcept
     {
-        int tls_idx = alloc_tls_index<T>::idx;
-        --tls_idx;
-        write_void_ptr(tls_idx, p);
-        BOOST_LEAF_ASSERT(read_void_ptr(tls_idx) == p);
+        static_assert(sizeof(std::intptr_t) >= sizeof(unsigned), "Incompatible tls_array implementation");
+        write_void_ptr(BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX, (void *) (std::intptr_t) x);
     }
 
-    ////////////////////////////////////////
-
-    template <class Tag>
-    std::uint32_t read_uint32() noexcept
+    BOOST_LEAF_ALWAYS_INLINE unsigned read_current_error_id() 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) read_void_ptr(BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX);
     }
 
-    template <class Tag>
-    void write_uint32( std::uint32_t x ) noexcept
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE void reserve_ptr()
     {
-        static_assert(sizeof(std::intptr_t) >= sizeof(std::uint32_t), "Incompatible tls_array implementation");
-        write_ptr<Tag>((Tag *) (void *) (std::intptr_t) x);
+        (void) detail::reserve_tls_index<T>::idx;
     }
 
-    template <class Tag>
-    void uint32_increment() noexcept
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE void write_ptr( T * p ) noexcept
     {
-        write_uint32<Tag>(read_uint32<Tag>() + 1);
+        int tls_idx = detail::tls_index<T>::idx;
+        BOOST_LEAF_ASSERT(tls_idx != (BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1));
+        --tls_idx;
+        write_void_ptr(tls_idx, p);
+        BOOST_LEAF_ASSERT(read_void_ptr(tls_idx) == p);
     }
 
-    template <class Tag>
-    void uint32_decrement() noexcept
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE T * read_ptr() noexcept
     {
-        write_uint32<Tag>(read_uint32<Tag>() - 1);
+        int tls_idx = detail::tls_index<T>::idx;
+        if( tls_idx == (BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1) )
+            return nullptr;
+        --tls_idx;
+        return reinterpret_cast<T *>(read_void_ptr(tls_idx));
     }
-}
+} // namespace tls
 
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef 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..f5aa5c74 100644
--- a/include/boost/leaf/config/tls_cpp11.hpp
+++ b/include/boost/leaf/config/tls_cpp11.hpp
@@ -1,28 +1,34 @@
 #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-2025 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
-// values using the C++11 built-in thread_local storage class specifier.
+// This header implements the TLS API specified in tls.hpp using the C++11
+// built-in thread_local storage class specifier. On Windows, this
+// implementation does not allow error objects to cross DLL boundaries. If this
+// is required, define BOOST_LEAF_CFG_WIN32=2 before including any LEAF headers
+// to enable the alternative implementation defined in tls_win32.hpp.
 
-#include <cstdint>
 #include <atomic>
+#include <cstdint>
 
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+namespace detail
 {
     using atomic_unsigned_int = std::atomic<unsigned int>;
-}
 
-namespace tls
-{
+    template <class=void>
+    struct BOOST_LEAF_SYMBOL_VISIBLE id_factory
+    {
+        static atomic_unsigned_int counter;
+    };
+
+    template <class T>
+    atomic_unsigned_int id_factory<T>::counter(1);
+
     template <class T>
     struct BOOST_LEAF_SYMBOL_VISIBLE ptr
     {
@@ -32,54 +38,59 @@ namespace tls
     template <class T>
     thread_local T * ptr<T>::p;
 
-    template <class T>
-    T * read_ptr() noexcept
+    template <class=void>
+    struct BOOST_LEAF_SYMBOL_VISIBLE current_error_id_storage
     {
-        return ptr<T>::p;
-    }
+        static thread_local unsigned x;
+    };
 
     template <class T>
-    void write_ptr( T * p ) noexcept
-    {
-        ptr<T>::p = p;
-    }
+    thread_local unsigned current_error_id_storage<T>::x;
+} // namespace detail
 
-    ////////////////////////////////////////
+} } // namespace boost::leaf
 
-    template <class Tag>
-    struct BOOST_LEAF_SYMBOL_VISIBLE tagged_uint32
+////////////////////////////////////////
+
+namespace boost { namespace leaf {
+
+namespace tls
+{
+    BOOST_LEAF_ALWAYS_INLINE unsigned generate_next_error_id() noexcept
     {
-        static thread_local std::uint32_t x;
-    };
+        unsigned id = (detail::id_factory<>::counter += 4);
+        BOOST_LEAF_ASSERT((id&3) == 1);
+        return id;
+    }
 
-    template <class Tag>
-    thread_local std::uint32_t tagged_uint32<Tag>::x;
+    BOOST_LEAF_ALWAYS_INLINE void write_current_error_id( unsigned x ) noexcept
+    {
+        detail::current_error_id_storage<>::x = x;
+    }
 
-    template <class Tag>
-    std::uint32_t read_uint32() noexcept
+    BOOST_LEAF_ALWAYS_INLINE unsigned read_current_error_id() noexcept
     {
-        return tagged_uint32<Tag>::x;
+        return detail::current_error_id_storage<>::x;
     }
 
-    template <class Tag>
-    void write_uint32( std::uint32_t x ) noexcept
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE void reserve_ptr()
     {
-        tagged_uint32<Tag>::x = x;
     }
 
-    template <class Tag>
-    void uint32_increment() noexcept
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE void write_ptr( T * p ) noexcept
     {
-        ++tagged_uint32<Tag>::x;
+        detail::ptr<T>::p = p;
     }
 
-    template <class Tag>
-    void uint32_decrement() noexcept
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE T * read_ptr() noexcept
     {
-        --tagged_uint32<Tag>::x;
+        return detail::ptr<T>::p;
     }
-}
+} // namespace tls
 
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef 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..0c817e4b 100644
--- a/include/boost/leaf/config/tls_freertos.hpp
+++ b/include/boost/leaf/config/tls_freertos.hpp
@@ -1,17 +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-2025 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 <task.h>
+// Copyright (c) 2022 Khalil Estell
 
-#ifndef BOOST_LEAF_USE_TLS_ARRAY
-#   define BOOST_LEAF_USE_TLS_ARRAY
-#endif
+// This header implements the TLS API specified in tls.hpp via the FreeTOS
+// pvTaskGetThreadLocalStoragePointer / pvTaskSetThreadLocalStoragePointer
+// functions, using the more general implementation defined in tls_array.hpp.
+
+#include <task.h>
 
 #ifndef BOOST_LEAF_CFG_TLS_ARRAY_SIZE
 #   define BOOST_LEAF_CFG_TLS_ARRAY_SIZE configNUM_THREAD_LOCAL_STORAGE_POINTERS
@@ -26,12 +26,12 @@ namespace tls
 {
     // See https://www.freertos.org/thread-local-storage-pointers.html.
 
-    inline void * read_void_ptr( int tls_index ) noexcept
+    BOOST_LEAF_ALWAYS_INLINE void * read_void_ptr( int tls_index ) noexcept
     {
         return pvTaskGetThreadLocalStoragePointer(0, tls_index);
     }
 
-    inline void write_void_ptr( int tls_index, void * p ) noexcept
+    BOOST_LEAF_ALWAYS_INLINE void write_void_ptr( int tls_index, void * p ) noexcept
     {
         vTaskSetThreadLocalStoragePointer(0, tls_index, p);
     }
@@ -39,4 +39,4 @@ namespace tls
 
 } }
 
-#endif
+#endif // #ifndef 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..66f3d57f 100644
--- a/include/boost/leaf/config/tls_globals.hpp
+++ b/include/boost/leaf/config/tls_globals.hpp
@@ -1,27 +1,30 @@
 #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-2025 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
-// values using globals, which is suitable for single thread environments.
+// This header implements the TLS API specified in tls.hpp 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;
-}
 
-namespace tls
-{
+    template <class=void>
+    struct BOOST_LEAF_SYMBOL_VISIBLE id_factory
+    {
+        static atomic_unsigned_int counter;
+    };
+
+    template <class T>
+    atomic_unsigned_int id_factory<T>::counter = 1;
+
     template <class T>
     struct BOOST_LEAF_SYMBOL_VISIBLE ptr
     {
@@ -31,54 +34,59 @@ namespace tls
     template <class T>
     T * ptr<T>::p;
 
-    template <class T>
-    T * read_ptr() noexcept
+    template <class=void>
+    struct BOOST_LEAF_SYMBOL_VISIBLE current_error_id_storage
     {
-        return ptr<T>::p;
-    }
+        static unsigned x;
+    };
 
     template <class T>
-    void write_ptr( T * p ) noexcept
-    {
-        ptr<T>::p = p;
-    }
+    unsigned current_error_id_storage<T>::x = 0;
+} // namespace detail
+
+} } // namespace boost::leaf
 
-    ////////////////////////////////////////
+////////////////////////////////////////
+
+namespace boost { namespace leaf {
 
-    template <class Tag>
-    struct BOOST_LEAF_SYMBOL_VISIBLE tagged_uint32
+namespace tls
+{
+    BOOST_LEAF_ALWAYS_INLINE unsigned generate_next_error_id() noexcept
     {
-        static std::uint32_t x;
-    };
+        unsigned id = (detail::id_factory<>::counter += 4);
+        BOOST_LEAF_ASSERT((id&3) == 1);
+        return id;
+    }
 
-    template <class Tag>
-    std::uint32_t tagged_uint32<Tag>::x;
+    BOOST_LEAF_ALWAYS_INLINE void write_current_error_id( unsigned v ) noexcept
+    {
+        detail::current_error_id_storage<>::x = v;
+    }
 
-    template <class Tag>
-    std::uint32_t read_uint32() noexcept
+    BOOST_LEAF_ALWAYS_INLINE unsigned read_current_error_id() noexcept
     {
-        return tagged_uint32<Tag>::x;
+        return detail::current_error_id_storage<>::x;
     }
 
-    template <class Tag>
-    void write_uint32( std::uint32_t x ) noexcept
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE void reserve_ptr()
     {
-        tagged_uint32<Tag>::x = x;
     }
 
-    template <class Tag>
-    void uint32_increment() noexcept
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE void write_ptr( T * p ) noexcept
     {
-        ++tagged_uint32<Tag>::x;
+        detail::ptr<T>::p = p;
     }
 
-    template <class Tag>
-    void uint32_decrement() noexcept
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE T * read_ptr() noexcept
     {
-        --tagged_uint32<Tag>::x;
+        return detail::ptr<T>::p;
     }
-}
+} // namespace tls
 
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef BOOST_LEAF_CONFIG_TLS_GLOBALS_HPP_INCLUDED
diff --git a/include/boost/leaf/config/tls_win32.hpp b/include/boost/leaf/config/tls_win32.hpp
new file mode 100644
index 00000000..cfa69ea4
--- /dev/null
+++ b/include/boost/leaf/config/tls_win32.hpp
@@ -0,0 +1,495 @@
+#ifndef BOOST_LEAF_CONFIG_TLS_WIN32_HPP_INCLUDED
+#define BOOST_LEAF_CONFIG_TLS_WIN32_HPP_INCLUDED
+
+// Copyright 2025 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 header implements the TLS API specified in tls.hpp using Win32 TLS
+// functions, allowing error objects to cross DLL boundaries on Windows. This
+// implementation is enabled by defining BOOST_LEAF_CFG_WIN32=2 before including
+// any LEAF headers.
+
+#ifndef _WIN32
+#   error "This header is only for Windows"
+#endif
+
+#include <atomic>
+#include <unordered_map>
+#include <cstdint>
+#include <new>
+#include <stdexcept>
+#include <windows.h>
+#ifdef min
+#   undef min
+#endif
+#ifdef max
+#   undef max
+#endif
+
+namespace boost { namespace leaf {
+
+// Thrown on TLS allocation failure.
+class win32_tls_error:
+    public std::runtime_error
+{
+public:
+    explicit win32_tls_error(char const * what) noexcept:
+        std::runtime_error(what)
+    {
+    }
+};
+
+namespace detail
+{
+    __declspec(noreturn) inline void raise_fail_fast(NTSTATUS status) noexcept
+    {
+        EXCEPTION_RECORD rec = {};
+        rec.ExceptionCode = status;
+        rec.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
+        RaiseFailFastException(&rec, nullptr, 0);
+        BOOST_LEAF_UNREACHABLE;
+    }
+
+    template <class T, class... Args>
+    T * heap_new(Args && ... args) noexcept
+    {
+        void * mem = HeapAlloc(GetProcessHeap(), 0, sizeof(T));
+        if (!mem)
+        {
+            raise_fail_fast(STATUS_NO_MEMORY);
+            BOOST_LEAF_UNREACHABLE;
+        }
+        return new (mem) T(static_cast<Args &&>(args)...);
+    }
+
+    template <class T>
+    void heap_delete(T * p) noexcept
+    {
+        if (p)
+        {
+            p->~T();
+            BOOL r = HeapFree(GetProcessHeap(), 0, p);
+            BOOST_LEAF_ASSERT(r), (void) r;
+        }
+    }
+
+    template <class T>
+    class heap_allocator
+    {
+    public:
+
+        using value_type = T;
+
+        heap_allocator() noexcept = default;
+
+        template <class U>
+        heap_allocator(heap_allocator<U> const &) noexcept
+        {
+        }
+
+        T * allocate(std::size_t n) noexcept
+        {
+            if (void * p = HeapAlloc(GetProcessHeap(), 0, n * sizeof(T)))
+                return static_cast<T *>(p);
+            raise_fail_fast(STATUS_NO_MEMORY);
+            BOOST_LEAF_UNREACHABLE;
+        }
+
+        void deallocate(T * p, std::size_t) noexcept
+        {
+            BOOL r = HeapFree(GetProcessHeap(), 0, p);
+            BOOST_LEAF_ASSERT(r), (void) r;
+        }
+
+        friend bool operator==(heap_allocator const &, heap_allocator const &) noexcept { return true; }
+        friend bool operator!=(heap_allocator const &, heap_allocator const &) noexcept { return false; }
+    };
+
+    class critical_section_lock
+    {
+        critical_section_lock(critical_section_lock const &) = delete;
+        critical_section_lock & operator=(critical_section_lock const &) = delete;
+
+        CRITICAL_SECTION & cs_;
+
+    public:
+
+        explicit critical_section_lock(CRITICAL_SECTION & cs) noexcept:
+            cs_(cs)
+        {
+            EnterCriticalSection(&cs_);
+        }
+
+        ~critical_section_lock() noexcept
+        {
+            LeaveCriticalSection(&cs_);
+        }
+    };
+
+    using atomic_unsigned_int = std::atomic<unsigned int>;
+
+    template <int N, int I>
+    struct cpp11_hash_step
+    {
+        BOOST_LEAF_ALWAYS_INLINE constexpr static std::uint32_t compute(char const (&str)[N], std::uint32_t hash) noexcept
+        {
+            return cpp11_hash_step<N, I - 1>::compute(str, (hash ^ static_cast<std::uint32_t>(str[I])) * 16777619u);
+        }
+    };
+
+    template <int N>
+    struct cpp11_hash_step<N, -1>
+    {
+        BOOST_LEAF_ALWAYS_INLINE constexpr static std::uint32_t compute(char const (&)[N], std::uint32_t hash) noexcept
+        {
+            return hash;
+        }
+    };
+
+    template <int N>
+    BOOST_LEAF_ALWAYS_INLINE constexpr std::uint32_t cpp11_hash_string(char const (&str)[N]) noexcept
+    {
+        return cpp11_hash_step<N, N - 2>::compute(str, 2166136261u); // str[N-2] is the last character before the \0.
+    }
+} // namespace detail
+
+namespace n
+{
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE constexpr std::uint32_t __cdecl h() noexcept
+    {
+        return detail::cpp11_hash_string(BOOST_LEAF_PRETTY_FUNCTION);
+    }
+}
+
+namespace detail
+{
+    template<class T>
+    BOOST_LEAF_ALWAYS_INLINE constexpr std::uint32_t type_hash() noexcept
+    {
+        return n::h<T>();
+    }
+}
+
+} } // namespace boost::leaf
+
+////////////////////////////////////////
+
+namespace boost { namespace leaf {
+
+namespace detail
+{
+    class slot_map
+    {
+        slot_map(slot_map const &) = delete;
+        slot_map & operator=(slot_map const &) = delete;
+
+        class tls_slot_index
+        {
+            tls_slot_index(tls_slot_index const &) = delete;
+            tls_slot_index & operator=(tls_slot_index const &) = delete;
+            tls_slot_index & operator=(tls_slot_index &&) = delete;
+
+            DWORD idx_;
+
+        public:
+
+            BOOST_LEAF_ALWAYS_INLINE tls_slot_index():
+                idx_(TlsAlloc())    
+            {
+                if (idx_ == TLS_OUT_OF_INDEXES)
+                    throw_exception_(win32_tls_error("TLS_OUT_OF_INDEXES"));
+            }   
+
+            BOOST_LEAF_ALWAYS_INLINE ~tls_slot_index() noexcept
+            {
+                if (idx_ == TLS_OUT_OF_INDEXES)
+                    return;
+                BOOL r = TlsFree(idx_);
+                BOOST_LEAF_ASSERT(r), (void) r;
+            }
+
+            BOOST_LEAF_ALWAYS_INLINE tls_slot_index(tls_slot_index && other) noexcept:
+                idx_(other.idx_)
+            {
+                other.idx_ = TLS_OUT_OF_INDEXES;
+            }
+
+            BOOST_LEAF_ALWAYS_INLINE DWORD get() const noexcept
+            {
+                BOOST_LEAF_ASSERT(idx_ != TLS_OUT_OF_INDEXES);
+                return idx_;
+            }
+        };
+
+        int refcount_;
+        HANDLE const mapping_;
+        tls_slot_index const error_id_slot_;
+        mutable CRITICAL_SECTION cs_;
+        std::unordered_map<
+            std::uint32_t,
+            tls_slot_index,
+            std::hash<std::uint32_t>,
+            std::equal_to<std::uint32_t>,
+            heap_allocator<std::pair<std::uint32_t const, tls_slot_index>>> map_;
+        atomic_unsigned_int error_id_storage_;
+
+    public:
+
+        explicit slot_map(HANDLE mapping) noexcept:
+            refcount_(1),
+            mapping_(mapping),
+            error_id_storage_(1)
+        {
+            BOOST_LEAF_ASSERT(mapping != INVALID_HANDLE_VALUE);
+            InitializeCriticalSection(&cs_);
+        }
+
+        ~slot_map() noexcept
+        {
+            DeleteCriticalSection(&cs_);
+            BOOL r = CloseHandle(mapping_);
+            BOOST_LEAF_ASSERT(r), (void) r;
+        }
+
+        BOOST_LEAF_ALWAYS_INLINE void add_ref() noexcept
+        {
+            BOOST_LEAF_ASSERT(refcount_ >= 1);
+            ++refcount_;
+        }
+
+        BOOST_LEAF_ALWAYS_INLINE void release() noexcept
+        {
+            --refcount_;
+            BOOST_LEAF_ASSERT(refcount_ >= 0);
+            if (refcount_ == 0)
+                heap_delete(this);
+        }
+
+        DWORD check(std::uint32_t type_hash) const noexcept
+        {
+            critical_section_lock lock(cs_);
+            auto it = map_.find(type_hash);
+            return (it != map_.end()) ? it->second.get() : TLS_OUT_OF_INDEXES;
+        }
+
+        DWORD get(std::uint32_t type_hash)
+        {
+            critical_section_lock lock(cs_);
+            DWORD idx = map_[type_hash].get();
+            BOOST_LEAF_ASSERT(idx != TLS_OUT_OF_INDEXES);
+            return idx;
+        }
+
+        BOOST_LEAF_ALWAYS_INLINE DWORD error_id_slot() const noexcept
+        {
+            return error_id_slot_.get();
+        }
+
+        BOOST_LEAF_ALWAYS_INLINE atomic_unsigned_int & error_id_storage() noexcept
+        {
+            return error_id_storage_;
+        }
+    }; // class slot_map
+
+    class module_state
+    {
+        module_state(module_state const &) = delete;
+        module_state & operator=(module_state const &) = delete;
+
+        static constexpr unsigned tls_failure_create_mapping = 0x01;
+        static constexpr unsigned tls_failure_map_view = 0x02;
+
+        void * hinstance_;
+        unsigned tls_failures_;
+        slot_map * sm_;
+
+    public:
+
+        constexpr module_state() noexcept:
+            hinstance_(nullptr),
+            tls_failures_(0),
+            sm_(nullptr)
+        {
+        }
+
+        BOOST_LEAF_ALWAYS_INLINE slot_map & sm() const noexcept
+        {
+            BOOST_LEAF_ASSERT(hinstance_);
+            BOOST_LEAF_ASSERT(!(tls_failures_ & tls_failure_create_mapping));
+            BOOST_LEAF_ASSERT(!(tls_failures_ & tls_failure_map_view));
+            BOOST_LEAF_ASSERT(sm_);
+            return *sm_;
+        }
+
+        BOOST_LEAF_ALWAYS_INLINE void update(PVOID hinstDLL, DWORD dwReason) noexcept
+        {
+            if (dwReason == DLL_PROCESS_ATTACH)
+            {
+                hinstance_ = hinstDLL;
+                char name[32] = "Local\\boost_leaf_";
+                {
+                    constexpr static char const hex[] = "0123456789ABCDEF";
+                    DWORD pid = GetCurrentProcessId();
+                    for (int i = 7; i >= 0; --i)
+                    {
+                        name[17 + i] = hex[pid & 0xf];
+                        pid >>= 4;
+                    }
+                    name[25] = '\0';
+                }
+                HANDLE mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0, sizeof(slot_map *), name);
+                DWORD mapping_status = GetLastError();
+                if (!mapping)
+                {
+                    tls_failures_ |= tls_failure_create_mapping;
+                    return;
+                }
+                BOOST_LEAF_ASSERT(mapping_status == ERROR_ALREADY_EXISTS || mapping_status == ERROR_SUCCESS);
+                bool is_first_module = (mapping_status == ERROR_SUCCESS);
+                slot_map * * mapped_ptr = static_cast<slot_map * *>(MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, sizeof(slot_map *)));
+                if (!mapped_ptr)
+                {
+                    tls_failures_ |= tls_failure_map_view;
+                    BOOL r = CloseHandle(mapping);
+                    BOOST_LEAF_ASSERT(r), (void) r;
+                    return;
+                }
+                if (is_first_module)
+                    sm_ = *mapped_ptr = heap_new<slot_map>(mapping);
+                else
+                {
+                    sm_ = *mapped_ptr;
+                    sm_->add_ref();
+                    BOOL r = CloseHandle(mapping);
+                    BOOST_LEAF_ASSERT(r), (void) r;
+                }
+                UnmapViewOfFile(mapped_ptr);
+            }
+            else if (dwReason == DLL_PROCESS_DETACH)
+            {
+                BOOST_LEAF_ASSERT(sm_ || tls_failures_);
+                if (sm_)
+                {
+                    sm_->release();
+                    sm_ = nullptr;
+                }
+            }
+        }
+    }; // class module_state
+
+    template<int = 0>
+    struct module
+    {
+        static module_state state;
+    };
+
+    template<int N>
+    module_state module<N>::state;
+
+    BOOST_LEAF_ALWAYS_INLINE unsigned generate_next_error_id() noexcept
+    {
+        static atomic_unsigned_int & counter = module<>::state.sm().error_id_storage();
+        unsigned id = (counter += 4);
+        BOOST_LEAF_ASSERT((id&3) == 1);
+        return id;
+    }
+
+    inline void NTAPI tls_callback(PVOID hinstDLL, DWORD dwReason, PVOID) noexcept
+    {
+        module<>::state.update(hinstDLL, dwReason);
+    }
+
+#ifdef _MSC_VER
+#   pragma section(".CRT$XLB", long, read)
+#   pragma data_seg(push, ".CRT$XLB")
+
+extern "C" __declspec(selectany) PIMAGE_TLS_CALLBACK boost_leaf_tls_callback = tls_callback;
+
+#   pragma data_seg(pop)
+#   ifdef _WIN64
+#       pragma comment(linker, "/INCLUDE:boost_leaf_tls_callback")
+#   else
+#       pragma comment(linker, "/INCLUDE:_boost_leaf_tls_callback")
+#   endif
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wattributes"
+
+extern "C" __attribute__((used, selectany)) PIMAGE_TLS_CALLBACK boost_leaf_tls_callback __attribute__((section(".CRT$XLB"))) = tls_callback;
+
+#   pragma GCC diagnostic pop
+#else
+#   error Unknown compiler, unable to define .CRT$XLB section
+#endif
+} // namespace detail
+
+} } // namespace boost::leaf
+
+////////////////////////////////////////
+
+namespace boost { namespace leaf {
+
+namespace tls
+{
+    BOOST_LEAF_ALWAYS_INLINE unsigned generate_next_error_id() noexcept
+    {
+        return detail::generate_next_error_id();
+    }
+
+    BOOST_LEAF_ALWAYS_INLINE void write_current_error_id(unsigned x) noexcept
+    {
+        using namespace detail;
+        DWORD slot = module<>::state.sm().error_id_slot();
+        BOOL r = TlsSetValue(slot, reinterpret_cast<void *>(static_cast<std::uintptr_t>(x)));
+        BOOST_LEAF_ASSERT(r), (void) r;
+    }
+
+    BOOST_LEAF_ALWAYS_INLINE unsigned read_current_error_id() noexcept
+    {
+        using namespace detail;
+        DWORD slot = module<>::state.sm().error_id_slot();
+        LPVOID value = TlsGetValue(slot);
+        BOOST_LEAF_ASSERT(GetLastError() == ERROR_SUCCESS);
+        return static_cast<unsigned>(reinterpret_cast<std::uintptr_t>(value));
+    }
+
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE void reserve_ptr()
+    {
+        using namespace detail;
+        thread_local DWORD const cached_slot = module<>::state.sm().get(type_hash<T>());
+        BOOST_LEAF_ASSERT(cached_slot != TLS_OUT_OF_INDEXES), (void) cached_slot;
+    }
+
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE void write_ptr(T * p) noexcept
+    {
+        using namespace detail;
+        thread_local DWORD const cached_slot = module<>::state.sm().check(type_hash<T>());
+        DWORD slot = cached_slot;
+        BOOST_LEAF_ASSERT(slot != TLS_OUT_OF_INDEXES);
+        BOOL r = TlsSetValue(slot, p);
+        BOOST_LEAF_ASSERT(r), (void) r;
+    }
+
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE T * read_ptr() noexcept
+    {
+        using namespace detail;
+        thread_local DWORD cached_slot = TLS_OUT_OF_INDEXES;
+        if (cached_slot == TLS_OUT_OF_INDEXES)
+            cached_slot = module<>::state.sm().check(type_hash<T>());
+        DWORD slot = cached_slot;
+        if (slot == TLS_OUT_OF_INDEXES)
+            return nullptr;
+        LPVOID value = TlsGetValue(slot);
+        BOOST_LEAF_ASSERT(GetLastError() == ERROR_SUCCESS);
+        return static_cast<T *>(value);
+    }
+} // namespace tls
+
+} } // namespace boost::leaf
+
+#endif // #ifndef BOOST_LEAF_CONFIG_TLS_WIN32_HPP_INCLUDED
diff --git a/include/boost/leaf/config/visibility.hpp b/include/boost/leaf/config/visibility.hpp
new file mode 100644
index 00000000..86615bb4
--- /dev/null
+++ b/include/boost/leaf/config/visibility.hpp
@@ -0,0 +1,45 @@
+#ifndef BOOST_LEAF_CONFIG_VISIBILITY_HPP_INCLUDED
+#define BOOST_LEAF_CONFIG_VISIBILITY_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)
+
+namespace boost { namespace leaf {
+
+class BOOST_LEAF_SYMBOL_VISIBLE error_id;
+class BOOST_LEAF_SYMBOL_VISIBLE error_info;
+class BOOST_LEAF_SYMBOL_VISIBLE diagnostic_info;
+class BOOST_LEAF_SYMBOL_VISIBLE diagnostic_details;
+
+struct BOOST_LEAF_SYMBOL_VISIBLE e_api_function;
+struct BOOST_LEAF_SYMBOL_VISIBLE e_file_name;
+struct BOOST_LEAF_SYMBOL_VISIBLE e_errno;
+struct BOOST_LEAF_SYMBOL_VISIBLE e_type_info_name;
+struct BOOST_LEAF_SYMBOL_VISIBLE e_at_line;
+struct BOOST_LEAF_SYMBOL_VISIBLE e_source_location;
+
+class BOOST_LEAF_SYMBOL_VISIBLE bad_result;
+template <class> class BOOST_LEAF_SYMBOL_VISIBLE result;
+
+namespace detail
+{
+    template <class> class BOOST_LEAF_SYMBOL_VISIBLE slot;
+
+    class BOOST_LEAF_SYMBOL_VISIBLE exception_base;
+
+    template <class> class BOOST_LEAF_SYMBOL_VISIBLE exception;
+
+#if BOOST_LEAF_CFG_CAPTURE
+    class BOOST_LEAF_SYMBOL_VISIBLE dynamic_allocator;
+#endif
+
+#if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+    class BOOST_LEAF_SYMBOL_VISIBLE leaf_error_category;
+    template <class> struct BOOST_LEAF_SYMBOL_VISIBLE get_leaf_error_category;
+#endif
+}
+
+} } // namespace boost::leaf
+
+#endif // BOOST_LEAF_CONFIG_VISIBILITY_HPP_INCLUDED
diff --git a/include/boost/leaf/context.hpp b/include/boost/leaf/context.hpp
index 0ac45d20..63518f30 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-2025 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
+
+////////////////////////////////////////
+
+namespace detail
+{
+    template <class T>
+    struct get_dispatch
+    {
+        static BOOST_LEAF_CONSTEXPR T const * get(T const * x) noexcept
         {
-            return ei;
+            return x;
+        }
+        static BOOST_LEAF_CONSTEXPR T const * get(void const *) noexcept
+        {
+            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 detail
 
 ////////////////////////////////////////
 
-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);
+            tuple_for_each<I-1,Tup>::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);
-        }
-
-        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 ) { }
-    };
-}
-
-////////////////////////////////////////////
-
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-
-namespace leaf_detail
-{
-    template <class T> struct requires_unexpected { constexpr static bool value = false; };
-    template <class T> struct requires_unexpected<T const> { constexpr static bool value = requires_unexpected<T>::value; };
-    template <class T> struct requires_unexpected<T const &> { constexpr static bool value = requires_unexpected<T>::value; };
-    template <class T> struct requires_unexpected<T const *> { constexpr static bool value = requires_unexpected<T>::value; };
-    template <> struct requires_unexpected<e_unexpected_count> { constexpr static bool value = true; };
-    template <> struct requires_unexpected<e_unexpected_info> { constexpr static bool value = true; };
-
-    template <class L>
-    struct unexpected_requested;
-
-    template <template <class ...> class L>
-    struct unexpected_requested<L<>>
-    {
-        constexpr static bool value = false;
+        BOOST_LEAF_CONSTEXPR static void print(std::basic_ostream<CharT, Traits> &, void const *, error_id, char const * &) { }
     };
 
-    template <template <class...> class L, template <class> class S, class Car, class... Cdr>
-    struct unexpected_requested<L<S<Car>, S<Cdr>...>>
+    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 = requires_unexpected<Car>::value || unexpected_requested<L<S<Cdr>...>>::value;
-    };
-}
-
-#endif
+        tuple_for_each<std::tuple_size<Tup>::value, Tup>::print(os, tup, to_print, prefix);
+    }
+} // namespace detail
 
-////////////////////////////////////////////
+////////////////////////////////////////
 
-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
             >;
@@ -267,9 +262,9 @@ namespace leaf_detail
 
     template <class... E>
     using deduce_e_tuple = typename deduce_e_tuple_impl<typename deduce_e_type_list<leaf_detail_mp11::mp_list<E...>>::type>::type;
-}
+} // namespace detail
 
-////////////////////////////////////////////
+////////////////////////////////////////
 
 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,31 @@ 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();
+        }
+#if __cplusplus < 201703L
+        BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE raii_deactivator( raii_deactivator && x ) noexcept:
+            ctx_(x.ctx_)
+        {
+            x.ctx_ = nullptr;
+        }
+#endif
+        BOOST_LEAF_ALWAYS_INLINE ~raii_deactivator() noexcept
+        {
+            if( ctx_ && ctx_->is_active() )
+                ctx_->deactivate();
+        }
+    };
 
 public:
 
@@ -302,7 +315,7 @@ class context
         BOOST_LEAF_ASSERT(!x.is_active());
     }
 
-    BOOST_LEAF_CONSTEXPR context() noexcept:
+    BOOST_LEAF_CONSTEXPR context():
         is_active_(false)
     {
     }
@@ -324,13 +337,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 +348,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 +372,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 +395,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);
+    }
+}; // template context
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class TypeList>
     struct deduce_context_impl;
@@ -416,25 +441,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
-    };
-}
+} // namespace detail
 
 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 +460,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
-
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef BOOST_LEAF_CONTEXT_HPP_INCLUDED
diff --git a/include/boost/leaf/detail/all.hpp b/include/boost/leaf/detail/all.hpp
index 8f5dcbd4..62030d5e 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-2025 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..9b51ed65
--- /dev/null
+++ b/include/boost/leaf/detail/capture_list.hpp
@@ -0,0 +1,121 @@
+#ifndef BOOST_LEAF_DETAIL_CAPTURE_LIST_HPP_INCLUDED
+#define BOOST_LEAF_DETAIL_CAPTURE_LIST_HPP_INCLUDED
+
+// Copyright 2018-2025 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 {
+
+namespace detail
+{
+
+    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_current_error_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
+        }
+    }; // class capture_list
+
+} // namespace detail
+
+} } // namespace boost::leaf
+
+#endif // #if BOOST_LEAF_CFG_CAPTURE
+
+#endif // #ifndef 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..e6003fa9 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-2025 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
+//  For some architectures (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 // #if BOOST_LEAF_CFG_DIAGNOSTICS
 
 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 bloat.
 
-    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>
+    {
+        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 name;
+        return cpp11_suffix<S1, S2, S1 - 2, S2 - 2>::check(str, suffix) ? S1 - S2 : 0;
     }
+} // namespace detail
 
-    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 };
     }
+} // namespace n
 
-#endif
+using parsed = n::r;
+
+template <class T>
+parsed parse()
+{
+    return n::p<T>();
 }
 
-} }
+} } // namespace boost::leaf
 
-#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 // #if defined(BOOST_LEAF_CFG_DIAGNOSTICS) && defined(BOOST_LEAF_HAS_CXXABI_H)
+        return os << mangled_name;
     }
-}
+} // namespace detail
 
-} }
-
-#endif
+} } // namespace boost::leaf
 
-#ifdef BOOST_LEAF_HAS_CXXABI_H
-#   undef BOOST_LEAF_HAS_CXXABI_H
-#endif
-
-#endif
+#endif // #ifndef 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..e8ccb11e 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-2025 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...); };
@@ -93,8 +92,8 @@ namespace leaf_detail
 
     template <class F>
     using fn_mp_args = typename function_traits<F>::mp_args;
-}
+} // namespace detail
 
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef 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..68e296f3 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-2025 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 // #ifndef BOOST_LEAF_DETAIL_MP11_HPP_INCLUDED
diff --git a/include/boost/leaf/detail/optional.hpp b/include/boost/leaf/detail/optional.hpp
index 494ecedc..06b10518 100644
--- a/include/boost/leaf/detail/optional.hpp
+++ b/include/boost/leaf/detail/optional.hpp
@@ -1,19 +1,16 @@
 #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-2025 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 <utility>
 #include <new>
 
 namespace boost { namespace leaf {
 
-namespace leaf_detail
+namespace detail
 {
     template <class T>
     class optional
@@ -66,7 +63,7 @@ namespace leaf_detail
             reset();
             if( int key = x.key() )
             {
-                put(key, x.value_);
+                load(key, x.value_);
                 key_ = key;
             }
             return *this;
@@ -77,7 +74,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 +87,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 +104,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 +122,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();
@@ -128,44 +134,48 @@ namespace leaf_detail
         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;
         }
-    };
+    }; // template optional
 
-}
+} // namespace detail
 
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef BOOST_LEAF_DETAIL_OPTIONAL_HPP_INCLUDED
diff --git a/include/boost/leaf/detail/print.hpp b/include/boost/leaf/detail/print.hpp
index d37c75f6..4299de68 100644
--- a/include/boost/leaf/detail/print.hpp
+++ b/include/boost/leaf/detail/print.hpp
@@ -1,24 +1,24 @@
 #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-2025 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>
-#include <cstring>
 
 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 +26,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 +38,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_));
         }
     };
-}
-
-} }
+} // namespace detail
 
-#endif
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef 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..28449d60
--- /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-2025 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';
+    }
+}; // class diagnostic_info
+
+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 // #if BOOST_LEAF_CFG_DIAGNOSTICS
+
+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";
+    }
+}; // class diagnostic_info
+
+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 // #else (#if BOOST_LEAF_CFG_DIAGNOSTICS)
+
+////////////////////////////////////////
+
+#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';
+    }
+}; // class diagnostic_details
+
+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->get() : nullptr );
+        }
+    };
+}
+
+#else // #if BOOST_LEAF_CFG_CAPTURE
+
+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";
+    }
+}; // class diagnostic_details
+
+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 (#if BOOST_LEAF_CFG_CAPTURE)
+
+#else // #if BOOST_LEAF_CFG_DIAGNOSTICS
+
+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 // #else (#if BOOST_LEAF_CFG_DIAGNOSTICS)
+
+using verbose_diagnostic_info = diagnostic_details;
+
+} } // namespace boost::leaf
+
+#endif // #ifndef BOOST_LEAF_DIAGNOSTICS_HPP_INCLUDED
diff --git a/include/boost/leaf/error.hpp b/include/boost/leaf/error.hpp
index 179b9068..7e02d67d 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-2025 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__)
@@ -56,7 +45,7 @@
         std::move(BOOST_LEAF_TMP);\
     }).value()
 
-#else
+#else // #if BOOST_LEAF_CFG_GNUC_STMTEXPR
 
 #define BOOST_LEAF_CHECK(r)\
     {\
@@ -67,382 +56,487 @@
             return BOOST_LEAF_TMP.error();\
     }
 
-#endif
+#endif // #else (#if BOOST_LEAF_CFG_GNUC_STMTEXPR)
 
-#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 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
+        return os << x.file << '(' << x.line << ") in function " << x.function;
+    }
+};
 
-namespace boost
+template <>
+struct show_in_diagnostics<e_source_location>: std::false_type
 {
-BOOST_LEAF_NORETURN void throw_exception( std::exception const & ); // user defined
-}
+};
 
-namespace boost { namespace leaf {
+////////////////////////////////////////
 
-template <class T>
-BOOST_LEAF_NORETURN void throw_exception( T const & e )
+namespace detail
 {
-    ::boost::throw_exception(e);
+    class 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 { }
+    };
 }
 
-} }
-
-#else
-
-namespace boost { namespace leaf {
+////////////////////////////////////////
 
-template <class T>
-BOOST_LEAF_NORETURN void throw_exception( T const & e )
+namespace detail
 {
-    throw e;
-}
+    template <class E>
+    class slot:
+        optional<E>
+    {
+        static_assert(std::is_same<E, typename std::decay<E>::type>::value, "E must be decayed for slot<E>");
+        slot( slot const & ) = delete;
+        slot & operator=( slot const & ) = delete;
 
-} }
+        using impl = optional<E>;
+        slot<E> * prev_;
 
-#endif
+    public:
 
-////////////////////////////////////////
+        BOOST_LEAF_CONSTEXPR slot():
+            prev_(nullptr)
+        {
+            tls::reserve_ptr<slot<E>>();
+        }
 
-namespace boost { namespace leaf {
+        template <class T>
+        BOOST_LEAF_CONSTEXPR slot( int key, T && e ):
+            optional<E>(key, std::forward<T>(e)),
+            prev_(nullptr)
+        {
+            tls::reserve_ptr<slot<E>>();
+        }
 
-#if BOOST_LEAF_CFG_DIAGNOSTICS
+        BOOST_LEAF_CONSTEXPR slot( slot && x ) noexcept:
+            optional<E>(std::move(x)),
+            prev_(nullptr)
+        {
+            BOOST_LEAF_ASSERT(x.prev_ == nullptr);
+        }
 
-namespace leaf_detail
-{
-    class BOOST_LEAF_SYMBOL_VISIBLE e_unexpected_count
-    {
-    public:
+        ~slot() noexcept
+        {
+            BOOST_LEAF_ASSERT(tls::read_ptr<slot<E>>() != this);
+        }
 
-        char const * (*first_type)();
-        int count;
+        void activate() noexcept
+        {
+            prev_ = tls::read_ptr<slot<E>>();
+            tls::write_ptr<slot<E>>(this);
+        }
 
-        BOOST_LEAF_CONSTEXPR explicit e_unexpected_count(char const * (*first_type)()) noexcept:
-            first_type(first_type),
-            count(1)
+        void deactivate() const noexcept
         {
+            tls::write_ptr<slot<E>>(prev_);
         }
 
-        template <class CharT, class Traits>
-        void print( std::basic_ostream<CharT, Traits> & os ) const
+        void unload( int err_id ) noexcept(!BOOST_LEAF_CFG_CAPTURE);
+
+        template <class CharT, class Traits, class ErrorID>
+        void print(std::basic_ostream<CharT, Traits> & os, ErrorID to_print, char const * & prefix) const
         {
-            BOOST_LEAF_ASSERT(first_type != nullptr);
-            BOOST_LEAF_ASSERT(count>0);
-            os << "Detected ";
-            if( count==1 )
-                os << "1 attempt to communicate an unexpected error object";
-            else
-                os << count << " attempts to communicate unexpected error objects, the first one";
-            (os << " of type " << first_type() << '\n').flush();
+            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 << ')';
+            }
         }
-    };
 
-    template <>
-    struct diagnostic<e_unexpected_count, false, false>
-    {
-        static constexpr bool is_invisible = true;
+        using impl::load;
+        using impl::has_value;
+        using impl::value;
+    }; // template slot
+} // namespace detail
 
-        template <class CharT, class Traits>
-        BOOST_LEAF_CONSTEXPR static void print( std::basic_ostream<CharT, Traits> &, e_unexpected_count const &) noexcept { }
-    };
+////////////////////////////////////////
+
+#if BOOST_LEAF_CFG_CAPTURE
+
+namespace detail
+{
+    class preloaded_base;
 
-    class BOOST_LEAF_SYMBOL_VISIBLE e_unexpected_info
+    template <class E>
+    struct capturing_slot_node_allocator;
+
+    class dynamic_allocator:
+        capture_list
     {
-        std::string s_;
-        std::set<char const *(*)()> already_;
+        dynamic_allocator( dynamic_allocator const & ) = delete;
+        dynamic_allocator & operator=( dynamic_allocator const & ) = delete;
 
-    public:
+        template <class>
+        friend struct capturing_slot_node_allocator;
 
-        e_unexpected_info() noexcept
+        preloaded_base * preloaded_list_;
+
+        class capturing_node:
+            public capture_list::node
         {
-        }
+        protected:
+            BOOST_LEAF_CONSTEXPR explicit capturing_node( capture_list::node * * & last ) noexcept:
+                node(last)
+            {
+                BOOST_LEAF_ASSERT(last == &next_);
+                BOOST_LEAF_ASSERT(next_ == nullptr);
+            }
+        public:
+            virtual void deactivate() const noexcept = 0;
+        };
 
         template <class E>
-        void add(E && e)
+        class capturing_slot_node final:
+            public slot<E>,
+            public capturing_node
         {
-            if( !diagnostic<E>::is_invisible && already_.insert(&type<E>).second  )
+            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 override
+            {
+                impl::deactivate();
+            }
+            void unload( int err_id ) override
+            {
+                impl::unload(err_id);
+            }
+#if BOOST_LEAF_CFG_DIAGNOSTICS
+            void print(std::ostream & os, error_id const & to_print, char const * & prefix) const override
             {
-                std::stringstream s;
-                diagnostic<E>::print(s,e);
-                (s << '\n').flush();
-                s_ += s.str();
+                impl::print(os, to_print, prefix);
             }
+#endif
+        public:
+            BOOST_LEAF_CONSTEXPR explicit capturing_slot_node( capture_list::node * * & last ):
+                capturing_node(last)
+            {
+                BOOST_LEAF_ASSERT(last == &next_);
+                BOOST_LEAF_ASSERT(next_ == nullptr);
+            }
+            template <class T>
+            BOOST_LEAF_CONSTEXPR capturing_slot_node( capture_list::node * * & last, int err_id, T && e ):
+                slot<E>(err_id, std::forward<T>(e)),
+                capturing_node(last)
+            {
+                BOOST_LEAF_ASSERT(last == &next_);
+                BOOST_LEAF_ASSERT(next_ == nullptr);
+            }
+        };
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+        class capturing_exception_node final:
+            public capturing_node
+        {
+            capturing_exception_node( capturing_exception_node const & ) = delete;
+            capturing_exception_node & operator=( capturing_exception_node const & ) = delete;
+            void deactivate() const noexcept override
+            {
+                BOOST_LEAF_ASSERT(0);
+            }
+            void unload( int ) override
+            {
+                std::rethrow_exception(ex_);
+            }
+#if BOOST_LEAF_CFG_DIAGNOSTICS
+            void print(std::ostream &, error_id const &, char const * &) const 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 // #ifndef BOOST_LEAF_NO_EXCEPTIONS
+
+        node * * last_;
+
+    public:
+
+        dynamic_allocator() noexcept:
+            capture_list(nullptr),
+            preloaded_list_(nullptr),
+            last_(&first_)
+        {
+            BOOST_LEAF_ASSERT(first_ == nullptr);
         }
 
-        template <class CharT, class Traits>
-        void print( std::basic_ostream<CharT, Traits> & os ) const
+        dynamic_allocator( dynamic_allocator && other ) noexcept:
+            capture_list(std::move(other)),
+            preloaded_list_(nullptr),
+            last_(other.last_ == &other.first_? &first_ : other.last_)
         {
-            os << "Unhandled error objects:\n" << s_;
+            BOOST_LEAF_ASSERT(last_ != nullptr);
+            BOOST_LEAF_ASSERT(*last_ == nullptr);
+            BOOST_LEAF_ASSERT(other.first_ == nullptr);
+            BOOST_LEAF_ASSERT(other.preloaded_list_ == nullptr);
+            other.last_ = &other.first_;
         }
-    };
 
-    template <>
-    struct diagnostic<e_unexpected_info, false, false>
-    {
-        static constexpr bool is_invisible = true;
+        preloaded_base * preloaded_list() const noexcept
+        {
+            return preloaded_list_;
+        }
 
-        template <class CharT, class Traits>
-        BOOST_LEAF_CONSTEXPR static void print( std::basic_ostream<CharT, Traits> &, e_unexpected_info const &) noexcept { }
-    };
+        preloaded_base * link_preloaded_item(preloaded_base * pb) noexcept
+        {
+            BOOST_LEAF_ASSERT(pb != nullptr);
+            preloaded_base * next = preloaded_list_;
+            preloaded_list_ = pb;
+            return next;
+        }
 
-}
+        void unlink_preloaded_item(preloaded_base * next) noexcept
+        {
+            preloaded_list_ = next;
+        }
 
-#endif
+        template <class E>
+        slot<E> * alloc()
+        {
+            BOOST_LEAF_ASSERT(last_ != nullptr);
+            BOOST_LEAF_ASSERT(*last_ == nullptr);
+            BOOST_LEAF_ASSERT(tls::read_ptr<slot<E>>() == nullptr);
+            capturing_slot_node<E> * csn = capturing_slot_node_allocator<E>::new_(last_);
+            csn->activate();
+            return csn;
+        }
 
-} }
+        template <class E>
+        slot<E> * reserve()
+        {
+            if( slot<E> * p = tls::read_ptr<slot<E>>() )
+                return p;
+            else
+                return alloc<E>();
+        }
 
-////////////////////////////////////////
+        void deactivate() const noexcept
+        {
+            for_each(
+                []( capture_list::node const & n )
+                {
+                    static_cast<capturing_node const &>(n).deactivate();
+                } );
+        }
 
-namespace boost { namespace leaf {
+        template <class LeafResult>
+        LeafResult extract_capture_list(int err_id)
+        {
+#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) };
+        }
 
-struct BOOST_LEAF_SYMBOL_VISIBLE e_source_location
-{
-    char const * file;
-    int line;
-    char const * function;
+        using capture_list::unload;
+        using capture_list::print;
+    }; // class dynamic_allocator
 
-    template <class CharT, class Traits>
-    friend std::basic_ostream<CharT, Traits> & operator<<( std::basic_ostream<CharT, Traits> & os, e_source_location const & x )
+    template <class E>
+    struct capturing_slot_node_allocator
     {
-        return os << leaf::type<e_source_location>() << ": " << x.file << '(' << x.line << ") in function " << x.function;
-    }
-};
+        template <class... A>
+        static dynamic_allocator::capturing_slot_node<E> * new_( A && ... a )
+        {
+            return new dynamic_allocator::capturing_slot_node<E>(std::forward<A>(a)...);
+        }
 
-////////////////////////////////////////
+        static void delete_( dynamic_allocator::capturing_slot_node<E> * p ) noexcept
+        {
+            delete p;
+        }
+    };
 
-namespace leaf_detail
-{
-    template <class E>
-    class BOOST_LEAF_SYMBOL_VISIBLE slot:
-        optional<E>
+    template <>
+    class slot<dynamic_allocator>
     {
         slot( slot const & ) = delete;
         slot & operator=( slot const & ) = delete;
 
-        using impl = optional<E>;
-        slot<E> * prev_;
+        dynamic_allocator da_;
+        slot * prev_;
 
     public:
 
-        BOOST_LEAF_CONSTEXPR slot() noexcept:
+        slot() noexcept:
             prev_(nullptr)
         {
+            tls::reserve_ptr<slot<dynamic_allocator>>();
         }
 
-        BOOST_LEAF_CONSTEXPR slot( slot && x ) noexcept:
-            optional<E>(std::move(x)),
+        slot( slot && x ) noexcept:
+            da_(std::move(x.da_)),
             prev_(nullptr)
         {
-            BOOST_LEAF_ASSERT(x.prev_==nullptr);
+            BOOST_LEAF_ASSERT(x.prev_ == nullptr);
         }
 
-        BOOST_LEAF_CONSTEXPR void activate() noexcept
+        ~slot() noexcept
         {
-            prev_ = tls::read_ptr<slot<E>>();
-            tls::write_ptr<slot<E>>(this);
+            BOOST_LEAF_ASSERT(tls::read_ptr<slot<dynamic_allocator>>() != this);
         }
 
-        BOOST_LEAF_CONSTEXPR void deactivate() noexcept
+        dynamic_allocator const & get() const noexcept
         {
-            tls::write_ptr<slot<E>>(prev_);
+            return da_;
         }
 
-        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
+        dynamic_allocator & get() noexcept
         {
-#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();
-                }
-#endif
+            return da_;
         }
 
-        using impl::put;
-        using impl::has_value;
-        using impl::value;
-    };
+        void activate() noexcept
+        {
+            prev_ = tls::read_ptr<slot<dynamic_allocator>>();
+            tls::write_ptr<slot<dynamic_allocator>>(this);
+        }
 
-#if BOOST_LEAF_CFG_DIAGNOSTICS
+        void deactivate() const noexcept
+        {
+            da_.deactivate();
+            tls::write_ptr<slot<dynamic_allocator>>(prev_);
+        }
 
-    template <class E>
-    BOOST_LEAF_CONSTEXPR inline void load_unexpected_count( int err_id ) noexcept
-    {
-        if( slot<e_unexpected_count> * sl = tls::read_ptr<slot<e_unexpected_count>>() )
+        void unload( int err_id )
         {
-            if( e_unexpected_count * unx = sl->has_value(err_id) )
-                ++unx->count;
-            else
-                sl->put(err_id, e_unexpected_count(&type<E>));
+            BOOST_LEAF_ASSERT(err_id);
+            da_.unload(err_id);
         }
-    }
 
-    template <class E>
-    BOOST_LEAF_CONSTEXPR inline void load_unexpected_info( int err_id, E && e ) noexcept
-    {
-        if( slot<e_unexpected_info> * sl = tls::read_ptr<slot<e_unexpected_info>>() )
+#if BOOST_LEAF_CFG_DIAGNOSTICS
+        template <class CharT, class Traits, class ErrorID>
+        void print(std::basic_ostream<CharT, Traits> &, ErrorID, char const * &) const
         {
-            if( e_unexpected_info * unx = sl->has_value(err_id) )
-                unx->add(std::forward<E>(e));
-            else
-                sl->put(err_id, e_unexpected_info()).add(std::forward<E>(e));
         }
-    }
+#endif
+    }; // slot specialization for dynamic_allocator
+} // namespace detail
 
-    template <class E>
-    BOOST_LEAF_CONSTEXPR inline void load_unexpected( int err_id, E && e  ) noexcept
+#endif // #if BOOST_LEAF_CFG_CAPTURE
+
+////////////////////////////////////////
+
+namespace detail
+{
+#if BOOST_LEAF_CFG_CAPTURE
+    inline dynamic_allocator * get_dynamic_allocator() noexcept
     {
-        load_unexpected_count<E>(err_id);
-        load_unexpected_info(err_id, std::forward<E>(e));
+        if( slot<dynamic_allocator> * sl = tls::read_ptr<slot<dynamic_allocator>>() )
+            return &sl->get();
+        return nullptr;
     }
-
 #endif
 
     template <class E>
-    BOOST_LEAF_CONSTEXPR inline void slot<E>::propagate( int err_id ) noexcept
+    inline slot<E> * get_slot() noexcept(!BOOST_LEAF_CFG_CAPTURE)
     {
-        if( this->key()!=err_id && err_id!=0 )
-            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));
-        }
+        static_assert(!std::is_pointer<E>::value, "Error objects of pointer types are not allowed");
+        static_assert(!std::is_same<E, error_id>::value, "Error objects of type error_id are not allowed");
+        if( slot<E> * p = tls::read_ptr<slot<E>>() )
+            return p;
+#if BOOST_LEAF_CFG_CAPTURE
+        if( dynamic_allocator * da = get_dynamic_allocator() )
+            return da->alloc<E>();
 #endif
+        return nullptr;
     }
 
     template <class E>
-    BOOST_LEAF_CONSTEXPR inline int load_slot( int err_id, E && e ) noexcept
+    inline void slot<E>::unload( int err_id ) noexcept(!BOOST_LEAF_CFG_CAPTURE)
     {
-        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);
-        if( slot<T> * p = tls::read_ptr<slot<T>>() )
-            (void) p->put(err_id, std::forward<E>(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::forward<E>(e));
-        }
-#endif
-        return 0;
+        BOOST_LEAF_ASSERT(err_id);
+        if( this->key() != err_id )
+            return;
+        if( impl * p = get_slot<E>() )
+            if( !p->has_value(err_id) )
+                *p = std::move(*this);
     }
 
-    template <class F>
-    BOOST_LEAF_CONSTEXPR inline int accumulate_slot( int err_id, F && f ) noexcept
+    template <class E>
+    BOOST_LEAF_CONSTEXPR inline int load_slot( int err_id, E && e ) noexcept(!BOOST_LEAF_CFG_CAPTURE)
     {
-        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);
-        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()));
-        }
+        using E_decayed = typename std::decay<E>::type;
+        BOOST_LEAF_ASSERT((err_id&3) == 1);
+        if( slot<E_decayed> * p = get_slot<E_decayed>() )
+            (void) p->load(err_id, std::forward<E>(e));
         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
+    template <class F>
+    BOOST_LEAF_CONSTEXPR inline int load_slot_deferred( int err_id, F && f )
     {
-        auto id = tls::read_uint32<tls_tag_id_factory_current_id>();
-        BOOST_LEAF_ASSERT(id==0 || (id&3)==1);
-        return id;
+        using E = typename function_traits<F>::return_type;
+        using E_decayed = typename std::decay<E>::type;
+        BOOST_LEAF_ASSERT((err_id&3) == 1);
+        if( slot<E_decayed> * p = get_slot<E_decayed>() )
+            (void) p->load(err_id, std::forward<F>(f)());
+        return 0;
     }
 
-    inline int new_id() noexcept
-    {
-        auto id = id_factory<>::generate_next_id();
-        tls::write_uint32<tls_tag_id_factory_current_id>(id);
-        return id;
+    template <class F>
+    BOOST_LEAF_CONSTEXPR inline int load_slot_accumulate( int err_id, F && f )
+    {
+        static_assert(function_traits<F>::arity == 1, "Lambdas passed to accumulate must take a single e-type argument by reference");
+        using E = fn_arg_type<F,0>;
+        using E_decayed = typename std::decay<E>::type;
+        BOOST_LEAF_ASSERT((err_id&3) == 1);
+        if( slot<E_decayed> * p = get_slot<E_decayed>() )
+            if( E_decayed * v = p->has_value(err_id) )
+                (void) std::forward<F>(f)(*v);
+            else
+                (void) std::forward<F>(f)(p->load(err_id, E_decayed()));
+        return 0;
     }
-}
+} // namespace detail
 
 ////////////////////////////////////////
 
-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 )
         {
             return load_slot(err_id, std::forward<E>(e));
         }
@@ -451,59 +545,134 @@ namespace leaf_detail
     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 )
         {
-            return load_slot(err_id, std::forward<F>(f)());
+            return load_slot_deferred(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 )
         {
-            return accumulate_slot(err_id, std::forward<F>(f));
+            return load_slot_accumulate(err_id, std::forward<F>(f));
         }
     };
 }
 
 ////////////////////////////////////////
 
+namespace detail
+{
+#if BOOST_LEAF_CFG_CAPTURE
+    class preloaded_base
+    {
+    protected:
+
+        preloaded_base() noexcept:
+            next_(
+                []( preloaded_base * this_ ) -> preloaded_base *
+                {
+                    if( dynamic_allocator * da = get_dynamic_allocator() )
+                        return da->link_preloaded_item(this_);
+                    return nullptr;
+                }(this))
+        {
+        }
+
+        ~preloaded_base() noexcept
+        {
+            if( dynamic_allocator * da = get_dynamic_allocator() )
+                da->unlink_preloaded_item(next_);
+            else
+                BOOST_LEAF_ASSERT(next_ == nullptr);
+        }
+
+    public:
+
+        preloaded_base * const next_;
+
+        virtual void reserve( dynamic_allocator & ) const = 0;
+    };
+#endif // #if BOOST_LEAF_CFG_CAPTURE
+
+    inline int current_id() noexcept
+    {
+        unsigned id = tls::read_current_error_id();
+        BOOST_LEAF_ASSERT(id == 0 || (id&3) == 1);
+        return int(id);
+    }
+
+    inline int new_id() noexcept
+    {
+        unsigned id = tls::generate_next_error_id();
+        tls::write_current_error_id(id);
+        return int(id);
+    }
+
+    inline int start_new_error() noexcept(!BOOST_LEAF_CFG_CAPTURE)
+    {
+#if BOOST_LEAF_CFG_CAPTURE
+        if( dynamic_allocator * da = get_dynamic_allocator() )
+            for( preloaded_base const * e = da->preloaded_list(); e; e = e->next_ )
+                e->reserve(*da);
+#endif
+        return new_id();
+    }
+
+    struct inject_loc
+    {
+        char const * file;
+        int line;
+        char const * fn;
+
+        template <class T>
+        friend T operator+( inject_loc loc, T && x ) noexcept(!BOOST_LEAF_CFG_CAPTURE)
+        {
+            x.load_source_location_(loc.file, loc.line, loc.fn);
+            return std::move(x);
+        }
+    };
+} // namespace detail
+
 #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(); }
+        bool equivalent( int,  std::error_condition const & ) const noexcept override { return false; }
+        bool equivalent( std::error_code const &, int ) const noexcept override { return false; }
+        char const * name() const noexcept override { return "LEAF error"; }
+        std::string message( int ) const override { return name(); }
     public:
-        ~leaf_category() noexcept final override { }
+        ~leaf_error_category() noexcept 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
+    inline int import_error_code( std::error_code const & ec ) noexcept(!BOOST_LEAF_CFG_CAPTURE)
     {
         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();
+                err_id = start_new_error();
                 (void) load_slot(err_id, ec);
                 return (err_id&~3)|1;
             }
@@ -511,33 +680,34 @@ namespace leaf_detail
         else
             return 0;
     }
-}
+} // namespace 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
+
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     BOOST_LEAF_CONSTEXPR error_id make_error_id(int) noexcept;
 }
 
-class BOOST_LEAF_SYMBOL_VISIBLE error_id
+class 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,35 +718,47 @@ 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(!BOOST_LEAF_CFG_CAPTURE):
+        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(!BOOST_LEAF_CFG_CAPTURE):
+        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
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     BOOST_LEAF_CONSTEXPR error_id load() const noexcept
     {
         return *this;
     }
 
+    template <class Item>
+    BOOST_LEAF_CONSTEXPR error_id load(Item && item) const
+    {
+        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
+    BOOST_LEAF_CONSTEXPR error_id load( Item && ... item ) const
     {
         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 +766,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,12 +791,12 @@ 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
+    BOOST_LEAF_CONSTEXPR void load_source_location_( char const * file, int line, char const * function ) const noexcept(!BOOST_LEAF_CFG_CAPTURE)
     {
         BOOST_LEAF_ASSERT(file&&*file);
         BOOST_LEAF_ASSERT(line>0);
@@ -627,105 +804,34 @@ class BOOST_LEAF_SYMBOL_VISIBLE error_id
         BOOST_LEAF_ASSERT(value_);
         (void) load(e_source_location {file,line,function});
     }
-};
+}; // class 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
+inline error_id new_error()
 {
-    return leaf_detail::make_error_id(leaf_detail::new_id());
+    return detail::make_error_id(detail::start_new_error());
 }
 
 template <class... Item>
-inline error_id new_error( Item && ... item ) noexcept
+inline error_id new_error( Item && ... item )
 {
-    return leaf_detail::make_error_id(leaf_detail::new_id()).load(std::forward<Item>(item)...);
+    return detail::make_error_id(detail::start_new_error()).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
@@ -737,6 +843,6 @@ struct is_result_type<R const>: is_result_type<R>
 {
 };
 
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef BOOST_LEAF_ERROR_HPP_INCLUDED
diff --git a/include/boost/leaf/exception.hpp b/include/boost/leaf/exception.hpp
index bda4dd77..36fb6fdf 100644
--- a/include/boost/leaf/exception.hpp
+++ b/include/boost/leaf/exception.hpp
@@ -1,26 +1,21 @@
 #ifndef BOOST_LEAF_EXCEPTION_HPP_INCLUDED
 #define BOOST_LEAF_EXCEPTION_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2025 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>
-
-#ifndef BOOST_LEAF_NO_EXCEPTIONS
-
-#include <exception>
-
-#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
+#include <typeinfo>
 
 ////////////////////////////////////////
 
+#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,77 +24,95 @@ 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::throw_exception_(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:
+    class exception final:
         public Ex,
         public exception_base,
         public error_id
     {
-        error_id get_error_id() const noexcept final override
+        mutable bool clear_current_error_;
+
+        bool is_current_exception() const noexcept
+        {
+            return tls::read_current_error_id() == unsigned(error_id::value());
+        }
+
+        error_id get_error_id() const noexcept 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 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_current_error_id(0);
+        }
+    }; // template exception
 
     template <class... T>
     struct at_least_one_derives_from_std_exception;
@@ -112,64 +125,71 @@ 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(!BOOST_LEAF_CFG_CAPTURE)
+    {
+        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(!BOOST_LEAF_CFG_CAPTURE)
+    {
+        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(!BOOST_LEAF_CFG_CAPTURE)
+    {
+        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(!BOOST_LEAF_CFG_CAPTURE)
+    {
+        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 leaf_detail::exception<std::exception> exception() noexcept
+    inline exception<std::exception> make_exception() noexcept
+    {
+        return exception<std::exception>(leaf::new_error());
+    }
+} // namespace detail
+
+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::throw_exception_.
+    throw_exception_(detail::make_exception(std::forward<E>(e)...));
 }
 
 ////////////////////////////////////////
 
 #ifndef BOOST_LEAF_NO_EXCEPTIONS
 
-template <class T>
-class 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());
     }
@@ -197,12 +217,12 @@ namespace leaf_detail
 
     template <class T>
     using deduce_exception_to_result_return_type = typename deduce_exception_to_result_return_type_impl<T>::type;
-}
+} // namespace detail
 
 template <class... Ex, class F>
 inline
-leaf_detail::deduce_exception_to_result_return_type<leaf_detail::fn_return_type<F>>
-exception_to_result( F && f ) noexcept
+detail::deduce_exception_to_result_return_type<detail::fn_return_type<F>>
+exception_to_result( F && f ) noexcept(!BOOST_LEAF_CFG_CAPTURE)
 {
     try
     {
@@ -210,7 +230,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(...)
     {
@@ -218,10 +238,8 @@ exception_to_result( F && f ) noexcept
     }
 }
 
-#endif
-
-} }
+#endif // #ifndef BOOST_LEAF_NO_EXCEPTIONS
 
-#endif
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef BOOST_LEAF_EXCEPTION_HPP_INCLUDED
diff --git a/include/boost/leaf/handle_errors.hpp b/include/boost/leaf/handle_errors.hpp
index c3c4e68b..6552e12d 100644
--- a/include/boost/leaf/handle_errors.hpp
+++ b/include/boost/leaf/handle_errors.hpp
@@ -1,78 +1,61 @@
 #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-2025 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;
+////////////////////////////////////////
 
 #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
+#endif // #ifndef BOOST_LEAF_NO_EXCEPTIONS
+
+////////////////////////////////////////
+
+class 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 +71,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 )
-    {
-        os << "leaf::error_info: ";
-        x.print(os);
-        return os << '\n';
-    }
-};
-
-////////////////////////////////////////
-
-#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)
+    BOOST_LEAF_CONSTEXPR e_source_location const * source_location() const noexcept
     {
+        return loc_;
     }
 
-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 // #ifndef BOOST_LEAF_NO_EXCEPTIONS
     }
 
-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';
     }
-};
+}; // class error_info
 
-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 +137,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>
@@ -397,7 +199,7 @@ namespace leaf_detail
                 return nullptr;
         }
     };
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     template <class E>
     struct peek_exception<E, true>
@@ -417,7 +219,7 @@ namespace leaf_detail
         }
     };
 
-#endif
+#endif // #ifndef BOOST_LEAF_NO_EXCEPTIONS
 
     template <class E, bool = does_not_participate_in_context_deduction<E>::value>
     struct peek_tuple;
@@ -487,11 +289,11 @@ namespace leaf_detail
         }
         return nullptr;
     }
-}
+} // namespace detail
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class A>
     template <class Tup>
@@ -542,11 +344,11 @@ namespace leaf_detail
             return handler_argument_traits<Car>::check(tup, ei) && check_arguments<Tup, Cdr...>::check(tup, ei);
         }
     };
-}
+} // namespace detail
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class>
     struct handler_matches_any_error: std::false_type
@@ -567,7 +369,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
@@ -667,7 +469,7 @@ namespace leaf_detail
             std::forward<Car>(car),
             std::forward<Cdr>(cdr)...);
     }
-}
+} // namespace detail
 
 ////////////////////////////////////////
 
@@ -679,7 +481,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 +492,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 +526,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 +546,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;
     }
 }
@@ -748,149 +567,253 @@ try_catch( TryBlock && try_block, H && ... ) noexcept
     return std::forward<TryBlock>(try_block)();
 }
 
-#else
+#else // #ifdef BOOST_LEAF_NO_EXCEPTIONS
 
-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;
                 } );
         }
     }
-}
+} // namespace 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,
-        [&]
-        {
-            return std::forward<TryBlock>(try_block)();
-        },
-        std::forward<H>(h)...);
+    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 // #else (#ifdef BOOST_LEAF_NO_EXCEPTIONS)
+
+#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 )
+        {
+            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.get().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.get().template extract_capture_list<leaf_result>(err_id);
+            }
+            catch(...)
+            {
+                sl.deactivate();
+                int err_id = current_error().value();
+                return sl.get().template extract_capture_list<leaf_result>(err_id);
+            }
+#endif // #ifndef BOOST_LEAF_NO_EXCEPTIONS
+        }
+    };
+
+    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 )
+        {
+            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.get().template extract_capture_list<leaf_result>(err_id);
+            }
+            catch(...)
+            {
+                sl.deactivate();
+                int err_id = current_error().value();
+                return sl.get().template extract_capture_list<leaf_result>(err_id);
+            }
+#endif // #ifndef BOOST_LEAF_NO_EXCEPTIONS
+        }
+    };
+} // namespace detail
+
+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 // #if BOOST_LEAF_CFG_CAPTURE
 
-} }
+} } // namespace boost::leaf
 
 // Boost Exception Integration
 
@@ -900,7 +823,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 +849,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) )
@@ -950,8 +873,8 @@ namespace leaf_detail
     template <class Tag, class T> struct handler_argument_traits<boost::error_info<Tag, T> const *>: handler_argument_traits_require_by_value<boost::error_info<Tag, T>> { };
     template <class Tag, class T> struct handler_argument_traits<boost::error_info<Tag, T> &>: handler_argument_traits_require_by_value<boost::error_info<Tag, T>> { };
     template <class Tag, class T> struct handler_argument_traits<boost::error_info<Tag, T> *>: handler_argument_traits_require_by_value<boost::error_info<Tag, T>> { };
-}
+} // namespace detail
 
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef BOOST_LEAF_HANDLE_ERRORS_HPP_INCLUDED
diff --git a/include/boost/leaf/on_error.hpp b/include/boost/leaf/on_error.hpp
index c41d7fc5..4831226d 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-2025 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,19 @@ class error_monitor
 #   else
             if( std::uncaught_exception() )
 #   endif
-                return leaf_detail::new_id();
+#   if BOOST_LEAF_CFG_CAPTURE
+                try
+                {
+                    return detail::start_new_error();
+                }
+                catch(...)
+                {
+                    BOOST_LEAF_ASSERT(detail::current_id() == err_id_);
+                    return detail::new_id();
+                }
+#   else
+                return detail::start_new_error();
+#   endif
 #endif
             return 0;
         }
@@ -49,113 +60,157 @@ 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());
     }
-};
+}; // class error_monitor
 
-////////////////////////////////////////////
+////////////////////////////////////////
 
-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);
         }
+
+#if BOOST_LEAF_CFG_CAPTURE
+        static void reserve( Tup const & tup, dynamic_allocator & da )
+        {
+            tuple_for_each_preload<I-1,Tup>::reserve(tup,da);
+            std::get<I-1>(tup).reserve(da);
+        }
+#endif
     };
 
-    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 { }
+
+#if BOOST_LEAF_CFG_CAPTURE
+        static void reserve( Tup const &, dynamic_allocator & ) { }
+#endif
     };
 
     template <class E>
     class preloaded_item
     {
-        using decay_E = typename std::decay<E>::type;
-        slot<decay_E> * s_;
-        decay_E e_;
+        using E_decayed = typename std::decay<E>::type;
+        E_decayed 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_));
-            }
+            if( slot<E_decayed> * p = tls::read_ptr<slot<E_decayed>>() )
+                if( !p->has_value(err_id) )
+                    (void) p->load(err_id, std::move(e_));
+        }
+
+#if BOOST_LEAF_CFG_CAPTURE
+        void reserve( dynamic_allocator & da ) const
+        {
+            da.reserve<E_decayed>();
+        }
+#endif
+    };
+
+    template <class F, class ReturnType = typename function_traits<F>::return_type>
+    class deferred_item
+    {
+        using E_decayed = typename std::decay<ReturnType>::type;
+        F f_;
+
+    public:
+
+        BOOST_LEAF_CONSTEXPR deferred_item( F && f ):
+            f_(std::forward<F>(f))
+        {
+        }
+
+        void trigger( int err_id ) noexcept
+        {
+            if( slot<E_decayed> * p = tls::read_ptr<slot<E_decayed>>() )
+                if( !p->has_value(err_id) )
+                {
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+                    try
+                    {
+#endif
+                        (void) p->load(err_id, f_());
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+                    }
+                    catch(...)
+                    {
+                    }
 #endif
+                }
         }
+
+#if BOOST_LEAF_CFG_CAPTURE
+        void reserve( dynamic_allocator & da ) const
+        {
+            da.reserve<E_decayed>();
+        }
+#endif
     };
 
     template <class F>
-    class deferred_item
+    class deferred_item<F, void>
     {
-        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
+        void trigger( int ) noexcept
         {
-            BOOST_LEAF_ASSERT((err_id&3)==1);
-            if( s_ )
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+            try
             {
-                if( !s_->has_value(err_id) )
-                    s_->put(err_id, f_());
+#endif
+                f_();
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
             }
-#if BOOST_LEAF_CFG_DIAGNOSTICS
-            else
+            catch(...)
             {
-                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
         }
+
+#if BOOST_LEAF_CFG_CAPTURE
+        void reserve( dynamic_allocator & ) const
+        {
+        }
+#endif
     };
 
     template <class F, class A0 = fn_arg_type<F,0>, int arity = function_traits<F>::arity>
@@ -164,60 +219,89 @@ namespace leaf_detail
     template <class F, class A0>
     class accumulating_item<F, A0 &, 1>
     {
-        using E = A0;
-        slot<E> * s_;
+        using E_decayed = typename std::decay<A0>::type;
         F f_;
 
     public:
 
-        BOOST_LEAF_CONSTEXPR accumulating_item( F && f ) noexcept:
-            s_(tls::read_ptr<slot<E>>()),
+        BOOST_LEAF_CONSTEXPR accumulating_item( F && f ):
             f_(std::forward<F>(f))
         {
         }
 
-        BOOST_LEAF_CONSTEXPR void trigger( int err_id ) noexcept
+        void trigger( int err_id ) noexcept
         {
-            BOOST_LEAF_ASSERT((err_id&3)==1);
-            if( s_ )
+            if( slot<E_decayed> * p = tls::read_ptr<slot<E_decayed>>() )
             {
-                if( E * e = s_->has_value(err_id) )
-                    (void) f_(*e);
-                else
-                    (void) f_(s_->put(err_id, E()));
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+                try
+                {
+#endif
+                    if( E_decayed * v = p->has_value(err_id) )
+                        (void) std::move(f_)(*v);
+                    else
+                        (void) std::move(f_)(p->load(err_id, E_decayed()));
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+                }
+                catch(...)
+                {
+                }
+#endif
             }
         }
+
+#if BOOST_LEAF_CFG_CAPTURE
+        void reserve( dynamic_allocator & da ) const
+        {
+            da.reserve<E_decayed>();
+        }
+#endif
     };
 
     template <class... Item>
     class preloaded
+#if BOOST_LEAF_CFG_CAPTURE
+        : preloaded_base
+#endif
     {
+        preloaded( preloaded const & ) = delete;
         preloaded & operator=( preloaded const & ) = delete;
 
         std::tuple<Item...> p_;
-        bool moved_;
         error_monitor id_;
+#if __cplusplus < 201703L
+        bool moved_ = false;
+#endif
+
+#if BOOST_LEAF_CFG_CAPTURE
+        void reserve( dynamic_allocator & da ) const override
+        {
+            tuple_for_each_preload<sizeof...(Item),decltype(p_)>::reserve(p_,da);
+        }
+#endif
 
     public:
 
         BOOST_LEAF_CONSTEXPR explicit preloaded( Item && ... i ):
-            p_(std::forward<Item>(i)...),
-            moved_(false)
+            p_(std::forward<Item>(i)...)
         {
         }
 
+#if __cplusplus < 201703L
         BOOST_LEAF_CONSTEXPR preloaded( preloaded && x ) noexcept:
             p_(std::move(x.p_)),
-            moved_(false),
             id_(std::move(x.id_))
         {
             x.moved_ = true;
         }
+#endif
 
         ~preloaded() noexcept
         {
+#if __cplusplus < 201703L
             if( moved_ )
                 return;
+#endif
             if( auto id = id_.check_id() )
                 tuple_for_each_preload<sizeof...(Item),decltype(p_)>::trigger(p_,id);
         }
@@ -243,16 +327,16 @@ namespace leaf_detail
     {
         using type = accumulating_item<F>;
     };
-}
+} // namespace 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)...);
 }
 
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef BOOST_LEAF_ON_ERROR_HPP_INCLUDED
diff --git a/include/boost/leaf/pred.hpp b/include/boost/leaf/pred.hpp
index 01ecf47e..a00e8617 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-2025 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>
@@ -34,7 +33,7 @@ namespace leaf_detail
         BOOST_LEAF_ASSERT(P != nullptr);
         return P(e);
     }
-#endif
+#endif // #if __cplusplus >= 201703L
 
     template <class MatchType, class V>
     BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE bool cmp_value_pack( MatchType const & e, V v )
@@ -47,7 +46,7 @@ namespace leaf_detail
     {
         return cmp_value_pack(e, car) || cmp_value_pack(e, cdr...);
     }
-}
+} // namespace detail
 
 ////////////////////////////////////////
 
@@ -72,11 +71,11 @@ BOOST_LEAF_CONSTEXPR inline bool category( std::error_code const & ec )
     return &ec.category() == &std::error_code(ErrorCodeEnum{}).category();
 }
 #endif
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     template <class T>
     struct match_enum_type
@@ -96,7 +95,7 @@ namespace leaf_detail
     {
         static_assert(sizeof(Enum) == 0, "leaf::condition<E, Enum> should be used with leaf::match_value<>, not with leaf::match<>");
     };
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 }
 
 template <class E, BOOST_LEAF_MATCH_ARGS(match_enum_type<E>, V1, V)>
@@ -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,10 +120,10 @@ 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
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 template <class E, BOOST_LEAF_MATCH_ARGS(match_enum_type<E>, V1, V)>
 struct is_predicate<match<E, V1, V...>>: std::true_type
@@ -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,9 +150,9 @@ 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
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 }
 
 template <class E, BOOST_LEAF_MATCH_ARGS(match_value_enum_type<E>, V1, V)>
@@ -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,10 +176,10 @@ 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
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 template <class E, BOOST_LEAF_MATCH_ARGS(match_value_enum_type<E>, V1, V)>
 struct is_predicate<match_value<E, V1, V...>>: std::true_type
@@ -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...);
     }
 };
 
@@ -209,7 +208,7 @@ template <auto P, auto V1, auto... V>
 struct is_predicate<match_member<P, V1, V...>>: std::true_type
 {
 };
-#endif
+#endif // #if __cplusplus >= 201703L
 
 ////////////////////////////////////////
 
@@ -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)...);
     }
 };
 
@@ -290,8 +289,8 @@ struct is_predicate<catch_<Ex...>>: std::true_type
 {
 };
 
-#endif
+#endif // #ifndef BOOST_LEAF_NO_EXCEPTIONS
 
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef BOOST_LEAF_PRED_HPP_INCLUDED
diff --git a/include/boost/leaf/result.hpp b/include/boost/leaf/result.hpp
index f2ad7e11..20d7cac8 100644
--- a/include/boost/leaf/result.hpp
+++ b/include/boost/leaf/result.hpp
@@ -1,58 +1,85 @@
 #ifndef BOOST_LEAF_RESULT_HPP_INCLUDED
 #define BOOST_LEAF_RESULT_HPP_INCLUDED
 
-// Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
-
+// Copyright 2018-2025 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 {
 
+////////////////////////////////////////
+
 class bad_result:
-    public std::exception,
-    public error_id
+    public std::exception
 {
-    char const * what() const noexcept final override
+    char const * what() const noexcept override
     {
         return "boost::leaf::bad_result";
     }
+};
 
-public:
+////////////////////////////////////////
 
-    explicit bad_result( error_id id ) noexcept:
-        error_id(id)
+namespace detail
+{
+    template <class T, bool Printable = is_printable<T>::value>
+    struct result_value_printer;
+
+    template <class T>
+    struct result_value_printer<T, true>
     {
-        BOOST_LEAF_ASSERT(value());
+        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}");
+        }
+    };
+
+    template <class CharT, class Traits, class T>
+    void print_result_value( std::basic_ostream<CharT, Traits> & s, T const & x )
+    {
+        result_value_printer<T>::print(s, x);
     }
-};
+} // namespace detail
 
 ////////////////////////////////////////
 
-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 +89,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 +109,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,21 +152,43 @@ 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));
         }
-    };
-}
+    }; // class result_discriminant
+} // namespace detail
 
 ////////////////////////////////////////
 
 template <class T>
-class result
+class BOOST_LEAF_ATTRIBUTE_NODISCARD result
 {
     template <class U>
     friend class result;
 
-    using result_discriminant = leaf_detail::result_discriminant;
+#if BOOST_LEAF_CFG_CAPTURE
+    friend class detail::dynamic_allocator;
+    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 +206,52 @@ 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);
+                    (void) k;
+                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);
+            (void) k;
+        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 +259,30 @@ 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);
+            (void) k;
+        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 +297,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 +372,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,29 +403,29 @@ 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{})
     {
     }
 
-#else
+#else // #if defined(BOOST_STRICT_CONFIG) || !defined(__clang__)
 
 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{})
     {
     }
 
-#endif
+#endif // #else (#if defined(BOOST_STRICT_CONFIG) || !defined(__clang__))
 
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
     result( std::error_code const & ec ) noexcept:
@@ -357,38 +433,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
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     ~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;
     }
 
@@ -421,7 +489,7 @@ class result
         return stored_;
     }
 
-#else
+#else // #ifdef BOOST_LEAF_NO_CXX11_REF_QUALIFIERS
 
     value_cref value() const &
     {
@@ -447,16 +515,16 @@ class result
         return std::move(stored_);
     }
 
-#endif
+#endif // #else (#ifdef BOOST_LEAF_NO_CXX11_REF_QUALIFIERS)
 
-    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
@@ -475,7 +543,7 @@ class result
         return *p;
     }
 
-#else
+#else // #ifdef BOOST_LEAF_NO_CXX11_REF_QUALIFIERS
 
     value_cref operator*() const & noexcept
     {
@@ -505,7 +573,7 @@ class result
         return std::move(*p);
     }
 
-#endif
+#endif // #else (#ifdef BOOST_LEAF_NO_CXX11_REF_QUALIFIERS)
 
     error_result error() noexcept
     {
@@ -513,39 +581,62 @@ class result
     }
 
     template <class... Item>
-    error_id load( Item && ... item ) noexcept
+    error_id load( Item && ... item ) noexcept(!BOOST_LEAF_CFG_CAPTURE)
     {
         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;
+    }
+}; // template result
 
 ////////////////////////////////////////
 
-namespace leaf_detail
+namespace detail
 {
     struct void_ { };
 }
 
 template <>
-class result<void>:
-    result<leaf_detail::void_>
+class 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))
+    using result_discriminant = detail::result_discriminant;
+    using void_ = detail::void_;
+    using base = result<void_>;
+
+#if BOOST_LEAF_CFG_CAPTURE
+    friend class detail::dynamic_allocator;
+
+    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 +657,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
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
-#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,12 +695,23 @@ 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;
+}; // result specialization for void
 
 ////////////////////////////////////////
 
@@ -621,6 +723,6 @@ struct is_result_type<result<T>>: std::true_type
 {
 };
 
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #ifndef BOOST_LEAF_RESULT_HPP_INCLUDED
diff --git a/include/boost/leaf/to_variant.hpp b/include/boost/leaf/to_variant.hpp
index 83a23b4c..7f20c475 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-2025 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,8 +42,8 @@ to_variant( TryBlock && try_block )
         } );
 }
 
-} }
+} } // namespace boost::leaf
 
-#endif
+#endif // #if __cplusplus >= 201703L
 
-#endif
+#endif // #ifndef BOOST_LEAF_TO_VARIANT_HPP_INCLUDED
diff --git a/meson.build b/meson.build
index 0ac746f5..b0250da8 100644
--- a/meson.build
+++ b/meson.build
@@ -1,38 +1,36 @@
-# Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
+# Copyright 2018-2025 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_boost = get_option('leaf_boost_examples')
-option_lua = get_option('leaf_lua_examples')
+option_single_header = get_option('leaf_single_header')
+option_boost_available = get_option('leaf_boost_available')
 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
-    if option_boost
-        error('The option leaf_boost_examples requires leaf_enable_examples. Aborting.')
-    endif
-    if option_lua
-        error('The option leaf_lua_examples requires leaf_enable_examples. Aborting.')
-    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()
-    if option_boost
+    if option_boost_available
         add_global_arguments(
             '-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 +41,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'
@@ -76,16 +78,19 @@ if not meson.is_subproject()
 endif
 
 dep_boost = [ ]
-if option_boost # Requires that LEAF resides under boost_root/libs/leaf.
+if option_boost_available # Requires that LEAF resides under boost_root/libs/leaf.
     dep_boost = declare_dependency(include_directories: '../..')
 endif
 
 dep_lua = [ ]
-if option_lua
+if option_enable_examples
     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,67 +105,79 @@ 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',
         'error_id_test',
         '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_alloc_fail_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_dynamic_reserve_test1',
+        'on_error_dynamic_reserve_test2',
+        'on_error_dynamic_reserve_test3',
+        '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,19 +185,20 @@ 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',
         'try_exception_and_result_test',
     ]
-    if option_boost and option_exceptions
+    if option_boost_available and option_exceptions
         tests += [
             'boost_exception_test'
         ]
     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
 
@@ -188,47 +206,44 @@ if option_enable_unit_tests
         test(t, executable(t, 'test/'+t+'.cpp', dependencies: [leaf, dep_thread, dep_boost, dep_test_single_header]) )
     endforeach
 
+    if target_machine.system() == 'windows'
+        dep_e_LastError = declare_dependency(compile_args: ['-DBOOST_LEAF_CFG_WIN32=1'])
+        test('e_LastError_test', executable('e_LastError_test', 'test/e_LastError_test.cpp', dependencies: [leaf, dep_thread, dep_boost, dep_test_single_header, dep_e_LastError]) )
+    endif
+
     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]) )
     endforeach
 
-endif
-
-#################################
-
-if option_enable_examples
-
-    print_file_examples = [
-        'print_file_result'
-    ]
-    if option_exceptions
-        print_file_examples += [
-            'print_file_eh'
-        ]
-    endif
-    if option_boost
-        print_file_examples += [
-            'print_file_outcome_result'
-        ]
+    # Shared library test
+    dep_so_dll = []
+    if target_machine.system() == 'windows'
+        dep_so_dll = declare_dependency(compile_args: ['-DBOOST_LEAF_CFG_WIN32=2'])
     endif
+    so_dll_test_lib1 = shared_library('so_dll_test_lib1', 'test/so_dll_lib1.cpp', dependencies: [leaf, dep_so_dll], gnu_symbol_visibility: 'hidden')
+    so_dll_test_lib2 = shared_library('so_dll_test_lib2', 'test/so_dll_lib2.cpp', dependencies: [leaf, dep_so_dll], gnu_symbol_visibility: 'hidden')
+    test('so_dll_test', executable('so_dll_test', 'test/so_dll_test.cpp', dependencies: [leaf, dep_so_dll], link_with: [so_dll_test_lib1, so_dll_test_lib2]))
 
-    foreach e : print_file_examples
-        executable(e, 'example/print_file/'+e+'.cpp', dependencies: [leaf, dep_thread, dep_boost] )
-    endforeach
+    # Test that the DLL test works when linked statically as well.
+    # This is to verify that we don't get multiply defined symbol link errors when tls_win32.hpp is included in multiple compilation units..
+    dep_so_dll_static = declare_dependency(compile_args: ['-DBOOST_LEAF_SO_DLL_TEST_STATIC'])
+    so_dll_static_lib1 = static_library('so_dll_static_lib1', 'test/so_dll_lib1.cpp', dependencies: [leaf, dep_so_dll, dep_so_dll_static])
+    so_dll_static_lib2 = static_library('so_dll_static_lib2', 'test/so_dll_lib2.cpp', dependencies: [leaf, dep_so_dll, dep_so_dll_static])
+    test('so_dll_static_test', executable('so_dll_static_test', 'test/so_dll_test.cpp', dependencies: [leaf, dep_so_dll, dep_so_dll_static], link_with: [so_dll_static_lib1, so_dll_static_lib2]))
 
 endif
 
@@ -236,58 +251,28 @@ endif
 
 if option_enable_examples
 
-    examples = [
-        'capture_in_result',
-        'error_log',
-        'error_trace',
-        'print_half'
-    ]
+    executable('print_file_leaf_result', 'example/print_file/print_file_leaf_result.cpp', dependencies: [leaf] )
     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
+        executable('print_file_exceptions', 'example/print_file/print_file_exceptions.cpp', dependencies: [leaf] )
     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.')
+    if option_boost_available
+        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_enable_examples
+        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..f5a115b4 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -1,8 +1,7 @@
-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('leaf_lua_examples',type:'boolean',value:false,description:'Enable or disable downloading of Lua and building the Lua examples')
+option('leaf_single_header',type:'boolean',value:false,description:'Unit tests #include "leaf.hpp" instead of individual headers')
+option('leaf_boost_available',type:'boolean',value:false,description:'Set to true to enable tests and examples that require Boost')
 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/subprojects/.wraplock b/subprojects/.wraplock
new file mode 100644
index 00000000..e69de29b
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..cff2af9c 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -1,120 +1,145 @@
-# 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
+        <library>/boost/config//boost_config
+        <use>/boost/exception//boost_exception
         <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 ;
+run e_LastError_test.cpp : : : <target-os>windows:<define>BOOST_LEAF_CFG_WIN32=1 ;
+run error_code_test.cpp : : : <toolset>clang-darwin,<exception-handling>off,<rtti>off:<linkflags>"-Wl,-ld_classic" ; # workaround for macos-14 linker bug
 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_alloc_fail_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_dynamic_reserve_test1.cpp ;
+run on_error_dynamic_reserve_test2.cpp ;
+run on_error_dynamic_reserve_test3.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 ;
 
-lib visibility_test_lib : visibility_test_lib.cpp : <visibility>hidden ;
-run visibility_test.cpp visibility_test_lib/<link>shared ;
-run visibility_test.cpp visibility_test_lib/<link>static : : : <target-os>windows ; # This can't work on Windows, so use static link for the test.
+lib so_dll_lib1 : so_dll_lib1.cpp : <link>shared <visibility>hidden <target-os>windows:<define>BOOST_LEAF_CFG_WIN32=2 : : <target-os>windows:<define>BOOST_LEAF_CFG_WIN32=2 ;
+lib so_dll_lib2 : so_dll_lib2.cpp : <link>shared <visibility>hidden <target-os>windows:<define>BOOST_LEAF_CFG_WIN32=2 : : <target-os>windows:<define>BOOST_LEAF_CFG_WIN32=2 ;
+run so_dll_test.cpp so_dll_lib1 so_dll_lib2 : : : <target-os>windows:<define>BOOST_LEAF_CFG_WIN32=2 ;
+
+lib so_dll_static_lib1 : so_dll_lib1.cpp : <link>static <define>BOOST_LEAF_SO_DLL_TEST_STATIC <target-os>windows:<define>BOOST_LEAF_CFG_WIN32=2 ;
+lib so_dll_static_lib2 : so_dll_lib2.cpp : <link>static <define>BOOST_LEAF_SO_DLL_TEST_STATIC <target-os>windows:<define>BOOST_LEAF_CFG_WIN32=2 ;
+run so_dll_test.cpp so_dll_static_lib1 so_dll_static_lib2 : : : <define>BOOST_LEAF_SO_DLL_TEST_STATIC <target-os>windows:<define>BOOST_LEAF_CFG_WIN32=2 : so_dll_static_test ;
 
 compile-fail _compile-fail-arg_boost_error_info_1.cpp ;
 compile-fail _compile-fail-arg_boost_error_info_2.cpp ;
@@ -125,8 +150,10 @@ 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-error_obj_ptr.cpp ;
 compile-fail _compile-fail-exception_1.cpp ;
 compile-fail _compile-fail-exception_2.cpp ;
 compile-fail _compile-fail-new_error.cpp ;
@@ -134,16 +161,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-error_obj_ptr.cpp b/test/_compile-fail-error_obj_ptr.cpp
new file mode 100644
index 00000000..90592677
--- /dev/null
+++ b/test/_compile-fail-error_obj_ptr.cpp
@@ -0,0 +1,13 @@
+// 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>
+
+namespace leaf = boost::leaf;
+
+void f()
+{
+    int x;
+    (void) leaf::new_error(&x);
+}
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..1d868309 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);
             }
         }
     }
@@ -161,4 +155,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #if defined(BOOST_LEAF_NO_EXCEPTIONS) || defined(BOOST_LEAF_NO_THREADS) || !BOOST_LEAF_CFG_CAPTURE
diff --git a/test/capture_exception_result_async_test.cpp b/test/capture_exception_result_async_test.cpp
index 48df5ead..40b95263 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);
             }
         }
     }
@@ -160,4 +154,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #if defined(BOOST_LEAF_NO_EXCEPTIONS) || defined(BOOST_LEAF_NO_THREADS) || !BOOST_LEAF_CFG_CAPTURE
diff --git a/test/capture_exception_result_unload_test.cpp b/test/capture_exception_result_unload_test.cpp
new file mode 100644
index 00000000..f7ae54f4
--- /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 // #if defined(BOOST_LEAF_NO_EXCEPTIONS) || !BOOST_LEAF_CFG_CAPTURE
diff --git a/test/capture_exception_state_test.cpp b/test/capture_exception_state_test.cpp
index 9e3b9cfa..9b1bc2f9 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,46 +52,56 @@ 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 // #if BOOST_LEAF_CFG_STD_STRING
+
+        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);
+        BOOST_TEST_EQ(ret, 42);
     }
-    catch(...)
-    {
-        ep = std::current_exception();
-    }
-    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();
 }
 
-#endif
+#endif // #if defined(BOOST_LEAF_NO_EXCEPTIONS) || !BOOST_LEAF_CFG_CAPTURE
diff --git a/test/capture_exception_unload_test.cpp b/test/capture_exception_unload_test.cpp
index c784c831..a4620536 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,84 +118,69 @@ void test( F f_ )
             } );
         BOOST_TEST_EQ(what, 2);
     }
+}
 
+int main()
+{
+    test( []
     {
-        auto ep = f();
-        bool what = leaf::try_catch(
-            [&ep]
+        return leaf::try_capture_all(
+            []() -> int
             {
-                std::rethrow_exception(ep); return true;
-            },
-            []( info<1> const & x, info<2> const & )
-            {
-                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();
 }
 
-#endif
+#endif // #if defined(BOOST_LEAF_NO_EXCEPTIONS) || !BOOST_LEAF_CFG_CAPTURE
diff --git a/test/capture_result_async_test.cpp b/test/capture_result_async_test.cpp
index c6166dc5..e01ee98d 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 )
@@ -159,4 +156,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #if defined(BOOST_LEAF_NO_THREADS) || !BOOST_LEAF_CFG_CAPTURE
diff --git a/test/capture_result_state_test.cpp b/test/capture_result_state_test.cpp
index 1d116231..02ed44c0 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,40 +51,56 @@ 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 // #if BOOST_LEAF_CFG_STD_STRING
+
+        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);
 
     return boost::report_errors();
 }
 
-#endif
+#endif // #if !BOOST_LEAF_CFG_CAPTURE
diff --git a/test/capture_result_unload_test.cpp b/test/capture_result_unload_test.cpp
index add325c0..1397d63b 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,15 +134,34 @@ 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();
 }
 
-#endif
+#endif // #if !BOOST_LEAF_CFG_CAPTURE
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..bc1f559c
--- /dev/null
+++ b/test/diagnostics_test4.cpp
@@ -0,0 +1,74 @@
+// 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();
+}
+
+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("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..26841e2c 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)
 
@@ -9,13 +8,15 @@
 
 int main()
 {
-    std::cout << "This test requires Windows";
+    std::cout << "Test skipped (Windows only)";
     return 0;
 }
 
 #else
 
-#define BOOST_LEAF_CFG_WIN32 1
+#if BOOST_LEAF_CFG_WIN32 <= 0
+#   error This test requires BOOST_LEAF_CFG_WIN32 > 0
+#endif
 
 #ifdef BOOST_LEAF_TEST_SINGLE_HEADER
 #   include "leaf.hpp"
@@ -25,8 +26,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 +39,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(
@@ -60,4 +69,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifndef _WIN32
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..162ea5dc 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)
 
@@ -15,12 +14,12 @@ int main()
     return 0;
 }
 
-#else
+#else // #if !BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 #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,13 @@ int main()
 #include "_test_res.hpp"
 #include "lightweight_test.hpp"
 
+#if BOOST_LEAF_BOOST_AVAILABLE
+#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 { };
+} }
+#endif
+
 namespace leaf = boost::leaf;
 
 struct e_wrapped_error_code { std::error_code value; };
@@ -93,7 +99,7 @@ void test()
             } );
         BOOST_TEST_EQ(r, 42);
     }
-#endif
+#endif // #if __cplusplus >= 201703L
 
     {
         int r = leaf::try_handle_all(
@@ -150,7 +156,7 @@ void test()
             } );
         BOOST_TEST_EQ(r, 42);
     }
-#endif
+#endif // #if __cplusplus >= 201703L
     {
         int r = leaf::try_handle_all(
             []() -> R
@@ -179,7 +185,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 +205,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;
             },
             []
@@ -208,13 +214,13 @@ void test()
             } );
         BOOST_TEST_EQ(r, 42);
     }
-#endif
+#endif // #if __cplusplus >= 201703L
 
     {
         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 +238,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 +258,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 )
             {
@@ -267,19 +273,19 @@ void test()
             } );
         BOOST_TEST_EQ(r, 42);
     }
-#endif
+#endif // #if __cplusplus >= 201703L
     {
         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 +299,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;
             },
             []
@@ -309,7 +315,7 @@ void test()
             } );
         BOOST_TEST_EQ(r, 42);
     }
-#endif
+#endif // #if __cplusplus >= 201703L
 }
 
 template <class R>
@@ -376,7 +382,7 @@ void test_void()
             } );
         BOOST_TEST_EQ(r, 42);
     }
-#endif
+#endif // #if __cplusplus >= 201703L
 
     {
         int r = 0;
@@ -436,7 +442,7 @@ void test_void()
             } );
         BOOST_TEST_EQ(r, 42);
     }
-#endif
+#endif // #if __cplusplus >= 201703L
     {
         int r = 0;
         leaf::try_handle_all(
@@ -467,7 +473,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 +494,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;
             },
             [&]
@@ -497,14 +503,14 @@ void test_void()
             } );
         BOOST_TEST_EQ(r, 42);
     }
-#endif
+#endif // #if __cplusplus >= 201703L
 
     {
         int r = 0;
         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 +529,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 +550,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 )
             {
@@ -559,20 +565,20 @@ void test_void()
             } );
         BOOST_TEST_EQ(r, 42);
     }
-#endif
+#endif // #if __cplusplus >= 201703L
     {
         int r = 0;
         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 +593,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;
             },
             [&]
@@ -603,7 +609,7 @@ void test_void()
             } );
         BOOST_TEST_EQ(r, 42);
     }
-#endif
+#endif // #if __cplusplus >= 201703L
 }
 
 int main()
@@ -612,7 +618,10 @@ int main()
     test<test_res<int, std::error_code>>();
     test_void<leaf::result<void>>();
     test_void<test_res<void, std::error_code>>();
+#ifdef BOOST_LEAF_BOOST_AVAILABLE
+    test<boost::system::result<int, std::error_code>>();
+#endif
     return boost::report_errors();
 }
 
-#endif
+#endif // #if !BOOST_LEAF_CFG_STD_SYSTEM_ERROR
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..f915863a 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;
             },
@@ -308,4 +291,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
diff --git a/test/exception_to_result_test.cpp b/test/exception_to_result_test.cpp
index c5838755..0168ba5e 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)
 
@@ -129,4 +128,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
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..665c342c 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});
@@ -53,11 +52,11 @@ leaf::result<R> f_errc_wrapped( Errc ec )
 {
     return leaf::new_error(e_std_error_code{make_error_code(ec)}, info<1>{1}, info<2>{2}, info<3>{3});
 }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 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);
@@ -143,7 +142,7 @@ int main()
             } );
         BOOST_TEST_EQ(c, 2);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
     // void, try_handle_all (failure), match cond_x (wrapped std::error_code)
@@ -176,7 +175,7 @@ int main()
             } );
         BOOST_TEST_EQ(c, 2);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     // void, try_handle_all (failure), match enum (single enum value)
     {
@@ -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;
@@ -367,7 +366,7 @@ int main()
             } );
         BOOST_TEST_EQ(r, 2);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
     // int, try_handle_all (failure), match cond_x (wrapped std::error_code)
@@ -395,7 +394,7 @@ int main()
             } );
         BOOST_TEST_EQ(r, 2);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     // int, try_handle_all (failure), match enum (single enum value)
     {
@@ -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);
@@ -566,7 +565,7 @@ int main()
             } );
         BOOST_TEST_EQ(r.value, 2);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
     // move_only, try_handle_all (failure), match cond_x (wrapped std::error_code)
@@ -594,7 +593,7 @@ int main()
             } );
         BOOST_TEST_EQ(r.value, 2);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     // move_only, try_handle_all (failure), match enum (single enum value)
     {
@@ -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..051d6d52 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});
@@ -53,7 +52,7 @@ leaf::result<R> f_errc_wrapped( Errc ec )
 {
     return leaf::new_error(e_std_error_code{make_error_code(ec)}, info<1>{1}, info<2>{2}, info<3>{3});
 }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 int main()
 {
@@ -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);
@@ -121,7 +120,7 @@ int main()
         BOOST_TEST_EQ(c, 1);
         BOOST_TEST(r);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
     // void, try_handle_some (failure, matched), match cond_x (wrapped std::error_code)
@@ -145,7 +144,7 @@ int main()
         BOOST_TEST_EQ(c, 1);
         BOOST_TEST(r);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     // void, try_handle_some (failure, matched), match enum (single enum value)
     {
@@ -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,14 +323,14 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
             } );
         BOOST_TEST_EQ(c, 2);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
     // void, try_handle_some (failure, initially not matched), match cond_x (wrapped std::error_code)
@@ -364,14 +363,14 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
             } );
         BOOST_TEST_EQ(c, 2);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     // void, try_handle_some (failure, initially not matched), match enum (single enum value)
     {
@@ -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,14 +593,14 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
             } );
         BOOST_TEST_EQ(c, 1);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
     // void, try_handle_some (failure, initially matched), match cond_x (wrapped std::error_code)
@@ -634,14 +633,14 @@ int main()
                 BOOST_TEST_EQ(c, 0);
                 c = 2;
             },
-            [&c]()
+            [&c]
             {
                 BOOST_TEST_EQ(c, 0);
                 c = 3;
             } );
         BOOST_TEST_EQ(c, 1);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     // void, try_handle_some (failure, initially matched), match enum (single enum value)
     {
@@ -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;
@@ -854,7 +853,7 @@ int main()
         BOOST_TEST(r);
         BOOST_TEST_EQ(*r, 2);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     // int, try_handle_some (failure, matched), match enum (single enum value)
     {
@@ -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 )
             {
@@ -1012,14 +1011,48 @@ int main()
             } );
         BOOST_TEST_EQ(r, 2);
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+
+#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 // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
     // 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
+
+#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 // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
+
     // 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
+
+#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 // #ifndef BOOST_LEAF_NO_EXCEPTIONS
+
     return boost::report_errors();
 }
diff --git a/test/lightweight_test.hpp b/test/lightweight_test.hpp
index 7b7ffd47..e3bf0bb1 100644
--- a/test/lightweight_test.hpp
+++ b/test/lightweight_test.hpp
@@ -1,19 +1,23 @@
-// 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/core/lightweight_test.hpp"
-#include <exception>
 
 #ifdef BOOST_LEAF_NO_EXCEPTIONS
 namespace boost
 {
-    BOOST_LEAF_NORETURN void throw_exception( std::exception const & e )
+    [[noreturn]] inline 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]] inline 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..8971dbeb 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)
 
@@ -25,7 +24,6 @@ int main()
 
 #include "_test_ec.hpp"
 #include "lightweight_test.hpp"
-#include <exception>
 
 namespace leaf = boost::leaf;
 
diff --git a/test/match_test.cpp b/test/match_test.cpp
index 3592d982..9dc17443 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)
 
@@ -13,7 +12,6 @@
 
 #include "_test_ec.hpp"
 #include "lightweight_test.hpp"
-#include <exception>
 
 namespace leaf = boost::leaf;
 
@@ -33,7 +31,7 @@ constexpr bool e_my_error_gt( e_my_error const & e ) noexcept
 {
   return e.value > S;
 }
-#endif
+#endif // #if __cplusplus >= 201703L
 
 struct my_exception: std::exception
 {
@@ -101,9 +99,9 @@ int main()
         BOOST_TEST(( !test<leaf::if_not<leaf::match<std::error_code, errc_a::a0>>>(e) ));
         BOOST_TEST(( test<leaf::if_not<leaf::match<std::error_code, errc_a::a2>>>(e) ));
         BOOST_TEST(( !test<leaf::if_not<leaf::match<std::error_code, errc_a::a2, errc_a::a0>>>(e) ));
-#endif
+#endif // #if __cplusplus >= 201703L
     }
-#endif
+#endif // #if BOOST_LEAF_CFG_STD_SYSTEM_ERROR
 
 #if __cplusplus >= 201703L
     {
@@ -164,7 +162,7 @@ int main()
                 return 1;
             },
 
-            []( my_error e )
+            []( my_error )
             {
                 return 2;
             },
@@ -188,7 +186,7 @@ int main()
                 return 1;
             },
 
-            []( my_error e )
+            []( my_error )
             {
                 return 2;
             },
@@ -246,7 +244,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 +263,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;
             },
@@ -276,7 +274,7 @@ int main()
             } );
         BOOST_TEST_EQ(r, 2);
     }
-#endif
+#endif // #if __cplusplus >= 201703L
 
     return boost::report_errors();
 }
diff --git a/test/match_value_test.cpp b/test/match_value_test.cpp
index 41054235..82caa7d7 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)
 
@@ -13,7 +12,6 @@
 
 #include "_test_ec.hpp"
 #include "lightweight_test.hpp"
-#include <exception>
 
 namespace leaf = boost::leaf;
 
diff --git a/test/multiple_errors_test.cpp b/test/multiple_errors_test.cpp
index da1e74ea..ece87b5c 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"
@@ -13,7 +13,6 @@
 #endif
 
 #include "lightweight_test.hpp"
-#include <exception>
 
 namespace leaf = boost::leaf;
 
@@ -68,7 +67,7 @@ int main()
             {
                 try
                 {
-                    throw leaf::exception(info<4>{4});
+                    leaf::throw_exception(info<4>{4});
                 }
                 catch(...)
                 {
@@ -85,6 +84,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 91%
rename from test/accumulate_nested_error_exception_test.cpp
rename to test/on_error_accumulate_nested_error_exception_test.cpp
index 163be9ac..9df615f7 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()
@@ -85,4 +84,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
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 75%
rename from test/accumulate_nested_new_error_exception_test.cpp
rename to test/on_error_accumulate_nested_new_error_exception_test.cpp
index 91b29971..46ef0cb0 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(...)
@@ -92,4 +99,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
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 91%
rename from test/accumulate_nested_success_exception_test.cpp
rename to test/on_error_accumulate_nested_success_exception_test.cpp
index ad8edc66..b09e4ce9 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)
 
@@ -69,4 +68,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
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/on_error_alloc_fail_test.cpp b/test/on_error_alloc_fail_test.cpp
new file mode 100644
index 00000000..6444b7fa
--- /dev/null
+++ b/test/on_error_alloc_fail_test.cpp
@@ -0,0 +1,239 @@
+// Copyright 2018-2025 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/error.hpp>
+#   include <boost/leaf/on_error.hpp>
+#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/result.hpp>
+#   include <boost/leaf/diagnostics.hpp>
+#   include <boost/leaf/exception.hpp>
+#endif
+
+#if !BOOST_LEAF_CFG_CAPTURE || defined(BOOST_LEAF_NO_EXCEPTIONS)
+
+int main()
+{
+    return 0;
+}
+
+#else
+
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+namespace leaf = boost::leaf;
+
+struct alloc_fail_info
+{
+    int value;
+};
+
+namespace boost { namespace leaf { namespace detail {
+
+template <>
+struct capturing_slot_node_allocator<alloc_fail_info>
+{
+    template <class... A>
+    static dynamic_allocator::capturing_slot_node<alloc_fail_info> * new_( A && ... )
+    {
+        throw std::bad_alloc();
+    }
+
+    static void delete_( dynamic_allocator::capturing_slot_node<alloc_fail_info> * p ) noexcept
+    {
+        delete p;
+    }
+};
+
+} } } // namespace boost::leaf::detail
+
+#include "lightweight_test.hpp"
+
+template <int N>
+struct other_info
+{
+    int value;
+};
+
+leaf::result<void> f()
+{
+    auto load = leaf::on_error( other_info<1>{1}, alloc_fail_info{42}, other_info<2>{2} );
+    return leaf::new_error();
+}
+
+int main()
+{
+    {
+        auto captured = leaf::try_capture_all(
+            []() -> leaf::result<void>
+            {
+                return f();
+            } );
+
+        int r = leaf::try_handle_all(
+            [&]() -> leaf::result<int>
+            {
+                (void) captured.value();
+                return 0;
+            },
+            []( std::bad_alloc const &, other_info<1> const & oi1, other_info<2> const * oi2, alloc_fail_info const * afi )
+            {
+                BOOST_TEST_EQ(oi1.value, 1);
+                BOOST_TEST_EQ(oi2, nullptr);
+                BOOST_TEST_EQ(afi, nullptr);
+                return 1;
+            },
+            []
+            {
+                return 2;
+            } );
+        BOOST_TEST_EQ(r, 1);
+    }
+
+#if BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_STD_STRING
+    {
+        int r = leaf::try_handle_all(
+            []() -> leaf::result<int>
+            {
+                BOOST_LEAF_CHECK(f());
+                return 0;
+            },
+            []( std::bad_alloc const &, leaf::diagnostic_details const & dd )
+            {
+                std::ostringstream s;
+                s << dd;
+                std::string str = s.str();
+                BOOST_TEST(str.find("other_info<1>") != std::string::npos);
+                BOOST_TEST(str.find("other_info<2>") == std::string::npos);
+                BOOST_TEST(str.find("alloc_fail_info") == std::string::npos);
+                return 1;
+            },
+            []
+            {
+                return 2;
+            } );
+        BOOST_TEST_EQ(r, 1);
+    }
+#endif
+
+////////////////////////////////////////
+
+    {
+        auto captured = leaf::try_capture_all(
+            []() -> leaf::result<void>
+            {
+                auto load = leaf::on_error( other_info<1>{1}, alloc_fail_info{42}, other_info<2>{2} );
+                throw std::runtime_error("test");
+            } );
+
+        int r = leaf::try_handle_all(
+            [&]() -> leaf::result<int>
+            {
+                (void) captured.value();
+                return 0;
+            },
+            []( other_info<1> const & oi1, other_info<2> const * oi2, alloc_fail_info const * afi )
+            {
+                BOOST_TEST_EQ(oi1.value, 1);
+                BOOST_TEST_EQ(oi2, nullptr);
+                BOOST_TEST_EQ(afi, nullptr);
+                return 1;
+            },
+            []
+            {
+                return 2;
+            } );
+        BOOST_TEST_EQ(r, 1);
+    }
+
+#if BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_STD_STRING
+    {
+        int r = leaf::try_catch(
+            []() -> int
+            {
+                auto load = leaf::on_error( other_info<1>{1}, alloc_fail_info{42}, other_info<2>{2} );
+                throw std::runtime_error("test");
+            },
+            []( leaf::diagnostic_details const & dd )
+            {
+                std::ostringstream s;
+                s << dd;
+                std::string str = s.str();
+                BOOST_TEST(str.find("other_info<1>") != std::string::npos);
+                BOOST_TEST(str.find("other_info<2>") == std::string::npos);
+                BOOST_TEST(str.find("alloc_fail_info") == std::string::npos);
+                return 1;
+            },
+            []
+            {
+                return 2;
+            } );
+        BOOST_TEST_EQ(r, 1);
+    }
+#endif
+
+////////////////////////////////////////
+
+    {
+        auto captured = leaf::try_capture_all(
+            []() -> leaf::result<void>
+            {
+                auto load = leaf::on_error( other_info<1>{1}, alloc_fail_info{42}, other_info<2>{2} );
+                leaf::throw_exception(std::runtime_error("test"));
+            } );
+
+        int r = leaf::try_handle_all(
+            [&]() -> leaf::result<int>
+            {
+                (void) captured.value();
+                return 0;
+            },
+            []( std::bad_alloc const &, other_info<1> const & oi1, other_info<2> const * oi2, alloc_fail_info const * afi )
+            {
+                BOOST_TEST_EQ(oi1.value, 1);
+                BOOST_TEST_EQ(oi2, nullptr);
+                BOOST_TEST_EQ(afi, nullptr);
+                return 1;
+            },
+            []
+            {
+                return 2;
+            } );
+        BOOST_TEST_EQ(r, 1);
+    }
+
+#if BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_STD_STRING
+    {
+        int r = leaf::try_catch(
+            []() -> int
+            {
+                auto load = leaf::on_error( other_info<1>{1}, alloc_fail_info{42}, other_info<2>{2} );
+                leaf::throw_exception(std::runtime_error("test"));
+            },
+            []( std::bad_alloc const &, leaf::diagnostic_details const & dd )
+            {
+                std::ostringstream s;
+                s << dd;
+                std::string str = s.str();
+                BOOST_TEST(str.find("other_info<1>") != std::string::npos);
+                BOOST_TEST(str.find("other_info<2>") == std::string::npos);
+                BOOST_TEST(str.find("alloc_fail_info") == std::string::npos);
+                return 1;
+            },
+            []
+            {
+                return 2;
+            } );
+        BOOST_TEST_EQ(r, 1);
+    }
+#endif
+
+    return boost::report_errors();
+}
+
+#endif
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 91%
rename from test/defer_nested_error_exception_test.cpp
rename to test/on_error_defer_nested_error_exception_test.cpp
index b85d3b60..0ee2a33e 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()
@@ -85,4 +84,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
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 90%
rename from test/defer_nested_new_error_exception_test.cpp
rename to test/on_error_defer_nested_new_error_exception_test.cpp
index 928d556a..9fb9507c 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()
@@ -92,4 +91,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
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 91%
rename from test/defer_nested_success_exception_test.cpp
rename to test/on_error_defer_nested_success_exception_test.cpp
index 2e559890..6899d582 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)
 
@@ -69,4 +68,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
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/on_error_dynamic_reserve_test1.cpp b/test/on_error_dynamic_reserve_test1.cpp
new file mode 100644
index 00000000..70d7bc9c
--- /dev/null
+++ b/test/on_error_dynamic_reserve_test1.cpp
@@ -0,0 +1,52 @@
+// Copyright 2018-2025 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/on_error.hpp>
+#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/result.hpp>
+#   include <boost/leaf/config/tls.hpp>
+#endif
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+template <int N>
+struct info
+{
+    int value;
+};
+
+leaf::result<void> f()
+{
+    BOOST_TEST_EQ(leaf::tls::read_ptr<leaf::detail::slot<info<42>>>(), nullptr);
+    BOOST_TEST_NE(leaf::tls::read_ptr<leaf::detail::slot<info<43>>>(), nullptr);
+    auto load = leaf::on_error( info<42>{42} );
+    BOOST_TEST_EQ(leaf::tls::read_ptr<leaf::detail::slot<info<42>>>(), nullptr);
+    return leaf::new_error(info<43>{});
+}
+
+int main()
+{
+    int r = leaf::try_handle_all(
+        []() -> leaf::result<int>
+        {
+            BOOST_LEAF_CHECK(f());
+            return 0;
+        },
+        []( info<43> const & )
+        {
+            return 1;
+        },
+        []
+        {
+            return 2;
+        } );
+    BOOST_TEST_EQ(r, 1);
+
+    return boost::report_errors();
+}
diff --git a/test/on_error_dynamic_reserve_test2.cpp b/test/on_error_dynamic_reserve_test2.cpp
new file mode 100644
index 00000000..4d1dd303
--- /dev/null
+++ b/test/on_error_dynamic_reserve_test2.cpp
@@ -0,0 +1,58 @@
+// Copyright 2018-2025 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/on_error.hpp>
+#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/result.hpp>
+#   include <boost/leaf/config/tls.hpp>
+#   include <boost/leaf/diagnostics.hpp>
+#endif
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+template <int N>
+struct info
+{
+    int value;
+};
+
+leaf::result<void> f()
+{
+    BOOST_TEST_EQ(leaf::tls::read_ptr<leaf::detail::slot<info<42>>>(), nullptr);
+    BOOST_TEST_NE(leaf::tls::read_ptr<leaf::detail::slot<info<43>>>(), nullptr);
+    auto load = leaf::on_error( info<42>{42} );
+    BOOST_TEST_EQ(leaf::tls::read_ptr<leaf::detail::slot<info<42>>>(), nullptr);
+    auto e = leaf::new_error(info<43>{});
+    BOOST_TEST(
+        (BOOST_LEAF_CFG_CAPTURE == 0 || BOOST_LEAF_CFG_DIAGNOSTICS == 0)
+        ==
+        (leaf::tls::read_ptr<leaf::detail::slot<info<42>>>() == nullptr));
+    return e;
+}
+
+int main()
+{
+    int r = leaf::try_handle_all(
+        []() -> leaf::result<int>
+        {
+            BOOST_LEAF_CHECK(f());
+            return 0;
+        },
+        []( info<43> const & )
+        {
+            return 1;
+        },
+        []( leaf::diagnostic_details const & )
+        {
+            return 2;
+        } );
+    BOOST_TEST_EQ(r, 1);
+
+    return boost::report_errors();
+}
diff --git a/test/on_error_dynamic_reserve_test3.cpp b/test/on_error_dynamic_reserve_test3.cpp
new file mode 100644
index 00000000..472cad40
--- /dev/null
+++ b/test/on_error_dynamic_reserve_test3.cpp
@@ -0,0 +1,74 @@
+// Copyright 2018-2025 Emil Dotchevski and Reverge Studios, Inc.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/leaf/config.hpp>
+
+#if !BOOST_LEAF_CFG_CAPTURE
+
+#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/on_error.hpp>
+#   include <boost/leaf/handle_errors.hpp>
+#   include <boost/leaf/result.hpp>
+#   include <boost/leaf/config/tls.hpp>
+#endif
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+template <int N>
+struct info
+{
+    int value;
+};
+
+leaf::result<void> f()
+{
+    BOOST_TEST_EQ(leaf::tls::read_ptr<leaf::detail::slot<info<42>>>(), nullptr);
+    BOOST_TEST_NE(leaf::tls::read_ptr<leaf::detail::slot<info<43>>>(), nullptr);
+    auto load = leaf::on_error( info<42>{42} );
+    BOOST_TEST_EQ(leaf::tls::read_ptr<leaf::detail::slot<info<42>>>(), nullptr);
+    auto e = leaf::new_error(info<43>{});
+    BOOST_TEST_NE(leaf::tls::read_ptr<leaf::detail::slot<info<42>>>(), nullptr);
+    return e;
+}
+
+int main()
+{
+    int r = leaf::try_handle_all(
+        []() -> leaf::result<int>
+        {
+            return leaf::try_capture_all(
+                []() -> leaf::result<int>
+                {
+                    BOOST_LEAF_CHECK(f());
+                    return 0;
+                } );
+        },
+        []( info<43> const & )
+        {
+            return 1;
+        },
+        []
+        {
+            return 2;
+        } );
+    BOOST_TEST_EQ(r, 1);
+
+    return boost::report_errors();
+}
+
+#endif
diff --git a/test/preload_basic_test.cpp b/test/on_error_preload_basic_test.cpp
similarity index 70%
rename from test/preload_basic_test.cpp
rename to test/on_error_preload_basic_test.cpp
index e374083d..86964e4d 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)
 
@@ -8,11 +7,11 @@
 #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 +38,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;
         },
         []
@@ -81,5 +70,22 @@ int main()
             auto load = leaf::on_error( inf1, info<-42>{-42} );
             return leaf::new_error();
         });
+
+#if BOOST_LEAF_CFG_CAPTURE
+    (void) leaf::try_capture_all(
+        []() -> leaf::result<void>
+        {
+            leaf::detail::dynamic_allocator * da = leaf::detail::get_dynamic_allocator();
+            BOOST_TEST_NE(da, nullptr);
+            BOOST_TEST_EQ(da->preloaded_list(), nullptr);
+            {
+                auto load = leaf::on_error( info<42>{42} );
+                BOOST_TEST_NE(da->preloaded_list(), nullptr);
+            }
+            BOOST_TEST_EQ(da->preloaded_list(), nullptr);
+            return { };
+        } );
+#endif
+
     return boost::report_errors();
 }
diff --git a/test/preload_exception_test.cpp b/test/on_error_preload_exception_test.cpp
similarity index 88%
rename from test/preload_exception_test.cpp
rename to test/on_error_preload_exception_test.cpp
index 8008d140..6dd7b7f0 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> )
@@ -150,4 +149,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #if defined(BOOST_LEAF_NO_EXCEPTIONS) || defined(BOOST_LEAF_NO_THREADS)
diff --git a/test/preload_nested_error_exception_test.cpp b/test/on_error_preload_nested_error_exception_test.cpp
similarity index 90%
rename from test/preload_nested_error_exception_test.cpp
rename to test/on_error_preload_nested_error_exception_test.cpp
index 301daae8..d585399c 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()
@@ -85,4 +84,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
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 90%
rename from test/preload_nested_new_error_exception_test.cpp
rename to test/on_error_preload_nested_new_error_exception_test.cpp
index 4a593e86..7fa75f6e 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()
@@ -92,4 +91,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
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 91%
rename from test/preload_nested_success_exception_test.cpp
rename to test/on_error_preload_nested_success_exception_test.cpp
index 86f509e6..8ca0071b 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)
 
@@ -69,4 +68,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
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..f1ba6ca7 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();
@@ -307,7 +269,7 @@ int main()
         BOOST_TEST(!r2);
         {
             val x;
-            BOOST_TEST(ctx.handle_error<val>(r2.error(), [&]{ return x; }) == x);
+            BOOST_TEST_EQ(ctx.handle_error<val>(r2.error(), [&]{ return x; }), x);
         }
         BOOST_TEST_EQ(err::count, 1);
         BOOST_TEST_EQ(val::count, 0);
@@ -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);
@@ -389,11 +369,11 @@ int main()
     }
     BOOST_TEST_EQ(err::count, 0);
     BOOST_TEST_EQ(val::count, 0);
-#endif
+#endif // #if BOOST_LEAF_CFG_CAPTURE
 
     // ^^ 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,167 +394,158 @@ 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; r2=std::move(r1);
         BOOST_TEST(r2);
         r2.value();
-        BOOST_TEST(r2.operator->() != 0);
+        BOOST_TEST(r2.operator->());
         *r2;
     }
 
-#if BOOST_LEAF_CFG_CAPTURE
-    { // void default -> capture -> move
-        leaf::result<void> r1 = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<void>(); } );
-        BOOST_TEST(r1);
-        r1.value();
-        BOOST_TEST(r1.operator->() != 0);
-        *r1;
-        leaf::result<void> r2 = std::move(r1);
-        BOOST_TEST(r2);
-        r2.value();
-        BOOST_TEST(r2.operator->() != 0);
-        *r2;
-    }
-    { // void default -> capture -> assign-move
-        leaf::result<void> r1 = leaf::capture( std::make_shared<context_type>(), []{ return leaf::result<void>(); } );
-        BOOST_TEST(r1);
-        r1.value();
-        BOOST_TEST(r1.operator->() != 0);
-        *r1;
-        leaf::result<void> r2; r2=std::move(r1);
-        BOOST_TEST(r2);
-        r2.value();
-        BOOST_TEST(r2.operator->() != 0);
-        *r2;
-    }
-#endif
-
     // ^^ void default ^^
     // vv void error vv
 
     { // void error move -> move
-        context_type ctx;
+        leaf::context<e_err>  ctx;
         auto active_context = activate_context(ctx);
         leaf::result<void> r1 = leaf::new_error( e_err { } );
         BOOST_TEST(!r1);
-        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);
         leaf::error_id r2e = r2.error();
         BOOST_TEST_EQ(r1e, r2e);
         BOOST_TEST(!r2);
-        BOOST_TEST(r2.operator->() == 0);
+        BOOST_TEST_EQ(r2.operator->(), nullptr);
     }
     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);
         leaf::error_id r2e = r2.error();
         BOOST_TEST_EQ(r1e, r2e);
         BOOST_TEST(!r2);
-        BOOST_TEST(r2.operator->() == 0);
+        BOOST_TEST_EQ(r2.operator->(), nullptr);
     }
     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);
         leaf::error_id r2e = r2.error();
         BOOST_TEST_EQ(r1e, r2e);
         BOOST_TEST(!r2);
-        BOOST_TEST(r2.operator->() == 0);
+        BOOST_TEST_EQ(r2.operator->(), nullptr);
         ctx.handle_error<void>(r2.error(), []{ });
         BOOST_TEST_EQ(err::count, 1);
     }
     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);
         leaf::error_id r2e = r2.error();
         BOOST_TEST_EQ(r1e, r2e);
         BOOST_TEST(!r2);
-        BOOST_TEST(r2.operator->() == 0);
+        BOOST_TEST_EQ(r2.operator->(), nullptr);
     }
     BOOST_TEST_EQ(err::count, 0);
 
 #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);
         leaf::error_id r2e = r2.error();
         BOOST_TEST_EQ(r1e, r2e);
         BOOST_TEST(!r2);
-        BOOST_TEST(r2.operator->() == 0);
+        BOOST_TEST_EQ(r2.operator->(), nullptr);
     }
     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);
         leaf::error_id r2e = r2.error();
         BOOST_TEST_EQ(r1e, r2e);
         BOOST_TEST(!r2);
-        BOOST_TEST(r2.operator->() == 0);
+        BOOST_TEST_EQ(r2.operator->(), nullptr);
     }
     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);
         leaf::error_id r2e = r2.error();
         BOOST_TEST_EQ(r1e, r2e);
         BOOST_TEST(!r2);
-        BOOST_TEST(r2.operator->() == 0);
+        BOOST_TEST_EQ(r2.operator->(), nullptr);
     }
     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);
         leaf::error_id r2e = r2.error();
         BOOST_TEST_EQ(r1e, r2e);
         BOOST_TEST(!r2);
-        BOOST_TEST(r2.operator->() == 0);
+        BOOST_TEST_EQ(r2.operator->(), nullptr);
     }
     BOOST_TEST_EQ(err::count, 0);
-#endif
+#endif // #if BOOST_LEAF_CFG_CAPTURE
 
     {
         leaf::result<int> r = leaf::error_id();
diff --git a/test/so_dll_lib1.cpp b/test/so_dll_lib1.cpp
new file mode 100644
index 00000000..a3762634
--- /dev/null
+++ b/test/so_dll_lib1.cpp
@@ -0,0 +1,35 @@
+// 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/exception.hpp>
+#   include <boost/leaf/result.hpp>
+#   include <boost/leaf/on_error.hpp>
+#endif
+
+#include "lightweight_test.hpp"
+
+#define BOOST_LEAF_SO_DLL_TEST_BUILDING_LIB1
+
+#include "so_dll_lib1.hpp"
+
+namespace leaf = boost::leaf;
+
+BOOST_LEAF_SO_DLL_TEST_LIB1_API leaf::result<void> hidden_result1()
+{
+    auto load = leaf::on_error( my_info<1>{1}, my_info<3>{3} );
+    return leaf::new_error( my_info<2>{2} );
+}
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+
+BOOST_LEAF_SO_DLL_TEST_LIB1_API void hidden_throw1()
+{
+    auto load = leaf::on_error( my_info<1>{1}, my_info<3>{3} );
+    leaf::throw_exception( my_info<2>{2} );
+}
+
+#endif
diff --git a/test/so_dll_lib1.hpp b/test/so_dll_lib1.hpp
new file mode 100644
index 00000000..7e00dc47
--- /dev/null
+++ b/test/so_dll_lib1.hpp
@@ -0,0 +1,29 @@
+#ifndef SO_DLL_TEST_LIB1_HPP_INCLUDED
+#define SO_DLL_TEST_LIB1_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 "so_dll_test.hpp"
+
+#ifdef _WIN32
+#   ifdef BOOST_LEAF_SO_DLL_TEST_STATIC
+#       define BOOST_LEAF_SO_DLL_TEST_LIB1_API
+#   elif defined(BOOST_LEAF_SO_DLL_TEST_BUILDING_LIB1)
+#       define BOOST_LEAF_SO_DLL_TEST_LIB1_API __declspec(dllexport)
+#   else
+#       define BOOST_LEAF_SO_DLL_TEST_LIB1_API __declspec(dllimport)
+#   endif
+#else
+#   define BOOST_LEAF_SO_DLL_TEST_LIB1_API [[gnu::visibility("default")]]
+#endif
+
+BOOST_LEAF_SO_DLL_TEST_LIB1_API boost::leaf::result<void> hidden_result1();
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+BOOST_LEAF_SO_DLL_TEST_LIB1_API void hidden_throw1();
+#endif
+
+#endif
+
diff --git a/test/so_dll_lib2.cpp b/test/so_dll_lib2.cpp
new file mode 100644
index 00000000..56afd1e2
--- /dev/null
+++ b/test/so_dll_lib2.cpp
@@ -0,0 +1,35 @@
+// 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/exception.hpp>
+#   include <boost/leaf/result.hpp>
+#   include <boost/leaf/on_error.hpp>
+#endif
+
+#include "lightweight_test.hpp"
+
+#define BOOST_LEAF_SO_DLL_TEST_BUILDING_LIB2
+
+#include "so_dll_lib2.hpp"
+
+namespace leaf = boost::leaf;
+
+BOOST_LEAF_SO_DLL_TEST_LIB2_API leaf::result<void> hidden_result2()
+{
+    auto load = leaf::on_error( my_info<1>{1}, my_info<3>{3} );
+    return leaf::new_error( my_info<2>{2} );
+}
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+
+BOOST_LEAF_SO_DLL_TEST_LIB2_API void hidden_throw2()
+{
+    auto load = leaf::on_error( my_info<1>{1}, my_info<3>{3} );
+    leaf::throw_exception( my_info<2>{2} );
+}
+
+#endif
diff --git a/test/so_dll_lib2.hpp b/test/so_dll_lib2.hpp
new file mode 100644
index 00000000..35cb138b
--- /dev/null
+++ b/test/so_dll_lib2.hpp
@@ -0,0 +1,29 @@
+#ifndef SO_DLL_TEST_LIB2_HPP_INCLUDED
+#define SO_DLL_TEST_LIB2_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 "so_dll_test.hpp"
+
+#ifdef _WIN32
+#   ifdef BOOST_LEAF_SO_DLL_TEST_STATIC
+#       define BOOST_LEAF_SO_DLL_TEST_LIB2_API
+#   elif defined(BOOST_LEAF_SO_DLL_TEST_BUILDING_LIB2)
+#       define BOOST_LEAF_SO_DLL_TEST_LIB2_API __declspec(dllexport)
+#   else
+#       define BOOST_LEAF_SO_DLL_TEST_LIB2_API __declspec(dllimport)
+#   endif
+#else
+#   define BOOST_LEAF_SO_DLL_TEST_LIB2_API [[gnu::visibility("default")]]
+#endif
+
+BOOST_LEAF_SO_DLL_TEST_LIB2_API boost::leaf::result<void> hidden_result2();
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+BOOST_LEAF_SO_DLL_TEST_LIB2_API void hidden_throw2();
+#endif
+
+#endif
+
diff --git a/test/so_dll_test.cpp b/test/so_dll_test.cpp
new file mode 100644
index 00000000..c16f41c9
--- /dev/null
+++ b/test/so_dll_test.cpp
@@ -0,0 +1,226 @@
+// 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_SO_DLL_TEST_BUILDING_EXE
+
+#ifdef BOOST_LEAF_TEST_SINGLE_HEADER
+#   include "leaf.hpp"
+#else
+#   include <boost/leaf/diagnostics.hpp>
+#   include <boost/leaf/result.hpp>
+#endif
+
+#include "so_dll_lib1.hpp"
+#include "so_dll_lib2.hpp"
+
+#if BOOST_LEAF_CFG_STD_STRING
+#   include <sstream>
+#   include <iostream>
+#endif
+
+#include <thread>
+#include <vector>
+#include <cstdlib>
+#include <ctime>
+#include <chrono>
+#include <mutex>
+#include <condition_variable>
+#include <functional>
+#include <future>
+
+#include "lightweight_test.hpp"
+
+namespace leaf = boost::leaf;
+
+int test_result(leaf::result<void> (*f)(), bool print)
+{
+    int r = leaf::try_handle_all(
+        [f]() -> leaf::result<int>
+        {
+            BOOST_LEAF_CHECK(f());
+            return 0;
+        },
+        [&]( my_info<1> x1, my_info<2> x2, leaf::diagnostic_details const & info, leaf::diagnostic_details const & vinfo )
+        {
+            if( x1.value != 1 )
+                return 1;
+            if( x2.value != 2 )
+                return 2;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS && print )
+            {
+#if BOOST_LEAF_CFG_STD_STRING
+                std::ostringstream ss; ss << vinfo;
+                std::string s = ss.str();
+                std::cout << "Handler matched, diagnostics:\n" << s << std::endl;
+                if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+                    if( s.find("Test my_info<3>::value = 3") == std::string::npos )
+                        return 3;
+#endif
+            }
+            return 0;
+        },
+        [&](leaf::diagnostic_details const & vinfo)
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            if( print )
+                std::cout << "Test is failing (catch-all), diagnostics:\n" << vinfo << std::endl;
+#endif
+            return 4;
+        } );
+    return r;
+}
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+int test_exception(void (*f)(), bool print)
+{
+    int r = leaf::try_catch(
+        [f]
+        {
+            f();
+            return 0;
+        },
+        [&]( my_info<1> x1, my_info<2> x2, leaf::diagnostic_details const & info, leaf::diagnostic_details const & vinfo )
+        {
+            if( x1.value != 1 )
+                return 1;
+            if( x2.value != 2 )
+                return 2;
+            if( BOOST_LEAF_CFG_DIAGNOSTICS && print )
+            {
+#if BOOST_LEAF_CFG_STD_STRING
+                std::ostringstream ss; ss << vinfo;
+                std::string s = ss.str();
+                std::cout << s << std::endl;
+                if( BOOST_LEAF_CFG_DIAGNOSTICS && BOOST_LEAF_CFG_CAPTURE )
+                    if( s.find("Test my_info<3>::value = 3") == std::string::npos )
+                        return 3;
+#endif
+            }
+            return 0;
+        },
+        [&](leaf::diagnostic_details const & vinfo)
+        {
+#if BOOST_LEAF_CFG_STD_STRING
+            if( print )
+                std::cout << "Test is failing\n" << vinfo;
+#endif
+            return 4;
+        } );
+    return r;
+}
+
+int test_catch(void (*f)())
+{
+    try
+    {
+        f();
+        return 1;
+    }
+    catch( leaf::error_id const & )
+    {
+        return 0;
+    }
+    catch(...)
+    {
+        return 2;
+    }
+}
+#endif // #ifndef BOOST_LEAF_NO_EXCEPTIONS
+
+void test_single_thread()
+{
+    BOOST_TEST_EQ(test_result(hidden_result2, true), 0);
+    BOOST_TEST_EQ(test_result(hidden_result1, true), 0);
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+    BOOST_TEST_EQ(test_exception(hidden_throw1, true), 0);
+    BOOST_TEST_EQ(test_catch(hidden_throw1), 0);
+    BOOST_TEST_EQ(test_exception(hidden_throw2, true), 0);
+    BOOST_TEST_EQ(test_catch(hidden_throw2), 0);
+#endif // #ifndef BOOST_LEAF_NO_EXCEPTIONS
+}
+
+void test_multithreaded()
+{
+    constexpr int N = 100;
+    {
+        std::mutex mtx;
+        std::condition_variable cv;
+        bool ready = false;
+        auto test_function = [&]
+        {
+            std::unique_lock<std::mutex> lock(mtx);
+            cv.wait(lock, [&]{ return ready; });
+            lock.unlock();
+            int result1 = test_result(hidden_result1, false);
+            int result2 = test_result(hidden_result2, false);
+            return result1 + result2;
+        };
+        std::vector<std::future<int>> futures;
+        for (int i = 0; i < N; ++i)
+            futures.push_back(std::async(std::launch::async, test_function));
+        {
+            std::lock_guard<std::mutex> lock(mtx);
+            ready = true;
+        }
+        cv.notify_all();
+        for (auto start = std::chrono::steady_clock::now(); std::chrono::steady_clock::now() - start < std::chrono::seconds(1); )
+            if ((std::rand() % 2) == 0 || futures.empty())
+                futures.push_back(std::async(std::launch::async, test_function));
+            else
+            {
+                BOOST_TEST_EQ(futures.back().get(), 0);
+                futures.pop_back();
+            }
+        for (auto & f : futures)
+            BOOST_TEST_EQ(f.get(), 0);
+    }
+
+#ifndef BOOST_LEAF_NO_EXCEPTIONS
+    {
+        std::mutex mtx;
+        std::condition_variable cv;
+        bool ready = false;
+        auto test_function = [&]
+        {
+            std::unique_lock<std::mutex> lock(mtx);
+            cv.wait(lock, [&]{ return ready; });
+            lock.unlock();
+            int result1 = test_exception(hidden_throw1, false);
+            int result2 = test_catch(hidden_throw1);
+            int result3 = test_exception(hidden_throw2, false);
+            int result4 = test_catch(hidden_throw2);
+            return result1 + result2 + result3 + result4;
+        };
+        std::vector<std::future<int>> futures;
+        for (int i = 0; i < N; ++i)
+            futures.push_back(std::async(std::launch::async, test_function));
+        {
+            std::lock_guard<std::mutex> lock(mtx);
+            ready = true;
+        }
+        cv.notify_all();
+        for (auto start = std::chrono::steady_clock::now(); std::chrono::steady_clock::now() - start < std::chrono::seconds(1); )
+            if ((std::rand() % 2) == 0 || futures.empty())
+                futures.push_back(std::async(std::launch::async, test_function));
+            else
+            {
+                BOOST_TEST_EQ(futures.back().get(), 0);
+                futures.pop_back();
+            }
+        for (auto & f : futures)
+            BOOST_TEST_EQ(f.get(), 0);
+    }
+#endif // #ifndef BOOST_LEAF_NO_EXCEPTIONS
+}
+
+int main()
+{
+    std::srand(std::hash<unsigned>{}(static_cast<unsigned>(std::time(nullptr))));
+
+    test_single_thread();
+    test_multithreaded();
+
+    return boost::report_errors();
+}
diff --git a/test/so_dll_test.hpp b/test/so_dll_test.hpp
new file mode 100644
index 00000000..9d6306e5
--- /dev/null
+++ b/test/so_dll_test.hpp
@@ -0,0 +1,29 @@
+#ifndef SO_DLL_TEST_HPP_INCLUDED
+#define SO_DLL_TEST_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>
+
+#if defined(_WIN32) && BOOST_LEAF_CFG_WIN32 < 2
+#   error This test requires BOOST_LEAF_CFG_WIN32 >= 2
+#endif
+
+// Note, under BOOST_LEAF_CFG_WIN32==2 (using Win32 TLS) we do not need
+// import/export for error types. We still need default visibility on POSIX.
+template <int Tag>
+struct [[gnu::visibility("default")]] my_info
+{
+    int value;
+
+    template <class CharT, class Traits>
+    friend std::ostream & operator<<( std::basic_ostream<CharT, Traits> & os, my_info const & x )
+    {
+        return os << "Test my_info<" << Tag << ">::value = " << x.value;
+    }
+};
+
+#endif
+
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..1e3114bd 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,21 +34,21 @@ 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);
             } );
-        BOOST_TEST(v.index() == 1);
+        BOOST_TEST_EQ(v.index(), 1);
         auto t = std::get<1>(v);
 
         BOOST_TEST(std::get<0>(t).has_value());
@@ -59,9 +58,9 @@ int main()
         BOOST_TEST(std::get<0>(t).value() == E1::e12);
         BOOST_TEST(std::get<2>(t).value() == E3::e31);
     }
-#endif
+#endif // #if !defined(__clang__) || __clang_major__ < 5 || __clang_major__ > 7
 
     return boost::report_errors();
 }
 
-#endif
+#endif // #if __cplusplus < 201703L
diff --git a/test/try_capture_all_test.cpp b/test/try_capture_all_test.cpp
new file mode 100644
index 00000000..08ea9bb3
--- /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 // #ifndef BOOST_LEAF_NO_EXCEPTIONS
+    {
+        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 // #if !BOOST_LEAF_CFG_CAPTURE
diff --git a/test/try_catch_error_id_test.cpp b/test/try_catch_error_id_test.cpp
index 5b32875c..fcd3bc2b 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;
         },
         []
@@ -53,4 +52,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
diff --git a/test/try_catch_system_error_test.cpp b/test/try_catch_system_error_test.cpp
index 2ece5fd9..0c940c9c 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> )
             {
@@ -147,4 +147,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #if defined(BOOST_LEAF_NO_EXCEPTIONS) || !BOOST_LEAF_CFG_STD_SYSTEM_ERROR
diff --git a/test/try_catch_test.cpp b/test/try_catch_test.cpp
index d14740f4..032b2cd2 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,9 +608,9 @@ int main()
         BOOST_TEST_EQ(r, 2);
     }
 
-    //////////////////////////////////////
+    ////////////////////////////////////////
 
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
diff --git a/test/try_exception_and_result_test.cpp b/test/try_exception_and_result_test.cpp
index 954ab091..21a3ff1f 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 )
             {
@@ -706,4 +705,4 @@ int main()
     return boost::report_errors();
 }
 
-#endif
+#endif // #ifdef BOOST_LEAF_NO_EXCEPTIONS
diff --git a/test/visibility_test.cpp b/test/visibility_test.cpp
deleted file mode 100644
index d3d58fe9..00000000
--- a/test/visibility_test.cpp
+++ /dev/null
@@ -1,109 +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/handle_errors.hpp>
-#   include <boost/leaf/result.hpp>
-#endif
-
-#include "visibility_test_lib.hpp"
-#include "lightweight_test.hpp"
-#include <sstream>
-
-namespace leaf = boost::leaf;
-
-leaf::result<void> hidden_result();
-void hidden_throw();
-
-int main()
-{
-    {
-        int r = leaf::try_handle_all(
-            []() -> leaf::result<int>
-            {
-                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 )
-            {
-                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);
-#endif
-                }
-                return 1;
-            },
-            []
-            {
-                return 2;
-            } );
-        BOOST_TEST_EQ(r, 1);
-    }
-
-#ifndef BOOST_LEAF_NO_EXCEPTIONS
-    {
-        int r = leaf::try_catch(
-            []
-            {
-                hidden_throw();
-                return 0;
-            },
-            []( my_info<1> x1, my_info<2> x2, leaf::diagnostic_info const & info, leaf::verbose_diagnostic_info 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);
-#endif
-                }
-                return 1;
-            },
-            []
-            {
-                return 2;
-            } );
-        BOOST_TEST_EQ(r, 1);
-    }
-    {
-        try
-        {
-            hidden_throw();
-            BOOST_ERROR("hidden_throw() failed to throw");
-        }
-        catch( leaf::error_id const & )
-        {
-        }
-        catch(...)
-        {
-            BOOST_ERROR("Failed to catch leaf::error_id");
-        }
-    }
-#endif
-
-return boost::report_errors();
-}
diff --git a/test/visibility_test_lib.cpp b/test/visibility_test_lib.cpp
deleted file mode 100644
index 2c4a0ac3..00000000
--- a/test/visibility_test_lib.cpp
+++ /dev/null
@@ -1,27 +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)
-
-#include "visibility_test_lib.hpp"
-#include <boost/leaf/exception.hpp>
-#include <boost/leaf/result.hpp>
-#include <boost/leaf/on_error.hpp>
-
-namespace leaf = boost::leaf;
-
-leaf::result<void> BOOST_SYMBOL_VISIBLE hidden_result()
-{
-    auto load = leaf::on_error( my_info<1>{1}, my_info<3>{3} );
-    return leaf::new_error( my_info<2>{2} );
-}
-
-#ifndef BOOST_NO_EXCEPTIONS
-
-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} );
-}
-
-#endif
diff --git a/test/visibility_test_lib.hpp b/test/visibility_test_lib.hpp
deleted file mode 100644
index bd924c3f..00000000
--- a/test/visibility_test_lib.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef VISIBILITY_TEST_LIB_HPP_INCLUDED
-#define VISIBILITY_TEST_LIB_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/config.hpp>
-#include <iosfwd>
-
-template <int Tag>
-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 )
-    {
-        return os << "Test my_info<" << Tag << ">::value = " << x.value;
-    }
-};
-
-#endif
diff --git a/wasm.txt b/wasm.txt
index 82e568fe..66243986 100644
--- a/wasm.txt
+++ b/wasm.txt
@@ -1,4 +1,4 @@
-# Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
+# Copyright 2018-2025 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)