diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 0000000..83403d9
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,54 @@
+# Copilot Instructions
+
+## Build Configuration
+
+**Always use debug builds when developing and testing.** Use the appropriate debug preset for your platform:
+
+- **MSVC on Windows:** `msvc-windows-x64-debug`
+- **Clang on Windows:** `clang-windows-x64-debug` (or `clang-windows-x64-debug-local` if using `CMakeUserPresets.json`)
+- **Clang on Linux:** `clang-linux-x64-debug` (or `clang-linux-x64-debug-local` if using `CMakeUserPresets.json`)
+
+Debug builds enable AddressSanitizer (`/fsanitize=address`) on MSVC, which helps catch memory errors during development.
+
+**All build and test commands must be run from a Visual Studio 2026 Developer PowerShell session.** Load it with:
+
+```powershell
+Import-Module "C:\Program Files\Microsoft Visual Studio\18\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
+Enter-VsDevShell -VsInstallPath "C:\Program Files\Microsoft Visual Studio\18\Enterprise" -Arch amd64 -SkipAutomaticLocation
+```
+
+See [BUILDING.md](../BUILDING.md) for full build instructions.
+
+## Project Overview
+
+Phantom.Coroutines is a C++23 coroutine library with two implementation options:
+
+- **Header-only:** include headers from `Phantom.Coroutines/include/`
+- **C++ Modules:** build and link against the `Phantom.Coroutines.Modules` CMake target
+
+Tests are in `Phantom.Coroutines.Test/` and cppcoro-compatibility tests in `Phantom.Coroutines.cppcoro.Test/`.
+
+## Testing
+
+### During development (iterative)
+
+Build and run only the C++ modules implementation and its tests. This is faster and catches most issues:
+
+```
+cmake --build --preset msvc-windows-x64-debug --target Phantom.Coroutines.Modules.Test
+.\out\build\msvc-windows-x64-debug\Phantom.Coroutines.Test\Phantom.Coroutines.Modules.Test.exe
+```
+
+### When a task is complete (full suite)
+
+Build everything and run all three test executables:
+
+```
+cmake --build --preset msvc-windows-x64-debug
+.\out\build\msvc-windows-x64-debug\Phantom.Coroutines.Test\Phantom.Coroutines.Test.exe
+.\out\build\msvc-windows-x64-debug\Phantom.Coroutines.Test\Phantom.Coroutines.Modules.Test.exe
+.\out\build\msvc-windows-x64-debug\Phantom.Coroutines.Test\Phantom.Coroutines.SingleModule.Test.exe
+.\out\build\msvc-windows-x64-debug\Phantom.Coroutines.cppcoro.Test\Phantom.Coroutines.cppcoro.Test.exe
+```
+
+All PRs must include unit tests. Follow the existing naming style: descriptive test names with single-purpose assertions.
diff --git a/.github/workflows/ok-to-test-command.yml b/.github/workflows/ok-to-test-command.yml
new file mode 100644
index 0000000..53b6044
--- /dev/null
+++ b/.github/workflows/ok-to-test-command.yml
@@ -0,0 +1,21 @@
+name: ok-to-test command
+
+on:
+  issue_comment:
+    types:
+      - created
+
+permissions:
+  contents: read
+  issues: write
+  pull-requests: write
+
+jobs:
+  ok-to-test:
+    if: >
+      github.event.issue.pull_request &&
+      (github.event.comment.body == '/ok-to-test' ||
+       github.event.comment.body == '/remove-ok-to-test')
+    uses: JoshuaRowePhantom/Phantom.ContinuousIntegration/.github/workflows/ok-to-test-command.yml@main
+    with:
+      repository-profile: Phantom.Coroutines
diff --git a/.github/workflows/pull-request-continuous-integration.yml b/.github/workflows/pull-request-continuous-integration.yml
new file mode 100644
index 0000000..1813e9f
--- /dev/null
+++ b/.github/workflows/pull-request-continuous-integration.yml
@@ -0,0 +1,21 @@
+name: Pull Request Continuous Integration
+
+on:
+  pull_request:
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - labeled
+      - unlabeled
+      - ready_for_review
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  pull-request-continuous-integration:
+    uses: JoshuaRowePhantom/Phantom.ContinuousIntegration/.github/workflows/pull-request-continuous-integration.yml@main
+    with:
+      repository-profile: Phantom.Coroutines
diff --git a/.github/workflows/pull-request-gate.yml b/.github/workflows/pull-request-gate.yml
new file mode 100644
index 0000000..cc269ae
--- /dev/null
+++ b/.github/workflows/pull-request-gate.yml
@@ -0,0 +1,21 @@
+name: Pull Request Gate
+
+on:
+  pull_request:
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - labeled
+      - unlabeled
+      - ready_for_review
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  continuous-integration-eligibility:
+    uses: JoshuaRowePhantom/Phantom.ContinuousIntegration/.github/workflows/pull-request-gate.yml@main
+    with:
+      repository-profile: Phantom.Coroutines
diff --git a/BUILDING.md b/BUILDING.md
new file mode 100644
index 0000000..2def7bc
--- /dev/null
+++ b/BUILDING.md
@@ -0,0 +1,99 @@
+# Building Phantom.Coroutines
+
+Phantom.Coroutines uses [CMake](https://cmake.org/) (3.30+) with [vcpkg](https://vcpkg.io/) for dependency management and [Ninja](https://ninja-build.org/) as the build generator.
+
+## Prerequisites
+
+- CMake 3.30 or later
+- Ninja
+- vcpkg (set `VCPKG_ROOT` environment variable to your vcpkg installation)
+- A supported compiler:
+  - **Windows:** MSVC (Visual Studio 2026 or later) or Clang
+  - **Linux:** Clang 21
+
+## Configure
+
+Use a CMake preset to configure. For development, prefer a **debug** preset:
+
+```
+cmake --preset msvc-windows-x64-debug
+```
+
+Available presets (defined in `CMakePresets.json`):
+
+| Preset | Platform | Compiler | Config |
+|---|---|---|---|
+| `msvc-windows-x64-debug` | Windows | MSVC | Debug |
+| `msvc-windows-x64-release` | Windows | MSVC | RelWithDebInfo |
+| `clang-windows-x64-debug` | Windows | Clang | Debug |
+| `clang-windows-x64-release` | Windows | Clang | RelWithDebInfo |
+| `clang-linux-x64-debug` | Linux | Clang 21 | Debug |
+| `clang-linux-x64-release` | Linux | Clang 21 | RelWithDebInfo |
+
+> **Note:** The release configuration is `RelWithDebInfo` (not `Release`). It enables link-time code generation (`/GL`/`/LTCG`) on MSVC.
+
+> **Note:** Debug builds on MSVC enable AddressSanitizer (`/fsanitize=address`).
+
+### Local overrides
+
+`CMakeUserPresets.json` provides `*-local` variants of the Clang presets that hard-code local compiler paths. Copy and adapt as needed for your machine.
+
+## Build
+
+```
+cmake --build --preset msvc-windows-x64-debug
+```
+
+Replace the preset name to match your configured preset.
+
+## Run Tests
+
+```
+ctest --preset msvc-windows-x64-debug-unit
+```
+
+Test presets mirror the configure presets. Tests take roughly 5 seconds to run.
+
+## Visual Studio
+
+Open the repository folder in Visual Studio. It will detect `CMakePresets.json` automatically. Select a preset from the configuration drop-down and build/run tests from the IDE.
+
+## Building with VS2026 PowerShell
+
+From a **Visual Studio 2026 Developer PowerShell** session, cmake, ninja, cl, and the Windows SDK are all on `PATH` and the MSVC environment variables (`INCLUDE`, `LIB`) are set correctly. Use the VS Developer PowerShell shortcut, or load it yourself:
+
+```powershell
+Import-Module "C:\Program Files\Microsoft Visual Studio\18\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
+Enter-VsDevShell -VsInstallPath "C:\Program Files\Microsoft Visual Studio\18\Enterprise" -Arch amd64 -SkipAutomaticLocation
+```
+
+Then configure (only needed once, or after clearing the cache):
+
+```powershell
+cmake --preset msvc-windows-x64-debug
+```
+
+Build the C++ modules test target (iterative development):
+
+```powershell
+cmake --build --preset msvc-windows-x64-debug --target Phantom.Coroutines.Modules.Test
+.\out\build\msvc-windows-x64-debug\Phantom.Coroutines.Test\Phantom.Coroutines.Modules.Test.exe
+```
+
+Full build and test suite (run when done with a task):
+
+```powershell
+cmake --build --preset msvc-windows-x64-debug
+.\out\build\msvc-windows-x64-debug\Phantom.Coroutines.Test\Phantom.Coroutines.Test.exe
+.\out\build\msvc-windows-x64-debug\Phantom.Coroutines.Test\Phantom.Coroutines.Modules.Test.exe
+.\out\build\msvc-windows-x64-debug\Phantom.Coroutines.Test\Phantom.Coroutines.SingleModule.Test.exe
+.\out\build\msvc-windows-x64-debug\Phantom.Coroutines.cppcoro.Test\Phantom.Coroutines.cppcoro.Test.exe
+```
+
+> **Note:** Use the test executables directly rather than `ctest`, as ctest spawns each test case as a separate process which is slow with AddressSanitizer enabled.
+
+> **Note:** If configure fails with `Could NOT find GTest`, delete `out\build\msvc-windows-x64-debug\CMakeCache.txt` and re-run configure. This can happen when the build directory was previously configured with a different toolchain.
+
+## C++ Modules
+
+The `Phantom.Coroutines.Modules` target builds C++ module support. Module linking is disabled for Clang builds (`DISABLE_LINK_MODULES=ON`) and can be disabled entirely with `-DDISABLE_COMPILE_MODULES=ON`.
diff --git a/CMakePresets.json b/CMakePresets.json
index 573ead5..be18f7c 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -123,6 +123,32 @@
       }
     }
   ],
