@reboot-dev/reboot 0.42.0 → 0.44.0

package/reboot_native.cc

@@ -27,20 +27,18 @@ namespace py = pybind11;
 
 // Helper when debugging, left for future optimization work.
 struct Timer {
-  Timer(const char* name)
-    : name_(name) {
+  Timer(const char* name) : name_(name) {
     start_ = std::chrono::high_resolution_clock::now();
   }
 
   void elapsed(const char* step = nullptr) const {
     auto end = std::chrono::high_resolution_clock::now();
-    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
-        end - start_);
+    auto duration =
+        std::chrono::duration_cast<std::chrono::milliseconds>(end - start_);
     std::stringstream ss;
     ss << name_
        << (step != nullptr ? " at " + std::string(step) : std::string(""))
-       << " took " << duration.count() << "ms"
-       << std::endl;
+       << " took " << duration.count() << "ms" << std::endl;
     std::cout << ss.str();
   }
 
@@ -87,9 +85,9 @@ struct PythonNodeAdaptor {
     if (const py::error_already_set* e_py =
             dynamic_cast<const py::error_already_set*>(&e)) {
       // This is a Python exception. Is it an `InputError`?
-      if (e_py->matches(py::module::import(
-                            "rebootdev.aio.exceptions")
-                            .attr("InputError"))) {
+      if (e_py->matches(
+              py::module::import("rebootdev.aio.exceptions")
+                  .attr("InputError"))) {
         // This is an InputError, which means it reports a mistake in the input
         // provided by the developer. We want to print _only_ the user-friendly
         // error message in the exception, without intimidating stack traces.
@@ -104,15 +102,13 @@ struct PythonNodeAdaptor {
         // help diagnose the problem.
         std::cerr << "Unexpected library exception: " << e_py->what()
                   << std::endl
-                  << "Please report this bug to the maintainers!"
-                  << std::endl;
+                  << "Please report this bug to the maintainers!" << std::endl;
       }
     } else {
       // This is a C++ exception; something went wrong in the C++ code. Request
       // that the developer reports the issue.
-      std::cerr
-          << "Unexpected adapter exception: " << e.what() << std::endl
-          << "Please report this bug to the maintainers!" << std::endl;
+      std::cerr << "Unexpected adapter exception: " << e.what() << std::endl
+                << "Please report this bug to the maintainers!" << std::endl;
     }
   }
 
@@ -224,11 +220,8 @@ struct PythonNodeAdaptor {
       try {
         function(env);
       } catch (const std::exception& e) {
-        std::cerr
-            << "Unexpected exception: " << e.what()
-            << "\n"
-            << "Please report this bug to the maintainers!"
-            << std::endl;
+        std::cerr << "Unexpected exception: " << e.what() << "\n"
+                  << "Please report this bug to the maintainers!" << std::endl;
       }
     }
   }
@@ -263,10 +256,7 @@ struct PythonNodeAdaptor {
   // into Python or expecting calls from Python.
   std::atomic<int> references{0};
 
-  Napi::TypedThreadSafeFunction<
-      void,
-      void,
-      _RunNodeFunctions>
+  Napi::TypedThreadSafeFunction<void, void, _RunNodeFunctions>
       thread_safe_function;
   std::mutex node_functions_mutex_;
   std::list<std::function<void(Napi::Env&)>> node_functions_;
@@ -294,9 +284,7 @@ struct NapiReferenceDeleter {
   template <typename T>
   void operator()(Napi::Reference<T>* reference) {
     adaptor->ScheduleCallbackOnNodeEventLoopLowPriority(
-        [reference](Napi::Env) {
-          delete reference;
-        });
+        [reference](Napi::Env) { delete reference; });
   }
 };
 
@@ -335,13 +323,9 @@ using NapiSafeObjectReference = NapiSafeReference<Napi::Object>;
 // 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_<NapiSafeFunctionReference>(m, "NapiSafeFunctionReference");
 
-  py::class_<NapiSafeObjectReference>(
-      m,
-      "NapiSafeObjectReference");
+  py::class_<NapiSafeObjectReference>(m, "NapiSafeObjectReference");
 }
 
 
@@ -354,9 +338,7 @@ Napi::External<py::object> make_napi_external(
       py_object,
       [](Napi::Env, py::object* py_object) {
         adaptor->ScheduleCallbackOnPythonEventLoopLowPriority(
-            [py_object]() {
-              delete py_object;
-            });
+            [py_object]() { delete py_object; });
       });
 
   if (type_tag != nullptr) {
@@ -379,126 +361,119 @@ void _RunNodeFunctions(
 void PythonNodeAdaptor::Initialize(
     Napi::Env& env,
     const Napi::Function& js_callback) {
-  thread_safe_function = Napi::TypedThreadSafeFunction<
-      void,
-      void,
-      _RunNodeFunctions>::New(
-      /* Environment: */ env,
-      /* JS callback: */ js_callback,
-      /* Resource name: */ "reboot_native",
-      /* Max queue size (0 = unlimited): */ 0,
-      /* Initial thread count: */ 1,
-      /* Context: */ (void*) nullptr,
-      // Finalizer:
-      [this](Napi::Env env, void*, void*) {
-        // 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);
+  thread_safe_function =
+      Napi::TypedThreadSafeFunction<void, void, _RunNodeFunctions>::New(
+          /* Environment: */
+          env,
+          /* JS callback: */ js_callback,
+          /* Resource name: */ "reboot_native",
+          /* Max queue size (0 = unlimited): */ 0,
+          /* Initial thread count: */ 1,
+          /* Context: */ (void*) nullptr,
+          // Finalizer:
+          [this](Napi::Env env, void*, void*) {
+            // 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
   // if the user's code never calls into us we won't keep Node
   // from exiting.
   thread_safe_function.Unref(env);
 
-  thread = std::thread(
-      [this]() {
-        // Set environment variables _before_ initializing the
-        // interpreter because it may cache the variables. Also, some
-        // of the variables need to be set before we start importing
-        // anything.
-        //
-        // Don't try and manipulate signals when running within Node!
-        setenv("REBOOT_SIGNALS_AVAILABLE", "false", 1);
-        // Specify that we are running from within `node`.
-        setenv("REBOOT_NODEJS", "true", 1);
-
-        py::initialize_interpreter();
-
-        try {
-          py::object module = py::module::import("rebootdev.nodejs.python");
-
-          module.attr("launch_subprocess_server") = py::cpp_function(
-              [](py::str py_base64_args) {
-                py::object py_future =
-                    py::module::import("asyncio").attr("Future")();
-
-                adaptor->ScheduleCallbackOnNodeEventLoop(
-                    [base64_args = std::string(py_base64_args),
-                     py_future = new py::object(py_future)](Napi::Env env) {
-                      try {
-                        Napi::Number js_pid =
-                            js_launchSubprocessServer
-                                ->Call(
-                                    {Napi::String::New(env, base64_args)})
-                                .As<Napi::Number>();
-
-                        adaptor->ScheduleCallbackOnPythonEventLoop(
-                            [py_future, pid = js_pid.Int64Value()]() {
-                              bool cancelled =
-                                  py_future->attr("cancelled")()
-                                      .cast<bool>();
-                              if (!cancelled) {
-                                py_future->attr("set_result")(pid);
-                              }
-                              delete py_future;
-                            });
-                      } catch (const Napi::Error& e) {
-                        adaptor->ScheduleCallbackOnPythonEventLoop(
-                            [py_future, what = e.what()]() {
-                              bool cancelled =
-                                  py_future->attr("cancelled")()
-                                      .cast<bool>();
-                              if (!cancelled) {
-                                py_future->attr("set_exception")(
-                                    py::module::import("builtins")
-                                        .attr("Exception")(
-                                            what));
-                              }
-                              delete py_future;
-                            });
-                      }
-                    });
+  thread = std::thread([this]() {
+    // Set environment variables _before_ initializing the
+    // interpreter because it may cache the variables. Also, some
+    // of the variables need to be set before we start importing
+    // anything.
+    //
+    // Don't try and manipulate signals when running within Node!
+    setenv("REBOOT_SIGNALS_AVAILABLE", "false", 1);
+    // Specify that we are running from within `node`.
+    setenv("REBOOT_NODEJS", "true", 1);
 
-                return py_future;
-              });
+    py::initialize_interpreter();
 
-          module.attr("run_functions") = py::cpp_function(
-              [this]() {
-                std::list<std::function<void()>> functions;
-                std::vector<std::pair<py::object*, std::string>> futures;
+    try {
+      py::object module = py::module::import("rebootdev.nodejs.python");
 
-                {
-                  std::unique_lock<std::mutex> lock(mutex);
-                  functions = std::move(python_functions);
-                  should_signal_fd_ = true;
-                }
+      module.attr("launch_subprocess_server") =
+          py::cpp_function([](py::str py_base64_args) {
+            py::object py_future =
+                py::module::import("asyncio").attr("Future")();
 
-                for (auto&& function : functions) {
+            adaptor->ScheduleCallbackOnNodeEventLoop(
+                [base64_args = std::string(py_base64_args),
+                 py_future = new py::object(py_future)](Napi::Env env) {
                   try {
-                    function();
-                  } catch (std::exception& e) {
-                    PythonNodeAdaptor::HandleException(e);
+                    Napi::Number js_pid =
+                        js_launchSubprocessServer
+                            ->Call({Napi::String::New(env, base64_args)})
+                            .As<Napi::Number>();
+
+                    adaptor->ScheduleCallbackOnPythonEventLoop(
+                        [py_future, pid = js_pid.Int64Value()]() {
+                          bool cancelled =
+                              py_future->attr("cancelled")().cast<bool>();
+                          if (!cancelled) {
+                            py_future->attr("set_result")(pid);
+                          }
+                          delete py_future;
+                        });
+                  } catch (const Napi::Error& e) {
+                    adaptor->ScheduleCallbackOnPythonEventLoop(
+                        [py_future, what = e.what()]() {
+                          bool cancelled =
+                              py_future->attr("cancelled")().cast<bool>();
+                          if (!cancelled) {
+                            py_future->attr("set_exception")(
+                                py::module::import("builtins")
+                                    .attr("Exception")(what));
+                          }
+                          delete py_future;
+                        });
                   }
-                }
-              });
+                });
+
+            return py_future;
+          });
 
-          py::object event_loop_thread = module.attr("EventLoopThread")(
-              read_fd_);
+      module.attr("run_functions") = py::cpp_function([this]() {
+        std::list<std::function<void()>> functions;
+        std::vector<std::pair<py::object*, std::string>> futures;
 
-          py::gil_scoped_release release;
+        {
+          std::unique_lock<std::mutex> lock(mutex);
+          functions = std::move(python_functions);
+          should_signal_fd_ = true;
+        }
 
-          while (true) {
-            std::this_thread::sleep_until(
-                std::chrono::time_point<std::chrono::system_clock>::max());
-            continue;
+        for (auto&& function : functions) {
+          try {
+            function();
+          } catch (std::exception& e) {
+            PythonNodeAdaptor::HandleException(e);
           }
-        } catch (const std::exception& e) {
-          std::cout << e.what() << std::endl;
-          throw;
         }
       });
+
+      py::object event_loop_thread = module.attr("EventLoopThread")(read_fd_);
+
+      py::gil_scoped_release release;
+
+      while (true) {
+        std::this_thread::sleep_until(
+            std::chrono::time_point<std::chrono::system_clock>::max());
+        continue;
+      }
+    } catch (const std::exception& e) {
+      std::cout << e.what() << std::endl;
+      throw;
+    }
+  });
 }
 
 
@@ -555,21 +530,19 @@ 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())));
-        }
-      });
+  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();
 }
@@ -598,8 +571,7 @@ T RunCallbackOnNodeEventLoop(F&& f, bool warn = false) {
                 .Call({e.Value(), Napi::String::New(env, "\n")});
           }
           promise.set_exception(
-              std::make_exception_ptr(
-                  std::runtime_error(e.what())));
+              std::make_exception_ptr(std::runtime_error(e.what())));
         } catch (const std::exception& e) {
           if (warn) {
             env.Global()
@@ -612,8 +584,7 @@ T RunCallbackOnNodeEventLoop(F&& f, bool warn = false) {
                      Napi::String::New(env, "\n")});
           }
           promise.set_exception(
-              std::make_exception_ptr(
-                  std::runtime_error(e.what())));
+              std::make_exception_ptr(std::runtime_error(e.what())));
         }
       });
 
