@reboot-dev/reboot 0.25.5 → 0.25.6

package/index.d.ts

@@ -43,9 +43,9 @@ export declare function getContext(): Context;
 export declare function runWithContext<T>(context: Context, callback: () => T): Promise<T>;
 export declare class Context {
     #private;
-    readonly aborted: Promise<void>;
-    constructor(external: any, aborted: Promise<void>);
-    static fromNativeExternal(external: any, kind: string, aborted: Promise<void>): ReaderContext | WriterContext | TransactionContext | WorkflowContext;
+    readonly cancelled: Promise<void>;
+    constructor(external: any, cancelled: Promise<void>);
+    static fromNativeExternal(external: any, kind: string, cancelled: Promise<void>): ReaderContext | WriterContext | TransactionContext | WorkflowContext;
     get __external(): any;
     get auth(): Auth | null;
     get stateId(): string;
@@ -57,20 +57,20 @@ export declare class Context {
 }
 export declare class ReaderContext extends Context {
     #private;
-    constructor(external: any, aborted: any);
+    constructor(external: any, cancelled: any);
 }
 export declare class WriterContext extends Context {
     #private;
-    constructor(external: any, aborted: any);
+    constructor(external: any, cancelled: any);
     set sync(sync: boolean);
 }
 export declare class TransactionContext extends Context {
     #private;
-    constructor(external: any, aborted: any);
+    constructor(external: any, cancelled: any);
 }
 export declare class WorkflowContext extends Context {
     #private;
-    constructor(external: any, aborted: any);
+    constructor(external: any, cancelled: any);
 }
 export declare function clearField(field: any, target: any): void;
 export declare function clearFields(target: any): void;

package/index.js

@@ -138,28 +138,28 @@ export async function runWithContext(context, callback) {
     return await contextStorage.run(context, callback);
 }
 export class Context {
-    constructor(external, aborted) {
+    constructor(external, cancelled) {
         _Context_external.set(this, void 0);
         if (!__classPrivateFieldGet(_a, _a, "f", _Context_isInternalConstructing)) {
             throw new TypeError("Context is not publicly constructable");
         }
         __classPrivateFieldSet(_a, _a, false, "f", _Context_isInternalConstructing);
         __classPrivateFieldSet(this, _Context_external, external, "f");
-        this.aborted = aborted;
+        this.cancelled = cancelled;
     }
-    static fromNativeExternal(external, kind, aborted) {
+    static fromNativeExternal(external, kind, cancelled) {
         __classPrivateFieldSet(_a, _a, true, "f", _Context_isInternalConstructing);
         if (kind === "reader") {
-            return new ReaderContext(external, aborted);
+            return new ReaderContext(external, cancelled);
         }
         else if (kind === "writer") {
-            return new WriterContext(external, aborted);
+            return new WriterContext(external, cancelled);
         }
         else if (kind === "transaction") {
-            return new TransactionContext(external, aborted);
+            return new TransactionContext(external, cancelled);
         }
         else if (kind === "workflow") {
-            return new WorkflowContext(external, aborted);
+            return new WorkflowContext(external, cancelled);
         }
         throw new Error("Unknown method kind");
     }
@@ -195,8 +195,8 @@ export class Context {
 _a = Context, _Context_external = new WeakMap();
 _Context_isInternalConstructing = { value: false };
 export class ReaderContext extends Context {
-    constructor(external, aborted) {
-        super(external, aborted);
+    constructor(external, cancelled) {
+        super(external, cancelled);
         // Property helps `tsc` not treat a `ReaderContext` as any other
         // context type that structurally looks equivalent.
         _ReaderContext_kind.set(this, "reader");
@@ -204,8 +204,8 @@ export class ReaderContext extends Context {
 }
 _ReaderContext_kind = new WeakMap();
 export class WriterContext extends Context {
-    constructor(external, aborted) {
-        super(external, aborted);
+    constructor(external, cancelled) {
+        super(external, cancelled);
         // Property helps `tsc` not treat a `WriterContext` as any other
         // context type that structurally looks equivalent.
         _WriterContext_kind.set(this, "writer");
@@ -228,8 +228,8 @@ export class WriterContext extends Context {
 }
 _WriterContext_kind = new WeakMap();
 export class TransactionContext extends Context {
-    constructor(external, aborted) {
-        super(external, aborted);
+    constructor(external, cancelled) {
+        super(external, cancelled);
         // Property helps `tsc` not treat a `TransactionContext` as any other
         // context type that structurally looks equivalent.
         _TransactionContext_kind.set(this, "transaction");
@@ -237,8 +237,8 @@ export class TransactionContext extends Context {
 }
 _TransactionContext_kind = new WeakMap();
 export class WorkflowContext extends Context {
-    constructor(external, aborted) {
-        super(external, aborted);
+    constructor(external, cancelled) {
+        super(external, cancelled);
         // Property helps `tsc` not treat a `WorkflowContext` as any other
         // context type that structurally looks equivalent.
         _WorkflowContext_kind.set(this, "workflow");
@@ -455,6 +455,7 @@ export class Application {
         // TODO: expose `.use()` to allow users to add their own middleware.
         __classPrivateFieldGet(this, _Application_express, "f").use(express.json());
         __classPrivateFieldGet(this, _Application_express, "f").use(express.urlencoded({ extended: true }));
+        __classPrivateFieldGet(this, _Application_express, "f").disable("x-powered-by");
         __classPrivateFieldSet(this, _Application_http, new Application.Http(__classPrivateFieldGet(this, _Application_express, "f"), async (args) => {
             return await __classPrivateFieldGet(this, _Application_createExternalContext, "f").call(this, args);
         }), "f");

package/package.json

@@ -3,7 +3,7 @@
     "@bufbuild/protobuf": "1.3.2",
     "@bufbuild/protoplugin": "1.3.2",
     "@bufbuild/protoc-gen-es": "1.3.2",
-    "@reboot-dev/reboot-api": "0.25.5",
+    "@reboot-dev/reboot-api": "0.25.6",
     "chalk": "^4.1.2",
     "node-addon-api": "^7.0.0",
     "node-gyp": ">=10.2.0",
@@ -16,7 +16,7 @@
   },
   "type": "module",
   "name": "@reboot-dev/reboot",
-  "version": "0.25.5",
+  "version": "0.25.6",
   "description": "npm package for Reboot",
   "scripts": {
     "postinstall": "rbt || exit 0",

package/reboot_native.cc

@@ -2,6 +2,7 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
+#include <atomic>
 #include <future>
 #include <iostream>
 #include <list>
@@ -38,7 +39,7 @@ struct PythonNodeAdaptor {
             dynamic_cast<const py::error_already_set*>(&e)) {
       // This is a Python exception. Is it an `InputError`?
       if (e_py->matches(py::module::import(
-                            "reboot.controller.exceptions")
+                            "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
@@ -131,6 +132,36 @@ struct PythonNodeAdaptor {
     }
   }
 
+  void KeepNodeFromExiting(Napi::Env env) {
+    if (references.fetch_add(1, std::memory_order_acq_rel) == 0) {
+      // Call `Ref()` on our NAPI thread safe function so that it
+      // can't be cleaned up and thus we won't exit.
+      //
+      // NOTE: `Ref()` and `Unref()` will just set and unset an
+      // "is_referenced" boolean flag, rather than incrementing and
+      // decrementing a reference count, hence we do the atomic
+      // reference counting ourselves.
+      thread_safe_function.Ref(env);
+    }
+  }
+
+  void AllowNodeToExit(Napi::Env env) {
+    if (references.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+      // Call `Unref()` on our NAPI thread safe function so that it
+      // can be cleaned up and we can exit.
+      //
+      // NOTE: `Ref()` and `Unref()` will just set and unset an
+      // "is_referenced" boolean flag, rather than incrementing and
+      // decrementing a reference count, hence we do the atomic
+      // reference counting ourselves.
+      thread_safe_function.Unref(env);
+    }
+  }
+
+  // Reference counting to keep Node from exiting when we're calling
+  // into Python or expecting calls from Python.
+  std::atomic<int> references{0};
+
   Napi::ThreadSafeFunction thread_safe_function;
 
   bool thread_safe_function_finalized = false;
@@ -267,7 +298,7 @@ void PythonNodeAdaptor::Initialize(
         py::initialize_interpreter();
 
         try {
-          py::object module = py::module::import("reboot.nodejs.python");
+          py::object module = py::module::import("rebootdev.nodejs.python");
 
           module.attr("launch_subprocess_consensus") = py::cpp_function(
               [](py::str py_base64_args) {
@@ -476,46 +507,70 @@ 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();
+  // Keep Node from exiting since we are calling into Python and Node
+  // otherwise might not know that outstanding promises that may be
+  // being `await`'ed are still being worked on.
+  //
+  // TODO: if `Application.run()` was called then Node will already
+  // not exit so unfortunately this is a noop and worse, the extra
+  // callback we attach to the promise via `.then()` below hurts
+  // performance. Consider a mechanism in that case and possibly
+  // others where we can not do this for better performance but still
+  // be correct.
+  adaptor->KeepNodeFromExiting(env);
+
+  auto js_deferred = std::make_shared<Napi::Promise::Deferred>(env);
+  auto js_promise = js_deferred->Promise();
 
   adaptor->ScheduleCallbackOnPythonEventLoop(
       [python_callback = std::forward<PythonCallback>(python_callback),
        node_callback = std::forward<NodeCallback>(node_callback),
-       deferred = std::move(deferred)]() mutable {
+       js_deferred = std::move(js_deferred)]() mutable {
         try {
           auto result = python_callback();
           adaptor->ScheduleCallbackOnNodeEventLoop(
               [node_callback = std::forward<NodeCallback>(node_callback),
-               deferred = std::move(deferred),
+               js_deferred = std::move(js_deferred),
                result = std::move(result)](Napi::Env env) mutable {
                 try {
-                  deferred->Resolve(node_callback(env, std::move(result)));
+                  js_deferred->Resolve(node_callback(env, std::move(result)));
                 } catch (const Napi::Error& e) {
-                  deferred->Reject(e.Value());
+                  js_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(
+                  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`?
-                  deferred->Reject(
+                  js_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),
+              [js_deferred = std::move(js_deferred),
                exception = std::move(exception)](Napi::Env env) mutable {
-                deferred->Reject(Napi::Error::New(env, exception).Value());
+                js_deferred->Reject(Napi::Error::New(env, exception).Value());
               });
         }
       });
 
-  return promise;
+  // Allow Node to exit after we've resolved or rejected the promise.
+  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});
+
+  return js_promise;
 }
 
 
@@ -528,8 +583,20 @@ Napi::Promise NodePromiseFromPythonFuture(
     PythonFutureCallback&& python_future_callback,
     PythonDoneCallback&& python_done_callback,
     NodeCallback&& node_callback) {
-  auto deferred = std::make_shared<Napi::Promise::Deferred>(env);
-  auto promise = deferred->Promise();
+  // Keep Node from exiting since we are calling into Python and Node
+  // otherwise might not know that outstanding promises that may be
+  // being `await`'ed are still being worked on.
+  //
+  // TODO: if `Application.run()` was called then Node will already
+  // not exit so unfortunately this is a noop and worse, the extra
+  // callback we attach to the promise via `.then()` below hurts
+  // performance. Consider a mechanism in that case and possibly
+  // others where we can not do this for better performance but still
+  // be correct.
+  adaptor->KeepNodeFromExiting(env);
+
+  auto js_deferred = std::make_shared<Napi::Promise::Deferred>(env);
+  auto js_promise = js_deferred->Promise();
 
   adaptor->ScheduleCallbackOnPythonEventLoop(
       [python_future_callback = std::forward<PythonFutureCallback>(
@@ -537,7 +604,7 @@ Napi::Promise NodePromiseFromPythonFuture(
        python_done_callback = std::forward<PythonDoneCallback>(
            python_done_callback),
        node_callback = std::forward<NodeCallback>(node_callback),
-       deferred = std::move(deferred)]() mutable {
+       js_deferred = std::move(js_deferred)]() mutable {
         try {
           // TODO: check that `py_future` is a future!
           py::object py_future = python_future_callback();
@@ -546,35 +613,45 @@ Napi::Promise NodePromiseFromPythonFuture(
               [python_done_callback = std::forward<PythonDoneCallback>(
                    python_done_callback),
                node_callback = std::forward<NodeCallback>(node_callback),
-               deferred = std::move(deferred),
+               js_deferred = std::move(js_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;
-
+                // Need to check `cancelled()` _first_ because
+                // `exception()` will raise if it has been cancelled.
+                if (py_future->attr("cancelled")().cast<bool>()) {
                   adaptor->ScheduleCallbackOnNodeEventLoop(
-                      [deferred = std::move(deferred),
-                       exception = std::move(exception)](Napi::Env env) {
-                        deferred->Reject(
-                            Napi::Error::New(env, exception).Value());
+                      [js_deferred = std::move(js_deferred)](Napi::Env env) {
+                        js_deferred->Reject(
+                            Napi::Error::New(env, "Cancelled").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);
-                      });
+                  py::object py_exception = py_future->attr("exception")();
+                  if (!py_exception.is_none()) {
+                    std::string exception = py_exception_str(py_exception);
+                    adaptor->ScheduleCallbackOnNodeEventLoop(
+                        [js_deferred = std::move(js_deferred),
+                         exception = std::move(exception)](Napi::Env env) {
+                          js_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),
+                         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));
+                          js_deferred->Resolve(js_result);
+                        });
+                  }
                 }
                 delete py_future;
               },
@@ -582,14 +659,26 @@ Napi::Promise NodePromiseFromPythonFuture(
         } catch (pybind11::error_already_set& e) {
           std::string exception = py_exception_str(e.value());
           adaptor->ScheduleCallbackOnNodeEventLoop(
-              [deferred = std::move(deferred),
+              [js_deferred = std::move(js_deferred),
                exception = std::move(exception)](Napi::Env env) mutable {
-                deferred->Reject(Napi::Error::New(env, exception).Value());
+                js_deferred->Reject(Napi::Error::New(env, exception).Value());
               });
         }
       });
 
-  return promise;
+  // Allow Node to exit after we've resolved or rejected the promise.
+  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});
+
+  return js_promise;
 }
 
 
@@ -685,7 +774,7 @@ Napi::Promise NodePromiseFromPythonTaskWithContext(
       env,
       std::move(name),
       std::make_tuple(
-          std::string("reboot.nodejs.python"),
+          std::string("rebootdev.nodejs.python"),
           std::string("create_task_with_context"),
           py_context),
       [js_context, // Ensures `py_context` remains valid.
@@ -899,7 +988,7 @@ void ImportPy(const Napi::CallbackInfo& info) {
 
   RunCallbackOnPythonEventLoop(
       [&module, &base64_encoded_rbt_py]() {
-        py::module::import("reboot.nodejs.python")
+        py::module::import("rebootdev.nodejs.python")
             .attr("import_py")(module, base64_encoded_rbt_py);
       });
 }
@@ -937,7 +1026,7 @@ static const napi_type_tag reboot_aio_applications_Application = MakeTypeTag(
 
 
 static const napi_type_tag reboot_aio_external_ExternalContext = MakeTypeTag(
-    "reboot.aio.external",
+    "rebootdev.aio.external",
     "ExternalContext");
 
 
@@ -1047,20 +1136,20 @@ Napi::Value Reboot_createExternalContext(const Napi::CallbackInfo& info) {
 Napi::Object make_js_context(
     Napi::Env& env,
     py::object* py_context,
-    py::object* py_aborted,
+    py::object* py_cancelled,
     const std::string& kind) {
   Napi::External<py::object> js_external_context =
       make_napi_external(env, py_context);
 
-  Napi::Promise js_aborted = NodePromiseFromPythonFuture(
+  Napi::Promise js_cancelled = NodePromiseFromPythonFuture(
       env,
-      [py_aborted]() {
-        // After returning we won't need `py_aborted` anymore, so we
+      [py_cancelled]() {
+        // After returning we won't need `py_cancelled` 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_cancelled_on_stack = *py_cancelled;
+        delete py_cancelled;
+        return py_cancelled_on_stack;
       },
       [](py::object py_result) {
         // TODO: check that `py_result` is `None`.
@@ -1077,7 +1166,7 @@ Napi::Object make_js_context(
       ->Call(
           {js_external_context,
            Napi::String::New(env, kind),
-           js_aborted})
+           js_cancelled})
       .As<Napi::Object>();
 }
 
@@ -1104,7 +1193,7 @@ py::object make_py_authorizer(NapiSafeObjectReference js_authorizer) {
       [](py::object self,
          const std::string& method_name,
          py::object py_reader_context,
-         py::object py_aborted,
+         py::object py_cancelled,
          std::optional<std::string> bytes_state,
          std::optional<std::string> bytes_request) {
         NapiSafeObjectReference* js_authorizer_reference =
@@ -1114,14 +1203,17 @@ py::object make_py_authorizer(NapiSafeObjectReference js_authorizer) {
         return PythonFutureFromNodePromise(
             [js_authorizer_reference,
              py_reader_context = new py::object(py_reader_context),
-             py_aborted = new py::object(py_aborted),
+             py_cancelled = new py::object(py_cancelled),
              method_name,
              bytes_state = std::move(bytes_state),
              bytes_request = std::move(bytes_request)](Napi::Env env) {
               std::vector<Napi::Value> js_args;
 
-              Napi::Object js_context =
-                  make_js_context(env, py_reader_context, py_aborted, "reader");
+              Napi::Object js_context = make_js_context(
+                  env,
+                  py_reader_context,
+                  py_cancelled,
+                  "reader");
 
               Napi::Object js_authorizer = js_authorizer_reference->Value(env);
 
@@ -1153,14 +1245,14 @@ py::object make_py_authorizer(NapiSafeObjectReference js_authorizer) {
       py::name("_authorize"),
       py::arg("method_name"),
       py::arg("context"),
-      py::arg("aborted"),
+      py::arg("cancelled"),
       py::arg("state"),
       py::arg("request"),
       py::is_method(py::none()));
 
   // Now define our subclass.
   py::object py_parent_class =
-      py::module::import("reboot.nodejs.python")
+      py::module::import("rebootdev.nodejs.python")
           .attr("NodeAdaptorAuthorizer");
 
   py::object py_parent_metaclass = py::reinterpret_borrow<py::object>(
@@ -1323,7 +1415,7 @@ py::object make_py_user_servicer(
          const std::string& kind,
          const std::string& method,
          py::object py_context,
-         py::object py_aborted,
+         py::object py_cancelled,
          const std::string& json_state,
          const std::string& json_request) {
         return PythonFutureFromNodePromise(
@@ -1331,13 +1423,13 @@ py::object make_py_user_servicer(
              kind,
              method,
              py_context = new py::object(py_context),
-             py_aborted = new py::object(py_aborted),
+             py_cancelled = new py::object(py_cancelled),
              json_state,
              json_request](Napi::Env env) {
               std::vector<Napi::Value> js_args;
 
               Napi::Object js_context =
-                  make_js_context(env, py_context, py_aborted, kind);
+                  make_js_context(env, py_context, py_cancelled, kind);
 
               js_args.push_back(js_context);
 
@@ -1469,7 +1561,7 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
   attributes["_verify_token"] = py::cpp_function(
       [](py::object self,
          py::object py_reader_context,
-         py::object py_aborted,
+         py::object py_cancelled,
          py::object py_token) {
         NapiSafeObjectReference* js_token_verifier_reference =
             self.attr("_js_token_verifier")
@@ -1485,12 +1577,12 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
 
         return PythonFutureFromNodePromise(
             [js_token_verifier_reference,
-             // We allocate 'py_aborted' and 'py_reader_context' with 'new
+             // We allocate 'py_cancelled' 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),
+             py_cancelled = new py::object(py_cancelled),
              token = std::move(token)](Napi::Env env) {
               std::vector<Napi::Value> js_args;
 
@@ -1498,7 +1590,7 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
                   make_js_context(
                       env,
                       py_reader_context,
-                      py_aborted,
+                      py_cancelled,
                       "reader"));
 
               if (token.has_value()) {
@@ -1533,12 +1625,12 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
       },
       py::name("_verify_token"),
       py::arg("context"),
-      py::arg("aborted"),
+      py::arg("cancelled"),
       py::arg("py_token"),
       py::is_method(py::none()));
 
   py::object py_parent_class =
-      py::module::import("reboot.nodejs.python")
+      py::module::import("rebootdev.nodejs.python")
           .attr("NodeAdaptorTokenVerifier");
 
   py::object py_parent_metaclass = py::reinterpret_borrow<py::object>(
@@ -1634,14 +1726,9 @@ Napi::Value Reboot_start(const Napi::CallbackInfo& info) {
 
   py::object* py_reboot = js_external_reboot.Value(info.Env()).Data();
 
-  // Call Ref() on our NAPI thread safe function so that it can't be cleaned up
-  // until Unref() is called in `Reboot_stop()`.
-  // 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.Ref(info.Env());
+  // Want to keep Node from exiting until we've called
+  // `Reboot.stop()`.
+  adaptor->KeepNodeFromExiting(info.Env());
 
   return NodePromiseFromPythonTask(
       info.Env(),
@@ -1673,18 +1760,11 @@ Napi::Value Reboot_stop(const Napi::CallbackInfo& info) {
         return py_reboot->attr("stop")();
       });
 
-  // 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.
+  // 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) {
-        adaptor->thread_safe_function.Unref(info.Env());
+        adaptor->AllowNodeToExit(info.Env());
       });
 
   js_promise
@@ -1855,7 +1935,7 @@ Napi::Value Task_await(const Napi::CallbackInfo& info) {
 
   return NodePromiseFromPythonTaskWithContext(
       info.Env(),
-      "reboot.nodejs.python.task_await(\""
+      "rebootdev.nodejs.python.task_await(\""
           + state_name + "\", \""
           + method + "\", ...) in nodejs",
       js_external_context,
@@ -1865,7 +1945,7 @@ Napi::Value Task_await(const Napi::CallbackInfo& info) {
        js_external_context, // Ensures `py_context` remains valid.
        py_context,
        json_task_id]() {
-        return py::module::import("reboot.nodejs.python")
+        return py::module::import("rebootdev.nodejs.python")
             .attr("task_await")(
                 py_context,
                 py::module::import(rbt_module.c_str())
@@ -1920,7 +2000,7 @@ Napi::Value ExternalContext_constructor(const Napi::CallbackInfo& info) {
        &idempotency_required,
        &idempotency_required_reason]() {
         py::object py_external = py::module::import(
-            "reboot.aio.external");
+            "rebootdev.aio.external");
 
         auto convert_str =
             [](const std::optional<std::string>& optional) -> py::object {
@@ -2041,8 +2121,7 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
 
                               return NodePromiseFromPythonCallback(
                                   info.Env(),
-                                  [js_from_native_external,
-                                   name = std::move(name),
+                                  [name = std::move(name),
                                    bearer_token = std::move(bearer_token),
                                    // Ensures `py_channel_manager`
                                    // remains valid. Need a copy
@@ -2058,7 +2137,7 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
 
                                     return new py::object(
                                         py::module::import(
-                                            "reboot.aio.external")
+                                            "rebootdev.aio.external")
                                             .attr("ExternalContext")(
                                                 "name"_a = py::str(name),
                                                 "channel_manager"_a =
@@ -2066,8 +2145,13 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
                                                 "bearer_token"_a =
                                                     py_bearer_token));
                                   },
-                                  [js_from_native_external = std::move(
-                                       js_from_native_external)](
+                                  [
+                                      // Need a copy, because we will
+                                      // create the 'ExternalContext' more
+                                      // than once, which means we wiil
+                                      // call this function more than once
+                                      // as well.
+                                      js_from_native_external](
                                       Napi::Env env,
                                       py::object* py_context) {
                                     // (check_line_length skip)
@@ -2187,15 +2271,9 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
 
 
 Napi::Value Application_run(const Napi::CallbackInfo& info) {
-  // Call Ref() on our NAPI thread safe function so that it can't be
-  // cleaned up and thus we won't 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.Ref(info.Env());
+  // Keep Node from exiting while we're running `Application.run` so
+  // that we can get calls from Python.
+  adaptor->KeepNodeFromExiting(info.Env());
 
   auto js_external_application = NapiSafeReference(
       info[0].As<Napi::External<py::object>>());
@@ -2206,7 +2284,7 @@ Napi::Value Application_run(const Napi::CallbackInfo& info) {
   Napi::Promise js_promise = NodePromiseFromPythonTask(
       info.Env(),
       "Application.run() in nodejs",
-      {"reboot.nodejs.python", "create_task"},
+      {"rebootdev.nodejs.python", "create_task"},
       [js_external_application, // Ensures `py_application` remains valid.
        py_application]() {
         return py_application->attr("run")();
@@ -2221,9 +2299,8 @@ Napi::Value Application_run(const Napi::CallbackInfo& info) {
           {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());
+                 // Allow Node to exit after `Application.run` returns.
+                 adaptor->AllowNodeToExit(info.Env());
                }),
            Napi::Function::New(
                info.Env(),
@@ -2236,9 +2313,8 @@ Napi::Value Application_run(const Napi::CallbackInfo& info) {
                      .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());
+                 // Allow Node to exit after `Application.run` returns.
+                 adaptor->AllowNodeToExit(info.Env());
                })});
 
   return js_promise;
@@ -2429,7 +2505,7 @@ Napi::Value Context_generateIdempotentStateId(const Napi::CallbackInfo& info) {
           py_alias = py::cast(*alias);
         }
         py::object py_idempotency_module = py::module::import(
-            "reboot.aio.idempotency");
+            "rebootdev.aio.idempotency");
         py::object py_idempotency = py::object(
             py_idempotency_module.attr("Idempotency")(
                 "key"_a = py_key,
@@ -2508,7 +2584,7 @@ Napi::Value retry_reactively_until(const Napi::CallbackInfo& info) {
                   });
             });
 
-        return py::module::import("reboot.aio.contexts")
+        return py::module::import("rebootdev.aio.contexts")
             .attr("retry_reactively_until")(py_context, py_condition);
       });
 }

package/version.d.ts

@@ -1 +1 @@
-export declare const REBOOT_VERSION = "0.25.5";
+export declare const REBOOT_VERSION = "0.25.6";

package/version.js

@@ -1 +1 @@
-export const REBOOT_VERSION = "0.25.5";
+export const REBOOT_VERSION = "0.25.6";