diff --git a/benchmark/src/libfork_benchmark/fib/fib.hpp b/benchmark/src/libfork_benchmark/fib/fib.hpp
index d39478d0..fd208483 100644
--- a/benchmark/src/libfork_benchmark/fib/fib.hpp
+++ b/benchmark/src/libfork_benchmark/fib/fib.hpp
@@ -59,32 +59,41 @@ struct tls_bump {
   }
 };
 
-constinit inline std::byte *bump_ptr = nullptr;
+// === Shared Context Logic ===
 
-struct global_bump {
+template <lf::stack_allocator Alloc>
+struct vector_ctx {
 
-  static auto operator new(std::size_t sz) -> void * {
-    auto *prev = bump_ptr;
-    bump_ptr += fib_align_size(sz);
-    return prev;
-  }
+  using handle_type = lf::frame_handle<vector_ctx>;
 
-  static auto operator delete(void *p, [[maybe_unused]] std::size_t sz) noexcept -> void {
-    bump_ptr = std::bit_cast<std::byte *>(p);
+  std::vector<handle_type> work;
+  Alloc allocator;
+
+  vector_ctx() { work.reserve(1024); }
+
+  auto alloc() noexcept -> Alloc & { return allocator; }
+
+  void push(handle_type handle) { work.push_back(handle); }
+
+  auto pop() noexcept -> handle_type {
+    auto handle = work.back();
+    work.pop_back();
+    return handle;
   }
 };
 
-// === Shared Context Logic ===
+template <lf::stack_allocator Alloc>
+struct poly_vector_ctx final : lf::polymorphic_context<Alloc> {
 
-struct vector_ctx final : lf::polymorphic_context {
+  using handle_type = lf::frame_handle<lf::polymorphic_context<Alloc>>;
 
-  std::vector<lf::work_handle> work;
+  std::vector<handle_type> work;
 
-  vector_ctx() { work.reserve(1024); }
+  poly_vector_ctx() { work.reserve(1024); }
 
-  void push(lf::work_handle handle) override { work.push_back(handle); }
+  void push(handle_type handle) override { work.push_back(handle); }
 
-  auto pop() noexcept -> lf::work_handle override {
+  auto pop() noexcept -> handle_type override {
     auto handle = work.back();
     work.pop_back();
     return handle;
diff --git a/benchmark/src/libfork_benchmark/fib/lf_parts.cpp b/benchmark/src/libfork_benchmark/fib/lf_parts.cpp
index e0cc3c40..3eeae2e2 100644
--- a/benchmark/src/libfork_benchmark/fib/lf_parts.cpp
+++ b/benchmark/src/libfork_benchmark/fib/lf_parts.cpp
@@ -12,15 +12,41 @@ import libfork.core;
 
 namespace {
 
-struct stack_on_heap {
-  static constexpr auto operator new(std::size_t sz) -> void * { return ::operator new(sz); }
-  static constexpr auto operator delete(void *p, [[maybe_unused]] std::size_t sz) noexcept -> void {
-    ::operator delete(p, sz);
+struct global_allocator {
+
+  struct empty {};
+
+  constexpr static auto push(std::size_t sz) -> void * { return ::operator new(sz); }
+  constexpr static auto pop(void *p, std::size_t sz) noexcept -> void { ::operator delete(p, sz); }
+  constexpr static auto checkpoint() noexcept -> empty { return {}; }
+  constexpr static auto switch_to(empty) noexcept -> void {}
+};
+
+static_assert(lf::stack_allocator<global_allocator>);
+
+struct linear_allocator {
+
+  std::unique_ptr<std::byte[]> data = std::make_unique<std::byte[]>(1024 * 1024);
+  std::byte *ptr = data.get();
+
+  constexpr auto push(std::size_t sz) -> void * {
+    auto *prev = ptr;
+    ptr += fib_align_size(sz);
+    return prev;
   }
+  constexpr auto pop(void *p, std::size_t) noexcept -> void { ptr = static_cast<std::byte *>(p); }
+
+  constexpr auto checkpoint() noexcept -> std::byte * { return data.get(); }
+
+  constexpr static auto switch_to(std::byte *) noexcept -> void {}
 };
 
-template <lf::alloc_mixin Stack>
-constexpr auto no_await = [](this auto fib, std::int64_t *ret, std::int64_t n) -> lf::task<void, Stack> {
+static_assert(lf::stack_allocator<linear_allocator>);
+
+using lf::task;
+
+template <lf::worker_context T>
+constexpr auto no_await = [](this auto fib, std::int64_t *ret, std::int64_t n) -> task<void, T> {
   if (n < 2) {
     *ret = n;
     co_return;
@@ -40,8 +66,8 @@ constexpr auto no_await = [](this auto fib, std::int64_t *ret, std::int64_t n) -
   *ret = lhs + rhs;
 };
 
-template <lf::alloc_mixin Stack>
-constexpr auto await = [](this auto fib, std::int64_t *ret, std::int64_t n) -> lf::task<void, Stack> {
+template <lf::worker_context T>
+constexpr auto await = [](this auto fib, std::int64_t *ret, std::int64_t n) -> lf::task<void, T> {
   if (n < 2) {
     *ret = n;
     co_return;
@@ -56,7 +82,8 @@ constexpr auto await = [](this auto fib, std::int64_t *ret, std::int64_t n) -> l
   *ret = lhs + rhs;
 };
 
-constexpr auto ret = [](this auto fib, std::int64_t n) -> lf::task<std::int64_t, tls_bump> {
+template <lf::worker_context T>
+constexpr auto ret = [](this auto fib, std::int64_t n) -> lf::task<std::int64_t, T> {
   if (n < 2) {
     co_return n;
   }
@@ -70,8 +97,8 @@ constexpr auto ret = [](this auto fib, std::int64_t n) -> lf::task<std::int64_t,
   co_return lhs + rhs;
 };
 
-template <typename Ctx, typename A = tls_bump>
-constexpr auto fork_call = [](this auto fib, std::int64_t n) -> lf::task<std::int64_t, A, Ctx> {
+template <typename T>
+constexpr auto fork_call = [](this auto fib, std::int64_t n) -> lf::task<std::int64_t, T> {
   if (n < 2) {
     co_return n;
   }
@@ -85,7 +112,10 @@ constexpr auto fork_call = [](this auto fib, std::int64_t n) -> lf::task<std::in
   co_return lhs + rhs;
 };
 
-template <auto Fn>
+using global_alloc = vector_ctx<global_allocator>;
+using linear_alloc = vector_ctx<linear_allocator>;
+
+template <auto Fn, typename T, typename U = T>
 void fib(benchmark::State &state) {
 
   std::int64_t n = state.range(0);
@@ -93,15 +123,13 @@ void fib(benchmark::State &state) {
 
   state.counters["n"] = static_cast<double>(n);
 
-  // Set bump allocator buffer
-  std::unique_ptr buf = std::make_unique<std::byte[]>(1024 * 1024);
-  tls_bump_ptr = buf.get();
-  bump_ptr = buf.get();
+  T context;
+
+  lf::thread_context<U> = static_cast<U *>(&context);
 
-  // Set both context and poly context
-  std::unique_ptr ctx = std::make_unique<vector_ctx>();
-  lf::thread_context<vector_ctx> = ctx.get();
-  lf::thread_context<lf::polymorphic_context> = ctx.get();
+  lf::defer _ = [] static noexcept {
+    lf::thread_context<U> = nullptr;
+  };
 
   for (auto _ : state) {
     benchmark::DoNotOptimize(n);
@@ -121,55 +149,44 @@ void fib(benchmark::State &state) {
     CHECK_RESULT(result, expect);
     benchmark::DoNotOptimize(result);
   }
-
-  if (tls_bump_ptr != buf.get() || bump_ptr != buf.get()) {
-    LF_TERMINATE("Stack leak detected");
-  }
-
-  tls_bump_ptr = nullptr;
-  bump_ptr = nullptr;
-  lf::thread_context<vector_ctx> = nullptr;
-  lf::thread_context<lf::polymorphic_context> = nullptr;
 }
 
 } // namespace
 
-// Return by ref-arg, test direct root, no co-await, direct resumes, uses new/delete for alloc
-BENCHMARK(fib<no_await<stack_on_heap>>)->Name("test/libfork/fib/heap/no_await")->Arg(fib_test);
-BENCHMARK(fib<no_await<stack_on_heap>>)->Name("base/libfork/fib/heap/no_await")->Arg(fib_base);
+static_assert(lf::worker_context<global_alloc>);
 
-// Same as above but uses tls bump allocator
-BENCHMARK(fib<no_await<tls_bump>>)->Name("test/libfork/fib/tls_bump/no_await")->Arg(fib_test);
-BENCHMARK(fib<no_await<tls_bump>>)->Name("base/libfork/fib/tls_bump/no_await")->Arg(fib_base);
+// Return by ref-arg, test direct root, no co-await, direct resumes, uses new/delete for alloc
+BENCHMARK(fib<no_await<global_alloc>, global_alloc>)->Name("test/libfork/fib/heap/no_await")->Arg(fib_test);
+BENCHMARK(fib<no_await<global_alloc>, global_alloc>)->Name("base/libfork/fib/heap/no_await")->Arg(fib_base);
 
-// Same as above but with global bump allocator
-BENCHMARK(fib<no_await<global_bump>>)->Name("test/libfork/fib/global_bump/no_await")->Arg(fib_test);
-BENCHMARK(fib<no_await<global_bump>>)->Name("base/libfork/fib/global_bump/no_await")->Arg(fib_base);
+// Same as above but uses bump allocator
+BENCHMARK(fib<no_await<linear_alloc>, linear_alloc>)->Name("test/libfork/fib/bump/no_await")->Arg(fib_test);
+BENCHMARK(fib<no_await<linear_alloc>, linear_alloc>)->Name("base/libfork/fib/bump/no_await")->Arg(fib_base);
 
 // TODO: no_await with segmented stack allocator?
 
 // Return by ref-arg, libfork call/call with co-await, uses new/delete for alloc
-BENCHMARK(fib<await<stack_on_heap>>)->Name("test/libfork/fib/heap/await")->Arg(fib_test);
-BENCHMARK(fib<await<stack_on_heap>>)->Name("base/libfork/fib/heap/await")->Arg(fib_base);
+BENCHMARK(fib<await<global_alloc>, global_alloc>)->Name("test/libfork/fib/heap/await")->Arg(fib_test);
+BENCHMARK(fib<await<global_alloc>, global_alloc>)->Name("base/libfork/fib/heap/await")->Arg(fib_base);
 
-// Same as above but uses tls bump allocator
-BENCHMARK(fib<await<tls_bump>>)->Name("test/libfork/fib/tls_bump/await")->Arg(fib_test);
-BENCHMARK(fib<await<tls_bump>>)->Name("base/libfork/fib/tls_bump/await")->Arg(fib_base);
-
-// Same as above but with global bump allocator
-BENCHMARK(fib<await<global_bump>>)->Name("test/libfork/fib/global_bump/await")->Arg(fib_test);
-BENCHMARK(fib<await<global_bump>>)->Name("base/libfork/fib/global_bump/await")->Arg(fib_base);
+// // Same as above but uses bump allocator
+BENCHMARK(fib<await<linear_alloc>, linear_alloc>)->Name("test/libfork/fib/bump/await")->Arg(fib_test);
+BENCHMARK(fib<await<linear_alloc>, linear_alloc>)->Name("base/libfork/fib/bump/await")->Arg(fib_base);
 
 // Return by value
 // libfork call/call with co-await
-BENCHMARK(fib<ret>)->Name("test/libfork/fib/tls_bump/return")->Arg(fib_test);
-BENCHMARK(fib<ret>)->Name("base/libfork/fib/tls_bump/return")->Arg(fib_base);
+BENCHMARK(fib<ret<linear_alloc>, linear_alloc>)->Name("test/libfork/fib/bump/return")->Arg(fib_test);
+BENCHMARK(fib<ret<linear_alloc>, linear_alloc>)->Name("base/libfork/fib/bump/return")->Arg(fib_base);
 
 // Return by value
 // libfork call/fork (no join)
 // Non-polymorphic vector-backed context
-BENCHMARK(fib<fork_call<vector_ctx>>)->Name("test/libfork/fib/vector_ctx")->Arg(fib_test);
-BENCHMARK(fib<fork_call<vector_ctx>>)->Name("base/libfork/fib/vector_ctx")->Arg(fib_base);
+BENCHMARK(fib<fork_call<linear_alloc>, linear_alloc>)->Name("test/libfork/fib/vector_ctx")->Arg(fib_test);
+BENCHMARK(fib<fork_call<linear_alloc>, linear_alloc>)->Name("base/libfork/fib/vector_ctx")->Arg(fib_base);
+
+using A = poly_vector_ctx<linear_allocator>;
+using B = lf::polymorphic_context<linear_allocator>;
 
-BENCHMARK(fib<fork_call<lf::polymorphic_context>>)->Name("test/libfork/fib/poly_vector_ctx")->Arg(fib_test);
-BENCHMARK(fib<fork_call<lf::polymorphic_context>>)->Name("base/libfork/fib/poly_vector_ctx")->Arg(fib_base);
+// Same as above but with polymorphic contexts.
+BENCHMARK(fib<fork_call<B>, A, B>)->Name("test/libfork/fib/poly_vector_ctx")->Arg(fib_test);
+BENCHMARK(fib<fork_call<B>, A, B>)->Name("base/libfork/fib/poly_vector_ctx")->Arg(fib_base);
diff --git a/src/core/concepts.cxx b/src/core/concepts.cxx
index 918e1ebe..656cb823 100644
--- a/src/core/concepts.cxx
+++ b/src/core/concepts.cxx
@@ -5,6 +5,24 @@ import std;
 
 namespace lf {
 
+// ========== Specialization ========== //
+
+template <typename T, template <typename...> typename Template>
+struct is_specialization_of : std::false_type {};
+
+template <template <typename...> typename Template, typename... Args>
+struct is_specialization_of<Template<Args...>, Template> : std::true_type {};
+
+/**
+ * @brief Test if `T` is a specialization of the template `Template`.
+ */
+export template <typename T, template <typename...> typename Template>
+concept specialization_of = is_specialization_of<std::remove_cvref_t<T>, Template>::value;
+
+// ========== Task constraint related concepts ========== //
+
+// ==== Returnable
+
 /**
  * @brief A type returnable from libfork's async functions/coroutines.
  *
@@ -13,31 +31,78 @@ namespace lf {
 template <typename T>
 concept returnable = std::is_void_v<T> || std::movable<T>;
 
+// ==== Stack
+
 template <typename T>
-concept mixinable = std::is_empty_v<T> && !std::is_final_v<T>;
+  requires std::is_object_v<T>
+consteval auto constify(T &&x) noexcept -> std::add_const_t<T> &;
 
+/**
+ * @brief Defines the API for a libfork compatible stack allocator.
+ *
+ * - After construction push is valid.
+ * - Pop is valid provided the FILO order is respected.
+ * - Destruction is expected to only occur when the stack is empty.
+ * - Result of `.checkpoint()` is expected to be "cheap to copy".
+ * - Switch releases the current stack and resumes from the checkpoint:
+ *     - This is a noop if the checkpoint is from this stack.
+ *     - If the checkpoint is default-constructed it is expected to switch to a new stack.
+ *
+ * Fast-path operations: empty, push, pop, checkpoint
+ * Slow-path operations: switch
+ */
 export template <typename T>
-concept alloc_mixin = mixinable<T> && requires (std::size_t n, T *ptr) {
-  { T::operator new(n) } -> std::same_as<void *>;
-  { T::operator delete(ptr, n) } noexcept -> std::same_as<void>;
+concept stack_allocator = std::is_object_v<T> && requires (T alloc, std::size_t n, void *ptr) {
+  // { alloc.empty() } noexcept -> std::same_as<bool>;
+  { alloc.push(n) } -> std::same_as<void *>;
+  { alloc.pop(ptr, n) } noexcept -> std::same_as<void>;
+  { alloc.checkpoint() } noexcept -> std::semiregular;
+  { alloc.switch_to({}) } noexcept -> std::same_as<void>;
+  { alloc.switch_to(constify(alloc.checkpoint())) } noexcept -> std::same_as<void>;
 };
 
-template <typename T, template <typename...> typename Template>
-struct is_specialization_of : std::false_type {};
+/**
+ * @brief Fetch the checkpoint type of a stack allocator `T`.
+ */
+template <stack_allocator T>
+using checkpoint_t = decltype(std::declval<T &>().checkpoint());
 
-template <template <typename...> typename Template, typename... Args>
-struct is_specialization_of<Template<Args...>, Template> : std::true_type {};
+// ==== Context
+
+export template <typename T>
+class frame_handle;
+
+template <typename T>
+concept ref_to_stack_allocator = std::is_lvalue_reference_v<T> && stack_allocator<std::remove_reference_t<T>>;
 
 /**
- * @brief Test if `T` is a specialization of the template `Template`.
+ * @brief Defines the API for a libfork compatible worker context.
+ *
+ * This requires that `T` is an object type and supports the following operations:
+ *
+ * - Push/pop a frame handle onto the context in a LIFO manner.
+ * - Have a `stack_allocator` that can be accessed via `alloc()`.
  */
-template <typename T, template <typename...> typename Template>
-concept specialization_of = is_specialization_of<std::remove_cvref_t<T>, Template>::value;
+export template <typename T>
+concept worker_context = std::is_object_v<T> && requires (T ctx, frame_handle<T> handle) {
+  { ctx.alloc() } noexcept -> ref_to_stack_allocator;
+  { ctx.push(handle) } -> std::same_as<void>;
+  { ctx.pop() } noexcept -> std::same_as<frame_handle<T>>;
+};
+
+/**
+ * @brief Fetch the allocator type of a worker context `T`.
+ */
+template <worker_context T>
+using allocator_t = std::remove_reference_t<decltype(std::declval<T &>().alloc())>;
+
+// ==== Forward-decl
 
-// Forward-decl
-export template <returnable T, alloc_mixin Stack, typename Context>
+export template <returnable T, worker_context Context>
 struct task;
 
+// ========== Invocability ========== //
+
 /**
  * @brief Test if a callable `Fn` when invoked with `Args...` returns an `lf::task`.
  */
@@ -50,9 +115,12 @@ concept async_invocable =
  */
 export template <typename Fn, typename... Args>
   requires async_invocable<Fn, Args...>
-using async_result_t = std::invoke_result_t<Fn, Args...>::type;
+using async_result_t = std::invoke_result_t<Fn, Args...>::value_type;
 
-template <typename Fn, typename R, typename... Args>
-concept async_invocable_to = async_invocable<Fn, Args...> && std::same_as<async_result_t<Fn, Args...>, R>;
+/**
+ * @brief Subsumes `async_invocable` and checks the result type is `R`.
+ */
+export template <typename Fn, typename R, typename... Args>
+concept async_invocable_to = async_invocable<Fn, Args...> && std::same_as<R, async_result_t<Fn, Args...>>;
 
 } // namespace lf
diff --git a/src/core/context.cxx b/src/core/context.cxx
index 01bf8ffd..18c7ea11 100644
--- a/src/core/context.cxx
+++ b/src/core/context.cxx
@@ -3,32 +3,31 @@ export module libfork.core:context;
 
 import std;
 
-import :frame;
+import :concepts;
 
 namespace lf {
 
-// TODO: private bits / split
-export struct work_handle {
-  frame_type *frame;
-};
-
-static_assert(std::atomic<work_handle>::is_always_lock_free);
+/**
+ * @brief A worker context polymorphic in push/pop.
+ */
+export template <stack_allocator Alloc>
+class polymorphic_context {
+ public:
+  constexpr polymorphic_context() = default;
 
-template <typename T>
-concept context = requires (T &ctx, work_handle h) {
-  { ctx.push(h) } -> std::same_as<void>;
-  { ctx.pop() } noexcept -> std::same_as<work_handle>;
-};
+  explicit constexpr polymorphic_context(Alloc alloc) noexcept(std::is_nothrow_move_constructible_v<Alloc>)
+      : m_allocator(std::move(alloc)) {}
 
-export struct polymorphic_context {
-  virtual void push(work_handle h) = 0;
-  virtual auto pop() noexcept -> work_handle = 0;
+  auto alloc() noexcept -> Alloc & { return m_allocator; }
+  virtual void push(frame_handle<polymorphic_context>) = 0;
+  virtual auto pop() noexcept -> frame_handle<polymorphic_context> = 0;
   virtual ~polymorphic_context() = default;
-};
 
-static_assert(context<polymorphic_context>);
+ private:
+  Alloc m_allocator;
+};
 
-export template <typename Context>
+export template <worker_context Context>
 constinit inline thread_local Context *thread_context = nullptr;
 
 } // namespace lf
diff --git a/src/core/core.cxx b/src/core/core.cxx
index 0cfb8b61..cffda422 100644
--- a/src/core/core.cxx
+++ b/src/core/core.cxx
@@ -3,13 +3,13 @@ export module libfork.core;
 // T1 partitions
 export import :concepts;
 export import :constants;
-export import :frame;
 export import :utility;
 export import :tuple;
 
 // T2 partitions
+export import :frame;   // concepts
+export import :context; // concepts
 export import :ops;     // concepts, tuple, utility
-export import :context; // frame
 
 // T3 partitions
-export import :promise; // context, ops
+export import :promise;
diff --git a/src/core/frame.cxx b/src/core/frame.cxx
index b513e79e..fc0a3f9d 100644
--- a/src/core/frame.cxx
+++ b/src/core/frame.cxx
@@ -4,21 +4,32 @@ export module libfork.core:frame;
 
 import std;
 
+import :concepts;
+
 namespace lf {
 
 // TODO: remove this and other exports
 export enum class category : std::uint8_t {
-  call,
+  call = 0,
   root,
   fork,
 };
 
-struct cancellation;
+struct cancellation {};
+
+// =================== Frame =================== //
 
+export template <typename Context>
 struct frame_type {
 
-  frame_type *parent = nullptr; // TODO: set as at root
+  using context_type = Context;
+  using allocator_type = allocator_t<Context>;
+  using checkpoint_type = checkpoint_t<allocator_type>;
+
+  frame_type *parent = nullptr;
   cancellation *cancel = nullptr;
+  [[no_unique_address]]
+  checkpoint_type stack_ckpt;
 
   std::uint32_t merges = 0;       // Atomic is 32 bits for speed
   std::uint16_t steals = 0;       // In debug do overflow checking
@@ -29,6 +40,35 @@ struct frame_type {
   constexpr auto handle() LF_HOF(std::coroutine_handle<frame_type>::from_promise(*this))
 };
 
-static_assert(std::is_standard_layout_v<frame_type>);
+// =================== Handle =================== //
+
+struct lock {};
+
+inline constexpr lock key = {};
+
+// TODO: api + test this is lock-free
+//
+// What is the API:
+//  - You can push/pop it
+//  - You can convert it to a "steal handle" -> which you can/must resume?
+//
+// What properties does it have:
+//  - It is trivially copyable/constructible/destructible
+//  - It has a null value, you can test if it is null
+//  - You can store it in an atomic and it is lock-free
+export template <typename T>
+class frame_handle {
+ public:
+  constexpr frame_handle() = default;
+  // constexpr frame_handle(std::nullptr_t) noexcept : m_ptr(nullptr) {}
+  constexpr frame_handle(lock, frame_type<T> *ptr) noexcept : m_ptr(ptr) {}
+
+  explicit operator bool() const noexcept { return m_ptr != nullptr; }
+
+  // private:
+  frame_type<T> *m_ptr = nullptr;
+};
+
+// =================== First arg =================== //
 
 } // namespace lf
diff --git a/src/core/promise.cxx b/src/core/promise.cxx
index 61cdc743..e9e8805a 100644
--- a/src/core/promise.cxx
+++ b/src/core/promise.cxx
@@ -9,10 +9,8 @@ export module libfork.core:promise;
 import std;
 
 import :concepts;
-import :constants;
 import :frame;
 import :utility;
-import :tuple;
 
 import :context;
 import :ops;
@@ -24,7 +22,7 @@ using coro = std::coroutine_handle<T>;
 
 // =============== Forward-decl =============== //
 
-template <returnable T, alloc_mixin Stack, context Context = polymorphic_context>
+export template <returnable T, worker_context Context>
 struct promise_type;
 
 // =============== Task =============== //
@@ -45,18 +43,24 @@ struct promise_type;
  *
  * \endrst
  */
-export template <returnable T, alloc_mixin Stack, typename Context = polymorphic_context>
-struct task : immovable, std::type_identity<T> {
-  promise_type<T, Stack, Context> *promise;
+export template <returnable T, worker_context Context>
+struct task : immovable {
+
+  // TODO: public private split here and elsewhere
+
+  using value_type = T;
+  using context_type = Context;
+
+  promise_type<T, Context> *promise;
 };
 
 // =============== Final =============== //
 
-template <context Context>
+template <worker_context Context>
 [[nodiscard]]
-constexpr auto final_suspend(frame_type *frame) noexcept -> coro<> {
+constexpr auto final_suspend(frame_type<Context> *frame) noexcept -> coro<> {
 
-  defer _ = [frame]() noexcept -> void {
+  defer _ = [frame] noexcept -> void {
     frame->handle().destroy();
   };
 
@@ -71,15 +75,13 @@ constexpr auto final_suspend(frame_type *frame) noexcept -> coro<> {
     default:
       LF_ASSUME(false);
   }
+  auto *context = not_null(thread_context<Context>);
+  auto *parent = not_null(frame->parent);
 
-  context auto *ctx = not_null(thread_context<Context>);
-
-  frame_type *parent = not_null(frame->parent);
-
-  if (frame_type *last_push = ctx->pop().frame) {
+  if (frame_handle last_pushed = context->pop()) {
     // No-one stole continuation, we are the exclusive owner of parent, so we
     // just keep ripping!
-    LF_ASSUME(last_push == parent);
+    LF_ASSUME(last_pushed.m_ptr == parent);
     // If no-one stole the parent then this child can also never have been
     // stolen. Hence, this must be the same thread that created the parent so
     // it already owns the stack. No steals have occurred so we do not need to
@@ -170,20 +172,21 @@ constexpr auto final_suspend(frame_type *frame) noexcept -> coro<> {
 }
 
 struct final_awaitable : std::suspend_always {
-  template <typename T, alloc_mixin S, typename Context>
-  constexpr static auto await_suspend(coro<promise_type<T, S, Context>> handle) noexcept -> coro<> {
+  template <returnable T, worker_context Context>
+  constexpr static auto await_suspend(coro<promise_type<T, Context>> handle) noexcept -> coro<> {
     return final_suspend<Context>(&handle.promise().frame);
   }
 };
 
 // =============== Call =============== //
 
+template <worker_context Context>
 struct call_awaitable : std::suspend_always {
 
-  frame_type *child;
+  frame_type<Context> *child;
 
-  template <typename... Us>
-  auto await_suspend(this auto self, coro<promise_type<Us...>> parent) noexcept -> coro<> {
+  template <returnable T>
+  auto await_suspend(this auto self, coro<promise_type<T, Context>> parent) noexcept -> coro<> {
     // Connect child to parent
     not_null(self.child)->parent = &parent.promise().frame;
 
@@ -193,12 +196,13 @@ struct call_awaitable : std::suspend_always {
 
 // =============== Fork =============== //
 
+template <worker_context Context>
 struct fork_awaitable : std::suspend_always {
 
-  frame_type *child;
+  frame_type<Context> *child;
 
-  template <typename T, alloc_mixin S, typename Context>
-  auto await_suspend(this auto self, coro<promise_type<T, S, Context>> parent) noexcept -> coro<> {
+  template <typename T>
+  auto await_suspend(this auto self, coro<promise_type<T, Context>> parent) noexcept -> coro<> {
 
     // It is critical to pass self by-value here, after the call to push()
     // the object may be destroyed, if passing by ref it would be use
@@ -209,7 +213,7 @@ struct fork_awaitable : std::suspend_always {
     not_null(self.child)->parent = &parent.promise().frame;
 
     LF_TRY {
-      not_null(thread_context<Context>)->push(work_handle{.frame = &parent.promise().frame});
+      not_null(thread_context<Context>)->push(frame_handle<Context>{key, &parent.promise().frame});
     } LF_CATCH_ALL {
       self.child->handle().destroy();
       // TODO: stash in parent frame (should not throw)
@@ -222,6 +226,7 @@ struct fork_awaitable : std::suspend_always {
 
 // =============== Frame mixin =============== //
 
+template <worker_context Context>
 struct mixin_frame {
 
   // === For internal use === //
@@ -229,22 +234,33 @@ struct mixin_frame {
   template <typename Self>
     requires (!std::is_const_v<Self>)
   [[nodiscard]]
-  constexpr auto handle(this Self &self) LF_HOF(coro<Self>::from_promise(self))
-
-  [[nodiscard]]
-  constexpr auto get_frame(this auto &&self)
-      LF_HOF(LF_FWD(self).frame)
+  constexpr auto handle(this Self &self)
+      LF_HOF(coro<Self>::from_promise(self))
 
   // === Called by the compiler === //
 
+  // --- Allocation
+
+  static auto operator new(std::size_t sz) -> void * {
+    return not_null(thread_context<Context>)->alloc().push(sz);
+  }
+
+  static auto operator delete(void *p, std::size_t sz) noexcept -> void {
+    not_null(thread_context<Context>)->alloc().pop(p, sz);
+  }
+
+  // --- Await transformations
+
   template <typename R, typename Fn, typename... Args>
-  constexpr static auto await_transform(call_pkg<R, Fn, Args...> &&pkg) noexcept -> call_awaitable {
+  static constexpr auto await_transform(call_pkg<R, Fn, Args...> &&pkg) noexcept -> call_awaitable<Context> {
 
     task child = std::move(pkg.args).apply(std::move(pkg.fn));
 
     // ::call is the default value
     LF_ASSUME(child.promise->frame.kind == category::call);
 
+    child.promise->frame.stack_ckpt = not_null(thread_context<Context>)->alloc().checkpoint();
+
     if constexpr (!std::is_void_v<R>) {
       child.promise->return_address = pkg.return_address;
     }
@@ -253,12 +269,14 @@ struct mixin_frame {
   }
 
   template <typename R, typename Fn, typename... Args>
-  constexpr static auto await_transform(fork_pkg<R, Fn, Args...> &&pkg) noexcept -> fork_awaitable {
+  constexpr static auto await_transform(fork_pkg<R, Fn, Args...> &&pkg) noexcept -> fork_awaitable<Context> {
 
     task child = std::move(pkg.args).apply(std::move(pkg.fn));
 
     child.promise->frame.kind = category::fork;
 
+    child.promise->frame.stack_ckpt = not_null(thread_context<Context>)->alloc().checkpoint();
+
     if constexpr (!std::is_void_v<R>) {
       child.promise->return_address = pkg.return_address;
     }
@@ -273,42 +291,27 @@ struct mixin_frame {
   constexpr static void unhandled_exception() noexcept { std::terminate(); }
 };
 
-static_assert(std::is_empty_v<mixin_frame>);
-
 // =============== Promise (void) =============== //
 
-template <alloc_mixin Stack, context Context>
-struct promise_type<void, Stack, Context> : Stack, mixin_frame {
+template <worker_context Context>
+struct promise_type<void, Context> : mixin_frame<Context> {
 
-  frame_type frame;
+  frame_type<Context> frame;
 
-  constexpr auto get_return_object() noexcept -> task<void, Stack, Context> { return {.promise = this}; }
+  constexpr auto get_return_object() noexcept -> task<void, Context> { return {.promise = this}; }
 
   constexpr static void return_void() noexcept {}
 };
 
-struct dummy_alloc {
-  static auto operator new(std::size_t) -> void *;
-  static auto operator delete(void *, std::size_t) noexcept -> void;
-};
-
-static_assert(alignof(promise_type<void, dummy_alloc>) == alignof(frame_type));
-
-#ifdef __cpp_lib_is_pointer_interconvertible
-static_assert(std::is_pointer_interconvertible_with_class(&promise_type<void, dummy_alloc>::frame));
-#else
-static_assert(std::is_standard_layout_v<promise_type<void, dummy_alloc>>);
-#endif
-
 // =============== Promise (non-void) =============== //
 
-template <returnable T, alloc_mixin Stack, context Context>
-struct promise_type : Stack, mixin_frame {
+template <returnable T, worker_context Context>
+struct promise_type : mixin_frame<Context> {
 
-  frame_type frame;
+  frame_type<Context> frame;
   T *return_address;
 
-  constexpr auto get_return_object() noexcept -> task<T, Stack, Context> { return {.promise = this}; }
+  constexpr auto get_return_object() noexcept -> task<T, Context> { return {.promise = this}; }
 
   template <typename U = T>
     requires std::assignable_from<T &, U &&>
@@ -317,14 +320,6 @@ struct promise_type : Stack, mixin_frame {
   }
 };
 
-static_assert(alignof(promise_type<int, dummy_alloc>) == alignof(frame_type));
-
-#ifdef __cpp_lib_is_pointer_interconvertible
-static_assert(std::is_pointer_interconvertible_with_class(&promise_type<int, dummy_alloc>::frame));
-#else
-static_assert(std::is_standard_layout_v<promise_type<int, dummy_alloc>>);
-#endif
-
 } // namespace lf
 
 // =============== std specialization =============== //
diff --git a/src/core/utility.cxx b/src/core/utility.cxx
index 83be7f28..837e09e1 100644
--- a/src/core/utility.cxx
+++ b/src/core/utility.cxx
@@ -84,7 +84,7 @@ export struct move_only {
  *
  *    auto * ptr = c_api_init();
  *
- *    defer _ = [&ptr] () noexcept {
+ *    defer _ = [&ptr] noexcept {
  *      c_api_clean_up(ptr);
  *    };
  *
@@ -92,7 +92,7 @@ export struct move_only {
  *
  * \endrst
  */
-template <class F>
+export template <class F>
   requires std::is_nothrow_invocable_v<F>
 class [[nodiscard("Defer will execute unless bound to a name!")]] defer : immovable {
  public:
diff --git a/test/src/promise.cpp b/test/src/promise.cpp
index 80a9079f..40fe6c2e 100644
--- a/test/src/promise.cpp
+++ b/test/src/promise.cpp
@@ -2,6 +2,52 @@
 
 import libfork.core;
 
+namespace {
+
+struct dummy_allocator {
+
+  struct ckpt {};
+
+  constexpr static auto push(std::size_t sz) -> void *;
+  constexpr static auto pop(void *p, std::size_t sz) noexcept -> void;
+  constexpr static auto checkpoint() noexcept -> ckpt;
+  constexpr static auto switch_to(ckpt) noexcept -> void;
+};
+
+static_assert(lf::stack_allocator<dummy_allocator>);
+
+struct dummy_context {
+  auto alloc() noexcept -> dummy_allocator &;
+  void push(lf::frame_handle<dummy_context>);
+  auto pop() noexcept -> lf::frame_handle<dummy_context>;
+};
+
+static_assert(lf::worker_context<dummy_context>);
+
+} // namespace
+
 TEST_CASE("Promise test", "[promise]") {
-  // TODO:
+
+  using frame_t = lf::frame_type<dummy_context>;
+
+  // Check for safe reinterpret_casts
+  STATIC_CHECK(std::is_standard_layout_v<lf::frame_type<dummy_context>>);
+
+  // Check on void
+  static_assert(alignof(lf::promise_type<void, dummy_context>) == alignof(frame_t));
+
+#ifdef __cpp_lib_is_pointer_interconvertible
+  static_assert(std::is_pointer_interconvertible_with_class(&lf::promise_type<void, dummy_context>::frame));
+#else
+  static_assert(std::is_standard_layout_v<lf::promise_type<void, dummy_context>>);
+#endif
+
+  // Check on non-void
+  static_assert(alignof(lf::promise_type<int, dummy_context>) == alignof(frame_t));
+
+#ifdef __cpp_lib_is_pointer_interconvertible
+  static_assert(std::is_pointer_interconvertible_with_class(&lf::promise_type<int, dummy_context>::frame));
+#else
+  static_assert(std::is_standard_layout_v<lf::promise_type<int, dummy_context>>);
+#endif
 }