+  "buildPresets": [
+    {
+      "name": "msvc-windows-x64-debug",
+      "configurePreset": "msvc-windows-x64-debug"
+    },
+    {
+      "name": "msvc-windows-x64-release",
+      "configurePreset": "msvc-windows-x64-release"
+    },
+    {
+      "name": "clang-windows-x64-debug",
+      "configurePreset": "clang-windows-x64-debug"
+    },
+    {
+      "name": "clang-windows-x64-release",
+      "configurePreset": "clang-windows-x64-release"
+    },
+    {
+      "name": "clang-linux-x64-debug",
+      "configurePreset": "clang-linux-x64-debug"
+    },
+    {
+      "name": "clang-linux-x64-release",
+      "configurePreset": "clang-linux-x64-release"
+    }
+  ],
   "testPresets": [
     {
       "name": "msvc-windows-x64-debug-unit",
@@ -132,6 +158,14 @@
       "name": "msvc-windows-x64-release-unit",
       "configurePreset": "msvc-windows-x64-release"
     },
+    {
+      "name": "clang-windows-x64-debug-unit",
+      "configurePreset": "clang-windows-x64-debug"
+    },
+    {
+      "name": "clang-windows-x64-release-unit",
+      "configurePreset": "clang-windows-x64-release"
+    },
     {
       "name": "clang-linux-x64-debug-unit",
       "configurePreset": "clang-linux-x64-debug"
@@ -141,4 +175,4 @@
       "configurePreset": "clang-linux-x64-release"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/Documentation/tracing.md b/Documentation/tracing.md
new file mode 100644
index 0000000..862c31c
--- /dev/null
+++ b/Documentation/tracing.md
@@ -0,0 +1,244 @@
+# Phantom.Coroutines Tracing
+
+The tracing system allows coroutine lifecycle events to be observed by attaching a *trace sink* to a
+`traced_promise`. The traced promise emits strongly-typed events before and after every coroutine
+lifecycle operation (initial/final suspend, `co_await`, `co_yield`, `co_return`, etc.) and delivers
+them to the trace sink.
+
+All tracing types live in `Phantom::Coroutines::tracing`.
+
+---
+
+## Trace Sinks
+
+A *trace sink* is any callable object. The `is_trace_sink` concept accepts every type:
+
+```cpp
+template<typename TraceSink>
+concept is_trace_sink = true;
+```
+
+The trace sink is called with two distinct kinds of arguments:
+
+| Argument kind | Purpose |
+|---|---|
+| `const events::event<...>&` | A lifecycle event has occurred — record or act on it. |
+| `const events::should_trace_return_value<Event>&` | A query asking whether to capture the return value for the next result event. |
+| `const events::should_capture_promise_creation_arguments<Event>&` | A query asking whether to capture promise creation arguments. |
+
+The two query types are described in detail below.
+
+---
+
+## Events
+
+Every event is an instance of `events::event<EventType, EventData, Accessors...>`. The three
+members of interest are:
+
+| Member | Type | Description |
+|---|---|---|
+| `SourceLocation` | `std::source_location` | Where the `co_await`/`co_yield`/etc. appears in source. |
+| `EventType` | `events::event_type<Label>` | Identifies the kind of event (e.g. `await_ready_result`). |
+| `EventData` | `events::event_data<...>` | Contextual data for the event (see below). |
+
+The convenience function `events::basic_event(sourceLocation, label, eventData)` builds a
+fully-typed event value.
+
+### Event labels
+
+Events are emitted in *begin / result / exception* triples for each operation:
+
+| Operation | Begin | Result | Exception |
+|---|---|---|---|
+| `initial_suspend` | `await_ready_begin` | `await_ready_result` | `await_ready_exception` |
+| `await_suspend` | `await_suspend_begin` | `await_suspend_result` | `await_suspend_exception` |
+| `await_resume` | `await_resume_begin` | `await_resume_result` | `await_resume_exception` |
+| `await_transform` | `await_transform_begin` | `await_transform_result` | `await_transform_exception` |
+| `unhandled_exception` | `unhandled_exception_begin` | `unhandled_exception_result` | `unhandled_exception_exception` |
+| `get_return_object` | `get_return_object_begin` | `get_return_object_result` | `get_return_object_exception` |
+| `yield_value` | `yield_value_begin` | `yield_value_result` | `yield_value_exception` |
+| `return_value` | `return_value_begin` | `return_value_result` | `return_value_exception` |
+| `return_void` | `return_void_begin` | `return_void_result` | `return_void_exception` |
+
+Additionally, `create_promise` and `destroy_promise` are emitted from the `traced_promise`
+constructor and destructor respectively.
+
+Each label type also inherits one or more tag structs (`event_is_begin`, `event_is_result`,
+`event_is_await_ready`, etc.) so filters can match broad categories without naming every label.
+
+### `event_data`
+
+`events::event_data<...>` is a template whose type parameters reflect which fields are populated.
+Fields that are absent use `empty_value` (or `empty_arguments_value` / `no_awaiter_type` for their
+respective categories). The `with()` method merges two `event_data` values, taking non-empty fields
+from the argument over empty fields from the receiver.
+
+| Field | Type when populated | Description |
+|---|---|---|
+| `Promise` | `T*` | Pointer to the underlying (untraced) promise. |
+| `TracedPromise` | `T*` | Pointer to the `traced_promise`. |
+| `PromiseCreationArguments` | `events::arguments<Args...>` | Arguments forwarded to the promise constructor (only when opted-in via `should_capture_promise_creation_arguments`). |
+| `Awaiter` | `T*` | Pointer to the wrapped awaiter. |
+| `TracedAwaiter` | `T*` | Pointer to the `traced_awaiter`. |
+| `AwaiterType` | One of the `*_awaiter_type` tag structs | Whether this awaiter is for initial suspend, final suspend, `co_yield`, or `co_await`. |
+| `MethodArguments` | `events::arguments<Args...>` | Arguments passed to the method (e.g. the handle for `await_suspend`, the value for `yield_value`). |
+| `MethodResult` | `events::value<T>` | Return value of the method — only present when opted-in via `should_trace_return_value`. |
+| `MethodException` | `events::value<std::exception_ptr>` | Exception caught by the method. |
+| `UnhandledException` | `events::value<std::exception_ptr>` | Exception from `unhandled_exception`. |
+| `YieldValue` | `events::value<T>` | Value passed to `co_yield`. |
+| `ReturnValue` | `events::value<T>` | Value passed to `co_return`. |
+
+---
+
+## Query protocol
+
+Two query types exist so the trace sink can control expensive optional features at compile time
+(and optionally at runtime).
+
+### `should_trace_return_value<Event>`
+
+By default, result events (e.g. `await_ready_result`) do **not** include the method's return value
+in `EventData.MethodResult`. Capturing the return value requires the value to be move- or
+copy-constructible and the trace sink to explicitly opt in.
+
+Before calling the wrapped method, `call_traced_method` checks the trace sink:
+
+1. **Sink not invocable** with `should_trace_return_value<Event>`, or **invocable but returns `void`**
+   → return value is **not** traced; `MethodResult` is `empty_value`.
+
+2. **Invocable and returns `std::true_type`**
+   → return value is **always** traced (compile-time decision, zero overhead).
+
+3. **Invocable and returns `std::false_type`**
+   → return value is **never** traced (compile-time decision).
+
+4. **Invocable and returns `bool`**
+   → the sink is queried at runtime; the return value is traced only when the query returns `true`.
+
+The `Event` template parameter of `should_trace_return_value<Event>` is the full `event_data` type
+that the result event *would* carry if the return value were traced (including all contextual fields
+such as `AwaiterType`). This lets the sink inspect which operation is being traced before deciding.
+
+#### Example: opting in unconditionally
+
+The helper `filters::trace_return_value(traceSink)` wraps any trace sink and adds a handler that
+returns `std::true_type` for every `should_trace_return_value` query:
+
+```cpp
+auto sink = filters::trace_return_value(my_trace_sink);
+// sink now receives result events with MethodResult populated.
+```
+
+#### Example: implementing the query manually
+
+```cpp
+struct my_trace_sink
+{
+    // Record lifecycle events.
+    void operator()(const auto& event) { /* ... */ }
+
+    // Opt in to return-value tracing for await_ready only.
+    std::true_type operator()(
+        const events::should_trace_return_value<auto>& query) const noexcept
+        requires events::is_event_type<
+            typename decltype(query)::event_type,
+            events::await_ready_result>
+    {
+        return {};
+    }
+};
+```
+
+> **Note:** filters such as `awaiter_type_fn` do *not* satisfy `should_trace_return_value` queries,
+> because `should_trace_return_value<Event>` has only a `using event_type = Event` member — it does
+> not expose `EventData`. A trace sink that only wraps a filter (and whose `operator()` returns
+> `void`) will **never** trace return values. Use `trace_return_value()` or add an explicit query
+> handler as shown above.
+
+### `should_capture_promise_creation_arguments<PromiseCreationEvent>`
+
+The same three-way protocol (`void` / `std::true_type` / `std::false_type` / `bool`) applies to
+`should_capture_promise_creation_arguments`. When opted-in, `PromiseCreationArguments` in the
+`create_promise` event data is populated with all arguments forwarded to the promise constructor.
+
+---
+
+## Filters
+
+Filters live in `Phantom::Coroutines::tracing::filters`. They are callable objects derived from
+`filters::filter` that return `std::true_type`, `std::false_type`, or `bool` depending on whether a
+given event matches. The `filter` base class provides a catch-all `operator()` that returns
+`std::false_type` for unrecognised event types.
+
+Filters compose with `&&`, `||`, and `!`. The composed result is again a `filter` that propagates
+compile-time `true_type`/`false_type` when possible.
+
+### Built-in filters
+
+| Filter | Matches |
+|---|---|
+| `filters::any_event` | Every event — always returns `std::true_type`. |
+| `filters::event_type<Label...>` | Events whose label type is one of `Label...`. |
+| `filters::awaiter_type<AwaiterType>` | Events whose `EventData.AwaiterType` is exactly `AwaiterType`. |
+
+### `constant_filtered_trace_sink` / `runtime_filtered_trace_sink`
+
+These helpers wrap a filter and a trace sink into a new trace sink:
+
+```cpp
+// Compile-time filtering: the sink call is entirely elided when filter(event) == false_type.
+auto sink = filters::constant_filtered_trace_sink(
+    filters::awaiter_type<events::initial_suspend_awaiter_type>,
+    my_trace_sink);
+
+// Runtime filtering.
+auto sink = filters::runtime_filtered_trace_sink(my_filter, my_trace_sink);
+```
+
+> **Note:** Queries (`should_trace_return_value`, `should_capture_promise_creation_arguments`)
+> bypass the filter entirely and are forwarded directly to the inner sink. The filter determines
+> which *events* to trace, not whether to answer interrogations about tracing behaviour.
+
+---
+
+## `traced_promise` and `traced_awaiter`
+
+`traced_promise<TraceSink, BasePromise>` wraps any `extensible_promise`-based promise type and
+intercepts every coroutine lifecycle method. It stores the trace sink and forwards it to each
+`traced_awaiter` it creates.
+
+`traced_awaiter<TraceSink, Awaitable, AwaiterType, BaseEventData>` wraps an awaitable and
+intercepts `await_ready`, `await_suspend`, and `await_resume`.
+
+Both use `call_traced_method` internally, which handles begin/result/exception event emission and
+the `should_trace_return_value` query protocol.
+
+### `suppress_trace`
+
+Wrap an awaitable in `suppress_trace{awaitable}` to bypass `await_transform` tracing for that
+particular `co_await`:
+
+```cpp
+co_await suppress_trace{ m_event.Wait() };
+```
+
+### Custom `trace` events
+
+Any `co_await` of a type derived from `tracing::trace` is intercepted and forwarded directly to the
+trace sink without suspending the coroutine:
+
+```cpp
+struct my_event : tracing::trace { /* fields */ };
+
+// Inside a coroutine whose promise is a traced_promise:
+co_await my_event{ /* data */ };
+```
+
+---
+
+## `composed_function`
+
+`composed_function<F1, F2, ...>` (from `functional.h`) inherits `operator()` from each function in
+the pack via `using`. This is the mechanism used by `trace_return_value()` to bolt a
+`should_trace_return_value` handler onto an existing trace sink without wrapping it in an outer
+lambda that would hide the query handler from the template machinery.
diff --git a/Phantom.Coroutines.Modules/CMakeLists.txt b/Phantom.Coroutines.Modules/CMakeLists.txt
index 0b3c9b2..27f5de4 100644
--- a/Phantom.Coroutines.Modules/CMakeLists.txt
+++ b/Phantom.Coroutines.Modules/CMakeLists.txt
@@ -51,6 +51,7 @@ target_sources(
     "extensible_promise.ixx"
     "fibonacci_heap.ixx" 
     "final_suspend_transfer.ixx"
+    "functional.ixx"
     "function_traits.ixx"
     "generator.ixx" 
     "immovable_object.ixx"
@@ -76,6 +77,7 @@ target_sources(
     "sync_wait.ixx"
     "tagged_pointer.ixx" 
     "task.ixx"
+#    "text_tracing.ixx"
     "thread_local_context.ixx"
     "thread_local_contextual_promise.ixx"
     "thread_local_storage.ixx" 
diff --git a/Phantom.Coroutines.Modules/Phantom.Coroutines.ixx b/Phantom.Coroutines.Modules/Phantom.Coroutines.ixx
index 0400313..d964aa5 100644
--- a/Phantom.Coroutines.Modules/Phantom.Coroutines.ixx
+++ b/Phantom.Coroutines.Modules/Phantom.Coroutines.ixx
@@ -32,6 +32,7 @@ export import Phantom.Coroutines.extensible_promise;
 export import Phantom.Coroutines.fibonacci_heap;
 export import Phantom.Coroutines.final_suspend_transfer;
 export import Phantom.Coroutines.function_traits;
+export import Phantom.Coroutines.functional;
 export import Phantom.Coroutines.generator;
 export import Phantom.Coroutines.immovable_object;
 export import Phantom.Coroutines.inline_scheduler;
diff --git a/Phantom.Coroutines.Modules/await_none_await_transform.ixx b/Phantom.Coroutines.Modules/await_none_await_transform.ixx
index 62afaa6..2825543 100644
--- a/Phantom.Coroutines.Modules/await_none_await_transform.ixx
+++ b/Phantom.Coroutines.Modules/await_none_await_transform.ixx
@@ -1,3 +1,4 @@
+module;
 #include "Phantom.Coroutines/detail/config_macros.h"
 export module Phantom.Coroutines.await_none_await_transform;
 import Phantom.Coroutines.type_traits;
diff --git a/Phantom.Coroutines.Modules/functional.ixx b/Phantom.Coroutines.Modules/functional.ixx
new file mode 100644
index 0000000..d1d587e
--- /dev/null
+++ b/Phantom.Coroutines.Modules/functional.ixx
@@ -0,0 +1,5 @@
+module;
+#include "Phantom.Coroutines/detail/config_macros.h"
+#include <utility>
+export module Phantom.Coroutines.functional;
+#include "Phantom.Coroutines/functional.h"
diff --git a/Phantom.Coroutines.Modules/make_task.ixx b/Phantom.Coroutines.Modules/make_task.ixx
index a4ee032..89bfb0c 100644
--- a/Phantom.Coroutines.Modules/make_task.ixx
+++ b/Phantom.Coroutines.Modules/make_task.ixx
@@ -3,6 +3,7 @@ module;
 #include <utility>
 #include "Phantom.Coroutines/detail/config_macros.h"
 export module Phantom.Coroutines.make_task;
+import Phantom.Coroutines.shared_task;
 import Phantom.Coroutines.task;
 import Phantom.Coroutines.type_traits;
 #include "Phantom.Coroutines/make_task.h"
diff --git a/Phantom.Coroutines.Modules/text_tracing.ixx b/Phantom.Coroutines.Modules/text_tracing.ixx
new file mode 100644
index 0000000..fc7f762
--- /dev/null
+++ b/Phantom.Coroutines.Modules/text_tracing.ixx
@@ -0,0 +1,6 @@
+module;
+#include <source_location>
+#include "Phantom.Coroutines/detail/config_macros.h"
+export module Phantom.Coroutines.text_tracing;
+import Phantom.Coroutines.tracing;
+#include "Phantom.Coroutines/text_tracing.h"
diff --git a/Phantom.Coroutines.Modules/tracing.ixx b/Phantom.Coroutines.Modules/tracing.ixx
index 18961db..f9a779f 100644
--- a/Phantom.Coroutines.Modules/tracing.ixx
+++ b/Phantom.Coroutines.Modules/tracing.ixx
@@ -4,11 +4,15 @@ module;
 #include <source_location>
 #include <tuple>
 #include <type_traits>
+#include <typeindex>
+#include <typeinfo>
 #include <utility>
 #include "Phantom.Coroutines/detail/config_macros.h"
 export module Phantom.Coroutines.tracing;
 import Phantom.Coroutines.awaiter_wrapper;
 import Phantom.Coroutines.coroutine;
+import Phantom.Coroutines.functional;
 import Phantom.Coroutines.extensible_promise;
+import Phantom.Coroutines.scope_guard;
 import Phantom.Coroutines.type_traits;
 #include "Phantom.Coroutines/tracing.h"
diff --git a/Phantom.Coroutines.Modules/value_awaiter.ixx b/Phantom.Coroutines.Modules/value_awaiter.ixx
index 4e1e3d4..cb5f781 100644
--- a/Phantom.Coroutines.Modules/value_awaiter.ixx
+++ b/Phantom.Coroutines.Modules/value_awaiter.ixx
@@ -1,4 +1,5 @@
 module;
+#include <utility>
 #include "Phantom.Coroutines/detail/config_macros.h"
 export module Phantom.Coroutines.value_awaiter;
 #include "Phantom.Coroutines/value_awaiter.h"
diff --git a/Phantom.Coroutines.Test/CMakeLists.txt b/Phantom.Coroutines.Test/CMakeLists.txt
index bcac685..8732bd0 100644
--- a/Phantom.Coroutines.Test/CMakeLists.txt
+++ b/Phantom.Coroutines.Test/CMakeLists.txt
@@ -18,9 +18,9 @@ set(
     "async_test.h"
     "atomic_state_test.cpp"
     "awaiter_list_test.cpp" 
+    "awaiters.h"
+    "awaiter_wrapper_test.cpp"   
     "contextual_promise_test.cpp" 
-    "detail/awaiter_wrapper_test.cpp"   
-    "detail/awaiters.h"
     "detail/fibonacci_heap_test.cpp"
     "detail/non_copyable_test.cpp"
     "detail/scope_guard_test.cpp"
@@ -48,13 +48,14 @@ set(
     "sync_wait_test.cpp"
     "tagged_pointer_test.cpp"
     "task_test.cpp"
+#    "text_tracing_test.cpp"
     "thread_local_contextual_promise_test.cpp"
     "thread_local_storage_test.cpp"
     "thread_pool_scheduler_test.cpp"
     "tracing_test.cpp"
     "type_traits_test.cpp"
     "value_awaiter_test.cpp"
- )
+)
 
 add_executable(
     Phantom.Coroutines.Test
@@ -75,6 +76,12 @@ target_link_libraries(
     GTest::gtest_main
 )
 
+target_compile_options(
+    Phantom.Coroutines.Test
+    PRIVATE
+    $<$<CXX_COMPILER_ID:MSVC>:/bigobj>
+)
+
 if(DISABLE_LINK_MODULES)
     add_library(
         Phantom.Coroutines.Modules.Test
@@ -115,6 +122,12 @@ target_link_libraries(
     GTest::gtest_main
 )
 
+target_compile_options(
+    Phantom.Coroutines.Modules.Test
+    PRIVATE
+    $<$<CXX_COMPILER_ID:MSVC>:/bigobj>
+)
+
 set_target_properties(
     Phantom.Coroutines.Modules.Test
     PROPERTIES
@@ -159,6 +172,12 @@ target_link_libraries(
     GTest::gtest_main
 )
 
+target_compile_options(
+    Phantom.Coroutines.SingleModule.Test
+    PRIVATE
+    $<$<CXX_COMPILER_ID:MSVC>:/bigobj>
+)
+
 set_target_properties(
     Phantom.Coroutines.SingleModule.Test
     PROPERTIES
diff --git a/Phantom.Coroutines.Test/async_mutex_test.cpp b/Phantom.Coroutines.Test/async_mutex_test.cpp
index cecaa95..1c4dbd2 100644
--- a/Phantom.Coroutines.Test/async_mutex_test.cpp
+++ b/Phantom.Coroutines.Test/async_mutex_test.cpp
@@ -1,6 +1,7 @@
 #include "Phantom.Coroutines/detail/config_macros.h"
 #include <chrono>
 #include <future>
+#include "async_test.h"
 #if defined(PHANTOM_COROUTINES_TESTING_SINGLE_MODULE)
 import Phantom.Coroutines;
 #elif defined(PHANTOM_COROUTINES_TESTING_MODULES)
@@ -18,7 +19,6 @@ import Phantom.Coroutines.task;
 #include "Phantom.Coroutines/policies.h"
 #include "Phantom.Coroutines/task.h"
 #endif
-#include "async_test.h"
 
 namespace Phantom::Coroutines
 {
diff --git a/Phantom.Coroutines.Test/async_test.h b/Phantom.Coroutines.Test/async_test.h
index 3b44b2e..c2af1c9 100644
--- a/Phantom.Coroutines.Test/async_test.h
+++ b/Phantom.Coroutines.Test/async_test.h
@@ -1,11 +1,11 @@
 #ifndef PHANTOM_COROUTINES_INCLUDE_ASYNC_TEST_H_H
 #define PHANTOM_COROUTINES_INCLUDE_ASYNC_TEST_H_H
 
-#include <coroutine>
 #include <gtest/gtest.h>
 #if defined(PHANTOM_COROUTINES_TESTING_SINGLE_MODULE)
 import Phantom.Coroutines;
 #elif defined(PHANTOM_COROUTINES_TESTING_MODULES)
+import Phantom.Coroutines.coroutine;
 import Phantom.Coroutines.reusable_task;
 #elif defined(PHANTOM_COROUTINES_TESTING_HEADERS)
 #include "Phantom.Coroutines/reusable_task.h"
diff --git a/Phantom.Coroutines.Test/detail/awaiter_wrapper_test.cpp b/Phantom.Coroutines.Test/awaiter_wrapper_test.cpp
similarity index 81%
rename from Phantom.Coroutines.Test/detail/awaiter_wrapper_test.cpp
rename to Phantom.Coroutines.Test/awaiter_wrapper_test.cpp
index 12ea133..458d6ba 100644
--- a/Phantom.Coroutines.Test/detail/awaiter_wrapper_test.cpp
+++ b/Phantom.Coroutines.Test/awaiter_wrapper_test.cpp
@@ -10,8 +10,9 @@ import Phantom.Coroutines;
 #include "Phantom.Coroutines/awaiter_wrapper.h"
 #endif
 
-namespace Phantom::Coroutines::detail
+namespace Phantom::Coroutines
 {
+
 template<
     typename Awaiter
 > struct awaiter_wrapper_test_awaiter
@@ -77,4 +78,22 @@ TEST(awaiter_wrapper_test, can_wrap_awaitable_rvalue)
     ASSERT_EQ(&wrapper.awaiter(), &awaitable.m_awaiter);
 }
 
+TEST(awaiter_wrapper_test, can_wrap_awaiter_with_co_await)
+{
+    // This class is both an awaitable and an awaiter.
+    // We check that the awaiter_wrapper picks the awaiter returned by co_await.
+    struct test_awaiter_with_co_await : generic_awaiter<void, void>
+    {
+        generic_awaiter<bool, int> m_awaiter;
+
+        auto& operator co_await()
+        {
+            return m_awaiter;
+        }
+    } awaitable;
+
+    awaiter_wrapper_test_awaiter<test_awaiter_with_co_await&&> wrapper{ [&]() -> auto&& { return std::move(awaitable); } };
+    ASSERT_EQ(&wrapper.awaiter(), &awaitable.m_awaiter);
+}
+
 }
\ No newline at end of file
diff --git a/Phantom.Coroutines.Test/detail/awaiters.h b/Phantom.Coroutines.Test/awaiters.h
similarity index 97%
rename from Phantom.Coroutines.Test/detail/awaiters.h
rename to Phantom.Coroutines.Test/awaiters.h
index 785c0f3..47f6c7f 100644
--- a/Phantom.Coroutines.Test/detail/awaiters.h
+++ b/Phantom.Coroutines.Test/awaiters.h
@@ -1,14 +1,14 @@
-#include <coroutine>
-#include <functional>
 #if defined(PHANTOM_COROUTINES_TESTING_SINGLE_MODULE)
 import Phantom.Coroutines;
 #elif defined(PHANTOM_COROUTINES_TESTING_MODULES)
 import Phantom.Coroutines.coroutine;
 #elif defined(PHANTOM_COROUTINES_TESTING_HEADERS)
+#include <coroutine>
+#include <functional>
 #include "Phantom.Coroutines/detail/coroutine.h"
 #endif
 
-namespace Phantom::Coroutines::detail
+namespace Phantom::Coroutines
 {
 
 // These types are used as placeholders in tests.
@@ -18,7 +18,7 @@ template<
 >
 struct typed_awaiter
 {
-    bool await_ready() { std::unreachable(); }
+    bool await_ready() const noexcept { std::unreachable(); }
     TSuspendResult await_suspend(coroutine_handle<>) { std::unreachable(); }
     TResumeResult await_resume() { std::unreachable(); }
 };
diff --git a/Phantom.Coroutines.Test/detail/non_copyable_test.cpp b/Phantom.Coroutines.Test/detail/non_copyable_test.cpp
index f473f94..f147ff3 100644
--- a/Phantom.Coroutines.Test/detail/non_copyable_test.cpp
+++ b/Phantom.Coroutines.Test/detail/non_copyable_test.cpp
@@ -1,3 +1,5 @@
+#include <concepts>
+#include <type_traits>
 #if defined(PHANTOM_COROUTINES_TESTING_SINGLE_MODULE)
 import Phantom.Coroutines;
 #elif defined(PHANTOM_COROUTINES_TESTING_MODULES)
@@ -5,8 +7,6 @@ import Phantom.Coroutines.non_copyable;
 #elif defined(PHANTOM_COROUTINES_TESTING_HEADERS)
 #include "Phantom.Coroutines/detail/non_copyable.h"
 #endif
-#include <concepts>
-#include <type_traits>
 
 namespace
 {
diff --git a/Phantom.Coroutines.Test/make_Task_test.cpp b/Phantom.Coroutines.Test/make_Task_test.cpp
index 8f117d5..245f1b2 100644
--- a/Phantom.Coroutines.Test/make_Task_test.cpp
+++ b/Phantom.Coroutines.Test/make_Task_test.cpp
@@ -30,7 +30,7 @@ ASYNC_TEST(make_task, Can_make_task_returning_void)
 ASYNC_TEST(make_task, Can_make_shared_task_returning_void)
 {
     async_manual_reset_event<> event;
-    auto result = make_task<shared_task>(event);
+    auto result = make_shared_task(event);
 
     static_assert(std::same_as<shared_task<>, decltype(result)>);
 
@@ -45,7 +45,7 @@ ASYNC_TEST(make_task, Can_make_shared_task_from_task)
     {
         co_return;
     };
-    auto result = make_task<shared_task>(lambda());
+    auto result = make_shared_task(lambda());
 
     static_assert(std::same_as<shared_task<>, decltype(result)>);
 
@@ -59,7 +59,7 @@ ASYNC_TEST(make_task, Can_make_shared_task_from_task_return_value)
     {
         co_return "hello world";
     };
-    auto result = make_task<shared_task>(lambda());
+    auto result = make_shared_task(lambda());
 
     static_assert(std::same_as<shared_task<std::string>, decltype(result)>);
 
diff --git a/Phantom.Coroutines.Test/reusable_task_test.cpp b/Phantom.Coroutines.Test/reusable_task_test.cpp
index fbb4490..81dd144 100644
--- a/Phantom.Coroutines.Test/reusable_task_test.cpp
+++ b/Phantom.Coroutines.Test/reusable_task_test.cpp
@@ -1,6 +1,7 @@
 #include <string>
 #include <type_traits>
 #include <gtest/gtest.h>
+#include "async_test.h"
 #if defined(PHANTOM_COROUTINES_TESTING_SINGLE_MODULE)
 import Phantom.Coroutines;
 import Phantom.Coroutines.Test.lifetime_tracker;
@@ -28,7 +29,6 @@ import Phantom.Coroutines.Test.pmr_task;
 #include "lifetime_tracker.h"
 #include "pmr_task.h"
 #endif
-#include "async_test.h"
 
 using namespace Phantom::Coroutines;
 using namespace Phantom::Coroutines::detail;
diff --git a/Phantom.Coroutines.Test/suspend_result_test.cpp b/Phantom.Coroutines.Test/suspend_result_test.cpp
index f56a8d7..528b84c 100644
--- a/Phantom.Coroutines.Test/suspend_result_test.cpp
+++ b/Phantom.Coroutines.Test/suspend_result_test.cpp
@@ -9,13 +9,10 @@ import Phantom.Coroutines.task;
 #include "Phantom.Coroutines/suspend_result.h"
 #include "Phantom.Coroutines/task.h"
 #endif
-#include "detail/awaiters.h"
+#include "awaiters.h"
 
 namespace Phantom::Coroutines
 {
-using detail::generic_awaiter;
-using detail::get_unusable_task;
-
 ASYNC_TEST(suspend_result_test, reports_not_suspended_for_await_ready_is_true)
 {
     auto testAwaiter = generic_awaiter<void, void>
diff --git a/Phantom.Coroutines.Test/sync_wait_test.cpp b/Phantom.Coroutines.Test/sync_wait_test.cpp
index c77b878..77b139a 100644
--- a/Phantom.Coroutines.Test/sync_wait_test.cpp
+++ b/Phantom.Coroutines.Test/sync_wait_test.cpp
@@ -12,7 +12,7 @@ import Phantom.Coroutines.task;
 #include "Phantom.Coroutines/sync_wait.h"
 #include "Phantom.Coroutines/task.h"
 #endif
-#include "detail/awaiters.h"
+#include "awaiters.h"
 #include <chrono>
 #include <future>
 
@@ -149,7 +149,7 @@ TEST(as_future_test, rethrows_exception_thrown_by_task_lambda)
 
 TEST(as_future_test, rethrows_exception_thrown_by_await_resume)
 {
-    struct awaitable : std::suspend_never
+    struct awaitable : suspend_never
     {
         void await_resume() 
         { 
diff --git a/Phantom.Coroutines.Test/task_test.cpp b/Phantom.Coroutines.Test/task_test.cpp
index 9912720..dff5e37 100644
--- a/Phantom.Coroutines.Test/task_test.cpp
+++ b/Phantom.Coroutines.Test/task_test.cpp
@@ -1,6 +1,7 @@
 #include <string>
 #include <type_traits>
 #include <gtest/gtest.h>
+#include "Phantom.Coroutines/detail/config_macros.h"
 #include "async_test.h"
 #if defined(PHANTOM_COROUTINES_TESTING_SINGLE_MODULE)
 import Phantom.Coroutines;
@@ -279,10 +280,8 @@ ASYNC_TEST(task_test, Can_use_returned_rvalue_reference)
             co_return std::move(initialValue);
         }();
 
-        [&]() {
-            EXPECT_EQ(2, statistics.instance_count);
-            EXPECT_EQ(1, statistics.move_construction_count);
-        }();
+        EXPECT_EQ(2, statistics.instance_count);
+        EXPECT_EQ(1, statistics.move_construction_count);
     }());
 
     EXPECT_TRUE(initialValue.moved_from());
@@ -294,22 +293,22 @@ ASYNC_TEST(task_test, Can_use_returned_rvalue_reference_with_same_address)
     lifetime_statistics statistics;
     lifetime_tracker initialValue = statistics.tracker();
 
-    co_await([&]() -> task<>
+    auto taskLambda = [&]() -> task<lifetime_tracker&&>
     {
-        [&](lifetime_tracker&& endValue) {
+        co_return std::move(initialValue);
+    };
 
-            endValue.use();
-            EXPECT_EQ(1, statistics.instance_count);
-            EXPECT_EQ(0, statistics.move_construction_count);
-        }(
-            co_await[&]() -> task<lifetime_tracker&&>
-        {
-            co_return std::move(initialValue);
-        }());
-    }());
+#if PHANTOM_COROUTINES_MSVC_INCORRECTLY_COPIES_CO_AWAIT_RVALUE_REFERENCE
+    auto&& endValue = std::move(co_await taskLambda());
+#else
+    auto&& endValue = co_await taskLambda();
+#endif
+
+    static_assert(std::same_as<lifetime_tracker&&, decltype(endValue)>);
 
-    EXPECT_FALSE(initialValue.moved_from());
     EXPECT_EQ(1, statistics.instance_count);
+    EXPECT_EQ(0, statistics.move_construction_count);
+    EXPECT_EQ(std::addressof(initialValue), std::addressof(endValue));
     EXPECT_FALSE(statistics.used_after_move);
 }
 
diff --git a/Phantom.Coroutines.Test/text_tracing_test.cpp b/Phantom.Coroutines.Test/text_tracing_test.cpp
new file mode 100644
index 0000000..1c9d619
--- /dev/null
+++ b/Phantom.Coroutines.Test/text_tracing_test.cpp
@@ -0,0 +1,16 @@
+#include "async_test.h"
+#include "Phantom.Coroutines/detail/config_macros.h"
+#if defined(PHANTOM_COROUTINES_TESTING_SINGLE_MODULE)
+import Phantom.Coroutines;
+#elif defined(PHANTOM_COROUTINES_TESTING_MODULES)
+import Phantom.Coroutines.text_tracing;
+#elif defined(PHANTOM_COROUTINES_TESTING_HEADERS)
+#include "Phantom.Coroutines/text_tracing.h"
+#endif
+
+namespace Phantom::Coroutines::tracing
+{
+
+
+
+}
diff --git a/Phantom.Coroutines.Test/tracing_test.cpp b/Phantom.Coroutines.Test/tracing_test.cpp
index aa16a74..91f38a4 100644
--- a/Phantom.Coroutines.Test/tracing_test.cpp
+++ b/Phantom.Coroutines.Test/tracing_test.cpp
@@ -1,8 +1,11 @@
 #include "async_test.h"
+#include <exception>
+#include <source_location>
 #include <typeindex>
 #include "Phantom.Coroutines/detail/config_macros.h"
 #if defined(PHANTOM_COROUTINES_TESTING_SINGLE_MODULE)
 import Phantom.Coroutines;
+import Phantom.Coroutines.Test.lifetime_tracker;
 #elif defined(PHANTOM_COROUTINES_TESTING_MODULES)
 import Phantom.Coroutines.config_globals;
 import Phantom.Coroutines.coroutine;
@@ -12,6 +15,8 @@ import Phantom.Coroutines.sync_wait;
 import Phantom.Coroutines.tracing;
 import Phantom.Coroutines.task;
 import Phantom.Coroutines.type_traits;
+import Phantom.Coroutines.value_awaiter;
+import Phantom.Coroutines.Test.lifetime_tracker;
 #elif defined(PHANTOM_COROUTINES_TESTING_HEADERS)
 #include "Phantom.Coroutines/detail/config_globals.h"
 #include "Phantom.Coroutines/polymorphic_promise.h"
@@ -19,6 +24,8 @@ import Phantom.Coroutines.type_traits;
 #include "Phantom.Coroutines/tracing.h"
 #include "Phantom.Coroutines/task.h"
 #include "Phantom.Coroutines/type_traits.h"
+#include "Phantom.Coroutines/value_awaiter.h"
+#include "lifetime_tracker.h"
 #endif
 
 namespace Phantom::Coroutines::tracing
@@ -53,27 +60,104 @@ struct tracing_tests : testing::Test
     >
     struct trace_sink
     {
-        traced_events_checker& checker;
-        
-        trace_sink(
-            trace_sink& other
-        ) : checker{ other.checker }
-        { }
+        const traced_events_checker& checker;
         
+        template<
+            typename ... Args
+        >
+            requires requires
+        {
+            get<const traced_events_checker&>(std::tie(std::declval<const Args&>()...));
+        }
         trace_sink(
-            const trace_sink& other
-        ) : checker{ other.checker }
+            const Args&... args
+        ) :
+            checker(get<const traced_events_checker&>(std::tie(args...)))
         { }
 
-        trace_sink(
-            auto&... args
-        ) :
-            checker(get<traced_events_checker&>(std::tie(args...)))
+        void operator()(const auto& traceEvent) const
+        {
+            if (Filter{}(traceEvent))
+            {
+                checker(&traceEvent);
+            }
+        }
+    };
+
+    struct throw_on_return
+    {
+        std::exception_ptr exception = std::make_exception_ptr(
+            std::runtime_error{
+                "Exception thrown on return"
+            }
+        );
+    };
+
+    struct throw_on_yield
+    {
+        std::exception_ptr exception = std::make_exception_ptr(
+            std::runtime_error{
+                "Exception thrown on yield"
+            }
+        );
+    };
+
+    struct throw_on_await_transform
+    {
+        std::exception_ptr exception = std::make_exception_ptr(
+            std::runtime_error{
+                "Exception thrown on await_transform"
+            }
+        );
+    };
+
+    struct throw_on_get_return_object
+    {
+        std::exception_ptr exception = std::make_exception_ptr(
+            std::runtime_error{
+                "Exception thrown on get_return_object"
+            }
+        );
+    };
+
+    struct throw_on_unhandled_exception
+    {
+        std::exception_ptr exception = std::make_exception_ptr(
+            std::runtime_error{
+                "Exception thrown on unhandled_exception"
+            }
+        );
+    };
+
+    struct tracing_return_value_tag {};
+
+    template<
+        typename Filter
+    >
+    struct trace_sink_tracing_return_value
+    {
+        const traced_events_checker& checker;
+
+        template<
+            typename ... Args
+        >
+            requires requires
         {
+            get<const traced_events_checker&>(std::tie(std::declval<const Args&>()...));
+        }
+        trace_sink_tracing_return_value(
+            const Args&... args
+        ) :
+            checker(get<const traced_events_checker&>(std::tie(args...)))
+        { }
 
+        template<typename Event>
+        std::true_type operator()(const events::should_trace_return_value<Event>&) const
+        {
+            return {};
         }
 
-        void operator()(const auto& traceEvent)
+        void operator()(const auto& traceEvent) const
         {
             if (Filter{}(traceEvent))
             {
@@ -82,72 +166,381 @@ struct tracing_tests : testing::Test
         }
     };
 
+    struct controllable_yield_promise_base
+        :
+        derived_promise<task_promise<void>>
+    {
+        using controllable_yield_promise_base::derived_promise::derived_promise;
+        using derived_promise<task_promise<void>>::await_transform;
+
+        std::exception_ptr exception_to_throw_on_yield;
+
+        Coroutines::detail::suspend_never await_transform(
+            this auto& self,
+            throw_on_yield throwOnYield)
+        {
+            self.exception_to_throw_on_yield = throwOnYield.exception;
+            return {};
+        }
+
+        Coroutines::detail::suspend_never yield_value(auto&&)
+        {
+            if (exception_to_throw_on_yield)
+            {
+                std::rethrow_exception(exception_to_throw_on_yield);
+            }
+            return {};
+        }
+    };
+
+    using test_yield_underlying_promise = polymorphic_promise<
+        controllable_yield_promise_base
+    >;
+
+    template<
+        typename Filter
+    >
+    using test_traced_yield_promise = traced_promise<
+        trace_sink<Filter>,
+        test_yield_underlying_promise
+    >;
+
+    template<
+        typename Filter
+    >
+    using test_traced_yield_promise_tracing_return_value = traced_promise<
+        trace_sink_tracing_return_value<Filter>,
+        test_yield_underlying_promise
+    >;
+
+    using test_traced_yield_task = basic_task<test_yield_underlying_promise>;
+
+    template<
+        typename Result
+    >
+    struct controllable_promise_base
+        :
+        derived_promise<task_promise<Result>>
+    {
+        std::exception_ptr exception_to_throw_on_return;
+        std::exception_ptr exception_to_throw_on_unhandled_exception;
+
+        using controllable_promise_base::derived_promise::derived_promise;
+        using derived_promise<task_promise<Result>>::await_transform;
+
+        Coroutines::detail::suspend_never await_transform(
+            throw_on_await_transform throwOnAwaitTransform)
+        {
+            std::rethrow_exception(throwOnAwaitTransform.exception);
+        }
+
+        Coroutines::detail::suspend_never await_transform(
+            this auto& self,
+            throw_on_return throwOnReturn)
+        {
+            self.exception_to_throw_on_return = throwOnReturn.exception;
+            return {};
+        }
+
+        Coroutines::detail::suspend_never await_transform(
+            this auto& self,
+            throw_on_unhandled_exception throwOnUnhandledException)
+        {
+            self.exception_to_throw_on_unhandled_exception = throwOnUnhandledException.exception;
+            return {};
+        }
+
+        void unhandled_exception()
+        {
+            if (exception_to_throw_on_unhandled_exception)
+            {
+                std::rethrow_exception(exception_to_throw_on_unhandled_exception);
+            }
+            derived_promise<task_promise<Result>>::unhandled_exception();
+        }
+    };
+
+    template<
+        typename Result
+    >
+    struct controllable_promise_return_value_or_void
+        :
+        controllable_promise_base<Result>
+    {
+        using controllable_promise_base<Result>::controllable_promise_base;
+
+        void return_value(
+            auto&& value)
+        {
+            if (this->exception_to_throw_on_return)
+            {
+                std::rethrow_exception(this->exception_to_throw_on_return);
+            }
+            this->controllable_promise_base<Result>::return_value(
+                std::forward<decltype(value)>(value));
+        }
+    };
+
+    template<
+    >
+    struct controllable_promise_return_value_or_void<
+        void
+    >
+        :
+        controllable_promise_base<void>
+    {
+        using controllable_promise_base<void>::controllable_promise_base;
+
+        void return_void()
+        {
+            if (this->exception_to_throw_on_return)
+            {
+                std::rethrow_exception(this->exception_to_throw_on_return);
+            }
+            else
+            {
+                return this->controllable_promise_base<void>::return_void();
+            }
+        }
+    };
+
+    template<
+        typename Result
+    >
+    struct controllable_promise
+        :
+        controllable_promise_return_value_or_void<Result>
+    {
+        using controllable_promise_return_value_or_void<Result>::controllable_promise_return_value_or_void;
+    };
+
+    template<
+        typename Result
+    >
+    using test_underlying_promise = polymorphic_promise<
+        controllable_promise<Result>
+    >;
+
+    template<
+        typename Result
+    >
+    struct throwing_get_return_object_promise_base
+        :
+        controllable_promise_base<Result>
+    {
+        using controllable_promise_base<Result>::controllable_promise_base;
+
+        [[noreturn]] static void throw_get_return_object()
+        {
+            throw std::runtime_error("Exception thrown on get_return_object");
+        }
+
+        auto get_return_object(this auto& self)
+            -> decltype(self.template controllable_promise_base<Result>::get_return_object())
+        {
+            throw_get_return_object();
+        }
+    };
+
+    template<
+        typename Result
+    >
+    struct throwing_get_return_object_promise
+        :
+        throwing_get_return_object_promise_base<Result>
+    {
+        using throwing_get_return_object_promise_base<Result>::throwing_get_return_object_promise_base;
+    };
+
+    template<
+        typename Result = void
+    >
+    using test_throwing_get_return_object_underlying_promise = polymorphic_promise<
+        throwing_get_return_object_promise<Result>
+    >;
+
+    template<
+        typename T = void
+    >
+    using test_throwing_get_return_object_task = basic_task<
+        test_throwing_get_return_object_underlying_promise<T>
+    >;
+
     template<
         typename Result,
         typename Filter
     >
     using test_traced_promise = traced_promise<
         trace_sink<Filter>,
-        polymorphic_promise<task_promise<Result>>
+        test_underlying_promise<Result>
     >;
 
     template<
-        typename T = void
+        typename Result,
+        typename Filter
     >
-    using test_traced_task = basic_task<polymorphic_promise<task_promise<T>>>;
+    using test_traced_promise_tracing_return_value = traced_promise<
+        trace_sink_tracing_return_value<Filter>,
+        test_underlying_promise<Result>
+    >;
 
     template<
-        typename EventType
+        typename T = void
     >
-    auto CastEventType(
-        const std::any& anyEvent)
+    using test_traced_task = basic_task<test_underlying_promise<T>>;
+
+    // --- Infrastructure for should_capture_promise_creation_arguments tests ---
+
+    struct should_capture_args_flag { bool value; };
+
+    struct capture_false_type_tag {};
+    struct capture_true_type_tag {};
+    struct capture_bool_tag {};
+
+    template<typename Result, typename Tag>
+    struct tagged_controllable_promise
+        :
+        controllable_promise<Result>
     {
-        // Get human-readable string for debugging purposes.
-        std::string expectedTypeName = typeid(const EventType*).name();
-        std::string actualTypeName = anyEvent.type().name();
-        EXPECT_EQ(expectedTypeName, actualTypeName);
+        using controllable_promise<Result>::controllable_promise;
+    };
 
-        return std::any_cast<const EventType*>(anyEvent);
-    }
+    template<typename Result, typename Tag>
+    using test_capture_underlying_promise = polymorphic_promise<
+        tagged_controllable_promise<Result, Tag>
+    >;
 
-    void ExpectIsInitialSuspend(
-        const auto* event
-    )
+    template<typename T = void, typename Tag = void>
+    using test_capture_task = basic_task<test_capture_underlying_promise<T, Tag>>;
+
+    template<typename Filter>
+    struct trace_sink_not_capturing_promise_args
     {
-        EXPECT_EQ(true, event->is_initial_suspend);
-        EXPECT_EQ(false, event->is_co_await);
-        EXPECT_EQ(false, event->is_co_yield);
-        EXPECT_EQ(false, event->is_final_suspend);
-    }
+        const traced_events_checker& checker;
 
-    void ExpectIsFinalSuspend(
-        const auto* event
-    )
+        template<typename... Args>
+            requires requires
+        {
+            get<const traced_events_checker&>(std::tie(std::declval<const Args&>()...));
+        }
+        trace_sink_not_capturing_promise_args(const Args&... args)
+            : checker(get<const traced_events_checker&>(std::tie(args...)))
+        {}
+
+        std::false_type operator()(const events::should_capture_promise_creation_arguments<events::create_promise>&) const
+        {
+            return {};
+        }
+
+        void operator()(const auto& traceEvent) const
+        {
+            if (Filter{}(traceEvent))
+            {
+                checker(&traceEvent);
+            }
+        }
+    };
+
+    template<typename Filter>
+    struct trace_sink_always_capturing_promise_args
     {
-        EXPECT_EQ(false, event->is_initial_suspend);
-        EXPECT_EQ(false, event->is_co_await);
-        EXPECT_EQ(false, event->is_co_yield);
-        EXPECT_EQ(true, event->is_final_suspend);
-    }
+        const traced_events_checker& checker;
 
-    void ExpectIsCoAwait(
-        const auto* event
-    )
+        template<typename... Args>
+            requires requires
+        {
+            get<const traced_events_checker&>(std::tie(std::declval<const Args&>()...));
+        }
+        trace_sink_always_capturing_promise_args(const Args&... args)
+            : checker(get<const traced_events_checker&>(std::tie(args...)))
+        {}
+
+        std::true_type operator()(const events::should_capture_promise_creation_arguments<events::create_promise>&) const
+        {
+            return {};
+        }
+
+        void operator()(const auto& traceEvent) const
+        {
+            if (Filter{}(traceEvent))
+            {
+                checker(&traceEvent);
+            }
+        }
+    };
+
+    template<typename Filter>
+    struct trace_sink_conditionally_capturing_promise_args
+    {
+        const traced_events_checker& checker;
+        bool capture;
+
+        template<typename... Args>
+            requires requires
+        {
+            get<const traced_events_checker&>(std::tie(std::declval<const Args&>()...));
+            get<const should_capture_args_flag&>(std::tie(std::declval<const Args&>()...));
+        }
+        trace_sink_conditionally_capturing_promise_args(const Args&... args)
+            : checker(get<const traced_events_checker&>(std::tie(args...)))
+            , capture(get<const should_capture_args_flag&>(std::tie(args...)).value)
+        {}
+
+        bool operator()(const events::should_capture_promise_creation_arguments<events::create_promise>&) const
+        {
+            return capture;
+        }
+
+        void operator()(const auto& traceEvent) const
+        {
+            if (Filter{}(traceEvent))
+            {
+                checker(&traceEvent);
+            }
+        }
+    };
+
+    template<typename Result, typename Filter>
+    using test_traced_promise_not_capturing_promise_args = traced_promise<
+        trace_sink_not_capturing_promise_args<Filter>,
+        test_capture_underlying_promise<Result, capture_false_type_tag>
+    >;
+
+    template<typename Result, typename Filter>
+    using test_traced_promise_always_capturing_promise_args = traced_promise<
+        trace_sink_always_capturing_promise_args<Filter>,
+        test_capture_underlying_promise<Result, capture_true_type_tag>
+    >;
+
+    template<typename Result, typename Filter>
+    using test_traced_promise_conditionally_capturing_promise_args = traced_promise<
+        trace_sink_conditionally_capturing_promise_args<Filter>,
+        test_capture_underlying_promise<Result, capture_bool_tag>
+    >;
+
+    template<
+        typename EventType
+    >
+    const EventType& CastEventType(
+        const std::any& anyEvent)
     {
-        EXPECT_EQ(false, event->is_initial_suspend);
-        EXPECT_EQ(true, event->is_co_await);
-        EXPECT_EQ(false, event->is_co_yield);
-        EXPECT_EQ(false, event->is_final_suspend);
+        // Get human-readable string for debugging purposes.
+        using expected_event_type = const EventType*;
+        std::string expectedTypeName = typeid(expected_event_type).name();
+        std::string actualTypeName = anyEvent.type().name();
+        EXPECT_EQ(expectedTypeName, actualTypeName);
+
+        return *std::any_cast<expected_event_type>(anyEvent);
     }
 
-    void ExpectIsCoYield(
-        const auto* event
-    )
+    template<
+        typename ExpectedEventType
+    >
+    const ExpectedEventType& CastEventType(
+        const std::any& anyEvent,
+        [[maybe_unused]] const ExpectedEventType& expectedEvent)
     {
-        EXPECT_EQ(false, event->is_initial_suspend);
-        EXPECT_EQ(false, event->is_co_await);
-        EXPECT_EQ(true, event->is_co_yield);
-        EXPECT_EQ(false, event->is_final_suspend);
+        return CastEventType<ExpectedEventType>(anyEvent);
     }
 
     struct test_awaiter_type_lambdas
@@ -332,594 +725,2842 @@ struct tracing_tests : testing::Test
         catch(Exception)
         { }
     }
-};
-} // namespace Phantom::Coroutines::tracing
 
-namespace std
-{
-template<
-    typename Result,
-    typename ... Args
->
-struct coroutine_traits<
-    Phantom::Coroutines::tracing::tracing_tests::test_traced_task<Result>,
+    template<
+        typename expected_event_type
+    >
+    bool compare_events(
+        const expected_event_type& expectedEvent,
+        const std::any& actualAny
+    )
+    {
+        auto& actualEvent = CastEventType<expected_event_type>(actualAny, expectedEvent);
+
+        if (expectedEvent.EventData.Promise != actualEvent.EventData.Promise)
+        {
+            return false;
+        }
+        if (expectedEvent.EventData.TracedPromise != actualEvent.EventData.TracedPromise)
+        {
+            return false;
+        }
+        if (expectedEvent.EventData.Awaiter != actualEvent.EventData.Awaiter)
+        {
+            return false;
+        }
+        if (expectedEvent.EventData.TracedAwaiter != actualEvent.EventData.TracedAwaiter)
+        {
+            return false;
+        }
+        if (expectedEvent.EventType != actualEvent.EventType)
+        {
+            return false;
+        }
+        
+        return true;
+    }
+
+    void expect_events_equal(
+        const auto& expectedEvent,
+        const std::any& actualAny
+    )
+    {
+        EXPECT_TRUE(compare_events(expectedEvent, actualAny));
+    }
+};
+} // namespace Phantom::Coroutines::tracing
+
+namespace std
+{
+template<
+    typename Result,
+    typename ... Args
+>
+struct coroutine_traits<
+    Phantom::Coroutines::tracing::tracing_tests::test_traced_task<Result>,
+    Args...
+>
+{
+    static constexpr bool has_return_value_tracing =
+        (std::is_same_v<Phantom::Coroutines::tracing::tracing_tests::tracing_return_value_tag, Args> || ...);
+
+    static constexpr auto get_filter(const Args& ... args)
+    {
+        auto tuple = std::tie(args...);
+        auto filter = Phantom::Coroutines::detail::tuple_extract_convertible_elements<
+            const Phantom::Coroutines::tracing::filters::filter&
+        >(tuple);
+
+        if constexpr (std::same_as<std::tuple<>, decltype(filter)>)
+        {
+            return Phantom::Coroutines::tracing::filters::any_event;
+        }
+        else
+        {
+            return get<0>(filter);
+        }
+    }
+
+    using filter_type = decltype(get_filter(std::declval<Args>()...));
+    using promise_type = std::conditional_t<
+        has_return_value_tracing,
+        Phantom::Coroutines::tracing::tracing_tests::test_traced_promise_tracing_return_value<Result, filter_type>,
+        Phantom::Coroutines::tracing::tracing_tests::test_traced_promise<Result, filter_type>
+    >;
+};
+
+template<
+    typename ... Args
+>
+struct coroutine_traits<
+    Phantom::Coroutines::tracing::tracing_tests::test_traced_yield_task,
+    Args...
+>
+{
+    static constexpr bool has_return_value_tracing =
+        (std::is_same_v<Phantom::Coroutines::tracing::tracing_tests::tracing_return_value_tag, Args> || ...);
+
+    static constexpr auto get_filter(const Args& ... args)
+    {
+        auto tuple = std::tie(args...);
+        auto filter = Phantom::Coroutines::detail::tuple_extract_convertible_elements<
+            const Phantom::Coroutines::tracing::filters::filter&
+        >(tuple);
+
+        if constexpr (std::same_as<std::tuple<>, decltype(filter)>)
+        {
+            return Phantom::Coroutines::tracing::filters::any_event;
+        }
+        else
+        {
+            return get<0>(filter);
+        }
+    }
+
+    using filter_type = decltype(get_filter(std::declval<Args>()...));
+    using promise_type = std::conditional_t<
+        has_return_value_tracing,
+        Phantom::Coroutines::tracing::tracing_tests::test_traced_yield_promise_tracing_return_value<filter_type>,
+        Phantom::Coroutines::tracing::tracing_tests::test_traced_yield_promise<filter_type>
+    >;
+};
+
+template<
+    typename Result,
+    typename ... Args
+>
+struct coroutine_traits<
+    Phantom::Coroutines::tracing::tracing_tests::test_throwing_get_return_object_task<Result>,
+    Args...
+>
+{
+    static constexpr auto get_filter(const Args& ... args)
+    {
+        auto tuple = std::tie(args...);
+        auto filter = Phantom::Coroutines::detail::tuple_extract_convertible_elements<
+            const Phantom::Coroutines::tracing::filters::filter&
+        >(tuple);
+
+        if constexpr (std::same_as<std::tuple<>, decltype(filter)>)
+        {
+            return Phantom::Coroutines::tracing::filters::any_event;
+        }
+        else
+        {
+            return get<0>(filter);
+        }
+    }
+
+    using filter_type = decltype(get_filter(std::declval<Args>()...));
+    using promise_type = Phantom::Coroutines::tracing::traced_promise<
+        Phantom::Coroutines::tracing::tracing_tests::trace_sink<filter_type>,
+        Phantom::Coroutines::tracing::tracing_tests::test_throwing_get_return_object_underlying_promise<Result>
+    >;
+};
+
+template<
+    typename Result,
+    typename ... Args
+>
+struct coroutine_traits<
+    Phantom::Coroutines::tracing::tracing_tests::test_capture_task<Result, Phantom::Coroutines::tracing::tracing_tests::capture_false_type_tag>,
+    Args...
+>
+{
+    static constexpr auto get_filter(const Args& ... args)
+    {
+        auto tuple = std::tie(args...);
+        auto filter = Phantom::Coroutines::detail::tuple_extract_convertible_elements<
+            const Phantom::Coroutines::tracing::filters::filter&
+        >(tuple);
+
+        if constexpr (std::same_as<std::tuple<>, decltype(filter)>)
+        {
+            return Phantom::Coroutines::tracing::filters::any_event;
+        }
+        else
+        {
+            return get<0>(filter);
+        }
+    }
+
+    using filter_type = decltype(get_filter(std::declval<Args>()...));
+    using promise_type = Phantom::Coroutines::tracing::tracing_tests::test_traced_promise_not_capturing_promise_args<Result, filter_type>;
+};
+
+template<
+    typename Result,
+    typename ... Args
+>
+struct coroutine_traits<
+    Phantom::Coroutines::tracing::tracing_tests::test_capture_task<Result, Phantom::Coroutines::tracing::tracing_tests::capture_true_type_tag>,
+    Args...
+>
+{
+    static constexpr auto get_filter(const Args& ... args)
+    {
+        auto tuple = std::tie(args...);
+        auto filter = Phantom::Coroutines::detail::tuple_extract_convertible_elements<
+            const Phantom::Coroutines::tracing::filters::filter&
+        >(tuple);
+
+        if constexpr (std::same_as<std::tuple<>, decltype(filter)>)
+        {
+            return Phantom::Coroutines::tracing::filters::any_event;
+        }
+        else
+        {
+            return get<0>(filter);
+        }
+    }
+
+    using filter_type = decltype(get_filter(std::declval<Args>()...));
+    using promise_type = Phantom::Coroutines::tracing::tracing_tests::test_traced_promise_always_capturing_promise_args<Result, filter_type>;
+};
+
+template<
+    typename Result,
+    typename ... Args
+>
+struct coroutine_traits<
+    Phantom::Coroutines::tracing::tracing_tests::test_capture_task<Result, Phantom::Coroutines::tracing::tracing_tests::capture_bool_tag>,
     Args...
 >
 {
     static constexpr auto get_filter(const Args& ... args)
     {
-        auto tuple = std::tie(args...);
-        auto filter = Phantom::Coroutines::detail::tuple_extract_convertible_elements<
-            const Phantom::Coroutines::tracing::filters::filter&
-        >(tuple);
+        auto tuple = std::tie(args...);
+        auto filter = Phantom::Coroutines::detail::tuple_extract_convertible_elements<
+            const Phantom::Coroutines::tracing::filters::filter&
+        >(tuple);
+
+        if constexpr (std::same_as<std::tuple<>, decltype(filter)>)
+        {
+            return Phantom::Coroutines::tracing::filters::any_event;
+        }
+        else
+        {
+            return get<0>(filter);
+        }
+    }
+
+    using filter_type = decltype(get_filter(std::declval<Args>()...));
+    using promise_type = Phantom::Coroutines::tracing::tracing_tests::test_traced_promise_conditionally_capturing_promise_args<Result, filter_type>;
+};
+
+}
+
+namespace Phantom::Coroutines::tracing
+{
+
+ASYNC_TEST_F(tracing_tests, trace_return_value_moves_value)
+{
+    auto filter = filters::event_type<
+        events::await_resume_result,
+        // Verifies that we -only- get the result event.
+        events::await_resume_exception
+    > && filters::awaiter_type<
+        events::co_await_awaiter_type
+    >;
+
+    lifetime_statistics lifetimeStatistics;
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        auto filter
+        ) -> test_traced_task<void>
+    {
+        EXPECT_EQ(0, lifetimeStatistics.copy_construction_count);
+        EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+        auto tracker = co_await value_awaiter { lifetimeStatistics.tracker() };
+        EXPECT_EQ(0, lifetimeStatistics.copy_construction_count);
+        EXPECT_EQ(1, lifetimeStatistics.move_construction_count);
+    };
+
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&] (const std::any&)
+    {
+    } };
+
+    co_await taskLambda(
+        tracedEventsChecker,
+        filter);
+
+    EXPECT_EQ(1, lifetimeStatistics.move_construction_count);
+}
+
+ASYNC_TEST_F(tracing_tests, trace_return_value_of_non_movable_value_copies_value)
+{
+    struct value_type
+    {
+        lifetime_tracker tracker;
+
+        value_type(lifetime_statistics& lifetimeStatistics)
+            : tracker(lifetimeStatistics)
+        {
+        }
+
+        value_type(const value_type&) = default;
+        value_type(value_type&&) = delete;
+    };
+
+    static_assert(!std::is_move_constructible_v<value_type>);
+    static_assert(std::is_copy_constructible_v<value_type>);
+    static_assert(std::is_move_constructible_v<value_type&>);
+    static_assert(std::is_copy_constructible_v<value_type&>);
+
+    auto filter = filters::event_type<
+        events::await_resume_result,
+        // Verifies that we -only- get the result event.
+        events::await_resume_exception
+    > && filters::awaiter_type<
+        events::co_await_awaiter_type
+    >;
+
+    lifetime_statistics lifetimeStatistics;
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        auto filter
+        ) -> test_traced_task<void>
+    {
+        EXPECT_EQ(0, lifetimeStatistics.copy_construction_count);
+        EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+        auto awaiter = value_awaiter{ value_type { lifetimeStatistics } };
+        auto result = co_await awaiter;
+        static_assert(std::same_as<value_type, decltype(result)>);
+        EXPECT_EQ(1, lifetimeStatistics.copy_construction_count);
+        EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+    };
+
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&] (const std::any&)
+    {
+    } };
+
+    co_await taskLambda(
+        tracedEventsChecker,
+        filter);
+
+    EXPECT_EQ(1, lifetimeStatistics.copy_construction_count);
+    EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+}
+
+ASYNC_TEST_F(tracing_tests, trace_return_value_of_non_copyable_value_does_not_trace_value)
+{
+    struct value_type
+    {
+        lifetime_tracker tracker;
+
+        value_type(lifetime_statistics& lifetimeStatistics)
+            : tracker(lifetimeStatistics)
+        {
+        }
+
+        value_type(const value_type&) = delete;
+    };
+
+    static_assert(!std::is_move_constructible_v<value_type>);
+    static_assert(!std::is_copy_constructible_v<value_type>);
+    static_assert(std::is_move_constructible_v<value_type&>);
+    static_assert(std::is_copy_constructible_v<value_type&>);
+
+    auto filter = filters::event_type<
+        events::await_resume_result,
+        // Verifies that we -only- get the result event.
+        events::await_resume_exception
+    > && filters::awaiter_type<
+        events::co_await_awaiter_type
+    >;
+
+    lifetime_statistics lifetimeStatistics;
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        auto filter
+        ) -> test_traced_task<void>
+    {
+        EXPECT_EQ(0, lifetimeStatistics.copy_construction_count);
+        EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+        auto awaiter = value_awaiter{ value_type { lifetimeStatistics } };
+        auto& result = co_await awaiter;
+        static_assert(std::same_as<const value_type&, decltype(result)>);
+        EXPECT_EQ(0, lifetimeStatistics.copy_construction_count);
+        EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+    };
+
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&] (const std::any&)
+    {
+    } };
+
+    co_await taskLambda(
+        tracedEventsChecker,
+        filter);
+
+    EXPECT_EQ(0, lifetimeStatistics.copy_construction_count);
+    EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_create_and_destroy_promise)
+{
+    auto filter = filters::event_type<
+        events::create_promise,
+        events::destroy_promise
+    >;
+
+    auto taskLambda = [](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        auto filter
+        ) -> test_traced_task<>
+        {
+            co_return;
+        };
+    using taskLambda_type = decltype(taskLambda);
+
+    using expected_promise_type = test_underlying_promise<void>;
+    using expected_traced_promise_type = test_traced_promise<void, decltype(filter)>;
+
+    expected_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .PromiseCreationArguments = events::make_arguments(
+                    taskLambda,
+                    tracedEventsChecker,
+                    filter),
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::create_promise{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = actualEvent.EventData.Promise;
+            expectedTracedPromise = actualEvent.EventData.TracedPromise;
+            expectedEvent.EventData.Promise = expectedPromise;
+            expectedEvent.EventData.TracedPromise = expectedTracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::destroy_promise{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await taskLambda(tracedEventsChecker, filter);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_initial_suspend)
+{
+    auto filter =
+        filters::awaiter_type<events::initial_suspend_awaiter_type>;
+
+    auto taskLambda = [](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            co_return;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<>,
+        traced_events_checker&,
+        decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_underlying_promise<void>;
+
+    // The unwrapped awaiter type - what the underlying promise's initial_suspend() returns
+    using unwrapped_awaiter_type = suspend_always;
+    using expected_traced_awaiter_type = decltype(std::declval<expected_traced_promise_type&>().initial_suspend());
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+    unwrapped_awaiter_type* expectedAwaiter = nullptr;
+    expected_traced_awaiter_type* expectedTracedAwaiter = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .Awaiter = static_cast<unwrapped_awaiter_type*>(nullptr),
+                .TracedAwaiter = static_cast<expected_traced_awaiter_type*>(nullptr),
+                .AwaiterType = events::initial_suspend_awaiter_type{},
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_ready_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+            expectedAwaiter = expectedEvent.EventData.Awaiter = actualEvent.EventData.Awaiter;
+            expectedTracedAwaiter = expectedEvent.EventData.TracedAwaiter = actualEvent.EventData.TracedAwaiter;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::initial_suspend_awaiter_type{},
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_ready_result{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::initial_suspend_awaiter_type{},
+                .MethodArguments = events::make_arguments(
+                    std::coroutine_handle<expected_traced_promise_type>::from_promise(*expectedTracedPromise)
+                )
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_suspend_begin{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::initial_suspend_awaiter_type{},
+                .MethodArguments = events::make_arguments(
+                    std::coroutine_handle<expected_traced_promise_type>::from_promise(*expectedTracedPromise)
+                )
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_suspend_result{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::initial_suspend_awaiter_type{},
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_resume_begin{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::initial_suspend_awaiter_type{},
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_resume_result{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await taskLambda(tracedEventsChecker, filter);
+    EXPECT_EQ(eventIndex, 6);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_final_suspend)
+{
+    auto filter = filters::awaiter_type<events::final_suspend_awaiter_type>;
+
+    auto taskLambda = [](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            co_return;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<>,
+        traced_events_checker&,
+        decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_underlying_promise<void>;
+
+    // The unwrapped awaiter type - what the underlying promise's final_suspend() returns
+    using expected_awaiter_type = final_suspend_transfer;
+    using expected_traced_awaiter_type = decltype(std::declval<expected_traced_promise_type&>().final_suspend());
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+    expected_awaiter_type* expectedAwaiter = nullptr;
+    expected_traced_awaiter_type* expectedTracedAwaiter = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .Awaiter = static_cast<expected_awaiter_type*>(nullptr),
+                .TracedAwaiter = static_cast<expected_traced_awaiter_type*>(nullptr),
+                .AwaiterType = events::final_suspend_awaiter_type{},
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_ready_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+            expectedAwaiter = expectedEvent.EventData.Awaiter = actualEvent.EventData.Awaiter;
+            expectedTracedAwaiter = expectedEvent.EventData.TracedAwaiter = actualEvent.EventData.TracedAwaiter;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::final_suspend_awaiter_type{},
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_ready_result{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::final_suspend_awaiter_type{},
+                .MethodArguments = events::make_arguments(
+                    std::coroutine_handle<expected_traced_promise_type>::from_promise(*expectedTracedPromise)
+                )
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_suspend_begin{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::final_suspend_awaiter_type{},
+                .MethodArguments = events::make_arguments(
+                    std::coroutine_handle<expected_traced_promise_type>::from_promise(*expectedTracedPromise)
+                ),
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_suspend_result{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await taskLambda(tracedEventsChecker, filter);
+    // Note that await_resume is not expected for final_suspend_transfer,
+    // so we only expect await_ready, await_suspend events.
+    EXPECT_EQ(eventIndex, 4);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_await_ready_exception)
+{
+    auto filter = 
+        filters::awaiter_type<events::co_await_awaiter_type>
+        &&
+        filters::event_type<
+            events::await_ready_begin,
+            events::await_ready_result,
+            events::await_ready_exception
+        >;
+
+    auto awaiter = test_awaiter().with_await_ready_exception(
+        std::runtime_error{ "await_ready exception" });
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            co_await awaiter;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_underlying_promise<void>;
+
+    using expected_awaiter_type = decltype(awaiter);
+    using expected_traced_awaiter_type = decltype(std::declval<expected_traced_promise_type&>().await_transform(awaiter));
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+    expected_awaiter_type* expectedAwaiter = nullptr;
+    expected_traced_awaiter_type* expectedTracedAwaiter = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .Awaiter = static_cast<expected_awaiter_type*>(nullptr),
+                .TracedAwaiter = static_cast<expected_traced_awaiter_type*>(nullptr),
+                .AwaiterType = events::co_await_awaiter_type{},
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_ready_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+            expectedAwaiter = expectedEvent.EventData.Awaiter = actualEvent.EventData.Awaiter;
+            expectedTracedAwaiter = expectedEvent.EventData.TracedAwaiter = actualEvent.EventData.TracedAwaiter;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            std::exception_ptr actualException;
+
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::co_await_awaiter_type{},
+                .MethodException = events::value{ actualException }
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_ready_exception{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+            actualException = actualEvent.EventData.MethodException.Value;
+            
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+
+            EXPECT_THROW(
+                std::rethrow_exception(
+                    actualEvent.EventData.MethodException.Value
+                ),
+                std::runtime_error
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await expect_exception<std::runtime_error>(taskLambda(tracedEventsChecker, filter));
+    EXPECT_EQ(eventIndex, 2);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_await_suspend_exception)
+{
+    auto filter = 
+        filters::awaiter_type<events::co_await_awaiter_type>
+        &&
+        filters::event_type<
+            events::await_ready_begin,
+            events::await_ready_result,
+            events::await_suspend_begin,
+            events::await_suspend_result,
+            events::await_suspend_exception
+        >;
+
+    auto awaiter = test_awaiter()
+        .with_await_ready_false()
+        .with_await_suspend_exception<void>(std::runtime_error{ "await_suspend exception" });
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            co_await awaiter;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_underlying_promise<void>;
+
+    using expected_awaiter_type = decltype(awaiter);
+    using expected_traced_awaiter_type = decltype(std::declval<expected_traced_promise_type&>().await_transform(awaiter));
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+    expected_awaiter_type* expectedAwaiter = nullptr;
+    expected_traced_awaiter_type* expectedTracedAwaiter = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .Awaiter = static_cast<expected_awaiter_type*>(nullptr),
+                .TracedAwaiter = static_cast<expected_traced_awaiter_type*>(nullptr),
+                .AwaiterType = events::co_await_awaiter_type{},
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_ready_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+            expectedAwaiter = expectedEvent.EventData.Awaiter = actualEvent.EventData.Awaiter;
+            expectedTracedAwaiter = expectedEvent.EventData.TracedAwaiter = actualEvent.EventData.TracedAwaiter;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::co_await_awaiter_type{},
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_ready_result{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::co_await_awaiter_type{},
+                .MethodArguments = events::make_arguments(
+                    std::coroutine_handle<expected_traced_promise_type>::from_promise(*expectedTracedPromise)
+                )
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_suspend_begin{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            std::exception_ptr actualException;
+
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::co_await_awaiter_type{},
+                .MethodArguments = events::make_arguments(
+                    std::coroutine_handle<expected_traced_promise_type>::from_promise(*expectedTracedPromise)
+                ),
+                .MethodException = events::value{ actualException }
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_suspend_exception{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+            actualException = actualEvent.EventData.MethodException.Value;
+            
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+
+            EXPECT_THROW(
+                std::rethrow_exception(
+                    actualEvent.EventData.MethodException.Value
+                ),
+                std::runtime_error
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await expect_exception<std::runtime_error>(taskLambda(tracedEventsChecker, filter));
+    EXPECT_EQ(eventIndex, 4);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_await_resume_exception)
+{
+    auto filter = 
+        filters::awaiter_type<events::co_await_awaiter_type>
+        &&
+        filters::event_type<
+            events::await_ready_begin,
+            events::await_ready_result,
+            events::await_suspend_begin,
+            events::await_suspend_result,
+            events::await_resume_begin,
+            events::await_resume_exception
+        >;
+
+    auto awaiter = test_awaiter()
+        .with_await_ready_true()
+        .with_await_resume_exception<void>(std::runtime_error{ "await_resume exception" });
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            co_await awaiter;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_underlying_promise<void>;
+
+    using expected_awaiter_type = decltype(awaiter);
+    using expected_traced_awaiter_type = decltype(std::declval<expected_traced_promise_type&>().await_transform(awaiter));
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+    expected_awaiter_type* expectedAwaiter = nullptr;
+    expected_traced_awaiter_type* expectedTracedAwaiter = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .Awaiter = static_cast<expected_awaiter_type*>(nullptr),
+                .TracedAwaiter = static_cast<expected_traced_awaiter_type*>(nullptr),
+                .AwaiterType = events::co_await_awaiter_type{},
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_ready_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+            expectedAwaiter = expectedEvent.EventData.Awaiter = actualEvent.EventData.Awaiter;
+            expectedTracedAwaiter = expectedEvent.EventData.TracedAwaiter = actualEvent.EventData.TracedAwaiter;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::co_await_awaiter_type{},
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_ready_result{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::co_await_awaiter_type{},
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_resume_begin{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            std::exception_ptr actualException;
+
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .Awaiter = expectedAwaiter,
+                .TracedAwaiter = expectedTracedAwaiter,
+                .AwaiterType = events::co_await_awaiter_type{},
+                .MethodException = events::value{ actualException }
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_resume_exception{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+            actualException = actualEvent.EventData.MethodException.Value;
+            
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+
+            EXPECT_THROW(
+                std::rethrow_exception(
+                    actualEvent.EventData.MethodException.Value
+                ),
+                std::runtime_error
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await expect_exception<std::runtime_error>(taskLambda(tracedEventsChecker, filter));
+    EXPECT_EQ(eventIndex, 4);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_return_value)
+{
+    auto filter = 
+        filters::event_type<
+            events::return_value_begin,
+            events::return_value_result
+        >;
+
+    std::string expectedReturnValue = "test return value";
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<std::string>
+        {
+            co_return expectedReturnValue;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<std::string>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_underlying_promise<std::string>;
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .MethodArguments = events::make_arguments(expectedReturnValue)
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::return_value_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .MethodArguments = events::make_arguments(expectedReturnValue)
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::return_value_result{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    auto result = co_await taskLambda(tracedEventsChecker, filter);
+    EXPECT_EQ(result, expectedReturnValue);
+    EXPECT_EQ(eventIndex, 2);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_return_value_exception)
+{
+    auto filter = 
+        filters::event_type<
+            events::return_value_begin,
+            events::return_value_exception
+        >;
+
+    std::string return_value = "test return value";
+    throw_on_return throw_on_return_awaiter;
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<std::string>
+        {
+            co_await throw_on_return_awaiter;
+            co_return return_value;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<std::string>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_underlying_promise<std::string>;
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .MethodArguments = events::make_arguments(return_value)
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::return_value_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            std::exception_ptr actualException;
+
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .MethodArguments = events::make_arguments(return_value),
+                .MethodException = events::value { throw_on_return_awaiter.exception },
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::return_value_exception{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await expect_exception<std::runtime_error>(taskLambda(tracedEventsChecker, filter));
+    EXPECT_EQ(eventIndex, 2);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_return_void)
+{
+    auto filter = 
+        filters::event_type<
+            events::return_void_begin,
+            events::return_void_result
+        >;
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            co_return;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_underlying_promise<void>;
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::return_void_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::return_void_result{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await taskLambda(tracedEventsChecker, filter);
+    EXPECT_EQ(eventIndex, 2);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_return_void_exception)
+{
+    auto filter = 
+        filters::event_type<
+            events::return_void_begin,
+            events::return_void_exception
+        >;
+
+    throw_on_return throw_on_return_awaiter;
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            co_await throw_on_return_awaiter;
+            co_return;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_underlying_promise<void>;
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::return_void_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .MethodException = events::value{ throw_on_return_awaiter.exception }
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::return_void_exception{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await expect_exception<std::runtime_error>(taskLambda(tracedEventsChecker, filter));
+    EXPECT_EQ(eventIndex, 2);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_unhandled_exception)
+{
+    auto filter = 
+        filters::event_type<
+            events::unhandled_exception_begin,
+            events::unhandled_exception_result
+        >;
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            throw std::runtime_error("unhandled exception");
+            co_return;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_underlying_promise<void>;
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::unhandled_exception_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::unhandled_exception_result{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await expect_exception<std::runtime_error>(taskLambda(tracedEventsChecker, filter));
+    EXPECT_EQ(eventIndex, 2);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_yield_value)
+{
+    auto filter =
+        filters::event_type<
+            events::yield_value_begin,
+            events::yield_value_result
+        >;
+
+    int yieldedValue = 42;
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_yield_task
+        {
+            co_yield yieldedValue;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_yield_task,
+        traced_events_checker&,
+        decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_yield_underlying_promise;
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .MethodArguments = events::make_arguments(yieldedValue),
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::yield_value_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .MethodArguments = events::make_arguments(yieldedValue),
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::yield_value_result{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await taskLambda(tracedEventsChecker, filter);
+    EXPECT_EQ(eventIndex, 2);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_yield_value_exception)
+{
+    auto filter =
+        filters::event_type<
+            events::yield_value_begin,
+            events::yield_value_exception
+        >;
+
+    int yieldedValue = 42;
+    throw_on_yield throw_on_yield_awaiter;
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_yield_task
+        {
+            co_await throw_on_yield_awaiter;
+            co_yield yieldedValue;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_yield_task,
+        traced_events_checker&,
+        decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_yield_underlying_promise;
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .MethodArguments = events::make_arguments(yieldedValue),
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::yield_value_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .MethodArguments = events::make_arguments(yieldedValue),
+                .MethodException = events::value{ throw_on_yield_awaiter.exception },
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::yield_value_exception{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await expect_exception<std::runtime_error>(taskLambda(tracedEventsChecker, filter));
+    EXPECT_EQ(eventIndex, 2);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_should_trace_return_value)
+{
+    auto filter =
+        filters::event_type<
+            events::yield_value_begin,
+            events::yield_value_result
+        >;
+
+    int yieldedValue = 42;
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter),
+        tracing_return_value_tag
+        ) -> test_traced_yield_task
+        {
+            co_yield yieldedValue;
+        };
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_yield_task,
+        traced_events_checker&,
+        decltype(filter),
+        tracing_return_value_tag
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_yield_underlying_promise;
+    using expected_yield_awaiter_type = Coroutines::detail::suspend_never;
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .MethodArguments = events::make_arguments(yieldedValue),
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::yield_value_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .MethodArguments = events::make_arguments(yieldedValue),
+                .MethodResult = events::value{ expected_yield_awaiter_type{} },
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::yield_value_result{},
+                expectedEventData
+            );
+
+            // Verifies MethodResult is present in the event (type-checked by CastEventType).
+            CastEventType(actualEventAny, expectedEvent);
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    co_await taskLambda(tracedEventsChecker, filter, tracing_return_value_tag{});
+    EXPECT_EQ(eventIndex, 2);
+}
+
+ASYNC_TEST_F(tracing_tests, traces_unhandled_exception_exception)
+{
+    // When unhandled_exception() itself throws, the traced promise emits
+    // unhandled_exception_exception and re-throws; the exception propagates
+    // to the caller of resume() just like any other exception from that method.
+    auto filter = filters::event_type<
+        events::unhandled_exception_begin,
+        events::unhandled_exception_exception
+    >;
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_underlying_promise<void>;
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::unhandled_exception_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            std::exception_ptr actualException;
+
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .MethodException = events::value{ actualException },
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::unhandled_exception_exception{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+            actualException = actualEvent.EventData.MethodException.Value;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+
+            EXPECT_THROW(
+                std::rethrow_exception(
+                    actualEvent.EventData.MethodException.Value
+                ),
+                std::runtime_error
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            co_await throw_on_unhandled_exception{};
+            throw std::runtime_error("body exception");
+        };
+
+    try
+    {
+        sync_wait(taskLambda(tracedEventsChecker, filter));
+        EXPECT_FALSE(true);
+    }
+    catch (const std::runtime_error&) { }
+    EXPECT_EQ(eventIndex, 2);
+
+    co_return;
+}
+
+
+ASYNC_TEST_F(tracing_tests, traces_await_transform)
+{
+    auto filter = filters::event_type<
+        events::await_transform_begin,
+        events::await_transform_result
+    >;
+
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
+
+    using expected_underlying_promise_type = test_underlying_promise<void>;
+
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
 
-        if constexpr (std::same_as<std::tuple<>, decltype(filter)>)
+        if (eventIndex == ++checkingIndex)
         {
-            return Phantom::Coroutines::tracing::filters::any_event;
+            auto expectedEventData = events::event_data
+            {
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_transform_begin{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
+            {
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_transform_result{},
+                expectedEventData
+            );
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
         }
         else
         {
-            return get<0>(filter);
+            EXPECT_FALSE(true);
         }
-    }
+    } };
 
-    using filter_type = decltype(get_filter(std::declval<Args>()...));
-    using promise_type = Phantom::Coroutines::tracing::tracing_tests::test_traced_promise<Result, filter_type>;
-};
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            co_await std::suspend_never{};
+        };
 
+    co_await taskLambda(tracedEventsChecker, filter);
+    EXPECT_EQ(eventIndex, 2);
 }
 
-namespace Phantom::Coroutines::tracing
-{
-
-ASYNC_TEST_F(tracing_tests, traces_basic_events_of_task)
+ASYNC_TEST_F(tracing_tests, traces_await_transform_exception)
 {
-    PHANTOM_COROUTINES_MSVC_PUSH_DISABLE_WARNING(4702)
-    auto taskLambda = [](
-        traced_events_checker& eventsChecker,
-        std::string inputArgument
-        ) -> test_traced_task<>
-    {
-        co_return;
-    };
-    PHANTOM_COROUTINES_MSVC_POP_WARNINGS()
-
-    using expected_promise_type = coroutine_function_traits<decltype(&decltype(taskLambda)::operator())>::promise_type;
-    expected_promise_type* expectedPromise = nullptr;
-    
-    using initialSuspendAwaiter = traced_awaiter<
-        trace_sink<filters::any_event_fn>,
-        std::suspend_always,
-        initial_suspend_awaiter
+    auto filter = filters::event_type<
+        events::await_transform_begin,
+        events::await_transform_exception
     >;
 
-    initialSuspendAwaiter* expectedInitialSuspendAwaiter = nullptr;
-    
-    using finalSuspendAwaiter = traced_awaiter<
-        trace_sink<filters::any_event_fn>,
-        final_suspend_transfer,
-        final_suspend_awaiter
-    >;
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
 
-    finalSuspendAwaiter* expectedFinalSuspendAwaiter = nullptr;
+    using expected_underlying_promise_type = test_underlying_promise<void>;
 
-    int eventIndex = 0;
-    traced_events_checker eventChecker
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
+
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
     {
-        [&](const std::any& anyEvent)
+        ++eventIndex;
+        auto checkingIndex = 0;
+
+        if (eventIndex == ++checkingIndex)
         {
-            using namespace events;
-            
-            ++eventIndex;
-            // We do this checkingIndex so that when trace messages are
-            // added or removed we don't have to change every index,
-            // we just insert code into the right place.
-            int checkingIndex = 0;
-            if (eventIndex == ++checkingIndex)
-            {
-                if constexpr (Config::Lambda_Reference_Is_First_Argument_Of_Promise_Constructor)
-                {
-                    using expectedEventType = create_promise<
-                        expected_promise_type,
-                        decltype(taskLambda) const&,
-                        traced_events_checker&,
-                        std::string&
-                    >;
-
-                    auto event = CastEventType<expectedEventType>(anyEvent);
-
-                    EXPECT_NE(nullptr, expectedPromise = event->Promise);
-                    EXPECT_EQ(&taskLambda, &get<0>(event->Arguments));
-                    EXPECT_EQ(&eventChecker, &get<1>(event->Arguments));
-                    EXPECT_EQ(std::string("hello"), get<2>(event->Arguments));
-                }
-                else
-                {
-                    using expectedEventType = create_promise<
-                        expected_promise_type,
-                        traced_events_checker&,
-                        std::string&
-                    >;
-
-                    auto event = CastEventType<expectedEventType>(anyEvent);
-
-                    EXPECT_NE(nullptr, expectedPromise = event->Promise);
-                    EXPECT_EQ(&eventChecker, &get<0>(event->Arguments));
-                    EXPECT_EQ(std::string("hello"), get<1>(event->Arguments));
-                }
-            }
-            else if (eventIndex == ++checkingIndex)
+            auto expectedEventData = events::event_data
             {
-                using expectedEventType = await_ready_begin<
-                    initialSuspendAwaiter
-                >;
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+            };
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_transform_begin{},
+                expectedEventData
+            );
 
-                EXPECT_NE(nullptr, expectedInitialSuspendAwaiter = event->Awaiter);
-                
-                ExpectIsInitialSuspend(event);
-                EXPECT_EQ(std::tuple<>{}, event->Arguments);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_ready_result<
-                    initialSuspendAwaiter,
-                    bool
-                >;
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
 
-                EXPECT_EQ(expectedInitialSuspendAwaiter, event->Awaiter);
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            std::exception_ptr actualException;
 
-                ExpectIsInitialSuspend(event);
-                EXPECT_EQ(std::tuple<>{}, event->Arguments);
-                EXPECT_EQ(false, event->Result);
-            }
-            else if (eventIndex == ++checkingIndex)
+            auto expectedEventData = events::event_data
             {
-                using expectedEventType = await_suspend_begin<
-                    initialSuspendAwaiter,
-                    std::coroutine_handle<expected_promise_type>
-                >;
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .MethodException = events::value{ actualException },
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::await_transform_exception{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+            actualException = actualEvent.EventData.MethodException.Value;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+
+            EXPECT_THROW(
+                std::rethrow_exception(
+                    actualEvent.EventData.MethodException.Value
+                ),
+                std::runtime_error
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            co_await throw_on_await_transform{};
+        };
 
-                EXPECT_EQ(expectedInitialSuspendAwaiter, event->Awaiter);
-                EXPECT_EQ(expectedPromise, &get<0>(event->Arguments).promise());
-                ExpectIsInitialSuspend(event);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_suspend_result<
-                    initialSuspendAwaiter,
-                    void,
-                    std::coroutine_handle<expected_promise_type>
-                >;
+    try
+    {
+        sync_wait(taskLambda(tracedEventsChecker, filter));
+        EXPECT_FALSE(true);
+    }
+    catch (const std::runtime_error&) { }
+    EXPECT_EQ(eventIndex, 2);
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    co_return;
+}
 
-                EXPECT_EQ(expectedInitialSuspendAwaiter, event->Awaiter);
-                EXPECT_EQ(expectedPromise, &get<0>(event->Arguments).promise());
-                EXPECT_EQ(true, event->is_void_result);
-                ExpectIsInitialSuspend(event);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_resume_begin<
-                    initialSuspendAwaiter
-                >;
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+ASYNC_TEST_F(tracing_tests, traces_get_return_object)
+{
+    auto filter = filters::event_type<
+        events::get_return_object_begin,
+        events::get_return_object_result
+    >;
 
-                EXPECT_EQ(expectedInitialSuspendAwaiter, event->Awaiter);
-                EXPECT_EQ(std::tuple<>{}, event->Arguments);
-                ExpectIsInitialSuspend(event);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_resume_result<
-                    initialSuspendAwaiter,
-                    void
-                >;
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_traced_task<>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    using expected_underlying_promise_type = test_underlying_promise<void>;
 
-                EXPECT_EQ(expectedInitialSuspendAwaiter, event->Awaiter);
-                EXPECT_EQ(std::tuple<>{}, event->Arguments);
-                EXPECT_EQ(true, event->is_void_result);
-                ExpectIsInitialSuspend(event);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = return_void_begin<
-                    expected_promise_type
-                >;
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
 
-                EXPECT_EQ(expectedPromise, event->Promise);
-            }
-            else if (eventIndex == ++checkingIndex)
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
             {
-                using expectedEventType = return_void_result<
-                    expected_promise_type,
-                    void
-                >;
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+            };
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::get_return_object_begin{},
+                expectedEventData
+            );
 
-                EXPECT_EQ(expectedPromise, event->Promise);
-                EXPECT_EQ(true, event->is_void_result);
-            }
-            else if (eventIndex == ++checkingIndex)
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
             {
-                using expectedEventType = await_ready_begin<
-                    finalSuspendAwaiter
-                >;
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+            };
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::get_return_object_result{},
+                expectedEventData
+            );
 
-                EXPECT_NE(nullptr, expectedFinalSuspendAwaiter = event->Awaiter);
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
 
-                ExpectIsFinalSuspend(event);
-                EXPECT_EQ(std::tuple<>{}, event->Arguments);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_ready_result<
-                    finalSuspendAwaiter,
-                    bool
-                >;
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            co_return;
+        };
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    co_await taskLambda(tracedEventsChecker, filter);
+    EXPECT_EQ(eventIndex, 2);
+}
 
-                EXPECT_EQ(expectedFinalSuspendAwaiter, event->Awaiter);
+ASYNC_TEST_F(tracing_tests, traces_get_return_object_exception)
+{
+    auto filter = filters::event_type<
+        events::get_return_object_begin,
+        events::get_return_object_exception
+    >;
 
-                ExpectIsFinalSuspend(event);
-                EXPECT_EQ(std::tuple<>{}, event->Arguments);
-                EXPECT_EQ(false, event->Result);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_suspend_begin<
-                    finalSuspendAwaiter,
-                    std::coroutine_handle<expected_promise_type>
-                >;
+    using expected_traced_promise_type = std::coroutine_traits<
+        test_throwing_get_return_object_task<>
+        , traced_events_checker&
+        , decltype(filter)
+    >::promise_type;
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    using expected_underlying_promise_type = test_throwing_get_return_object_underlying_promise<void>;
 
-                EXPECT_EQ(expectedFinalSuspendAwaiter, event->Awaiter);
-                EXPECT_EQ(expectedPromise, &get<0>(event->Arguments).promise());
-                ExpectIsFinalSuspend(event);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_suspend_result<
-                    finalSuspendAwaiter,
-                    std::coroutine_handle<void>,
-                    std::coroutine_handle<expected_promise_type>
-                >;
+    expected_underlying_promise_type* expectedPromise = nullptr;
+    expected_traced_promise_type* expectedTracedPromise = nullptr;
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    auto eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        ++eventIndex;
+        auto checkingIndex = 0;
 
-                EXPECT_EQ(expectedFinalSuspendAwaiter, event->Awaiter);
-                EXPECT_EQ(expectedPromise, &get<0>(event->Arguments).promise());
-                EXPECT_EQ(false, event->is_void_result);
-                EXPECT_NE(nullptr, event->Result.address());
-                ExpectIsFinalSuspend(event);
-            }
-            else if (eventIndex == ++checkingIndex)
+        if (eventIndex == ++checkingIndex)
+        {
+            auto expectedEventData = events::event_data
             {
-                using expectedEventType = destroy_promise<
-                    expected_promise_type
-                >;
+                .Promise = static_cast<expected_underlying_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+            };
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::get_return_object_begin{},
+                expectedEventData
+            );
 
-                EXPECT_EQ(expectedPromise, event->Promise);
-            }
-            else
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+
+            expectedPromise = expectedEvent.EventData.Promise = actualEvent.EventData.Promise;
+            expectedTracedPromise = expectedEvent.EventData.TracedPromise = actualEvent.EventData.TracedPromise;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+        }
+        else if (eventIndex == ++checkingIndex)
+        {
+            std::exception_ptr actualException;
+
+            auto expectedEventData = events::event_data
             {
-                EXPECT_FALSE(true);
-            }
+                .Promise = expectedPromise,
+                .TracedPromise = expectedTracedPromise,
+                .MethodException = events::value{ actualException },
+            };
+
+            auto expectedEvent = basic_event(
+                std::source_location(),
+                events::get_return_object_exception{},
+                expectedEventData
+            );
+
+            auto& actualEvent = CastEventType(actualEventAny, expectedEvent);
+            actualException = actualEvent.EventData.MethodException.Value;
+
+            expect_events_equal(
+                expectedEvent,
+                actualEventAny
+            );
+
+            EXPECT_THROW(
+                std::rethrow_exception(
+                    actualEvent.EventData.MethodException.Value
+                ),
+                std::runtime_error
+            );
         }
-    };
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+    } };
+
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_throwing_get_return_object_task<>
+        {
+            co_return;
+        };
+
+    try
+    {
+        auto task = taskLambda(tracedEventsChecker, filter);
+        EXPECT_FALSE(true);
+    }
+    catch (const std::runtime_error&) { }
+    EXPECT_EQ(eventIndex, 2);
 
-    co_await taskLambda(eventChecker, "hello");
-    EXPECT_EQ(14, eventIndex);
+    co_return;
 }
 
-ASYNC_TEST_F(tracing_tests, traces_co_await_events_await_ready_true_void_result)
+ASYNC_TEST_F(tracing_tests, traces_should_capture_promise_creation_arguments_false_type)
 {
-    using awaiter_type = Coroutines::detail::suspend_never;
+    auto filter = filters::event_type<events::create_promise>;
 
     auto taskLambda = [](
+        this auto& self,
         traced_events_checker& eventsChecker,
-        std::string inputArgument,
-        filters::is_co_await_fn = {}
-        ) -> test_traced_task<>
-    {
-        co_await awaiter_type{};
-    };
+        decltype(filter) filter
+        ) -> test_capture_task<void, capture_false_type_tag>
+        {
+            co_return;
+        };
 
-    using traced_awaiter = traced_awaiter<
-        trace_sink<filters::is_co_await_fn>,
-        awaiter_type,
-        co_await_awaiter
+    using expected_traced_promise_type = test_traced_promise_not_capturing_promise_args<
+        void,
+        decltype(filter)
     >;
-
-    traced_awaiter* expectedAwaiter = nullptr;
+    using expected_promise_type = test_capture_underlying_promise<void, capture_false_type_tag>;
 
     int eventIndex = 0;
-    traced_events_checker eventChecker
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny) mutable
     {
-        [&](const std::any& anyEvent)
+        if (eventIndex == 0)
         {
-            using namespace events;
-
-            ++eventIndex;
-            // We do this checkingIndex so that when trace messages are
-            // added or removed we don't have to change every index,
-            // we just insert code into the right place.
-            int checkingIndex = 0;
-            if (eventIndex == ++checkingIndex)
+            auto expectedEventData = events::event_data
             {
-                using expectedEventType = await_ready_begin<
-                    traced_awaiter
-                >;
-
-                auto event = CastEventType<expectedEventType>(anyEvent);
-
-                expectedAwaiter = event->Awaiter;
-                EXPECT_EQ(false, filters::has_result(*event).value);
-                ExpectIsCoAwait(event);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_ready_result<
-                    traced_awaiter,
-                    bool
-                >;
+                .Promise = static_cast<expected_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .PromiseCreationArguments = events::empty_arguments,
+            };
+            using expected_event_type = decltype(basic_event(
+                std::source_location{},
+                events::create_promise{},
+                expectedEventData));
+
+            auto& actualEvent = CastEventType<expected_event_type>(actualEventAny);
+            EXPECT_NE(actualEvent.EventData.Promise, nullptr);
+            EXPECT_NE(actualEvent.EventData.TracedPromise, nullptr);
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+        ++eventIndex;
+    } };
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    auto task = taskLambda(tracedEventsChecker, filter);
+    EXPECT_EQ(eventIndex, 1);
 
-                EXPECT_EQ(expectedAwaiter, event->Awaiter);
-                EXPECT_EQ(true, event->Result);
-                ExpectIsCoAwait(event);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_resume_begin<
-                    traced_awaiter
-                >;
+    co_return;
+}
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+ASYNC_TEST_F(tracing_tests, traces_should_capture_promise_creation_arguments_true_type)
+{
+    auto filter = filters::event_type<events::create_promise>;
 
-                EXPECT_EQ(expectedAwaiter, event->Awaiter);
-                ExpectIsCoAwait(event);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_resume_result<
-                    traced_awaiter,
-                    void
-                >;
+    auto taskLambda = [](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter) filter
+        ) -> test_capture_task<void, capture_true_type_tag>
+        {
+            co_return;
+        };
+    using lambda_type = decltype(taskLambda);
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    using expected_traced_promise_type = test_traced_promise_always_capturing_promise_args<
+        void,
+        decltype(filter)
+    >;
+    using expected_promise_type = test_capture_underlying_promise<void, capture_true_type_tag>;
 
-                EXPECT_EQ(expectedAwaiter, event->Awaiter);
-                EXPECT_EQ(true, event->is_void_result);
-                ExpectIsCoAwait(event);
-            }
-            else
+    int eventIndex = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny) mutable
+    {
+        if (eventIndex == 0)
+        {
+            auto expectedEventData = events::event_data
             {
-                EXPECT_FALSE(true);
-            }
+                .Promise = static_cast<expected_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .PromiseCreationArguments = events::make_arguments(
+                    taskLambda,
+                    tracedEventsChecker,
+                    filter),
+            };
+            using expected_event_type = decltype(basic_event(
+                std::source_location{},
+                events::create_promise{},
+                expectedEventData));
+
+            auto& actualEvent = CastEventType<expected_event_type>(actualEventAny);
+            EXPECT_NE(actualEvent.EventData.Promise, nullptr);
+            EXPECT_NE(actualEvent.EventData.TracedPromise, nullptr);
         }
-    };
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+        ++eventIndex;
+    } };
+
+    auto task = taskLambda(tracedEventsChecker, filter);
+    EXPECT_EQ(eventIndex, 1);
 
-    co_await taskLambda(eventChecker, "hello");
-    EXPECT_EQ(4, eventIndex);
+    co_return;
 }
 
-ASYNC_TEST_F(tracing_tests, traces_co_await_events_await_ready_exception)
+ASYNC_TEST_F(tracing_tests, traces_should_capture_promise_creation_arguments_bool_true)
 {
-    auto awaiter = test_awaiter()
-        .with_await_ready_exception(std::runtime_error("await_ready_exception"));
+    auto filter = filters::event_type<events::create_promise>;
 
-    using awaiter_type = decltype(awaiter);
+    should_capture_args_flag captureFlag{ true };
 
-    auto taskLambda = [&](
+    auto taskLambda = [](
+        this auto& self,
         traced_events_checker& eventsChecker,
-        std::string inputArgument,
-        filters::is_co_await_fn = {}
-        ) -> test_traced_task<>
-    {
-        co_await awaiter;
-    };
+        decltype(filter) filter,
+        should_capture_args_flag flag
+        ) -> test_capture_task<void, capture_bool_tag>
+        {
+            co_return;
+        };
+    using lambda_type = decltype(taskLambda);
 
-    using traced_awaiter = traced_awaiter<
-        trace_sink<filters::is_co_await_fn>,
-        awaiter_type,
-        co_await_awaiter
+    using expected_traced_promise_type = test_traced_promise_conditionally_capturing_promise_args<
+        void,
+        decltype(filter)
     >;
-
-    traced_awaiter* expectedAwaiter = nullptr;
+    using expected_promise_type = test_capture_underlying_promise<void, capture_bool_tag>;
+    using expected_optional_type = std::optional<std::tuple<
+        const lambda_type&,
+        const traced_events_checker&,
+        const decltype(filter)&,
+        const should_capture_args_flag&
+    >>;
 
     int eventIndex = 0;
-    traced_events_checker eventChecker
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny) mutable
     {
-        [&](const std::any& anyEvent)
+        if (eventIndex == 0)
         {
-            using namespace events;
-
-            ++eventIndex;
-            // We do this checkingIndex so that when trace messages are
-            // added or removed we don't have to change every index,
-            // we just insert code into the right place.
-            int checkingIndex = 0;
-            if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_ready_begin<
-                    traced_awaiter
-                >;
-
-                auto event = CastEventType<expectedEventType>(anyEvent);
-
-                expectedAwaiter = event->Awaiter;
-                EXPECT_EQ(false, filters::has_result(*event).value);
-                ExpectIsCoAwait(event);
-            }
-            else if (eventIndex == ++checkingIndex)
+            auto expectedEventData = events::event_data
             {
-                using expectedEventType = await_ready_exception<
-                    traced_awaiter
-                >;
-
-                auto event = CastEventType<expectedEventType>(anyEvent);
-
-                EXPECT_EQ(expectedAwaiter, event->Awaiter);
-                EXPECT_THROW(std::rethrow_exception(event->Exception), std::runtime_error);
-                ExpectIsCoAwait(event);
-            }
-            else
-            {
-                EXPECT_FALSE(true);
-            }
+                .Promise = static_cast<expected_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .PromiseCreationArguments = expected_optional_type{},
+            };
+            using expected_event_type = decltype(basic_event(
+                std::source_location{},
+                events::create_promise{},
+                expectedEventData));
+
+            auto& actualEvent = CastEventType<expected_event_type>(actualEventAny);
+            EXPECT_NE(actualEvent.EventData.Promise, nullptr);
+            EXPECT_NE(actualEvent.EventData.TracedPromise, nullptr);
+            EXPECT_TRUE(actualEvent.EventData.PromiseCreationArguments.has_value());
         }
-    };
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+        ++eventIndex;
+    } };
 
-    co_await expect_exception<std::runtime_error>(taskLambda(eventChecker, "hello"));
-    EXPECT_EQ(2, eventIndex);
+    auto task = taskLambda(tracedEventsChecker, filter, captureFlag);
+    EXPECT_EQ(eventIndex, 1);
+
+    co_return;
 }
 
-ASYNC_TEST_F(tracing_tests, traces_co_await_events_await_suspend_void_result)
+ASYNC_TEST_F(tracing_tests, traces_should_capture_promise_creation_arguments_bool_false)
 {
-    auto awaiter = test_awaiter()
-        .with_await_ready_false()
-        .with_await_suspend_void()
-        .with_await_resume_void();
+    auto filter = filters::event_type<events::create_promise>;
 
-    using awaiter_type = decltype(awaiter);
+    should_capture_args_flag captureFlag{ false };
 
-    auto taskLambda = [&](
+    auto taskLambda = [](
+        this auto& self,
         traced_events_checker& eventsChecker,
-        std::string inputArgument,
-        filters::is_co_await_fn = {}
-        ) -> test_traced_task<>
-    {
-        co_await awaiter;
-    };
-
-    using expected_promise_type = coroutine_function_traits<decltype(&decltype(taskLambda)::operator())>::promise_type;
+        decltype(filter) filter,
+        should_capture_args_flag flag
+        ) -> test_capture_task<void, capture_bool_tag>
+        {
+            co_return;
+        };
+    using lambda_type = decltype(taskLambda);
 
-    using traced_awaiter = traced_awaiter<
-        trace_sink<filters::is_co_await_fn>,
-        awaiter_type,
-        co_await_awaiter
+    using expected_traced_promise_type = test_traced_promise_conditionally_capturing_promise_args<
+        void,
+        decltype(filter)
     >;
-
-    traced_awaiter* expectedAwaiter = nullptr;
+    using expected_promise_type = test_capture_underlying_promise<void, capture_bool_tag>;
+    using expected_optional_type = std::optional<std::tuple<
+        const lambda_type&,
+        const traced_events_checker&,
+        const decltype(filter)&,
+        const should_capture_args_flag&
+    >>;
 
     int eventIndex = 0;
-    traced_events_checker eventChecker
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny) mutable
     {
-        [&](const std::any& anyEvent)
+        if (eventIndex == 0)
         {
-            using namespace events;
-
-            ++eventIndex;
-            // We do this checkingIndex so that when trace messages are
-            // added or removed we don't have to change every index,
-            // we just insert code into the right place.
-            int checkingIndex = 0;
-            if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_ready_begin<
-                    traced_awaiter
-                >;
-
-                auto event = CastEventType<expectedEventType>(anyEvent);
-
-                expectedAwaiter = event->Awaiter;
-                EXPECT_EQ(false, filters::has_result(*event).value);
-                ExpectIsCoAwait(event);
-            }
-            else if (eventIndex == ++checkingIndex)
+            auto expectedEventData = events::event_data
             {
-                using expectedEventType = await_ready_result<
-                    traced_awaiter,
-                    bool
-                >;
+                .Promise = static_cast<expected_promise_type*>(nullptr),
+                .TracedPromise = static_cast<expected_traced_promise_type*>(nullptr),
+                .PromiseCreationArguments = expected_optional_type{},
+            };
+            using expected_event_type = decltype(basic_event(
+                std::source_location{},
+                events::create_promise{},
+                expectedEventData));
+
+            auto& actualEvent = CastEventType<expected_event_type>(actualEventAny);
+            EXPECT_NE(actualEvent.EventData.Promise, nullptr);
+            EXPECT_NE(actualEvent.EventData.TracedPromise, nullptr);
+            EXPECT_FALSE(actualEvent.EventData.PromiseCreationArguments.has_value());
+        }
+        else
+        {
+            EXPECT_FALSE(true);
+        }
+        ++eventIndex;
+    } };
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    auto task = taskLambda(tracedEventsChecker, filter, captureFlag);
+    EXPECT_EQ(eventIndex, 1);
 
-                EXPECT_EQ(expectedAwaiter, event->Awaiter);
-                EXPECT_EQ(false, event->Result);
-                ExpectIsCoAwait(event);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_suspend_begin<
-                    traced_awaiter,
-                    std::coroutine_handle<expected_promise_type>
-                >;
+    co_return;
+}
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
 
-                EXPECT_EQ(expectedAwaiter, event->Awaiter);
-                EXPECT_EQ(true, static_cast<bool>(get<0>(event->Arguments)));
-                ExpectIsCoAwait(event);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_resume_begin<
-                    traced_awaiter
-                >;
+ASYNC_TEST_F(tracing_tests, suppress_trace_suppresses_await_transform_tracing)
+{
+    auto filter = filters::event_type<
+        events::await_transform_begin,
+        events::await_transform_result
+    >;
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    int eventCount = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any&)
+    {
+        ++eventCount;
+    } };
 
-                EXPECT_EQ(expectedAwaiter, event->Awaiter);
-                ExpectIsCoAwait(event);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_resume_result<
-                    traced_awaiter,
-                    void
-                >;
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            co_await suppress_trace{ std::suspend_never{} };
+        };
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    co_await taskLambda(tracedEventsChecker, filter);
+    EXPECT_EQ(eventCount, 0);
+}
 
