rivetkit 2.0.42 → 2.1.0-rc.1

package/dist/tsup/{chunk-Q6W7RJJP.js → chunk-DIGBC2VI.js}

@@ -1,39 +1,25 @@
 import {
   importWebSocket,
   logger
-} from "./chunk-XXGJCOL6.js";
+} from "./chunk-A6YIZWTK.js";
 import {
-  ACTOR_VERSIONED,
-  ActionContext,
-  ActorContext,
-  BeforeConnectContext,
-  CONN_CONNECTED_SYMBOL,
-  CONN_DRIVER_SYMBOL,
-  CONN_SEND_MESSAGE_SYMBOL,
-  CONN_SPEAKS_RIVETKIT_SYMBOL,
-  CONN_STATE_MANAGER_SYMBOL,
-  CONN_VERSIONED,
   CURRENT_VERSION,
-  CURRENT_VERSION2,
-  CachedSerializer,
-  Conn,
-  ConnectContext,
-  CreateConnStateContext,
-  DeadlineError,
   EncodingSchema,
   HEADER_CONN_PARAMS,
   HEADER_ENCODING,
   HEADER_RIVET_TOKEN,
   HTTP_ACTION_REQUEST_VERSIONED,
   HTTP_ACTION_RESPONSE_VERSIONED,
+  HTTP_QUEUE_SEND_REQUEST_VERSIONED,
+  HTTP_QUEUE_SEND_RESPONSE_VERSIONED,
   HTTP_RESPONSE_ERROR_VERSIONED,
   HttpActionRequestSchema,
   HttpActionResponseSchema,
+  HttpQueueSendRequestSchema,
+  HttpQueueSendResponseSchema,
   HttpResponseErrorSchema,
-  KEYS,
   PATH_CONNECT,
   PATH_WEBSOCKET_PREFIX,
-  RequestContext,
   TO_CLIENT_VERSIONED,
   TO_SERVER_VERSIONED,
   ToClientSchema,
@@ -41,36 +27,25 @@ import {
   WS_PROTOCOL_CONN_PARAMS,
   WS_PROTOCOL_ENCODING,
   WS_PROTOCOL_STANDARD,
-  WebSocketContext,
-  assertUnreachable as assertUnreachable2,
   contentTypeForEncoding,
-  createHttpDriver,
-  deadline,
   deserializeActorKey,
   deserializeWithEncoding,
-  generateSecureToken,
   inputDataToBuffer,
-  isConnStatePath,
-  isStatePath,
   jsonStringifyCompat,
-  makeConnKey,
-  processMessage,
   serializeActorKey,
   serializeWithEncoding,
   tryParseEndpoint,
   uint8ArrayToBase64
-} from "./chunk-GMAVRZSF.js";
+} from "./chunk-M2T62AZQ.js";
+import {
+  assertUnreachable as assertUnreachable2
+} from "./chunk-T5YCUGVS.js";
 import {
-  EXTRA_ERROR_LOG,
-  SinglePromiseQueue,
   VERSION,
-  arrayBuffersEqual,
   assertUnreachable,
   bufferToArrayBuffer,
   combineUrlPath,
   deconstructError,
-  getBaseLogger,
-  getIncludeTarget,
   getLogMessage,
   getLogger,
   getNextPhase,
@@ -80,25 +55,14 @@ import {
   getRivetRunner,
   getRivetToken,
   httpUserAgent,
-  isCborSerializable,
   noopNext,
   promiseWithResolvers,
   stringifyError
-} from "./chunk-FJ3KTN4V.js";
+} from "./chunk-6LIBPELE.js";
 import {
-  ActionNotFound,
-  ActionTimedOut,
   ActorNotFound,
-  DatabaseNotEnabled,
-  InternalError,
-  InvalidRequest,
-  InvalidRequestHandlerResponse,
-  InvalidStateType,
-  OutgoingMessageTooLong,
-  RequestHandlerNotDefined,
-  StateNotEnabled,
-  VarsNotEnabled
-} from "./chunk-LFVF5SCU.js";
+  InvalidRequest
+} from "./chunk-7HTNH26M.js";
 
 // src/devtools-loader/log.ts
 function logger2() {
@@ -129,7 +93,7 @@ import * as cbor2 from "cbor-x";
 import invariant2 from "invariant";
 
 // src/remote-manager-driver/api-utils.ts
-import { z } from "zod";
+import { z } from "zod/v4";
 
 // src/client/utils.ts
 import * as cbor from "cbor-x";
@@ -138,7 +102,7 @@ import invariant from "invariant";
 // src/client/errors.ts
 var ActorClientError = class extends Error {
 };
-var InternalError2 = class extends ActorClientError {
+var InternalError = class extends ActorClientError {
 };
 var ManagerError = class extends ActorClientError {
   constructor(error, opts) {
@@ -976,7 +940,7 @@ function apiActorToOutput(actor) {
 }
 
 // src/client/actor-conn.ts
-import * as cbor3 from "cbor-x";
+import * as cbor4 from "cbor-x";
 import invariant3 from "invariant";
 import pRetry2 from "p-retry";
 
@@ -1061,8 +1025,74 @@ async function checkForSchedulingError(group, code, actorId, query, driver) {
   return null;
 }
 
+// src/client/queue.ts
+import * as cbor3 from "cbor-x";
+function createQueueSender(senderOptions) {
+  async function send(name, body, options) {
+    const wait = (options == null ? void 0 : options.wait) ?? false;
+    const timeout = options == null ? void 0 : options.timeout;
+    const result = await sendHttpRequest({
+      url: `http://actor/queue/${encodeURIComponent(name)}`,
+      method: "POST",
+      headers: {
+        [HEADER_ENCODING]: senderOptions.encoding,
+        ...senderOptions.params !== void 0 ? {
+          [HEADER_CONN_PARAMS]: JSON.stringify(
+            senderOptions.params
+          )
+        } : {}
+      },
+      body: { body, wait, timeout },
+      encoding: senderOptions.encoding,
+      customFetch: senderOptions.customFetch,
+      signal: options == null ? void 0 : options.signal,
+      requestVersion: CURRENT_VERSION,
+      requestVersionedDataHandler: HTTP_QUEUE_SEND_REQUEST_VERSIONED,
+      responseVersion: CURRENT_VERSION,
+      responseVersionedDataHandler: HTTP_QUEUE_SEND_RESPONSE_VERSIONED,
+      requestZodSchema: HttpQueueSendRequestSchema,
+      responseZodSchema: HttpQueueSendResponseSchema,
+      requestToJson: (value) => ({
+        ...value,
+        name
+      }),
+      requestToBare: (value) => ({
+        name: value.name ?? name,
+        body: bufferToArrayBuffer(cbor3.encode(value.body)),
+        wait: value.wait ?? false,
+        timeout: value.timeout !== void 0 ? BigInt(value.timeout) : null
+      }),
+      responseFromJson: (json) => {
+        if (json.response === void 0) {
+          return { status: json.status };
+        }
+        return {
+          status: json.status,
+          response: json.response
+        };
+      },
+      responseFromBare: (bare) => {
+        if (bare.response === null || bare.response === void 0) {
+          return { status: bare.status };
+        }
+        return {
+          status: bare.status,
+          response: cbor3.decode(new Uint8Array(bare.response))
+        };
+      }
+    });
+    if (wait) {
+      return result;
+    }
+    return;
+  }
+  return {
+    send
+  };
+}
+
 // src/client/actor-conn.ts
-var CONNECT_SYMBOL = Symbol("connect");
+var CONNECT_SYMBOL = /* @__PURE__ */ Symbol("connect");
 var ActorConnRaw = class {
   #disposed = false;
   /* Will be aborted on dispose. */
@@ -1076,9 +1106,11 @@ var ActorConnRaw = class {
   #eventSubscriptions = /* @__PURE__ */ new Map();
   #errorHandlers = /* @__PURE__ */ new Set();
   #openHandlers = /* @__PURE__ */ new Set();
+  #openScheduled = false;
   #closeHandlers = /* @__PURE__ */ new Set();
   #statusChangeHandlers = /* @__PURE__ */ new Set();
   #actionIdCounter = 0;
+  #queueSender;
   /**
    * Interval that keeps the NodeJS process alive if this is the only thing running.
    *
@@ -1107,8 +1139,26 @@ var ActorConnRaw = class {
     this.#params = params;
     this.#encoding = encoding;
     this.#actorQuery = actorQuery;
+    this.#queueSender = createQueueSender({
+      encoding: this.#encoding,
+      params: this.#params,
+      customFetch: async (request) => {
+        if (!this.#actorId) {
+          const { actorId } = await queryActor(
+            void 0,
+            this.#actorQuery,
+            this.#driver
+          );
+          this.#actorId = actorId;
+        }
+        return this.#driver.sendRequest(this.#actorId, request);
+      }
+    });
     this.#keepNodeAliveInterval = setInterval(() => 6e4);
   }
+  send(name, body, options) {
+    return this.#queueSender.send(name, body, options);
+  }
   /**
    * Call a raw action connection. See {@link ActorConn} for type-safe action calls.
    *
@@ -1123,7 +1173,7 @@ var ActorConnRaw = class {
     logger().debug({ msg: "action", name: opts.name, args: opts.args });
     const actionId = this.#actionIdCounter;
     this.#actionIdCounter += 1;
-    const { promise, resolve, reject } = promiseWithResolvers();
+    const { promise, resolve, reject } = promiseWithResolvers((reason) => logger().warn({ msg: "unhandled action promise rejection", reason }));
     this.#actionsInFlight.set(actionId, {
       name: opts.name,
       resolve,
@@ -1153,12 +1203,11 @@ var ActorConnRaw = class {
     return output;
   }
   /**
-  	 * Do not call this directly.
-  enc
-  	 * Establishes a connection to the server using the specified endpoint & encoding & driver.
-  	 *
-  	 * @protected
-  	 */
+   * Do not call this directly.
+   * Establishes a connection to the server using the specified endpoint & encoding & driver.
+   *
+   * @protected
+   */
   [CONNECT_SYMBOL]() {
     this.#connectWithRetry();
   }
@@ -1231,7 +1280,7 @@ var ActorConnRaw = class {
     try {
       if (this.#onOpenPromise)
         throw new Error("#onOpenPromise already defined");
-      this.#onOpenPromise = promiseWithResolvers();
+      this.#onOpenPromise = promiseWithResolvers((reason) => logger().warn({ msg: "unhandled open promise rejection", reason }));
       await this.#connectWebSocket();
       await this.#onOpenPromise.promise;
     } finally {
@@ -1307,29 +1356,46 @@ var ActorConnRaw = class {
       }
       return;
     }
-    logger().debug({
-      msg: "socket open",
-      messageQueueLength: this.#messageQueue.length,
-      connId: this.#connId
-    });
-    this.#setConnStatus("connected");
-    if (this.#onOpenPromise) {
-      this.#onOpenPromise.resolve(void 0);
-    } else {
-      logger().warn({ msg: "#onOpenPromise is undefined" });
-    }
-    for (const eventName of this.#eventSubscriptions.keys()) {
-      this.#sendSubscription(eventName, true);
+    if (this.#connStatus === "connected" || this.#openScheduled) {
+      return;
     }
-    const queue = this.#messageQueue;
-    this.#messageQueue = [];
-    logger().debug({
-      msg: "flushing message queue",
-      queueLength: queue.length
+    this.#openScheduled = true;
+    queueMicrotask(() => {
+      this.#openScheduled = false;
+      if (this.#disposed) {
+        logger().debug({
+          msg: "handleOnOpen scheduled after dispose, closing websocket"
+        });
+        if (this.#websocket) {
+          this.#websocket.close(1e3, "Disposed");
+          this.#websocket = void 0;
+        }
+        return;
+      }
+      logger().debug({
+        msg: "socket open",
+        messageQueueLength: this.#messageQueue.length,
+        connId: this.#connId
+      });
+      this.#setConnStatus("connected");
+      if (this.#onOpenPromise) {
+        this.#onOpenPromise.resolve(void 0);
+      } else {
+        logger().warn({ msg: "#onOpenPromise is undefined" });
+      }
+      for (const eventName of this.#eventSubscriptions.keys()) {
+        this.#sendSubscription(eventName, true);
+      }
+      const queue = this.#messageQueue;
+      this.#messageQueue = [];
+      logger().debug({
+        msg: "flushing message queue",
+        queueLength: queue.length
+      });
+      for (const msg of queue) {
+        this.#sendMessage(msg);
+      }
     });
-    for (const msg of queue) {
-      this.#sendMessage(msg);
-    }
   }
   /** Called by the onmessage event from drivers. */
   async #handleOnMessage(data) {
@@ -1531,7 +1597,7 @@ var ActorConnRaw = class {
           name: action.name
         }))
       });
-      throw new InternalError2(`No in flight response for ${id}`);
+      throw new InternalError(`No in flight response for ${id}`);
     }
     this.#actionsInFlight.delete(id);
     logger().debug({
@@ -1707,7 +1773,14 @@ var ActorConnRaw = class {
         messageType: message.body.tag,
         actionName: (_a = message.body.val) == null ? void 0 : _a.name
       });
-      if (readyState === 1) {
+      if (this.#connStatus !== "connected") {
+        logger().debug({
+          msg: "websocket init pending, queueing message",
+          connStatus: this.#connStatus,
+          messageType: message.body.tag
+        });
+        queueMessage = true;
+      } else if (readyState === 1) {
         try {
           const messageSerialized = serializeWithEncoding(
             this.#encoding,
@@ -1727,7 +1800,7 @@ var ActorConnRaw = class {
                       id: msg.body.val.id,
                       name: msg.body.val.name,
                       args: bufferToArrayBuffer(
-                        cbor3.encode(msg.body.val.args)
+                        cbor4.encode(msg.body.val.args)
                       )
                     }
                   }
@@ -1792,7 +1865,7 @@ var ActorConnRaw = class {
                 group: msg.body.val.group,
                 code: msg.body.val.code,
                 message: msg.body.val.message,
-                metadata: msg.body.val.metadata ? cbor3.decode(
+                metadata: msg.body.val.metadata ? cbor4.decode(
                   new Uint8Array(
                     msg.body.val.metadata
                   )
@@ -1807,7 +1880,7 @@ var ActorConnRaw = class {
               tag: "ActionResponse",
               val: {
                 id: msg.body.val.id,
-                output: cbor3.decode(
+                output: cbor4.decode(
                   new Uint8Array(msg.body.val.output)
                 )
               }
@@ -1819,7 +1892,7 @@ var ActorConnRaw = class {
               tag: "Event",
               val: {
                 name: msg.body.val.name,
-                args: cbor3.decode(
+                args: cbor4.decode(
                   new Uint8Array(msg.body.val.args)
                 )
               }
@@ -1872,7 +1945,7 @@ var ActorConnRaw = class {
     if (this.#websocket) {
       const ws = this.#websocket;
       if (ws.readyState !== 2 && ws.readyState !== 3) {
-        const { promise, resolve } = promiseWithResolvers();
+        const { promise, resolve } = promiseWithResolvers((reason) => logger().warn({ msg: "unhandled websocket close promise rejection", reason }));
         ws.addEventListener("close", () => resolve(void 0));
         ws.close(1e3, "Disposed");
         await promise;
@@ -1899,7 +1972,7 @@ var ActorConnRaw = class {
 };
 
 // src/client/actor-handle.ts
-import * as cbor4 from "cbor-x";
+import * as cbor5 from "cbor-x";
 import invariant5 from "invariant";
 
 // src/client/raw-utils.ts
@@ -2004,6 +2077,7 @@ var ActorHandleRaw = class {
   #encoding;
   #actorQuery;
   #params;
+  #queueSender;
   /**
    * Do not call this directly.
    *
@@ -2017,6 +2091,21 @@ var ActorHandleRaw = class {
     this.#encoding = encoding;
     this.#actorQuery = actorQuery;
     this.#params = params;
+    this.#queueSender = createQueueSender({
+      encoding: this.#encoding,
+      params: this.#params,
+      customFetch: async (request) => {
+        const { actorId } = await queryActor(
+          void 0,
+          this.#actorQuery,
+          this.#driver
+        );
+        return this.#driver.sendRequest(actorId, request);
+      }
+    });
+  }
+  send(name, body, options) {
+    return this.#queueSender.send(name, body, options);
   }
   /**
    * Call a raw action. This method sends an HTTP request to invoke the named action.
@@ -2067,12 +2156,12 @@ var ActorHandleRaw = class {
         }),
         // BARE Request: args needs to be CBOR-encoded
         requestToBare: (args) => ({
-          args: bufferToArrayBuffer(cbor4.encode(args))
+          args: bufferToArrayBuffer(cbor5.encode(args))
         }),
         // JSON Response: output is the raw value
         responseFromJson: (json) => json.output,
         // BARE Response: output is ArrayBuffer that needs CBOR-decoding
-        responseFromBare: (bare) => cbor4.decode(new Uint8Array(bare.output))
+        responseFromBare: (bare) => cbor5.decode(new Uint8Array(bare.output))
       });
       return responseData;
     } catch (err) {
@@ -2120,13 +2209,10 @@ var ActorHandleRaw = class {
     );
   }
   /**
-   * Makes a raw HTTP request to the actor.
-   *
-   * @param input - The URL, path, or Request object
-   * @param init - Standard fetch RequestInit options
-   * @returns Promise<Response> - The raw HTTP response
+   * Fetches a resource from this actor via the /request endpoint. This is a
+   * convenience wrapper around the raw HTTP API.
    */
-  async fetch(input, init) {
+  fetch(input, init) {
     return rawHttpFetch(
       this.#driver,
       this.#actorQuery,
@@ -2136,13 +2222,9 @@ var ActorHandleRaw = class {
     );
   }
   /**
-   * Creates a raw WebSocket connection to the actor.
-   *
-   * @param path - The path for the WebSocket connection (e.g., "stream")
-   * @param protocols - Optional WebSocket subprotocols
-   * @returns WebSocket - A raw WebSocket connection
+   * Opens a raw WebSocket connection to this actor.
    */
-  async websocket(path, protocols) {
+  webSocket(path, protocols) {
     return rawWebSocket(
       this.#driver,
       this.#actorQuery,
@@ -2154,16 +2236,18 @@ var ActorHandleRaw = class {
   /**
    * Resolves the actor to get its unique actor ID.
    */
-  async resolve({ signal } = {}) {
-    if ("getForKey" in this.#actorQuery || "getOrCreateForKey" in this.#actorQuery) {
-      let name;
-      if ("getForKey" in this.#actorQuery) {
-        name = this.#actorQuery.getForKey.name;
-      } else if ("getOrCreateForKey" in this.#actorQuery) {
-        name = this.#actorQuery.getOrCreateForKey.name;
-      } else {
-        assertUnreachable2(this.#actorQuery);
-      }
+  async resolve() {
+    if ("getForKey" in this.#actorQuery) {
+      const name = this.#actorQuery.getForKey.name;
+      const { actorId } = await queryActor(
+        void 0,
+        this.#actorQuery,
+        this.#driver
+      );
+      this.#actorQuery = { getForId: { actorId, name } };
+      return actorId;
+    } else if ("getOrCreateForKey" in this.#actorQuery) {
+      const name = this.#actorQuery.getOrCreateForKey.name;
       const { actorId } = await queryActor(
         void 0,
         this.#actorQuery,
@@ -2193,8 +2277,8 @@ var ActorHandleRaw = class {
 };
 
 // src/client/client.ts
-var ACTOR_CONNS_SYMBOL = Symbol("actorConns");
-var CREATE_ACTOR_CONN_PROXY = Symbol("createActorConnProxy");
+var ACTOR_CONNS_SYMBOL = /* @__PURE__ */ Symbol("actorConns");
+var CREATE_ACTOR_CONN_PROXY = /* @__PURE__ */ Symbol("createActorConnProxy");
 var ClientRaw = class {
   #disposed = false;
   [ACTOR_CONNS_SYMBOL] = /* @__PURE__ */ new Set();
@@ -2426,9 +2510,7 @@ function createActorProxy(handle) {
     },
     // Support for 'in' operator
     has(target, prop) {
-      if (typeof prop === "string") {
-        return true;
-      }
+      if (typeof prop === "string") return true;
       return Reflect.has(target, prop);
     },
     // Support instanceof checks
@@ -2462,7 +2544,7 @@ function createActorProxy(handle) {
 }
 
 // src/client/config.ts
-import z2 from "zod";
+import z2 from "zod/v4";
 function getDefaultEndpoint() {
   var _a;
   if (typeof window !== "undefined" && ((_a = window.location) == null ? void 0 : _a.origin)) {
@@ -2541,2207 +2623,20 @@ function convertRegistryConfigToClientConfig(config) {
   };
 }
 
-// src/actor/instance/mod.ts
-import invariant7 from "invariant";
-
-// src/inspector/actor-inspector.ts
-import * as cbor5 from "cbor-x";
-import { createNanoEvents } from "nanoevents";
-var ActorInspector = class {
-  constructor(actor) {
-    this.actor = actor;
-    this.emitter.on("eventFired", (event) => {
-      const commonParams = {
-        id: crypto.randomUUID(),
-        timestamp: BigInt(Date.now())
-      };
-      this.#lastEvents.push({
-        ...commonParams,
-        ...transformEvent(event)
-      });
-      if (this.#lastEvents.length > 100) {
-        this.#lastEvents = this.#lastEvents.slice(-100);
-      }
-    });
-  }
-  emitter = createNanoEvents();
-  #lastEvents = [];
-  getLastEvents() {
-    return this.#lastEvents;
-  }
-  clearEvents() {
-    this.#lastEvents = [];
-    this.emitter.emit("eventsChanged");
-  }
-  // actor accessor methods
-  isDatabaseEnabled() {
-    try {
-      return this.actor.db !== void 0;
-    } catch {
-      return false;
-    }
-  }
-  isStateEnabled() {
-    return this.actor.stateEnabled;
-  }
-  getState() {
-    if (!this.actor.stateEnabled) {
-      throw new StateNotEnabled();
-    }
-    return bufferToArrayBuffer(
-      cbor5.encode(this.actor.stateManager.persistRaw.state)
-    );
-  }
-  getRpcs() {
-    return this.actor.actions;
-  }
-  getConnections() {
-    return Array.from(
-      this.actor.connectionManager.connections.entries()
-    ).map(([id, conn]) => {
-      var _a, _b;
-      const connStateManager = conn[CONN_STATE_MANAGER_SYMBOL];
-      return {
-        type: (_a = conn[CONN_DRIVER_SYMBOL]) == null ? void 0 : _a.type,
-        id,
-        details: bufferToArrayBuffer(
-          cbor5.encode({
-            type: (_b = conn[CONN_DRIVER_SYMBOL]) == null ? void 0 : _b.type,
-            params: conn.params,
-            stateEnabled: connStateManager.stateEnabled,
-            state: connStateManager.stateEnabled ? connStateManager.state : void 0,
-            subscriptions: conn.subscriptions.size,
-            isHibernatable: conn.isHibernatable
-            // TODO: Include underlying hibernatable metadata +
-            // path + headers
-          })
-        )
-      };
-    });
-  }
-  async setState(state) {
-    if (!this.actor.stateEnabled) {
-      throw new StateNotEnabled();
-    }
-    this.actor.stateManager.state = cbor5.decode(Buffer.from(state));
-    await this.actor.stateManager.saveState({ immediate: true });
-  }
-  async executeAction(name, params) {
-    const conn = await this.actor.connectionManager.prepareAndConnectConn(
-      createHttpDriver(),
-      // TODO: This may cause issues
-      void 0,
-      void 0,
-      void 0,
-      void 0
-    );
-    try {
-      return bufferToArrayBuffer(
-        cbor5.encode(
-          await this.actor.executeAction(
-            new ActionContext(this.actor, conn),
-            name,
-            cbor5.decode(Buffer.from(params))
-          )
-        )
-      );
-    } finally {
-      conn.disconnect();
-    }
-  }
-};
-function transformEvent(event) {
-  if (event.type === "action") {
-    return {
-      body: {
-        tag: "ActionEvent",
-        val: {
-          name: event.name,
-          args: bufferToArrayBuffer(cbor5.encode(event.args)),
-          connId: event.connId
-        }
-      }
-    };
-  } else if (event.type === "subscribe") {
-    return {
-      body: {
-        tag: "SubscribeEvent",
-        val: {
-          eventName: event.eventName,
-          connId: event.connId
-        }
-      }
-    };
-  } else if (event.type === "unsubscribe") {
-    return {
-      body: {
-        tag: "UnSubscribeEvent",
-        val: {
-          eventName: event.eventName,
-          connId: event.connId
-        }
-      }
-    };
-  } else if (event.type === "event") {
-    return {
-      body: {
-        tag: "FiredEvent",
-        val: {
-          eventName: event.eventName,
-          args: bufferToArrayBuffer(cbor5.encode(event.args)),
-          connId: event.connId
-        }
-      }
-    };
-  } else if (event.type === "broadcast") {
-    return {
-      body: {
-        tag: "BroadcastEvent",
-        val: {
-          eventName: event.eventName,
-          args: bufferToArrayBuffer(cbor5.encode(event.args))
-        }
-      }
-    };
-  } else {
-    assertUnreachable(event);
+// src/client/mod.ts
+function createClient(endpointOrConfig) {
+  const configInput = endpointOrConfig === void 0 ? {} : typeof endpointOrConfig === "string" ? { endpoint: endpointOrConfig } : endpointOrConfig;
+  const config = ClientConfigSchema.parse(configInput);
+  const driver = new RemoteManagerDriver(config);
+  if (config.devtools) {
+    injectDevtools(config);
   }
-}
-
-// src/actor/conn/persisted.ts
-import * as cbor6 from "cbor-x";
-function convertConnToBarePersistedConn(persist) {
-  return {
-    id: persist.id,
-    parameters: bufferToArrayBuffer(cbor6.encode(persist.parameters)),
-    state: bufferToArrayBuffer(cbor6.encode(persist.state)),
-    subscriptions: persist.subscriptions.map((sub) => ({
-      eventName: sub.eventName
-    })),
-    gatewayId: persist.gatewayId,
-    requestId: persist.requestId,
-    serverMessageIndex: persist.serverMessageIndex,
-    clientMessageIndex: persist.clientMessageIndex,
-    requestPath: persist.requestPath,
-    requestHeaders: new Map(Object.entries(persist.requestHeaders))
-  };
-}
-function convertConnFromBarePersistedConn(bareData) {
-  return {
-    id: bareData.id,
-    parameters: cbor6.decode(new Uint8Array(bareData.parameters)),
-    state: cbor6.decode(new Uint8Array(bareData.state)),
-    subscriptions: bareData.subscriptions.map((sub) => ({
-      eventName: sub.eventName
-    })),
-    gatewayId: bareData.gatewayId,
-    requestId: bareData.requestId,
-    serverMessageIndex: bareData.serverMessageIndex,
-    clientMessageIndex: bareData.clientMessageIndex,
-    requestPath: bareData.requestPath,
-    requestHeaders: Object.fromEntries(bareData.requestHeaders)
-  };
-}
-
-// src/actor/schedule.ts
-var Schedule = class {
-  #actor;
-  constructor(actor) {
-    this.#actor = actor;
-  }
-  async after(duration, fn, ...args) {
-    await this.#actor.scheduleEvent(Date.now() + duration, fn, args);
-  }
-  async at(timestamp, fn, ...args) {
-    await this.#actor.scheduleEvent(timestamp, fn, args);
-  }
-};
-
-// src/actor/instance/connection-manager.ts
-import invariant6 from "invariant";
-var ConnectionManager = class {
-  #actor;
-  #connections = /* @__PURE__ */ new Map();
-  /** Connections that have had their state changed and need to be persisted. */
-  #connsWithPersistChanged = /* @__PURE__ */ new Set();
-  constructor(actor) {
-    this.#actor = actor;
-  }
-  get connections() {
-    return this.#connections;
-  }
-  getConnForId(id) {
-    return this.#connections.get(id);
-  }
-  get connsWithPersistChanged() {
-    return this.#connsWithPersistChanged;
-  }
-  clearConnWithPersistChanged() {
-    this.#connsWithPersistChanged.clear();
-  }
-  markConnWithPersistChanged(conn) {
-    invariant6(
-      conn.isHibernatable,
-      "cannot mark non-hibernatable conn for persist"
-    );
-    this.#actor.rLog.debug({
-      msg: "marked connection as changed",
-      connId: conn.id,
-      totalChanged: this.#connsWithPersistChanged.size
-    });
-    this.#connsWithPersistChanged.add(conn.id);
-    this.#actor.stateManager.savePersistThrottled();
-  }
-  // MARK: - Connection Lifecycle
-  /**
-   * Handles pre-connection logic (i.e. auth & create state) before actually connecting the connection.
-   */
-  async prepareConn(driver, params, request, requestPath, requestHeaders, isHibernatable, isRestoringHibernatable) {
-    this.#actor.assertReady();
-    if (isRestoringHibernatable) {
-      return this.#reconnectHibernatableConn(driver);
-    }
-    if (this.#actor.config.onBeforeConnect) {
-      const ctx = new BeforeConnectContext(this.#actor, request);
-      await this.#actor.config.onBeforeConnect(ctx, params);
-    }
-    let connState;
-    if (this.#actor.connStateEnabled) {
-      connState = await this.#createConnState(params, request);
-    }
-    let connData;
-    if (isHibernatable) {
-      const hibernatable = driver.hibernatable;
-      invariant6(hibernatable, "must have hibernatable");
-      invariant6(requestPath, "missing requestPath for hibernatable ws");
-      invariant6(
-        requestHeaders,
-        "missing requestHeaders for hibernatable ws"
-      );
-      connData = {
-        hibernatable: {
-          id: crypto.randomUUID(),
-          parameters: params,
-          state: connState,
-          subscriptions: [],
-          gatewayId: hibernatable.gatewayId,
-          requestId: hibernatable.requestId,
-          clientMessageIndex: 0,
-          // First message index will be 1, so we start at 0
-          serverMessageIndex: 0,
-          requestPath,
-          requestHeaders
-        }
-      };
-    } else {
-      connData = {
-        ephemeral: {
-          id: crypto.randomUUID(),
-          parameters: params,
-          state: connState
-        }
-      };
-    }
-    const conn = new Conn(this.#actor, connData);
-    conn[CONN_DRIVER_SYMBOL] = driver;
-    return conn;
-  }
-  /**
-   * Adds a connection form prepareConn to the actor and calls onConnect.
-   *
-   * This method is intentionally not async since it needs to be called in
-   * `onOpen` for WebSockets. If this is async, the order of open events will
-   * be messed up and cause race conditions that can drop WebSocket messages.
-   * So all async work in prepareConn.
-   */
-  connectConn(conn) {
-    invariant6(!this.#connections.has(conn.id), "conn already connected");
-    this.#connections.set(conn.id, conn);
-    if (this.#actor.driver.onCreateConn) {
-      this.#actor.driver.onCreateConn(conn);
-    }
-    if (conn.isHibernatable) {
-      this.markConnWithPersistChanged(conn);
-    }
-    this.#callOnConnect(conn);
-    this.#actor.inspector.emitter.emit("connectionsUpdated");
-    this.#actor.resetSleepTimer();
-    conn[CONN_CONNECTED_SYMBOL] = true;
-    if (conn[CONN_SPEAKS_RIVETKIT_SYMBOL]) {
-      const initData = { actorId: this.#actor.id, connectionId: conn.id };
-      conn[CONN_SEND_MESSAGE_SYMBOL](
-        new CachedSerializer(
-          initData,
-          TO_CLIENT_VERSIONED,
-          CURRENT_VERSION,
-          ToClientSchema,
-          // JSON: identity conversion (no nested data to encode)
-          (value) => ({
-            body: {
-              tag: "Init",
-              val: value
-            }
-          }),
-          // BARE/CBOR: identity conversion (no nested data to encode)
-          (value) => ({
-            body: {
-              tag: "Init",
-              val: value
-            }
-          })
-        )
-      );
-    }
-  }
-  #reconnectHibernatableConn(driver) {
-    invariant6(driver.hibernatable, "missing requestIdBuf");
-    const existingConn = this.findHibernatableConn(
-      driver.hibernatable.gatewayId,
-      driver.hibernatable.requestId
-    );
-    invariant6(
-      existingConn,
-      "cannot find connection for restoring connection"
-    );
-    this.#actor.rLog.debug({
-      msg: "reconnecting hibernatable websocket connection",
-      connectionId: existingConn.id
-    });
-    if (existingConn[CONN_DRIVER_SYMBOL]) {
-      this.#disconnectExistingDriver(existingConn);
-    }
-    existingConn[CONN_DRIVER_SYMBOL] = driver;
-    this.#actor.resetSleepTimer();
-    existingConn[CONN_CONNECTED_SYMBOL] = true;
-    this.#actor.inspector.emitter.emit("connectionsUpdated");
-    return existingConn;
-  }
-  #disconnectExistingDriver(conn) {
-    const driver = conn[CONN_DRIVER_SYMBOL];
-    if (driver == null ? void 0 : driver.disconnect) {
-      driver.disconnect(
-        this.#actor,
-        conn,
-        "Reconnecting hibernatable websocket with new driver state"
-      );
-    }
-  }
-  /**
-   * Handle connection disconnection.
-   *
-   * This is called by `Conn.disconnect`. This should not call `Conn.disconnect.`
-   */
-  async connDisconnected(conn) {
-    this.#connections.delete(conn.id);
-    this.#actor.rLog.debug({ msg: "removed conn", connId: conn.id });
-    if (this.#actor.driver.onDestroyConn) {
-      this.#actor.driver.onDestroyConn(conn);
-    }
-    for (const eventName of [...conn.subscriptions.values()]) {
-      this.#actor.eventManager.removeSubscription(eventName, conn, true);
-    }
-    this.#actor.resetSleepTimer();
-    this.#actor.inspector.emitter.emit("connectionsUpdated");
-    if (this.#actor.config.onDisconnect) {
-      try {
-        const result = this.#actor.config.onDisconnect(
-          this.#actor.actorContext,
-          conn
-        );
-        if (result instanceof Promise) {
-          result.catch((error) => {
-            this.#actor.rLog.error({
-              msg: "error in `onDisconnect`",
-              error: stringifyError(error)
-            });
-          });
-        }
-      } catch (error) {
-        this.#actor.rLog.error({
-          msg: "error in `onDisconnect`",
-          error: stringifyError(error)
-        });
-      }
-    }
-    this.#connsWithPersistChanged.delete(conn.id);
-    if (conn.isHibernatable) {
-      const key = makeConnKey(conn.id);
-      try {
-        await this.#actor.driver.kvBatchDelete(this.#actor.id, [key]);
-        this.#actor.rLog.debug({
-          msg: "removed connection from KV",
-          connId: conn.id
-        });
-      } catch (err) {
-        this.#actor.rLog.error({
-          msg: "kvBatchDelete failed for conn",
-          err: stringifyError(err)
-        });
-      }
-    }
-  }
-  /**
-   * Utilify function for call sites that don't need a separate prepare and connect phase.
-   */
-  async prepareAndConnectConn(driver, params, request, requestPath, requestHeaders) {
-    const conn = await this.prepareConn(
-      driver,
-      params,
-      request,
-      requestPath,
-      requestHeaders,
-      false,
-      false
-    );
-    this.connectConn(conn);
-    return conn;
-  }
-  // MARK: - Persistence
-  /**
-   * Restores connections from persisted data during actor initialization.
-   */
-  restoreConnections(connections) {
-    for (const connPersist of connections) {
-      const conn = new Conn(this.#actor, {
-        hibernatable: connPersist
-      });
-      this.#connections.set(conn.id, conn);
-      if (this.#actor.driver.onCreateConn) {
-        this.#actor.driver.onCreateConn(conn);
-      }
-      for (const sub of connPersist.subscriptions) {
-        this.#actor.eventManager.addSubscription(
-          sub.eventName,
-          conn,
-          true
-        );
-      }
-    }
-  }
-  // MARK: - Private Helpers
-  findHibernatableConn(gatewayIdBuf, requestIdBuf) {
-    return Array.from(this.#connections.values()).find((conn) => {
-      const connStateManager = conn[CONN_STATE_MANAGER_SYMBOL];
-      const h = connStateManager.hibernatableDataRaw;
-      return h && arrayBuffersEqual(h.gatewayId, gatewayIdBuf) && arrayBuffersEqual(h.requestId, requestIdBuf);
-    });
-  }
-  async #createConnState(params, request) {
-    if ("createConnState" in this.#actor.config) {
-      const ctx = new CreateConnStateContext(this.#actor, request);
-      const dataOrPromise = this.#actor.config.createConnState(
-        ctx,
-        params
-      );
-      if (dataOrPromise instanceof Promise) {
-        return await deadline(
-          dataOrPromise,
-          this.#actor.config.options.createConnStateTimeout
-        );
-      }
-      return dataOrPromise;
-    } else if ("connState" in this.#actor.config) {
-      return structuredClone(this.#actor.config.connState);
-    }
-    throw new Error(
-      "Could not create connection state from 'createConnState' or 'connState'"
-    );
-  }
-  #callOnConnect(conn) {
-    if (this.#actor.config.onConnect) {
-      try {
-        const ctx = new ConnectContext(this.#actor, conn);
-        const result = this.#actor.config.onConnect(ctx, conn);
-        if (result instanceof Promise) {
-          deadline(
-            result,
-            this.#actor.config.options.onConnectTimeout
-          ).catch((error) => {
-            this.#actor.rLog.error({
-              msg: "error in `onConnect`, closing socket",
-              error
-            });
-            conn == null ? void 0 : conn.disconnect("`onConnect` failed");
-          });
-        }
-      } catch (error) {
-        this.#actor.rLog.error({
-          msg: "error in `onConnect`",
-          error: stringifyError(error)
-        });
-        conn == null ? void 0 : conn.disconnect("`onConnect` failed");
-      }
-    }
-  }
-};
-
-// src/actor/instance/event-manager.ts
-import * as cbor7 from "cbor-x";
-var EventManager = class {
-  #actor;
-  #subscriptionIndex = /* @__PURE__ */ new Map();
-  constructor(actor) {
-    this.#actor = actor;
-  }
-  // MARK: - Public API
-  /**
-   * Adds a subscription for a connection to an event.
-   *
-   * @param eventName - The name of the event to subscribe to
-   * @param connection - The connection subscribing to the event
-   * @param fromPersist - Whether this subscription is being restored from persistence
-   */
-  addSubscription(eventName, connection, fromPersist) {
-    if (connection.subscriptions.has(eventName)) {
-      this.#actor.rLog.debug({
-        msg: "connection already has subscription",
-        eventName,
-        connId: connection.id
-      });
-      return;
-    }
-    connection.subscriptions.add(eventName);
-    let subscribers = this.#subscriptionIndex.get(eventName);
-    if (!subscribers) {
-      subscribers = /* @__PURE__ */ new Set();
-      this.#subscriptionIndex.set(eventName, subscribers);
-    }
-    subscribers.add(connection);
-    if (!fromPersist) {
-      connection[CONN_STATE_MANAGER_SYMBOL].addSubscription({
-        eventName
-      });
-      this.#actor.stateManager.saveState({ immediate: true });
-    }
-    this.#actor.rLog.debug({
-      msg: "subscription added",
-      eventName,
-      connId: connection.id,
-      totalSubscribers: subscribers.size
-    });
-  }
-  /**
-   * Removes a subscription for a connection from an event.
-   *
-   * @param eventName - The name of the event to unsubscribe from
-   * @param connection - The connection unsubscribing from the event
-   * @param fromRemoveConn - Whether this is being called as part of connection removal
-   */
-  removeSubscription(eventName, connection, fromRemoveConn) {
-    if (!connection.subscriptions.has(eventName)) {
-      this.#actor.rLog.warn({
-        msg: "connection does not have subscription",
-        eventName,
-        connId: connection.id
-      });
-      return;
-    }
-    connection.subscriptions.delete(eventName);
-    const subscribers = this.#subscriptionIndex.get(eventName);
-    if (subscribers) {
-      subscribers.delete(connection);
-      if (subscribers.size === 0) {
-        this.#subscriptionIndex.delete(eventName);
-      }
-    }
-    if (!fromRemoveConn) {
-      const removed = connection[CONN_STATE_MANAGER_SYMBOL].removeSubscription({ eventName });
-      if (!removed) {
-        this.#actor.rLog.warn({
-          msg: "subscription does not exist in persist",
-          eventName,
-          connId: connection.id
-        });
-      }
-      this.#actor.stateManager.saveState({ immediate: true });
-    }
-    this.#actor.rLog.debug({
-      msg: "subscription removed",
-      eventName,
-      connId: connection.id,
-      remainingSubscribers: (subscribers == null ? void 0 : subscribers.size) || 0
-    });
-  }
-  /**
-   * Broadcasts an event to all subscribed connections.
-   *
-   * @param name - The name of the event to broadcast
-   * @param args - The arguments to send with the event
-   */
-  broadcast(name, ...args) {
-    this.#actor.assertReady();
-    this.#actor.inspector.emitter.emit("eventFired", {
-      type: "broadcast",
-      eventName: name,
-      args
-    });
-    const subscribers = this.#subscriptionIndex.get(name);
-    if (!subscribers || subscribers.size === 0) {
-      this.#actor.rLog.debug({
-        msg: "no subscribers for event",
-        eventName: name
-      });
-      return;
-    }
-    const eventData = { name, args };
-    const toClientSerializer = new CachedSerializer(
-      eventData,
-      TO_CLIENT_VERSIONED,
-      CURRENT_VERSION,
-      ToClientSchema,
-      // JSON: args is the raw value (array of arguments)
-      (value) => ({
-        body: {
-          tag: "Event",
-          val: {
-            name: value.name,
-            args: value.args
-          }
-        }
-      }),
-      // BARE/CBOR: args needs to be CBOR-encoded to ArrayBuffer
-      (value) => ({
-        body: {
-          tag: "Event",
-          val: {
-            name: value.name,
-            args: bufferToArrayBuffer(cbor7.encode(value.args))
-          }
-        }
-      })
-    );
-    let sentCount = 0;
-    for (const connection of subscribers) {
-      if (connection[CONN_SPEAKS_RIVETKIT_SYMBOL]) {
-        try {
-          connection[CONN_SEND_MESSAGE_SYMBOL](toClientSerializer);
-          sentCount++;
-        } catch (error) {
-          if (error instanceof OutgoingMessageTooLong) {
-            throw error;
-          }
-          this.#actor.rLog.error({
-            msg: "failed to send event to connection",
-            eventName: name,
-            connId: connection.id,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-    }
-    this.#actor.rLog.debug({
-      msg: "event broadcasted",
-      eventName: name,
-      subscriberCount: subscribers.size,
-      sentCount
-    });
-  }
-  /**
-   * Gets all subscribers for a specific event.
-   *
-   * @param eventName - The name of the event
-   * @returns Set of connections subscribed to the event, or undefined if no subscribers
-   */
-  getSubscribers(eventName) {
-    return this.#subscriptionIndex.get(eventName);
-  }
-  /**
-   * Gets all events and their subscriber counts.
-   *
-   * @returns Map of event names to subscriber counts
-   */
-  getEventStats() {
-    const stats = /* @__PURE__ */ new Map();
-    for (const [eventName, subscribers] of this.#subscriptionIndex) {
-      stats.set(eventName, subscribers.size);
-    }
-    return stats;
-  }
-  /**
-   * Clears all subscriptions for a connection.
-   * Used during connection cleanup.
-   *
-   * @param connection - The connection to clear subscriptions for
-   */
-  clearConnectionSubscriptions(connection) {
-    for (const eventName of [...connection.subscriptions.values()]) {
-      this.removeSubscription(eventName, connection, true);
-    }
-  }
-  /**
-   * Gets the total number of unique events being subscribed to.
-   */
-  get eventCount() {
-    return this.#subscriptionIndex.size;
-  }
-  /**
-   * Gets the total number of subscriptions across all events.
-   */
-  get totalSubscriptionCount() {
-    let total = 0;
-    for (const subscribers of this.#subscriptionIndex.values()) {
-      total += subscribers.size;
-    }
-    return total;
-  }
-  /**
-   * Checks if an event has any subscribers.
-   *
-   * @param eventName - The name of the event to check
-   * @returns True if the event has at least one subscriber
-   */
-  hasSubscribers(eventName) {
-    const subscribers = this.#subscriptionIndex.get(eventName);
-    return subscribers !== void 0 && subscribers.size > 0;
-  }
-};
-
-// src/actor/instance/persisted.ts
-import * as cbor8 from "cbor-x";
-function convertActorToBarePersisted(persist) {
-  return {
-    input: persist.input !== void 0 ? bufferToArrayBuffer(cbor8.encode(persist.input)) : null,
-    hasInitialized: persist.hasInitialized,
-    state: bufferToArrayBuffer(cbor8.encode(persist.state)),
-    scheduledEvents: persist.scheduledEvents.map((event) => ({
-      eventId: event.eventId,
-      timestamp: BigInt(event.timestamp),
-      action: event.action,
-      args: event.args ?? null
-    }))
-  };
-}
-function convertActorFromBarePersisted(bareData) {
-  return {
-    input: bareData.input ? cbor8.decode(new Uint8Array(bareData.input)) : void 0,
-    hasInitialized: bareData.hasInitialized,
-    state: cbor8.decode(new Uint8Array(bareData.state)),
-    scheduledEvents: bareData.scheduledEvents.map((event) => ({
-      eventId: event.eventId,
-      timestamp: Number(event.timestamp),
-      action: event.action,
-      args: event.args ?? void 0
-    }))
-  };
-}
-
-// src/actor/instance/schedule-manager.ts
-import * as cbor9 from "cbor-x";
-var ScheduleManager = class {
-  #actor;
-  #actorDriver;
-  #alarmWriteQueue = new SinglePromiseQueue();
-  #config;
-  // ActorConfig type
-  #persist;
-  // Reference to PersistedActor
-  constructor(actor, actorDriver, config) {
-    this.#actor = actor;
-    this.#actorDriver = actorDriver;
-    this.#config = config;
-  }
-  // MARK: - Public API
-  /**
-   * Sets the persist object reference.
-   * Called after StateManager initializes the persist proxy.
-   */
-  setPersist(persist) {
-    this.#persist = persist;
-  }
-  /**
-   * Schedules an event to be executed at a specific timestamp.
-   *
-   * @param timestamp - Unix timestamp in milliseconds when the event should fire
-   * @param action - The name of the action to execute
-   * @param args - Arguments to pass to the action
-   */
-  async scheduleEvent(timestamp, action, args) {
-    const newEvent = {
-      eventId: crypto.randomUUID(),
-      timestamp,
-      action,
-      args: bufferToArrayBuffer(cbor9.encode(args))
-    };
-    await this.#scheduleEventInner(newEvent);
-  }
-  /**
-   * Triggers any pending alarms that are due.
-   * This method is idempotent and safe to call multiple times.
-   */
-  async onAlarm() {
-    var _a, _b, _c;
-    const now = Date.now();
-    this.#actor.log.debug({
-      msg: "alarm triggered",
-      now,
-      events: ((_b = (_a = this.#persist) == null ? void 0 : _a.scheduledEvents) == null ? void 0 : _b.length) || 0
-    });
-    if (!((_c = this.#persist) == null ? void 0 : _c.scheduledEvents)) {
-      this.#actor.rLog.debug({ msg: "no scheduled events" });
-      return;
-    }
-    const dueIndex = this.#persist.scheduledEvents.findIndex(
-      (x) => x.timestamp <= now
-    );
-    if (dueIndex === -1) {
-      this.#actor.rLog.debug({ msg: "no events are due yet" });
-      if (this.#persist.scheduledEvents.length > 0) {
-        const nextTs = this.#persist.scheduledEvents[0].timestamp;
-        this.#actor.log.debug({
-          msg: "alarm fired early, rescheduling for next event",
-          now,
-          nextTs,
-          delta: nextTs - now
-        });
-        await this.#queueSetAlarm(nextTs);
-      }
-      return;
-    }
-    const dueEvents = this.#persist.scheduledEvents.splice(0, dueIndex + 1);
-    this.#actor.log.debug({
-      msg: "running events",
-      count: dueEvents.length
-    });
-    if (this.#persist.scheduledEvents.length > 0) {
-      const nextTs = this.#persist.scheduledEvents[0].timestamp;
-      this.#actor.log.info({
-        msg: "setting next alarm",
-        nextTs,
-        remainingEvents: this.#persist.scheduledEvents.length
-      });
-      await this.#queueSetAlarm(nextTs);
-    }
-    await this.#executeDueEvents(dueEvents);
-  }
-  /**
-   * Initializes alarms on actor startup.
-   * Sets the alarm for the next scheduled event if any exist.
-   */
-  async initializeAlarms() {
-    var _a, _b;
-    if (((_b = (_a = this.#persist) == null ? void 0 : _a.scheduledEvents) == null ? void 0 : _b.length) > 0) {
-      await this.#queueSetAlarm(
-        this.#persist.scheduledEvents[0].timestamp
-      );
-    }
-  }
-  /**
-   * Waits for any pending alarm write operations to complete.
-   */
-  async waitForPendingAlarmWrites() {
-    if (this.#alarmWriteQueue.runningDrainLoop) {
-      await this.#alarmWriteQueue.runningDrainLoop;
-    }
-  }
-  /**
-   * Gets statistics about scheduled events.
-   */
-  getScheduleStats() {
-    var _a;
-    if (!((_a = this.#persist) == null ? void 0 : _a.scheduledEvents)) {
-      return {
-        totalEvents: 0,
-        nextEventTime: null,
-        overdueCount: 0
-      };
-    }
-    const now = Date.now();
-    const events = this.#persist.scheduledEvents;
-    return {
-      totalEvents: events.length,
-      nextEventTime: events.length > 0 ? events[0].timestamp : null,
-      overdueCount: events.filter(
-        (e) => e.timestamp <= now
-      ).length
-    };
-  }
-  /**
-   * Cancels a scheduled event by its ID.
-   *
-   * @param eventId - The ID of the event to cancel
-   * @returns True if the event was found and cancelled
-   */
-  async cancelEvent(eventId) {
-    var _a;
-    if (!((_a = this.#persist) == null ? void 0 : _a.scheduledEvents)) {
-      return false;
-    }
-    const index = this.#persist.scheduledEvents.findIndex(
-      (e) => e.eventId === eventId
-    );
-    if (index === -1) {
-      return false;
-    }
-    const wasFirst = index === 0;
-    this.#persist.scheduledEvents.splice(index, 1);
-    if (wasFirst && this.#persist.scheduledEvents.length > 0) {
-      await this.#queueSetAlarm(
-        this.#persist.scheduledEvents[0].timestamp
-      );
-    }
-    this.#actor.log.info({
-      msg: "cancelled scheduled event",
-      eventId,
-      remainingEvents: this.#persist.scheduledEvents.length
-    });
-    return true;
-  }
-  // MARK: - Private Helpers
-  async #scheduleEventInner(newEvent) {
-    var _a;
-    this.#actor.log.info({
-      msg: "scheduling event",
-      eventId: newEvent.eventId,
-      timestamp: newEvent.timestamp,
-      action: newEvent.action
-    });
-    if (!((_a = this.#persist) == null ? void 0 : _a.scheduledEvents)) {
-      throw new Error("Persist not initialized");
-    }
-    const insertIndex = this.#persist.scheduledEvents.findIndex(
-      (x) => x.timestamp > newEvent.timestamp
-    );
-    if (insertIndex === -1) {
-      this.#persist.scheduledEvents.push(newEvent);
-    } else {
-      this.#persist.scheduledEvents.splice(insertIndex, 0, newEvent);
-    }
-    if (insertIndex === 0 || this.#persist.scheduledEvents.length === 1) {
-      this.#actor.log.info({
-        msg: "setting alarm for new event",
-        timestamp: newEvent.timestamp,
-        eventCount: this.#persist.scheduledEvents.length
-      });
-      await this.#queueSetAlarm(newEvent.timestamp);
-    }
-  }
-  async #executeDueEvents(events) {
-    for (const event of events) {
-      try {
-        this.#actor.log.info({
-          msg: "executing scheduled event",
-          eventId: event.eventId,
-          timestamp: event.timestamp,
-          action: event.action
-        });
-        const actions = this.#config.actions ?? {};
-        const fn = actions[event.action];
-        if (!fn) {
-          throw new Error(
-            `Missing action for scheduled event: ${event.action}`
-          );
-        }
-        if (typeof fn !== "function") {
-          throw new Error(
-            `Scheduled event action ${event.action} is not a function (got ${typeof fn})`
-          );
-        }
-        const args = event.args ? cbor9.decode(new Uint8Array(event.args)) : [];
-        const result = fn.call(
-          void 0,
-          this.#actor.actorContext,
-          ...args
-        );
-        if (result instanceof Promise) {
-          await result;
-        }
-        this.#actor.log.debug({
-          msg: "scheduled event completed",
-          eventId: event.eventId,
-          action: event.action
-        });
-      } catch (error) {
-        this.#actor.log.error({
-          msg: "error executing scheduled event",
-          error: stringifyError(error),
-          eventId: event.eventId,
-          timestamp: event.timestamp,
-          action: event.action
-        });
-      }
-    }
-  }
-  async #queueSetAlarm(timestamp) {
-    await this.#alarmWriteQueue.enqueue(async () => {
-      await this.#actorDriver.setAlarm(this.#actor, timestamp);
-    });
-  }
-  /**
-   * Gets the next scheduled event, if any.
-   */
-  getNextEvent() {
-    var _a;
-    if (!((_a = this.#persist) == null ? void 0 : _a.scheduledEvents) || this.#persist.scheduledEvents.length === 0) {
-      return null;
-    }
-    return this.#persist.scheduledEvents[0];
-  }
-  /**
-   * Gets all scheduled events.
-   */
-  getAllEvents() {
-    var _a;
-    return ((_a = this.#persist) == null ? void 0 : _a.scheduledEvents) || [];
-  }
-  /**
-   * Clears all scheduled events.
-   * Use with caution - this removes all pending scheduled events.
-   */
-  clearAllEvents() {
-    var _a;
-    if ((_a = this.#persist) == null ? void 0 : _a.scheduledEvents) {
-      this.#persist.scheduledEvents = [];
-      this.#actor.log.warn({ msg: "cleared all scheduled events" });
-    }
-  }
-};
-
-// src/actor/instance/state-manager.ts
-import { idToStr } from "@rivetkit/engine-runner";
-import onChange from "@rivetkit/on-change";
-var StateManager = class {
-  #actor;
-  #actorDriver;
-  // State tracking
-  #persist;
-  #persistRaw;
-  #persistChanged = false;
-  #isInOnStateChange = false;
-  // Save management
-  #persistWriteQueue = new SinglePromiseQueue();
-  #lastSaveTime = 0;
-  #pendingSaveTimeout;
-  #pendingSaveScheduledTimestamp;
-  #onPersistSavedPromise;
-  // Configuration
-  #config;
-  // ActorConfig type
-  #stateSaveInterval;
-  constructor(actor, actorDriver, config) {
-    this.#actor = actor;
-    this.#actorDriver = actorDriver;
-    this.#config = config;
-    this.#stateSaveInterval = config.options.stateSaveInterval || 100;
-  }
-  // MARK: - Public API
-  get persist() {
-    return this.#persist;
-  }
-  get persistRaw() {
-    return this.#persistRaw;
-  }
-  get persistChanged() {
-    return this.#persistChanged;
-  }
-  get state() {
-    this.#validateStateEnabled();
-    return this.#persist.state;
-  }
-  set state(value) {
-    this.#validateStateEnabled();
-    this.#persist.state = value;
-  }
-  get stateEnabled() {
-    return "createState" in this.#config || "state" in this.#config;
-  }
-  // MARK: - Initialization
-  /**
-   * Initializes state from persisted data or creates new state.
-   */
-  async initializeState(persistData) {
-    if (!persistData.hasInitialized) {
-      let stateData;
-      if (this.stateEnabled) {
-        this.#actor.rLog.info({ msg: "actor state initializing" });
-        if ("createState" in this.#config) {
-          stateData = await this.#config.createState(
-            this.#actor.actorContext,
-            persistData.input
-          );
-        } else if ("state" in this.#config) {
-          stateData = structuredClone(this.#config.state);
-        } else {
-          throw new Error(
-            "Both 'createState' or 'state' were not defined"
-          );
-        }
-      } else {
-        this.#actor.rLog.debug({ msg: "state not enabled" });
-      }
-      persistData.state = stateData;
-      persistData.hasInitialized = true;
-      const bareData = convertActorToBarePersisted(persistData);
-      await this.#actorDriver.kvBatchPut(this.#actor.id, [
-        [
-          KEYS.PERSIST_DATA,
-          ACTOR_VERSIONED.serializeWithEmbeddedVersion(
-            bareData,
-            CURRENT_VERSION2
-          )
-        ]
-      ]);
-    }
-    this.initPersistProxy(persistData);
-  }
-  /**
-   * Creates proxy for persist object that handles automatic state change detection.
-   */
-  initPersistProxy(target) {
-    this.#persistRaw = target;
-    if (target === null || typeof target !== "object") {
-      let invalidPath = "";
-      if (!isCborSerializable(
-        target,
-        (path) => {
-          invalidPath = path;
-        },
-        ""
-      )) {
-        throw new InvalidStateType({ path: invalidPath });
-      }
-      return target;
-    }
-    if (this.#persist) {
-      onChange.unsubscribe(this.#persist);
-    }
-    this.#persist = onChange(
-      target,
-      (path, value, _previousValue, _applyData) => {
-        this.#handleStateChange(path, value);
-      },
-      { ignoreDetached: true }
-    );
-  }
-  // MARK: - State Persistence
-  /**
-   * Forces the state to get saved.
-   */
-  async saveState(opts) {
-    var _a;
-    this.#actor.assertReady(opts.allowStoppingState);
-    if (this.#persistChanged) {
-      if (opts.immediate) {
-        await this.#savePersistInner();
-      } else {
-        if (!this.#onPersistSavedPromise) {
-          this.#onPersistSavedPromise = promiseWithResolvers();
-        }
-        this.savePersistThrottled(opts.maxWait);
-        await ((_a = this.#onPersistSavedPromise) == null ? void 0 : _a.promise);
-      }
-    }
-  }
-  /**
-   * Throttled save state method. Used to write to KV at a reasonable cadence.
-   *
-   * Passing a maxWait will override the stateSaveInterval with the min
-   * between that and the maxWait.
-   */
-  savePersistThrottled(maxWait) {
-    const now = Date.now();
-    const timeSinceLastSave = now - this.#lastSaveTime;
-    let saveDelay = Math.max(
-      0,
-      this.#stateSaveInterval - timeSinceLastSave
-    );
-    if (maxWait !== void 0) {
-      saveDelay = Math.min(saveDelay, maxWait);
-    }
-    if (this.#pendingSaveTimeout !== void 0 && this.#pendingSaveScheduledTimestamp !== void 0) {
-      const newScheduledTimestamp = now + saveDelay;
-      if (newScheduledTimestamp < this.#pendingSaveScheduledTimestamp) {
-        clearTimeout(this.#pendingSaveTimeout);
-        this.#pendingSaveTimeout = void 0;
-        this.#pendingSaveScheduledTimestamp = void 0;
-      } else {
-        return;
-      }
-    }
-    if (saveDelay > 0) {
-      this.#pendingSaveScheduledTimestamp = now + saveDelay;
-      this.#pendingSaveTimeout = setTimeout(() => {
-        this.#pendingSaveTimeout = void 0;
-        this.#pendingSaveScheduledTimestamp = void 0;
-        this.#savePersistInner().catch((error) => {
-          this.#actor.rLog.error({
-            msg: "error saving persist data in scheduled save",
-            error: stringifyError(error)
-          });
-        });
-      }, saveDelay);
-    } else {
-      this.#savePersistInner().catch((error) => {
-        this.#actor.rLog.error({
-          msg: "error saving persist data immediately",
-          error: stringifyError(error)
-        });
-      });
-    }
-  }
-  /**
-   * Clears any pending save timeout.
-   */
-  clearPendingSaveTimeout() {
-    if (this.#pendingSaveTimeout) {
-      clearTimeout(this.#pendingSaveTimeout);
-      this.#pendingSaveTimeout = void 0;
-      this.#pendingSaveScheduledTimestamp = void 0;
-    }
-  }
-  /**
-   * Waits for any pending write operations to complete.
-   */
-  async waitForPendingWrites() {
-    if (this.#persistWriteQueue.runningDrainLoop) {
-      await this.#persistWriteQueue.runningDrainLoop;
-    }
-  }
-  // MARK: - Private Helpers
-  #validateStateEnabled() {
-    if (!this.stateEnabled) {
-      throw new StateNotEnabled();
-    }
-  }
-  #handleStateChange(path, value) {
-    const actorStatePath = isStatePath(path);
-    const connStatePath = isConnStatePath(path);
-    if (actorStatePath || connStatePath) {
-      let invalidPath = "";
-      if (!isCborSerializable(
-        value,
-        (invalidPathPart) => {
-          invalidPath = invalidPathPart;
-        },
-        ""
-      )) {
-        throw new InvalidStateType({
-          path: path + (invalidPath ? `.${invalidPath}` : "")
-        });
-      }
-    }
-    this.#actor.rLog.debug({
-      msg: "onChange triggered, setting persistChanged=true",
-      path
-    });
-    this.#persistChanged = true;
-    if (actorStatePath) {
-      this.#actor.inspector.emitter.emit(
-        "stateUpdated",
-        this.#persist.state
-      );
-    }
-    if (actorStatePath && this.#config.onStateChange && this.#actor.isReady() && !this.#isInOnStateChange) {
-      try {
-        this.#isInOnStateChange = true;
-        this.#config.onStateChange(
-          this.#actor.actorContext,
-          this.#persistRaw.state
-        );
-      } catch (error) {
-        this.#actor.rLog.error({
-          msg: "error in `_onStateChange`",
-          error: stringifyError(error)
-        });
-      } finally {
-        this.#isInOnStateChange = false;
-      }
-    }
-  }
-  async #savePersistInner() {
-    var _a, _b;
-    this.#actor.rLog.info({
-      msg: "savePersistInner called",
-      persistChanged: this.#persistChanged,
-      connsWithPersistChangedSize: this.#actor.connectionManager.connsWithPersistChanged.size,
-      connsWithPersistChangedIds: Array.from(
-        this.#actor.connectionManager.connsWithPersistChanged
-      )
-    });
-    try {
-      this.#lastSaveTime = Date.now();
-      const hasChanges = this.#persistChanged || this.#actor.connectionManager.connsWithPersistChanged.size > 0;
-      if (hasChanges) {
-        await this.#persistWriteQueue.enqueue(async () => {
-          this.#actor.rLog.debug({
-            msg: "saving persist",
-            actorChanged: this.#persistChanged,
-            connectionsChanged: this.#actor.connectionManager.connsWithPersistChanged.size
-          });
-          const entries = [];
-          if (this.#persistChanged) {
-            this.#persistChanged = false;
-            const bareData = convertActorToBarePersisted(
-              this.#persistRaw
-            );
-            entries.push([
-              KEYS.PERSIST_DATA,
-              ACTOR_VERSIONED.serializeWithEmbeddedVersion(
-                bareData,
-                CURRENT_VERSION2
-              )
-            ]);
-          }
-          const connections = [];
-          for (const connId of this.#actor.connectionManager.connsWithPersistChanged) {
-            const conn = this.#actor.conns.get(connId);
-            if (!conn) {
-              this.#actor.rLog.warn({
-                msg: "connection not found in conns map",
-                connId
-              });
-              continue;
-            }
-            const connStateManager = conn[CONN_STATE_MANAGER_SYMBOL];
-            const hibernatableDataRaw = connStateManager.hibernatableDataRaw;
-            if (!hibernatableDataRaw) {
-              this.#actor.log.warn({
-                msg: "missing raw hibernatable data for conn in getChangedConnectionsData",
-                connId: conn.id
-              });
-              continue;
-            }
-            this.#actor.rLog.info({
-              msg: "persisting connection",
-              connId,
-              gatewayId: idToStr(hibernatableDataRaw.requestId),
-              requestId: idToStr(hibernatableDataRaw.requestId),
-              serverMessageIndex: hibernatableDataRaw.serverMessageIndex,
-              clientMessageIndex: hibernatableDataRaw.clientMessageIndex,
-              hasState: hibernatableDataRaw.state !== void 0
-            });
-            const bareData = convertConnToBarePersistedConn(
-              hibernatableDataRaw
-            );
-            const connData = CONN_VERSIONED.serializeWithEmbeddedVersion(
-              bareData,
-              CURRENT_VERSION2
-            );
-            entries.push([makeConnKey(connId), connData]);
-            connections.push(conn);
-          }
-          this.#actor.rLog.info({
-            msg: "prepared entries for kvBatchPut",
-            totalEntries: entries.length,
-            connectionEntries: connections.length,
-            connectionIds: connections.map((c) => c.id)
-          });
-          if (this.#actorDriver.onBeforePersistConn) {
-            for (const conn of connections) {
-              this.#actorDriver.onBeforePersistConn(conn);
-            }
-          }
-          this.#actor.connectionManager.clearConnWithPersistChanged();
-          this.#actor.rLog.info({
-            msg: "calling kvBatchPut",
-            actorId: this.#actor.id,
-            entriesCount: entries.length
-          });
-          await this.#actorDriver.kvBatchPut(this.#actor.id, entries);
-          this.#actor.rLog.info({
-            msg: "kvBatchPut completed successfully"
-          });
-          if (this.#actorDriver.onAfterPersistConn) {
-            for (const conn of connections) {
-              this.#actorDriver.onAfterPersistConn(conn);
-            }
-          }
-          this.#actor.rLog.debug({ msg: "persist saved" });
-        });
-      } else {
-        this.#actor.rLog.info({
-          msg: "savePersistInner skipped - no changes"
-        });
-      }
-      (_a = this.#onPersistSavedPromise) == null ? void 0 : _a.resolve();
-    } catch (error) {
-      this.#actor.rLog.error({
-        msg: "error saving persist",
-        error: stringifyError(error)
-      });
-      (_b = this.#onPersistSavedPromise) == null ? void 0 : _b.reject(error);
-      throw error;
-    }
-  }
-};
-
-// src/actor/instance/mod.ts
-var CanSleep = /* @__PURE__ */ ((CanSleep2) => {
-  CanSleep2[CanSleep2["Yes"] = 0] = "Yes";
-  CanSleep2[CanSleep2["NotReady"] = 1] = "NotReady";
-  CanSleep2[CanSleep2["NotStarted"] = 2] = "NotStarted";
-  CanSleep2[CanSleep2["ActiveConns"] = 3] = "ActiveConns";
-  CanSleep2[CanSleep2["ActiveHonoHttpRequests"] = 4] = "ActiveHonoHttpRequests";
-  return CanSleep2;
-})(CanSleep || {});
-var ActorInstance = class {
-  // MARK: - Core Properties
-  actorContext;
-  #config;
-  driver;
-  #inlineClient;
-  #actorId;
-  #name;
-  #key;
-  #region;
-  // MARK: - Managers
-  connectionManager;
-  stateManager;
-  eventManager;
-  #scheduleManager;
-  // MARK: - Logging
-  #log;
-  #rLog;
-  // MARK: - Lifecycle State
-  /**
-   * If the core actor initiation has set up.
-   *
-   * Almost all actions on this actor will throw an error if false.
-   **/
-  #ready = false;
-  /**
-   * If the actor has fully started.
-   *
-   * The only purpose of this is to prevent sleeping until started.
-   */
-  #started = false;
-  #sleepCalled = false;
-  #destroyCalled = false;
-  #stopCalled = false;
-  #sleepTimeout;
-  #abortController = new AbortController();
-  // MARK: - Variables & Database
-  #vars;
-  #db;
-  // MARK: - Background Tasks
-  #backgroundPromises = [];
-  // MARK: - HTTP/WebSocket Tracking
-  #activeHonoHttpRequests = 0;
-  // MARK: - Deprecated (kept for compatibility)
-  #schedule;
-  // MARK: - Inspector
-  #inspectorToken;
-  #inspector = new ActorInspector(this);
-  // MARK: - Constructor
-  constructor(config) {
-    this.#config = config;
-    this.actorContext = new ActorContext(this);
-  }
-  // MARK: - Public Getters
-  get log() {
-    invariant7(this.#log, "log not configured");
-    return this.#log;
-  }
-  get rLog() {
-    invariant7(this.#rLog, "log not configured");
-    return this.#rLog;
-  }
-  get isStopping() {
-    return this.#stopCalled;
-  }
-  get id() {
-    return this.#actorId;
-  }
-  get name() {
-    return this.#name;
-  }
-  get key() {
-    return this.#key;
-  }
-  get region() {
-    return this.#region;
-  }
-  get inlineClient() {
-    return this.#inlineClient;
-  }
-  get inspector() {
-    return this.#inspector;
-  }
-  get inspectorToken() {
-    return this.#inspectorToken;
-  }
-  get conns() {
-    return this.connectionManager.connections;
-  }
-  get schedule() {
-    return this.#schedule;
-  }
-  get abortSignal() {
-    return this.#abortController.signal;
-  }
-  get actions() {
-    return Object.keys(this.#config.actions ?? {});
-  }
-  get config() {
-    return this.#config;
-  }
-  // MARK: - State Access
-  get persist() {
-    return this.stateManager.persist;
-  }
-  get state() {
-    return this.stateManager.state;
-  }
-  set state(value) {
-    this.stateManager.state = value;
-  }
-  get stateEnabled() {
-    return this.stateManager.stateEnabled;
-  }
-  get connStateEnabled() {
-    return "createConnState" in this.#config || "connState" in this.#config;
-  }
-  // MARK: - Variables & Database
-  get vars() {
-    this.#validateVarsEnabled();
-    invariant7(this.#vars !== void 0, "vars not enabled");
-    return this.#vars;
-  }
-  get db() {
-    if (!this.#db) {
-      throw new DatabaseNotEnabled();
-    }
-    return this.#db;
-  }
-  // MARK: - Initialization
-  async start(actorDriver, inlineClient, actorId, name, key, region) {
-    var _a, _b;
-    this.driver = actorDriver;
-    this.#inlineClient = inlineClient;
-    this.#actorId = actorId;
-    this.#name = name;
-    this.#key = key;
-    this.#region = region;
-    this.#initializeLogging();
-    this.connectionManager = new ConnectionManager(this);
-    this.stateManager = new StateManager(this, actorDriver, this.#config);
-    this.eventManager = new EventManager(this);
-    this.#scheduleManager = new ScheduleManager(
-      this,
-      actorDriver,
-      this.#config
-    );
-    this.#schedule = new Schedule(this);
-    await this.#loadState();
-    await this.#initializeInspectorToken();
-    if (this.#varsEnabled) {
-      await this.#initializeVars();
-    }
-    await this.#callOnStart();
-    await this.#setupDatabase();
-    await this.#scheduleManager.initializeAlarms();
-    this.#ready = true;
-    await ((_b = (_a = this.driver).onBeforeActorStart) == null ? void 0 : _b.call(_a, this));
-    this.#started = true;
-    this.#rLog.info({ msg: "actor started" });
-    this.resetSleepTimer();
-    await this.onAlarm();
-  }
-  // MARK: - Ready Check
-  isReady() {
-    return this.#ready;
-  }
-  assertReady(allowStoppingState = false) {
-    if (!this.#ready) throw new InternalError("Actor not ready");
-    if (!allowStoppingState && this.#stopCalled)
-      throw new InternalError("Actor is stopping");
-  }
-  // MARK: - Stop
-  async onStop(mode) {
-    if (this.#stopCalled) {
-      this.#rLog.warn({ msg: "already stopping actor" });
-      return;
-    }
-    this.#stopCalled = true;
-    this.#rLog.info({
-      msg: "setting stopCalled=true",
-      mode
-    });
-    if (this.#sleepTimeout) {
-      clearTimeout(this.#sleepTimeout);
-      this.#sleepTimeout = void 0;
-    }
-    try {
-      this.#abortController.abort();
-    } catch {
-    }
-    if (mode === "sleep") {
-      await this.#callOnSleep();
-    } else if (mode === "destroy") {
-      await this.#callOnDestroy();
-    } else {
-      assertUnreachable2(mode);
-    }
-    await this.#disconnectConnections();
-    await this.#waitBackgroundPromises(
-      this.#config.options.waitUntilTimeout
-    );
-    this.#rLog.info({ msg: "clearing pending save timeouts" });
-    this.stateManager.clearPendingSaveTimeout();
-    this.#rLog.info({ msg: "saving state immediately" });
-    await this.stateManager.saveState({
-      immediate: true,
-      allowStoppingState: true
-    });
-    await this.stateManager.waitForPendingWrites();
-    await this.#scheduleManager.waitForPendingAlarmWrites();
-  }
-  // MARK: - Sleep
-  startSleep() {
-    var _a;
-    if (this.#stopCalled || this.#destroyCalled) {
-      this.#rLog.debug({
-        msg: "cannot call startSleep if actor already stopping"
-      });
-      return;
-    }
-    if (this.#sleepCalled) {
-      this.#rLog.warn({
-        msg: "cannot call startSleep twice, actor already sleeping"
-      });
-      return;
-    }
-    this.#sleepCalled = true;
-    const sleep = (_a = this.driver.startSleep) == null ? void 0 : _a.bind(this.driver, this.#actorId);
-    invariant7(this.#sleepingSupported, "sleeping not supported");
-    invariant7(sleep, "no sleep on driver");
-    this.#rLog.info({ msg: "actor sleeping" });
-    setImmediate(() => {
-      sleep();
-    });
-  }
-  // MARK: - Destroy
-  startDestroy() {
-    if (this.#stopCalled || this.#sleepCalled) {
-      this.#rLog.debug({
-        msg: "cannot call startDestroy if actor already stopping or sleeping"
-      });
-      return;
-    }
-    if (this.#destroyCalled) {
-      this.#rLog.warn({
-        msg: "cannot call startDestroy twice, actor already destroying"
-      });
-      return;
-    }
-    this.#destroyCalled = true;
-    const destroy = this.driver.startDestroy.bind(
-      this.driver,
-      this.#actorId
-    );
-    this.#rLog.info({ msg: "actor destroying" });
-    setImmediate(() => {
-      destroy();
-    });
-  }
-  // MARK: - HTTP Request Tracking
-  beginHonoHttpRequest() {
-    this.#activeHonoHttpRequests++;
-    this.resetSleepTimer();
-  }
-  endHonoHttpRequest() {
-    this.#activeHonoHttpRequests--;
-    if (this.#activeHonoHttpRequests < 0) {
-      this.#activeHonoHttpRequests = 0;
-      this.#rLog.warn({
-        msg: "active hono requests went below 0, this is a RivetKit bug",
-        ...EXTRA_ERROR_LOG
-      });
-    }
-    this.resetSleepTimer();
-  }
-  // MARK: - Message Processing
-  async processMessage(message, conn) {
-    await processMessage(message, this, conn, {
-      onExecuteAction: async (ctx, name, args) => {
-        this.inspector.emitter.emit("eventFired", {
-          type: "action",
-          name,
-          args,
-          connId: conn.id
-        });
-        return await this.executeAction(ctx, name, args);
-      },
-      onSubscribe: async (eventName, conn2) => {
-        this.inspector.emitter.emit("eventFired", {
-          type: "subscribe",
-          eventName,
-          connId: conn2.id
-        });
-        this.eventManager.addSubscription(eventName, conn2, false);
-      },
-      onUnsubscribe: async (eventName, conn2) => {
-        this.inspector.emitter.emit("eventFired", {
-          type: "unsubscribe",
-          eventName,
-          connId: conn2.id
-        });
-        this.eventManager.removeSubscription(eventName, conn2, false);
-      }
-    });
-  }
-  // MARK: - Action Execution
-  async executeAction(ctx, actionName, args) {
-    this.assertReady();
-    const actions = this.#config.actions ?? {};
-    if (!(actionName in actions)) {
-      this.#rLog.warn({ msg: "action does not exist", actionName });
-      throw new ActionNotFound(actionName);
-    }
-    const actionFunction = actions[actionName];
-    if (typeof actionFunction !== "function") {
-      this.#rLog.warn({
-        msg: "action is not a function",
-        actionName,
-        type: typeof actionFunction
-      });
-      throw new ActionNotFound(actionName);
-    }
-    try {
-      this.#rLog.debug({
-        msg: "executing action",
-        actionName,
-        args
-      });
-      const outputOrPromise = actionFunction.call(
-        void 0,
-        ctx,
-        ...args
-      );
-      let output;
-      if (outputOrPromise instanceof Promise) {
-        output = await deadline(
-          outputOrPromise,
-          this.#config.options.actionTimeout
-        );
-      } else {
-        output = outputOrPromise;
-      }
-      if (this.#config.onBeforeActionResponse) {
-        try {
-          const processedOutput = this.#config.onBeforeActionResponse(
-            this.actorContext,
-            actionName,
-            args,
-            output
-          );
-          if (processedOutput instanceof Promise) {
-            output = await processedOutput;
-          } else {
-            output = processedOutput;
-          }
-        } catch (error) {
-          this.#rLog.error({
-            msg: "error in `onBeforeActionResponse`",
-            error: stringifyError(error)
-          });
-        }
-      }
-      return output;
-    } catch (error) {
-      if (error instanceof DeadlineError) {
-        throw new ActionTimedOut();
-      }
-      this.#rLog.error({
-        msg: "action error",
-        actionName,
-        error: stringifyError(error)
-      });
-      throw error;
-    } finally {
-      this.stateManager.savePersistThrottled();
-    }
-  }
-  // MARK: - HTTP/WebSocket Handlers
-  async handleRawRequest(conn, request) {
-    this.assertReady();
-    if (!this.#config.onRequest) {
-      throw new RequestHandlerNotDefined();
-    }
-    try {
-      const ctx = new RequestContext(this, conn, request);
-      const response = await this.#config.onRequest(ctx, request);
-      if (!response) {
-        throw new InvalidRequestHandlerResponse();
-      }
-      return response;
-    } catch (error) {
-      this.#rLog.error({
-        msg: "onRequest error",
-        error: stringifyError(error)
-      });
-      throw error;
-    } finally {
-      this.stateManager.savePersistThrottled();
-    }
-  }
-  handleRawWebSocket(conn, websocket, request) {
-    this.assertReady();
-    if (!this.#config.onWebSocket) {
-      throw new InternalError("onWebSocket handler not defined");
-    }
-    try {
-      this.resetSleepTimer();
-      const ctx = new WebSocketContext(this, conn, request);
-      const voidOrPromise = this.#config.onWebSocket(ctx, websocket);
-      if (voidOrPromise instanceof Promise) {
-        voidOrPromise.then(() => {
-          this.stateManager.savePersistThrottled();
-        });
-      } else {
-        this.stateManager.savePersistThrottled();
-      }
-    } catch (error) {
-      this.#rLog.error({
-        msg: "onWebSocket error",
-        error: stringifyError(error)
-      });
-      throw error;
-    }
-  }
-  // MARK: - Scheduling
-  async scheduleEvent(timestamp, action, args) {
-    await this.#scheduleManager.scheduleEvent(timestamp, action, args);
-  }
-  async onAlarm() {
-    this.resetSleepTimer();
-    await this.#scheduleManager.onAlarm();
-  }
-  // MARK: - Background Tasks
-  waitUntil(promise) {
-    this.assertReady();
-    const nonfailablePromise = promise.then(() => {
-      this.#rLog.debug({ msg: "wait until promise complete" });
-    }).catch((error) => {
-      this.#rLog.error({
-        msg: "wait until promise failed",
-        error: stringifyError(error)
-      });
-    });
-    this.#backgroundPromises.push(nonfailablePromise);
-  }
-  // MARK: - Private Helper Methods
-  #initializeLogging() {
-    var _a, _b;
-    const logParams = {
-      actor: this.#name,
-      key: serializeActorKey(this.#key),
-      actorId: this.#actorId
-    };
-    const extraLogParams = (_b = (_a = this.driver).getExtraActorLogParams) == null ? void 0 : _b.call(_a);
-    if (extraLogParams) Object.assign(logParams, extraLogParams);
-    this.#log = getBaseLogger().child(
-      Object.assign(
-        getIncludeTarget() ? { target: "actor" } : {},
-        logParams
-      )
-    );
-    this.#rLog = getBaseLogger().child(
-      Object.assign(
-        getIncludeTarget() ? { target: "actor-runtime" } : {},
-        logParams
-      )
-    );
-  }
-  async #loadState() {
-    const [persistDataBuffer] = await this.driver.kvBatchGet(
-      this.#actorId,
-      [KEYS.PERSIST_DATA]
-    );
-    invariant7(
-      persistDataBuffer !== null,
-      "persist data has not been set, it should be set when initialized"
-    );
-    const bareData = ACTOR_VERSIONED.deserializeWithEmbeddedVersion(persistDataBuffer);
-    const persistData = convertActorFromBarePersisted(bareData);
-    if (persistData.hasInitialized) {
-      await this.#restoreExistingActor(persistData);
-    } else {
-      await this.#createNewActor(persistData);
-    }
-    this.#scheduleManager.setPersist(this.stateManager.persist);
-  }
-  async #createNewActor(persistData) {
-    this.#rLog.info({ msg: "actor creating" });
-    await this.stateManager.initializeState(persistData);
-    if (this.#config.onCreate) {
-      await this.#config.onCreate(
-        this.actorContext,
-        persistData.input
-      );
-    }
-  }
-  async #restoreExistingActor(persistData) {
-    const connEntries = await this.driver.kvListPrefix(
-      this.#actorId,
-      KEYS.CONN_PREFIX
-    );
-    const connections = [];
-    for (const [_key, value] of connEntries) {
-      try {
-        const bareData = CONN_VERSIONED.deserializeWithEmbeddedVersion(
-          new Uint8Array(value)
-        );
-        const conn = convertConnFromBarePersistedConn(bareData);
-        connections.push(conn);
-      } catch (error) {
-        this.#rLog.error({
-          msg: "failed to decode connection",
-          error: stringifyError(error)
-        });
-      }
-    }
-    this.#rLog.info({
-      msg: "actor restoring",
-      connections: connections.length
-    });
-    this.stateManager.initPersistProxy(persistData);
-    this.connectionManager.restoreConnections(connections);
-  }
-  async #initializeInspectorToken() {
-    const [tokenBuffer] = await this.driver.kvBatchGet(this.#actorId, [
-      KEYS.INSPECTOR_TOKEN
-    ]);
-    if (tokenBuffer !== null) {
-      const decoder = new TextDecoder();
-      this.#inspectorToken = decoder.decode(tokenBuffer);
-      this.#rLog.debug({ msg: "loaded existing inspector token" });
-    } else {
-      this.#inspectorToken = generateSecureToken();
-      const tokenBytes = new TextEncoder().encode(this.#inspectorToken);
-      await this.driver.kvBatchPut(this.#actorId, [
-        [KEYS.INSPECTOR_TOKEN, tokenBytes]
-      ]);
-      this.#rLog.debug({ msg: "generated new inspector token" });
-    }
-  }
-  async #initializeVars() {
-    let vars;
-    if ("createVars" in this.#config) {
-      const dataOrPromise = this.#config.createVars(
-        this.actorContext,
-        this.driver.getContext(this.#actorId)
-      );
-      if (dataOrPromise instanceof Promise) {
-        vars = await deadline(
-          dataOrPromise,
-          this.#config.options.createVarsTimeout
-        );
-      } else {
-        vars = dataOrPromise;
-      }
-    } else if ("vars" in this.#config) {
-      vars = structuredClone(this.#config.vars);
-    } else {
-      throw new Error(
-        "Could not create variables from 'createVars' or 'vars'"
-      );
-    }
-    this.#vars = vars;
-  }
-  async #callOnStart() {
-    this.#rLog.info({ msg: "actor starting" });
-    if (this.#config.onWake) {
-      const result = this.#config.onWake(this.actorContext);
-      if (result instanceof Promise) {
-        await result;
-      }
-    }
-  }
-  async #callOnSleep() {
-    if (this.#config.onSleep) {
-      try {
-        this.#rLog.debug({ msg: "calling onSleep" });
-        const result = this.#config.onSleep(this.actorContext);
-        if (result instanceof Promise) {
-          await deadline(result, this.#config.options.onSleepTimeout);
-        }
-        this.#rLog.debug({ msg: "onSleep completed" });
-      } catch (error) {
-        if (error instanceof DeadlineError) {
-          this.#rLog.error({ msg: "onSleep timed out" });
-        } else {
-          this.#rLog.error({
-            msg: "error in onSleep",
-            error: stringifyError(error)
-          });
-        }
-      }
-    }
-  }
-  async #callOnDestroy() {
-    if (this.#config.onDestroy) {
-      try {
-        this.#rLog.debug({ msg: "calling onDestroy" });
-        const result = this.#config.onDestroy(this.actorContext);
-        if (result instanceof Promise) {
-          await deadline(
-            result,
-            this.#config.options.onDestroyTimeout
-          );
-        }
-        this.#rLog.debug({ msg: "onDestroy completed" });
-      } catch (error) {
-        if (error instanceof DeadlineError) {
-          this.#rLog.error({ msg: "onDestroy timed out" });
-        } else {
-          this.#rLog.error({
-            msg: "error in onDestroy",
-            error: stringifyError(error)
-          });
-        }
-      }
-    }
-  }
-  async #setupDatabase() {
-    var _a, _b;
-    if ("db" in this.#config && this.#config.db) {
-      const client = await this.#config.db.createClient({
-        getDatabase: () => this.driver.getDatabase(this.#actorId)
-      });
-      this.#rLog.info({ msg: "database migration starting" });
-      await ((_b = (_a = this.#config.db).onMigrate) == null ? void 0 : _b.call(_a, client));
-      this.#rLog.info({ msg: "database migration complete" });
-      this.#db = client;
-    }
-  }
-  async #disconnectConnections() {
-    const promises = [];
-    this.#rLog.debug({
-      msg: "disconnecting connections on actor stop",
-      totalConns: this.connectionManager.connections.size
-    });
-    for (const connection of this.connectionManager.connections.values()) {
-      this.#rLog.debug({
-        msg: "checking connection for disconnect",
-        connId: connection.id,
-        isHibernatable: connection.isHibernatable
-      });
-      if (!connection.isHibernatable) {
-        this.#rLog.debug({
-          msg: "disconnecting non-hibernatable connection on actor stop",
-          connId: connection.id
-        });
-        promises.push(connection.disconnect());
-      } else {
-        this.#rLog.debug({
-          msg: "preserving hibernatable connection on actor stop",
-          connId: connection.id
-        });
-      }
-    }
-    const res = await Promise.race([
-      Promise.all(promises).then(() => false),
-      new Promise(
-        (res2) => globalThis.setTimeout(() => res2(true), 1500)
-      )
-    ]);
-    if (res) {
-      this.#rLog.warn({
-        msg: "timed out waiting for connections to close, shutting down anyway"
-      });
-    }
-  }
-  async #waitBackgroundPromises(timeoutMs) {
-    const pending = this.#backgroundPromises;
-    if (pending.length === 0) {
-      this.#rLog.debug({ msg: "no background promises" });
-      return;
-    }
-    const timedOut = await Promise.race([
-      Promise.allSettled(pending).then(() => false),
-      new Promise(
-        (resolve) => setTimeout(() => resolve(true), timeoutMs)
-      )
-    ]);
-    if (timedOut) {
-      this.#rLog.error({
-        msg: "timed out waiting for background tasks",
-        count: pending.length,
-        timeoutMs
-      });
-    } else {
-      this.#rLog.debug({ msg: "background promises finished" });
-    }
-  }
-  resetSleepTimer() {
-    if (this.#config.options.noSleep || !this.#sleepingSupported) return;
-    if (this.#stopCalled) return;
-    const canSleep = this.#canSleep();
-    this.#rLog.debug({
-      msg: "resetting sleep timer",
-      canSleep: CanSleep[canSleep],
-      existingTimeout: !!this.#sleepTimeout,
-      timeout: this.#config.options.sleepTimeout
-    });
-    if (this.#sleepTimeout) {
-      clearTimeout(this.#sleepTimeout);
-      this.#sleepTimeout = void 0;
-    }
-    if (this.#sleepCalled) return;
-    if (canSleep === 0 /* Yes */) {
-      this.#sleepTimeout = setTimeout(() => {
-        this.startSleep();
-      }, this.#config.options.sleepTimeout);
-    }
-  }
-  #canSleep() {
-    if (!this.#ready) return 1 /* NotReady */;
-    if (!this.#started) return 1 /* NotReady */;
-    if (this.#activeHonoHttpRequests > 0)
-      return 4 /* ActiveHonoHttpRequests */;
-    for (const _conn of this.connectionManager.connections.values()) {
-      return 3 /* ActiveConns */;
-    }
-    return 0 /* Yes */;
-  }
-  get #sleepingSupported() {
-    return this.driver.startSleep !== void 0;
-  }
-  get #varsEnabled() {
-    return "createVars" in this.#config || "vars" in this.#config;
-  }
-  #validateVarsEnabled() {
-    if (!this.#varsEnabled) {
-      throw new VarsNotEnabled();
-    }
-  }
-};
-
-// src/actor/definition.ts
-var ActorDefinition = class {
-  #config;
-  constructor(config) {
-    this.#config = config;
-  }
-  get config() {
-    return this.#config;
-  }
-  instantiate() {
-    return new ActorInstance(this.#config);
-  }
-};
-function lookupInRegistry(config, name) {
-  const definition = config.use[name];
-  if (!definition) throw new Error(`no actor in registry for name ${name}`);
-  return definition;
-}
-
-// src/client/mod.ts
-function createClient(endpointOrConfig) {
-  const configInput = endpointOrConfig === void 0 ? {} : typeof endpointOrConfig === "string" ? { endpoint: endpointOrConfig } : endpointOrConfig;
-  const config = ClientConfigSchema.parse(configInput);
-  const driver = new RemoteManagerDriver(config);
-  if (config.devtools) {
-    injectDevtools(config);
-  }
-  return createClientWithDriver(driver, config);
+  return createClientWithDriver(driver, config);
 }
 
 export {
-  ActorDefinition,
-  lookupInRegistry,
   ActorClientError,
-  InternalError2 as InternalError,
+  InternalError,
   ManagerError,
   MalformedResponseMessage,
   ActorError,
@@ -4759,4 +2654,4 @@ export {
   RemoteManagerDriver,
   createClient
 };
-//# sourceMappingURL=chunk-Q6W7RJJP.js.map
+//# sourceMappingURL=chunk-DIGBC2VI.js.map