@reboot-dev/reboot 0.23.0 → 0.25.0

package/reboot_native.cc

@@ -81,6 +81,23 @@ struct PythonNodeAdaptor {
 
   template <typename F>
   void ScheduleCallbackOnNodeEventLoop(F&& f) {
+    // It is possible that Node.js is shutting down and has already
+    // called the `thread_safe_function` finalizer and trying to use
+    // `thread_safe_function` will raise SIGABRT or SIGSEGV.
+    //
+    // Given that we're shutting down we just return!
+    //
+    // If the callback is to free memory, e.g., from a
+    // `NapiSafeReference`, that's not a problem because we're
+    // shutting down so all the memory will get freed then! ;-)
+    //
+    // If this is for some other critical function that is necessary
+    // to do _before_ shutting down then we'll need to rethink this
+    // approaach.
+    if (thread_safe_function_finalized) {
+      return;
+    }
+
     napi_status status = thread_safe_function.BlockingCall(
         [f = std::forward<F>(f)](
             Napi::Env env,
@@ -116,6 +133,8 @@ struct PythonNodeAdaptor {
 
   Napi::ThreadSafeFunction thread_safe_function;
 
+  bool thread_safe_function_finalized = false;
+
   std::thread thread;
   std::mutex mutex;
   std::condition_variable python_functions_not_empty;
@@ -133,6 +152,83 @@ static Napi::FunctionReference* js_launchSubprocessConsensus =
     new Napi::FunctionReference();
 
 
+struct NapiReferenceDeleter {
+  template <typename T>
+  void operator()(Napi::Reference<T>* reference) {
+    adaptor->ScheduleCallbackOnNodeEventLoop(
+        [reference](Napi::Env) {
+          delete reference;
+        });
+  }
+};
+
+
+template <typename T>
+class NapiSafeReference {
+ public:
+  NapiSafeReference(T t)
+    : _reference(
+          new Napi::Reference<T>(Napi::Persistent(std::move(t))),
+          NapiReferenceDeleter()) {}
+
+  NapiSafeReference(Napi::Reference<T>&& reference)
+    : _reference(
+          new Napi::Reference<T>(std::move(reference)),
+          NapiReferenceDeleter()) {}
+
+  // Helper for getting the value of the reference. We require a
+  // `Napi::Env` to ensure we only try and get the value from within a
+  // Node thread (e.g., using the main thread or from within a NAPI
+  // thread safe function).
+  T Value(Napi::Env) const {
+    return _reference->Value();
+  }
+
+ private:
+  std::shared_ptr<Napi::Reference<T>> _reference;
+};
+
+using NapiSafeFunctionReference = NapiSafeReference<Napi::Function>;
+using NapiSafeObjectReference = NapiSafeReference<Napi::Object>;
+
+// For every servicer we construct a _subclass_ of our Python
+// generated Node adaptor, e.g., `GreeterServicerNodeAdaptor`, _at
+// runtime_ which we add to the following Python module. This module
+// also includes our C++ <-> Python class wrappers for storing NAPI
+// objects in Python to properly handle memory management.
+PYBIND11_EMBEDDED_MODULE(reboot_native, m) {
+  py::class_<NapiSafeFunctionReference>(
+      m,
+      "NapiSafeFunctionReference");
+
+  py::class_<NapiSafeObjectReference>(
+      m,
+      "NapiSafeObjectReference");
+}
+
+
+Napi::External<py::object> make_napi_external(
+    Napi::Env env,
+    py::object* py_object,
+    const napi_type_tag* type_tag = nullptr) {
+  auto js_external = Napi::External<py::object>::New(
+      env,
+      py_object,
+      [](Napi::Env, py::object* py_object) {
+        adaptor->ScheduleCallbackOnPythonEventLoop(
+            [py_object]() {
+              delete py_object;
+            });
+      });
+
+  if (type_tag != nullptr) {
+    js_external.TypeTag(type_tag);
+  }
+
+  return js_external;
+}
+
+
 void PythonNodeAdaptor::Initialize(
     Napi::Env& env,
     const Napi::Function& js_callback) {
@@ -143,8 +239,12 @@ void PythonNodeAdaptor::Initialize(
       /* Max queue size (0 = unlimited): */ 0,
       /* Initial thread count: */ 1,
       /* Context: */ this,
-      /* Finalizer: */
-      [](Napi::Env env, void*, PythonNodeAdaptor*) {},
+      // Finalizer:
+      [this](Napi::Env env, void*, PythonNodeAdaptor*) {
+        // Set that we've been finalized so that we don't use
+        // `thread_safe_function` again, see comment in
+        // `ScheduleCallbackOnNodeEventLoop`.
+        thread_safe_function_finalized = true; },
       /* Finalizer data: */ (void*) nullptr);
 
   // We start with our thread safe function unreferenced so that
@@ -301,6 +401,476 @@ std::string message_from_js_error(const Napi::Object& js_error) {
 }
 
 
+template <typename F, typename T = std::invoke_result_t<F>>
+T RunCallbackOnPythonEventLoop(F&& f) {
+  std::promise<T> promise;
+
+  adaptor->ScheduleCallbackOnPythonEventLoop(
+      [&f, &promise]() {
+        try {
+          if constexpr (std::is_void<T>::value) {
+            f();
+            promise.set_value();
+          } else {
+            promise.set_value(f());
+          }
+        } catch (const std::exception& e) {
+          promise.set_exception(
+              std::make_exception_ptr(
+                  std::runtime_error(e.what())));
+        }
+      });
+
+  return promise.get_future().get();
+}
+
+
+template <typename F, typename T = std::invoke_result_t<F, Napi::Env>>
+T RunCallbackOnNodeEventLoop(F&& f, bool warn = false) {
+  std::promise<T> promise;
+
+  adaptor->ScheduleCallbackOnNodeEventLoop(
+      [&f, &warn, &promise](Napi::Env env) {
+        try {
+          if constexpr (std::is_void<T>::value) {
+            f(env);
+            promise.set_value();
+          } else {
+            promise.set_value(f(env));
+          }
+        } catch (const Napi::Error& e) {
+          if (warn) {
+            env.Global()
+                .Get("console")
+                .As<Napi::Object>()
+                .Get("warn")
+                .As<Napi::Function>()
+                .Call({e.Value(), Napi::String::New(env, "\n")});
+          }
+          promise.set_exception(
+              std::make_exception_ptr(
+                  std::runtime_error(e.what())));
+        } catch (const std::exception& e) {
+          if (warn) {
+            env.Global()
+                .Get("console")
+                .As<Napi::Object>()
+                .Get("warn")
+                .As<Napi::Function>()
+                .Call(
+                    {Napi::String::New(env, e.what()),
+                     Napi::String::New(env, "\n")});
+          }
+          promise.set_exception(
+              std::make_exception_ptr(
+                  std::runtime_error(e.what())));
+        }
+      });
+
+  return promise.get_future().get();
+}
+
+
+template <typename PythonCallback, typename NodeCallback>
+Napi::Promise NodePromiseFromPythonCallback(
+    Napi::Env env,
+    PythonCallback&& python_callback,
+    NodeCallback&& node_callback) {
+  auto deferred = std::make_shared<Napi::Promise::Deferred>(env);
+  auto promise = deferred->Promise();
+
+  adaptor->ScheduleCallbackOnPythonEventLoop(
+      [python_callback = std::forward<PythonCallback>(python_callback),
+       node_callback = std::forward<NodeCallback>(node_callback),
+       deferred = std::move(deferred)]() mutable {
+        try {
+          auto result = python_callback();
+          adaptor->ScheduleCallbackOnNodeEventLoop(
+              [node_callback = std::forward<NodeCallback>(node_callback),
+               deferred = std::move(deferred),
+               result = std::move(result)](Napi::Env env) mutable {
+                try {
+                  deferred->Resolve(node_callback(env, std::move(result)));
+                } catch (const Napi::Error& e) {
+                  deferred->Reject(e.Value());
+                } catch (const std::exception& e) {
+                  // TODO: is this code unreachable because Node.js
+                  // will properly always only pass us a `Napi::Error`?
+                  deferred->Reject(
+                      Napi::Error::New(env, e.what()).Value());
+                } catch (...) {
+                  // TODO: is this code unreachable because Node.js
+                  // will properly always only pass us a `Napi::Error`?
+                  deferred->Reject(
+                      Napi::Error::New(env, "Unknown error").Value());
+                }
+              });
+        } catch (pybind11::error_already_set& e) {
+          std::string exception = py_exception_str(e.value());
+          adaptor->ScheduleCallbackOnNodeEventLoop(
+              [deferred = std::move(deferred),
+               exception = std::move(exception)](Napi::Env env) mutable {
+                deferred->Reject(Napi::Error::New(env, exception).Value());
+              });
+        }
+      });
+
+  return promise;
+}
+
+
+template <
+    typename PythonFutureCallback,
+    typename PythonDoneCallback,
+    typename NodeCallback>
+Napi::Promise NodePromiseFromPythonFuture(
+    Napi::Env env,
+    PythonFutureCallback&& python_future_callback,
+    PythonDoneCallback&& python_done_callback,
+    NodeCallback&& node_callback) {
+  auto deferred = std::make_shared<Napi::Promise::Deferred>(env);
+  auto promise = deferred->Promise();
+
+  adaptor->ScheduleCallbackOnPythonEventLoop(
+      [python_future_callback = std::forward<PythonFutureCallback>(
+           python_future_callback),
+       python_done_callback = std::forward<PythonDoneCallback>(
+           python_done_callback),
+       node_callback = std::forward<NodeCallback>(node_callback),
+       deferred = std::move(deferred)]() mutable {
+        try {
+          // TODO: check that `py_future` is a future!
+          py::object py_future = python_future_callback();
+
+          py_future.attr("add_done_callback")(py::cpp_function(
+              [python_done_callback = std::forward<PythonDoneCallback>(
+                   python_done_callback),
+               node_callback = std::forward<NodeCallback>(node_callback),
+               deferred = std::move(deferred),
+               // NOTE: need to keep a reference to `py_future` so that it
+               // doesn't get destroyed before completing!
+               py_future = new py::object(py_future)](py::object) mutable {
+                py::object py_exception = py_future->attr("exception")();
+                if (!py_exception.is_none()) {
+                  py::str py_exception_string = py_exception_str(py_exception);
+                  std::string exception = py_exception_string;
+
+                  adaptor->ScheduleCallbackOnNodeEventLoop(
+                      [deferred = std::move(deferred),
+                       exception = std::move(exception)](Napi::Env env) {
+                        deferred->Reject(
+                            Napi::Error::New(env, exception).Value());
+                      });
+                } else {
+                  // TODO: try / catch around `python_done_callback`.
+                  py::object py_result = py_future->attr("result")();
+                  auto result = python_done_callback(std::move(py_result));
+
+                  adaptor->ScheduleCallbackOnNodeEventLoop(
+                      [node_callback =
+                           std::forward<NodeCallback>(node_callback),
+                       deferred = std::move(deferred),
+                       result = std::move(result)](Napi::Env env) mutable {
+                        // TODO: try / catch around `node_callback`.
+                        auto js_result = node_callback(env, std::move(result));
+                        deferred->Resolve(js_result);
+                      });
+                }
+                delete py_future;
+              },
+              py::arg("future")));
+        } catch (pybind11::error_already_set& e) {
+          std::string exception = py_exception_str(e.value());
+          adaptor->ScheduleCallbackOnNodeEventLoop(
+              [deferred = std::move(deferred),
+               exception = std::move(exception)](Napi::Env env) mutable {
+                deferred->Reject(Napi::Error::New(env, exception).Value());
+              });
+        }
+      });
+
+  return promise;
+}
+
+
+template <typename PythonFutureCallback>
+Napi::Promise NodePromiseFromPythonFuture(
+    Napi::Env env,
+    PythonFutureCallback&& python_future_callback) {
+  return NodePromiseFromPythonFuture(
+      env,
+      std::forward<PythonFutureCallback>(python_future_callback),
+      [](py::object py_result) {
+        // TODO: check that `py_result` is `None`.
+        return std::nullopt;
+      },
+      [](Napi::Env env, std::nullopt_t) {
+        return env.Null();
+      });
+}
+
+
+template <
+    typename PythonTaskCallback,
+    typename PythonDoneCallback,
+    typename NodeCallback,
+    typename... CreateTaskArgs>
+Napi::Promise NodePromiseFromPythonTask(
+    Napi::Env env,
+    std::string&& name,
+    std::tuple<std::string, std::string, CreateTaskArgs...>&& create_task,
+    PythonTaskCallback&& python_task_callback,
+    PythonDoneCallback&& python_done_callback,
+    NodeCallback&& node_callback) {
+  return NodePromiseFromPythonFuture(
+      env,
+      [name = std::move(name),
+       create_task = std::move(create_task),
+       python_task_callback = std::forward<PythonTaskCallback>(
+           python_task_callback)]() mutable {
+        py::object py_task = std::apply(
+            [&name, &python_task_callback](
+                const std::string& import,
+                const std::string& attr,
+                auto&&... args) mutable {
+              return py::module::import(import.c_str())
+                  .attr(attr.c_str())(
+                      python_task_callback(),
+                      std::forward<decltype(args)>(args)...,
+                      "name"_a = name.c_str());
+            },
+            std::move(create_task));
+
+        return py_task;
+      },
+      std::forward<PythonDoneCallback>(python_done_callback),
+      std::forward<NodeCallback>(node_callback));
+}
+
+
+template <typename PythonTaskCallback, typename... CreateTaskArgs>
+Napi::Promise NodePromiseFromPythonTask(
+    Napi::Env env,
+    std::string&& name,
+    std::tuple<std::string, std::string, CreateTaskArgs...>&& create_task,
+    PythonTaskCallback&& python_task_callback) {
+  return NodePromiseFromPythonTask(
+      env,
+      std::move(name),
+      std::move(create_task),
+      std::forward<PythonTaskCallback>(python_task_callback),
+      [](py::object py_result) {
+        // TODO: check that `py_result` is `None`.
+        return std::nullopt;
+      },
+      [](Napi::Env env, std::nullopt_t) {
+        return env.Null();
+      });
+}
+
+
+template <
+    typename PythonTaskCallback,
+    typename PythonDoneCallback,
+    typename NodeCallback>
+Napi::Promise NodePromiseFromPythonTaskWithContext(
+    Napi::Env env,
+    std::string&& name,
+    NapiSafeReference<Napi::External<py::object>>& js_context,
+    PythonTaskCallback&& python_task_callback,
+    PythonDoneCallback&& python_done_callback,
+    NodeCallback&& node_callback) {
+  py::object* py_context = js_context.Value(env).Data();
+  return NodePromiseFromPythonTask(
+      env,
+      std::move(name),
+      std::make_tuple(
+          std::string("reboot.nodejs.python"),
+          std::string("create_task_with_context"),
+          py_context),
+      [js_context, // Ensures `py_context` remains valid.
+       python_task_callback =
+           std::forward<PythonTaskCallback>(python_task_callback)]() mutable {
+        return python_task_callback();
+      },
+      std::forward<PythonDoneCallback>(python_done_callback),
+      std::forward<NodeCallback>(node_callback));
+}
+
+
+template <typename PythonTaskCallback>
+Napi::Promise NodePromiseFromPythonTaskWithContext(
+    Napi::Env env,
+    std::string&& name,
+    NapiSafeReference<Napi::External<py::object>>& js_context,
+    PythonTaskCallback&& python_task_callback) {
+  return NodePromiseFromPythonTaskWithContext(
+      env,
+      std::move(name),
+      js_context,
+      std::forward<PythonTaskCallback>(python_task_callback),
+      [](py::object py_result) {
+        // TODO: check that `py_result` is `None`.
+        return std::nullopt;
+      },
+      [](Napi::Env env, std::nullopt_t) {
+        return env.Null();
+      });
+}
+
+
+template <
+    typename NodePromiseCallback,
+    typename NodePromiseResolvedCallback,
+    typename PythonCallback>
+py::object PythonFutureFromNodePromise(
+    NodePromiseCallback&& node_promise_callback,
+    NodePromiseResolvedCallback&& node_promise_resolved_callback,
+    PythonCallback&& python_callback) {
+  py::object py_future = py::module::import("asyncio").attr("Future")();
+
+  adaptor->ScheduleCallbackOnNodeEventLoop(
+      [node_promise_callback =
+           std::forward<NodePromiseCallback>(node_promise_callback),
+       node_promise_resolved_callback =
+           std::forward<NodePromiseResolvedCallback>(
+               node_promise_resolved_callback),
+       python_callback = std::forward<PythonCallback>(python_callback),
+       py_future = new py::object(py_future)](Napi::Env env) mutable {
+        try {
+          Napi::Object js_promise = node_promise_callback(env);
+
+          js_promise
+              .Get("then")
+              .As<Napi::Function>()
+              .Call(
+                  js_promise,
+                  {Napi::Function::New(
+                       env,
+                       [node_promise_resolved_callback =
+                            std::forward<NodePromiseResolvedCallback>(
+                                node_promise_resolved_callback),
+                        python_callback = std::forward<PythonCallback>(
+                            python_callback),
+                        py_future](const Napi::CallbackInfo& info) mutable {
+                         // TODO: put a try/catch around
+                         // `node_promise_resolved_callback` to handle
+                         // any errors.
+
+                         auto result = node_promise_resolved_callback(
+                             info.Env(),
+                             info[0]);
+
+                         adaptor->ScheduleCallbackOnPythonEventLoop(
+                             [python_callback = std::forward<PythonCallback>(
+                                  python_callback),
+                              py_future,
+                              result = std::move(result)]() mutable {
+                               bool cancelled =
+                                   py_future->attr("cancelled")().cast<bool>();
+                               if (!cancelled) {
+                                 // TODO: put a try/catch around
+                                 // `python_callback` to handle any
+                                 // errors.
+                                 py_future->attr("set_result")(
+                                     python_callback(std::move(result)));
+                               }
+                               delete py_future;
+                             });
+                       }),
+                   Napi::Function::New(
+                       env,
+                       [py_future](const Napi::CallbackInfo& info) {
+                         std::string message = message_from_js_error(
+                             info[0].As<Napi::Object>());
+
+                         adaptor->ScheduleCallbackOnPythonEventLoop(
+                             [py_future, message = std::move(message)]() {
+                               bool cancelled =
+                                   py_future->attr("cancelled")()
+                                       .cast<bool>();
+                               if (!cancelled) {
+                                 py_future->attr("set_exception")(
+                                     py::module::import("builtins")
+                                         .attr("Exception")(
+                                             message));
+                               }
+                               delete py_future;
+                             });
+                       })});
+        } catch (const std::exception& e) {
+          // NOTE: we're just catching exception here vs `Napi::Error`
+          // since all we care about is `what()` but we're making sure
+          // that we'll get all `Napi::Error` with this
+          // `static_assert`.
+          static_assert(
+              std::is_base_of<std::exception, Napi::Error>::value,
+              "Expecting `Napi::Error` to be subclass of `std::exception`");
+
+          std::string message = e.what();
+
+          adaptor->ScheduleCallbackOnPythonEventLoop(
+              [py_future, message = std::move(message)]() {
+                bool cancelled =
+                    py_future->attr("cancelled")().cast<bool>();
+                if (!cancelled) {
+                  py_future->attr("set_exception")(
+                      py::module::import("builtins")
+                          .attr("Exception")(message));
+                }
+                delete py_future;
+              });
+        } catch (...) {
+          // TODO: is this code unreachable because Node.js
+          // will properly always only pass us a `Napi::Error`?
+          adaptor->ScheduleCallbackOnPythonEventLoop(
+              [py_future]() {
+                bool cancelled =
+                    py_future->attr("cancelled")().cast<bool>();
+                if (!cancelled) {
+                  py_future->attr("set_exception")(
+                      py::module::import("builtins")
+                          .attr("Exception")("Unknown error"));
+                }
+                delete py_future;
+              });
+        }
+      });
+
+  return py_future;
+}
+
+
+template <
+    typename NodePromiseCallback,
+    typename NodePromiseResolvedCallback>
+py::object PythonFutureFromNodePromise(
+    NodePromiseCallback&& node_promise_callback,
+    NodePromiseResolvedCallback&& node_promise_resolved_callback) {
+  return PythonFutureFromNodePromise(
+      std::forward<NodePromiseCallback>(node_promise_callback),
+      std::forward<NodePromiseResolvedCallback>(
+          node_promise_resolved_callback),
+      [](auto&& result) {
+        return std::move(result);
+      });
+}
+
+
+template <typename NodePromiseCallback>
+py::object PythonFutureFromNodePromise(
+    NodePromiseCallback&& node_promise_callback) {
+  return PythonFutureFromNodePromise(
+      std::forward<NodePromiseCallback>(node_promise_callback),
+      [](Napi::Env, Napi::Value) {
+        return std::nullopt;
+      },
+      [](auto&&) {
+        return py::none();
+      });
+}
+
+
 void Initialize(const Napi::CallbackInfo& info) {
   // Ensure we only initialize once, even if nodejs tries to load
   // the module more than once.
@@ -327,17 +897,11 @@ void ImportPy(const Napi::CallbackInfo& info) {
   std::string module = info[0].As<Napi::String>().Utf8Value();
   std::string base64_encoded_rbt_py = info[1].As<Napi::String>().Utf8Value();
 
-  std::promise<void> promise;
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [&module, &base64_encoded_rbt_py, &promise]() {
+  RunCallbackOnPythonEventLoop(
+      [&module, &base64_encoded_rbt_py]() {
         py::module::import("reboot.nodejs.python")
             .attr("import_py")(module, base64_encoded_rbt_py);
-
-        promise.set_value();
       });
-
-  promise.get_future().get();
 }
 
 
@@ -401,41 +965,16 @@ std::string uint8array_to_str(const Napi::Uint8Array& arr) {
 
 
 Napi::Value Reboot_constructor(const Napi::CallbackInfo& info) {
-  std::promise<py::object*> promise;
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [&promise]() {
+  py::object* py_reboot = RunCallbackOnPythonEventLoop(
+      []() {
         py::object tests = py::module::import("reboot.aio.tests");
-        promise.set_value(new py::object(tests.attr("Reboot")()));
-      }
-      // TODO(benh): improve error handling mechanism to force all
-      // raised exceptions to be handled.
-      //
-      // [](py::error_already_set& e) {
-
-      // },
-      // [](std::exception& e) {
-
-      // },
-      // []() {
-
-      // }
-  );
-
-  py::object* py_reboot = promise.get_future().get();
+        return new py::object(tests.attr("Reboot")());
+      });
 
-  Napi::External<py::object> js_external_reboot =
-      Napi::External<py::object>::New(
-          info.Env(),
-          py_reboot,
-          [](Napi::Env, py::object* py_reboot) {
-            adaptor->ScheduleCallbackOnPythonEventLoop(
-                [py_reboot]() {
-                  delete py_reboot;
-                });
-          });
-
-  js_external_reboot.TypeTag(&reboot_aio_tests_Reboot);
+  Napi::External<py::object> js_external_reboot = make_napi_external(
+      info.Env(),
+      py_reboot,
+      &reboot_aio_tests_Reboot);
 
   return js_external_reboot;
 }
@@ -468,15 +1007,12 @@ Napi::Value Reboot_createExternalContext(const Napi::CallbackInfo& info) {
     app_internal = info[5].As<Napi::Boolean>();
   }
 
-  std::promise<py::object*> promise;
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
+  py::object* py_context = RunCallbackOnPythonEventLoop(
       [py_reboot,
        &name,
        &idempotency_seed,
        &bearer_token,
-       app_internal,
-       &promise]() {
+       app_internal]() {
         py::object py_idempotency_seed = py::none();
         if (idempotency_seed.has_value()) {
           py_idempotency_seed =
@@ -487,29 +1023,18 @@ Napi::Value Reboot_createExternalContext(const Napi::CallbackInfo& info) {
         if (bearer_token.has_value()) {
           py_bearer_token = py::str(*bearer_token);
         }
-        promise.set_value(
-            new py::object(
-                py_reboot->attr("create_external_context")(
-                    "name"_a = name,
-                    "idempotency_seed"_a = py_idempotency_seed,
-                    "bearer_token"_a = py_bearer_token,
-                    "app_internal"_a = app_internal)));
+        return new py::object(
+            py_reboot->attr("create_external_context")(
+                "name"_a = name,
+                "idempotency_seed"_a = py_idempotency_seed,
+                "bearer_token"_a = py_bearer_token,
+                "app_internal"_a = app_internal));
       });
 
-  py::object* py_context = promise.get_future().get();
-
-  Napi::External<py::object> js_external_context =
-      Napi::External<py::object>::New(
-          info.Env(),
-          py_context,
-          [](Napi::Env, py::object* py_context) {
-            adaptor->ScheduleCallbackOnPythonEventLoop(
-                [py_context]() {
-                  delete py_context;
-                });
-          });
-
-  js_external_context.TypeTag(&reboot_aio_external_ExternalContext);
+  Napi::External<py::object> js_external_context = make_napi_external(
+      info.Env(),
+      py_context,
+      &reboot_aio_external_ExternalContext);
 
   return js_from_native_external
       .Call(
@@ -518,61 +1043,6 @@ Napi::Value Reboot_createExternalContext(const Napi::CallbackInfo& info) {
 }
 
 
-struct NapiReferenceDeleter {
-  template <typename T>
-  void operator()(Napi::Reference<T>* reference) {
-    adaptor->ScheduleCallbackOnNodeEventLoop(
-        [reference](Napi::Env) {
-          delete reference;
-        });
-  }
-};
-
-
-template <typename T>
-class NapiSafeReference {
- public:
-  NapiSafeReference(T t)
-    : _reference(
-        new Napi::Reference<T>(Napi::Persistent(std::move(t))),
-        NapiReferenceDeleter()) {}
-
-  NapiSafeReference(Napi::Reference<T>&& reference)
-    : _reference(
-        new Napi::Reference<T>(std::move(reference)),
-        NapiReferenceDeleter()) {}
-
-  // Helper for getting the value of the reference. We require a
-  // `Napi::Env` to ensure we only try and get the value from within a
-  // Node thread (e.g., using the main thread or from within a NAPI
-  // thread safe function).
-  T Value(Napi::Env) {
-    return _reference->Value();
-  }
-
- private:
-  std::shared_ptr<Napi::Reference<T>> _reference;
-};
-
-using NapiSafeFunctionReference = NapiSafeReference<Napi::Function>;
-using NapiSafeObjectReference = NapiSafeReference<Napi::Object>;
-
-// For every servicer we construct a _subclass_ of our Python
-// generated Node adaptor, e.g., `GreeterServicerNodeAdaptor`, _at
-// runtime_ which we add to the following Python module. This module
-// also includes our C++ <-> Python class wrappers for storing NAPI
-// objects in Python to properly handle memory management.
-PYBIND11_EMBEDDED_MODULE(reboot_native, m) {
-  py::class_<NapiSafeFunctionReference>(
-      m,
-      "NapiSafeFunctionReference");
-
-  py::class_<NapiSafeObjectReference>(
-      m,
-      "NapiSafeObjectReference");
-}
-
-
 // NOTE: must be called within _Node_.
 Napi::Object make_js_context(
     Napi::Env& env,
@@ -580,58 +1050,34 @@ Napi::Object make_js_context(
     py::object* py_aborted,
     const std::string& kind) {
   Napi::External<py::object> js_external_context =
-      Napi::External<py::object>::New(
-          env,
-          py_context,
-          [](Napi::Env, py::object* py_context) {
-            adaptor->ScheduleCallbackOnPythonEventLoop(
-                [py_context]() {
-                  delete py_context;
-                });
-          });
-
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(env);
-
-  auto promise = deferred->Promise();
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [py_aborted, deferred = std::move(deferred)]() {
-        py_aborted->attr("add_done_callback")(py::cpp_function(
-            [deferred = std::move(deferred)](
-                py::object py_future) {
-              py::object py_exception =
-                  py_future.attr("exception")();
-
-              std::optional<std::string> exception;
-
-              if (!py_exception.is_none()) {
-                py::str py_exception_string =
-                    py_exception_str(py_exception);
-
-                exception.emplace(py_exception_string);
-              }
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [deferred = std::move(deferred),
-                   exception = std::move(exception)](
-                      Napi::Env env) {
-                    if (!exception.has_value()) {
-                      deferred->Resolve(env.Undefined());
-                    } else {
-                      deferred->Reject(
-                          Napi::Error::New(env, *exception)
-                              .Value());
-                    }
-                  });
-            }));
+      make_napi_external(env, py_context);
+
+  Napi::Promise js_aborted = NodePromiseFromPythonFuture(
+      env,
+      [py_aborted]() {
+        // After returning we won't need `py_aborted` anymore, so we
+        // make a copy on the stack so we can delete our copy on the
+        // heap.
+        py::object py_aborted_on_stack = *py_aborted;
         delete py_aborted;
+        return py_aborted_on_stack;
+      },
+      [](py::object py_result) {
+        // TODO: check that `py_result` is `None`.
+        return std::nullopt;
+      },
+      [](Napi::Env env, std::nullopt_t) {
+        // NOTE: we're explicitly returning `undefined` here instead
+        // of `null` which is the default if we were to not include
+        // this lambda or the one above.
+        return env.Undefined();
       });
 
   return js_Context_fromNativeExternal
       ->Call(
           {js_external_context,
            Napi::String::New(env, kind),
-           promise})
+           js_aborted})
       .As<Napi::Object>();
 }
 
@@ -661,21 +1107,17 @@ py::object make_py_authorizer(NapiSafeObjectReference js_authorizer) {
          py::object py_aborted,
          std::optional<std::string> bytes_state,
          std::optional<std::string> bytes_request) {
-        py::object py_future =
-            py::module::import("asyncio").attr("Future")();
-
         NapiSafeObjectReference* js_authorizer_reference =
             self.attr("_js_authorizer")
                 .cast<NapiSafeObjectReference*>();
 
-        adaptor->ScheduleCallbackOnNodeEventLoop(
+        return PythonFutureFromNodePromise(
             [js_authorizer_reference,
              py_reader_context = new py::object(py_reader_context),
              py_aborted = new py::object(py_aborted),
              method_name,
              bytes_state = std::move(bytes_state),
-             bytes_request = std::move(bytes_request),
-             py_future = new py::object(py_future)](Napi::Env env) {
+             bytes_request = std::move(bytes_request)](Napi::Env env) {
               std::vector<Napi::Value> js_args;
 
               Napi::Object js_context =
@@ -695,63 +1137,18 @@ py::object make_py_authorizer(NapiSafeObjectReference js_authorizer) {
               js_args.push_back(js_bytes_state);
               js_args.push_back(js_bytes_request);
 
-              Napi::Object js_promise =
-                  js_authorizer.Get("_authorize")
-                      .As<Napi::Function>()
-                      .Call(js_authorizer, {js_args})
-                      .As<Napi::Object>();
-
-              js_promise
-                  .Get("then")
+              return js_authorizer.Get("_authorize")
                   .As<Napi::Function>()
-                  .Call(
-                      js_promise,
-                      {Napi::Function::New(
-                           env,
-                           [py_future](
-                               const Napi::CallbackInfo& info) {
-                             Napi::Uint8Array js_bytes_decision =
-                                 info[0].As<Napi::Uint8Array>();
-
-                             std::string bytes_decision = uint8array_to_str(
-                                 js_bytes_decision);
-
-                             adaptor->ScheduleCallbackOnPythonEventLoop(
-                                 [py_future, bytes_decision]() {
-                                   bool cancelled =
-                                       py_future->attr("cancelled")()
-                                           .cast<bool>();
-                                   if (!cancelled) {
-                                     py_future->attr("set_result")(
-                                         py::bytes(bytes_decision));
-                                   }
-                                   delete py_future;
-                                 });
-                           }),
-                       Napi::Function::New(
-                           env,
-                           [py_future](const Napi::CallbackInfo& info) {
-                             std::string message = message_from_js_error(
-                                 info[0].As<Napi::Object>());
-
-                             adaptor->ScheduleCallbackOnPythonEventLoop(
-                                 [py_future,
-                                  message = std::move(message)]() {
-                                   bool cancelled =
-                                       py_future->attr("cancelled")()
-                                           .cast<bool>();
-                                   if (!cancelled) {
-                                     py_future->attr("set_exception")(
-                                         py::module::import("builtins")
-                                             .attr("Exception")(
-                                                 message));
-                                   }
-                                   delete py_future;
-                                 });
-                           })});
+                  .Call(js_authorizer, {js_args})
+                  .As<Napi::Object>();
+            },
+            [](Napi::Env env, Napi::Value js_bytes_decision) {
+              return uint8array_to_str(
+                  js_bytes_decision.As<Napi::Uint8Array>());
+            },
+            [](std::string&& bytes_decision) {
+              return py::bytes(bytes_decision);
             });
-
-        return py_future;
       },
       py::name("_authorize"),
       py::arg("method_name"),
@@ -795,7 +1192,7 @@ using ServicerDetails =
 
 // NOTE: must be called within _Node_.
 std::vector<std::shared_ptr<ServicerDetails>> make_servicer_details(
-    Napi::Env& env,
+    Napi::Env env,
     const Napi::Array& js_servicers) {
   std::vector<std::shared_ptr<ServicerDetails>> servicer_details;
 
@@ -887,13 +1284,10 @@ py::object make_py_user_servicer(
             py_self.attr("_js_servicer_constructor")
                 .cast<NapiSafeFunctionReference*>();
 
-        std::promise<NapiSafeObjectReference> promise;
-
-        adaptor->ScheduleCallbackOnNodeEventLoop(
-            [&promise,
-             py_self = new py::object(py_self),
-             js_servicer_constructor](Napi::Env env) {
-              try {
+        try {
+          return RunCallbackOnNodeEventLoop(
+              [py_self = new py::object(py_self),
+               js_servicer_constructor](Napi::Env env) {
                 Napi::Object js_servicer =
                     js_servicer_constructor->Value(env).New({});
 
@@ -901,35 +1295,16 @@ py::object make_py_user_servicer(
                 // external so that we can call `read()` and `write()`
                 // on it.
                 Napi::External<py::object> js_external_self =
-                    Napi::External<py::object>::New(
-                        env,
-                        py_self,
-                        [](Napi::Env, py::object* py_self) {
-                          adaptor->ScheduleCallbackOnPythonEventLoop(
-                              [py_self]() {
-                                delete py_self;
-                              });
-                        });
+                    make_napi_external(env, py_self);
 
                 js_servicer
                     .Get("__storeExternal")
                     .As<Napi::Function>()
                     .Call(js_servicer, {js_external_self});
 
-                promise.set_value(NapiSafeObjectReference(js_servicer));
-              } catch (const Napi::Error& e) {
-                env.Global()
-                    .Get("console")
-                    .As<Napi::Object>()
-                    .Get("log")
-                    .As<Napi::Function>()
-                    .Call({e.Value(), Napi::String::New(env, "\n")});
-                promise.set_exception(
-                    std::make_exception_ptr(std::runtime_error(e.what())));
-              }
-            });
-        try {
-          return promise.get_future().get();
+                return NapiSafeObjectReference(js_servicer);
+              },
+              /* warn = */ true);
         } catch (const std::exception& e) {
           PyErr_SetString(
               py::module::import("reboot.aio.servers")
@@ -951,18 +1326,14 @@ py::object make_py_user_servicer(
          py::object py_aborted,
          const std::string& json_state,
          const std::string& json_request) {
-        py::object py_future =
-            py::module::import("asyncio").attr("Future")();
-
-        adaptor->ScheduleCallbackOnNodeEventLoop(
+        return PythonFutureFromNodePromise(
             [&js_servicer_reference,
              kind,
              method,
              py_context = new py::object(py_context),
              py_aborted = new py::object(py_aborted),
              json_state,
-             json_request,
-             py_future = new py::object(py_future)](Napi::Env env) {
+             json_request](Napi::Env env) {
               std::vector<Napi::Value> js_args;
 
               Napi::Object js_context =
@@ -976,94 +1347,37 @@ py::object make_py_user_servicer(
               Napi::Object js_servicer =
                   js_servicer_reference.Value(env);
 
-              Napi::Object js_promise =
-                  js_servicer
-                      .Get("_" + method)
-                      .As<Napi::Function>()
-                      .Call(js_servicer, js_args)
-                      .As<Napi::Object>();
-
-              js_promise
-                  .Get("then")
+              return js_servicer
+                  .Get("_" + method)
                   .As<Napi::Function>()
-                  .Call(
-                      js_promise,
-                      {Napi::Function::New(
-                           env,
-                           [py_future](const Napi::CallbackInfo& info) {
-                             std::string json =
-                                 info[0].As<Napi::String>().Utf8Value();
-
-                             adaptor->ScheduleCallbackOnPythonEventLoop(
-                                 [py_future, json]() {
-                                   bool cancelled =
-                                       py_future->attr("cancelled")()
-                                           .cast<bool>();
-                                   if (!cancelled) {
-                                     py_future->attr("set_result")(json);
-                                   }
-                                   delete py_future;
-                                 });
-                           }),
-                       Napi::Function::New(
-                           env,
-                           [py_future](const Napi::CallbackInfo& info) {
-                             std::string message = message_from_js_error(
-                                 info[0].As<Napi::Object>());
-
-                             adaptor->ScheduleCallbackOnPythonEventLoop(
-                                 [py_future,
-                                  message = std::move(message)]() {
-                                   bool cancelled =
-                                       py_future->attr("cancelled")()
-                                           .cast<bool>();
-                                   if (!cancelled) {
-                                     py_future->attr("set_exception")(
-                                         py::module::import("builtins")
-                                             .attr("Exception")(
-                                                 message));
-                                   }
-                                   delete py_future;
-                                 });
-                           })});
+                  .Call(js_servicer, js_args)
+                  .As<Napi::Object>();
+            },
+            [](Napi::Env env, Napi::Value value) {
+              return std::string(value.As<Napi::String>().Utf8Value());
             });
-
-        return py_future;
       });
 
   // Constructs and returns an Authorizer.
   attributes["_construct_authorizer"] = py::cpp_function(
       [](NapiSafeObjectReference& js_servicer_reference) -> py::object {
-        std::promise<std::optional<NapiSafeObjectReference>> promise;
-        adaptor->ScheduleCallbackOnNodeEventLoop(
-            [&js_servicer_reference, &promise](Napi::Env env) {
-              try {
+        std::optional<NapiSafeObjectReference> js_authorizer;
+        try {
+          js_authorizer = RunCallbackOnNodeEventLoop(
+              [&js_servicer_reference](Napi::Env env)
+                  -> std::optional<NapiSafeObjectReference> {
                 Napi::Object js_servicer = js_servicer_reference.Value(env);
                 Napi::Value js_authorizer =
                     js_servicer.Get("_authorizer")
                         .As<Napi::Function>()
                         .Call(js_servicer, {});
                 if (!js_authorizer.IsNull()) {
-                  promise.set_value(
-                      NapiSafeObjectReference(
-                          js_authorizer.As<Napi::Object>()));
+                  return NapiSafeObjectReference(
+                      js_authorizer.As<Napi::Object>());
                 } else {
-                  promise.set_value(std::nullopt);
+                  return std::nullopt;
                 }
-              } catch (const Napi::Error& e) {
-                env.Global()
-                    .Get("console")
-                    .As<Napi::Object>()
-                    .Get("log")
-                    .As<Napi::Function>()
-                    .Call({e.Value(), Napi::String::New(env, "\n")});
-                promise.set_exception(
-                    std::make_exception_ptr(std::runtime_error(e.what())));
-              }
-            });
-        std::optional<NapiSafeObjectReference> js_authorizer;
-        try {
-          js_authorizer = promise.get_future().get();
+              });
         } catch (const std::exception& e) {
           PyErr_SetString(
               py::module::import("reboot.aio.servers")
@@ -1156,20 +1470,28 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
       [](py::object self,
          py::object py_reader_context,
          py::object py_aborted,
-         const std::string& token) {
-        py::object py_future =
-            py::module::import("asyncio").attr("Future")();
-
+         py::object py_token) {
         NapiSafeObjectReference* js_token_verifier_reference =
             self.attr("_js_token_verifier")
                 .cast<NapiSafeObjectReference*>();
 
-        adaptor->ScheduleCallbackOnNodeEventLoop(
+        // Converting to 'py::str' involves Python runtime access.
+        // Perform this conversion here, on the Python thread, before entering
+        // Node.
+        std::optional<std::string> token;
+        if (!py_token.is_none()) {
+          token = py::str(py_token);
+        }
+
+        return PythonFutureFromNodePromise(
             [js_token_verifier_reference,
+             // We allocate 'py_aborted' and 'py_reader_context' with 'new
+             // py::object' on the Python thread, ensuring they remain valid
+             // when passed into Node. Cleanup is handled later on the Python
+             // thread, see 'make_js_context'.
              py_reader_context = new py::object(py_reader_context),
              py_aborted = new py::object(py_aborted),
-             token,
-             py_future = new py::object(py_future)](Napi::Env env) {
+             token = std::move(token)](Napi::Env env) {
               std::vector<Napi::Value> js_args;
 
               js_args.push_back(
@@ -1179,85 +1501,49 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
                       py_aborted,
                       "reader"));
 
-              js_args.push_back(Napi::String::New(env, token));
+              if (token.has_value()) {
+                js_args.push_back(Napi::String::New(env, *token));
+              } else {
+                js_args.push_back(env.Undefined());
+              }
 
               Napi::Object js_token_verifier =
                   js_token_verifier_reference->Value(env);
-              Napi::Object js_promise =
-                  js_token_verifier
-                      .Get("_verifyToken")
-                      .As<Napi::Function>()
-                      .Call(js_token_verifier, {js_args})
-                      .As<Napi::Object>();
-
-              js_promise
-                  .Get("then")
+
+              return js_token_verifier
+                  .Get("_verifyToken")
                   .As<Napi::Function>()
-                  .Call(
-                      js_promise,
-                      {Napi::Function::New(
-                           env,
-                           [py_future](const Napi::CallbackInfo& info) {
-                             std::optional<std::string> bytes_auth;
-                             if (!info[0].IsNull()) {
-                               bytes_auth =
-                                   uint8array_to_str(
-                                       info[0].As<Napi::Uint8Array>());
-                             }
-
-                             adaptor->ScheduleCallbackOnPythonEventLoop(
-                                 [py_future, bytes_auth]() {
-                                   bool cancelled =
-                                       py_future->attr("cancelled")()
-                                           .cast<bool>();
-                                   if (!cancelled) {
-                                     if (bytes_auth.has_value()) {
-                                       py_future->attr("set_result")(
-                                           py::bytes(*bytes_auth));
-                                     } else {
-                                       py_future->attr("set_result")(
-                                           py::none());
-                                     }
-                                   }
-                                   delete py_future;
-                                 });
-                           }),
-                       Napi::Function::New(
-                           env,
-                           [py_future](const Napi::CallbackInfo& info) {
-                             std::string message = message_from_js_error(
-                                 info[0].As<Napi::Object>());
-
-                             adaptor->ScheduleCallbackOnPythonEventLoop(
-                                 [py_future,
-                                  message = std::move(message)]() {
-                                   bool cancelled =
-                                       py_future->attr("cancelled")()
-                                           .cast<bool>();
-                                   if (!cancelled) {
-                                     py_future->attr("set_exception")(
-                                         py::module::import("builtins")
-                                             .attr("Exception")(
-                                                 message));
-                                   }
-                                   delete py_future;
-                                 });
-                           })});
+                  .Call(js_token_verifier, {js_args})
+                  .As<Napi::Object>();
+            },
+            [](Napi::Env env, Napi::Value value) {
+              std::optional<std::string> bytes_auth;
+              if (!value.IsNull()) {
+                bytes_auth = uint8array_to_str(value.As<Napi::Uint8Array>());
+              }
+              return bytes_auth;
+            },
+            [](std::optional<std::string>&& bytes_auth) -> py::object {
+              if (bytes_auth.has_value()) {
+                return py::bytes(*bytes_auth);
+              } else {
+                return py::none();
+              }
             });
-
-        return py_future;
       },
       py::name("_verify_token"),
       py::arg("context"),
       py::arg("aborted"),
-      py::arg("token"),
+      py::arg("py_token"),
       py::is_method(py::none()));
 
   py::object py_parent_class =
       py::module::import("reboot.nodejs.python")
           .attr("NodeAdaptorTokenVerifier");
+
   py::object py_parent_metaclass = py::reinterpret_borrow<py::object>(
       (PyObject*) &PyType_Type);
+
   py::object py_token_verifier = py_parent_metaclass(
       "_NodeAdaptorTokenVerifier",
       py::make_tuple(py_parent_class),
@@ -1278,94 +1564,45 @@ Napi::Value Reboot_up(const Napi::CallbackInfo& info) {
 
   py::object* py_reboot = js_external_reboot.Value(info.Env()).Data();
 
-  Napi::Array js_servicers = info[1].As<Napi::Array>();
+  auto js_external_application = NapiSafeReference(
+      info[1].As<Napi::External<py::object>>());
 
-  std::optional<NapiSafeObjectReference> js_token_verifier;
-  if (info[2].IsObject()) {
-    js_token_verifier = NapiSafeReference(info[2].As<Napi::Object>());
-  }
+  py::object* py_application = js_external_application.Value(info.Env()).Data();
 
   bool local_envoy = false;
-  if (!info[3].IsUndefined()) {
-    local_envoy = info[3].As<Napi::Boolean>();
+  if (!info[2].IsUndefined()) {
+    local_envoy = info[2].As<Napi::Boolean>();
   }
 
-  auto env = info.Env();
-  auto servicer_details = make_servicer_details(env, js_servicers);
-
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(info.Env());
-
-  auto promise = deferred->Promise();
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
+  return NodePromiseFromPythonTask(
+      info.Env(),
+      "Reboot.up(...) in nodejs",
+      {"asyncio", "create_task"},
       [js_external_reboot, // Ensures `py_reboot` remains valid.
        py_reboot,
-       js_token_verifier,
-       local_envoy,
-       servicer_details = std::move(servicer_details),
-       deferred = std::move(deferred)]() {
-        py::list py_servicers = make_py_servicers(servicer_details);
-        py::object py_token_verifier = py::none();
-        if (js_token_verifier.has_value()) {
-          py_token_verifier = make_py_token_verifier(*js_token_verifier);
-        }
-
-        py::object py_task =
-            py::module::import("asyncio").attr("create_task")(
-                py_reboot->attr("up")(
-                    "servicers"_a = py_servicers,
-                    "token_verifier"_a = py_token_verifier,
-                    // NOTE: while we support subprocess consensuses
-                    // for `rbt dev` and `rbt serve` we do not support
-                    // them for tests because we don't have a way to
-                    // clone a process like we do with multiprocessing
-                    // in Python.
-                    "in_process"_a = true,
-                    "local_envoy"_a = local_envoy),
-                "name"_a = "Reboot.up(...) in nodejs");
-
-        py_task.attr("add_done_callback")(py::cpp_function(
-            [deferred = std::move(deferred),
-             // NOTE: need to keep a reference to `py_task` so that it
-             // doesn't get destroyed before completing!
-             py_task = new py::object(py_task)](py::object py_future) {
-              py::object py_exception = py_future.attr("exception")();
-
-              std::optional<std::string> application_id;
-              std::optional<std::string> exception;
-
-              if (py_exception.is_none()) {
-                py::str py_application_id =
-                    py_future.attr("result")().attr("application_id")();
-                application_id.emplace(py_application_id);
-              } else {
-                py::str py_exception_string = py_exception_str(py_exception);
-
-                exception.emplace(py_exception_string);
-              }
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [deferred = std::move(deferred),
-                   application_id = std::move(application_id),
-                   exception = std::move(exception)](Napi::Env env) {
-                    if (application_id.has_value()) {
-                      auto js_application_config = Napi::Object::New(env);
-                      js_application_config.Set(
-                          "applicationId",
-                          *application_id);
-                      deferred->Resolve(js_application_config);
-                    } else {
-                      deferred->Reject(
-                          Napi::Error::New(env, *exception).Value());
-                    }
-                  });
-
-              delete py_task;
-            },
-            py::arg("future")));
+       js_external_application, // Ensures `py_application` remains valid.
+       py_application,
+       local_envoy]() {
+        return py_reboot->attr("up")(
+            py_application,
+            // NOTE: while we support subprocess consensuses
+            // for `rbt dev` and `rbt serve` we do not support
+            // them for tests because we don't have a way to
+            // clone a process like we do with multiprocessing
+            // in Python.
+            "in_process"_a = true,
+            "local_envoy"_a = local_envoy);
+      },
+      [](py::object py_revision) {
+        py::str py_application_id =
+            py_revision.attr("config").attr("application_id")();
+        return std::string(py_application_id);
+      },
+      [](Napi::Env env, std::string&& application_id) {
+        Napi::Object js_revision = Napi::Object::New(env);
+        js_revision.Set("applicationId", application_id);
+        return js_revision;
       });
-
-  return promise;
 }
 
 void Reboot_down(const Napi::CallbackInfo& info) {
@@ -1392,49 +1629,13 @@ Napi::Value Reboot_start(const Napi::CallbackInfo& info) {
   // flag, rather than incrementing and decrementing a reference count.
   adaptor->thread_safe_function.Ref(info.Env());
 
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(info.Env());
-
-  auto promise = deferred->Promise();
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [py_reboot, deferred = std::move(deferred)]() {
-        py::object py_task =
-            py::module::import("asyncio").attr("create_task")(
-                py_reboot->attr("start")(),
-                "name"_a = "Reboot.start() in nodejs");
-
-        py_task.attr("add_done_callback")(py::cpp_function(
-            [deferred = std::move(deferred),
-             // NOTE: need to keep a reference to `py_task` so that it
-             // doesn't get destroyed before completing!
-             py_task = new py::object(py_task)](py::object py_future) {
-              py::object py_exception = py_future.attr("exception")();
-
-              std::optional<std::string> exception;
-
-              if (!py_exception.is_none()) {
-                py::str py_exception_string = py_exception_str(py_exception);
-
-                exception.emplace(py_exception_string);
-              }
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [deferred = std::move(deferred),
-                   exception = std::move(exception)](Napi::Env env) {
-                    if (!exception.has_value()) {
-                      deferred->Resolve(env.Null());
-                    } else {
-                      deferred->Reject(
-                          Napi::Error::New(env, *exception).Value());
-                    }
-                  });
-
-              delete py_task;
-            },
-            py::arg("future")));
+  return NodePromiseFromPythonTask(
+      info.Env(),
+      "Reboot.start() in nodejs",
+      {"asyncio", "create_task"},
+      [py_reboot]() {
+        return py_reboot->attr("start")();
       });
-
-  return promise;
 }
 
 Napi::Value Reboot_stop(const Napi::CallbackInfo& info) {
@@ -1448,58 +1649,34 @@ Napi::Value Reboot_stop(const Napi::CallbackInfo& info) {
 
   py::object* py_reboot = js_external_reboot.Value(info.Env()).Data();
 
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(info.Env());
-
-  auto promise = deferred->Promise();
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [py_reboot, deferred = std::move(deferred)]() {
-        py::object py_task =
-            py::module::import("asyncio").attr("create_task")(
-                py_reboot->attr("stop")(),
-                "name"_a = "Reboot.stop() in nodejs");
-
-        py_task.attr("add_done_callback")(py::cpp_function(
-            [deferred = std::move(deferred),
-             // NOTE: need to keep a reference to `py_task` so that it
-             // doesn't get destroyed before completing!
-             py_task = new py::object(py_task)](py::object py_future) {
-              py::object py_exception = py_future.attr("exception")();
-
-              std::optional<std::string> exception;
-
-              if (!py_exception.is_none()) {
-                py::str py_exception_string = py_exception_str(py_exception);
-
-                exception.emplace(py_exception_string);
-              }
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [deferred = std::move(deferred),
-                   exception = std::move(exception)](Napi::Env env) {
-                    if (!exception.has_value()) {
-                      deferred->Resolve(env.Null());
-                    } else {
-                      deferred->Reject(
-                          Napi::Error::New(env, *exception).Value());
-                    }
-                    // Call Unref() on our NAPI thread safe function so that the
-                    // object can be destroyed and the event loop can exit.
-                    // See:
-                    // (check_line_length skip)
-                    // https://nodejs.github.io/node-addon-examples/special-topics/thread-safe-functions/#q-my-application-isnt-exiting-correctly-it-just-hangs.
-                    // Note that Ref() and Unref() will set and unset an
-                    // "is_referenced" boolean flag, rather than incrementing
-                    // and decrementing a reference count.
-                    adaptor->thread_safe_function.Unref(env);
-                  });
+  Napi::Promise js_promise = NodePromiseFromPythonTask(
+      info.Env(),
+      "Reboot.stop() in nodejs",
+      {"asyncio", "create_task"},
+      [py_reboot]() {
+        return py_reboot->attr("stop")();
+      });
 
-              delete py_task;
-            },
-            py::arg("future")));
+  // Call Unref() on our NAPI thread safe function so that the
+  // object can be destroyed and the event loop can exit.
+  // See:
+  // (check_line_length skip)
+  // https://nodejs.github.io/node-addon-examples/special-topics/thread-safe-functions/#q-my-application-isnt-exiting-correctly-it-just-hangs.
+  // Note that Ref() and Unref() will set and unset an
+  // "is_referenced" boolean flag, rather than incrementing
+  // and decrementing a reference count.
+  auto js_resolve_reject = Napi::Function::New(
+      info.Env(),
+      [](const Napi::CallbackInfo& info) {
+        adaptor->thread_safe_function.Unref(info.Env());
       });
 
-  return promise;
+  js_promise
+      .Get("then")
+      .As<Napi::Function>()
+      .Call(js_promise, {js_resolve_reject, js_resolve_reject});
+
+  return js_promise;
 }
 
 // NOTE: We block on a promise here, so this method should not be called outside
@@ -1515,15 +1692,13 @@ Napi::Value Reboot_url(const Napi::CallbackInfo& info) {
 
   py::object* py_reboot = js_external_reboot.Value(info.Env()).Data();
 
-  std::promise<std::string> promise;
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [py_reboot, &promise]() {
+  std::string url = RunCallbackOnPythonEventLoop(
+      [py_reboot]() {
         py::str url = py_reboot->attr("url")();
-        promise.set_value(std::string(url));
+        return std::string(url);
       });
 
-  return Napi::String::New(info.Env(), promise.get_future().get());
+  return Napi::String::New(info.Env(), url);
 }
 
 Napi::Value Service_constructor(const Napi::CallbackInfo& info) {
@@ -1537,35 +1712,22 @@ Napi::Value Service_constructor(const Napi::CallbackInfo& info) {
 
   std::string id = js_args.Get("id").As<Napi::String>().Utf8Value();
 
-  std::promise<py::object*> promise;
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [&rbt_module, &node_adaptor, &id, &promise]() {
+  py::object* py_service = RunCallbackOnPythonEventLoop(
+      [&rbt_module, &node_adaptor, &id]() {
         py::object py_module = py::module::import(rbt_module.c_str());
         py::object py_schedule_type =
             py_module
                 .attr(node_adaptor.c_str())
                 .attr("_Schedule");
-        promise.set_value(
-            new py::object(py_module.attr(node_adaptor.c_str())(
-                // The call will stay within the same application.
-                "application_id"_a = py::none(),
-                "state_id"_a = id,
-                "schedule_type"_a = py_schedule_type)));
+        return new py::object(py_module.attr(node_adaptor.c_str())(
+            // The call will stay within the same application.
+            "application_id"_a = py::none(),
+            "state_id"_a = id,
+            "schedule_type"_a = py_schedule_type));
       });
 
-  py::object* py_service = promise.get_future().get();
-
   Napi::External<py::object> js_external_service =
-      Napi::External<py::object>::New(
-          info.Env(),
-          py_service,
-          [](Napi::Env, py::object* py_service) {
-            adaptor->ScheduleCallbackOnPythonEventLoop(
-                [py_service]() {
-                  delete py_service;
-                });
-          });
+      make_napi_external(info.Env(), py_service);
 
   // auto type_tag = MakeTypeTag(module, type);
   // js_external_service.TypeTag(&type_tag);
@@ -1607,23 +1769,20 @@ Napi::Value Service_call(const Napi::CallbackInfo& info) {
 
   std::string json_options = js_args.Get("jsonOptions").As<Napi::String>();
 
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(info.Env());
-
-  auto promise = deferred->Promise();
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
+  return NodePromiseFromPythonTaskWithContext(
+      info.Env(),
+      "servicer._" + kind + "(\"" + method + "\", ...) in nodejs",
+      js_external_context,
       [js_external_service, // Ensures `py_service` remains valid.
        py_service,
        kind,
        method,
        request_module,
        request_type,
-       // Ensures `py_context` remains valid.
-       js_external_context,
+       js_external_context, // Ensures `py_context` remains valid.
        py_context,
        json_request,
-       json_options,
-       deferred = std::move(deferred)]() {
+       json_options]() {
         // If a type is a nested message type, we can't import it directly
         // as 'from module import Foo.Bar.Baz', instead we need to import the
         // top level 'Foo' and call 'Foo.Bar.Baz' on it.
@@ -1640,73 +1799,25 @@ Napi::Value Service_call(const Napi::CallbackInfo& info) {
           py_request_type = py_request_type.attr(part.c_str());
         }
 
-        py::object py_task =
-            py::module::import("reboot.nodejs.python")
-                .attr("create_task_with_context")(
-                    py_service->attr(("_" + kind).c_str())(
-                        method,
-                        py_context,
-                        py_request_type,
-                        json_request,
-                        json_options),
-                    py_context,
-                    "name"_a = ("servicer._" + kind
-                                + "(\"" + method + "\", ...) in nodejs")
-                                   .c_str());
-
-        py_task.attr("add_done_callback")(py::cpp_function(
-            [deferred = std::move(deferred),
-             // NOTE: need to keep a reference to `py_task` so that it
-             // doesn't get destroyed before completing!
-             py_task = new py::object(py_task)](py::object py_future) {
-              py::object py_exception = py_future.attr("exception")();
-
-              std::optional<std::string> json;
-              std::optional<std::string> exception;
-
-              if (py_exception.is_none()) {
-                py::str py_json = py_future.attr("result")();
-                json.emplace(py_json);
-              } else {
-                py::str py_exception_string = py_exception_str(py_exception);
-
-                exception.emplace(py_exception_string);
-              }
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [deferred = std::move(deferred),
-                   json = std::move(json),
-                   exception = std::move(exception)](Napi::Env env) {
-                    if (json.has_value()) {
-                      deferred->Resolve(
-                          Napi::String::New(env, *json));
-                    } else {
-                      deferred->Reject(
-                          Napi::Error::New(env, *exception).Value());
-                    }
-                  });
-
-              delete py_task;
-            }));
+        return py_service->attr(("_" + kind).c_str())(
+            method,
+            py_context,
+            py_request_type,
+            json_request,
+            json_options);
+      },
+      [](py::object py_json) {
+        return py_json.cast<std::string>();
+      },
+      [](Napi::Env env, std::string&& json) {
+        return Napi::String::New(env, json);
       });
-
-  return promise;
 }
 
 
-Napi::Value Future_await(const Napi::CallbackInfo& info) {
+Napi::Value Task_await(const Napi::CallbackInfo& info) {
   Napi::Object js_args = info[0].As<Napi::Object>();
 
-  // NOTE: we immediately get a safe reference to the `Napi::External`
-  // so that Node will not garbage collect it and the `py::object*` we
-  // get out of it will remain valid.
-  auto js_external_service = NapiSafeReference(
-      js_args.Get("external").As<Napi::External<py::object>>());
-
-  // CHECK(js_external_service.CheckTypeTag(...));
-
-  py::object* py_service = js_external_service.Value(info.Env()).Data();
-
   // NOTE: we immediately get a safe reference to the `Napi::External`
   // so that Node will not garbage collect it and the `py::object*` we
   // get out of it will remain valid.
@@ -1718,71 +1829,40 @@ Napi::Value Future_await(const Napi::CallbackInfo& info) {
   py::object* py_context =
       js_external_context.Value(info.Env()).Data();
 
-  std::string method = js_args.Get("method").As<Napi::String>();
+  std::string rbt_module = js_args.Get("rbtModule").As<Napi::String>();
 
-  std::string json_task_id = js_args.Get("jsonTaskId").As<Napi::String>();
+  std::string state_name = js_args.Get("stateName").As<Napi::String>();
 
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(info.Env());
+  std::string method = js_args.Get("method").As<Napi::String>();
 
-  auto promise = deferred->Promise();
+  std::string json_task_id = js_args.Get("jsonTaskId").As<Napi::String>();
 
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [js_external_service, // Ensures `py_service` remains valid.
-       py_service,
-       method,
-       // Ensures `py_context` remains valid.
-       js_external_context,
+  return NodePromiseFromPythonTaskWithContext(
+      info.Env(),
+      "reboot.nodejs.python.task_await(\""
+          + state_name + "\", \""
+          + method + "\", ...) in nodejs",
+      js_external_context,
+      [rbt_module = std::move(rbt_module),
+       state_name = std::move(state_name),
+       method = std::move(method),
+       js_external_context, // Ensures `py_context` remains valid.
        py_context,
-       json_task_id,
-       deferred = std::move(deferred)]() {
-        py::object py_task =
-            py::module::import("reboot.nodejs.python")
-                .attr("create_task_with_context")(
-                    py_service->attr("_future_await")(
-                        method,
-                        py_context,
-                        json_task_id),
-                    py_context,
-                    "name"_a = ("servicer._future_await(\""
-                                + method + "\", ...) in nodejs")
-                                   .c_str());
-        py_task.attr("add_done_callback")(py::cpp_function(
-            [deferred = std::move(deferred),
-             // NOTE: need to keep a reference to `py_task` so that it
-             // doesn't get destroyed before completing!
-             py_task = new py::object(py_task)](py::object py_future) {
-              py::object py_exception = py_future.attr("exception")();
-
-              std::optional<std::string> json;
-              std::optional<std::string> exception;
-
-              if (py_exception.is_none()) {
-                py::str py_json = py_future.attr("result")();
-                json.emplace(py_json);
-              } else {
-                py::str py_exception_string = py_exception_str(py_exception);
-
-                exception.emplace(py_exception_string);
-              }
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [deferred = std::move(deferred),
-                   json = std::move(json),
-                   exception = std::move(exception)](Napi::Env env) {
-                    if (json.has_value()) {
-                      deferred->Resolve(
-                          Napi::String::New(env, *json));
-                    } else {
-                      deferred->Reject(
-                          Napi::Error::New(env, *exception).Value());
-                    }
-                  });
-
-              delete py_task;
-            }));
+       json_task_id]() {
+        return py::module::import("reboot.nodejs.python")
+            .attr("task_await")(
+                py_context,
+                py::module::import(rbt_module.c_str())
+                    .attr(state_name.c_str()),
+                method,
+                json_task_id);
+      },
+      [](py::object py_json) {
+        return py_json.cast<std::string>();
+      },
+      [](Napi::Env env, std::string&& json) {
+        return Napi::String::New(env, json);
       });
-
-  return promise;
 }
 
 Napi::Value ExternalContext_constructor(const Napi::CallbackInfo& info) {
@@ -1816,11 +1896,8 @@ Napi::Value ExternalContext_constructor(const Napi::CallbackInfo& info) {
             .Utf8Value();
   }
 
-  std::promise<py::object*> promise;
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [&promise,
-       &name,
+  py::object* py_external_context = RunCallbackOnPythonEventLoop(
+      [&name,
        &url,
        &bearer_token,
        &idempotency_seed,
@@ -1830,8 +1907,7 @@ Napi::Value ExternalContext_constructor(const Napi::CallbackInfo& info) {
             "reboot.aio.external");
 
         auto convert_str =
-            [](
-                const std::optional<std::string>& optional) -> py::object {
+            [](const std::optional<std::string>& optional) -> py::object {
           if (optional.has_value()) {
             return py::str(*optional);
           } else {
@@ -1839,30 +1915,20 @@ Napi::Value ExternalContext_constructor(const Napi::CallbackInfo& info) {
           }
         };
 
-        promise.set_value(
-            new py::object(py_external.attr("ExternalContext")(
-                "name"_a = py::str(name),
-                "url"_a = convert_str(url),
-                "bearer_token"_a = convert_str(bearer_token),
-                "idempotency_seed"_a = convert_str(idempotency_seed),
-                "idempotency_required"_a = py::bool_(idempotency_required),
-                "idempotency_required_reason"_a = convert_str(
-                    idempotency_required_reason))));
+        return new py::object(py_external.attr("ExternalContext")(
+            "name"_a = py::str(name),
+            "url"_a = convert_str(url),
+            "bearer_token"_a = convert_str(bearer_token),
+            "idempotency_seed"_a = convert_str(idempotency_seed),
+            "idempotency_required"_a = py::bool_(idempotency_required),
+            "idempotency_required_reason"_a = convert_str(
+                idempotency_required_reason)));
       });
-  py::object* py_external_context = promise.get_future().get();
 
-  Napi::External<py::object> js_external_context =
-      Napi::External<py::object>::New(
-          info.Env(),
-          py_external_context,
-          [](Napi::Env, py::object* py_external_context) {
-            adaptor->ScheduleCallbackOnPythonEventLoop(
-                [py_external_context]() {
-                  delete py_external_context;
-                });
-          });
-
-  js_external_context.TypeTag(&reboot_aio_external_ExternalContext);
+  Napi::External<py::object> js_external_context = make_napi_external(
+      info.Env(),
+      py_external_context,
+      &reboot_aio_external_ExternalContext);
 
   return js_external_context;
 }
@@ -1873,62 +1939,190 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
 
   Napi::Array js_servicers = info[1].As<Napi::Array>();
 
-  auto env = info.Env();
-  auto servicer_details = make_servicer_details(env, js_servicers);
+  Napi::Object js_web_framework = info[2].As<Napi::Object>();
+
+  auto js_web_framework_start = NapiSafeFunctionReference(
+      js_web_framework.Get("start").As<Napi::Function>());
+
+  auto js_web_framework_stop = NapiSafeFunctionReference(
+      js_web_framework.Get("stop").As<Napi::Function>());
+
+  auto servicer_details = make_servicer_details(info.Env(), js_servicers);
 
   auto js_initialize = NapiSafeFunctionReference(
-      info[2].As<Napi::Function>());
+      info[3].As<Napi::Function>());
 
   std::optional<std::string> initialize_bearer_token;
-  if (!info[3].IsUndefined()) {
-    initialize_bearer_token = info[3].As<Napi::String>().Utf8Value();
+  if (!info[4].IsUndefined()) {
+    initialize_bearer_token = info[4].As<Napi::String>().Utf8Value();
   }
 
   std::optional<NapiSafeObjectReference> js_token_verifier;
-  if (!info[4].IsUndefined()) {
-    js_token_verifier = NapiSafeReference(info[4].As<Napi::Object>());
+  if (!info[5].IsUndefined()) {
+    js_token_verifier = NapiSafeReference(info[5].As<Napi::Object>());
   }
 
-  std::promise<py::object*> promise;
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [&promise,
-       servicer_details = std::move(servicer_details),
+  py::object* py_application = RunCallbackOnPythonEventLoop(
+      [servicer_details = std::move(servicer_details),
+       js_web_framework_start = std::move(js_web_framework_start),
+       js_web_framework_stop = std::move(js_web_framework_stop),
        initialize_bearer_token = std::move(initialize_bearer_token),
        js_initialize = std::move(js_initialize),
        js_token_verifier,
        js_from_native_external = std::move(js_from_native_external)]() {
         py::list py_servicers = make_py_servicers(servicer_details);
 
+        py::object py_web_framework_start = py::cpp_function(
+            [js_web_framework_start = std::move(js_web_framework_start),
+             js_from_native_external /* Need a copy because it is shared. */](
+                std::string consensus_id,
+                py::object py_port,
+                py::object py_channel_manager) {
+              std::optional<int> port;
+              if (!py_port.is_none()) {
+                port = py_port.cast<int>();
+              }
+
+              return PythonFutureFromNodePromise(
+                  [js_web_framework_start = std::move(js_web_framework_start),
+                   js_from_native_external = std::move(js_from_native_external),
+                   consensus_id = std::move(consensus_id),
+                   port,
+                   py_channel_manager = new py::object(py_channel_manager)](
+                      Napi::Env env) mutable {
+                    Napi::External<py::object> js_external_channel_manager =
+                        make_napi_external(env, py_channel_manager);
+
+                    Napi::Function js_create_external_context =
+                        Napi::Function::New(
+                            env,
+                            [js_from_native_external = std::move(
+                                 js_from_native_external),
+                             // Ensures `py_channel_manager` remains valid.
+                             js_external_channel_manager = NapiSafeReference(
+                                 js_external_channel_manager)](
+                                const Napi::CallbackInfo& info) mutable {
+                              Napi::Object js_args = info[0].As<Napi::Object>();
+
+                              std::string name =
+                                  js_args
+                                      .Get("name")
+                                      .As<Napi::String>()
+                                      .Utf8Value();
+
+                              std::optional<std::string> bearer_token;
+                              if (!js_args.Get("bearerToken").IsUndefined()) {
+                                bearer_token =
+                                    js_args.Get("bearerToken")
+                                        .As<Napi::String>()
+                                        .Utf8Value();
+                              }
+
+                              py::object* py_channel_manager =
+                                  js_external_channel_manager
+                                      .Value(info.Env())
+                                      .Data();
+
+                              return NodePromiseFromPythonCallback(
+                                  info.Env(),
+                                  [js_from_native_external,
+                                   name = std::move(name),
+                                   bearer_token = std::move(bearer_token),
+                                   // Ensures `py_channel_manager`
+                                   // remains valid. Need a copy
+                                   // because
+                                   // `js_create_external_context` may
+                                   // get called more than once.
+                                   js_external_channel_manager,
+                                   py_channel_manager]() mutable {
+                                    py::object py_bearer_token = py::none();
+                                    if (bearer_token.has_value()) {
+                                      py_bearer_token = py::str(*bearer_token);
+                                    }
+
+                                    return new py::object(
+                                        py::module::import(
+                                            "reboot.aio.external")
+                                            .attr("ExternalContext")(
+                                                "name"_a = py::str(name),
+                                                "channel_manager"_a =
+                                                    py_channel_manager,
+                                                "bearer_token"_a =
+                                                    py_bearer_token));
+                                  },
+                                  [js_from_native_external = std::move(
+                                       js_from_native_external)](
+                                      Napi::Env env,
+                                      py::object* py_context) {
+                                    // (check_line_length skip)
+                                    Napi::External<py::object> js_external_context =
+                                        make_napi_external(
+                                            env,
+                                            py_context,
+                                            // (check_line_length skip)
+                                            &reboot_aio_external_ExternalContext);
+
+                                    return js_from_native_external
+                                        .Value(env)
+                                        .Call(
+                                            env.Global(),
+                                            {js_external_context});
+                                  });
+                            });
+
+                    return js_web_framework_start
+                        .Value(env)
+                        .Call(
+                            env.Global(),
+                            {Napi::String::New(env, consensus_id),
+                             port.has_value()
+                                 ? Napi::Number::New(env, *port)
+                                 : env.Null(),
+                             js_create_external_context})
+                        .As<Napi::Object>();
+                  },
+                  [](Napi::Env env, Napi::Value value) {
+                    Napi::Number js_port = value.As<Napi::Number>();
+                    return js_port.Int32Value();
+                  });
+            });
+
+        py::object py_web_framework_stop = py::cpp_function(
+            [js_web_framework_stop = std::move(js_web_framework_stop)](
+                std::string consensus_id) {
+              return PythonFutureFromNodePromise(
+                  [js_web_framework_stop = std::move(js_web_framework_stop),
+                   consensus_id = std::move(consensus_id)](
+                      Napi::Env env) mutable {
+                    return js_web_framework_stop
+                        .Value(env)
+                        .Call(
+                            env.Global(),
+                            {Napi::String::New(env, consensus_id)})
+                        .As<Napi::Object>();
+                  });
+            });
+
         py::object py_initialize = py::cpp_function(
             [js_initialize = std::move(js_initialize),
-             js_from_native_external = std::move(js_from_native_external)](
+             js_from_native_external /* Need a copy because it is shared. */](
                 py::object py_context) mutable {
-              py::object py_future =
-                  py::module::import("asyncio").attr("Future")();
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [js_initialize, // NOTE: need a _copy_ of
-                                  // `js_initialize` here since
-                                  // `py_initialize` may be called more
-                                  // than once!
-                   js_from_native_external = std::move(js_from_native_external),
-                   py_context = new py::object(py_context),
-                   py_future = new py::object(py_future)](
+              return PythonFutureFromNodePromise(
+                  [js_initialize,
+                   js_from_native_external, // NOTE: need a _copy_ of
+                                            // both `js_initialize`
+                                            // and
+                                            // `js_from_native_external`
+                                            // here since
+                                            // `py_initialize` may be
+                                            // called more than once!
+                   py_context = new py::object(py_context)](
                       Napi::Env env) mutable {
                     Napi::External<py::object> js_external_context =
-                        Napi::External<py::object>::New(
+                        make_napi_external(
                             env,
                             py_context,
-                            [](Napi::Env, py::object* py_context) {
-                              adaptor->ScheduleCallbackOnPythonEventLoop(
-                                  [py_context]() {
-                                    delete py_context;
-                                  });
-                            });
-
-                    js_external_context.TypeTag(
-                        &reboot_aio_external_ExternalContext);
+                            &reboot_aio_external_ExternalContext);
 
                     Napi::Object js_context =
                         js_from_native_external
@@ -1938,57 +2132,11 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
                                 {js_external_context})
                             .As<Napi::Object>();
 
-                    Napi::Object js_promise =
-                        js_initialize
-                            .Value(env)
-                            .Call(env.Global(), {js_context})
-                            .As<Napi::Object>();
-
-                    js_promise
-                        .Get("then")
-                        .As<Napi::Function>()
-                        .Call(
-                            js_promise,
-                            {Napi::Function::New(
-                                 env,
-                                 [py_future](const Napi::CallbackInfo& info) {
-                                   adaptor->ScheduleCallbackOnPythonEventLoop(
-                                       [py_future]() {
-                                         bool cancelled =
-                                             py_future
-                                                 ->attr("cancelled")()
-                                                 .cast<bool>();
-                                         if (!cancelled) {
-                                           py_future->attr("set_result")(
-                                               py::none());
-                                         }
-                                         delete py_future;
-                                       });
-                                 }),
-                             Napi::Function::New(
-                                 env,
-                                 [py_future](const Napi::CallbackInfo& info) {
-                                   std::string message = message_from_js_error(
-                                       info[0].As<Napi::Object>());
-
-                                   adaptor->ScheduleCallbackOnPythonEventLoop(
-                                       [py_future,
-                                        message = std::move(message)]() {
-                                         bool cancelled =
-                                             py_future->attr("cancelled")()
-                                                 .cast<bool>();
-                                         if (!cancelled) {
-                                           py_future->attr("set_exception")(
-                                               py::module::import("builtins")
-                                                   .attr("Exception")(
-                                                       message));
-                                         }
-                                         delete py_future;
-                                       });
-                                 })});
+                    return js_initialize
+                        .Value(env)
+                        .Call(env.Global(), {js_context})
+                        .As<Napi::Object>();
                   });
-
-              return py_future;
             });
 
         py::object py_initialize_bearer_token = py::none();
@@ -2001,44 +2149,22 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
           py_token_verifier = make_py_token_verifier(*js_token_verifier);
         }
 
-        promise.set_value(
-            new py::object(
-                py::module::import("reboot.aio.applications")
-                    .attr("Application")(
-                        "servicers"_a = py_servicers,
-                        "initialize"_a = py_initialize,
-                        "initialize_bearer_token"_a =
-                            py_initialize_bearer_token,
-                        "token_verifier"_a = py_token_verifier)));
-      }
-      // TODO(benh): improve error handling mechanism to force all
-      // raised exceptions to be handled.
-      //
-      // [](py::error_already_set& e) {
-
-      // },
-      // [](std::exception& e) {
-
-      // },
-      // []() {
-
-      // }
-  );
-
-  py::object* py_application = promise.get_future().get();
-
-  Napi::External<py::object> js_external_application =
-      Napi::External<py::object>::New(
-          info.Env(),
-          py_application,
-          [](Napi::Env, py::object* py_application) {
-            adaptor->ScheduleCallbackOnPythonEventLoop(
-                [py_application]() {
-                  delete py_application;
-                });
-          });
+        return new py::object(
+            py::module::import("reboot.aio.applications")
+                .attr("NodeApplication")(
+                    "servicers"_a = py_servicers,
+                    "web_framework_start"_a = py_web_framework_start,
+                    "web_framework_stop"_a = py_web_framework_stop,
+                    "initialize"_a = py_initialize,
+                    "initialize_bearer_token"_a =
+                        py_initialize_bearer_token,
+                    "token_verifier"_a = py_token_verifier));
+      });
 
-  js_external_application.TypeTag(&reboot_aio_applications_Application);
+  Napi::External<py::object> js_external_application = make_napi_external(
+      info.Env(),
+      py_application,
+      &reboot_aio_applications_Application);
 
   return js_external_application;
 }
@@ -2061,58 +2187,45 @@ Napi::Value Application_run(const Napi::CallbackInfo& info) {
   py::object* py_application =
       js_external_application.Value(info.Env()).Data();
 
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(info.Env());
-
-  auto promise = deferred->Promise();
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
+  Napi::Promise js_promise = NodePromiseFromPythonTask(
+      info.Env(),
+      "Application.run() in nodejs",
+      {"reboot.nodejs.python", "create_task"},
       [js_external_application, // Ensures `py_application` remains valid.
-       py_application,
-       deferred = std::move(deferred)]() {
-        py::object py_task =
-            py::module::import("reboot.nodejs.python")
-                .attr("create_task")(
-                    py_application->attr("run")(),
-                    "name"_a = "Application.run() in nodejs");
-
-        py_task.attr("add_done_callback")(py::cpp_function(
-            [deferred = std::move(deferred),
-             // NOTE: need to keep a reference to `py_task` so that it
-             // doesn't get destroyed before completing!
-             py_task = new py::object(py_task)](py::object py_future) {
-              py::object py_exception = py_future.attr("exception")();
-
-              std::optional<std::string> exception;
-
-              if (!py_exception.is_none()) {
-                py::str py_exception_string = py_exception_str(py_exception);
-
-                exception.emplace(py_exception_string);
-              }
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [deferred = std::move(deferred),
-                   exception = std::move(exception)](Napi::Env env) {
-                    if (!exception.has_value()) {
-                      deferred->Resolve(env.Null());
-                    } else {
-                      env.Global()
-                          .Get("process")
-                          .As<Napi::Object>()
-                          .Set("exitCode", 1);
-                      deferred->Reject(
-                          Napi::Error::New(env, *exception).Value());
-                    }
-                    // When `Application.run` exits, we unref our
-                    // thread_safe_function to cause the runtime to exit.
-                    adaptor->thread_safe_function.Unref(env);
-                  });
-
-              delete py_task;
-            }));
+       py_application]() {
+        return py_application->attr("run")();
       });
 
-  return promise;
+  // More to do if `Application.run` returns ...
+  js_promise
+      .Get("then")
+      .As<Napi::Function>()
+      .Call(
+          js_promise,
+          {Napi::Function::New(
+               info.Env(),
+               [](const Napi::CallbackInfo& info) {
+                 // When `Application.run` exits, we unref our
+                 // thread_safe_function to cause the runtime to exit.
+                 adaptor->thread_safe_function.Unref(info.Env());
+               }),
+           Napi::Function::New(
+               info.Env(),
+               [](const Napi::CallbackInfo& info) {
+                 // There was an error, let's also set the
+                 // `process.exitCode` to reflect this.
+                 info.Env()
+                     .Global()
+                     .Get("process")
+                     .As<Napi::Object>()
+                     .Set("exitCode", 1);
+
+                 // When `Application.run` exits, we unref our
+                 // thread_safe_function to cause the runtime to exit.
+                 adaptor->thread_safe_function.Unref(info.Env());
+               })});
+
+  return js_promise;
 }
 
 
@@ -2124,22 +2237,18 @@ Napi::Value Context_auth(const Napi::CallbackInfo& info) {
 
   py::object* py_context = js_external_context.Data();
 
-  std::promise<std::optional<std::string>> promise;
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [py_context, &promise]() {
+  std::optional<std::string> auth_bytes = RunCallbackOnPythonEventLoop(
+      [py_context]() -> std::optional<std::string> {
         py::object py_auth = py_context->attr("auth");
 
         if (py_auth.is_none()) {
-          promise.set_value(std::nullopt);
+          return std::nullopt;
         } else {
           std::string auth_bytes = py::bytes(py_auth.attr("to_proto_bytes")());
-          promise.set_value(auth_bytes);
+          return auth_bytes;
         }
       });
 
-  std::optional<std::string> auth_bytes = promise.get_future().get();
-
   if (auth_bytes.has_value()) {
     Napi::Env env = info.Env();
     return str_to_uint8array(env, *auth_bytes);
@@ -2157,15 +2266,13 @@ Napi::Value Context_stateId(const Napi::CallbackInfo& info) {
 
   py::object* py_context = js_external_context.Data();
 
-  std::promise<std::string> promise;
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [py_context, &promise]() {
+  std::string state_id = RunCallbackOnPythonEventLoop(
+      [py_context]() {
         py::str state_id = py_context->attr("state_id");
-        promise.set_value(std::string(state_id));
+        return std::string(state_id);
       });
 
-  return Napi::String::New(info.Env(), promise.get_future().get());
+  return Napi::String::New(info.Env(), state_id);
 }
 
 
@@ -2177,21 +2284,17 @@ Napi::Value Context_iteration(const Napi::CallbackInfo& info) {
 
   py::object* py_context = js_external_context.Data();
 
-  std::promise<std::optional<int>> promise;
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [py_context, &promise]() {
+  std::optional<int> iteration = RunCallbackOnPythonEventLoop(
+      [py_context]() -> std::optional<int> {
         py::object iteration = py_context->attr("iteration");
 
         if (iteration.is_none()) {
-          promise.set_value(std::optional<int>());
+          return std::nullopt;
         } else {
-          promise.set_value(iteration.cast<int>());
+          return iteration.cast<int>();
         }
       });
 
-  std::optional<int> iteration = promise.get_future().get();
-
   if (iteration.has_value()) {
     return Napi::Number::New(info.Env(), *iteration);
   } else {
@@ -2200,6 +2303,41 @@ Napi::Value Context_iteration(const Napi::CallbackInfo& info) {
 }
 
 
+Napi::Value Context_cookie(const Napi::CallbackInfo& info) {
+  Napi::External<py::object> js_external_context =
+      info[0].As<Napi::External<py::object>>();
+
+  // CHECK(...CheckTypeTag(...));
+
+  py::object* py_context = js_external_context.Data();
+
+  std::string cookie = RunCallbackOnPythonEventLoop(
+      [py_context]() {
+        py::str cookie = py_context->attr("cookie");
+        return std::string(cookie);
+      });
+
+  return Napi::String::New(info.Env(), cookie);
+}
+
+
+Napi::Value Context_appInternal(const Napi::CallbackInfo& info) {
+  Napi::External<py::object> js_external_context =
+      info[0].As<Napi::External<py::object>>();
+
+  // CHECK(...CheckTypeTag(...));
+
+  py::object* py_context = js_external_context.Data();
+
+  bool app_internal = RunCallbackOnPythonEventLoop(
+      [py_context]() {
+        return py_context->attr("app_internal").cast<bool>();
+      });
+
+  return Napi::Boolean::New(info.Env(), app_internal);
+}
+
+
 Napi::Value Context_generateIdempotentStateId(const Napi::CallbackInfo& info) {
   // NOTE: we immediately get a safe reference to the `Napi::External`
   // so that Node will not garbage collect it and the `py::object*` we
@@ -2231,19 +2369,15 @@ Napi::Value Context_generateIdempotentStateId(const Napi::CallbackInfo& info) {
     alias = js_alias.As<Napi::String>().Utf8Value();
   }
 
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(info.Env());
-
-  auto promise = deferred->Promise();
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
+  return NodePromiseFromPythonCallback(
+      info.Env(),
       [js_external_context, // Ensures `py_context` remains valid.
        py_context,
        state_type = std::move(state_type),
        service_name = std::move(service_name),
        method = std::move(method),
        key = std::move(key),
-       alias = std::move(alias),
-       deferred = std::move(deferred)]() {
+       alias = std::move(alias)]() {
         py::object py_key = py::none();
         if (key.has_value()) {
           py_key = py::cast(*key);
@@ -2259,34 +2393,20 @@ Napi::Value Context_generateIdempotentStateId(const Napi::CallbackInfo& info) {
                 "key"_a = py_key,
                 "alias"_a = py_alias));
 
-        py::object generate_idempotent_state_id =
+        py::object py_generate_idempotent_state_id =
             py_context->attr("generate_idempotent_state_id");
-        try {
-          py::object result = generate_idempotent_state_id(
-              state_type,
-              service_name,
-              method,
-              py_idempotency);
 
-          auto state_id = result.cast<std::string>();
+        py::object py_state_id = py_generate_idempotent_state_id(
+            state_type,
+            service_name,
+            method,
+            py_idempotency);
 
-          adaptor->ScheduleCallbackOnNodeEventLoop(
-              [state_id = std::move(state_id),
-               deferred = std::move(deferred)](Napi::Env env) {
-                deferred->Resolve(Napi::String::New(env, state_id));
-              });
-        } catch (pybind11::error_already_set& e) {
-          std::string exception_message = py_exception_str(e.value());
-          adaptor->ScheduleCallbackOnNodeEventLoop(
-              [exception_message = std::move(exception_message),
-               deferred = std::move(deferred)](Napi::Env env) {
-                deferred->Reject(
-                    Napi::Error::New(env, exception_message).Value());
-              });
-        }
+        return py_state_id.cast<std::string>();
+      },
+      [](Napi::Env env, std::string&& state_id) {
+        return Napi::String::New(env, state_id);
       });
-
-  return promise;
 }
 
 
@@ -2301,16 +2421,11 @@ Napi::Value WriterContext_set_sync(const Napi::CallbackInfo& info) {
 
   bool sync = info[1].As<Napi::Boolean>();
 
-  std::promise<void> promise;
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
-      [&py_context, sync, &promise]() {
+  RunCallbackOnPythonEventLoop(
+      [&py_context, sync]() {
         py_context->attr("sync") = sync;
-        promise.set_value();
       });
 
-  promise.get_future().get();
-
   return info.Env().Undefined();
 }
 
@@ -2326,121 +2441,34 @@ Napi::Value retry_reactively_until(const Napi::CallbackInfo& info) {
   auto js_condition = NapiSafeFunctionReference(
       info[1].As<Napi::Function>());
 
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(info.Env());
-
-  auto promise = deferred->Promise();
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
+  return NodePromiseFromPythonTaskWithContext(
+      info.Env(),
+      "retry_reactively_until(...) in nodejs",
+      js_external_context,
       [js_external_context, // Ensures `py_context` remains valid.
        py_context,
-       js_condition = std::move(js_condition),
-       deferred = std::move(deferred)]() {
+       js_condition = std::move(js_condition)]() {
         py::object py_condition = py::cpp_function(
             [js_condition = std::move(js_condition)]() mutable {
-              py::object py_future =
-                  py::module::import("asyncio").attr("Future")();
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [js_condition, // NOTE: need a _copy_ of
-                                 // `js_condition` here since
-                                 // `py_condition` may be called more
-                                 // than once!
-                   py_future = new py::object(py_future)](
-                      Napi::Env env) mutable {
-                    Napi::Object js_promise =
-                        js_condition
-                            .Value(env)
-                            .Call(env.Global(), {})
-                            .As<Napi::Object>();
-
-                    js_promise
-                        .Get("then")
-                        .As<Napi::Function>()
-                        .Call(
-                            js_promise,
-                            {Napi::Function::New(
-                                 env,
-                                 [py_future](const Napi::CallbackInfo& info) {
-                                   bool result = info[0].As<Napi::Boolean>();
-                                   adaptor->ScheduleCallbackOnPythonEventLoop(
-                                       [py_future, result]() {
-                                         bool cancelled =
-                                             py_future->attr("cancelled")()
-                                                 .cast<bool>();
-                                         if (!cancelled) {
-                                           py_future->attr("set_result")(
-                                               result);
-                                         }
-                                         delete py_future;
-                                       });
-                                 }),
-                             Napi::Function::New(
-                                 env,
-                                 [py_future](const Napi::CallbackInfo& info) {
-                                   std::string message = message_from_js_error(
-                                       info[0].As<Napi::Object>());
-
-                                   adaptor->ScheduleCallbackOnPythonEventLoop(
-                                       [py_future,
-                                        message = std::move(message)]() {
-                                         bool cancelled =
-                                             py_future->attr("cancelled")()
-                                                 .cast<bool>();
-                                         if (!cancelled) {
-                                           py_future->attr("set_exception")(
-                                               py::module::import("builtins")
-                                                   .attr("Exception")(
-                                                       message));
-                                         }
-                                         delete py_future;
-                                       });
-                                 })});
+              return PythonFutureFromNodePromise(
+                  // NOTE: need a _copy_ of
+                  // `js_condition` here since
+                  // `py_condition` may be called more
+                  // than once!
+                  [js_condition](Napi::Env env) mutable {
+                    return js_condition
+                        .Value(env)
+                        .Call(env.Global(), {})
+                        .As<Napi::Object>();
+                  },
+                  [](Napi::Env, Napi::Value value) {
+                    return value.As<Napi::Boolean>().Value();
                   });
-
-              return py_future;
             });
 
-        py::object py_task =
-            py::module::import("reboot.nodejs.python")
-                .attr("create_task_with_context")(
-                    (py::module::import("reboot.aio.contexts")
-                         .attr("retry_reactively_until"))(
-                        py_context,
-                        py_condition),
-                    py_context,
-                    "name"_a = "retry_reactively_until(...) in nodejs");
-
-        py_task.attr("add_done_callback")(py::cpp_function(
-            [deferred = std::move(deferred),
-             // NOTE: need to keep a reference to `py_task` so that it
-             // doesn't get destroyed before completing!
-             py_task = new py::object(py_task)](py::object py_future) {
-              py::object py_exception = py_future.attr("exception")();
-
-              std::optional<std::string> exception;
-
-              if (!py_exception.is_none()) {
-                py::str py_exception_string = py_exception_str(py_exception);
-
-                exception.emplace(py_exception_string);
-              }
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [deferred = std::move(deferred),
-                   exception = std::move(exception)](Napi::Env env) {
-                    if (!exception.has_value()) {
-                      deferred->Resolve(env.Null());
-                    } else {
-                      deferred->Reject(
-                          Napi::Error::New(env, *exception).Value());
-                    }
-                  });
-
-              delete py_task;
-            }));
+        return py::module::import("reboot.aio.contexts")
+            .attr("retry_reactively_until")(py_context, py_condition);
       });
-
-  return promise;
 }
 
 
@@ -2459,132 +2487,45 @@ Napi::Value atLeastOrMostOnce(const Napi::CallbackInfo& info) {
 
   bool at_most_once = info[3].As<Napi::Boolean>();
 
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(info.Env());
-
-  auto promise = deferred->Promise();
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
+  return NodePromiseFromPythonTaskWithContext(
+      info.Env(),
+      "memoize(...) in nodejs",
+      js_external_context,
       [js_external_context, // Ensures `py_context` remains valid.
        py_context,
        js_callable = std::move(js_callable),
        idempotency_alias = std::move(idempotency_alias),
-       at_most_once,
-       deferred = std::move(deferred)]() {
+       at_most_once]() {
         py::object py_callable = py::cpp_function(
             [js_callable = std::move(js_callable)]() mutable {
-              py::object py_future =
-                  py::module::import("asyncio").attr("Future")();
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [js_callable, // NOTE: need a _copy_ of
-                                // `js_callable` here since
-                                // `py_callable` may be called more
-                                // than once!
-                   py_future = new py::object(py_future)](
-                      Napi::Env env) mutable {
-                    Napi::Object js_promise =
-                        js_callable
-                            .Value(env)
-                            .Call(env.Global(), {})
-                            .As<Napi::Object>();
-
-                    js_promise
-                        .Get("then")
-                        .As<Napi::Function>()
-                        .Call(
-                            js_promise,
-                            {Napi::Function::New(
-                                 env,
-                                 [py_future](const Napi::CallbackInfo& info) {
-                                   std::string result =
-                                       info[0].As<Napi::String>().Utf8Value();
-                                   adaptor->ScheduleCallbackOnPythonEventLoop(
-                                       [py_future, result]() {
-                                         bool cancelled =
-                                             py_future->attr("cancelled")()
-                                                 .cast<bool>();
-                                         if (!cancelled) {
-                                           py_future->attr("set_result")(
-                                               result);
-                                         }
-                                         delete py_future;
-                                       });
-                                 }),
-                             Napi::Function::New(
-                                 env,
-                                 [py_future](const Napi::CallbackInfo& info) {
-                                   std::string message = message_from_js_error(
-                                       info[0].As<Napi::Object>());
-
-                                   adaptor->ScheduleCallbackOnPythonEventLoop(
-                                       [py_future,
-                                        message = std::move(message)]() {
-                                         bool cancelled =
-                                             py_future->attr("cancelled")()
-                                                 .cast<bool>();
-                                         if (!cancelled) {
-                                           py_future->attr("set_exception")(
-                                               py::module::import("builtins")
-                                                   .attr("Exception")(
-                                                       message));
-                                         }
-                                         delete py_future;
-                                       });
-                                 })});
+              return PythonFutureFromNodePromise(
+                  // NOTE: need a _copy_ of `js_callable` here since
+                  // `py_callable` may be called more than once!
+                  [js_callable](Napi::Env env) mutable {
+                    return js_callable
+                        .Value(env)
+                        .Call(env.Global(), {})
+                        .As<Napi::Object>();
+                  },
+                  [](Napi::Env, Napi::Value value) {
+                    return std::string(value.As<Napi::String>().Utf8Value());
                   });
-
-              return py_future;
             });
 
-        py::object py_task =
-            py::module::import("reboot.nodejs.python")
-                .attr("create_task_with_context")(
-                    (py::module::import("reboot.aio.memoize").attr("memoize"))(
-                        py::str(idempotency_alias),
-                        py_context,
-                        py_callable,
-                        "type_t"_a = py::eval("str"),
-                        "at_most_once"_a = at_most_once),
-                    py_context,
-                    "name"_a = "memoize(...) in nodejs");
-
-        py_task.attr("add_done_callback")(py::cpp_function(
-            [deferred = std::move(deferred),
-             // NOTE: need to keep a reference to `py_task` so that it
-             // doesn't get destroyed before completing!
-             py_task = new py::object(py_task)](py::object py_future) {
-              py::object py_exception = py_future.attr("exception")();
-
-              std::optional<std::string> json;
-              std::optional<std::string> exception;
-
-              if (py_exception.is_none()) {
-                py::str py_json = py_future.attr("result")();
-                json.emplace(py_json);
-              } else {
-                py::str py_exception_string = py_exception_str(py_exception);
-
-                exception.emplace(py_exception_string);
-              }
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [deferred = std::move(deferred),
-                   json = std::move(json),
-                   exception = std::move(exception)](Napi::Env env) {
-                    if (json.has_value()) {
-                      deferred->Resolve(
-                          Napi::String::New(env, *json));
-                    } else {
-                      deferred->Reject(
-                          Napi::Error::New(env, *exception).Value());
-                    }
-                  });
-
-              delete py_task;
-            }));
+        return py::module::import("reboot.aio.memoize")
+            .attr("memoize")(
+                py::str(idempotency_alias),
+                py_context,
+                py_callable,
+                "type_t"_a = py::eval("str"),
+                "at_most_once"_a = at_most_once);
+      },
+      [](py::object py_json) {
+        return py_json.cast<std::string>();
+      },
+      [](Napi::Env env, std::string&& json) {
+        return Napi::String::New(env, json);
       });
-
-  return promise;
 }
 
 
@@ -2603,60 +2544,22 @@ Napi::Value Servicer_read(const Napi::CallbackInfo& info) {
 
   py::object* py_context = js_external_context.Value(info.Env()).Data();
 
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(info.Env());
-
-  auto promise = deferred->Promise();
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
+  return NodePromiseFromPythonTaskWithContext(
+      info.Env(),
+      "servicer._read(...) in nodejs",
+      js_external_context,
       [js_external_servicer, // Ensures `py_servicer` remains valid.
        py_servicer,
        js_external_context, // Ensures `py_context` remains valid.
-       py_context,
-       deferred = std::move(deferred)]() {
-        py::object py_task =
-            py::module::import("reboot.nodejs.python")
-                .attr("create_task_with_context")(
-                    py_servicer->attr("_read")(py_context),
-                    py_context,
-                    "name"_a = "servicer._read(...) in nodejs");
-
-        py_task.attr("add_done_callback")(py::cpp_function(
-            [deferred = std::move(deferred),
-             // NOTE: need to keep a reference to `py_task` so that it
-             // doesn't get destroyed before completing!
-             py_task = new py::object(py_task)](py::object py_future) {
-              py::object py_exception = py_future.attr("exception")();
-
-              std::optional<std::string> json;
-              std::optional<std::string> exception;
-
-              if (py_exception.is_none()) {
-                py::str py_json = py_future.attr("result")();
-                json.emplace(py_json);
-              } else {
-                py::str py_exception_string = py_exception_str(py_exception);
-
-                exception.emplace(py_exception_string);
-              }
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [deferred = std::move(deferred),
-                   json = std::move(json),
-                   exception = std::move(exception)](Napi::Env env) {
-                    if (json.has_value()) {
-                      deferred->Resolve(
-                          Napi::String::New(env, *json));
-                    } else {
-                      deferred->Reject(
-                          Napi::Error::New(env, *exception).Value());
-                    }
-                  });
-
-              delete py_task;
-            }));
+       py_context]() {
+        return py_servicer->attr("_read")(py_context);
+      },
+      [](py::object py_json) {
+        return py_json.cast<std::string>();
+      },
+      [](Napi::Env env, std::string&& json) {
+        return Napi::String::New(env, json);
       });
-
-  return promise;
 }
 
 
@@ -2680,135 +2583,48 @@ Napi::Value Servicer_write(const Napi::CallbackInfo& info) {
 
   std::string json_options = info[3].As<Napi::String>().Utf8Value();
 
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(info.Env());
-
-  auto promise = deferred->Promise();
-
-  adaptor->ScheduleCallbackOnPythonEventLoop(
+  return NodePromiseFromPythonTaskWithContext(
+      info.Env(),
+      "servicer._write(...) in nodejs",
+      js_external_context,
       [js_external_servicer, // Ensures `py_servicer` remains valid.
        py_servicer,
        js_external_context, // Ensures `py_context` remains valid.
        py_context,
        js_writer = std::move(js_writer),
-       json_options = std::move(json_options),
-       deferred = std::move(deferred)]() {
+       json_options = std::move(json_options)]() {
         py::object py_writer = py::cpp_function(
             [js_writer = std::move(js_writer)](
                 std::string state_json) mutable {
-              py::object py_future =
-                  py::module::import("asyncio").attr("Future")();
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
+              return PythonFutureFromNodePromise(
                   [js_writer, // NOTE: need a _copy_ of
                               // `js_writer` here since
                               // `py_writer` may be called more
                               // than once!
-                   state_json,
-                   py_future = new py::object(py_future)](
-                      Napi::Env env) mutable {
-                    Napi::Object js_promise =
-                        js_writer
-                            .Value(env)
-                            .Call(
-                                env.Global(),
-                                {Napi::String::New(env, state_json)})
-                            .As<Napi::Object>();
-
-                    js_promise
-                        .Get("then")
-                        .As<Napi::Function>()
+                   state_json](Napi::Env env) mutable {
+                    return js_writer
+                        .Value(env)
                         .Call(
-                            js_promise,
-                            {Napi::Function::New(
-                                 env,
-                                 [py_future](const Napi::CallbackInfo& info) {
-                                   std::string result =
-                                       info[0].As<Napi::String>().Utf8Value();
-                                   adaptor->ScheduleCallbackOnPythonEventLoop(
-                                       [py_future, result]() {
-                                         bool cancelled =
-                                             py_future->attr("cancelled")()
-                                                 .cast<bool>();
-                                         if (!cancelled) {
-                                           py_future->attr("set_result")(
-                                               result);
-                                         }
-                                         delete py_future;
-                                       });
-                                 }),
-                             Napi::Function::New(
-                                 env,
-                                 [py_future](const Napi::CallbackInfo& info) {
-                                   std::string message = message_from_js_error(
-                                       info[0].As<Napi::Object>());
-
-                                   adaptor->ScheduleCallbackOnPythonEventLoop(
-                                       [py_future,
-                                        message = std::move(message)]() {
-                                         bool cancelled =
-                                             py_future->attr("cancelled")()
-                                                 .cast<bool>();
-                                         if (!cancelled) {
-                                           py_future->attr("set_exception")(
-                                               py::module::import("builtins")
-                                                   .attr("Exception")(
-                                                       message));
-                                         }
-                                         delete py_future;
-                                       });
-                                 })});
+                            env.Global(),
+                            {Napi::String::New(env, state_json)})
+                        .As<Napi::Object>();
+                  },
+                  [](Napi::Env env, Napi::Value value) {
+                    return std::string(value.As<Napi::String>().Utf8Value());
                   });
-
-              return py_future;
             });
 
-        py::object py_task =
-            py::module::import("reboot.nodejs.python")
-                .attr("create_task_with_context")(
-                    py_servicer->attr("_write")(
-                        py_context,
-                        py_writer,
-                        json_options),
-                    py_context,
-                    "name"_a = "servicer._write(...) in nodejs");
-
-        py_task.attr("add_done_callback")(py::cpp_function(
-            [deferred = std::move(deferred),
-             // NOTE: need to keep a reference to `py_task` so that it
-             // doesn't get destroyed before completing!
-             py_task = new py::object(py_task)](py::object py_future) {
-              py::object py_exception = py_future.attr("exception")();
-
-              std::optional<std::string> result;
-              std::optional<std::string> exception;
-
-              if (py_exception.is_none()) {
-                py::str py_result = py_future.attr("result")();
-                result.emplace(py_result);
-              } else {
-                py::str py_exception_string = py_exception_str(py_exception);
-
-                exception.emplace(py_exception_string);
-              }
-
-              adaptor->ScheduleCallbackOnNodeEventLoop(
-                  [deferred = std::move(deferred),
-                   result = std::move(result),
-                   exception = std::move(exception)](Napi::Env env) {
-                    if (result.has_value()) {
-                      deferred->Resolve(
-                          Napi::String::New(env, *result));
-                    } else {
-                      deferred->Reject(
-                          Napi::Error::New(env, *exception).Value());
-                    }
-                  });
-
-              delete py_task;
-            }));
+        return py_servicer->attr("_write")(
+            py_context,
+            py_writer,
+            json_options);
+      },
+      [](py::object py_result) {
+        return py_result.cast<std::string>();
+      },
+      [](Napi::Env env, std::string&& result) {
+        return Napi::String::New(env, result);
       });
-
-  return promise;
 }
 
 
@@ -2874,6 +2690,14 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
       Napi::String::New(env, "Context_iteration"),
       Napi::Function::New<Context_iteration>(env));
 
+  exports.Set(
+      Napi::String::New(env, "Context_cookie"),
+      Napi::Function::New<Context_cookie>(env));
+
+  exports.Set(
+      Napi::String::New(env, "Context_appInternal"),
+      Napi::Function::New<Context_appInternal>(env));
+
   exports.Set(
       Napi::String::New(env, "Context_generateIdempotentStateId"),
       Napi::Function::New<Context_generateIdempotentStateId>(env));
@@ -2891,8 +2715,8 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
       Napi::Function::New<atLeastOrMostOnce>(env));
 
   exports.Set(
-      Napi::String::New(env, "Future_await"),
-      Napi::Function::New<Future_await>(env));
+      Napi::String::New(env, "Task_await"),
+      Napi::Function::New<Task_await>(env));
 
   exports.Set(
       Napi::String::New(env, "ExternalContext_constructor"),