-                EXPECT_EQ(expectedAwaiter, event->Awaiter);
-                EXPECT_EQ(true, event->is_void_result);
-                ExpectIsCoAwait(event);
-            }
-            else if (eventIndex == ++checkingIndex)
-            {
-                using expectedEventType = await_suspend_result<
-                    traced_awaiter,
-                    void,
-                    std::coroutine_handle<expected_promise_type>
-                >;
+ASYNC_TEST_F(tracing_tests, trace_sends_custom_event_to_sink)
+{
+    struct custom_trace_event : trace
+    {
+        int value;
+    };
 
-                auto event = CastEventType<expectedEventType>(anyEvent);
+    auto filter = filters::any_event;
 
-                EXPECT_EQ(expectedAwaiter, event->Awaiter);
-                EXPECT_EQ(true, event->is_void_result);
-                ExpectIsCoAwait(event);
-            }
-            else
-            {
-                EXPECT_FALSE(true);
-            }
+    int customEventCount = 0;
+    traced_events_checker tracedEventsChecker;
+    tracedEventsChecker = { [&](const std::any& actualEventAny)
+    {
+        if (actualEventAny.type() == typeid(const custom_trace_event*))
+        {
+            auto& actual = CastEventType<custom_trace_event>(actualEventAny);
+            EXPECT_EQ(actual.value, 42);
+            ++customEventCount;
         }
-    };
+    } };
 
