diff --git a/libs/internal/include/launchdarkly/async/promise.hpp b/libs/internal/include/launchdarkly/async/promise.hpp
new file mode 100644
index 000000000..ffdc66b87
--- /dev/null
+++ b/libs/internal/include/launchdarkly/async/promise.hpp
@@ -0,0 +1,531 @@
+#pragma once
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <vector>
+
+namespace launchdarkly::async {
+
+// Continuation is a move-only type-erased callable, effectively a polyfill
+// for C++23's std::move_only_function. It exists because C++17's std::function
+// requires all captured variables to be copy-constructible, which prevents
+// storing lambdas that capture move-only types.
+//
+// Continuation is used to represent units of work passed to executors. An
+// executor is a callable with signature void(Continuation<void()>) that
+// schedules the work to run somewhere — for example, on an ASIO io_context:
+//
+//   auto executor = [&ioc](Continuation<void()> work) {
+//       boost::asio::post(ioc, std::move(work));
+//   };
+//
+// The primary template is declared but not defined; only the partial
+// specialization below (which splits Sig into R and Args...) is usable.
+// This lets callers write Continuation<void()> instead of Continuation<void>.
+template <typename Sig>
+class Continuation;
+
+template <typename R, typename... Args>
+class Continuation<R(Args...)> {
+    // Base and Impl form a classic type-erasure pair. Base is a non-template
+    // abstract interface stored via unique_ptr, giving a stable type regardless
+    // of F. Impl<F> is the concrete template subclass that holds and calls F.
+    struct Base {
+        virtual R call(Args...) = 0;
+        virtual ~Base() = default;
+    };
+
+    template <typename F>
+    struct Impl : Base {
+        F f;
+        Impl(F f) : f(std::move(f)) {}
+        R call(Args... args) override { return f(std::forward<Args>(args)...); }
+    };
+
+    std::unique_ptr<Base> impl_;
+
+   public:
+    // Constructs a Continuation from any callable F. F may be a lambda,
+    // function pointer, or other callable; it need not be copy-constructible.
+    // F&& is a forwarding reference: accepts any callable by move or copy,
+    // then moves it into Impl<F> so Continuation itself owns the callable.
+    template <typename F>
+    Continuation(F&& f)
+        : impl_(std::make_unique<Impl<std::decay_t<F>>>(std::forward<F>(f))) {}
+    Continuation(Continuation&&) = default;
+    Continuation& operator=(Continuation&&) = default;
+
+    // Invokes the stored callable with the given arguments.
+    // Returns whatever the callable returns.
+    R operator()(Args... args) const {
+        return impl_->call(std::forward<Args>(args)...);
+    }
+};
+
+template <typename T>
+class Promise;
+
+template <typename T>
+class Future;
+
+// Type trait to detect whether a type is a Future<T>. The primary template
+// defaults to false; the partial specialization matches Future<T> specifically.
+template <typename T>
+struct is_future : std::false_type {};
+
+template <typename T>
+struct is_future<Future<T>> : std::true_type {};
+
+// Type trait to extract T from Future<T>. Only the partial specialization is
+// defined, so using future_value on a non-Future type is a compile error.
+template <typename T>
+struct future_value;
+
+template <typename T>
+struct future_value<Future<T>> {
+    using type = T;
+};
+
+// PromiseInternal holds the shared state between a Promise and its associated
+// Futures: the result value, the mutex protecting it, and the list of
+// continuations waiting to run when the result is set.
+//
+// This is an internal class and not intended to be used directly. Promise and
+// Future each hold a shared_ptr<PromiseInternal>, which lets multiple Future
+// copies all refer to the same underlying state, and lets Promise and Future
+// have independent lifetimes while the shared state remains alive as long as
+// either end holds it.
+template <typename T>
+class PromiseInternal {
+   public:
+    PromiseInternal() = default;
+    ~PromiseInternal() = default;
+    PromiseInternal(PromiseInternal const&) = delete;
+    PromiseInternal& operator=(PromiseInternal const&) = delete;
+    PromiseInternal(PromiseInternal&&) = delete;
+    PromiseInternal& operator=(PromiseInternal&&) = delete;
+
+    // Sets the result and schedules all registered continuations via their
+    // executors. Returns true if the result was set, or false if it was already
+    // set by a previous call to Resolve.
+    bool Resolve(T result) {
+        std::vector<Continuation<void(T const&)>> to_call;
+        {
+            std::lock_guard lock(mutex_);
+            if (result_.has_value()) {
+                return false;
+            }
+
+            // Move result into storage if possible; otherwise copy.
+            if constexpr (std::is_move_constructible_v<T>) {
+                result_ = std::move(result);
+            } else {
+                result_ = result;
+            }
+            to_call = std::move(continuations_);
+        }
+
+        // Call continuations outside the lock so that continuations which
+        // re-enter this future (e.g. via GetResult or Then) don't deadlock.
+        for (auto& continuation : to_call) {
+            // It's safe to access result_ outside the lock here, because it
+            // can't be changed again.
+            continuation(*result_);
+        }
+
+        return true;
+    }
+
+    // Returns true if Resolve has been called.
+    bool IsFinished() const {
+        std::lock_guard lock(mutex_);
+        return result_.has_value();
+    }
+
+    // Returns a copy of the result, if resolved.
+    std::optional<T> GetResult() const {
+        std::lock_guard lock(mutex_);
+        return result_;
+    }
+
+    // Then where the continuation returns R directly, yielding Future<R>.
+    template <typename F,
+              // Deduce R from what F returns when called with T const&.
+              typename R = std::invoke_result_t<F, T const&>,
+              // Disable when R is a Future so the flattening overload wins
+              // instead.
+              typename = std::enable_if_t<!is_future<R>::value>>
+    Future<R> Then(F&& continuation,
+                   std::function<void(Continuation<void()>)> executor) {
+        Promise<R> newPromise;
+        Future<R> newFuture = newPromise.GetFuture();
+
+        std::optional<T> already_resolved;
+        {
+            std::lock_guard lock(mutex_);
+
+            if (result_.has_value()) {
+                already_resolved = result_;
+            } else {
+                continuations_.push_back(
+                    [newPromise = std::move(newPromise),
+                     continuation = std::move(continuation),
+                     executor](T const& result) mutable {
+                        executor(Continuation<void()>(
+                            [newPromise = std::move(newPromise),
+                             continuation = std::move(continuation),
+                             result]() mutable {
+                                newPromise.Resolve(continuation(result));
+                            }));
+                    });
+                return newFuture;
+            }
+        }
+
+        // Already resolved: call executor outside the lock so that
+        // continuations which re-enter this future don't deadlock.
+        executor(Continuation<void()>(
+            [newPromise = std::move(newPromise),
+             continuation = std::move(continuation),
+             result = std::move(already_resolved)]() mutable {
+                newPromise.Resolve(continuation(*result));
+            }));
+        return newFuture;
+    }
+
+    // Then where the continuation returns Future<T2> (i.e. R = Future<T2>),
+    // yielding a flattened Future<T2> that resolves when the inner future does.
+    template <typename F,
+              // Deduce R from what F returns when called with T const&.
+              typename R = std::invoke_result_t<F, T const&>,
+              // Unwrap Future<T2> -> T2 so the return type is Future<T2>, not
+              // Future<Future<T2>>.
+              typename T2 = typename future_value<R>::type,
+              // Only enabled when R is a Future; otherwise the direct overload
+              // wins.
+              typename = std::enable_if_t<is_future<R>::value>>
+    Future<T2> Then(F&& continuation,
+                    std::function<void(Continuation<void()>)> executor) {
+        Promise<T2> outerPromise;
+        Future<T2> outerFuture = outerPromise.GetFuture();
+
+        auto do_work = [outerPromise = std::move(outerPromise),
+                        continuation = std::move(continuation),
+                        executor](T const& val) mutable {
+            Future<T2> innerFuture = continuation(val);
+            innerFuture.Then(
+                [outerPromise = std::move(outerPromise)](
+                    T2 const& inner_val) mutable -> std::monostate {
+                    outerPromise.Resolve(inner_val);
+                    return {};
+                },
+                executor);
+        };
+
+        std::optional<T> already_resolved;
+        {
+            std::lock_guard lock(mutex_);
+            if (result_.has_value()) {
+                already_resolved = result_;
+            } else {
+                continuations_.push_back([do_work = std::move(do_work),
+                                          executor](T const& result) mutable {
+                    executor(Continuation<void()>(
+                        [do_work = std::move(do_work), result]() mutable {
+                            do_work(result);
+                        }));
+                });
+                return outerFuture;
+            }
+        }
+
+        // Already resolved: call executor outside the lock so that
+        // continuations which re-enter this future don't deadlock.
+        executor(Continuation<void()>(
+            [do_work = std::move(do_work),
+             result = std::move(already_resolved)]() mutable {
+                do_work(*result);
+            }));
+        return outerFuture;
+    }
+
+   private:
+    mutable std::mutex mutex_;
+    std::optional<T> result_{};
+    std::vector<Continuation<void(T const&)>> continuations_;
+};
+
+// Promise is the write end of a one-shot async value, similar to std::promise.
+// Create a Promise<T>, hand its Future to a consumer via GetFuture(), then
+// call Resolve() exactly once to deliver the value.
+//
+// Promise is move-only: it cannot be copied, but it can be moved. This
+// prevents accidentally resolving the same promise from two places.
+//
+// Using tl::expected<V, E> as T is the recommended way to represent
+// operations that may fail:
+//
+//   Promise<tl::expected<int, std::string>> promise;
+//   Future<tl::expected<int, std::string>> future = promise.GetFuture();
+//   // ... hand future to a consumer, then later:
+//   promise.Resolve(42);                            // success
+//   promise.Resolve(tl::unexpected("timed out"));  // failure
+template <typename T>
+class Promise {
+   public:
+    Promise() : internal_(std::make_shared<PromiseInternal<T>>()) {}
+    ~Promise() = default;
+    Promise(Promise const&) = delete;
+    Promise& operator=(Promise const&) = delete;
+    Promise(Promise&&) = default;
+    Promise& operator=(Promise&&) = default;
+
+    // Sets the result to the given value and schedules any continuations that
+    // were registered via Future::Then. Returns true if the result was set, or
+    // false if Resolve was already called.
+    bool Resolve(T result) {
+        if constexpr (std::is_move_constructible_v<T>) {
+            return internal_->Resolve(std::move(result));
+        } else {
+            return internal_->Resolve(result);
+        }
+    }
+
+    // Returns a Future that will resolve when this Promise is resolved.
+    // May be called multiple times; each call returns a Future referring to
+    // the same underlying state.
+    Future<T> GetFuture() { return Future(internal_); }
+
+   private:
+    std::shared_ptr<PromiseInternal<T>> internal_;
+};
+
+// Future is the read end of a one-shot async value, similar to std::future,
+// but with support for chaining via Then.
+//
+// A Future is obtained from Promise::GetFuture(). Multiple copies of a Future
+// may exist and all refer to the same underlying result. When the associated
+// Promise is resolved, all continuations registered via Then are scheduled.
+//
+// Unlike std::future, Future does not support blocking on the result directly.
+// Instead, use Then to attach work that runs once the value is available.
+//
+// Example using tl::expected<V, E> to represent a fallible async operation:
+//
+//   boost::asio::io_context ioc;
+//   auto executor = [&ioc](Continuation<void()> work) {
+//       boost::asio::post(ioc, std::move(work));
+//   };
+//
+//   Future<tl::expected<float, std::string>> result = future.Then(
+//       [](tl::expected<int, std::string> const& val)
+//               -> tl::expected<float, std::string> {
+//           if (!val) return tl::unexpected(val.error());
+//           return *val * 1.5f;
+//       },
+//       executor);
+template <typename T>
+class Future {
+   public:
+    Future(std::shared_ptr<PromiseInternal<T>> internal)
+        : internal_(std::move(internal)) {}
+    ~Future() = default;
+    Future(Future const&) = default;
+    Future& operator=(Future const&) = default;
+    Future(Future&&) = default;
+    Future& operator=(Future&&) = default;
+
+    // Returns true if the associated Promise has been resolved.
+    bool IsFinished() const { return internal_->IsFinished(); }
+
+    // Returns a copy of the result, if resolved.
+    std::optional<T> GetResult() const { return internal_->GetResult(); }
+
+    // Blocks the calling thread until the future resolves or the timeout
+    // expires. Returns a copy of the result, if resolved within the timeout.
+    template <typename Rep, typename Period>
+    std::optional<T> WaitForResult(std::chrono::duration<Rep, Period> timeout) {
+        struct State {
+            std::mutex mutex;
+            std::condition_variable cv;
+            bool ready = false;
+        };
+        auto state = std::make_shared<State>();
+
+        // The continuation ignores T entirely. The executor signals the cv
+        // when called, since being called means the original future has
+        // resolved.
+        Then([](T const&) { return std::monostate{}; },
+             [state](Continuation<void()> work) {
+                 {
+                     std::lock_guard<std::mutex> lock(state->mutex);
+                     state->ready = true;
+                 }
+                 state->cv.notify_one();
+                 work();
+             });
+
+        std::unique_lock<std::mutex> lock(state->mutex);
+        state->cv.wait_for(lock, timeout, [&state] { return state->ready; });
+
+        return GetResult();
+    }
+
+    // Registers a continuation to run when this Future resolves, returning a
+    // new Future<R> that resolves to the continuation's return value.
+    //
+    // Parameters:
+    //   continuation - Called with the resolved T const& when this Future
+    //                  resolves. Must return a value of type R (not a Future).
+    //   executor     - Called with the work to schedule when this Future
+    //                  resolves. Controls where and when the continuation runs.
+    //
+    // Returns a Future<R> that resolves to whatever the continuation returns.
+    template <typename F,
+              // Deduce R from what F returns when called with T const&.
+              typename R = std::invoke_result_t<F, T const&>,
+              // Disable when R is a Future so the flattening overload wins
+              // instead.
+              typename = std::enable_if_t<!is_future<R>::value>>
+    Future<R> Then(F&& continuation,
+                   std::function<void(Continuation<void()>)> executor) {
+        return internal_->Then(std::forward<F>(continuation),
+                               std::move(executor));
+    }
+
+    // Registers a continuation to run when this Future resolves, where the
+    // continuation itself returns a Future<T2>. Returns a flattened Future<T2>
+    // that resolves when the inner future does, avoiding Future<Future<T2>>.
+    // Use this overload to chain async operations that themselves return a
+    // Future, avoiding a nested Future<Future<T2>>:
+    //
+    //   Future<tl::expected<Data, Err>> result = future.Then(
+    //       [](tl::expected<Key, Err> const& key) {
+    //           return fetch(key);  // fetch returns Future<expected<Data,
+    //           Err>>
+    //       },
+    //       executor);
+    //
+    // Parameters:
+    //   continuation - Called with the resolved T const& when this Future
+    //                  resolves. Must return a Future<T2>.
+    //   executor     - Called with the work to schedule when this Future
+    //                  resolves, and again when the inner Future resolves.
+    //
+    // Returns a Future<T2> that resolves when the inner Future<T2> resolves.
+    template <typename F,
+              // Deduce R from what F returns when called with T const&.
+              typename R = std::invoke_result_t<F, T const&>,
+              // Unwrap Future<T2> -> T2 so the return type is Future<T2>, not
+              // Future<Future<T2>>.
+              typename T2 = typename future_value<R>::type,
+              // Only enabled when R is a Future; otherwise the direct overload
+              // wins.
+              typename = std::enable_if_t<is_future<R>::value>>
+    Future<T2> Then(F&& continuation,
+                    std::function<void(Continuation<void()>)> executor) {
+        return internal_->Then(std::forward<F>(continuation),
+                               std::move(executor));
+    }
+
+   private:
+    std::shared_ptr<PromiseInternal<T>> internal_;
+};
+
+// WhenAll takes a variadic list of Futures (each with potentially different
+// value types) and returns a Future<std::monostate> that resolves once all
+// of the input futures have resolved. The result carries no value; callers
+// who need the individual results can read them from their original futures
+// after WhenAll resolves.
+//
+// If called with no arguments, the returned future is already resolved.
+//
+// Example:
+//
+//   Future<int> f1 = ...;
+//   Future<std::string> f2 = ...;
+//   WhenAll(f1, f2).Then(
+//       [&](std::monostate const&) {
+//           // f1 and f2 are both finished here.
+//           use(f1.GetResult().value(), f2.GetResult().value());
+//           return std::monostate{};
+//       },
+//       executor);
+template <typename... Ts>
+Future<std::monostate> WhenAll(Future<Ts>... futures) {
+    Promise<std::monostate> promise;
+    Future<std::monostate> result = promise.GetFuture();
+
+    if constexpr (sizeof...(Ts) == 0) {
+        promise.Resolve(std::monostate{});
+        return result;
+    }
+
+    auto shared_promise =
+        std::make_shared<Promise<std::monostate>>(std::move(promise));
+    auto count = std::make_shared<std::atomic<std::size_t>>(sizeof...(Ts));
+
+    auto attach = [&](auto future) {
+        future.Then(
+            [shared_promise, count](auto const&) -> std::monostate {
+                if (count->fetch_sub(1) == 1) {
+                    shared_promise->Resolve(std::monostate{});
+                }
+                return std::monostate{};
+            },
+            [](Continuation<void()> f) { f(); });
+    };
+
+    (attach(futures), ...);
+
+    return result;
+}
+
+// WhenAny takes a variadic list of Futures (each with potentially different
+// value types) and returns a Future<std::size_t> that resolves with the
+// 0-based index of whichever input future resolves first. The caller can use
+// the index to identify the winning future and read its result directly.
+//
+// If called with no arguments, the returned future never resolves.
+//
+// Example:
+//
+//   Future<int> f0 = ...;
+//   Future<std::string> f1 = ...;
+//   WhenAny(f0, f1).Then(
+//       [&](std::size_t const& index) {
+//           if (index == 0) use(f0.GetResult().value());
+//           else            use(f1.GetResult().value());
+//           return std::monostate{};
+//       },
+//       executor);
+template <typename... Ts>
+Future<std::size_t> WhenAny(Future<Ts>... futures) {
+    Promise<std::size_t> promise;
+    Future<std::size_t> result = promise.GetFuture();
+
+    auto shared_promise =
+        std::make_shared<Promise<std::size_t>>(std::move(promise));
+
+    std::size_t index = 0;
+    auto attach = [&](auto future) {
+        std::size_t i = index++;
+        future.Then(
+            [shared_promise, i](auto const&) -> std::monostate {
+                shared_promise->Resolve(i);
+                return std::monostate{};
+            },
+            [](Continuation<void()> f) { f(); });
+    };
+
+    (attach(futures), ...);
+
+    return result;
+}
+
+}  // namespace launchdarkly::async
diff --git a/libs/internal/src/CMakeLists.txt b/libs/internal/src/CMakeLists.txt
index 44600638b..2fffa42b3 100644
--- a/libs/internal/src/CMakeLists.txt
+++ b/libs/internal/src/CMakeLists.txt
@@ -1,6 +1,7 @@
 
 file(GLOB HEADER_LIST CONFIGURE_DEPENDS
         "${LaunchDarklyInternalSdk_SOURCE_DIR}/include/launchdarkly/*.hpp"
+        "${LaunchDarklyInternalSdk_SOURCE_DIR}/include/launchdarkly/async/*.hpp"
         "${LaunchDarklyInternalSdk_SOURCE_DIR}/include/launchdarkly/events/*.hpp"
         "${LaunchDarklyInternalSdk_SOURCE_DIR}/include/launchdarkly/network/*.hpp"
         "${LaunchDarklyInternalSdk_SOURCE_DIR}/include/launchdarkly/serialization/*.hpp"
diff --git a/libs/internal/tests/promise_test.cpp b/libs/internal/tests/promise_test.cpp
new file mode 100644
index 000000000..d338bcabd
--- /dev/null
+++ b/libs/internal/tests/promise_test.cpp
@@ -0,0 +1,534 @@
+#include <gtest/gtest.h>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/post.hpp>
+#include <tl/expected.hpp>
+
+#include <thread>
+
+#include "launchdarkly/async/promise.hpp"
+
+using namespace launchdarkly::async;
+
+TEST(Promise, SimplePromise) {
+    Promise<int> promise;
+    Future<int> future = promise.GetFuture();
+
+    Future<float> future2 = future.Then(
+        [](int const& inner) { return static_cast<float>(inner * 2.0); },
+        [](Continuation<void()> f) { f(); });
+
+    promise.Resolve(43);
+
+    auto result = future2.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(result.has_value());
+    EXPECT_FLOAT_EQ(*result, 86.0f);
+}
+
+TEST(Promise, ASIOTest) {
+    boost::asio::io_context ioc;
+    auto work = boost::asio::make_work_guard(ioc);
+    std::thread ioc_thread([&]() { ioc.run(); });
+
+    Promise<int> promise;
+    Future<int> future = promise.GetFuture();
+
+    Future<float> future2 = future.Then(
+        [](int const& inner) { return static_cast<float>(inner * 2.0); },
+        [&ioc](Continuation<void()> f) {
+            boost::asio::post(ioc, [f = std::move(f)]() mutable { f(); });
+        });
+
+    promise.Resolve(42);
+
+    auto result = future2.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(result.has_value());
+    EXPECT_FLOAT_EQ(*result, 84.0f);
+
+    work.reset();
+    ioc_thread.join();
+}
+
+TEST(Promise, GetResultNotFinished) {
+    Promise<int> promise;
+    Future<int> future = promise.GetFuture();
+
+    auto result = future.GetResult();
+    EXPECT_FALSE(result.has_value());
+}
+
+TEST(Promise, GetResultFinished) {
+    Promise<int> promise;
+    Future<int> future = promise.GetFuture();
+
+    promise.Resolve(42);
+
+    auto result = future.GetResult();
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(*result, 42);
+}
+
+// Verifies that a type which is move-assignable but not move-constructible
+// can still be used as T. The optional assignment for an empty optional needs
+// move-constructibility, not move-assignability, so the if constexpr branch
+// must check the correct trait.
+TEST(Promise, MoveAssignableNotMoveConstructible) {
+    struct MoveAssignableOnly {
+        int value;
+        explicit MoveAssignableOnly(int v) : value(v) {}
+        MoveAssignableOnly(MoveAssignableOnly const&) = default;
+        MoveAssignableOnly& operator=(MoveAssignableOnly const&) = default;
+        MoveAssignableOnly(MoveAssignableOnly&&) = delete;
+        MoveAssignableOnly& operator=(MoveAssignableOnly&&) = default;
+    };
+
+    Promise<MoveAssignableOnly> promise;
+    Future<MoveAssignableOnly> future = promise.GetFuture();
+
+    promise.Resolve(MoveAssignableOnly{42});
+
+    auto result = future.GetResult();
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(result->value, 42);
+}
+
+TEST(Promise, CopyOnlyResult) {
+    struct CopyOnly {
+        int value;
+        explicit CopyOnly(int v) : value(v) {}
+        CopyOnly(CopyOnly const&) = default;
+        CopyOnly& operator=(CopyOnly const&) = default;
+        CopyOnly(CopyOnly&&) = delete;
+        CopyOnly& operator=(CopyOnly&&) = delete;
+    };
+
+    Promise<CopyOnly> promise;
+    Future<CopyOnly> future = promise.GetFuture();
+
+    promise.Resolve(CopyOnly{42});
+
+    auto result = future.GetResult();
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(result->value, 42);
+}
+
+TEST(Promise, ContinueByReturningFuture) {
+    Promise<int> promise1;
+    Promise<int> promise2;
+    Future<int> future2 = promise2.GetFuture();
+
+    Future<int> chained =
+        promise1.GetFuture().Then([future2](int const&) { return future2; },
+                                  [](Continuation<void()> f) { f(); });
+
+    promise1.Resolve(0);
+    promise2.Resolve(42);
+
+    auto result = chained.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(*result, 42);
+}
+
+TEST(Promise, ResolvedBeforeContinuation) {
+    Promise<int> promise;
+    Future<int> future = promise.GetFuture();
+
+    promise.Resolve(21);
+
+    Future<int> future2 = future.Then([](int const& val) { return val * 2; },
+                                      [](Continuation<void()> f) { f(); });
+
+    auto result = future2.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(*result, 42);
+}
+
+TEST(Promise, ResolvedAfterContinuation) {
+    Promise<int> promise;
+    Future<int> future = promise.GetFuture();
+
+    Future<int> future2 = future.Then([](int const& val) { return val * 2; },
+                                      [](Continuation<void()> f) { f(); });
+
+    promise.Resolve(21);
+
+    auto result = future2.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(*result, 42);
+}
+
+// Verifies that a continuation which captures a copy-only type (deleted move
+// constructor) can still be registered and invoked correctly.
+TEST(Promise, CopyOnlyCallback) {
+    struct CopyOnlyInt {
+        int value;
+        explicit CopyOnlyInt(int v) : value(v) {}
+        CopyOnlyInt(CopyOnlyInt const&) = default;
+        CopyOnlyInt& operator=(CopyOnlyInt const&) = default;
+        CopyOnlyInt(CopyOnlyInt&&) = delete;
+        CopyOnlyInt& operator=(CopyOnlyInt&&) = delete;
+    };
+
+    Promise<int> promise;
+    Future<int> future = promise.GetFuture();
+
+    CopyOnlyInt multiplier{2};
+    Future<int> future2 = future.Then(
+        [multiplier](int const& val) { return val * multiplier.value; },
+        [](Continuation<void()> f) { f(); });
+
+    promise.Resolve(21);
+
+    auto result = future2.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(*result, 42);
+}
+
+// Verifies that a continuation which captures a move-only type (deleted copy
+// constructor) can still be registered and invoked correctly.
+TEST(Promise, MoveOnlyCallback) {
+    Promise<int> promise;
+    Future<int> future = promise.GetFuture();
+
+    auto captured = std::make_unique<int>(2);
+    Future<int> future2 =
+        future.Then([captured = std::move(captured)](
+                        int const& val) { return val * *captured; },
+                    [](Continuation<void()> f) { f(); });
+
+    promise.Resolve(21);
+
+    auto result = future2.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(result.has_value());
+    EXPECT_EQ(*result, 42);
+}
+
+// Verifies that when a continuation is both moveable and copyable, Then stores
+// it by moving rather than copying.
+TEST(Promise, CallbackMovedWhenPossible) {
+    int copies = 0;
+    struct Counted {
+        int value;
+        int* copy_count;
+        explicit Counted(int v, int* c) : value(v), copy_count(c) {}
+        Counted(Counted const& o) : value(o.value), copy_count(o.copy_count) {
+            ++(*copy_count);
+        }
+        Counted& operator=(Counted const& o) {
+            value = o.value;
+            copy_count = o.copy_count;
+            ++(*copy_count);
+            return *this;
+        }
+        Counted(Counted&&) noexcept = default;
+        Counted& operator=(Counted&&) noexcept = default;
+    };
+
+    Promise<int> promise;
+    Future<int> future = promise.GetFuture();
+
+    Counted multiplier{2, &copies};
+    copies = 0;  // reset after construction
+
+    future.Then([multiplier = std::move(multiplier)](
+                    int const& val) mutable { return val * multiplier.value; },
+                [](Continuation<void()> f) { f(); });
+
+    EXPECT_EQ(copies, 0);
+
+    promise.Resolve(21);
+}
+
+// Demonstrates using std::monostate as a void-like result type for
+// fire-and-forget async operations where the completion matters but no value is
+// produced.
+TEST(Promise, MonostateVoidLike) {
+    Promise<std::monostate> promise;
+    Future<std::monostate> future = promise.GetFuture();
+
+    bool ran = false;
+    future.Then(
+        [&ran](std::monostate const&) {
+            ran = true;
+            return std::monostate{};
+        },
+        [](Continuation<void()> f) { f(); });
+
+    promise.Resolve(std::monostate{});
+
+    auto result = future.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(result.has_value());
+    EXPECT_TRUE(ran);
+}
+
+// Demonstrates using tl::expected as T to represent a fallible async operation
+// that resolves successfully.
+TEST(Promise, ExpectedSuccess) {
+    Promise<tl::expected<int, std::string>> promise;
+    Future<tl::expected<int, std::string>> future = promise.GetFuture();
+
+    promise.Resolve(42);
+
+    auto result = future.GetResult();
+    ASSERT_TRUE(result.has_value());
+    ASSERT_TRUE(result->has_value());
+    EXPECT_EQ(**result, 42);
+}
+
+// Demonstrates using tl::expected as T to represent a fallible async operation
+// that resolves with an error.
+TEST(Promise, ExpectedFailure) {
+    Promise<tl::expected<int, std::string>> promise;
+    Future<tl::expected<int, std::string>> future = promise.GetFuture();
+
+    promise.Resolve(tl::unexpected(std::string("timed out")));
+
+    auto result = future.GetResult();
+    ASSERT_TRUE(result.has_value());
+    ASSERT_FALSE(result->has_value());
+    EXPECT_EQ(result->error(), "timed out");
+}
+
+// Verifies that Promise supports move assignment, consistent with it being
+// move-only.
+TEST(Promise, MoveAssignment) {
+    Promise<int> p1;
+    Future<int> future = p1.GetFuture();
+
+    Promise<int> p2;
+    p2 = std::move(p1);
+    p2.Resolve(42);
+
+    EXPECT_EQ(*future.GetResult(), 42);
+}
+
+// Verifies that Future supports move assignment.
+TEST(Promise, FutureMoveAssignment) {
+    Promise<int> promise;
+    Future<int> f1 = promise.GetFuture();
+    Future<int> f2 = promise.GetFuture();
+
+    f2 = std::move(f1);
+    promise.Resolve(42);
+
+    EXPECT_EQ(*f2.GetResult(), 42);
+}
+
+// Verifies that Future supports copy assignment.
+TEST(Promise, FutureCopyAssignment) {
+    Promise<int> promise;
+    Future<int> f1 = promise.GetFuture();
+    Future<int> f2 = promise.GetFuture();
+
+    f2 = f1;
+    promise.Resolve(42);
+
+    EXPECT_EQ(*f2.GetResult(), 42);
+}
+
+// Verifies that a Continuation can be constructed from an lvalue callable
+// (named lambda), not just from a temporary.
+TEST(Promise, LvalueLambdaContinuation) {
+    auto fn = [](int x) { return x * 2; };
+    Continuation<int(int)> c(fn);
+    EXPECT_EQ(c(21), 42);
+}
+
+TEST(WhenAll, NoFutures) {
+    Future<std::monostate> result = WhenAll();
+    EXPECT_TRUE(result.IsFinished());
+}
+
+// Verifies WhenAll resolves when all futures are already resolved.
+TEST(WhenAll, AllAlreadyResolved) {
+    Promise<int> p1;
+    Promise<std::string> p2;
+
+    p1.Resolve(1);
+    p2.Resolve("hello");
+
+    Future<std::monostate> result = WhenAll(p1.GetFuture(), p2.GetFuture());
+    auto r = result.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(r.has_value());
+}
+
+// Verifies WhenAll resolves only after all futures resolve, using futures of
+// mixed value types. The original futures still hold their results afterward.
+TEST(WhenAll, ResolvesAfterAll) {
+    Promise<int> p1;
+    Promise<std::string> p2;
+
+    Future<int> f1 = p1.GetFuture();
+    Future<std::string> f2 = p2.GetFuture();
+
+    Future<std::monostate> result = WhenAll(f1, f2);
+
+    EXPECT_FALSE(result.IsFinished());
+    p1.Resolve(42);
+    EXPECT_FALSE(result.IsFinished());
+    p2.Resolve("done");
+
+    auto r = result.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(r.has_value());
+    EXPECT_EQ(*f1.GetResult(), 42);
+    EXPECT_EQ(*f2.GetResult(), "done");
+}
+
+// Verifies that WhenAny resolves with the index of the first future to resolve.
+TEST(WhenAny, FirstResolved) {
+    Promise<int> p0;
+    Promise<int> p1;
+    Promise<int> p2;
+
+    Future<std::size_t> result =
+        WhenAny(p0.GetFuture(), p1.GetFuture(), p2.GetFuture());
+
+    EXPECT_FALSE(result.IsFinished());
+    p1.Resolve(42);
+
+    auto r = result.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(r.has_value());
+    EXPECT_EQ(*r, 1u);
+}
+
+// Verifies that WhenAny works with futures of mixed value types, and that
+// resolving a later future after the winner does not change the result.
+TEST(WhenAny, MixedTypesFirstWins) {
+    Promise<int> p0;
+    Promise<std::string> p1;
+
+    Future<int> f0 = p0.GetFuture();
+    Future<std::string> f1 = p1.GetFuture();
+
+    Future<std::variant<int, std::string>> result = WhenAny(f0, f1).Then(
+        [f0, f1](size_t const& index) -> std::variant<int, std::string> {
+            if (index == 0) {
+                return f0.GetResult().value();
+            } else {
+                return f1.GetResult().value();
+            }
+        },
+        [](Continuation<void()> f) { f(); });
+
+    p1.Resolve("hello");
+    p0.Resolve(99);
+
+    auto r = result.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(r.has_value());
+    EXPECT_EQ(std::get<std::string>(*result.GetResult()), "hello");
+}
+
+// Verifies that WhenAny resolves immediately if a future is already resolved.
+TEST(WhenAny, AlreadyResolved) {
+    Promise<int> p0;
+    Promise<int> p1;
+
+    p0.Resolve(42);
+
+    Future<std::size_t> result = WhenAny(p0.GetFuture(), p1.GetFuture());
+
+    auto r = result.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(r.has_value());
+    EXPECT_EQ(*r, 0u);
+}
+
+TEST(WhenAll, ConcurrentResolution) {
+    auto spawn = [](int val) {
+        Promise<int> p;
+        Future<int> f = p.GetFuture();
+        return std::make_pair(
+            f, std::thread([p = std::move(p), val]() mutable {
+                std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                p.Resolve(val);
+            }));
+    };
+
+    auto [f1, t1] = spawn(1);
+    auto [f2, t2] = spawn(2);
+    auto [f3, t3] = spawn(3);
+    auto [f4, t4] = spawn(4);
+    auto [f5, t5] = spawn(5);
+
+    auto result = WhenAll(f1, f2, f3, f4, f5);
+
+    auto r = result.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(r.has_value());
+
+    EXPECT_EQ(f1.GetResult().value(), 1);
+    EXPECT_EQ(f2.GetResult().value(), 2);
+    EXPECT_EQ(f3.GetResult().value(), 3);
+    EXPECT_EQ(f4.GetResult().value(), 4);
+    EXPECT_EQ(f5.GetResult().value(), 5);
+
+    t1.join();
+    t2.join();
+    t3.join();
+    t4.join();
+    t5.join();
+}
+
+// Verifies that WaitForResult returns nullopt when the promise is never
+// resolved within the timeout.
+TEST(Promise, WaitForResultTimeout) {
+    Promise<int> promise;
+    Future<int> future = promise.GetFuture();
+
+    auto result = future.WaitForResult(std::chrono::milliseconds(50));
+    EXPECT_FALSE(result.has_value());
+}
+
+// Verifies that when multiple threads race to resolve the same promise,
+// exactly one succeeds and the rest return false.
+TEST(Promise, ConcurrentResolveSingleWinner) {
+    Promise<int> promise;
+    Future<int> future = promise.GetFuture();
+
+    std::atomic<int> winners{0};
+    std::vector<std::thread> threads;
+    for (int i = 0; i < 10; i++) {
+        threads.emplace_back([&promise, &winners, i] {
+            if (promise.Resolve(i)) {
+                winners++;
+            }
+        });
+    }
+
+    for (auto& t : threads) {
+        t.join();
+    }
+
+    EXPECT_EQ(winners, 1);
+    EXPECT_TRUE(future.GetResult().has_value());
+}
+
+// Verifies that a chain of Then calls executes correctly when continuations
+// are dispatched via a multi-threaded ASIO executor.
+TEST(Promise, MultiThreadedASIOExecutor) {
+    boost::asio::io_context ioc;
+    auto work = boost::asio::make_work_guard(ioc);
+
+    std::vector<std::thread> ioc_threads;
+    for (int i = 0; i < 4; i++) {
+        ioc_threads.emplace_back([&ioc] { ioc.run(); });
+    }
+
+    auto executor = [&ioc](Continuation<void()> f) {
+        boost::asio::post(ioc, std::move(f));
+    };
+
+    Promise<int> promise;
+    Future<int> result =
+        promise.GetFuture()
+            .Then([](int const& v) { return v * 2; }, executor)
+            .Then([](int const& v) { return v + 1; }, executor);
+
+    promise.Resolve(10);
+
+    auto r = result.WaitForResult(std::chrono::seconds(5));
+    ASSERT_TRUE(r.has_value());
+    EXPECT_EQ(*r, 21);
+
+    work.reset();
+    for (auto& t : ioc_threads) {
+        t.join();
+    }
+}