@reboot-dev/reboot 0.33.1 → 0.34.0

package/index.d.ts

@@ -52,30 +52,43 @@ export declare function runWithContext<T>(context: Context, callback: () => T):
 export declare class Context {
     #private;
     readonly cancelled: Promise<void>;
-    constructor(external: any, cancelled: Promise<void>);
-    static fromNativeExternal(external: any, kind: string, cancelled: Promise<void>): ReaderContext | WriterContext | TransactionContext | WorkflowContext;
+    readonly stateId: string;
+    readonly method: string;
+    readonly stateTypeName: string;
+    readonly callerBearerToken: string;
+    readonly cookie: string;
+    readonly appInternal: boolean;
+    readonly auth: Auth | null;
+    constructor({ external, stateId, method, stateTypeName, callerBearerToken, cookie, appInternal, auth, cancelled, }: {
+        external: any;
+        stateId: string;
+        method: string;
+        stateTypeName: string;
+        callerBearerToken: string;
+        cookie: string;
+        appInternal: boolean;
+        auth: Auth | null;
+        cancelled: Promise<void>;
+    });
+    static fromNativeExternal({ kind, ...options }: {
+        [x: string]: any;
+        kind: any;
+    }): ReaderContext | WriterContext | TransactionContext | WorkflowContext;
     get __external(): any;
-    get auth(): Auth | null;
-    get stateId(): string;
-    get stateTypeName(): string;
-    get method(): string;
-    get callerBearerToken(): string | null;
-    get cookie(): string;
-    get appInternal(): boolean;
     generateIdempotentStateId(stateType: string, serviceName: string, method: string, idempotency: IdempotencyOptions): Promise<any>;
 }
 export declare class ReaderContext extends Context {
     #private;
-    constructor(external: any, cancelled: any);
+    constructor(options: any);
 }
 export declare class WriterContext extends Context {
     #private;
-    constructor(external: any, cancelled: any);
+    constructor(options: any);
     set sync(sync: boolean);
 }
 export declare class TransactionContext extends Context {
     #private;
-    constructor(external: any, cancelled: any);
+    constructor(options: any);
 }
 export type Interval = {
     ms?: number;
@@ -86,7 +99,7 @@ export type Interval = {
 };
 export declare class WorkflowContext extends Context {
     #private;
-    constructor(external: any, cancelled: any);
+    constructor(options: any);
     loop(alias: string, { interval }?: {
         interval?: Interval;
     }): AsyncGenerator<number, void, unknown>;
@@ -140,7 +153,7 @@ export declare abstract class TokenVerifier {
      *   `Auth` information if the token is valid, null otherwise.
      */
     abstract verifyToken(context: ReaderContext, token?: string): Promise<Auth | null>;
-    _verifyToken(context: ReaderContext, token?: string): Promise<Uint8Array | null>;
+    _verifyToken(external: any, cancelled: Promise<void>, bytesCall: Uint8Array): Promise<Uint8Array | null>;
 }
 export type AuthorizerDecision = errors_pb.Unauthenticated | errors_pb.PermissionDenied | errors_pb.Ok;
 /**
@@ -164,7 +177,7 @@ export declare abstract class Authorizer<StateType, RequestTypes> {
      *         `errors_pb.PermissionDenied()` otherwise.
      */
     abstract authorize(methodName: string, context: ReaderContext, state?: StateType, request?: RequestTypes): Promise<AuthorizerDecision>;
-    _authorize?: (methodName: string, context: ReaderContext, bytesState?: Uint8Array, bytesRequest?: Uint8Array) => Promise<Uint8Array>;
+    _authorize?: (external: any, cancelled: Promise<void>, bytesCall: Uint8Array) => Promise<Uint8Array>;
 }
 export type AuthorizerCallable<StateType, RequestType> = (args: {
     context: ReaderContext;

package/index.js

@@ -9,12 +9,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Reboot_external, _ExternalContext_external, _a, _Context_external, _Context_isInternalConstructing, _Context_stateId, _Context_method, _Context_stateTypeName, _ReaderContext_kind, _WriterContext_kind, _TransactionContext_kind, _WorkflowContext_kind, _Application_servicers, _Application_tokenVerifier, _Application_express, _Application_http, _Application_servers, _Application_createExternalContext, _Application_external;
-import { auth_pb, errors_pb, protobuf_es, toCamelCase, tasks_pb, } from "@reboot-dev/reboot-api";
+var _Reboot_external, _ExternalContext_external, _a, _Context_external, _Context_isInternalConstructing, _ReaderContext_kind, _WriterContext_kind, _TransactionContext_kind, _WorkflowContext_kind, _Application_servicers, _Application_tokenVerifier, _Application_express, _Application_http, _Application_servers, _Application_createExternalContext, _Application_external;
+import { auth_pb, errors_pb, nodejs_pb, protobuf_es, tasks_pb, toCamelCase, } from "@reboot-dev/reboot-api";
 import { strict as assert } from "assert";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { fork } from "node:child_process";
 import { createRequire } from "node:module";
+import toobusy from "toobusy-js";
 import { z } from "zod/v4";
 import * as reboot_native from "./reboot_native.cjs";
 import { ensureError } from "./utils/errors.js";
@@ -168,80 +169,52 @@ export async function runWithContext(context, callback) {
     }, callback);
 }
 export class Context {
-    constructor(external, cancelled) {
+    constructor({ external, stateId, method, stateTypeName, callerBearerToken, cookie, appInternal, auth, cancelled, }) {
         _Context_external.set(this, void 0);
-        _Context_stateId.set(this, void 0);
-        _Context_method.set(this, void 0);
-        _Context_stateTypeName.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.stateId = stateId;
+        // Since we are passing a 'method' from Python, it will contain the
+        // Python-style method name, so we have to convert it there.
+        this.method = toCamelCase(method);
+        this.stateTypeName = stateTypeName;
+        this.callerBearerToken = callerBearerToken;
+        this.cookie = cookie;
+        this.appInternal = appInternal;
+        this.auth = auth;
         this.cancelled = cancelled;
     }
-    static fromNativeExternal(external, kind, cancelled) {
+    static fromNativeExternal({ kind, ...options }) {
         __classPrivateFieldSet(_a, _a, true, "f", _Context_isInternalConstructing);
         if (kind === "reader") {
-            return new ReaderContext(external, cancelled);
+            return new ReaderContext(options);
         }
         else if (kind === "writer") {
-            return new WriterContext(external, cancelled);
+            return new WriterContext(options);
         }
         else if (kind === "transaction") {
-            return new TransactionContext(external, cancelled);
+            return new TransactionContext(options);
         }
         else if (kind === "workflow") {
-            return new WorkflowContext(external, cancelled);
+            return new WorkflowContext(options);
         }
         throw new Error("Unknown method kind");
     }
     get __external() {
         return __classPrivateFieldGet(this, _Context_external, "f");
     }
-    get auth() {
-        const authBytes = reboot_native.Context_auth(__classPrivateFieldGet(this, _Context_external, "f"));
-        if (authBytes) {
-            return Auth.fromProtoBytes(authBytes);
-        }
-        return null;
-    }
-    get stateId() {
-        if (__classPrivateFieldGet(this, _Context_stateId, "f") === undefined) {
-            __classPrivateFieldSet(this, _Context_stateId, reboot_native.Context_stateId(__classPrivateFieldGet(this, _Context_external, "f")), "f");
-        }
-        return __classPrivateFieldGet(this, _Context_stateId, "f");
-    }
-    get stateTypeName() {
-        if (__classPrivateFieldGet(this, _Context_stateTypeName, "f") === undefined) {
-            __classPrivateFieldSet(this, _Context_stateTypeName, reboot_native.Context_stateTypeName(__classPrivateFieldGet(this, _Context_external, "f")), "f");
-        }
-        return __classPrivateFieldGet(this, _Context_stateTypeName, "f");
-    }
-    get method() {
-        if (__classPrivateFieldGet(this, _Context_method, "f") === undefined) {
-            __classPrivateFieldSet(this, _Context_method, toCamelCase(reboot_native.Context_method(__classPrivateFieldGet(this, _Context_external, "f"))), "f");
-        }
-        return __classPrivateFieldGet(this, _Context_method, "f");
-    }
-    get callerBearerToken() {
-        return reboot_native.Context_callerBearerToken(__classPrivateFieldGet(this, _Context_external, "f"));
-    }
-    get cookie() {
-        return reboot_native.Context_cookie(__classPrivateFieldGet(this, _Context_external, "f"));
-    }
-    get appInternal() {
-        return reboot_native.Context_appInternal(__classPrivateFieldGet(this, _Context_external, "f"));
-    }
     async generateIdempotentStateId(stateType, serviceName, method, idempotency) {
         return reboot_native.Context_generateIdempotentStateId(__classPrivateFieldGet(this, _Context_external, "f"), stateType, serviceName, method, idempotency);
     }
 }
-_a = Context, _Context_external = new WeakMap(), _Context_stateId = new WeakMap(), _Context_method = new WeakMap(), _Context_stateTypeName = new WeakMap();
+_a = Context, _Context_external = new WeakMap();
 _Context_isInternalConstructing = { value: false };
 export class ReaderContext extends Context {
-    constructor(external, cancelled) {
-        super(external, cancelled);
+    constructor(options) {
+        super(options);
         // Property helps `tsc` not treat a `ReaderContext` as any other
         // context type that structurally looks equivalent.
         _ReaderContext_kind.set(this, "reader");
@@ -249,8 +222,8 @@ export class ReaderContext extends Context {
 }
 _ReaderContext_kind = new WeakMap();
 export class WriterContext extends Context {
-    constructor(external, cancelled) {
-        super(external, cancelled);
+    constructor(options) {
+        super(options);
         // Property helps `tsc` not treat a `WriterContext` as any other
         // context type that structurally looks equivalent.
         _WriterContext_kind.set(this, "writer");
@@ -268,13 +241,14 @@ export class WriterContext extends Context {
     //   3. The writer is _not_ within a transaction.
     //   4. The writer is _not_ running as a task.
     set sync(sync) {
+        // TODO: optimize this so that we don't block the event loop.
         reboot_native.WriterContext_set_sync(this.__external, sync);
     }
 }
 _WriterContext_kind = new WeakMap();
 export class TransactionContext extends Context {
-    constructor(external, cancelled) {
-        super(external, cancelled);
+    constructor(options) {
+        super(options);
         // Property helps `tsc` not treat a `TransactionContext` as any other
         // context type that structurally looks equivalent.
         _TransactionContext_kind.set(this, "transaction");
@@ -282,8 +256,8 @@ export class TransactionContext extends Context {
 }
 _TransactionContext_kind = new WeakMap();
 export class WorkflowContext extends Context {
-    constructor(external, cancelled) {
-        super(external, cancelled);
+    constructor(options) {
+        super(options);
         // Property helps `tsc` not treat a `WorkflowContext` as any other
         // context type that structurally looks equivalent.
         _WorkflowContext_kind.set(this, "workflow");
@@ -398,8 +372,21 @@ export class Auth {
  * Bearer` token when passed and optionally extract token metadata.
  */
 export class TokenVerifier {
-    async _verifyToken(context, token) {
-        const auth = await this.verifyToken(context, token);
+    async _verifyToken(external, cancelled, bytesCall) {
+        const call = nodejs_pb.VerifyTokenCall.fromBinary(bytesCall);
+        const context = Context.fromNativeExternal({
+            external,
+            kind: "reader",
+            stateId: call.context.stateId,
+            method: call.context.method,
+            stateTypeName: call.context.stateTypeName,
+            callerBearerToken: call.context.callerBearerToken,
+            cookie: call.context.cookie,
+            appInternal: call.context.appInternal,
+            auth: null,
+            cancelled,
+        });
+        const auth = await this.verifyToken(context, call.token);
         if (!auth) {
             return null;
         }
@@ -617,6 +604,14 @@ export class Application {
         return __classPrivateFieldGet(this, _Application_http, "f");
     }
     async run() {
+        if (process.env.REBOOT_ENABLE_EVENT_LOOP_LAG_MONITORING === "true") {
+            toobusy.onLag((lag) => {
+                console.log(`Node.js event loop lag detected! Latency: ${lag}ms.
+          This may indicate a blocking operation on the main thread
+          (e.g., CPU-intensive task). If you are not running such tasks,
+          please report this issue to the maintainers.`);
+            });
+        }
         return await reboot_native.Application_run(__classPrivateFieldGet(this, _Application_external, "f"));
     }
     get __external() {
@@ -897,7 +892,7 @@ const callback = (...args) => {
     console.log(new Date(), ...args);
 };
 ensurePythonVenv();
-reboot_native.initialize(callback, Context.fromNativeExternal, launchSubprocessConsensus);
+reboot_native.initialize(callback, launchSubprocessConsensus);
 // TODO: move these into @reboot-dev/reboot-api and also generate them
 // via plugin, perhaps via a new plugin which emits the Zod schemas
 // for all protobuf messages, which might be easier after we've moved

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.33.1",
+    "@reboot-dev/reboot-api": "0.34.0",
     "chalk": "^4.1.2",
     "node-addon-api": "^7.0.0",
     "node-gyp": ">=10.2.0",
@@ -14,11 +14,12 @@
     "express": "^5.1.0",
     "@scarf/scarf": "1.4.0",
     "tsx": "^4.19.2",
-    "zod": "^3.25.51"
+    "zod": "^3.25.51",
+    "toobusy-js": "^0.5.1"
   },
   "type": "module",
   "name": "@reboot-dev/reboot",
-  "version": "0.33.1",
+  "version": "0.34.0",
   "description": "npm package for Reboot",
   "scripts": {
     "preinstall": "node preinstall.cjs",

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));

package/reboot_native.cjs

@@ -74,14 +74,6 @@ exports.Reboot_stop = reboot_native.exports.Reboot_stop;
 exports.Reboot_up = reboot_native.exports.Reboot_up;
 exports.Reboot_down = reboot_native.exports.Reboot_down;
 exports.Reboot_url = reboot_native.exports.Reboot_url;
-exports.Context_auth = reboot_native.exports.Context_auth;
-exports.Context_stateId = reboot_native.exports.Context_stateId;
-exports.Context_stateTypeName = reboot_native.exports.Context_stateTypeName;
-exports.Context_method = reboot_native.exports.Context_method;
-exports.Context_callerBearerToken =
-  reboot_native.exports.Context_callerBearerToken;
-exports.Context_cookie = reboot_native.exports.Context_cookie;
-exports.Context_appInternal = reboot_native.exports.Context_appInternal;
 exports.Context_generateIdempotentStateId =
   reboot_native.exports.Context_generateIdempotentStateId;
 exports.WriterContext_set_sync = reboot_native.exports.WriterContext_set_sync;

package/version.d.ts

@@ -1 +1 @@
-export declare const REBOOT_VERSION = "0.33.1";
+export declare const REBOOT_VERSION = "0.34.0";

package/version.js

@@ -1 +1 @@
-export const REBOOT_VERSION = "0.33.1";
+export const REBOOT_VERSION = "0.34.0";