-    sync_wait(taskLambda(eventChecker, "hello"));
-    EXPECT_EQ(6, eventIndex);
-    co_return;
-}
+    auto taskLambda = [&](
+        this auto& self,
+        traced_events_checker& eventsChecker,
+        decltype(filter)
+        ) -> test_traced_task<>
+        {
+            auto event = custom_trace_event{ .value = 42 };
+            co_await event;
+        };
 
+    co_await taskLambda(tracedEventsChecker, filter);
+    EXPECT_EQ(customEventCount, 1);
 }
+
+} // namespace phantom::coroutines::test
diff --git a/Phantom.Coroutines.Test/type_traits_test.cpp b/Phantom.Coroutines.Test/type_traits_test.cpp
index e1ad511..2b12831 100644
--- a/Phantom.Coroutines.Test/type_traits_test.cpp
+++ b/Phantom.Coroutines.Test/type_traits_test.cpp
@@ -1,17 +1,19 @@
 #include <gtest/gtest.h>
+#include <tuple>
+#include <type_traits>
 #include "Phantom.Coroutines/detail/config_macros.h"
 #if defined(PHANTOM_COROUTINES_TESTING_SINGLE_MODULE)
 import Phantom.Coroutines;
 #elif defined(PHANTOM_COROUTINES_TESTING_MODULES)
+import Phantom.Coroutines.coroutine;
 import Phantom.Coroutines.type_traits;
 import Phantom.Coroutines.value_awaiter;
 #elif defined(PHANTOM_COROUTINES_TESTING_HEADERS)
+#include "Phantom.Coroutines/detail/coroutine.h"
 #include "Phantom.Coroutines/type_traits.h"
 #include "Phantom.Coroutines/value_awaiter.h"
 #endif
