@reboot-dev/reboot 0.33.1 → 0.35.0

package/reboot_native.cc

@@ -2,6 +2,10 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
+#if __linux__
+#include <sys/eventfd.h>
+#endif
+
 #include <atomic>
 #include <future>
 #include <iostream>
@@ -21,8 +25,53 @@ using namespace pybind11::literals;
 namespace py = pybind11;
 
 
+// Helper when debugging, left for future optimization work.
+struct Timer {
+  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_);
+    std::stringstream ss;
+    ss << name_
+       << (step != nullptr ? " at " + std::string(step) : std::string(""))
+       << " took " << duration.count() << "ms"
+       << std::endl;
+    std::cout << ss.str();
+  }
+
+  std::string name_;
+  std::chrono::time_point<std::chrono::high_resolution_clock> start_;
+};
+
+
+void _RunNodeFunctions(
+    Napi::Env env,
+    Napi::Function /* callback */,
+    void* /* context */,
+    void* /* data */);
+
+
 struct PythonNodeAdaptor {
-  PythonNodeAdaptor() {}
+  PythonNodeAdaptor() {
+#if __linux__
+    read_fd_ = write_fd_ = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
+#else
+    int pipe_fds[2];
+    if (pipe(pipe_fds) == -1) {
+      perror("pipe(...)");
+      abort();
+    }
+
+    // TODO: make nonblocking and close on exec.
+    read_fd_ = pipe_fds[0];
+    write_fd_ = pipe_fds[1];
+#endif
+  }
 
   ~PythonNodeAdaptor() {
     // We must join because thread captures `this`.
@@ -68,20 +117,41 @@ struct PythonNodeAdaptor {
   }
 
   template <typename F>
-  void ScheduleCallbackOnPythonEventLoop(F&& f) {
-    auto function = [f = std::forward<F>(f)]() mutable {
-      f();
-    };
+  void ScheduleCallbackOnPythonEventLoop(F&& f, bool high_priority = true) {
+    bool signal_fd = false;
 
     {
       std::lock_guard<std::mutex> lock(mutex);
-      python_functions.emplace_back(std::move(function));
+      python_functions.emplace_back(std::move(f));
+      if (high_priority && should_signal_fd_) {
+        signal_fd = true;
+        should_signal_fd_ = false;
+      }
+    }
+
+    if (signal_fd) {
+      uint64_t one = 1;
+      // Writing to this file descriptor communicates to Python
+      // (see `public/rebootdev/nodejs/python.py`) that
+      // `run_functions()` should be called (while holding the Python
+      // GIL). In `Initialize()` we've set up `run_functions()` to run
+      // the `python_functions` we've just added our callback to.
+      if (write(write_fd_, &one, sizeof(one)) < 0) {
+        perror("write(...)");
+        abort();
+      }
     }
-    python_functions_not_empty.notify_one();
   }
 
   template <typename F>
-  void ScheduleCallbackOnNodeEventLoop(F&& f) {
+  void ScheduleCallbackOnPythonEventLoopLowPriority(F&& f) {
+    return ScheduleCallbackOnPythonEventLoop(
+        std::move(f),
+        /* high_priority = */ false);
+  }
+
+  template <typename F>
+  void ScheduleCallbackOnNodeEventLoop(F&& f, bool high_priority = true) {
     // It is possible that Node.js is shutting down and has already
     // called the `thread_safe_function` finalizer and trying to use
     // `thread_safe_function` will raise SIGABRT or SIGSEGV.
@@ -99,36 +169,67 @@ struct PythonNodeAdaptor {
       return;
     }
 
-    napi_status status = thread_safe_function.BlockingCall(
-        [f = std::forward<F>(f)](
-            Napi::Env env,
-            Napi::Function /* js_callback */) mutable {
-          try {
-            f(env);
-          } catch (const std::exception& e) {
-            PythonNodeAdaptor::HandleException(e);
-          }
-        });
+    bool call_thread_safe_function = false;
 
-    // TODO: handle each of the possible values for `status`:
-    //
-    // napi_ok: the call was successfully added to the queue.
-    //
-    // napi_queue_full: the queue was full when trying to call in a
-    //                  non-blocking method.
-    //
-    // napi_closing: the thread-safe function is aborted and cannot
-    //               accept more calls.
-    //
-    // napi_invalid_arg: the thread-safe function is closed.
-    //
-    // napi_generic_failure: a generic error occurred when attempting
-    //
+    {
+      std::lock_guard<std::mutex> lock(node_functions_mutex_);
+      node_functions_.emplace_back(std::move(f));
+      if (high_priority && should_call_thread_safe_function_) {
+        call_thread_safe_function = true;
+        should_call_thread_safe_function_ = false;
+      }
+    }
+
+    if (call_thread_safe_function) {
+      napi_status status = thread_safe_function.BlockingCall();
+
+      // TODO: handle each of the possible values for `status`:
+      //
+      // napi_ok: the call was successfully added to the queue.
+      //
+      // napi_queue_full: the queue was full when trying to call in a
+      //                  non-blocking method.
+      //
+      // napi_closing: the thread-safe function is aborted and cannot
+      //               accept more calls.
+      //
+      // napi_invalid_arg: the thread-safe function is closed.
+      //
+      // napi_generic_failure: a generic error occurred when attempting
+      //
+
+      if (status != napi_ok) {
+        Napi::Error::Fatal(
+            "ThreadEntry",
+            "Napi::ThreadSafeNapi::Function.BlockingCall() failed");
+      }
+    }
+  }
+
+  template <typename F>
+  void ScheduleCallbackOnNodeEventLoopLowPriority(F&& f) {
+    return ScheduleCallbackOnNodeEventLoop(
+        std::move(f),
+        /* high_priority = */ false);
+  }
 
-    if (status != napi_ok) {
-      Napi::Error::Fatal(
-          "ThreadEntry",
-          "Napi::ThreadSafeNapi::Function.BlockingCall() failed");
+  void RunNodeFunctions(Napi::Env& env) {
+    std::list<std::function<void(Napi::Env&)>> functions;
+    {
+      std::lock_guard<std::mutex> lock(node_functions_mutex_);
+      functions = std::move(node_functions_);
+      should_call_thread_safe_function_ = true;
+    }
+    for (auto&& function : functions) {
+      try {
+        function(env);
+      } catch (const std::exception& e) {
+        std::cerr
+            << "Unexpected exception: " << e.what()
+            << "\n"
+            << "Please report this bug to the maintainers!"
+            << std::endl;
+      }
     }
   }
 
@@ -162,23 +263,29 @@ struct PythonNodeAdaptor {
   // into Python or expecting calls from Python.
   std::atomic<int> references{0};
 
-  Napi::ThreadSafeFunction thread_safe_function;
+  Napi::TypedThreadSafeFunction<
+      void,
+      void,
+      _RunNodeFunctions>
+      thread_safe_function;
+  std::mutex node_functions_mutex_;
+  std::list<std::function<void(Napi::Env&)>> node_functions_;
+  bool should_call_thread_safe_function_ = true;
 
   bool thread_safe_function_finalized = false;
 
   std::thread thread;
   std::mutex mutex;
-  std::condition_variable python_functions_not_empty;
   std::list<std::function<void()>> python_functions;
+  int read_fd_ = -1;
+  int write_fd_ = -1;
+  bool should_signal_fd_ = true;
 };
 
 
 static PythonNodeAdaptor* adaptor = new PythonNodeAdaptor();
 
 // References to nodejs functions so we don't have to look them up.
-static Napi::FunctionReference* js_Context_fromNativeExternal =
-    new Napi::FunctionReference();
-
 static Napi::FunctionReference* js_launchSubprocessConsensus =
     new Napi::FunctionReference();
 
@@ -186,7 +293,7 @@ static Napi::FunctionReference* js_launchSubprocessConsensus =
 struct NapiReferenceDeleter {
   template <typename T>
   void operator()(Napi::Reference<T>* reference) {
-    adaptor->ScheduleCallbackOnNodeEventLoop(
+    adaptor->ScheduleCallbackOnNodeEventLoopLowPriority(
         [reference](Napi::Env) {
           delete reference;
         });
@@ -246,7 +353,7 @@ Napi::External<py::object> make_napi_external(
       env,
       py_object,
       [](Napi::Env, py::object* py_object) {
-        adaptor->ScheduleCallbackOnPythonEventLoop(
+        adaptor->ScheduleCallbackOnPythonEventLoopLowPriority(
             [py_object]() {
               delete py_object;
             });
@@ -260,18 +367,30 @@ Napi::External<py::object> make_napi_external(
 }
 
 
+void _RunNodeFunctions(
+    Napi::Env env,
+    Napi::Function /* callback */,
+    void* /* context */,
+    void* /* data */) {
+  adaptor->RunNodeFunctions(env);
+}
+
+
 void PythonNodeAdaptor::Initialize(
     Napi::Env& env,
     const Napi::Function& js_callback) {
-  thread_safe_function = Napi::ThreadSafeFunction::New(
+  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: */ this,
+      /* Context: */ (void*) nullptr,
       // Finalizer:
-      [this](Napi::Env env, void*, PythonNodeAdaptor*) {
+      [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`.
@@ -345,35 +464,35 @@ void PythonNodeAdaptor::Initialize(
                 return py_future;
               });
 
-          py::object event_loop_thread = module.attr("EventLoopThread")();
+          module.attr("run_functions") = py::cpp_function(
+              [this]() {
+                std::list<std::function<void()>> functions;
+                std::vector<std::pair<py::object*, std::string>> futures;
+
+                {
+                  std::unique_lock<std::mutex> lock(mutex);
+                  functions = std::move(python_functions);
+                  should_signal_fd_ = true;
+                }
+
+                for (auto&& function : functions) {
+                  try {
+                    function();
+                  } catch (std::exception& e) {
+                    PythonNodeAdaptor::HandleException(e);
+                  }
+                }
+              });
+
+          py::object event_loop_thread = module.attr("EventLoopThread")(
+              read_fd_);
 
           py::gil_scoped_release release;
 
           while (true) {
-            std::function<void()> function;
-
-            {
-              std::unique_lock<std::mutex> lock(mutex);
-              python_functions_not_empty.wait(
-                  lock,
-                  [this] { return !python_functions.empty(); });
-
-              function = std::move(python_functions.front());
-              python_functions.pop_front();
-            }
-
-            {
-              py::gil_scoped_acquire acquire;
-
-              event_loop_thread.attr("run_callback_on_event_loop")(
-                  py::cpp_function([function = std::move(function)]() {
-                    try {
-                      function();
-                    } catch (const std::exception& e) {
-                      PythonNodeAdaptor::HandleException(e);
-                    }
-                  }));
-            }
+            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;
@@ -968,12 +1087,8 @@ void Initialize(const Napi::CallbackInfo& info) {
   std::call_once(initialize_once, [&]() {
     Napi::Env env = info.Env();
 
-    js_Context_fromNativeExternal->Reset(
-        info[1].As<Napi::Function>(),
-        /* refcount = */ 1);
-
     js_launchSubprocessConsensus->Reset(
-        info[2].As<Napi::Function>(),
+        info[1].As<Napi::Function>(),
         /* refcount = */ 1);
 
     // NOTE: must initialize after storing above nodejs functions.
@@ -1133,15 +1248,10 @@ Napi::Value Reboot_createExternalContext(const Napi::CallbackInfo& info) {
 
 
 // NOTE: must be called within _Node_.
-Napi::Object make_js_context(
+Napi::Promise make_js_cancelled(
     Napi::Env& env,
-    py::object* py_context,
-    py::object* py_cancelled,
-    const std::string& kind) {
-  Napi::External<py::object> js_external_context =
-      make_napi_external(env, py_context);
-
-  Napi::Promise js_cancelled = NodePromiseFromPythonFuture(
+    py::object* py_cancelled) {
+  return NodePromiseFromPythonFuture(
       env,
       [py_cancelled]() {
         // After returning we won't need `py_cancelled` anymore, so we
@@ -1161,13 +1271,6 @@ Napi::Object make_js_context(
         // this lambda or the one above.
         return env.Undefined();
       });
-
-  return js_Context_fromNativeExternal
-      ->Call(
-          {js_external_context,
-           Napi::String::New(env, kind),
-           js_cancelled})
-      .As<Napi::Object>();
 }
 
 
@@ -1191,11 +1294,9 @@ py::object make_py_authorizer(NapiSafeObjectReference js_authorizer) {
   // Trampolines us from Python through C++ into Node.
   attributes["_authorize"] = py::cpp_function(
       [](py::object self,
-         const std::string& method_name,
          py::object py_reader_context,
          py::object py_cancelled,
-         std::optional<std::string> bytes_state,
-         std::optional<std::string> bytes_request) {
+         std::string bytes_call) {
         NapiSafeObjectReference* js_authorizer_reference =
             self.attr("_js_authorizer")
                 .cast<NapiSafeObjectReference*>();
@@ -1204,30 +1305,21 @@ py::object make_py_authorizer(NapiSafeObjectReference js_authorizer) {
             [js_authorizer_reference,
              py_reader_context = new py::object(py_reader_context),
              py_cancelled = new py::object(py_cancelled),
-             method_name,
-             bytes_state = std::move(bytes_state),
-             bytes_request = std::move(bytes_request)](Napi::Env env) {
+             bytes_call = std::move(bytes_call)](Napi::Env env) {
               std::vector<Napi::Value> js_args;
 
-              Napi::Object js_context = make_js_context(
-                  env,
-                  py_reader_context,
-                  py_cancelled,
-                  "reader");
+              Napi::External<py::object> js_external_context =
+                  make_napi_external(env, py_reader_context);
 
-              Napi::Object js_authorizer = js_authorizer_reference->Value(env);
+              js_args.push_back(js_external_context);
+
+              Napi::Promise js_cancelled = make_js_cancelled(env, py_cancelled);
 
-              Napi::Value js_bytes_request = bytes_request.has_value()
-                  ? str_to_uint8array(env, *bytes_request)
-                  : env.Undefined();
-              Napi::Value js_bytes_state = bytes_state.has_value()
-                  ? str_to_uint8array(env, *bytes_state)
-                  : env.Undefined();
+              js_args.push_back(js_cancelled);
 
-              js_args.push_back(Napi::String::New(env, method_name));
-              js_args.push_back(js_context);
-              js_args.push_back(js_bytes_state);
-              js_args.push_back(js_bytes_request);
+              js_args.push_back(str_to_uint8array(env, bytes_call));
+
+              Napi::Object js_authorizer = js_authorizer_reference->Value(env);
 
               return js_authorizer.Get("_authorize")
                   .As<Napi::Function>()
@@ -1243,11 +1335,9 @@ py::object make_py_authorizer(NapiSafeObjectReference js_authorizer) {
             });
       },
       py::name("_authorize"),
-      py::arg("method_name"),
       py::arg("context"),
       py::arg("cancelled"),
-      py::arg("state"),
-      py::arg("request"),
+      py::arg("bytes_call"),
       py::is_method(py::none()));
 
   // Now define our subclass.
@@ -1412,41 +1502,41 @@ py::object make_py_user_servicer(
   // calls.
   attributes["_trampoline"] = py::cpp_function(
       [](NapiSafeObjectReference& js_servicer_reference,
-         const std::string& kind,
-         const std::string& method,
          py::object py_context,
          py::object py_cancelled,
-         const std::string& json_state,
-         const std::string& json_request) {
+         std::string bytes_call) {
         return PythonFutureFromNodePromise(
             [&js_servicer_reference,
-             kind,
-             method,
              py_context = new py::object(py_context),
              py_cancelled = new py::object(py_cancelled),
-             json_state,
-             json_request](Napi::Env env) {
+             bytes_call = std::move(bytes_call)](Napi::Env env) {
               std::vector<Napi::Value> js_args;
 
-              Napi::Object js_context =
-                  make_js_context(env, py_context, py_cancelled, kind);
+              Napi::External<py::object> js_external_context =
+                  make_napi_external(env, py_context);
+
+              js_args.push_back(js_external_context);
 
-              js_args.push_back(js_context);
+              Napi::Promise js_cancelled = make_js_cancelled(env, py_cancelled);
 
-              js_args.push_back(Napi::String::New(env, json_state));
-              js_args.push_back(Napi::String::New(env, json_request));
+              js_args.push_back(js_cancelled);
+
+              js_args.push_back(str_to_uint8array(env, bytes_call));
 
               Napi::Object js_servicer =
                   js_servicer_reference.Value(env);
 
               return js_servicer
-                  .Get("_" + method)
+                  .Get("__dispatch")
                   .As<Napi::Function>()
                   .Call(js_servicer, js_args)
                   .As<Napi::Object>();
             },
             [](Napi::Env env, Napi::Value value) {
-              return std::string(value.As<Napi::String>().Utf8Value());
+              return uint8array_to_str(value.As<Napi::Uint8Array>());
+            },
+            [](std::string&& bytes_result) -> py::object {
+              return py::bytes(bytes_result);
             });
       });
 
@@ -1562,19 +1652,11 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
       [](py::object self,
          py::object py_reader_context,
          py::object py_cancelled,
-         py::object py_token) {
+         std::string bytes_call) {
         NapiSafeObjectReference* js_token_verifier_reference =
             self.attr("_js_token_verifier")
                 .cast<NapiSafeObjectReference*>();
 
-        // Converting to 'py::str' involves Python runtime access.
-        // Perform this conversion here, on the Python thread, before entering
-        // Node.
-        std::optional<std::string> token;
-        if (!py_token.is_none()) {
-          token = py::str(py_token);
-        }
-
         return PythonFutureFromNodePromise(
             [js_token_verifier_reference,
              // We allocate 'py_cancelled' and 'py_reader_context' with 'new
@@ -1583,21 +1665,19 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
              // thread, see 'make_js_context'.
              py_reader_context = new py::object(py_reader_context),
              py_cancelled = new py::object(py_cancelled),
-             token = std::move(token)](Napi::Env env) {
+             bytes_call = std::move(bytes_call)](Napi::Env env) {
               std::vector<Napi::Value> js_args;
 
-              js_args.push_back(
-                  make_js_context(
-                      env,
-                      py_reader_context,
-                      py_cancelled,
-                      "reader"));
+              Napi::External<py::object> js_external_context =
+                  make_napi_external(env, py_reader_context);
 
-              if (token.has_value()) {
-                js_args.push_back(Napi::String::New(env, *token));
-              } else {
-                js_args.push_back(env.Null());
-              }
+              js_args.push_back(js_external_context);
+
+              Napi::Promise js_cancelled = make_js_cancelled(env, py_cancelled);
+
+              js_args.push_back(js_cancelled);
+
+              js_args.push_back(str_to_uint8array(env, bytes_call));
 
               Napi::Object js_token_verifier =
                   js_token_verifier_reference->Value(env);
@@ -1626,7 +1706,7 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
       py::name("_verify_token"),
       py::arg("context"),
       py::arg("cancelled"),
-      py::arg("py_token"),
+      py::arg("bytes_call"),
       py::is_method(py::none()));
 
   py::object py_parent_class =
@@ -2331,151 +2411,6 @@ Napi::Value Application_run(const Napi::CallbackInfo& info) {
 }
 
 
-Napi::Value Context_auth(const Napi::CallbackInfo& info) {
-  Napi::External<py::object> js_external_context =
-      info[0].As<Napi::External<py::object>>();
-
-  // CHECK(...CheckTypeTag(...));
-
-  py::object* py_context = js_external_context.Data();
-
-  std::optional<std::string> auth_bytes = RunCallbackOnPythonEventLoop(
-      [py_context]() -> std::optional<std::string> {
-        py::object py_auth = py_context->attr("auth");
-
-        if (py_auth.is_none()) {
-          return std::nullopt;
-        } else {
-          std::string auth_bytes = py::bytes(py_auth.attr("to_proto_bytes")());
-          return auth_bytes;
-        }
-      });
-
-  if (auth_bytes.has_value()) {
-    Napi::Env env = info.Env();
-    return str_to_uint8array(env, *auth_bytes);
-  } else {
-    return info.Env().Null();
-  }
-}
-
-
-Napi::Value Context_stateId(const Napi::CallbackInfo& info) {
-  Napi::External<py::object> js_external_context =
-      info[0].As<Napi::External<py::object>>();
-
-  // CHECK(...CheckTypeTag(...));
-
-  py::object* py_context = js_external_context.Data();
-
-  std::string state_id = RunCallbackOnPythonEventLoop(
-      [py_context]() {
-        py::str state_id = py_context->attr("state_id");
-        return std::string(state_id);
-      });
-
-  return Napi::String::New(info.Env(), state_id);
-}
-
-
-Napi::Value Context_stateTypeName(const Napi::CallbackInfo& info) {
-  Napi::External<py::object> js_external_context =
-      info[0].As<Napi::External<py::object>>();
-
-  // CHECK(...CheckTypeTag(...));
-
-  py::object* py_context = js_external_context.Data();
-
-  std::string state_type_name = RunCallbackOnPythonEventLoop(
-      [py_context]() {
-        py::str state_type_name = py_context->attr("state_type_name");
-        return std::string(state_type_name);
-      });
-
-  return Napi::String::New(info.Env(), state_type_name);
-}
-
-
-Napi::Value Context_method(const Napi::CallbackInfo& info) {
-  Napi::External<py::object> js_external_context =
-      info[0].As<Napi::External<py::object>>();
-
-  // CHECK(...CheckTypeTag(...));
-
-  py::object* py_context = js_external_context.Data();
-
-  std::string method = RunCallbackOnPythonEventLoop(
-      [py_context]() {
-        py::str method = py_context->attr("method");
-        return std::string(method);
-      });
-
-  return Napi::String::New(info.Env(), method);
-}
-
-
-Napi::Value Context_callerBearerToken(
-    const Napi::CallbackInfo& info) {
-  Napi::External<py::object> js_external_context =
-      info[0].As<Napi::External<py::object>>();
-
-  // CHECK(...CheckTypeTag(...));
-
-  py::object* py_context = js_external_context.Data();
-
-  std::optional<std::string> caller_bearer_token = RunCallbackOnPythonEventLoop(
-      [py_context]() -> std::optional<std::string> {
-        py::object caller_bearer_token = py_context->attr(
-            "caller_bearer_token");
-        if (caller_bearer_token.is_none()) {
-          return std::nullopt;
-        } else {
-          return std::string(py::str(caller_bearer_token));
-        }
-      });
-  if (caller_bearer_token.has_value()) {
-    return Napi::String::New(info.Env(), *caller_bearer_token);
-  } else {
-    return info.Env().Null();
-  }
-}
-
-
-Napi::Value Context_cookie(const Napi::CallbackInfo& info) {
-  Napi::External<py::object> js_external_context =
-      info[0].As<Napi::External<py::object>>();
-
-  // CHECK(...CheckTypeTag(...));
-
-  py::object* py_context = js_external_context.Data();
-
-  std::string cookie = RunCallbackOnPythonEventLoop(
-      [py_context]() {
-        py::str cookie = py_context->attr("cookie");
-        return std::string(cookie);
-      });
-
-  return Napi::String::New(info.Env(), cookie);
-}
-
-
-Napi::Value Context_appInternal(const Napi::CallbackInfo& info) {
-  Napi::External<py::object> js_external_context =
-      info[0].As<Napi::External<py::object>>();
-
-  // CHECK(...CheckTypeTag(...));
-
-  py::object* py_context = js_external_context.Data();
-
-  bool app_internal = RunCallbackOnPythonEventLoop(
-      [py_context]() {
-        return py_context->attr("app_internal").cast<bool>();
-      });
-
-  return Napi::Boolean::New(info.Env(), app_internal);
-}
-
-
 Napi::Value Context_generateIdempotentStateId(const Napi::CallbackInfo& info) {
   // NOTE: we immediately get a safe reference to the `Napi::External`
   // so that Node will not garbage collect it and the `py::object*` we
@@ -2911,34 +2846,6 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
       Napi::String::New(env, "Service_call"),
       Napi::Function::New<Service_call>(env));
 
-  exports.Set(
-      Napi::String::New(env, "Context_auth"),
-      Napi::Function::New<Context_auth>(env));
-
-  exports.Set(
-      Napi::String::New(env, "Context_stateId"),
-      Napi::Function::New<Context_stateId>(env));
-
-  exports.Set(
-      Napi::String::New(env, "Context_stateTypeName"),
-      Napi::Function::New<Context_stateTypeName>(env));
-
-  exports.Set(
-      Napi::String::New(env, "Context_method"),
-      Napi::Function::New<Context_method>(env));
-
-  exports.Set(
-      Napi::String::New(env, "Context_callerBearerToken"),
-      Napi::Function::New<Context_callerBearerToken>(env));
-
-  exports.Set(
-      Napi::String::New(env, "Context_cookie"),
-      Napi::Function::New<Context_cookie>(env));
-
-  exports.Set(
-      Napi::String::New(env, "Context_appInternal"),
-      Napi::Function::New<Context_appInternal>(env));
-
   exports.Set(
       Napi::String::New(env, "Context_generateIdempotentStateId"),
       Napi::Function::New<Context_generateIdempotentStateId>(env));