@@ -658,8 +629,7 @@ Napi::Promise NodePromiseFromPythonCallback(
                 } catch (const std::exception& e) {
                   // TODO: is this code unreachable because Node.js
                   // will properly always only pass us a `Napi::Error`?
-                  js_deferred->Reject(
-                      Napi::Error::New(env, e.what()).Value());
+                  js_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`?
@@ -678,16 +648,14 @@ Napi::Promise NodePromiseFromPythonCallback(
       });
 
   // Allow Node to exit after we've resolved or rejected the promise.
-  auto js_resolve_reject = Napi::Function::New(
-      env,
-      [](const Napi::CallbackInfo& info) {
+  auto js_resolve_reject =
+      Napi::Function::New(env, [](const Napi::CallbackInfo& info) {
         adaptor->AllowNodeToExit(info.Env());
       });
 
-  js_promise
-      .Get("then")
-      .As<Napi::Function>()
-      .Call(js_promise, {js_resolve_reject, js_resolve_reject});
+  js_promise.Get("then").As<Napi::Function>().Call(
+      js_promise,
+      {js_resolve_reject, js_resolve_reject});
 
   return js_promise;
 }
@@ -719,10 +687,10 @@ Napi::Promise NodePromiseFromPythonFuture(
   auto js_promise = js_deferred->Promise();
 
   adaptor->ScheduleCallbackOnPythonEventLoop(
-      [python_future_callback = std::forward<PythonFutureCallback>(
-           python_future_callback),
-       python_done_callback = std::forward<PythonDoneCallback>(
-           python_done_callback),
+      [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),
        js_deferred = std::move(js_deferred)]() mutable {
         try {
@@ -730,8 +698,8 @@ Napi::Promise NodePromiseFromPythonFuture(
           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),
+              [python_done_callback =
+                   std::forward<PythonDoneCallback>(python_done_callback),
                node_callback = std::forward<NodeCallback>(node_callback),
                js_deferred = std::move(js_deferred),
                // NOTE: need to keep a reference to `py_future` so that it
@@ -766,9 +734,8 @@ Napi::Promise NodePromiseFromPythonFuture(
                          js_deferred = std::move(js_deferred),
                          result = std::move(result)](Napi::Env env) mutable {
                           // TODO: try / catch around `node_callback`.
-                          auto js_result = node_callback(
-                              env,
-                              std::move(result));
+                          auto js_result =
+                              node_callback(env, std::move(result));
                           js_deferred->Resolve(js_result);
                         });
                   }
@@ -787,16 +754,14 @@ Napi::Promise NodePromiseFromPythonFuture(
       });
 
   // Allow Node to exit after we've resolved or rejected the promise.
-  auto js_resolve_reject = Napi::Function::New(
-      env,
-      [](const Napi::CallbackInfo& info) {
+  auto js_resolve_reject =
+      Napi::Function::New(env, [](const Napi::CallbackInfo& info) {
         adaptor->AllowNodeToExit(info.Env());
       });
 
-  js_promise
-      .Get("then")
-      .As<Napi::Function>()
-      .Call(js_promise, {js_resolve_reject, js_resolve_reject});
+  js_promise.Get("then").As<Napi::Function>().Call(
+      js_promise,
+      {js_resolve_reject, js_resolve_reject});
 
   return js_promise;
 }
@@ -815,9 +780,7 @@ Napi::Promise NodePromiseFromPythonFuture(
         // TODO: check that `py_result` is `None`.
         return std::nullopt;
       },
-      [](Napi::Env env, std::nullopt_t) {
-        return env.Null();
-      });
+      [](Napi::Env env, std::nullopt_t) { return env.Null(); });
 }
 
 
@@ -838,8 +801,8 @@ Napi::Promise NodePromiseFromPythonTask(
       env,
       [name,
        create_task = std::move(create_task),
-       python_task_callback = std::forward<PythonTaskCallback>(
-           python_task_callback)]() mutable {
+       python_task_callback =
+           std::forward<PythonTaskCallback>(python_task_callback)]() mutable {
         py::object py_task = std::apply(
             [&name, &python_task_callback](
                 const std::string& import,
@@ -875,9 +838,7 @@ Napi::Promise NodePromiseFromPythonTask(
         // TODO: check that `py_result` is `None`.
         return std::nullopt;
       },
-      [](Napi::Env env, std::nullopt_t) {
-        return env.Null();
-      });
+      [](Napi::Env env, std::nullopt_t) { return env.Null(); });
 }
 
 
@@ -900,11 +861,9 @@ Napi::Promise NodePromiseFromPythonTaskWithContext(
           std::string("rebootdev.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();
-      },
+      [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));
 }
@@ -925,9 +884,7 @@ Napi::Promise NodePromiseFromPythonTaskWithContext(
         // TODO: check that `py_result` is `None`.
         return std::nullopt;
       },
-      [](Napi::Env env, std::nullopt_t) {
-        return env.Null();
-      });
+      [](Napi::Env env, std::nullopt_t) { return env.Null(); });
 }
 
 
@@ -952,64 +909,58 @@ py::object PythonFutureFromNodePromise(
         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;
-                             });
-                       })});
+          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
@@ -1021,31 +972,28 @@ py::object PythonFutureFromNodePromise(
 
           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;
-              });
+          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;
-              });
+          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;
+          });
         }
       });
 
@@ -1053,19 +1001,14 @@ py::object PythonFutureFromNodePromise(
 }
 
 
-template <
-    typename NodePromiseCallback,
-    typename NodePromiseResolvedCallback>
+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);
-      });
+      std::forward<NodePromiseResolvedCallback>(node_promise_resolved_callback),
+      [](auto&& result) { return std::move(result); });
 }
 
 
@@ -1074,12 +1017,8 @@ 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();
-      });
+      [](Napi::Env, Napi::Value) { return std::nullopt; },
+      [](auto&&) { return py::none(); });
 }
 
 
@@ -1105,11 +1044,10 @@ 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();
 
-  RunCallbackOnPythonEventLoop(
-      [&module, &base64_encoded_rbt_py]() {
-        py::module::import("rebootdev.nodejs.python")
-            .attr("import_py")(module, base64_encoded_rbt_py);
-      });
+  RunCallbackOnPythonEventLoop([&module, &base64_encoded_rbt_py]() {
+    py::module::import("rebootdev.nodejs.python")
+        .attr("import_py")(module, base64_encoded_rbt_py);
+  });
 }
 
 
@@ -1134,19 +1072,16 @@ napi_type_tag MakeTypeTag(const std::string& module, const std::string& type) {
 }
 
 
-static const napi_type_tag reboot_aio_tests_Reboot = MakeTypeTag(
-    "reboot.aio.tests",
-    "Reboot");
+static const napi_type_tag reboot_aio_tests_Reboot =
+    MakeTypeTag("reboot.aio.tests", "Reboot");
 
 
-static const napi_type_tag reboot_aio_applications_Application = MakeTypeTag(
-    "reboot.aio.applications",
-    "Application");
+static const napi_type_tag reboot_aio_applications_Application =
+    MakeTypeTag("reboot.aio.applications", "Application");
 
 
-static const napi_type_tag reboot_aio_external_ExternalContext = MakeTypeTag(
-    "rebootdev.aio.external",
-    "ExternalContext");
+static const napi_type_tag reboot_aio_external_ExternalContext =
+    MakeTypeTag("rebootdev.aio.external", "ExternalContext");
 
 
 Napi::Value python3Path(const Napi::CallbackInfo& info) {
@@ -1173,16 +1108,13 @@ std::string uint8array_to_str(const Napi::Uint8Array& arr) {
 
 
 Napi::Value Reboot_constructor(const Napi::CallbackInfo& info) {
-  py::object* py_reboot = RunCallbackOnPythonEventLoop(
-      []() {
-        py::object tests = py::module::import("reboot.aio.tests");
-        return new py::object(tests.attr("Reboot")());
-      });
+  py::object* py_reboot = RunCallbackOnPythonEventLoop([]() {
+    py::object tests = py::module::import("reboot.aio.tests");
+    return new py::object(tests.attr("Reboot")());
+  });
 
-  Napi::External<py::object> js_external_reboot = make_napi_external(
-      info.Env(),
-      py_reboot,
-      &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;
 }
@@ -1216,27 +1148,21 @@ Napi::Value Reboot_createExternalContext(const Napi::CallbackInfo& info) {
   }
 
   py::object* py_context = RunCallbackOnPythonEventLoop(
-      [py_reboot,
-       &name,
-       &idempotency_seed,
-       &bearer_token,
-       app_internal]() {
+      [py_reboot, &name, &idempotency_seed, &bearer_token, app_internal]() {
         py::object py_idempotency_seed = py::none();
         if (idempotency_seed.has_value()) {
-          py_idempotency_seed =
-              py::module::import("uuid")
-                  .attr("UUID")(py::str(*idempotency_seed));
+          py_idempotency_seed = py::module::import("uuid").attr("UUID")(
+              py::str(*idempotency_seed));
         }
         py::object py_bearer_token = py::none();
         if (bearer_token.has_value()) {
           py_bearer_token = py::str(*bearer_token);
         }
-        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));
+        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));
       });
 
   Napi::External<py::object> js_external_context = make_napi_external(
@@ -1244,17 +1170,14 @@ Napi::Value Reboot_createExternalContext(const Napi::CallbackInfo& info) {
       py_context,
       &reboot_aio_external_ExternalContext);
 
-  return js_from_native_external
-      .Call(
-          info.Env().Global(),
-          {js_external_context});
+  return js_from_native_external.Call(
+      info.Env().Global(),
+      {js_external_context});
 }
 
 
 // NOTE: must be called within _Node_.
-Napi::Promise make_js_cancelled(
-    Napi::Env& env,
-    py::object* py_cancelled) {
+Napi::Promise make_js_cancelled(Napi::Env& env, py::object* py_cancelled) {
   return NodePromiseFromPythonFuture(
       "make_js_cancelled",
       env,
@@ -1303,8 +1226,7 @@ py::object make_py_authorizer(NapiSafeObjectReference js_authorizer) {
          py::object py_cancelled,
          std::string bytes_call) {
         NapiSafeObjectReference* js_authorizer_reference =
-            self.attr("_js_authorizer")
-                .cast<NapiSafeObjectReference*>();
+            self.attr("_js_authorizer").cast<NapiSafeObjectReference*>();
 
         return PythonFutureFromNodePromise(
             [js_authorizer_reference,
@@ -1346,12 +1268,11 @@ py::object make_py_authorizer(NapiSafeObjectReference js_authorizer) {
       py::is_method(py::none()));
 
   // Now define our subclass.
-  py::object py_parent_class =
-      py::module::import("rebootdev.nodejs.python")
-          .attr("NodeAdaptorAuthorizer");
+  py::object py_parent_class = py::module::import("rebootdev.nodejs.python")
+                                   .attr("NodeAdaptorAuthorizer");
 
-  py::object py_parent_metaclass = py::reinterpret_borrow<py::object>(
-      (PyObject*) &PyType_Type);
+  py::object py_parent_metaclass =
+      py::reinterpret_borrow<py::object>((PyObject*) &PyType_Type);
 
   py::object py_class = py_parent_metaclass(
       "_NodeAdaptorAuthorizer",
@@ -1389,20 +1310,14 @@ std::vector<std::shared_ptr<ServicerDetails>> make_servicer_details(
       Napi::Function js_servicer_constructor = value.As<Napi::Function>();
 
       std::string name =
-          js_servicer_constructor
-              .Get("name")
-              .As<Napi::String>()
-              .Utf8Value();
+          js_servicer_constructor.Get("name").As<Napi::String>().Utf8Value();
 
-      std::string rbt_module =
-          js_servicer_constructor
-              .Get("__rbtModule__")
-              .As<Napi::String>()
-              .Utf8Value();
+      std::string rbt_module = js_servicer_constructor.Get("__rbtModule__")
+                                   .As<Napi::String>()
+                                   .Utf8Value();
 
       std::string servicer_node_adaptor =
-          js_servicer_constructor
-              .Get("__servicerNodeAdaptor__")
+          js_servicer_constructor.Get("__servicerNodeAdaptor__")
               .As<Napi::String>()
               .Utf8Value();
 
@@ -1418,23 +1333,17 @@ std::vector<std::shared_ptr<ServicerDetails>> make_servicer_details(
                   Napi::Persistent(js_servicer_constructor))}));
     } else if (
         value.IsObject()
-        && !value
-                .As<Napi::Object>()
+        && !value.As<Napi::Object>()
                 .Get("nativeServicerModule")
                 .IsUndefined()) {
-      std::string module =
-          value
-              .As<Napi::Object>()
-              .Get("nativeServicerModule")
-              .As<Napi::String>()
-              .Utf8Value();
+      std::string module = value.As<Napi::Object>()
+                               .Get("nativeServicerModule")
+                               .As<Napi::String>()
+                               .Utf8Value();
       servicer_details.push_back(
-          std::make_shared<ServicerDetails>(NativeServicerDetails{
-              module}));
+          std::make_shared<ServicerDetails>(NativeServicerDetails{module}));
     } else {
-      Napi::Error::New(
-          env,
-          "Unexpected `servicer` type.")
+      Napi::Error::New(env, "Unexpected `servicer` type.")
           .ThrowAsJavaScriptException();
     }
   }
@@ -1484,8 +1393,7 @@ py::object make_py_user_servicer(
                 Napi::External<py::object> js_external_self =
                     make_napi_external(env, py_self);
 
-                js_servicer
-                    .Get("__storeExternal")
+                js_servicer.Get("__storeExternal")
                     .As<Napi::Function>()
                     .Call(js_servicer, {js_external_self});
 
@@ -1505,11 +1413,11 @@ py::object make_py_user_servicer(
 
   // Trampolines us from Python through C++ into Node for Servicer method
   // calls.
-  attributes["_trampoline"] = py::cpp_function(
-      [](NapiSafeObjectReference& js_servicer_reference,
-         py::object py_context,
-         py::object py_cancelled,
-         std::string bytes_call) {
+  attributes["_trampoline"] =
+      py::cpp_function([](NapiSafeObjectReference& js_servicer_reference,
+                          py::object py_context,
+                          py::object py_cancelled,
+                          std::string bytes_call) {
         return PythonFutureFromNodePromise(
             [&js_servicer_reference,
              py_context = new py::object(py_context),
@@ -1528,11 +1436,9 @@ py::object make_py_user_servicer(
 
               js_args.push_back(str_to_uint8array(env, bytes_call));
 
-              Napi::Object js_servicer =
-                  js_servicer_reference.Value(env);
+              Napi::Object js_servicer = js_servicer_reference.Value(env);
 
-              return js_servicer
-                  .Get("__dispatch")
+              return js_servicer.Get("__dispatch")
                   .As<Napi::Function>()
                   .Call(js_servicer, js_args)
                   .As<Napi::Object>();
@@ -1551,13 +1457,12 @@ py::object make_py_user_servicer(
         std::optional<NapiSafeObjectReference> js_authorizer;
         try {
           js_authorizer = RunCallbackOnNodeEventLoop(
-              [&js_servicer_reference](Napi::Env env)
-                  -> std::optional<NapiSafeObjectReference> {
+              [&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, {});
+                Napi::Value js_authorizer = js_servicer.Get("_authorizer")
+                                                .As<Napi::Function>()
+                                                .Call(js_servicer, {});
                 if (!js_authorizer.IsNull()) {
                   return NapiSafeObjectReference(
                       js_authorizer.As<Napi::Object>());
@@ -1587,8 +1492,8 @@ py::object make_py_user_servicer(
       py::module::import(details.rbt_module.c_str())
           .attr(details.servicer_node_adaptor.c_str());
 
-  py::object py_metaclass = py::reinterpret_borrow<py::object>(
-      (PyObject*) &PyType_Type);
+  py::object py_metaclass =
+      py::reinterpret_borrow<py::object>((PyObject*) &PyType_Type);
 
   // Our subclass will be in the `reboot_native` module with
   // the same name as what is used in JS/TS, e.g.,
@@ -1606,8 +1511,7 @@ py::object make_py_user_servicer(
 
 // NOTE: must be called from within _Python_.
 py::list make_py_servicers(
-    const std::vector<
-        std::shared_ptr<ServicerDetails>>& servicer_details) {
+    const std::vector<std::shared_ptr<ServicerDetails>>& servicer_details) {
   py::module_ module = py::module::import("reboot_native");
 
   py::list py_servicers;
@@ -1619,8 +1523,7 @@ py::list make_py_servicers(
         auto native_details =
             std::get_if<NativeServicerDetails>(details.get())) {
       py_servicers.attr("extend")(
-          py::module::import(
-              native_details->py_servicers_module.c_str())
+          py::module::import(native_details->py_servicers_module.c_str())
               .attr("servicers")());
     }
     // TODO: Can I get exhaustiveness checking for the std::variant?
@@ -1659,8 +1562,7 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
          py::object py_cancelled,
          std::string bytes_call) {
         NapiSafeObjectReference* js_token_verifier_reference =
-            self.attr("_js_token_verifier")
-                .cast<NapiSafeObjectReference*>();
+            self.attr("_js_token_verifier").cast<NapiSafeObjectReference*>();
 
         return PythonFutureFromNodePromise(
             [js_token_verifier_reference,
@@ -1687,8 +1589,7 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
               Napi::Object js_token_verifier =
                   js_token_verifier_reference->Value(env);
 
-              return js_token_verifier
-                  .Get("_verifyToken")
+              return js_token_verifier.Get("_verifyToken")
                   .As<Napi::Function>()
                   .Call(js_token_verifier, {js_args})
                   .As<Napi::Object>();
@@ -1714,12 +1615,11 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
       py::arg("bytes_call"),
       py::is_method(py::none()));
 
-  py::object py_parent_class =
-      py::module::import("rebootdev.nodejs.python")
-          .attr("NodeAdaptorTokenVerifier");
+  py::object py_parent_class = py::module::import("rebootdev.nodejs.python")
+                                   .attr("NodeAdaptorTokenVerifier");
 
-  py::object py_parent_metaclass = py::reinterpret_borrow<py::object>(
-      (PyObject*) &PyType_Type);
+  py::object py_parent_metaclass =
+      py::reinterpret_borrow<py::object>((PyObject*) &PyType_Type);
 
   py::object py_token_verifier = py_parent_metaclass(
       "_NodeAdaptorTokenVerifier",
@@ -1734,19 +1634,19 @@ Napi::Value Reboot_up(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
   // get out of it will remain valid.
-  auto js_external_reboot = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_reboot =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
   // CHECK(js_external_reboot.CheckTypeTag(&reboot_aio_tests_Reboot));
 
   py::object* py_reboot = js_external_reboot.Value(info.Env()).Data();
 
-  auto js_external_application = NapiSafeReference(
-      info[1].As<Napi::External<py::object>>());
+  auto js_external_application =
+      NapiSafeReference(info[1].As<Napi::External<py::object>>());
 
   py::object* py_application = js_external_application.Value(info.Env()).Data();
 
-  bool local_envoy = false;
+  std::optional<bool> local_envoy;
   if (!info[2].IsUndefined()) {
     local_envoy = info[2].As<Napi::Boolean>();
   }
@@ -1760,12 +1660,16 @@ Napi::Value Reboot_up(const Napi::CallbackInfo& info) {
       info.Env(),
       "Reboot.up(...) in nodejs",
       {"asyncio", "create_task"},
-      [js_external_reboot, // Ensures `py_reboot` remains valid.
+      [js_external_reboot,  // Ensures `py_reboot` remains valid.
        py_reboot,
-       js_external_application, // Ensures `py_application` remains valid.
+       js_external_application,  // Ensures `py_application` remains valid.
        py_application,
        local_envoy,
        local_envoy_port]() {
+        py::object py_local_envoy = py::none();
+        if (local_envoy.has_value()) {
+          py_local_envoy = py::bool_(*local_envoy);
+        }
         return py_reboot->attr("up")(
             py_application,
             // NOTE: while we support subprocess servers
@@ -1774,7 +1678,7 @@ Napi::Value Reboot_up(const Napi::CallbackInfo& info) {
             // clone a process like we do with multiprocessing
             // in Python.
             "in_process"_a = true,
-            "local_envoy"_a = local_envoy,
+            "local_envoy"_a = py_local_envoy,
             "local_envoy_port"_a = local_envoy_port);
       },
       [](py::object py_revision) {
@@ -1790,8 +1694,8 @@ Napi::Value Reboot_up(const Napi::CallbackInfo& info) {
 }
 
 Napi::Value Reboot_down(const Napi::CallbackInfo& info) {
-  auto js_external_reboot = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_reboot =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
   // CHECK(js_external_reboot.CheckTypeTag(&reboot_aio_tests_Reboot));
 
@@ -1801,18 +1705,16 @@ Napi::Value Reboot_down(const Napi::CallbackInfo& info) {
       info.Env(),
       "Reboot.down() in nodejs",
       {"asyncio", "create_task"},
-      [js_external_reboot, // Ensures `py_reboot` remains valid.
-       py_reboot]() {
-        return py_reboot->attr("down")();
-      });
+      [js_external_reboot,  // Ensures `py_reboot` remains valid.
+       py_reboot]() { return py_reboot->attr("down")(); });
 }
 
 Napi::Value Reboot_start(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
   // get out of it will remain valid.
-  auto js_external_reboot = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_reboot =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
   // CHECK(js_external_reboot.CheckTypeTag(&reboot_aio_tests_Reboot));
 
@@ -1826,18 +1728,16 @@ Napi::Value Reboot_start(const Napi::CallbackInfo& info) {
       info.Env(),
       "Reboot.start() in nodejs",
       {"asyncio", "create_task"},
-      [js_external_reboot, // Ensures `py_reboot` remains valid.
-       py_reboot]() {
-        return py_reboot->attr("start")();
-      });
+      [js_external_reboot,  // Ensures `py_reboot` remains valid.
+       py_reboot]() { return py_reboot->attr("start")(); });
 }
 
 Napi::Value Reboot_stop(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
   // get out of it will remain valid.
-  auto js_external_reboot = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_reboot =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
   // CHECK(js_external_reboot.CheckTypeTag(&reboot_aio_tests_Reboot));
 
@@ -1847,22 +1747,18 @@ Napi::Value Reboot_stop(const Napi::CallbackInfo& info) {
       info.Env(),
       "Reboot.stop() in nodejs",
       {"asyncio", "create_task"},
-      [js_external_reboot, // Ensures `py_reboot` remains valid.
-       py_reboot]() {
-        return py_reboot->attr("stop")();
-      });
+      [js_external_reboot,  // Ensures `py_reboot` remains valid.
+       py_reboot]() { return py_reboot->attr("stop")(); });
 
   // Allow Node to exit after we've resolved or rejected the promise.
-  auto js_resolve_reject = Napi::Function::New(
-      info.Env(),
-      [](const Napi::CallbackInfo& info) {
+  auto js_resolve_reject =
+      Napi::Function::New(info.Env(), [](const Napi::CallbackInfo& info) {
         adaptor->AllowNodeToExit(info.Env());
       });
 
-  js_promise
-      .Get("then")
-      .As<Napi::Function>()
-      .Call(js_promise, {js_resolve_reject, js_resolve_reject});
+  js_promise.Get("then").As<Napi::Function>().Call(
+      js_promise,
+      {js_resolve_reject, js_resolve_reject});
 
   return js_promise;
 }
@@ -1873,18 +1769,17 @@ Napi::Value Reboot_url(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
   // get out of it will remain valid.
-  auto js_external_reboot = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_reboot =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
   // CHECK(...CheckTypeTag(...));
 
   py::object* py_reboot = js_external_reboot.Value(info.Env()).Data();
 
-  std::string url = RunCallbackOnPythonEventLoop(
-      [py_reboot]() {
-        py::str url = py_reboot->attr("url")();
-        return std::string(url);
-      });
+  std::string url = RunCallbackOnPythonEventLoop([py_reboot]() {
+    py::str url = py_reboot->attr("url")();
+    return std::string(url);
+  });
 
   return Napi::String::New(info.Env(), url);
 }
@@ -1900,13 +1795,11 @@ Napi::Value Service_constructor(const Napi::CallbackInfo& info) {
 
   std::string id = js_args.Get("id").As<Napi::String>().Utf8Value();
 
-  py::object* py_service = RunCallbackOnPythonEventLoop(
-      [&rbt_module, &node_adaptor, &id]() {
+  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");
+            py_module.attr(node_adaptor.c_str()).attr("_Schedule");
         return new py::object(py_module.attr(node_adaptor.c_str())(
             // The call will stay within the same application.
             "application_id"_a = py::none(),
@@ -1950,8 +1843,7 @@ Napi::Value Service_call(const Napi::CallbackInfo& info) {
 
   // CHECK(...CheckTypeTag(...));
 
-  py::object* py_context =
-      js_external_context.Value(info.Env()).Data();
+  py::object* py_context = js_external_context.Value(info.Env()).Data();
 
   std::string json_request = js_args.Get("jsonRequest").As<Napi::String>();
 
@@ -1961,13 +1853,13 @@ Napi::Value Service_call(const Napi::CallbackInfo& info) {
       info.Env(),
       "servicer._" + kind + "(\"" + method + "\", ...) in nodejs",
       js_external_context,
-      [js_external_service, // Ensures `py_service` remains valid.
+      [js_external_service,  // Ensures `py_service` remains valid.
        py_service,
        kind,
        method,
        request_module,
        request_type,
-       js_external_context, // Ensures `py_context` remains valid.
+       js_external_context,  // Ensures `py_context` remains valid.
        py_context,
        json_request,
        json_options]() {
@@ -1994,9 +1886,7 @@ Napi::Value Service_call(const Napi::CallbackInfo& info) {
             json_request,
             json_options);
       },
-      [](py::object py_json) {
-        return py_json.cast<std::string>();
-      },
+      [](py::object py_json) { return py_json.cast<std::string>(); },
       [](Napi::Env env, std::string&& json) {
         return Napi::String::New(env, json);
       });
@@ -2014,8 +1904,7 @@ Napi::Value Task_await(const Napi::CallbackInfo& info) {
 
   // CHECK(...CheckTypeTag(...));
 
-  py::object* py_context =
-      js_external_context.Value(info.Env()).Data();
+  py::object* py_context = js_external_context.Value(info.Env()).Data();
 
   std::string rbt_module = js_args.Get("rbtModule").As<Napi::String>();
 
@@ -2027,27 +1916,23 @@ Napi::Value Task_await(const Napi::CallbackInfo& info) {
 
   return NodePromiseFromPythonTaskWithContext(
       info.Env(),
-      "rebootdev.nodejs.python.task_await(\""
-          + state_name + "\", \""
-          + method + "\", ...) in nodejs",
+      "rebootdev.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.
+       js_external_context,  // Ensures `py_context` remains valid.
        py_context,
        json_task_id]() {
         return py::module::import("rebootdev.nodejs.python")
             .attr("task_await")(
                 py_context,
-                py::module::import(rbt_module.c_str())
-                    .attr(state_name.c_str()),
+                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>();
-      },
+      [](py::object py_json) { return py_json.cast<std::string>(); },
       [](Napi::Env env, std::string&& json) {
         return Napi::String::New(env, json);
       });
@@ -2078,21 +1963,17 @@ Napi::Value ExternalContext_constructor(const Napi::CallbackInfo& info) {
 
   std::optional<std::string> idempotency_required_reason;
   if (!info[6].IsUndefined()) {
-    idempotency_required_reason =
-        info[6]
-            .As<Napi::String>()
-            .Utf8Value();
+    idempotency_required_reason = info[6].As<Napi::String>().Utf8Value();
   }
 
-  py::object* py_external_context = RunCallbackOnPythonEventLoop(
-      [&name,
-       &url,
-       &bearer_token,
-       &idempotency_seed,
-       &idempotency_required,
-       &idempotency_required_reason]() {
-        py::object py_external = py::module::import(
-            "rebootdev.aio.external");
+  py::object* py_external_context =
+      RunCallbackOnPythonEventLoop([&name,
+                                    &url,
+                                    &bearer_token,
+                                    &idempotency_seed,
+                                    &idempotency_required,
+                                    &idempotency_required_reason]() {
+        py::object py_external = py::module::import("rebootdev.aio.external");
 
         auto convert_str =
             [](const std::optional<std::string>& optional) -> py::object {
@@ -2109,8 +1990,8 @@ Napi::Value ExternalContext_constructor(const Napi::CallbackInfo& info) {
             "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)));
+            "idempotency_required_reason"_a =
+                convert_str(idempotency_required_reason)));
       });
 
   Napi::External<py::object> js_external_context = make_napi_external(
@@ -2122,8 +2003,8 @@ Napi::Value ExternalContext_constructor(const Napi::CallbackInfo& info) {
 }
 
 Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
-  auto js_from_native_external = NapiSafeFunctionReference(
-      info[0].As<Napi::Function>());
+  auto js_from_native_external =
+      NapiSafeFunctionReference(info[0].As<Napi::Function>());
 
   Napi::Array js_servicers = info[1].As<Napi::Array>();
 
@@ -2137,8 +2018,7 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
 
   auto servicer_details = make_servicer_details(info.Env(), js_servicers);
 
-  auto js_initialize = NapiSafeFunctionReference(
-      info[3].As<Napi::Function>());
+  auto js_initialize = NapiSafeFunctionReference(info[3].As<Napi::Function>());
 
   std::optional<std::string> initialize_bearer_token;
   if (!info[4].IsUndefined()) {
@@ -2184,31 +2064,27 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
                     Napi::Function js_create_external_context =
                         Napi::Function::New(
                             env,
-                            [js_from_native_external = std::move(
-                                 js_from_native_external),
+                            [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::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();
+                                bearer_token = js_args.Get("bearerToken")
+                                                   .As<Napi::String>()
+                                                   .Utf8Value();
                               }
 
                               py::object* py_channel_manager =
-                                  js_external_channel_manager
-                                      .Value(info.Env())
+                                  js_external_channel_manager.Value(info.Env())
                                       .Data();
 
                               return NodePromiseFromPythonCallback(
@@ -2246,32 +2122,30 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
                                       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(
+                                    Napi::External<py::object>
+                                        // (check_line_length skip)
+                                        js_external_context = make_napi_external(
                                             env,
                                             py_context,
                                             // (check_line_length skip)
                                             &reboot_aio_external_ExternalContext);
 
-                                    return js_from_native_external
-                                        .Value(env)
+                                    return js_from_native_external.Value(env)
                                         .Call(
                                             env.Global(),
                                             {js_external_context,
-                                             // (check_line_length skip)
-                                             Napi::String::New(env, "external")});
+                                             Napi::String::New(
+                                                 env,
+                                                 "external")});
                                   });
                             });
 
-                    return js_web_framework_start
-                        .Value(env)
+                    return js_web_framework_start.Value(env)
                         .Call(
                             env.Global(),
                             {Napi::String::New(env, server_id),
-                             port.has_value()
-                                 ? Napi::Number::New(env, *port)
-                                 : env.Null(),
+                             port.has_value() ? Napi::Number::New(env, *port)
+                                              : env.Null(),
                              js_create_external_context})
                         .As<Napi::Object>();
                   },
@@ -2282,17 +2156,13 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
             });
 
         py::object py_web_framework_stop = py::cpp_function(
-            [js_web_framework_stop = std::move(js_web_framework_stop)](
-                std::string server_id) {
+            [js_web_framework_stop =
+                 std::move(js_web_framework_stop)](std::string server_id) {
               return PythonFutureFromNodePromise(
                   [js_web_framework_stop = std::move(js_web_framework_stop),
-                   server_id = std::move(server_id)](
-                      Napi::Env env) mutable {
-                    return js_web_framework_stop
-                        .Value(env)
-                        .Call(
-                            env.Global(),
-                            {Napi::String::New(env, server_id)})
+                   server_id = std::move(server_id)](Napi::Env env) mutable {
+                    return js_web_framework_stop.Value(env)
+                        .Call(env.Global(), {Napi::String::New(env, server_id)})
                         .As<Napi::Object>();
                   });
             });
@@ -2303,15 +2173,15 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
                 py::object py_context) mutable {
               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 {
+                   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 =
                         make_napi_external(
                             env,
@@ -2319,16 +2189,14 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
                             &reboot_aio_external_ExternalContext);
 
                     Napi::Object js_context =
-                        js_from_native_external
-                            .Value(env)
+                        js_from_native_external.Value(env)
                             .Call(
                                 env.Global(),
                                 {js_external_context,
                                  Napi::String::New(env, "initialize")})
                             .As<Napi::Object>();
 
-                    return js_initialize
-                        .Value(env)
+                    return js_initialize.Value(env)
                         .Call(env.Global(), {js_context})
                         .As<Napi::Object>();
                   });
@@ -2351,8 +2219,7 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
                     "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,
+                    "initialize_bearer_token"_a = py_initialize_bearer_token,
                     "token_verifier"_a = py_token_verifier));
       });
 
@@ -2370,47 +2237,37 @@ Napi::Value Application_run(const Napi::CallbackInfo& info) {
   // that we can get calls from Python.
   adaptor->KeepNodeFromExiting(info.Env());
 
-  auto js_external_application = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_application =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
-  py::object* py_application =
-      js_external_application.Value(info.Env()).Data();
+  py::object* py_application = js_external_application.Value(info.Env()).Data();
 
   Napi::Promise js_promise = NodePromiseFromPythonTask(
       info.Env(),
       "Application.run() in nodejs",
       {"rebootdev.nodejs.python", "create_task"},
-      [js_external_application, // Ensures `py_application` remains valid.
-       py_application]() {
-        return py_application->attr("run")();
-      });
+      [js_external_application,  // Ensures `py_application` remains valid.
+       py_application]() { return py_application->attr("run")(); });
 
   // 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) {
-                 // Allow Node to exit after `Application.run` returns.
-                 adaptor->AllowNodeToExit(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);
-
-                 // Allow Node to exit after `Application.run` returns.
-                 adaptor->AllowNodeToExit(info.Env());
-               })});
+  js_promise.Get("then").As<Napi::Function>().Call(
+      js_promise,
+      {Napi::Function::New(
+           info.Env(),
+           [](const Napi::CallbackInfo& info) {
+             // Allow Node to exit after `Application.run` returns.
+             adaptor->AllowNodeToExit(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);
+
+         // Allow Node to exit after `Application.run` returns.
+         adaptor->AllowNodeToExit(info.Env());
+       })});
 
   return js_promise;
 }
@@ -2420,22 +2277,18 @@ 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
   // get out of it will remain valid.
-  auto js_external_context = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_context =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
   py::object* py_context = js_external_context.Value(info.Env()).Data();
 
-  std::string state_type =
-      info[1].As<Napi::String>().Utf8Value();
+  std::string state_type = info[1].As<Napi::String>().Utf8Value();
 
-  std::string service_name =
-      info[2].As<Napi::String>().Utf8Value();
+  std::string service_name = info[2].As<Napi::String>().Utf8Value();
 
-  std::string method =
-      info[3].As<Napi::String>().Utf8Value();
+  std::string method = info[3].As<Napi::String>().Utf8Value();
 
-  Napi::Object idempotency_options =
-      info[4].As<Napi::Object>();
+  Napi::Object idempotency_options = info[4].As<Napi::Object>();
   auto js_key = idempotency_options.Get("key");
   std::optional<std::string> key;
   if (js_key.IsString()) {
@@ -2454,7 +2307,7 @@ Napi::Value Context_generateIdempotentStateId(const Napi::CallbackInfo& info) {
 
   return NodePromiseFromPythonCallback(
       info.Env(),
-      [js_external_context, // Ensures `py_context` remains valid.
+      [js_external_context,  // Ensures `py_context` remains valid.
        py_context,
        state_type = std::move(state_type),
        service_name = std::move(service_name),
@@ -2510,25 +2363,23 @@ Napi::Value WriterContext_set_sync(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
   // get out of it will remain valid.
-  auto js_external_context = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_context =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
   py::object* py_context = js_external_context.Value(info.Env()).Data();
 
   bool sync = info[1].As<Napi::Boolean>();
 
   RunCallbackOnPythonEventLoop(
-      [&py_context, sync]() {
-        py_context->attr("sync") = sync;
-      });
+      [&py_context, sync]() { py_context->attr("sync") = sync; });
 
   return info.Env().Undefined();
 }
 
 
 Napi::Value WorkflowContext_loop(const Napi::CallbackInfo& info) {
-  auto js_external_context = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_context =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
   // CHECK(...CheckTypeTag(...));
 
@@ -2540,51 +2391,47 @@ Napi::Value WorkflowContext_loop(const Napi::CallbackInfo& info) {
       info.Env(),
       "context.loop(...) in nodejs",
       js_external_context,
-      [js_external_context, // Ensures `py_context` remains valid.
+      [js_external_context,  // Ensures `py_context` remains valid.
        py_context,
        alias = std::move(alias)]() {
         return py::module::import("rebootdev.nodejs.python")
             .attr("loop")(py_context, alias);
       },
-      [](py::object py_iterate) {
-        return new py::object(py_iterate);
-      },
+      [](py::object py_iterate) { return new py::object(py_iterate); },
       [js_external_context](Napi::Env env, py::object* py_iterate) mutable {
         Napi::External<py::object> js_iterate_external =
             make_napi_external(env, py_iterate);
 
-        Napi::Function js_iterate =
-            Napi::Function::New(
-                env,
-                [js_external_context,
-                 js_iterate_external = // Ensures `py_iterate` remains valid.
-                 NapiSafeReference(js_iterate_external),
-                 py_iterate](
-                    const Napi::CallbackInfo& info) mutable {
-                  bool more = info[0].As<Napi::Boolean>();
-                  return NodePromiseFromPythonTaskWithContext(
-                      info.Env(),
-                      "iterate(...) in nodejs",
-                      js_external_context,
-                      [js_iterate_external, py_iterate, more]() {
-                        return (*py_iterate)(more);
-                      },
-                      [](py::object py_iteration) -> std::optional<int> {
-                        if (!py_iteration.is_none()) {
-                          return py_iteration.cast<int>();
-                        } else {
-                          return std::nullopt;
-                        }
-                      },
-                      [](Napi::Env env,
-                         std::optional<int>&& iteration) -> Napi::Value {
-                        if (iteration.has_value()) {
-                          return Napi::Number::New(env, *iteration);
-                        } else {
-                          return env.Null();
-                        }
-                      });
-                });
+        Napi::Function js_iterate = Napi::Function::New(
+            env,
+            [js_external_context,
+             js_iterate_external =  // Ensures `py_iterate` remains valid.
+             NapiSafeReference(js_iterate_external),
+             py_iterate](const Napi::CallbackInfo& info) mutable {
+              bool more = info[0].As<Napi::Boolean>();
+              return NodePromiseFromPythonTaskWithContext(
+                  info.Env(),
+                  "iterate(...) in nodejs",
+                  js_external_context,
+                  [js_iterate_external, py_iterate, more]() {
+                    return (*py_iterate)(more);
+                  },
+                  [](py::object py_iteration) -> std::optional<int> {
+                    if (!py_iteration.is_none()) {
+                      return py_iteration.cast<int>();
+                    } else {
+                      return std::nullopt;
+                    }
+                  },
+                  [](Napi::Env env,
+                     std::optional<int>&& iteration) -> Napi::Value {
+                    if (iteration.has_value()) {
+                      return Napi::Number::New(env, *iteration);
+                    } else {
+                      return env.Null();
+                    }
+                  });
+            });
 
         return js_iterate;
       });
@@ -2592,21 +2439,20 @@ Napi::Value WorkflowContext_loop(const Napi::CallbackInfo& info) {
 
 
 Napi::Value retry_reactively_until(const Napi::CallbackInfo& info) {
-  auto js_external_context = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_context =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
   // CHECK(...CheckTypeTag(...));
 
   py::object* py_context = js_external_context.Value(info.Env()).Data();
 
-  auto js_condition = NapiSafeFunctionReference(
-      info[1].As<Napi::Function>());
+  auto js_condition = NapiSafeFunctionReference(info[1].As<Napi::Function>());
 
   return NodePromiseFromPythonTaskWithContext(
       info.Env(),
       "retry_reactively_until(...) in nodejs",
       js_external_context,
-      [js_external_context, // Ensures `py_context` remains valid.
+      [js_external_context,  // Ensures `py_context` remains valid.
        py_context,
        js_condition = std::move(js_condition)]() {
         py::object py_condition = py::cpp_function(
@@ -2617,8 +2463,7 @@ Napi::Value retry_reactively_until(const Napi::CallbackInfo& info) {
                   // `py_condition` may be called more
                   // than once!
                   [js_condition](Napi::Env env) mutable {
-                    return js_condition
-                        .Value(env)
+                    return js_condition.Value(env)
                         .Call(env.Global(), {})
                         .As<Napi::Object>();
                   },
@@ -2634,8 +2479,8 @@ Napi::Value retry_reactively_until(const Napi::CallbackInfo& info) {
 
 
 Napi::Value memoize(const Napi::CallbackInfo& info) {
-  auto js_external_context = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_context =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
   // CHECK(...CheckTypeTag(...));
 
@@ -2647,8 +2492,7 @@ Napi::Value memoize(const Napi::CallbackInfo& info) {
   auto js_how = idempotency_tuple.Get((uint32_t) 1);
   std::string how = js_how.As<Napi::String>().Utf8Value();
 
-  auto js_callable = NapiSafeFunctionReference(
-      info[2].As<Napi::Function>());
+  auto js_callable = NapiSafeFunctionReference(info[2].As<Napi::Function>());
 
   bool at_most_once = info[3].As<Napi::Boolean>();
 
@@ -2658,21 +2502,20 @@ Napi::Value memoize(const Napi::CallbackInfo& info) {
       info.Env(),
       "memoize(...) in nodejs",
       js_external_context,
-      [js_external_context, // Ensures `py_context` remains valid.
+      [js_external_context,  // Ensures `py_context` remains valid.
        py_context,
        alias = std::move(alias),
        how = std::move(how),
        js_callable = std::move(js_callable),
        at_most_once,
        until]() {
-        py::object py_callable = py::cpp_function(
-            [js_callable = std::move(js_callable)]() mutable {
+        py::object py_callable =
+            py::cpp_function([js_callable = std::move(js_callable)]() mutable {
               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)
+                    return js_callable.Value(env)
                         .Call(env.Global(), {})
                         .As<Napi::Object>();
                   },
@@ -2690,9 +2533,7 @@ Napi::Value memoize(const Napi::CallbackInfo& info) {
                 "at_most_once"_a = at_most_once,
                 "until"_a = until);
       },
-      [](py::object py_json) {
-        return py_json.cast<std::string>();
-      },
+      [](py::object py_json) { return py_json.cast<std::string>(); },
       [](Napi::Env env, std::string&& json) {
         return Napi::String::New(env, json);
       });
@@ -2700,15 +2541,15 @@ Napi::Value memoize(const Napi::CallbackInfo& info) {
 
 
 Napi::Value Servicer_read(const Napi::CallbackInfo& info) {
-  auto js_external_servicer = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_servicer =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
   // CHECK(...CheckTypeTag(...));
 
   py::object* py_servicer = js_external_servicer.Value(info.Env()).Data();
 
-  auto js_external_context = NapiSafeReference(
-      info[1].As<Napi::External<py::object>>());
+  auto js_external_context =
+      NapiSafeReference(info[1].As<Napi::External<py::object>>());
 
   // CHECK(...CheckTypeTag(...));
 
@@ -2720,16 +2561,14 @@ Napi::Value Servicer_read(const Napi::CallbackInfo& info) {
       info.Env(),
       "servicer._read(...) in nodejs",
       js_external_context,
-      [js_external_servicer, // Ensures `py_servicer` remains valid.
+      [js_external_servicer,  // Ensures `py_servicer` remains valid.
        py_servicer,
-       js_external_context, // Ensures `py_context` remains valid.
+       js_external_context,  // Ensures `py_context` remains valid.
        py_context,
        json_options = std::move(json_options)]() {
         return py_servicer->attr("_read")(py_context, json_options);
       },
-      [](py::object py_json) {
-        return py_json.cast<std::string>();
-      },
+      [](py::object py_json) { return py_json.cast<std::string>(); },
       [](Napi::Env env, std::string&& json) {
         return Napi::String::New(env, json);
       });
@@ -2737,22 +2576,21 @@ Napi::Value Servicer_read(const Napi::CallbackInfo& info) {
 
 
 Napi::Value Servicer_write(const Napi::CallbackInfo& info) {
-  auto js_external_servicer = NapiSafeReference(
-      info[0].As<Napi::External<py::object>>());
+  auto js_external_servicer =
+      NapiSafeReference(info[0].As<Napi::External<py::object>>());
 
   // CHECK(...CheckTypeTag(...));
 
   py::object* py_servicer = js_external_servicer.Value(info.Env()).Data();
 
-  auto js_external_context = NapiSafeReference(
-      info[1].As<Napi::External<py::object>>());
+  auto js_external_context =
+      NapiSafeReference(info[1].As<Napi::External<py::object>>());
 
   // CHECK(...CheckTypeTag(...));
 
   py::object* py_context = js_external_context.Value(info.Env()).Data();
 
-  auto js_writer = NapiSafeFunctionReference(
-      info[2].As<Napi::Function>());
+  auto js_writer = NapiSafeFunctionReference(info[2].As<Napi::Function>());
 
   std::string json_options = info[3].As<Napi::String>().Utf8Value();
 
@@ -2760,23 +2598,21 @@ Napi::Value Servicer_write(const Napi::CallbackInfo& info) {
       info.Env(),
       "servicer._write(...) in nodejs",
       js_external_context,
-      [js_external_servicer, // Ensures `py_servicer` remains valid.
+      [js_external_servicer,  // Ensures `py_servicer` remains valid.
        py_servicer,
-       js_external_context, // Ensures `py_context` remains valid.
+       js_external_context,  // Ensures `py_context` remains valid.
        py_context,
        js_writer = std::move(js_writer),
        json_options = std::move(json_options)]() {
         py::object py_writer = py::cpp_function(
-            [js_writer = std::move(js_writer)](
-                std::string state_json) mutable {
+            [js_writer = std::move(js_writer)](std::string state_json) mutable {
               return PythonFutureFromNodePromise(
-                  [js_writer, // NOTE: need a _copy_ of
-                              // `js_writer` here since
-                              // `py_writer` may be called more
-                              // than once!
+                  [js_writer,  // NOTE: need a _copy_ of
+                               // `js_writer` here since
+                               // `py_writer` may be called more
+                               // than once!
                    state_json](Napi::Env env) mutable {
-                    return js_writer
-                        .Value(env)
+                    return js_writer.Value(env)
                         .Call(
                             env.Global(),
                             {Napi::String::New(env, state_json)})
@@ -2787,14 +2623,9 @@ Napi::Value Servicer_write(const Napi::CallbackInfo& info) {
                   });
             });
 
-        return py_servicer->attr("_write")(
-            py_context,
-            py_writer,
-            json_options);
-      },
-      [](py::object py_result) {
-        return py_result.cast<std::string>();
+        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);
       });