-#include <tuple>
-#include <type_traits>
-#include "detail/awaiters.h"
+#include "awaiters.h"
 
 PHANTOM_COROUTINES_PUSH_DISABLE_INTERNAL_LINKAGE_WARNING()
 
@@ -20,6 +22,10 @@ namespace Phantom::Coroutines::detail
 
 namespace
 {
+static_assert(true == is_empty_type_list<>);
+static_assert(false == is_empty_type_list<int>);
+static_assert(false == is_empty_type_list<int, int>);
+
 static_assert(false == is_in_types<int>);
 static_assert(true == is_in_types<int, int>);
 static_assert(false == is_in_types<int, bool>);
@@ -83,8 +89,8 @@ template<
 >
 struct test_coroutine_function_traits_promise
 {
-    std::suspend_always initial_suspend();
-    std::suspend_always final_suspend() noexcept;
+    suspend_always initial_suspend();
+    suspend_always final_suspend() noexcept;
     void return_void();
     void unhandled_exception();
     test_coroutine_function_traits_task get_return_object();
@@ -240,6 +246,15 @@ static_assert(is_awaiter<typed_awaiter<int&>>);
 static_assert(is_awaiter<typed_awaiter<int&&>>);
 static_assert(!is_awaiter<not_awaitable>);
 
+static_assert(is_awaitable<typed_awaitable<void>>);
+static_assert(is_awaitable<typed_awaitable<void>&>);
+static_assert(is_awaitable<typed_awaitable<void>&&>);
+
+static_assert(is_simple_awaiter<typed_awaiter<void>>);
+static_assert(!is_simple_awaiter<typed_awaitable<void>>);
+static_assert(!is_simple_awaiter<typed_awaitable<void>&>);
+static_assert(!is_simple_awaiter<typed_awaitable<void>&&>);
+
 static_assert(has_co_await_member<typed_awaitable<void>>);
 static_assert(!has_co_await_member<not_awaitable>);
 
@@ -313,6 +328,48 @@ TEST(type_traits_test, get_awaiter_returns_awaiter_lvalue_as_lvalue_reference)
     ASSERT_EQ(&result, &awaiter);
 }
 
+TEST(type_traits_test, get_awaiter_returns_co_await_on_awaiter_with_member_co_await)
+{
+    struct test_awaiter : generic_awaiter<bool, int>
+    {
+        generic_awaiter<bool, long> m_awaiter;
+
+        auto& operator co_await()
+        {
+            return m_awaiter;
+        }
+    } awaitable;
+
+    decltype(auto) result = get_awaiter(awaitable);
+    static_assert(std::same_as<generic_awaiter<bool, long>&, decltype(result)>);
+    ASSERT_EQ(&awaitable.m_awaiter, &result);
+}
+
+namespace
+{
+
+struct test_awaitable_with_friend_co_await : generic_awaiter<bool, int>
+{
+    generic_awaiter<bool, long> m_awaiter;
+
+    friend auto& operator co_await(
+        test_awaitable_with_friend_co_await& awaitable)
+    {
+        return awaitable.m_awaiter;
+    }
+};
+
+static_assert(has_co_await_non_member<test_awaitable_with_friend_co_await>);
+}
+
+TEST(type_traits_test, get_awaiter_returns_co_await_on_awaiter_with_friend_co_await)
+{
+    test_awaitable_with_friend_co_await awaitable;
+    decltype(auto) result = get_awaiter(awaitable);
+    static_assert(std::same_as<generic_awaiter<bool, long>&, decltype(result)>);
+    ASSERT_EQ(&awaitable.m_awaiter, &result);
+}
+
 TEST(type_traits_test, get_awaiter_returns_awaiter_rvalue_reference_as_rvalue_reference)
 {
     generic_awaiter<> awaiter;
diff --git a/Phantom.Coroutines.Test/value_awaiter_test.cpp b/Phantom.Coroutines.Test/value_awaiter_test.cpp
index 8c68c2b..d8811c3 100644
--- a/Phantom.Coroutines.Test/value_awaiter_test.cpp
+++ b/Phantom.Coroutines.Test/value_awaiter_test.cpp
@@ -1,30 +1,109 @@
+#include <functional>
+#include "Phantom.Coroutines/detail/config_macros.h"
 #include "async_test.h"
 #if defined(PHANTOM_COROUTINES_TESTING_SINGLE_MODULE)
 import Phantom.Coroutines;
+import Phantom.Coroutines.Test.lifetime_tracker;
 #elif defined(PHANTOM_COROUTINES_TESTING_MODULES)
 import Phantom.Coroutines.value_awaiter;
+import Phantom.Coroutines.Test.lifetime_tracker;
 #elif defined(PHANTOM_COROUTINES_TESTING_HEADERS)
 #include "Phantom.Coroutines/value_awaiter.h"
+#include "lifetime_tracker.h"
 #endif
 
 namespace Phantom::Coroutines
 {
 
-ASYNC_TEST(value_awaiter_test, can_await_by_value)
+ASYNC_TEST(value_awaiter_test, await_value_from_lvalue_returns_const_reference)
 {
-    value_awaiter<std::string> awaiter{ "hello" };
+    lifetime_statistics lifetimeStatistics;
+    value_awaiter awaiter{ lifetimeStatistics.tracker() };
     decltype(auto) result = co_await awaiter;
-    static_assert(std::same_as<decltype(result), std::string>);
-    EXPECT_EQ("hello", result);
+    static_assert(std::same_as<decltype(result), const lifetime_tracker&>);
+    EXPECT_EQ(0, lifetimeStatistics.copy_construction_count);
+    EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+    EXPECT_EQ(lifetimeStatistics, result);
+    EXPECT_EQ(std::addressof(awaiter.m_value), std::addressof(result));
 }
 
-ASYNC_TEST(value_awaiter_test, can_await_by_reference)
+ASYNC_TEST(value_awaiter_test, await_value_from_rvalue_returns_rvalue_reference)
 {
-    std::string expected = "hello";
-    value_awaiter<std::string&> awaiter{ expected };
+    lifetime_statistics lifetimeStatistics;
+    value_awaiter awaiter{ lifetimeStatistics.tracker() };
+#if PHANTOM_COROUTINES_MSVC_INCORRECTLY_COPIES_CO_AWAIT_RVALUE_REFERENCE
+    // The extra "move" is to workaround a compiler bug in MSVC where it copies the result of await_resume.
+    decltype(auto) result = std::move(co_await std::move(awaiter));
+#else
+    decltype(auto) result = co_await std::move(awaiter);
+#endif
+    static_assert(std::same_as<decltype(result), lifetime_tracker&&>);
+    EXPECT_EQ(0, lifetimeStatistics.copy_construction_count);
+    EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+    EXPECT_EQ(lifetimeStatistics, result);
+    EXPECT_EQ(std::addressof(awaiter.m_value), std::addressof(result));
+}
+
+ASYNC_TEST(value_awaiter_test, await_lvalue_reference_from_lvalue_returns_lvalue_reference)
+{
+    lifetime_statistics lifetimeStatistics;
+    lifetime_tracker tracker = lifetimeStatistics.tracker();
+    value_awaiter<lifetime_tracker&> awaiter{ tracker };
     decltype(auto) result = co_await awaiter;
-    static_assert(std::same_as<decltype(result), std::string&>);
-    EXPECT_EQ(&expected, &result);
+    static_assert(std::same_as<decltype(result), lifetime_tracker&>);
+    EXPECT_EQ(0, lifetimeStatistics.copy_construction_count);
+    EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+    EXPECT_EQ(lifetimeStatistics, result);
+    EXPECT_EQ(std::addressof(awaiter.m_value), std::addressof(result));
+}
+
+ASYNC_TEST(value_awaiter_test, await_lvalue_reference_from_rvalue_returns_lvalue_reference)
+{
+    lifetime_statistics lifetimeStatistics;
+    lifetime_tracker tracker = lifetimeStatistics.tracker();
+    value_awaiter<lifetime_tracker&> awaiter{ tracker };
+    decltype(auto) result = co_await std::move(awaiter);
+    static_assert(std::same_as<decltype(result), lifetime_tracker&>);
+    EXPECT_EQ(0, lifetimeStatistics.copy_construction_count);
+    EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+    EXPECT_EQ(lifetimeStatistics, result);
+    EXPECT_EQ(std::addressof(awaiter.m_value), std::addressof(result));
+}
+
+ASYNC_TEST(value_awaiter_test, await_rvalue_reference_from_lvalue_returns_rvalue_reference)
+{
+    lifetime_statistics lifetimeStatistics;
+    lifetime_tracker tracker = lifetimeStatistics.tracker();
+    value_awaiter<lifetime_tracker&&> awaiter{ std::move(tracker) };
+#if PHANTOM_COROUTINES_MSVC_INCORRECTLY_COPIES_CO_AWAIT_RVALUE_REFERENCE
+    // The extra "move" is to workaround a compiler bug in MSVC where it copies the result of await_resume.
+    decltype(auto) result = std::move(co_await awaiter);
+#else
+    decltype(auto) result = co_await awaiter;
+#endif
+    static_assert(std::same_as<decltype(result), lifetime_tracker&&>);
+    EXPECT_EQ(0, lifetimeStatistics.copy_construction_count);
+    EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+    EXPECT_EQ(lifetimeStatistics, result);
+    EXPECT_EQ(std::addressof(awaiter.m_value), std::addressof(result));
+}
+
+ASYNC_TEST(value_awaiter_test, await_rvalue_reference_from_rvalue_returns_rvalue_reference)
+{
+    lifetime_statistics lifetimeStatistics;
+    lifetime_tracker tracker = lifetimeStatistics.tracker();
+    value_awaiter<lifetime_tracker&&> awaiter{ std::move(tracker) };
+#if PHANTOM_COROUTINES_MSVC_INCORRECTLY_COPIES_CO_AWAIT_RVALUE_REFERENCE
+    // The extra "move" is to workaround a compiler bug in MSVC where it copies the result of await_resume.
+    decltype(auto) result = std::move(co_await awaiter);
+#else
+    decltype(auto) result = co_await awaiter;
+#endif
+    static_assert(std::same_as<decltype(result), lifetime_tracker&&>);
+    EXPECT_EQ(0, lifetimeStatistics.copy_construction_count);
+    EXPECT_EQ(0, lifetimeStatistics.move_construction_count);
+    EXPECT_EQ(lifetimeStatistics, result);
+    EXPECT_EQ(std::addressof(awaiter.m_value), std::addressof(result));
 }
 
 }
\ No newline at end of file
diff --git a/Phantom.Coroutines.cppcoro.Test/cppcoro_shared_task_test.cpp b/Phantom.Coroutines.cppcoro.Test/cppcoro_shared_task_test.cpp
index 756103f..de661e9 100644
--- a/Phantom.Coroutines.cppcoro.Test/cppcoro_shared_task_test.cpp
+++ b/Phantom.Coroutines.cppcoro.Test/cppcoro_shared_task_test.cpp
@@ -1,5 +1,7 @@
 #include "async_test.h"
 #include "cppcoro/shared_task.hpp"
+#include <concepts>
+#include <coroutine>
 
 static_assert(std::same_as<cppcoro::shared_task<>, Phantom::Coroutines::shared_task<>>);
 static_assert(std::same_as<::Phantom::Coroutines::shared_task<>, decltype(::cppcoro::make_shared_task(std::suspend_always{}))>);
diff --git a/Phantom.Coroutines.cppcoro.Test/cppcoro_task_test.cpp b/Phantom.Coroutines.cppcoro.Test/cppcoro_task_test.cpp
index 1cd0b7a..c4b0f9d 100644
--- a/Phantom.Coroutines.cppcoro.Test/cppcoro_task_test.cpp
+++ b/Phantom.Coroutines.cppcoro.Test/cppcoro_task_test.cpp
@@ -1,8 +1,9 @@
 #include "async_test.h"
+#include <coroutine>
 #include <concepts>
+#include <string>
 #include "cppcoro/task.hpp"
 
-
 namespace Phantom::cppcoro_test
 {
 using namespace ::cppcoro;
diff --git a/Phantom.Coroutines.cppcoro/include/cppcoro/shared_task.hpp b/Phantom.Coroutines.cppcoro/include/cppcoro/shared_task.hpp
index 7bae5b0..0bab046 100644
--- a/Phantom.Coroutines.cppcoro/include/cppcoro/shared_task.hpp
+++ b/Phantom.Coroutines.cppcoro/include/cppcoro/shared_task.hpp
@@ -18,7 +18,7 @@ template<
     Awaitable&& awaitable
 )
 {
-    return ::Phantom::Coroutines::make_task<shared_task>(
+    return ::Phantom::Coroutines::make_task_wrapper<shared_task>(
         std::forward<Awaitable>(awaitable));
 }
 
diff --git a/Phantom.Coroutines.cppcoro/include/cppcoro/task.hpp b/Phantom.Coroutines.cppcoro/include/cppcoro/task.hpp
index fbcba80..e836ad0 100644
--- a/Phantom.Coroutines.cppcoro/include/cppcoro/task.hpp
+++ b/Phantom.Coroutines.cppcoro/include/cppcoro/task.hpp
@@ -16,7 +16,7 @@ constexpr auto make_task = [](
     auto&& awaitable
 )
 {
-    return ::Phantom::Coroutines::make_task<task>(
+    return ::Phantom::Coroutines::make_task_wrapper<task>(
         std::forward<decltype(awaitable)>(awaitable));
 };
 
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/awaiter_wrapper.h b/Phantom.Coroutines/include/Phantom.Coroutines/awaiter_wrapper.h
index 75d0156..5b18327 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/awaiter_wrapper.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/awaiter_wrapper.h
@@ -105,9 +105,9 @@ template<
 > class awaiter_wrapper;
 
 // The is_awaiter specialization provides the behavior of wrapping
-// an actual awaiter object.
+// an actual awaiter object that has no operator co_await.
 template<
-    is_awaiter Awaiter
+    is_simple_awaiter Awaiter
 > class awaiter_wrapper<
     Awaiter
 > :
@@ -201,15 +201,14 @@ template<
     using awaiter_wrapper::awaiter_wrapper_storage::awaiter_wrapper_storage;
     
 public:
-    decltype(auto) awaiter(
-        this auto& self)
+    decltype(auto) awaiter()
     {
-        if (!self.awaiter_wrapper::m_awaiter)
+        if (!m_awaiter)
         {
-            self.awaiter_wrapper::m_awaiter.emplace(
-                self.awaiter_wrapper::get_awaiter_lambda());
+            m_awaiter.emplace(
+                get_awaiter_lambda());
         }
-        return self.awaiter_wrapper::m_awaiter->awaitable();
+        return m_awaiter->awaitable();
     }
 
     decltype(auto) handle(
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/contextual_promise.h b/Phantom.Coroutines/include/Phantom.Coroutines/contextual_promise.h
index 9a02f68..1c28329 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/contextual_promise.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/contextual_promise.h
@@ -31,6 +31,7 @@ template<
     :
 public derived_promise<BasePromise>
 {
+    using derived_promise = derived_promise<BasePromise>;
     struct DoNotEnterOnResume {};
     struct DoNotLeaveOnSuspend {};
     struct DoEnterOnResume {};
@@ -45,8 +46,9 @@ public derived_promise<BasePromise>
         public awaiter_wrapper<Awaiter>,
         public extensible_promise_handle<Promise>
     {
+        using awaiter_wrapper = awaiter_wrapper<Awaiter>;
+        using extensible_promise_handle = extensible_promise_handle<Promise>;
         bool m_bSuspended = false;
-
     public:
         contextual_promise_awaiter(
             Enter,
@@ -54,33 +56,37 @@ public derived_promise<BasePromise>
             Promise& promise,
             std::invocable<> auto&& awaitableFunc
         ) : 
-            awaiter_wrapper<Awaiter>{ std::forward<decltype(awaitableFunc)>(awaitableFunc) },
-            extensible_promise_handle<Promise>{ promise }
+            awaiter_wrapper{ std::forward<decltype(awaitableFunc)>(awaitableFunc) },
+            extensible_promise_handle{ promise }
         {}
 
         bool await_ready(
             this auto& self,
             auto&&... args
         ) noexcept(
-            noexcept(self.awaiter().await_ready(std::forward<decltype(args)>(args)...))
+            noexcept(self.awaiter_wrapper::awaiter().await_ready(
+                std::forward<decltype(args)>(args)...))
             )
         {
-            return self.awaiter().await_ready(std::forward<decltype(args)>(args)...);
+            return self.awaiter_wrapper::awaiter().await_ready(
+                std::forward<decltype(args)>(args)...);
         }
 
         auto await_suspend(
             this auto& self,
             auto&&... args
         ) noexcept(
-            noexcept(self.awaiter().await_suspend(std::forward<decltype(args)>(args)...))
+            noexcept(self.awaiter_wrapper::awaiter().await_suspend(
+                std::forward<decltype(args)>(args)...))
             )
         {
             self.m_bSuspended = true;
             if (std::same_as<DoLeaveOnSuspend, Leave>)
             {
-                self.extensible_promise_handle<Promise>::promise().leave();
+                self.extensible_promise_handle::promise().leave();
             }
-            return self.awaiter().await_suspend(std::forward<decltype(args)>(args)...);
+            return self.awaiter_wrapper::awaiter().await_suspend(
+                std::forward<decltype(args)>(args)...);
         }
 
         auto await_resume(
@@ -96,10 +102,10 @@ public derived_promise<BasePromise>
             {
                 if (self.m_bSuspended)
                 {
-                    self.extensible_promise_handle<Promise>::promise().enter();
+                    self.extensible_promise_handle::promise().enter();
                 }
             }
-            return self.awaiter().await_resume(std::forward<decltype(args)>(args)...);
+            return self.awaiter_wrapper::awaiter().await_resume(std::forward<decltype(args)>(args)...);
         }
     };
 
@@ -118,12 +124,12 @@ public derived_promise<BasePromise>
     > contextual_promise_awaiter(Enter, Leave, Promise&, AwaitableFunc&&) -> contextual_promise_awaiter<Enter, Leave, Promise, std::invoke_result_t<AwaitableFunc>>;
 
 public:
-    using contextual_promise::derived_promise::derived_promise;
+    using derived_promise::derived_promise;
 
     auto initial_suspend(
         this auto& self
     ) noexcept(noexcept(
-        self.derived_promise<BasePromise>::initial_suspend()
+        self.contextual_promise::derived_promise::initial_suspend()
         ))
     {
         static_assert(is_contextual_promise<decltype(self)>);
@@ -135,7 +141,7 @@ public derived_promise<BasePromise>
             self,
             [&]() -> decltype(auto)
             {
-                return self.derived_promise<BasePromise>::initial_suspend();
+                return self.contextual_promise::derived_promise::initial_suspend();
             }
         };
     }
@@ -153,7 +159,7 @@ public derived_promise<BasePromise>
             self,
             [&]() noexcept -> decltype(auto)
             {
-                return self.derived_promise<BasePromise>::final_suspend();
+                return self.contextual_promise::derived_promise::final_suspend();
             }
         };
     }
@@ -170,11 +176,11 @@ public derived_promise<BasePromise>
             DoLeaveOnSuspend{},
             self,
             [&]() noexcept(noexcept(
-                self.derived_promise<BasePromise>::await_transform(
+                self.contextual_promise::derived_promise::await_transform(
                     std::forward<decltype(awaitable)>(awaitable))
                 )) -> decltype(auto)
             {
-                return self.derived_promise<BasePromise>::await_transform(
+                return self.contextual_promise::derived_promise::await_transform(
                     std::forward<decltype(awaitable)>(awaitable));
             }
         };
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/detail/config_macros_clang.h b/Phantom.Coroutines/include/Phantom.Coroutines/detail/config_macros_clang.h
index 8eb6a85..6b2e467 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/detail/config_macros_clang.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/detail/config_macros_clang.h
@@ -21,3 +21,5 @@
 
 #define PHANTOM_COROUTINES_PUSH_DISABLE_INTERNAL_LINKAGE_WARNING() PHANTOM_COROUTINES_CLANG_PUSH_DISABLE_WARNING("clang diagnostic ignored \"-Wundefined-internal\"")
 #define PHANTOM_COROUTINES_POP_WARNINGS() PHANTOM_COROUTINES_CLANG_POP_WARNINGS()
+
+#define PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS [[no_unique_address]]
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/detail/config_macros_clang_msvc.h b/Phantom.Coroutines/include/Phantom.Coroutines/detail/config_macros_clang_msvc.h
index 27528e6..c34136c 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/detail/config_macros_clang_msvc.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/detail/config_macros_clang_msvc.h
@@ -25,3 +25,5 @@
 
 #define PHANTOM_COROUTINES_PUSH_DISABLE_INTERNAL_LINKAGE_WARNING() PHANTOM_COROUTINES_CLANG_PUSH_DISABLE_WARNING("clang diagnostic ignored \"-Wundefined-internal\"")
 #define PHANTOM_COROUTINES_POP_WARNINGS() PHANTOM_COROUTINES_CLANG_POP_WARNINGS()
+
+#define PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/detail/config_macros_msvc.h b/Phantom.Coroutines/include/Phantom.Coroutines/detail/config_macros_msvc.h
index bc73c38..ad7b129 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/detail/config_macros_msvc.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/detail/config_macros_msvc.h
@@ -21,6 +21,11 @@
 #define PHANTOM_COROUTINES_NO_REJECT_LAMBDA_WITH_INVALID_MEMBER 1
 #endif
 
+// Bug https://developercommunity.visualstudio.com/t/Incorrect-Code-Generation:-Assigning-res/11021227
+#ifndef PHANTOM_COROUTINES_MSVC_INCORRECTLY_COPIES_CO_AWAIT_RVALUE_REFERENCE
+#define PHANTOM_COROUTINES_MSVC_INCORRECTLY_COPIES_CO_AWAIT_RVALUE_REFERENCE 1
+#endif
+
 // MSVC captures the result of get_return_object as-is.
 #define PHANTOM_COROUTINES_USE_REFERENCE_WRAPPER_RETURN_TYPE_FOR_GET_RETURN_OBJECT 0
 
@@ -40,3 +45,5 @@
 
 #define PHANTOM_COROUTINES_PUSH_DISABLE_INTERNAL_LINKAGE_WARNING() PHANTOM_COROUTINES_MSVC_PUSH_DISABLE_WARNING(5046)
 #define PHANTOM_COROUTINES_POP_WARNINGS() PHANTOM_COROUTINES_MSVC_POP_WARNINGS()
+
+#define PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/detail/core_task.h b/Phantom.Coroutines/include/Phantom.Coroutines/detail/core_task.h
index 0d3aba7..5ecaf7d 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/detail/core_task.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/detail/core_task.h
@@ -55,7 +55,7 @@ class core_task_variant_return_result
         Result value
     ) requires (!std::same_as<void, Result>)
     {
-        self.m_result.emplace<self.result_index>(std::move(value));
+        self.m_result.template emplace<self.result_index>(std::move(value));
     }
 
     void return_variant_result(
@@ -63,7 +63,7 @@ class core_task_variant_return_result
         const Result& value
     )
     {
-        self.m_result.emplace<self.result_index>(value);
+        self.m_result.template emplace<self.result_index>(value);
     }
 };
 
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/detail/coroutine.h b/Phantom.Coroutines/include/Phantom.Coroutines/detail/coroutine.h
index 8c6fc7a..45f78fb 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/detail/coroutine.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/detail/coroutine.h
@@ -14,6 +14,7 @@ namespace Phantom::Coroutines
 {
 namespace detail
 {
+PHANTOM_COROUTINES_MODULE_EXPORT
 using std::coroutine_traits;
 
 PHANTOM_COROUTINES_MODULE_EXPORT
@@ -90,6 +91,12 @@ using detail::noop_coroutine;
 
 namespace std
 {
+PHANTOM_COROUTINES_MODULE_EXPORT
+using std::coroutine_handle;
+
+PHANTOM_COROUTINES_MODULE_EXPORT
+using std::coroutine_traits;
+
 PHANTOM_COROUTINES_MODULE_EXPORT
 using std::coroutine_traits;
 
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/extensible_promise.h b/Phantom.Coroutines/include/Phantom.Coroutines/extensible_promise.h
index dae5a2a..848f140 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/extensible_promise.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/extensible_promise.h
@@ -54,6 +54,80 @@ is_extensible_promise<Promise>
     { promise.template promise<Promise>() } -> std::same_as<Promise&>;
 };
 
+
+PHANTOM_COROUTINES_MODULE_EXPORT
+template<
+    typename T,
+    typename ... Args
+>
+concept is_constructible_from_promise_arguments =
+    std::constructible_from<T, Args...>
+    && !is_empty_type_list<Args...>;
+
+PHANTOM_COROUTINES_MODULE_EXPORT
+template<
+    typename T,
+    typename ... Args
+>
+concept is_default_constructible_from_promise_arguments =
+    (
+        !std::constructible_from<T, Args...>
+        ||
+        is_empty_type_list<Args...>
+    )
+    && std::constructible_from<T>;
+
+// Derived classes of a promise type should derive from this class to enable
+// delegating promise construction arguments to the base promise type.
+// If the base promise does not accept the argument set, but does accept
+// the defualt constructor, then arguments are not delegated.
+PHANTOM_COROUTINES_MODULE_EXPORT
+template<
+    typename Base
+> class derived_promise_construction
+    :
+    public Base
+{
+public:
+    // Enable construction by delegating the arguments
+    // to the base class.
+    // This constructor is enabled only if the base class
+    // supports the argument set.
+    template<
+        typename ... Args
+    > 
+    requires
+        is_constructible_from_promise_arguments<Base, Args&&...>
+    derived_promise_construction(
+        Args&&... args
+    )
+    :
+    Base(
+        std::forward<Args>(args)...
+    )
+    {
+    }
+
+    // Enable construction by invoking the default constructor.
+    // This constructor is enabled only if the base class
+    // does not support the argument set and default-constructs
+    // the base class.
+    // This constructor allows derived promises to always pass
+    // arguments to derived_promise, even if the base promise
+    // does not support accepting arguments.
+    template<
+        typename ... Args
+    > requires
+        is_default_constructible_from_promise_arguments<Base, Args&&...>
+    derived_promise_construction(
+        Args&&...
+    ) 
+        :
+        Base()
+    {
+    }
+};
+
 namespace detail
 {
 template<
@@ -103,45 +177,6 @@ class derived_promise_identity_await_transform
     }
 };
 
-template<
-    typename Base
-> class derived_promise_base
-    :
-    public Base
-{
-public:
-    // Enable construction by delegating the arguments
-    // to the base class.
-    // This constructor is enabled only if the base class
-    // supports the argument set.
-    template<
-        typename ... Args
-    > derived_promise_base(
-        Args&&... args
-    )
-        requires std::constructible_from<Base, Args&&...>
-    :
-    Base(
-        std::forward<Args>(args)...
-    )
-    {}
-
-    // Enable construction by invoking the default constructor.
-    // This constructor is enabled only if the base class
-    // does not support the argument set and default-constructs
-    // the base class.
-    template<
-        typename ... Args
-    > derived_promise_base(
-        Args&&...
-    ) requires (
-        !std::constructible_from<Base, Args&&...>
-        && std::constructible_from<Base>)
-        :
-    Base()
-    {}
-};
-
 // The template derived_promise_await_transform ensures there is a valid
 // await_transform() method in the derived_promise implementation,
 // so that it can always be called unconditionally by derived classes.
@@ -151,9 +186,9 @@ template<
 > class derived_promise_await_transform
     :
 public derived_promise_identity_await_transform,
-public derived_promise_base<BasePromise>
+public derived_promise_construction<BasePromise>
 {
-    using derived_promise_base<BasePromise>::derived_promise_base;
+    using derived_promise_construction<BasePromise>::derived_promise_construction;
 };
 
 template<
@@ -165,9 +200,10 @@ class derived_promise_await_transform<
     BasePromise,
     Bases...
 > :
-    public derived_promise_base<BasePromise>
+    public derived_promise_construction<BasePromise>
 {
 public:
+    using derived_promise_construction<BasePromise>::derived_promise_construction;
 };
 
 // A derived_promise is a promise that wraps an extensible_promise
@@ -189,7 +225,7 @@ template<
 >
     :
     public derived_promise_await_transform<BasePromise, Bases...>,
-    public derived_promise_base<Bases>...
+    public derived_promise_construction<Bases>...
 {
 protected:
     using base_promise_type = BasePromise;
@@ -204,13 +240,14 @@ template<
     > derived_promise_impl(
         Args&&... args
     )
-        requires std::constructible_from<derived_promise_await_transform<BasePromise, Bases...>, Args&&...>
-    && (std::constructible_from<derived_promise_base<Bases>, Args&&...> && ...)
+    requires 
+        std::constructible_from<derived_promise_await_transform<BasePromise, Bases...>, Args&&...>
+        && (std::constructible_from<derived_promise_construction<Bases>, Args&&...> && ...)
     :
     derived_promise_await_transform<BasePromise, Bases...>(
         std::forward<Args>(args)...
     ),
-    derived_promise_base<Bases>(
+    derived_promise_construction<Bases>(
         std::forward<Args>(args)...
     )...
     {}
@@ -227,15 +264,15 @@ template<
 >
 class derived_promise :
     public detail::derived_promise_impl<
-    BasePromise,
-    std::tuple<Bases...>,
-    typename detail::filter_types
-    <
-        detail::has_await_transform_filter,
-        detail::derived_promise_await_transform<BasePromise, Bases...>,
-        detail::derived_promise_base<Bases>...
-    >::tuple_type
->
+        BasePromise,
+        std::tuple<Bases...>,
+        typename detail::filter_types
+        <
+            detail::has_await_transform_filter,
+            detail::derived_promise_await_transform<BasePromise, Bases...>,
+            derived_promise_construction<Bases>...
+        >::tuple_type
+    >
 {
     using derived_promise::derived_promise_impl::derived_promise_impl;
 };
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/functional.h b/Phantom.Coroutines/include/Phantom.Coroutines/functional.h
new file mode 100644
index 0000000..17d481d
--- /dev/null
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/functional.h
@@ -0,0 +1,58 @@
+#ifndef PHANTOM_COROUTINES_INCLUDE_FUNCTIONAL_H
+#define PHANTOM_COROUTINES_INCLUDE_FUNCTIONAL_H
+#ifndef PHANTOM_COROUTINES_COMPILING_MODULES
+#include "detail/config_macros.h"
+#include <utility>
+#endif
+
+static_assert(PHANTOM_COROUTINES_IS_CONFIGURED);
+PHANTOM_COROUTINES_ASSERT_IS_MODULE;
+
+namespace Phantom::Coroutines
+{
+
+namespace detail
+{
+template<
+    typename Function
+>
+struct composed_function_wrapper
+{
+    Function function;
+
+    decltype(auto) operator()(auto&& ... args)
+    {
+        return std::invoke(
+            function,
+            std::forward<decltype(args)>(args)...);
+    }
+};
+}
+
+PHANTOM_COROUTINES_MODULE_EXPORT
+template<
+    typename ... Functions
+>
+struct composed_function
+    :
+    detail::composed_function_wrapper<Functions>...
+{
+    composed_function(
+        auto&& ... functions
+    ) :
+        detail::composed_function_wrapper<Functions>{ std::forward<decltype(functions)>(functions) }...
+    {}
+
+    using detail::composed_function_wrapper<Functions>::operator()...;
+};
+
+PHANTOM_COROUTINES_MODULE_EXPORT
+template<
+    typename ... Functions
+>
+composed_function(
+    Functions&& ... functions
+) -> composed_function<std::remove_reference_t<Functions>...>;
+
+}
+#endif // PHANTOM_COROUTINES_INCLUDE_FUNCTIONAL_H
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/make_task.h b/Phantom.Coroutines/include/Phantom.Coroutines/make_task.h
index 98bff83..03c5fd8 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/make_task.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/make_task.h
@@ -3,6 +3,7 @@
 #ifndef PHANTOM_COROUTINES_COMPILING_MODULES
 #include <type_traits>
 #include <utility>
+#include "shared_task.h"
 #include "task.h"
 #include "type_traits.h"
 #endif
@@ -13,31 +14,36 @@ PHANTOM_COROUTINES_ASSERT_IS_MODULE;
 namespace Phantom::Coroutines
 {
 
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    template <typename Result> typename Task = task,
+    typename Task,
     typename Awaitable
-> auto make_task(
-    Awaitable&& awaitable
+> Task make_task_wrapper_implementation(
+    Awaitable awaitable
 )
+{
+    co_return co_await std::forward<Awaitable>(awaitable);
+}
+
+PHANTOM_COROUTINES_MODULE_EXPORT
+template<
+    template <typename Result> typename Task
+> constexpr auto make_task_wrapper = []<typename Awaitable>(
+    Awaitable&& awaitable
+    )
 {
     using result_task_type = Task<detail::remove_rvalue_reference_t<awaitable_result_type_t<Awaitable>>>;
+    return make_task_wrapper_implementation<
+        result_task_type,
+        Awaitable
+    >(
+        std::forward<Awaitable>(awaitable));
+};
 
-    if constexpr (std::is_lvalue_reference_v<Awaitable>)
-    {
-        return [](Awaitable awaitable) -> result_task_type
-        {
-            co_return co_await awaitable;
-        }(awaitable);
-    }
-    else
-    {
-        return [](Awaitable awaitable) -> result_task_type
-        {
-            co_return co_await std::move(awaitable);
-        }(std::move(awaitable));
-    }
-}
+PHANTOM_COROUTINES_MODULE_EXPORT
+constexpr auto make_task = make_task_wrapper<task>;
+
+PHANTOM_COROUTINES_MODULE_EXPORT
+constexpr auto make_shared_task = make_task_wrapper<shared_task>;
 
 }
 #endif
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/text_tracing.h b/Phantom.Coroutines/include/Phantom.Coroutines/text_tracing.h
new file mode 100644
index 0000000..88cd903
--- /dev/null
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/text_tracing.h
@@ -0,0 +1,79 @@
+#ifndef PHANTOM_COROUTINES_INCLUDE_TEXT_TRACING_H
+#define PHANTOM_COROUTINES_INCLUDE_TEXT_TRACING_H
+#ifndef PHANTOM_COROUTINES_COMPILING_MODULES
+#include <source_location>
+#include "tracing.h"
+#endif
+
+static_assert(PHANTOM_COROUTINES_IS_CONFIGURED);
+PHANTOM_COROUTINES_ASSERT_IS_MODULE;
+
+namespace Phantom::Coroutines
+{
+
+namespace tracing
+{
+
+template<
+    typename Value,
+    typename Destination
+>
+struct formatted_text_trace_value
+{
+    const Value& value;
+};
+
+template<
+    typename Value,
+    typename Destination,
+    template<typename Value> typename Formatter
+>
+struct formatted_text_trace_value_formatter
+    :
+    Formatter<Value>
+{
+    using formatter_type = Formatter<Value>;
+
+    auto format(
+        const formatted_text_trace_value<Value, Destination>& formattedValue,
+        auto& context
+    ) const
+    {
+        return formatter_type::format(formattedValue.value, context);
+    }
+
+    using formatter_type::format;
+    using formatter_type::parse;
+};
+
+template<
+    typename TextTraceSink,
+    typename Destination = TextTraceSink
+>
+struct text_trace_sink
+{
+    TextTraceSink m_textTraceSink;
+
+    template<
+        typename Event
+    >
+    auto operator()(
+        const Event& event
+    )
+    {
+        m_textTraceSink(
+            formatted_text_trace_value<Event, Destination>
+            {
+                .value = event
+            }
+        );
+    }
+};
+
+// namespace [Phantom::Coroutines::]tracing
+}
+
+// namespace Phantom::Coroutines
+}
+
+#endif
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/thread_local_contextual_promise.h b/Phantom.Coroutines/include/Phantom.Coroutines/thread_local_contextual_promise.h
index 0f7d052..adbc455 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/thread_local_contextual_promise.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/thread_local_contextual_promise.h
@@ -36,20 +36,10 @@ template<
 
 private:
     std::optional<thread_local_context_scope> m_scope;
-    std::optional<value_type> m_value;
+    std::optional<value_type> m_value = ThreadLocalContext::current();
 
 public:
-    template<
-        typename... Args
-    > thread_local_contextual_promise(
-        Args&&... args
-    ) :
-        thread_local_contextual_promise::derived_promise{ std::forward<Args>(args)... },
-        m_value
-    {
-        ThreadLocalContext::current()
-    }
-    {}
+    using base_promise::base_promise;
 
     void enter()
     {
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/tracing.h b/Phantom.Coroutines/include/Phantom.Coroutines/tracing.h
index 084589a..28c7e1b 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/tracing.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/tracing.h
@@ -4,12 +4,16 @@
 #include <concepts>
 #include <exception>
 #include <source_location>
-#include <type_traits>
 #include <tuple>
+#include <type_traits>
+#include <typeindex>
+#include <typeinfo>
 #include <utility>
 #include "detail/config_macros.h"
 #include "detail/coroutine.h"
+#include "detail/scope_guard.h"
 #include "awaiter_wrapper.h"
+#include "functional.h"
 #include "extensible_promise.h"
 #include "type_traits.h"
 #endif
@@ -22,6 +26,18 @@ namespace Phantom::Coroutines
 
 namespace tracing
 {
+
+PHANTOM_COROUTINES_MODULE_EXPORT
+template<
+    typename TraceSink
+> concept is_trace_sink = true;
+//requires
+//{
+//    trace();
+//    should_trace();
+//    should_trace_return_value;
+//};
+
 namespace events
 {
 PHANTOM_COROUTINES_MODULE_EXPORT
@@ -44,739 +60,1073 @@ template<
     typename Awaiter
 > concept is_traced_promise_co_await_awaiter = std::remove_cvref_t<Awaiter>::is_traced_promise_co_await_awaiter;
 
-// Base for all tracing events.
 PHANTOM_COROUTINES_MODULE_EXPORT
-struct event
+template<
+    typename TValue
+>
+struct value
 {
-    std::source_location SourceLocation;
-
-    // Two event objects compare equal even if the source
-    // location is not equal, because SourceLocation
-    // is neither comparable nor reliable.
-    friend auto operator<=>(const event&, const event&)
-    {
-        return 0 <=> 0;
-    }
+    using value_type = TValue;
+    const value_type& Value;
 
-    friend bool operator==(const event&, const event&)
-    {
-        return true;
-    }
+    friend auto operator<=>(const value&, const value&) = default;
 };
 
-// Base for all tracing events that include arguments
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
     typename ... Args
-> struct arguments
-{
-    using arguments_type = std::tuple<const Args&...>;
-    arguments_type Arguments;
+>
+using arguments = value<std::tuple<const Args&...>>;
 
-    friend auto operator<=>(const arguments&, const arguments&) = default;
-};
+PHANTOM_COROUTINES_MODULE_EXPORT
+constexpr auto make_arguments(
+    const auto&... args
+)
+{
+    return value{ std::tie(std::as_const(args)...) };
+}
 
-// Base for all tracing events that refer to a promise.
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TPromise
+    typename Label
 >
-struct promise_event
-    :
-    event
+struct event_type
 {
-    TPromise* Promise;
+    event_type() = default;
+    event_type(
+        Label
+    )
+    {
+    }
+
+    using label_type = Label;
 
-    friend auto operator<=>(const promise_event&, const promise_event&) = default;
+    template<
+        typename Label1,
+        typename Label2
+    >
+    friend consteval bool operator==(
+        const event_type<Label1>&,
+        const event_type<Label2>&);
+
+    template<
+        typename Label1,
+        typename Label2
+    >
+    friend consteval bool operator!=(
+        const event_type<Label1>&,
+        const event_type<Label2>&);
 };
 
-// Trace a promise creation
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TPromise,
-    typename ... Args
+    typename Label1,
+    typename Label2
 >
-struct create_promise
-    :
-    promise_event<TPromise>,
-    arguments<Args...>
+consteval bool operator==(
+    const event_type<Label1>&,
+    const event_type<Label2>&)
 {
-    friend auto operator<=>(const create_promise&, const create_promise&) = default;
-};
+    return std::same_as<Label1, Label2>;
+}
 
-// Trace a promise destruction
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TPromise
+    typename Label1,
+    typename Label2
 >
-struct destroy_promise
-    :
-    promise_event<TPromise>
+consteval bool operator!=(
+    const event_type<Label1>&,
+    const event_type<Label2>&)
 {
-    friend auto operator<=>(const destroy_promise&, const destroy_promise&) = default;
-};
+    return !std::same_as<Label1, Label2>;
+}
 
-// Base for all tracing events that refer to a result value,
-// either from an awaiter or from the promise itself.
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TResult
+    typename TEventType,
+    typename TEventData,
+    template<typename> typename ... Accessors
 >
-struct result_event
+struct event : 
+    Accessors<event<TEventType, TEventData, Accessors...>>...
 {
-    static constexpr bool is_void_result = false;
-    using result_type = TResult;
-    using result_reference_type = const TResult&;
-
-    result_reference_type Result;
+    using event_type = event_type<TEventType>;
+    using event_data_type = TEventData;
+    
+    std::source_location SourceLocation;
+    event_type EventType;
+    event_data_type EventData;
+};
 
-    friend auto operator<=>(const result_event&, const result_event&) = default;
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct empty_value
+{
+    using value_type = void;
+    static constexpr void* Value = nullptr;
+    
+    friend auto operator<=>(const empty_value&, const empty_value&) = default;
 };
 
-// Base for all tracing events that refer to a void result value,
-// either from an awaiter or from the promise itself.
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
->
-struct result_event<void>
+struct empty_arguments_value
 {
-    static constexpr bool is_void_result = true;
-    using result_type = void;
+    using value_type = std::tuple<>;
+    static constexpr value_type Value = {};
 
-    friend auto operator<=>(const result_event&, const result_event&) = default;
+    friend auto operator<=>(const empty_arguments_value&, const empty_arguments_value&) = default;
 };
 
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename T
-> concept is_void_result_event = T::is_void_result;
+constexpr empty_value empty{};
+PHANTOM_COROUTINES_MODULE_EXPORT
+constexpr empty_arguments_value empty_arguments{ };
 
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TPromise,
-    typename TResult
->
-struct promise_result_event
-    :
-    promise_event<TPromise>,
-    result_event<TResult>
+struct no_awaiter_type
 {
-    friend auto operator<=>(const promise_result_event&, const promise_result_event&) = default;
+    static constexpr bool is_traced_promise_initial_suspend_awaiter = false;
+    static constexpr bool is_traced_promise_final_suspend_awaiter = false;
+    static constexpr bool is_traced_promise_co_yield_awaiter = false;
+    static constexpr bool is_traced_promise_co_await_awaiter = false;
 };
 
-// Base for all tracing events that refer to an exception,
-// either from an awaiter or from the promise itself.
 PHANTOM_COROUTINES_MODULE_EXPORT
-struct exception_event
+struct initial_suspend_awaiter_type
 {
-    std::exception_ptr Exception;
+    static constexpr bool is_traced_promise_initial_suspend_awaiter = true;
+    static constexpr bool is_traced_promise_final_suspend_awaiter = false;
+    static constexpr bool is_traced_promise_co_yield_awaiter = false;
+    static constexpr bool is_traced_promise_co_await_awaiter = false;
 };
 
-// Base for all tracing events that refer to an awaiter.
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TAwaiter
->
-struct awaiter_event
-    : event
+struct final_suspend_awaiter_type
 {
-    static constexpr bool is_initial_suspend = is_traced_promise_initial_suspend_awaiter<TAwaiter>;
-    static constexpr bool is_final_suspend = is_traced_promise_final_suspend_awaiter<TAwaiter>;
-    static constexpr bool is_co_yield = is_traced_promise_co_yield_awaiter<TAwaiter>;
-    static constexpr bool is_co_await = is_traced_promise_co_await_awaiter<TAwaiter>;
-
-    TAwaiter* Awaiter;
-
-    friend auto operator<=>(const awaiter_event&, const awaiter_event&) = default;
+    static constexpr bool is_traced_promise_initial_suspend_awaiter = false;
+    static constexpr bool is_traced_promise_final_suspend_awaiter = true;
+    static constexpr bool is_traced_promise_co_yield_awaiter = false;
+    static constexpr bool is_traced_promise_co_await_awaiter = false;
 };
 
-// Trace entry to an awaiter await_ready method.
-
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TAwaiter,
-    typename ... Arguments
->
-struct await_ready_event
-    :
-    awaiter_event<TAwaiter>,
-    arguments<Arguments...>
+struct co_yield_awaiter_type
 {
-    friend auto operator<=>(const await_ready_event&, const await_ready_event&) = default;
+    static constexpr bool is_traced_promise_initial_suspend_awaiter = false;
+    static constexpr bool is_traced_promise_final_suspend_awaiter = false;
+    static constexpr bool is_traced_promise_co_yield_awaiter = true;
+    static constexpr bool is_traced_promise_co_await_awaiter = false;
 };
 
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TAwaiter,
-    typename ... Arguments
->
-struct await_ready_begin
-    :
-    await_ready_event<TAwaiter, Arguments...>
+struct co_await_awaiter_type
 {
-    friend auto operator<=>(const await_ready_begin&, const await_ready_begin&) = default;
+    static constexpr bool is_traced_promise_initial_suspend_awaiter = false;
+    static constexpr bool is_traced_promise_final_suspend_awaiter = false;
+    static constexpr bool is_traced_promise_co_yield_awaiter = false;
+    static constexpr bool is_traced_promise_co_await_awaiter = true;
 };
 
-// Trace result from an awaiter await_ready method.
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TAwaiter,
-    typename TResult,
-    typename ... Arguments
->
-struct await_ready_result
-    :
-    await_ready_event<TAwaiter, Arguments...>,
-    result_event<TResult>
-{
-    friend auto operator<=>(const await_ready_result&, const await_ready_result&) = default;
-};
+    typename T
+> concept is_empty =
+std::same_as<T, nullptr_t>
+||
+std::same_as<T, empty_value>
+||
+std::same_as<T, empty_arguments_value>
+||
+std::same_as<T, no_awaiter_type>;
 
-// Trace exception from an awaiter await_ready method.
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TAwaiter,
-    typename ... Arguments
+    typename T
+> concept is_not_empty = !is_empty<T>;
+
+template<
+    typename Event
 >
-struct await_ready_exception
-    :
-    await_ready_event<TAwaiter, Arguments...>,
-    exception_event
+struct PromiseAccessor
 {
-    friend auto operator<=>(const await_ready_exception&, const await_ready_exception&) = default;
+    static constexpr bool has_promise = requires(Event self)
+    {
+        { self.Data.Promise } -> is_not_empty;
+    };
+
+    auto* promise(this auto& self)
+    {
+        if constexpr (has_promise)
+        {
+            return self.Data.Promise;
+        }
+        else
+        {
+            return &empty;
+        }
+    }
+    
+    static constexpr bool has_traced_promise = requires(Event self)
+    {
+        { self.Data.TracedPromise } -> is_not_empty;
+    };
+
+    auto* traced_promise(this auto& self)
+    {
+        if constexpr (has_traced_promise)
+        {
+            return self.Data.TracedPromise;
+        }
+        else
+        {
+            return &empty;
+        }
+    }
+
+    static constexpr bool has_promise_creation_arguments = requires(Event self)
+    {
+        { self.Data.PromiseCreationArguments } -> is_not_empty;
+    };
+
+    auto* promise_creation_arguments(
+        this auto& self
+    )
+    {
+        if constexpr (has_promise_creation_arguments)
+        {
+            return self.Data.PromiseCreationArguments;
+        }
+        else
+        {
+            return &empty_arguments;
+        }
+    }
 };
 
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TAwaiter
+    typename Event
 >
-struct await_ready_events
+struct AwaiterAccessor
 {
-    await_ready_events(const TAwaiter&) {}
+    static constexpr bool has_awaiter = requires(Event self)
+    {
+        { self.Data.Awaiter } -> is_not_empty;
+    };
 
-    template<
-        typename ... Arguments
-    >
-    using begin_event = await_ready_begin<TAwaiter, Arguments...>;
+    auto* awaiter(this auto& self)
+    {
+        if constexpr (has_awaiter)
+        {
+            return self.Data.Awaiter;
+        }
+        else
+        {
+            return &empty;
+        }
+    }
 
-    template<
-        typename Result,
-        typename ... Arguments
-    > using result_event = await_ready_result<TAwaiter, Result, Arguments...>;
+    static constexpr bool has_awaiter_type = requires(Event self)
+    {
+        { self.Data.AwaiterType } -> is_not_empty;
+    };
+
+    auto* awaiter_type(this auto& self)
+    {
+        if constexpr (has_awaiter_type)
+        {
+            return self.Data.AwaiterType;
+        }
+        else
+        {
+            return &empty;
+        }
+    }
+
+    static constexpr bool has_traced_awaiter = requires(Event self)
+    {
+        { self.Data.TracedAwaiter } -> is_not_empty;
+    };
+
+    auto* traced_awaiter(this auto& self)
+    {
+        if constexpr (has_awaiter)
+        {
+            return self.Data.TracedAwaiter;
+        }
+        else
+        {
+            return &empty;
+        }
+    }
 
-    template<
-        typename ... Arguments
-    >
-    using exception_event = await_ready_exception<TAwaiter, Arguments...>;
 };
 
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TAwaiter,
-    typename ... Arguments
+    typename Event
 >
-struct await_suspend_event
-    :
-    awaiter_event<TAwaiter>,
-    arguments<Arguments...>
+struct MethodArgumentsAccessor
 {
-    friend auto operator<=>(const await_suspend_event&, const await_suspend_event&) = default;
+    static constexpr bool has_method_arguments = requires(Event self)
+    {
+        { self.Data.MethodArguments } -> is_not_empty;
+    };
+
+    auto* method_arguments(this auto& self)
+    {
+        if constexpr (has_method_arguments)
+        {
+            return self.Data.MethodArguments;
+        }
+        else
+        {
+            return &empty_arguments;
+        }
+    }
 };
 
-// Trace entry from an awaiter await_suspend method.
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TAwaiter,
-    typename ... Arguments
+    typename Event
 >
-struct await_suspend_begin
-    :
-    await_suspend_event<TAwaiter, Arguments...>
+struct MethodResultAccessor
 {
-    friend auto operator<=>(const await_suspend_begin&, const await_suspend_begin&) = default;
+    static constexpr bool has_method_result = requires(Event self)
+    {
+        { self.Data.MethodResult } -> is_not_empty;
+    };
+
+    auto* method_result(this auto& self)
+    {
+        if constexpr (has_method_result)
+        {
+            return self.Data.MethodResult;
+        }
+        else
+        {
+            return &empty;
+        }
+    }
 };
 
-// Trace result from an await_suspend method.
-// Note that it is _highly likely_ that the TAwaiter parameter
-// to await_suspend_result is not valid anymore, since
-// the coroutine may have been destroyed if the await_suspend
-// allowed resuming the coroutine either in a nested fashion
-// or on another thread. In these cases, the awaiter object
-// is likely a temporary object that has been destroyed,
-// and should likely not be inspected.
-// For these reasons, the await_suspend_result event
-// might be emitted _after_ the await_resume events.
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TAwaiter,
-    typename TResult,
-    typename ... Arguments
+    typename Event
 >
-struct await_suspend_result
-    :
-    await_suspend_event<TAwaiter, Arguments...>,
-    result_event<TResult>
+struct MethodExceptionAccessor
 {
-    friend auto operator<=>(const await_suspend_result&, const await_suspend_result&) = default;
+    static constexpr bool has_method_exception = requires(Event self)
+    {
+        { self.Data.MethodException } -> is_not_empty;
+    };
+
+    auto* method_exception(this auto& self)
+    {
+        if constexpr (has_method_exception)
+        {
+            return self.Data.MethodException;
+        }
+        else
+        {
+            return &empty;
+        }
+    }
 };
 
-// Trace exception from an awaiter await_suspend method.
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TAwaiter,
-    typename ... Arguments
+    typename Event
 >
-struct await_suspend_exception
-    :
-    await_suspend_event<TAwaiter, Arguments...>,
-    exception_event
+struct UnhandledExceptionAccessor
 {
-    friend auto operator<=>(const await_suspend_exception&, const await_suspend_exception&) = default;
+    static constexpr bool has_unhandled_exception = requires(Event self)
+    {
+        { self.Data.UnhandledException } -> is_not_empty;
+    };
+
+    auto* unhandled_exception(this auto& self)
+    {
+        if constexpr (has_unhandled_exception)
+        {
+            return self.Data.UnhandledException;
+        }
+        else
+        {
+            return &empty;
+        }
+    }
 };
 
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TAwaiter
+    typename Event
 >
-struct await_suspend_events
+struct YieldValueAccessor
 {
-    await_suspend_events(const TAwaiter&) {}
-
-    template<
-        typename ... Arguments
-    > using begin_event = await_suspend_begin<TAwaiter, Arguments...>;
-
-    template<
-        typename Result,
-        typename ... Arguments
-    > using result_event = await_suspend_result<TAwaiter, Result, Arguments...>;
+    static constexpr bool has_yield_value = requires(Event self)
+    {
+        { self.Data.YieldValue } -> is_not_empty;
+    };
 
-    template<
-        typename ... Arguments
-    > using exception_event = await_suspend_exception<TAwaiter, Arguments...>;
+    auto* yield_value(this auto& self)
+    {
+        if constexpr (has_yield_value)
+        {
+            return self.Data.YieldValue;
+        }
+        else
+        {
+            return &empty;
+        }
+    }
 };
 
-// Base for all tracing events that refer to an awaiter await_ready method.
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TAwaiter,
-    typename ... Arguments
+    typename Event
 >
-struct await_resume_event
-    :
-    awaiter_event<TAwaiter>,
-    arguments<Arguments...>
+struct ReturnValueAccessor
 {
-    friend auto operator<=>(const await_resume_event&, const await_resume_event&) = default;
+    static constexpr bool has_return_value = requires(Event self)
+    {
+        { self.Data.ReturnValue } -> is_not_empty;
+    };
+
+    auto* return_value(this auto& self)
+    {
+        if constexpr (has_return_value)
+        {
+            return self.Data.ReturnValue;
+        }
+        else
+        {
+            return &empty;
+        }
+    }
 };
 
-// Trace entry to an awaiter await_resume method.
+// The trace sink is _queried_ for should_capture_promise_creation_arguments<Event>
+// to determine whether to capture the promise creation arguments. The query is
+// in the form of:
+// * Check to see if traceSink(const should_capture_promise_creation_arguments<PromiseCreationEvent>&) is accepted.
+// * If it is not, then do not capture and trace the promise creation arguments.
+// * If it is, check the return value:
+// * If it is std::true_type, then capture and trace the promise creation arguments.
+// * If it is std::false_type, then do not capture and trace the promise creation arguments
+// * If it is bool, then check the value at runtime to determine
+//  whether to capture and trace the promise creation arguments.
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TAwaiter,
-    typename ... Arguments
+    typename PromiseCreationEvent
 >
-struct await_resume_begin
-    :
-    await_resume_event<TAwaiter, Arguments...>
+struct should_capture_promise_creation_arguments
 {
-    friend auto operator<=>(const await_resume_begin&, const await_resume_begin&) = default;
-};
-
-// Trace result from an awaiter await_resume method.
+    using event_type = PromiseCreationEvent;
+};
+
+// The trace sink is _queried_ for should_trace_return_value<Event>
+// to determine whether to trace the return value. The query is
+// in the form of:
+// * Check to see if traceSink(const should_trace_return_value<Event>&) is accepted.
+// * If it is not, then do not trace the return value.
+// * If it is, check the return value:
+// * If it is std::true_type, then trace the return value.
+// * If it is std::false_type, then do not trace the return
+// * If it is bool, then check the value at runtime to determine
+//  whether to trace the return value.
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TAwaiter,
-    typename TResult,
-    typename ... Arguments
+    typename Event
 >
-struct await_resume_result
-    :
-    await_resume_event<TAwaiter, Arguments...>,
-    result_event<TResult>
+struct should_trace_return_value
 {
-    friend auto operator<=>(const await_resume_result&, const await_resume_result&) = default;
+    using event_type = Event;
 };
 
-// Trace exception from an awaiter await_resume method.
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TAwaiter,
-    typename ... Arguments
->
-struct await_resume_exception
-    :
-    await_resume_event<TAwaiter, Arguments...>,
-    exception_event
+struct event_is_begin
 {
-    friend auto operator<=>(const await_resume_exception&, const await_resume_exception&) = default;
+    static constexpr bool is_begin = true;
 };
 
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TAwaiter
->
-struct await_resume_events
+struct event_is_result
 {
-    await_resume_events(TAwaiter&) {}
+    static constexpr bool is_result = true;
+};
 
-    template<
-        typename ... Arguments
-    > using begin_event = await_resume_begin<TAwaiter, Arguments...>;
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct event_is_exception
+{
+    static constexpr bool is_exception = true;
+};
 
-    template<
-        typename Result,
-        typename ... Arguments
-    > using result_event = await_resume_result<TAwaiter, Result, Arguments...>;
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct event_is_await_ready
+{
+    static constexpr bool is_await_ready = true;
+};
 
-    template<
-        typename ... Arguments
-    > using exception_event = await_resume_exception<TAwaiter, Arguments...>;
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct event_is_await_suspend
+{
+    static constexpr bool is_await_suspend = true;
 };
 
-// Base for promise events that return an exception
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TPromise
->
-struct promise_exception_event
-    :
-    promise_event<TPromise>,
-    exception_event
+struct event_is_await_resume
 {
-    friend auto operator<=>(const promise_exception_event&, const promise_exception_event&) = default;
+    static constexpr bool is_await_resume = true;
 };
 
-// Trace unhandled_exception on a promise.
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TPromise
-> struct unhandled_exception
-    :
-    promise_exception_event<TPromise>
+struct event_is_await_transform
 {
-    friend auto operator<=>(const unhandled_exception&, const unhandled_exception&) = default;
+    static constexpr bool is_await_transform = true;
 };
 
-// Trace entry to an return_void method.
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TPromise
-> struct return_void_begin
-    :
-    promise_event<TPromise>
+struct event_is_unhandled_exception
 {
-    friend auto operator<=>(const return_void_begin&, const return_void_begin&) = default;
+    static constexpr bool is_unhandled_exception = true;
 };
 
-// Trace result from a return_void method.
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TPromise,
-    typename TResult
-> struct return_void_result
-    :
-    promise_result_event<TPromise, TResult>
+struct event_is_get_return_object
 {
-    friend auto operator<=>(const return_void_result&, const return_void_result&) = default;
+    static constexpr bool is_get_return_object = true;
 };
 
-// Trace exception from a return_void method.
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TPromise
-> struct return_void_exception
-    :
-    promise_exception_event<TPromise>
+struct event_is_yield_value
 {
-    friend auto operator<=>(const return_void_exception&, const return_void_exception&) = default;
+    static constexpr bool is_yield_value = true;
 };
 
-// Trace entry to a return_value method.
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TPromise,
-    typename Argument
-> struct return_value_begin
-    :
-    promise_result_event<TPromise, Argument>
+struct event_is_return_value
 {
-    friend auto operator<=>(const return_value_begin&, const return_value_begin&) = default;
+    static constexpr bool is_return_value = true;
 };
 
-// Trace result from a return_value method.
 PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TPromise,
-    typename TResult
-> struct return_value_result
-    :
-    promise_result_event<TPromise, TResult>
+struct event_is_return_void
 {
-    friend auto operator<=>(const return_value_result&, const return_value_result&) = default;
+    static constexpr bool is_return_void = true;
 };
 
-// Trace exception from a return_value method.
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct create_promise {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct destroy_promise {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct await_ready_begin : event_is_await_ready, event_is_begin {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct await_ready_result : event_is_await_ready, event_is_result {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct await_ready_exception : event_is_await_ready, event_is_exception {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct await_suspend_begin : event_is_await_suspend, event_is_begin {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct await_suspend_result : event_is_await_suspend, event_is_result {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct await_suspend_exception : event_is_await_suspend, event_is_exception {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct await_resume_begin : event_is_await_resume, event_is_begin {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct await_resume_result : event_is_await_resume, event_is_result {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct await_resume_exception : event_is_await_resume, event_is_exception {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct await_transform_begin : event_is_await_transform, event_is_begin {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct await_transform_result : event_is_await_transform, event_is_result {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct await_transform_exception : event_is_await_transform, event_is_exception {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct unhandled_exception_begin : event_is_unhandled_exception, event_is_begin {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct unhandled_exception_result : event_is_unhandled_exception, event_is_result {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct unhandled_exception_exception : event_is_unhandled_exception, event_is_exception {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct get_return_object_begin : event_is_get_return_object, event_is_begin {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct get_return_object_result : event_is_get_return_object, event_is_result {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct get_return_object_exception : event_is_get_return_object, event_is_exception {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct yield_value_begin : event_is_yield_value, event_is_begin {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct yield_value_result : event_is_yield_value, event_is_result {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct yield_value_exception : event_is_yield_value, event_is_exception {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct return_value_begin : event_is_return_value, event_is_begin {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct return_value_result : event_is_return_value, event_is_result {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct return_value_exception : event_is_return_value, event_is_exception {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct return_void_begin : event_is_return_void, event_is_begin {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct return_void_result : event_is_return_void, event_is_result {};
+PHANTOM_COROUTINES_MODULE_EXPORT
+struct return_void_exception : event_is_return_void, event_is_exception {};
+
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TPromise
-> struct return_value_exception
-    :
-    promise_exception_event<TPromise>
+    typename Event,
+    typename EventType
+> concept is_event_type = std::same_as<typename Event::event_type::label_type, EventType>;
+
+PHANTOM_COROUTINES_MODULE_EXPORT
+template<
+    typename TPromise = empty_value,
+    typename TTracedPromise = empty_value,
+    typename TPromiseCreationArguments = empty_arguments_value,
+    typename TAwaiter = empty_value,
+    typename TTracedAwaiter = empty_value,
+    typename TAwaiterType = no_awaiter_type,
+    typename TMethodArguments = empty_arguments_value,
+    typename TMethodResult = empty_value,
+    typename TMethodException = empty_value,
+    typename TUnhandledException = empty_value,
+    typename TYieldValue = empty_value,
+    typename TReturnValue = empty_value
+>
+struct event_data
 {
-    friend auto operator<=>(const return_value_exception&, const return_value_exception&) = default;
+    PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS TPromise Promise = empty;
+    PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS TTracedPromise TracedPromise = empty;
+    PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS TPromiseCreationArguments PromiseCreationArguments = empty_arguments;
+    PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS TAwaiter Awaiter = empty;
+    PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS TTracedAwaiter TracedAwaiter = empty;
+    PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS TAwaiterType AwaiterType = no_awaiter_type{};
+    PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS TMethodArguments MethodArguments = empty_arguments;
+    PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS TMethodResult MethodResult = empty;
+    PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS TMethodException MethodException = empty;
+    PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS TUnhandledException UnhandledException = empty;
+    PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS TYieldValue YieldValue = empty;
+    PHANTOM_COROUTINES_NO_UNIQUE_ADDRESS TReturnValue ReturnValue = empty;
+
+    friend auto operator<=>(const event_data&, const event_data&) = default;
+
+    static constexpr auto combine(
+        const auto& lhs,
+        const auto& rhs
+    )
+    {
+        if constexpr (is_empty<std::remove_cvref_t<decltype(rhs)>>)
+        {
+            return lhs;
+        }
+        else
+        {
+            return rhs;
+        }
+    }
+
+    auto with(
+        const auto& other
+    ) const
+    {
+        return events::event_data
+        {
+            .Promise = combine(
+                this->Promise, 
+                other.Promise),
+            .TracedPromise = combine(
+                this->TracedPromise,
+                other.TracedPromise),
+            .PromiseCreationArguments = combine(
+                this->PromiseCreationArguments, 
+                other.PromiseCreationArguments),
+            .Awaiter = combine(
+                this->Awaiter, 
+                other.Awaiter),
+            .TracedAwaiter = combine(
+                this->TracedAwaiter,
+                other.TracedAwaiter),
+            .AwaiterType = combine(
+                this->AwaiterType,
+                other.AwaiterType),
+            .MethodArguments = combine(
+                this->MethodArguments, 
+                other.MethodArguments),
+            .MethodResult = combine(
+                this->MethodResult, 
+                other.MethodResult),
+            .MethodException = combine(
+                this->MethodException, 
+                other.MethodException),
+            .UnhandledException = combine(
+                this->UnhandledException, 
+                other.UnhandledException),
+            .YieldValue = combine(
+                this->YieldValue, 
+                other.YieldValue),
+            .ReturnValue = combine(
+                this->ReturnValue, 
+                other.ReturnValue),
+        };
+    }
 };
 
+template<
+    typename EventType,
+    typename EventData
+>
+using basic_event_type = event<
+    EventType,
+    EventData,
+    PromiseAccessor,
+    AwaiterAccessor,
+    MethodArgumentsAccessor,
+    MethodResultAccessor,
+    MethodExceptionAccessor,
+    UnhandledExceptionAccessor,
+    YieldValueAccessor,
+    ReturnValueAccessor
+>;
+
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename Argument
+    typename EventType,
+    typename EventData
 >
-struct return_value_argument_events
+auto basic_event(
+    const std::source_location& sourceLocation,
+    const EventType& eventType,
+    const EventData& eventData
+)
 {
-    template<
-        typename TPromise
-    > using return_value_begin = events::return_value_begin<TPromise, Argument>;
+    return basic_event_type<
+        EventType,
+        EventData
+    >
+    {
+        .SourceLocation = sourceLocation,
+        .EventType = eventType,
+        .EventData = eventData,
+    };
+}
 
-    template<
-        typename TPromise,
-        typename TResult
-    > using return_value_result = events::return_value_result<TPromise, TResult>;
+// namespace events
+}
+
+namespace detail
+{
+
+template<
+    is_trace_sink TraceSink
+>
+struct trace_sink_accessor
+{
+    TraceSink m_traceSink;
 
-    template<
-        typename TPromise
-    > using return_value_exception = events::return_value_exception<TPromise>;
+    auto& trace_sink()
+    {
+        return m_traceSink;
+    }
 };
 
-// Trace entry to a yield_value method.
 template<
-    typename TPromise,
-    typename Argument
-> struct yield_value_event
-    :
-    promise_event<TPromise>,
-    arguments<Argument>
+    typename BeginEventType,
+    typename ResultEventType,
+    typename ExceptionEventType
+>
+struct method_events_group
 {
-};
+    method_events_group(
+        BeginEventType,
+        ResultEventType,
+        ExceptionEventType)
+    { }
 
-PHANTOM_COROUTINES_MODULE_EXPORT
-template<
-    typename TPromise,
-    typename Argument
-> struct yield_value_begin
-    :
-    yield_value_event<TPromise, Argument>
-{
-    friend auto operator<=>(const yield_value_begin&, const yield_value_begin&) = default;
+    using begin_event_type = BeginEventType;
+    using result_event_type = ResultEventType;
+    using exception_event_type = ExceptionEventType;
+
+    BeginEventType BeginEvent;
+    ResultEventType ResultEvent;
+    ExceptionEventType ExceptionEvent;
 };
 
-// Trace result from a yield_value method.
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TPromise,
-    typename Argument,
-    typename TResult
-> struct yield_value_result
-    :
-    yield_value_event<TPromise, Argument>,
-    result_event<TResult>
+    typename TraceSink,
+    typename EventType,
+    typename BaseEventData,
+    typename MethodResult
+>
+struct trace_sink_should_trace_return_value_result_type
 {
-    friend auto operator<=>(const yield_value_result&, const yield_value_result&) = default;
+    static constexpr bool can_trace_return_value = false;
+    static constexpr bool should_query_for_trace_return_value = false;
 };
 
-// Trace exception from a yeild_value method.
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TPromise,
-    typename Argument
-> struct yield_value_exception
-    :
-    yield_value_event<TPromise, Argument>
-{
-    friend auto operator<=>(const yield_value_exception&, const yield_value_exception&) = default;
-};
+    typename EventType,
+    typename BaseEventData,
+    typename MethodResult
+>
+using should_trace_return_value_query_type = events::should_trace_return_value<
+    decltype(
+        std::declval<BaseEventData>().with(
+                events::event_data
+                {
+                    .MethodResult = events::value{ std::declval<MethodResult>() }
+            })
+        ) > ;
 
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TPromise
+    typename TraceSink,
+    typename EventType,
+    typename BaseEventData,
+    typename MethodResult
+>
+requires 
+(
+    (
+        std::is_move_constructible_v<MethodResult>
+        ||
+        std::is_copy_constructible_v<MethodResult>
+    )
+    &&
+    std::invocable<
+        TraceSink,
+        should_trace_return_value_query_type<
+            EventType, 
+            BaseEventData, 
+            MethodResult
+        >
+    >
+)
+struct trace_sink_should_trace_return_value_result_type<
+    TraceSink,
+    EventType,
+    BaseEventData,
+    MethodResult
 >
-struct yield_value_argument_events
 {
-    template<
-        typename ... Arguments
-    > using yield_value_begin = events::yield_value_begin<TPromise, Arguments...>;
+    using query_type = should_trace_return_value_query_type<
+        EventType,
+        BaseEventData,
+        MethodResult
+    >;
 
-    template<
-        typename TResult,
-        typename ... Arguments
-    > using yield_value_result = events::yield_value_result<TPromise, TResult, Arguments...>;
+    using type = std::invoke_result_t<
+        TraceSink,
+        query_type>;
 
-    template<
-        typename ... Arguments
-    > using yield_value_exception = events::yield_value_exception<TPromise, Arguments...>;
-};
+    static constexpr bool can_trace_return_value = 
+        std::same_as<type, std::true_type>
+        || std::same_as<type, bool>;
 
-// namespace events
-}
+    static constexpr bool should_query_for_trace_return_value = std::same_as<type, bool>;
+};
 
-PHANTOM_COROUTINES_MODULE_EXPORT
 template<
     typename TraceSink
-> concept is_trace_sink = std::invocable<
-    TraceSink,
-    events::event
->;
-
-PHANTOM_COROUTINES_MODULE_EXPORT
-struct initial_suspend_awaiter
+>
+struct trace_sink_capture_promise_creation_arguments_result_type
 {
-    static constexpr bool is_traced_promise_initial_suspend_awaiter = true;
-    static constexpr bool is_traced_promise_final_suspend_awaiter = false;
-    static constexpr bool is_traced_promise_co_yield_awaiter = false;
-    static constexpr bool is_traced_promise_co_await_awaiter = false;
+    // Default: sink does not respond to the query → always capture (current unconditional behavior).
+    static constexpr bool should_not_capture = false;
+    static constexpr bool should_query_at_runtime = false;
 };
 
-PHANTOM_COROUTINES_MODULE_EXPORT
-struct final_suspend_awaiter
+template<
+    typename TraceSink
+>
+requires std::invocable<TraceSink, events::should_capture_promise_creation_arguments<events::create_promise>>
+struct trace_sink_capture_promise_creation_arguments_result_type<TraceSink>
 {
-    static constexpr bool is_traced_promise_initial_suspend_awaiter = false;
-    static constexpr bool is_traced_promise_final_suspend_awaiter = true;
-    static constexpr bool is_traced_promise_co_yield_awaiter = false;
-    static constexpr bool is_traced_promise_co_await_awaiter = false;
+    using type = std::invoke_result_t<TraceSink, events::should_capture_promise_creation_arguments<events::create_promise>>;
+    static constexpr bool should_not_capture = std::same_as<type, std::false_type>;
+    static constexpr bool should_query_at_runtime = std::same_as<type, bool>;
 };
 
-PHANTOM_COROUTINES_MODULE_EXPORT
-struct co_yield_awaiter
-{
-    static constexpr bool is_traced_promise_initial_suspend_awaiter = false;
-    static constexpr bool is_traced_promise_final_suspend_awaiter = false;
-    static constexpr bool is_traced_promise_co_yield_awaiter = true;
-    static constexpr bool is_traced_promise_co_await_awaiter = false;
-};
+} // namespace detail
 
-PHANTOM_COROUTINES_MODULE_EXPORT
-struct co_await_awaiter
+auto call_traced_method(
+    const auto& traceSink,
+    auto events,
+    std::source_location sourceLocation,
+    const auto& baseEventData,
+    std::invocable<> auto call
+) -> std::invoke_result_t<decltype(call)>
 {
-    static constexpr bool is_traced_promise_initial_suspend_awaiter = false;
-    static constexpr bool is_traced_promise_final_suspend_awaiter = false;
-    static constexpr bool is_traced_promise_co_yield_awaiter = false;
-    static constexpr bool is_traced_promise_co_await_awaiter = true;
-};
+    using result_type = std::invoke_result_t<decltype(call)>;
+    constexpr bool is_move_constructible = std::is_move_constructible_v<result_type>;
+    constexpr bool is_copy_constructible = std::is_copy_constructible_v<result_type>;
+    using trace_sink_should_trace_return_value_result_type = detail::trace_sink_should_trace_return_value_result_type<
+        decltype(traceSink),
+        decltype(events.ResultEvent),
+        decltype(baseEventData),
+        result_type>;
+
+    constexpr bool can_trace_return_value = 
+        trace_sink_should_trace_return_value_result_type::can_trace_return_value
+        &&
+        (
+            is_move_constructible
+            ||
+            is_copy_constructible
+            );
+
+    constexpr bool should_query_for_trace_return_value = can_trace_return_value
+        && trace_sink_should_trace_return_value_result_type::should_query_for_trace_return_value;
+
+    auto invoke_without_tracing_return_value = [&]() -> result_type
+    {
+        if constexpr (std::same_as<void, result_type>)
+        {
+            call();
+            traceSink(
+                events::basic_event(
+                    sourceLocation,
+                    events.ResultEvent,
+                    baseEventData));
+        }
+        else
+        {
+            auto uncaughtExceptions = std::uncaught_exceptions();
 
-namespace detail
-{
-template<
-    typename TraceSink
->
-struct trace_sink_accessor
-{
-    TraceSink m_traceSink;
+            Coroutines::detail::scope_guard guard = [&]()
+            {
+                if (std::uncaught_exceptions() != uncaughtExceptions)
+                {
+                    // If the number of uncaught exceptions has changed in between
+                    // the call being performed and this guard being deactivated,
+                    // it means an exception was thrown by the call,
+                    // and we should not report a "result" type but an "exception" type.
+                    return;
+                };
 
-    auto& trace_sink()
+                traceSink(
+                    events::basic_event(
+                        sourceLocation,
+                        events.ResultEvent,
+                        baseEventData));
+            };
+
+            return call();
+        }
+    };
+
+    try
     {
-        return m_traceSink;
-    }
-};
+        traceSink(
+            events::basic_event(
+                sourceLocation,
+                events.BeginEvent,
+                baseEventData));
 
-} // namespace detail
+        if constexpr (!can_trace_return_value)
+        {
+            return invoke_without_tracing_return_value();
+        }
+        else
+        {
+            auto invoke_with_tracing_return_value = [&]() -> result_type
+            {
+                decltype(auto) result = call();
+                traceSink(
+                    events::basic_event(
+                        sourceLocation,
+                        events.ResultEvent,
+                        baseEventData.with(
+                            events::event_data
+                            {
+                                .MethodResult = events::value{ result }
+                            })));
+
+                if constexpr (is_move_constructible && !std::is_reference_v<result_type>)
+                {
+                    return auto(result);
+                }
+                else
+                {
+                    return result;
+                }
+            };
+
+            if constexpr (!should_query_for_trace_return_value)
+            {
+                return invoke_with_tracing_return_value();
+            }
+            else
+            {
+                bool shouldTraceReturnValue = traceSink(
+                    events::should_trace_return_value<
+                        decltype(events::basic_event(
+                            sourceLocation,
+                            events.ResultEvent,
+                            baseEventData.with(
+                                events::event_data
+                                {
+                                    .MethodResult = events::value{ std::declval<result_type>() }
+                                })))>{});
+                if (shouldTraceReturnValue)
+                {
+                    return invoke_with_tracing_return_value();
+                }
+                else
+                {
+                    return invoke_without_tracing_return_value();
+                }
+            }
+        }
+    }
+    catch (...)
+    {
+        auto exception = std::current_exception();
+        traceSink(
+            events::basic_event(
+                sourceLocation,
+                events.ExceptionEvent,
+                baseEventData.with(
+                    events::event_data
+                    {
+                        .MethodException = events::value{ exception }
+                    })));
+        throw;
+    }
+}
 
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TraceSink,
+    is_trace_sink TraceSink,
     typename Awaitable,
-    typename AwaiterType
+    typename AwaiterType,
+    typename BaseEventData
 >
 struct traced_awaiter :
     detail::trace_sink_accessor<TraceSink>,
     awaiter_wrapper<Awaitable>,
     AwaiterType
 {
-    using awaiter_wrapper = traced_awaiter::awaiter_wrapper;
+    using awaiter_wrapper = awaiter_wrapper<Awaitable>;
     using trace_sink_accessor = traced_awaiter::trace_sink_accessor;
     using traced_awaiter::trace_sink_accessor::trace_sink;
+    using wrapped_awaiter_type = std::remove_reference_t<typename awaiter_wrapper::awaiter_type>;
 
     std::source_location m_sourceLocation;
+    BaseEventData m_baseEventData;
 
-    template<
-        typename Events,
-        std::invocable<> Call,
-        typename... Arguments
-    >
     auto call_awaiter(
-        [[maybe_unused]] this auto& awaiter,
-        Events,
-        [[maybe_unused]] Call call,
-        [[maybe_unused]] std::tuple<Arguments&...> traceArguments
-    ) -> std::invoke_result_t<Call>
-    {
-        using wrapped_awaiter_type = typename traced_awaiter::awaiter_wrapper::awaiter_type;
-
-        using begin_event_type = typename Events::template begin_event<
-            Arguments...
-        >;
-        using result_type = std::invoke_result_t<Call>;
-        using result_event_type = typename Events::template result_event<
-            result_type,
-            Arguments...
-        >;
-        using exception_event_type = typename Events::template exception_event<
-            Arguments...
-        >;
-
-        // We capture these variables here because
-        // the await_suspend_result event may be emitted
-        // after the awaiter has been destroyed.
-        auto traceSink = awaiter.traced_awaiter::trace_sink();
-        auto sourceLocation = awaiter.traced_awaiter::m_sourceLocation;
-
-        try
-        {
-            traceSink(
-                begin_event_type
-                {
-                    sourceLocation,
-                    &awaiter,
-                    traceArguments
-                });
-
-            if constexpr (std::same_as<void, result_type>)
-            {
-                call();
-                traceSink(
-                    result_event_type
-                    {
-                        sourceLocation,
-                        &awaiter,
-                        traceArguments,
-                    });
-            }
-            else
-            {
-                decltype(auto) result = call();
-
-                traceSink(
-                    result_event_type
-                    {
-                        sourceLocation,
-                        &awaiter,
-                        traceArguments,
-                        result,
-                    });
-
-                return result;
-            }
-        }
-        catch (...)
-        {
-            traceSink(
-                exception_event_type
+        this auto& awaiter,
+        auto events,
+        const auto& baseEventData,
+        std::invocable<> auto call
+        
+    ) -> std::invoke_result_t<decltype(call)>
+    {
+        return call_traced_method(
+            awaiter.traced_awaiter::trace_sink(),
+            events,
+            awaiter.m_sourceLocation,
+            baseEventData.with(
+                events::event_data
                 {
-                    sourceLocation,
-                    &awaiter,
-                    traceArguments,
-                    std::current_exception(),
-                });
-            throw;
-        }
+                    .Awaiter = static_cast<wrapped_awaiter_type*>(std::addressof(awaiter.awaiter())),
+                    .TracedAwaiter = std::addressof(awaiter),
+                    .AwaiterType = AwaiterType{},
+                }),
+            call);
     }
 
     decltype(auto) await_ready(
@@ -784,12 +1134,18 @@ struct traced_awaiter :
         ) noexcept(noexcept(self.awaiter_wrapper::await_ready()))
     {
         return self.traced_awaiter::call_awaiter(
-            events::await_ready_events{ self },
+            detail::method_events_group
+            {
+                events::await_ready_begin{},
+                events::await_ready_result{},
+                events::await_ready_exception{},
+            },
+            self.get_event_data(
+                events::empty_arguments),
             [&]() -> decltype(auto)
             {
                 return self.awaiter_wrapper::await_ready();
-            },
-            std::tie()
+            }
         );
     }
 
@@ -802,13 +1158,19 @@ struct traced_awaiter :
         ) noexcept(noexcept(self.awaiter_wrapper::await_suspend(std::forward<Arg>(arg))))
     {
         return self.traced_awaiter::call_awaiter(
-            events::await_suspend_events{ self },
+            detail::method_events_group
+            {
+                events::await_suspend_begin{},
+                events::await_suspend_result{},
+                events::await_suspend_exception{},
+            },
+            self.get_event_data(
+                events::make_arguments(arg)),
             [&]() -> decltype(auto)
             {
                 return self.awaiter_wrapper::await_suspend(
                     std::forward<Arg>(arg));
-            },
-            std::tie(arg)
+            }
         );
     }
 
@@ -817,50 +1179,78 @@ struct traced_awaiter :
     ) noexcept(noexcept(self.awaiter_wrapper::await_resume()))
     {
         return self.traced_awaiter::call_awaiter(
-            events::await_resume_events{ self },
+            detail::method_events_group
+            {
+                events::await_resume_begin{},
+                events::await_resume_result{},
+                events::await_resume_exception{},
+            },
+            self.get_event_data(
+                events::empty_arguments),
             [&]() -> decltype(auto)
             {
                 return self.awaiter_wrapper::await_resume();
-            },
-            std::tie()
+            }
         );
     }
 
     traced_awaiter(
         std::source_location sourceLocation,
         std::invocable auto awaiterFunction,
+        AwaiterType,
         trace_sink_accessor traceSinkAccessor,
-        AwaiterType awaiterType
+        BaseEventData baseEventData
     )
         :
         trace_sink_accessor{ traceSinkAccessor },
         m_sourceLocation{ sourceLocation },
         awaiter_wrapper{ std::move(awaiterFunction) },
-        AwaiterType{ awaiterType }
+        m_baseEventData{ std::move(baseEventData) }
+    {
+    }
+
+    template<
+        typename ... Args
+    >
+    auto get_event_data(
+        this auto& awaiter,
+        const auto& methodArguments
+    )
     {
+        return awaiter.m_baseEventData.with(
+            events::event_data
+        {
+            .Awaiter = &awaiter,
+            .MethodArguments = methodArguments,
+        });
     }
 };
 
 template<
-    std::invocable AwaiterFunction,
-    typename TraceSink,
-    typename AwaiterType
+    is_trace_sink TraceSink,
+    std::invocable<> AwaiterFunction,
+    typename AwaiterType,
+    typename BaseEventData
 >
 traced_awaiter(
     std::source_location,
     AwaiterFunction,
+    AwaiterType,
     detail::trace_sink_accessor<TraceSink>,
-    AwaiterType
+    BaseEventData
 ) -> traced_awaiter<
     TraceSink,
     std::invoke_result_t<AwaiterFunction>,
-    AwaiterType
+    AwaiterType,
+    BaseEventData
 >;
 
 
 namespace detail
 {
 
+// This class stored the trace sink and produces non-result-specific tracing events.
+PHANTOM_COROUTINES_MODULE_EXPORT
 template<
     is_trace_sink TraceSink
 >
@@ -874,147 +1264,122 @@ class traced_promise_trace_sink_storage
 public:
     using trace_sink_type = TraceSink;
 
-protected:
-    TraceSink m_traceSink;
+public:
+    trace_sink_type m_traceSink;
 
     template<
-        typename TPromise
+        typename ... Args
     >
+    requires
+        is_constructible_from_promise_arguments<trace_sink_type, Args&&...>
     traced_promise_trace_sink_storage(
-        TPromise& self,
-        auto& ... args
-    )
-        requires std::constructible_from<TraceSink, decltype(args)...>
-    :
-    m_traceSink{ args... }
+        Args&& ... args
+    ) :
+    m_traceSink(std::forward<Args>(args)...)
     {
-        m_traceSink(
-            events::create_promise<
-                TPromise,
-                decltype(args)&...
-            >
-        {
-            std::source_location::current(),
-                & self,
-                std::tie(args...)
-        });
     }
 
+    // Allow default construction of the trace sink when arguments are provided.
     template<
-        typename TPromise
+        typename ... Args
     >
+    requires 
+        is_default_constructible_from_promise_arguments<trace_sink_type, Args&&...>
     traced_promise_trace_sink_storage(
-        TPromise& self,
-        auto& ... args
-    )
-    requires (
-        !std::constructible_from<TraceSink, decltype(args)...>
-        && std::constructible_from<TraceSink>
+        Args&& ... args
+    ) :
+    m_traceSink()
+    {
+    }
+
+    auto get_event_data(
+        this auto& promise
     )
-    :
-    m_traceSink{}
     {
-        m_traceSink(
-            events::create_promise<
-                TPromise,
-                decltype(args)...
-            >
+        return events::event_data
         {
-            std::source_location::current(),
-                & self,
-                std::make_tuple<const decltype(args)&...>(args...)
-        });
+            .Promise = &promise.get_underlying_promise(),
+            .TracedPromise = &promise,
+        };
     }
 
-    template<
-        typename TPromise,
-        template<typename TBeginEventPromise> typename BeginEventType,
-        template<typename TResultEventPromise, typename Result> typename ResultEventType,
-        template<typename TExceptionEventPromise> typename ExceptionEventType
-    >
-    decltype(auto) call_promise(
-        this TPromise& promise,
+    decltype(auto) call_promise_method(
+        this auto& promise,
+        auto events,
         std::source_location sourceLocation,
-        std::invocable auto call,
-        auto&& ... traceArgs
+        const auto& baseEventData,
+        std::invocable auto call
     )
     {
-        using promise_type = std::remove_cvref_t<TPromise>;
-
-        try
-        {
-            promise.traced_promise_trace_sink_storage::m_traceSink(
-                BeginEventType<promise_type>
-            {
-                sourceLocation,
-                    & promise,
-                    std::forward<decltype(traceArgs)>(traceArgs)...
-            });
-
-            using result_type = decltype(call());
-            if constexpr (std::same_as<void, result_type>)
-            {
-                call();
-
-                promise.traced_promise_trace_sink_storage::m_traceSink(
-                    ResultEventType<promise_type, void>
-                {
-                    sourceLocation,
-                        & promise,
-                });
-            }
-            else
-            {
-                decltype(auto) result = call();
-
-                promise.traced_promise_trace_sink_storage::m_traceSink(
-                    ResultEventType<promise_type, result_type>
-                {
-                    sourceLocation,
-                        & promise,
-                        std::forward<decltype(traceArgs)>(traceArgs)...,
-                        result
-                });
-
-                return std::forward<decltype(result)>(result);
-            }
-        }
-        catch (...)
-        {
-            promise.traced_promise_trace_sink_storage::m_traceSink(
-                ExceptionEventType<promise_type>
-            {
-                sourceLocation,
-                    & promise,
-                    std::current_exception(),
-            });
-            throw;
-        }
+        return call_traced_method(
+            promise.traced_promise_trace_sink_storage::m_traceSink,
+            events,
+            sourceLocation,
+            baseEventData.with(
+                promise.get_event_data()),
+            call);
     }
 };
 
+// This class embodies constructors for traced promises.
 template<
     is_trace_sink TraceSink,
     typename BasePromise
 >
-class traced_promise_yield_value
+class traced_promise_construction
     :
     public traced_promise_trace_sink_storage<TraceSink>,
     public derived_promise<BasePromise>
 {
 public:
     template<
-        typename TPromise
+        typename ... Args
     >
-    traced_promise_yield_value(
-        TPromise& self,
-        auto&& ... args
-    ) :
-        traced_promise_yield_value::traced_promise_trace_sink_storage{ self, std::forward<decltype(args)>(args)... },
-        traced_promise_yield_value::derived_promise{ std::forward<decltype(args)>(args)... }
+    requires 
+        std::constructible_from<traced_promise_trace_sink_storage<TraceSink>, Args&&...>
+        && 
+        std::constructible_from<derived_promise<BasePromise>, Args&&...>
+    traced_promise_construction(
+        Args&& ... args
+    ) 
+        :
+        traced_promise_construction::traced_promise_trace_sink_storage(std::forward<Args>(args)...),
+        traced_promise_construction::derived_promise(std::forward<Args>(args)... )
     {
     }
+};
+
+// This class provides an implementation of yield_value for a promise
+// if it has a yield_value implementation.
+// The main template does not provide yield_value.
+template<
+    is_trace_sink TraceSink,
+    typename BasePromise
+>
+class traced_promise_yield_value
+    :
+    public traced_promise_construction<TraceSink, BasePromise>
+{
+public:
+    using traced_promise_yield_value::traced_promise_construction::traced_promise_construction;
+};
+
+// The specialization for promises that have yield_value.
+template<
+    is_trace_sink TraceSink,
+    has_yield_value BasePromise
+>
+class traced_promise_yield_value<
+    TraceSink,
+    BasePromise
+>
+    :
+    public traced_promise_construction<TraceSink, BasePromise>
+{
+public:
+    using traced_promise_yield_value::traced_promise_construction::traced_promise_construction;
 
+    // Trace an delegate the base class's yield_value implementation.
     template<
         typename TPromise
     >
@@ -1023,23 +1388,24 @@ class traced_promise_yield_value
         auto&& value,
         std::source_location sourceLocation = std::source_location::current()
     )
-        requires has_yield_value<BasePromise>
-    {
-        return std::forward<TPromise>(promise).template call_promise<
-            TPromise,
-            events::yield_value_argument_events<decltype(value)>::yield_value_begin,
-            events::yield_value_argument_events<decltype(value)>::yield_value_result,
-            events::yield_value_argument_events<decltype(value)>::yield_value_exception
-        >(
-            promise,
+    {
+        return std::forward<TPromise>(promise).call_promise_method(
+            detail::method_events_group
+            {
+                events::yield_value_begin{},
+                events::yield_value_result{},
+                events::yield_value_exception{},
+            },
             sourceLocation,
+            events::event_data
+            {
+                .MethodArguments = events::make_arguments(value),
+            },
             [&]()
             {
-                return std::forward<TPromise>(promise).traced_promise_yield_value::yield_value(
+                return std::forward<TPromise>(promise).traced_promise_construction<TraceSink, BasePromise>::yield_value(
                     std::forward<decltype(value)>(value));
-            },
-            value,
-            co_yield_awaiter{}
+            }
         );
     }
 };
@@ -1055,29 +1421,35 @@ class traced_promise_return_value_or_void
     using traced_promise_return_value_or_void::traced_promise_yield_value::traced_promise_yield_value;
 
 public:
+    using traced_promise_return_value_or_void::traced_promise_yield_value::call_promise_method;
+
     template<
         typename TPromise,
         typename Value
     >
-    decltype(auto) return_value(
+    void return_value(
         this TPromise&& promise,
         Value&& value,
         std::source_location sourceLocation = std::source_location::current()
     )
     {
-        return std::forward<TPromise>(promise).template call_promise<
-            TPromise,
-            events::return_value_argument_events<Value>::return_value_begin,
-            events::return_value_argument_events<Value>::return_value_result,
-            events::return_value_argument_events<Value>::return_value_exception
-        >(
+        std::forward<TPromise>(promise).call_promise_method(
+            detail::method_events_group
+            {
+                events::return_value_begin{},
+                events::return_value_result{},
+                events::return_value_exception{},
+            },
             sourceLocation,
+            events::event_data
+            {
+                .MethodArguments = events::make_arguments(value),
+            },
             [&]()
             {
-                return std::forward<TPromise>(promise).traced_promise_return_value_or_void::traced_promise_yield_value::return_value(
+                std::forward<TPromise>(promise).traced_promise_return_value_or_void<TraceSink, BasePromise>::traced_promise_yield_value::return_value(
                     std::forward<Value>(value));
-            },
-            value
+            }
         );
     }
 };
@@ -1094,27 +1466,32 @@ class traced_promise_return_value_or_void<
     public traced_promise_yield_value<TraceSink, BasePromise>
 {
     using traced_promise_return_value_or_void::traced_promise_yield_value::traced_promise_yield_value;
-    using traced_promise_return_value_or_void::traced_promise_yield_value::call_promise;
 
 public:
+    using traced_promise_return_value_or_void::traced_promise_yield_value::call_promise_method;
+
     template<
         typename TPromise
     >
-    decltype(auto) return_void(
+    void return_void(
         this TPromise&& promise,
         std::source_location sourceLocation = std::source_location::current()
     )
     {
-        return std::forward<TPromise>(promise).template call_promise<
-            TPromise,
-            events::return_void_begin,
-            events::return_void_result,
-            events::return_void_exception
-        >(
+        std::forward<TPromise>(promise).call_promise_method(
+            detail::method_events_group
+            {
+                events::return_void_begin{},
+                events::return_void_result{},
+                events::return_void_exception{},
+            },
             sourceLocation,
+            events::event_data
+            {
+            },
             [&]()
             {
-                return std::forward<TPromise>(promise).traced_promise_return_value_or_void<TraceSink, BasePromise>::traced_promise_yield_value::return_void();
+                std::forward<TPromise>(promise).traced_promise_return_value_or_void<TraceSink, BasePromise>::traced_promise_yield_value::return_void();
             }
         );
     }
@@ -1145,11 +1522,20 @@ struct suppress_trace
 //    co_await trace{ my_trace_event_information{} };
 PHANTOM_COROUTINES_MODULE_EXPORT
 struct trace
-    :
-    events::event
 {
 };
 
+namespace detail
+{
+
+template<typename T>
+struct is_suppress_trace : std::false_type {};
+
+template<typename Awaiter>
+struct is_suppress_trace<suppress_trace<Awaiter>> : std::true_type {};
+
+}
+
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
     is_trace_sink TraceSink,
@@ -1159,31 +1545,94 @@ class traced_promise
     :
     public detail::traced_promise_base<TraceSink, BasePromise>
 {
+public:
+    using traced_promise_base = detail::traced_promise_base<TraceSink, BasePromise>;
+    using traced_promise_base::call_promise_method;
+    using traced_promise_base::get_event_data;
+    using traced_promise_base::m_traceSink;
+
     template<
         typename Declaration
     >
     struct traced_promise_trace_sink_accessor;
 
-protected:
-    using base_promise = detail::traced_promise_base<TraceSink, BasePromise>;
-    using base_promise::m_traceSink;
-
 public:
+    template<
+        typename ... Args
+    >
     traced_promise(
-        auto&& ... args
-    ) :
-        base_promise{ *this, std::forward<decltype(args)>(args)... }
+        Args&& ... args
+    )
+        :
+        traced_promise_base{ std::forward<Args>(args)... }
     {
+        using capture_result = detail::trace_sink_capture_promise_creation_arguments_result_type<TraceSink>;
+
+        auto emit_create_promise = [&](auto promiseCreationArguments)
+        {
+            m_traceSink(
+                events::basic_event(
+                    std::source_location::current(),
+                    events::create_promise{},
+                    events::event_data
+                    {
+                        .Promise = &this->get_underlying_promise(),
+                        .TracedPromise = this,
+                        .PromiseCreationArguments = promiseCreationArguments,
+                    }));
+        };
+
+        if constexpr (capture_result::should_not_capture)
+        {
+            emit_create_promise(events::empty_arguments);
+        }
+        else if constexpr (capture_result::should_query_at_runtime)
+        {
+            std::optional<std::tuple<const std::decay_t<Args>&...>> capturedArgs;
+            if (m_traceSink(events::should_capture_promise_creation_arguments<events::create_promise>{}))
+            {
+                capturedArgs.emplace(std::tie(args...));
+            }
+            emit_create_promise(capturedArgs);
+        }
+        else
+        {
+            emit_create_promise(events::make_arguments(args...));
+        }
     }
 
     ~traced_promise()
     {
         m_traceSink(
-            events::destroy_promise<traced_promise>
-        {
-            std::source_location::current(),
-            this
-        });
+            basic_event(
+                std::source_location::current(),
+                events::destroy_promise{},
+                get_event_data()
+            ));
+    }
+
+    template<
+        typename TPromise
+    >
+    decltype(auto) get_return_object(
+        this TPromise& promise,
+        std::source_location sourceLocation = std::source_location::current()
+    )
+    {
+        return promise.call_promise_method(
+            detail::method_events_group
+            {
+                events::get_return_object_begin{},
+                events::get_return_object_result{},
+                events::get_return_object_exception{},
+            },
+            sourceLocation,
+            events::event_data{},
+            [&]() -> decltype(auto)
+            {
+                return promise.traced_promise_base::get_return_object();
+            }
+        );
     }
 
     template<
@@ -1197,12 +1646,13 @@ class traced_promise
         return traced_awaiter
         {
             sourceLocation,
-            [&]() { return promise.base_promise::initial_suspend(); },
+            [&]() { return promise.traced_promise_base::initial_suspend(); },
+            events::initial_suspend_awaiter_type{},
             detail::trace_sink_accessor
             {
                 promise.traced_promise::m_traceSink
             },
-            initial_suspend_awaiter{}
+            promise.get_event_data()
         };
     }
 
@@ -1217,12 +1667,13 @@ class traced_promise
         return traced_awaiter
         {
             sourceLocation,
-            [&]() { return promise.base_promise::final_suspend(); },
+            [&]() { return promise.traced_promise_base::final_suspend(); },
+            events::final_suspend_awaiter_type{},
             detail::trace_sink_accessor
             {
                 promise.traced_promise::m_traceSink
             },
-            final_suspend_awaiter{}
+            promise.get_event_data()
         };
     }
 
@@ -1234,36 +1685,62 @@ class traced_promise
         std::source_location sourceLocation = std::source_location::current()
     )
     {
-        promise.traced_promise::m_traceSink(
-            events::unhandled_exception<TPromise>
-        {
+        promise.call_promise_method(
+            detail::method_events_group
+            {
+                events::unhandled_exception_begin{},
+                events::unhandled_exception_result{},
+                events::unhandled_exception_exception{},
+            },
             sourceLocation,
-            &promise,
-            std::current_exception()
-        });
-
-        promise.base_promise::unhandled_exception();
+            events::event_data{},
+            [&]()
+            {
+                return promise.traced_promise_base::unhandled_exception();
+            }
+        );
     }
 
+    template<
+        typename Awaiter
+    >
     auto await_transform(
         this auto& promise,
-        auto&& awaiter,
+        Awaiter&& awaiter,
         std::source_location sourceLocation = std::source_location::current()
     )
+    requires (
+        !detail::is_suppress_trace<std::remove_cvref_t<Awaiter>>::value
+        && !std::derived_from<std::remove_cvref_t<Awaiter>, trace>
+    )
     {
         return traced_awaiter
         {
             sourceLocation,
-            [&]() 
-            { 
-                return promise.base_promise::await_transform(
-                    std::forward<decltype(awaiter)>(awaiter)); 
+            [&]() -> decltype(auto)
+            {
+                return promise.call_promise_method(
+                    detail::method_events_group
+                    {
+                        events::await_transform_begin{},
+                        events::await_transform_result{},
+                        events::await_transform_exception{},
+                    },
+                    sourceLocation,
+                    events::event_data{},
+                    [&]() -> decltype(auto)
+                    {
+                        return promise.traced_promise_base::await_transform(
+                            std::forward<decltype(awaiter)>(awaiter));
+                    }
+                );
             },
+            events::co_await_awaiter_type{},
             detail::trace_sink_accessor
             {
                 promise.traced_promise::m_traceSink
             },
-            co_await_awaiter{}
+            promise.get_event_data()
         };
     }
 
@@ -1274,7 +1751,7 @@ class traced_promise
         const suppress_trace<Awaiter>& noTraceAwaiter
     )
     {
-        return promise.base_promise::await_transform(
+        return promise.traced_promise_base::await_transform(
             noTraceAwaiter.value
         );
     }
@@ -1288,242 +1765,243 @@ class traced_promise
             traceEvent);
         return suspend_never{};
     }
+
+    template<
+        typename This
+    >
+    auto& get_underlying_promise(
+        this This& self)
+    {
+        if constexpr (std::is_const_v<This>)
+        {
+            return static_cast<const BasePromise&>(self);
+        }
+        else
+        {
+            return static_cast<BasePromise&>(self);
+        }
+    }
 };
 
 PHANTOM_COROUTINES_MODULE_EXPORT
 namespace filters
 {
 
+struct filter;
+
+template<
+    typename T
+>
+concept is_filter = std::derived_from<T, filter>;
+
+template<
+    is_filter Left,
+    is_filter Right
+>
+struct and_filter;
+
+template<
+    is_filter Left,
+    is_filter Right
+>
+struct or_filter;
+
+template<
+    is_filter Filter
+>
+struct not_filter;
+
 struct filter
 {
-    constexpr std::false_type operator()(const events::event&) const noexcept {
+    constexpr std::false_type operator()(const auto&) const noexcept {
         return {};
     }
 
     template<
-        std::derived_from<filter> Left,
-        std::derived_from<filter> Right
+        is_filter Left,
+        is_filter Right
     >
     friend constexpr auto operator&&(
         Left left,
         Right right
         ) noexcept
     {
-        return [=](const events::event& event) {
-            return left(event) && right(event);
-            };
+        return and_filter<Left, Right>{ left, right };
     }
 
     template<
-        std::derived_from<filter> Left,
-        std::derived_from<filter> Right
+        is_filter Left,
+        is_filter Right
     >
     friend constexpr auto operator||(
-        const Left& left, 
-        const Right& right
+        Left left, 
+        Right right
         ) noexcept
     {
-        return [=](const events::event& event) {
-            return left(event) || right(event);
-            };
+        return or_filter<Left, Right>{ left, right };
     }
 
     template<
-        std::derived_from<filter> Filter
+        is_filter Filter
     >
     friend constexpr auto operator!(
-        const Filter& filter
+        Filter filter
         ) noexcept
     {
-        return [=](const events::event& event) {
-            return !filter(event);
-            };
+        return not_filter<Filter>{ filter };
     }
 };
 
-struct any_event_fn : filter
+template<
+    is_filter Left,
+    is_filter Right
+>
+struct and_filter : filter
 {
-    constexpr std::true_type operator()(const events::event&) const noexcept {
-        return {};
-    }
-};
-constexpr any_event_fn any_event{};
-
-struct has_arguments_fn : filter {
-    using filter::operator();
-    template<typename... Arguments>
-    constexpr std::true_type operator()(const events::arguments<Arguments...>&) const noexcept {
-        return {};
-    }
-};
-constexpr has_arguments_fn has_arguments{};
-
-struct has_void_result_fn : filter {
-    using filter::operator();
-    constexpr std::true_type operator()(const events::result_event<void>&) const noexcept {
-        return {};
-    }
-};
-constexpr has_void_result_fn has_void_result{};
-
-struct has_result_fn : filter {
-    using filter::operator();
-    template<typename Result>
-    constexpr std::true_type operator()(const events::result_event<Result>&) const noexcept {
-        return {};
-    }
-};
-constexpr has_result_fn has_result{};
-
-struct has_exception_fn : filter {
-    template<
-        std::derived_from<events::event> Event
-    >
-    constexpr auto operator()(
-        const Event&
-        ) const noexcept {
-        return std::is_base_of<
-            events::exception_event,
-            Event
-        >{};
-    }
-};
-constexpr has_exception_fn has_exception{};
+    Left left;
+    Right right;
 
-struct has_promise_fn : filter {
-    using filter::operator();
-    template<typename TPromise>
-    constexpr std::true_type operator()(const events::promise_event<TPromise>&) const noexcept {
-        return {};
-    }
-};
-constexpr has_promise_fn has_promise{};
+    constexpr bool operator()(
+        const auto& event
+        ) const noexcept
+    {
+        using leftType = decltype(left(event));
+        using rightType = decltype(right(event));
 
-struct has_awaiter_fn : filter {
-    using filter::operator();
-    template<typename Awaiter>
-    constexpr std::true_type operator()(const events::awaiter_event<Awaiter>&) const noexcept {
-        return {};
+        if constexpr (
+            std::same_as<std::false_type, leftType>
+            ||
+            std::same_as<std::false_type, rightType>)
+        {
+            return std::false_type{};
+        }
+        else if constexpr (
+            std::same_as<std::true_type, leftType> &&
+            std::same_as<std::true_type, rightType>)
+        {
+            return std::true_type{};
+        }
+        else
+        {
+            return left(event) && right(event);
+        }
     }
 };
-constexpr has_awaiter_fn has_awaiter{};
 
-struct is_create_promise_fn : filter {
-    using filter::operator();
-    template<typename TPromise, typename... Arguments>
-    constexpr std::true_type operator()(const events::create_promise<TPromise, Arguments...>&) const noexcept {
-        return {};
-    }
-};
-constexpr is_create_promise_fn is_create_promise{};
+template<
+    is_filter Left,
+    is_filter Right
+>
+struct or_filter : filter
+{
+    Left left;
+    Right right;
 
-struct is_destroy_promise_fn : filter {
-    using filter::operator();
-    template<typename TPromise>
-    constexpr std::true_type operator()(const events::destroy_promise<TPromise>&) const noexcept {
-        return {};
-    }
-};
-constexpr is_destroy_promise_fn is_destroy_promise{};
+    constexpr bool operator()(
+        const auto& event
+        ) const noexcept
+    {
+        using leftType = decltype(left(event));
+        using rightType = decltype(right(event));
 
-struct is_await_ready_fn : filter {
-    using filter::operator();
-    template<typename Awaiter, typename... Arguments>
-    constexpr std::true_type operator()(const events::await_ready_event<Awaiter, Arguments...>&) const noexcept {
-        return {};
+        if constexpr (
+            std::same_as<std::true_type, leftType>
+            ||
+            std::same_as<std::true_type, rightType>)
+        {
+            return std::true_type{};
+        }
+        else if constexpr (
+            std::same_as<std::false_type, leftType> &&
+            std::same_as<std::false_type, rightType>)
+        {
+            return std::false_type{};
+        }
+        else
+        {
+            return left(event) && right(event);
+        }
     }
 };
-constexpr is_await_ready_fn is_await_ready{};
 
-struct is_await_suspend_fn : filter {
-    using filter::operator();
-    template<typename Awaiter, typename... Arguments>
-    constexpr std::true_type operator()(const events::await_suspend_event<Awaiter, Arguments...>&) const noexcept {
-        return {};
-    }
-};
-constexpr is_await_suspend_fn is_await_suspend{};
+template<
+    is_filter Filter
+>
+struct not_filter : filter
+{
+    Filter filter;
 
-struct is_await_resume_fn : filter {
-    using filter::operator();
-    template<typename Awaiter, typename... Arguments>
-    constexpr std::true_type operator()(const events::await_resume_event<Awaiter, Arguments...>&) const noexcept {
-        return {};
-    }
+    constexpr auto operator()(
+        const auto& event)
+    {
+        using type = decltype(filter(event));
+        if constexpr (std::same_as<std::true_type, type>)
+        {
+            return std::false_type{};
+        }
+        else if constexpr (std::same_as<std::false_type, type>)
+        {
+            return std::true_type{};
+        }
+        else
+        {
+            return !filter(event);
+        }
+    };
 };
-constexpr is_await_resume_fn is_await_resume{};
 
-struct is_return_void_fn : filter {
-    using filter::operator();
-    template<typename TPromise>
-    constexpr std::true_type operator()(const events::return_void_begin<TPromise>&) const noexcept {
+struct any_event_fn : filter
+{
+    constexpr std::true_type operator()(const auto&) const noexcept {
         return {};
     }
 };
-constexpr is_return_void_fn is_return_void{};
+constexpr any_event_fn any_event{};
 
-struct is_return_value_fn : filter {
+template<
+    typename ... EventType
+>
+struct event_type_fn : filter
+{
     using filter::operator();
-    template<typename TPromise, typename... Arguments>
-    constexpr std::true_type operator()(const events::return_value_begin<TPromise, Arguments...>&) const noexcept {
+    constexpr std::true_type operator()(
+        const auto& event
+        ) const noexcept
+        requires (
+            events::is_event_type<std::remove_cvref_t<decltype(event)>, EventType> || ...
+        )
+    {
         return {};
     }
 };
-constexpr is_return_value_fn is_return_value{};
 
-struct is_yield_value_fn : filter {
-    using filter::operator();
-    template<typename TPromise, typename... Arguments>
-    constexpr std::true_type operator()(const events::yield_value_event<TPromise, Arguments...>&) const noexcept {
-        return {};
-    }
-};
-constexpr is_yield_value_fn is_yield_value{};
+template<
+    typename ... EventType
+>
+event_type_fn<EventType...> event_type;
 
-struct is_unhandled_exception_fn : filter {
+template<
+    typename AwaiterType
+>
+struct awaiter_type_fn : filter
+{
     using filter::operator();
-    template<typename TPromise>
-    constexpr std::true_type operator()(const events::unhandled_exception<TPromise>&) const noexcept {
+    constexpr std::true_type operator()(
+        const auto& event
+        ) const noexcept
+        requires std::same_as<
+            const decltype(event.EventData.AwaiterType)&,
+            const AwaiterType&
+        >
+    {
         return {};
     }
 };
-constexpr is_unhandled_exception_fn is_unhandled_exception{};
-
-struct is_initial_suspend_fn : filter {
-    using filter::operator();
-    template<typename Awaiter>
-    constexpr auto operator()(const events::awaiter_event<Awaiter>& event) const noexcept {
-        return std::bool_constant<event.is_initial_suspend>{};
-    }
-};
-constexpr is_initial_suspend_fn is_initial_suspend{};
-
-struct is_final_suspend_fn : filter {
-    using filter::operator();
-    template<typename Awaiter>
-    constexpr auto operator()(const events::awaiter_event<Awaiter>& event) const noexcept {
-        return std::bool_constant<event.is_final_suspend>{};
-    }
-};
-constexpr is_final_suspend_fn is_final_suspend{};
-
-struct is_co_yield_fn : filter {
-    using filter::operator();
-    template<typename Awaiter>
-    constexpr auto operator()(const events::awaiter_event<Awaiter>& event) const noexcept {
-        return std::bool_constant<event.is_co_yield>{};
-    }
-};
-constexpr is_co_yield_fn is_co_yield{};
 
-struct is_co_await_fn : filter {
-    using filter::operator();
-    template<typename Awaiter>
-    constexpr auto operator()(const events::awaiter_event<Awaiter>& event) const noexcept {
-        return std::bool_constant< event.is_co_await>{};
-    }
-};
-constexpr is_co_await_fn is_co_await{};
+template<
+    typename AwaiterType
+>
+constexpr awaiter_type_fn<AwaiterType> awaiter_type;
 
 template<
     typename Event
@@ -1531,7 +2009,7 @@ template<
 struct check_constexpr_fn
 {
     template<
-        std::derived_from<filter> Filter
+        is_filter Filter
     > constexpr auto operator()(
         Filter filter
         ) const noexcept
@@ -1540,6 +2018,24 @@ struct check_constexpr_fn
     }
 };
 
+// Return a trace sink that traces return values for events that are selected.
+template<
+    typename TraceSink
+>
+constexpr auto trace_return_value(
+    TraceSink traceSink
+)
+{
+    return composed_function
+    {
+        traceSink,
+        []<typename Event>(const events::should_trace_return_value<Event>&)
+        {
+            return std::true_type{};
+        }
+    };
+}
+
 template<
     typename Event
 > constexpr check_constexpr_fn<Event> check_constexpr{};
@@ -1549,11 +2045,23 @@ constexpr auto constant_filtered_trace_sink(
     auto&& traceSink
 )
 {
-    return [traceSink = std::forward<decltype(traceSink)>(traceSink), filter](const auto& event)
+    return Phantom::Coroutines::composed_function
     {
-        if constexpr (filter(event))
+        // Queries bypass the filter and propagate to the inner sink.
+        [traceSink]<typename Event>(const events::should_trace_return_value<Event>& query) -> decltype(auto)
         {
-            traceSink(event);
+            return traceSink(query);
+        },
+        [traceSink]<typename Event>(const events::should_capture_promise_creation_arguments<Event>& query) -> decltype(auto)
+        {
+            return traceSink(query);
+        },
+        [traceSink, filter](const auto& event)
+        {
+            if constexpr (filter(event))
+            {
+                traceSink(event);
+            }
         }
     };
 }
@@ -1563,11 +2071,23 @@ constexpr auto runtime_filtered_trace_sink(
     auto&& traceSink
 )
 {
-    return [traceSink = std::forward<decltype(traceSink)>(traceSink), filter](const auto& event)
+    return Phantom::Coroutines::composed_function
     {
-        if (filter(event))
+        // Queries bypass the filter and propagate to the inner sink.
+        [traceSink]<typename Event>(const events::should_trace_return_value<Event>& query) -> decltype(auto)
         {
-            traceSink(event);
+            return traceSink(query);
+        },
+        [traceSink]<typename Event>(const events::should_capture_promise_creation_arguments<Event>& query) -> decltype(auto)
+        {
+            return traceSink(query);
+        },
+        [traceSink, filter](const auto& event)
+        {
+            if (filter(event))
+            {
+                traceSink(event);
+            }
         }
     };
 }
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/type_traits.h b/Phantom.Coroutines/include/Phantom.Coroutines/type_traits.h
index afdc7d1..5d9b621 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/type_traits.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/type_traits.h
@@ -17,6 +17,12 @@ PHANTOM_COROUTINES_ASSERT_IS_MODULE;
 
 namespace Phantom::Coroutines
 {
+PHANTOM_COROUTINES_MODULE_EXPORT
+template<
+    typename ... T
+>
+concept is_empty_type_list = (sizeof...(T) == 0);
+
 namespace detail
 {
 PHANTOM_COROUTINES_MODULE_EXPORT
@@ -314,15 +320,15 @@ struct conflict_detector
 PHANTOM_COROUTINES_MODULE_EXPORT
 struct has_await_suspend_conflicted_name
 {
-    using await_suspend = int;
+    static int await_suspend;
 };
 
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
     typename Awaiter
-> concept has_await_suspend = !requires
+> concept has_await_suspend = !requires (conflict_detector<Awaiter, has_await_suspend_conflicted_name> conflictDetector, int result)
 {
-    typename conflict_detector<Awaiter, has_await_suspend_conflicted_name>::await_suspend;
+    { result = conflictDetector.await_suspend };
 };
 
 PHANTOM_COROUTINES_MODULE_EXPORT
@@ -368,8 +374,7 @@ template<
 
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    typename TAwaiter,
-    typename CoroutineHandle = coroutine_handle<>
+    typename TAwaiter
 >
 concept is_awaiter =
     requires (
@@ -397,18 +402,34 @@ template<
     TAwaitable awaitable
     )
 {
-    { operator co_await(std::forward(awaitable)) } -> is_awaiter;
+    { operator co_await(awaitable) } -> is_awaiter;
 };
 
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
     typename TAwaitable
-> concept is_awaitable =
+> concept has_co_await =
 has_co_await_member<TAwaitable>
 ||
-has_co_await_non_member<TAwaitable>
+has_co_await_non_member<TAwaitable>;
+
+// A simple awaiter is an awaiter that has no co_await member.
+PHANTOM_COROUTINES_MODULE_EXPORT
+template<
+    typename TAwaiter
+>
+concept is_simple_awaiter =
+is_awaiter<TAwaiter>
+&&
+!has_co_await<TAwaiter>;
+
+PHANTOM_COROUTINES_MODULE_EXPORT
+template<
+    typename TAwaitable
+> concept is_awaitable =
+has_co_await<TAwaitable>
 ||
-is_awaiter<TAwaitable>;
+is_simple_awaiter<TAwaitable>;
 
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
@@ -434,7 +455,7 @@ decltype(auto) get_awaiter(
 
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
-    is_awaiter Awaiter
+    is_simple_awaiter Awaiter
 >
 decltype(auto) get_awaiter(
     Awaiter&& awaitable
@@ -485,15 +506,15 @@ template<
 
 struct has_await_transform_conflicted_name
 {
-    using await_transform = int;
+    static int await_transform;
 };
 
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
     typename Promise
-> concept has_await_transform = !requires
+> concept has_await_transform = !requires (conflict_detector<Promise, has_await_transform_conflicted_name> conflictDetector, int result)
 {
-    typename conflict_detector<Promise, has_await_transform_conflicted_name>::await_transform;
+    { result = conflictDetector.await_transform };
 };
 
 PHANTOM_COROUTINES_MODULE_EXPORT
@@ -529,15 +550,15 @@ template<
 
 struct has_yield_value_conflicted_name
 {
-    using yield_value = int;
+    static int yield_value;
 };
 
 PHANTOM_COROUTINES_MODULE_EXPORT
 template<
     typename Promise
-> concept has_yield_value = !requires
+> concept has_yield_value = !requires (conflict_detector<Promise, has_yield_value_conflicted_name> conflictDetector, int result)
 {
-    typename conflict_detector<Promise, has_yield_value_conflicted_name>::yield_value;
+    { result = conflictDetector.yield_value };
 };
 
 PHANTOM_COROUTINES_MODULE_EXPORT
@@ -715,6 +736,8 @@ using detail::is_awaitable;
 PHANTOM_COROUTINES_MODULE_EXPORT
 using detail::is_awaiter;
 PHANTOM_COROUTINES_MODULE_EXPORT
+using detail::is_simple_awaiter;
+PHANTOM_COROUTINES_MODULE_EXPORT
 using detail::has_co_await_member;
 PHANTOM_COROUTINES_MODULE_EXPORT
 using detail::has_co_await_non_member;
diff --git a/Phantom.Coroutines/include/Phantom.Coroutines/value_awaiter.h b/Phantom.Coroutines/include/Phantom.Coroutines/value_awaiter.h
index 6e57fa3..788c310 100644
--- a/Phantom.Coroutines/include/Phantom.Coroutines/value_awaiter.h
+++ b/Phantom.Coroutines/include/Phantom.Coroutines/value_awaiter.h
@@ -1,6 +1,7 @@
 #ifndef PHANTOM_COROUTINES_INCLUDE_VALUE_AWAITER_H
 #define PHANTOM_COROUTINES_INCLUDE_VALUE_AWAITER_H
 #ifndef PHANTOM_COROUTINES_COMPILING_MODULES
+#include <utility>
 #endif
 
 static_assert(PHANTOM_COROUTINES_IS_CONFIGURED);
@@ -26,9 +27,42 @@ struct value_awaiter
     {
     }
 
-    Value await_resume() const noexcept
+    template<
+        typename Self
+    >
+    decltype(auto) await_resume(
+        this Self&& self
+    )
     {
-        return m_value;
+        if constexpr (std::is_rvalue_reference_v<Value>)
+        {
+            return std::move(self.m_value);
+        }
+        else if constexpr (std::is_reference_v<Value>)
+        {
+            return self.m_value;
+        } 
+        else
+        {
+            return std::as_const(self.m_value);
+        }
+    }
+
+    // This allows value_awaiter to be used as an r-value and get r-value semantics from the co_await.
+    // If we're of value_type, we remap to Value&& to move the value out.
+    decltype(auto) operator co_await(
+        this auto&& self)
+    {
+        if constexpr (
+            std::is_rvalue_reference_v<decltype(self)>
+            && !std::is_reference_v<Value>)
+        {
+            return value_awaiter<Value&&>{ std::move(self.m_value) };
+        }
+        else
+        {
+            return self;
+        }
     }
 };