rivetkit 2.0.22-rc.2 → 2.0.23

package/dist/tsup/{chunk-AMK3AACS.js → chunk-FTQ62XTN.js}

@@ -3,11 +3,11 @@ import {
   ForeignKeysSchema,
   PatchSchema,
   TablesSchema
-} from "./chunk-C4FPCW7T.js";
+} from "./chunk-DLYZKFRY.js";
 import {
   importWebSocket,
   logger
-} from "./chunk-F7WVJXPB.js";
+} from "./chunk-5UJQWWO3.js";
 import {
   ActionContext,
   HTTP_ACTION_REQUEST_VERSIONED,
@@ -18,7 +18,7 @@ import {
   TO_SERVER_VERSIONED,
   inputDataToBuffer,
   processMessage
-} from "./chunk-BHLQTKOD.js";
+} from "./chunk-RUTBXBRR.js";
 import {
   CachedSerializer,
   DeadlineError,
@@ -43,15 +43,12 @@ import {
   encodingIsBinary,
   generateRandomString,
   generateSecureToken,
+  isConnStatePath,
+  isStatePath,
   jsonStringifyCompat,
   serializeWithEncoding,
   uint8ArrayToBase64
-} from "./chunk-CVLO2OOK.js";
-import {
-  getBaseLogger,
-  getIncludeTarget,
-  getLogger
-} from "./chunk-VMFBKBJL.js";
+} from "./chunk-PHNIVSG5.js";
 import {
   EXTRA_ERROR_LOG,
   SinglePromiseQueue,
@@ -60,13 +57,17 @@ import {
   bufferToArrayBuffer,
   combineUrlPath,
   deconstructError,
+  getBaseLogger,
   getEnvUniversal,
+  getIncludeTarget,
+  getLogger,
   httpUserAgent,
+  idToStr,
   isCborSerializable,
   noopNext,
   promiseWithResolvers,
   stringifyError
-} from "./chunk-7RUROQAZ.js";
+} from "./chunk-5PKKNNNS.js";
 import {
   ActionNotFound,
   ActionTimedOut,
@@ -83,7 +84,7 @@ import {
 } from "./chunk-G64QUEDJ.js";
 
 // src/actor/conn.ts
-import * as cbor from "cbor-x";
+import * as cbor2 from "cbor-x";
 
 // src/actor/conn-drivers.ts
 var WEBSOCKET_DRIVER = {
@@ -139,15 +140,6 @@ var WEBSOCKET_DRIVER = {
   },
   getConnectionReadyState: (_actor, _conn, state) => {
     return state.websocket.readyState;
-  },
-  isHibernatable(_actor, _conn, state) {
-    if (state.websocket.raw) {
-      const raw = state.websocket.raw;
-      if (typeof raw.isHibernatable === "boolean") {
-        return raw.isHibernatable;
-      }
-    }
-    return false;
   }
 };
 var SSE_DRIVER = {
@@ -164,9 +156,6 @@ var SSE_DRIVER = {
       return 3 /* CLOSED */;
     }
     return 1 /* OPEN */;
-  },
-  isHibernatable() {
-    return false;
   }
 };
 var HTTP_DRIVER = {
@@ -174,9 +163,6 @@ var HTTP_DRIVER = {
     return 1 /* OPEN */;
   },
   disconnect: async () => {
-  },
-  isHibernatable() {
-    return false;
   }
 };
 var CONN_DRIVERS = {
@@ -191,221 +177,8 @@ function getConnDriverKindFromState(state) {
   else assertUnreachable(state);
 }
 
-// src/actor/conn.ts
-function generateConnId() {
-  return crypto.randomUUID();
-}
-function generateConnToken() {
-  return generateSecureToken(32);
-}
-function generateConnRequestId() {
-  return crypto.randomUUID();
-}
-var Conn = class {
-  subscriptions = /* @__PURE__ */ new Set();
-  // TODO: Remove this cyclical reference
-  #actor;
-  /**
-   * The proxied state that notifies of changes automatically.
-   *
-   * Any data that should be stored indefinitely should be held within this object.
-   */
-  __persist;
-  get __driverState() {
-    var _a;
-    return (_a = this.__socket) == null ? void 0 : _a.driverState;
-  }
-  /**
-   * Socket connected to this connection.
-   *
-   * If undefined, then nothing is connected to this.
-   */
-  __socket;
-  get __status() {
-    if (this.__socket) {
-      return "connected";
-    } else {
-      return "reconnecting";
-    }
-  }
-  get params() {
-    return this.__persist.params;
-  }
-  get __stateEnabled() {
-    return this.#actor.connStateEnabled;
-  }
-  /**
-   * Gets the current state of the connection.
-   *
-   * Throws an error if the state is not enabled.
-   */
-  get state() {
-    this.#validateStateEnabled();
-    if (!this.__persist.state) throw new Error("state should exists");
-    return this.__persist.state;
-  }
-  /**
-   * Sets the state of the connection.
-   *
-   * Throws an error if the state is not enabled.
-   */
-  set state(value) {
-    this.#validateStateEnabled();
-    this.__persist.state = value;
-  }
-  /**
-   * Unique identifier for the connection.
-   */
-  get id() {
-    return this.__persist.connId;
-  }
-  /**
-   * Token used to authenticate this request.
-   */
-  get _token() {
-    return this.__persist.token;
-  }
-  /**
-   * Status of the connection.
-   */
-  get status() {
-    return this.__status;
-  }
-  /**
-   * @experimental
-   *
-   * If the underlying connection can hibernate.
-   */
-  get isHibernatable() {
-    if (this.__driverState) {
-      const driverKind = getConnDriverKindFromState(this.__driverState);
-      const driver = CONN_DRIVERS[driverKind];
-      return driver.isHibernatable(
-        this.#actor,
-        this,
-        this.__driverState[driverKind]
-      );
-    } else {
-      return false;
-    }
-  }
-  /**
-   * Timestamp of the last time the connection was seen, i.e. the last time the connection was active and checked for liveness.
-   */
-  get lastSeen() {
-    return this.__persist.lastSeen;
-  }
-  /**
-   * Initializes a new instance of the Connection class.
-   *
-   * This should only be constructed by {@link Actor}.
-   *
-   * @protected
-   */
-  constructor(actor, persist) {
-    this.#actor = actor;
-    this.__persist = persist;
-  }
-  #validateStateEnabled() {
-    if (!this.__stateEnabled) {
-      throw new ConnStateNotEnabled();
-    }
-  }
-  /**
-   * Sends a WebSocket message to the client.
-   *
-   * @param message - The message to send.
-   *
-   * @protected
-   */
-  _sendMessage(message) {
-    if (this.__driverState) {
-      const driverKind = getConnDriverKindFromState(this.__driverState);
-      const driver = CONN_DRIVERS[driverKind];
-      if (driver.sendMessage) {
-        driver.sendMessage(
-          this.#actor,
-          this,
-          this.__driverState[driverKind],
-          message
-        );
-      } else {
-        this.#actor.rLog.debug({
-          msg: "conn driver does not support sending messages",
-          conn: this.id
-        });
-      }
-    } else {
-      this.#actor.rLog.warn({
-        msg: "missing connection driver state for send message",
-        conn: this.id
-      });
-    }
-  }
-  /**
-   * Sends an event with arguments to the client.
-   *
-   * @param eventName - The name of the event.
-   * @param args - The arguments for the event.
-   * @see {@link https://rivet.dev/docs/events|Events Documentation}
-   */
-  send(eventName, ...args) {
-    this.#actor.inspector.emitter.emit("eventFired", {
-      type: "event",
-      eventName,
-      args,
-      connId: this.id
-    });
-    this._sendMessage(
-      new CachedSerializer(
-        {
-          body: {
-            tag: "Event",
-            val: {
-              name: eventName,
-              args: bufferToArrayBuffer(cbor.encode(args))
-            }
-          }
-        },
-        TO_CLIENT_VERSIONED
-      )
-    );
-  }
-  /**
-   * Disconnects the client with an optional reason.
-   *
-   * @param reason - The reason for disconnection.
-   */
-  async disconnect(reason) {
-    if (this.__socket && this.__driverState) {
-      const driverKind = getConnDriverKindFromState(this.__driverState);
-      const driver = CONN_DRIVERS[driverKind];
-      if (driver.disconnect) {
-        driver.disconnect(
-          this.#actor,
-          this,
-          this.__driverState[driverKind],
-          reason
-        );
-      } else {
-        this.#actor.rLog.debug({
-          msg: "no disconnect handler for conn driver",
-          conn: this.id
-        });
-      }
-      this.#actor.__connDisconnected(this, true, this.__socket.requestId);
-    } else {
-      this.#actor.rLog.warn({
-        msg: "missing connection driver state for disconnect",
-        conn: this.id
-      });
-    }
-    this.__socket = void 0;
-  }
-};
-
 // src/actor/instance.ts
-import * as cbor2 from "cbor-x";
+import * as cbor from "cbor-x";
 import invariant from "invariant";
 import onChange from "on-change";
 
@@ -930,21 +703,18 @@ var ActorInstance = class {
       },
       getConnections: async () => {
         return Array.from(this.#connections.entries()).map(
-          ([id, conn]) => {
-            var _a;
-            return {
-              id,
-              params: conn.params,
-              state: conn.__stateEnabled ? conn.state : void 0,
-              status: conn.status,
-              subscriptions: conn.subscriptions.size,
-              lastSeen: conn.lastSeen,
-              stateEnabled: conn.__stateEnabled,
-              isHibernatable: conn.isHibernatable,
-              requestId: (_a = conn.__socket) == null ? void 0 : _a.requestId,
-              driver: conn.__driverState ? getConnDriverKindFromState(conn.__driverState) : void 0
-            };
-          }
+          ([id, conn]) => ({
+            id,
+            params: conn.params,
+            state: conn.__stateEnabled ? conn.state : void 0,
+            status: conn.status,
+            subscriptions: conn.subscriptions.size,
+            lastSeen: conn.lastSeen,
+            stateEnabled: conn.__stateEnabled,
+            isHibernatable: conn.isHibernatable,
+            hibernatableRequestId: conn.__persist.hibernatableRequestId ? idToStr(conn.__persist.hibernatableRequestId) : void 0,
+            driver: conn.__driverState ? getConnDriverKindFromState(conn.__driverState) : void 0
+          })
         );
       },
       setState: async (state) => {
@@ -957,6 +727,7 @@ var ActorInstance = class {
         const conn = await this.createConn(
           {
             requestId,
+            hibernatable: false,
             driverState: { [2 /* HTTP */]: {} }
           },
           void 0,
@@ -1167,7 +938,7 @@ var ActorInstance = class {
             `Alarm function lookup for ${event.kind.generic.actionName} returned ${typeof fn}`
           );
         try {
-          const args = event.kind.generic.args ? cbor2.decode(new Uint8Array(event.kind.generic.args)) : [];
+          const args = event.kind.generic.args ? cbor.decode(new Uint8Array(event.kind.generic.args)) : [];
           await fn.call(void 0, this.actorContext, ...args);
         } catch (error) {
           this.actorContext.log.error({
@@ -1194,7 +965,7 @@ var ActorInstance = class {
       kind: {
         generic: {
           actionName: action,
-          args: bufferToArrayBuffer(cbor2.encode(args))
+          args: bufferToArrayBuffer(cbor.encode(args))
         }
       }
     });
@@ -1260,6 +1031,10 @@ var ActorInstance = class {
       }
       (_a = this.#onPersistSavedPromise) == null ? void 0 : _a.resolve();
     } catch (error) {
+      this.#rLog.error({
+        msg: "error saving persist",
+        error: stringifyError(error)
+      });
       (_b = this.#onPersistSavedPromise) == null ? void 0 : _b.reject(error);
       throw error;
     }
@@ -1294,27 +1069,34 @@ var ActorInstance = class {
       target,
       // biome-ignore lint/suspicious/noExplicitAny: Don't know types in proxy
       (path, value, _previousValue, _applyData) => {
-        if (path !== "state" && !path.startsWith("state.")) {
-          return;
-        }
-        let invalidPath = "";
-        if (!isCborSerializable(
-          value,
-          (invalidPathPart) => {
-            invalidPath = invalidPathPart;
-          },
-          ""
-        )) {
-          throw new InvalidStateType({
-            path: path + (invalidPath ? `.${invalidPath}` : "")
-          });
+        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.#rLog.debug({
+          msg: "onChange triggered, setting persistChanged=true",
+          path
+        });
         this.#persistChanged = true;
-        this.inspector.emitter.emit(
-          "stateUpdated",
-          this.#persist.state
-        );
-        if (this.#config.onStateChange && this.#ready && !this.#isInOnStateChange) {
+        if (actorStatePath) {
+          this.inspector.emitter.emit(
+            "stateUpdated",
+            this.#persist.state
+          );
+        }
+        if (actorStatePath && this.#config.onStateChange && this.#ready && !this.#isInOnStateChange) {
           try {
             this.#isInOnStateChange = true;
             this.#config.onStateChange(
@@ -1349,7 +1131,8 @@ var ActorInstance = class {
     if (persistData.hasInitiated) {
       this.#rLog.info({
         msg: "actor restoring",
-        connections: persistData.connections.length
+        connections: persistData.connections.length,
+        hibernatableWebSockets: persistData.hibernatableWebSocket.length
       });
       this.#setPersist(persistData);
       for (const connPersist of this.#persist.connections) {
@@ -1480,6 +1263,55 @@ var ActorInstance = class {
    */
   async createConn(socket, params, request, connectionId, connectionToken) {
     this.#assertReady();
+    if (socket.requestIdBuf && socket.hibernatable) {
+      this.rLog.debug({
+        msg: "checking for hibernatable websocket connection",
+        requestId: socket.requestId,
+        existingConnectionsCount: this.#connections.size
+      });
+      const existingConn = Array.from(this.#connections.values()).find(
+        (conn2) => conn2.__persist.hibernatableRequestId && arrayBuffersEqual(
+          conn2.__persist.hibernatableRequestId,
+          socket.requestIdBuf
+        )
+      );
+      if (existingConn) {
+        this.rLog.debug({
+          msg: "reconnecting hibernatable websocket connection",
+          connectionId: existingConn.id,
+          requestId: socket.requestId
+        });
+        if (existingConn.__driverState) {
+          this.#rLog.warn({
+            msg: "found existing driver state on hibernatable websocket",
+            connectionId: existingConn.id,
+            requestId: socket.requestId
+          });
+          const driverKind = getConnDriverKindFromState(
+            existingConn.__driverState
+          );
+          const driver = CONN_DRIVERS[driverKind];
+          if (driver.disconnect) {
+            driver.disconnect(
+              this,
+              existingConn,
+              existingConn.__driverState[driverKind],
+              "Reconnecting hibernatable websocket with new driver state"
+            );
+          }
+        }
+        existingConn.__socket = socket;
+        existingConn.__persist.lastSeen = Date.now();
+        this.#resetSleepTimer();
+        this.inspector.emitter.emit("connectionUpdated");
+        return existingConn;
+      } else {
+        this.rLog.debug({
+          msg: "no existing hibernatable connection found, creating new connection",
+          requestId: socket.requestId
+        });
+      }
+    }
     if (connectionId && connectionToken) {
       this.rLog.debug({
         msg: "checking for existing connection",
@@ -1525,11 +1357,12 @@ var ActorInstance = class {
           )
         );
         return existingConn;
+      } else {
+        this.rLog.debug({
+          msg: "connection not found or token mismatch, creating new connection",
+          connectionId
+        });
       }
-      this.rLog.debug({
-        msg: "connection not found or token mismatch, creating new connection",
-        connectionId
-      });
     }
     const newConnId = generateConnId();
     const newConnToken = generateConnToken();
@@ -1578,6 +1411,14 @@ var ActorInstance = class {
       lastSeen: Date.now(),
       subscriptions: []
     };
+    if (socket.requestIdBuf) {
+      const isHibernatable = this.#persist.hibernatableWebSocket.findIndex(
+        (ws) => arrayBuffersEqual(ws.requestId, socket.requestIdBuf)
+      ) !== -1;
+      if (isHibernatable) {
+        persist.hibernatableRequestId = socket.requestIdBuf;
+      }
+    }
     const conn = new Conn(this, persist);
     conn.__socket = socket;
     this.#connections.set(conn.id, conn);
@@ -2117,7 +1958,7 @@ var ActorInstance = class {
           tag: "Event",
           val: {
             name,
-            args: bufferToArrayBuffer(cbor2.encode(args))
+            args: bufferToArrayBuffer(cbor.encode(args))
           }
         }
       },
@@ -2157,6 +1998,12 @@ var ActorInstance = class {
    */
   async saveState(opts) {
     this.#assertReady(opts.allowStoppingState);
+    this.#rLog.debug({
+      msg: "saveState called",
+      persistChanged: this.#persistChanged,
+      allowStoppingState: opts.allowStoppingState,
+      immediate: opts.immediate
+    });
     if (this.#persistChanged) {
       if (opts.immediate) {
         await this.#savePersistInner();
@@ -2203,6 +2050,7 @@ var ActorInstance = class {
    **/
   #resetSleepTimer() {
     if (this.#config.options.noSleep || !this.#sleepingSupported) return;
+    if (this.#stopCalled) return;
     const canSleep = this.#canSleep();
     this.#rLog.debug({
       msg: "resetting sleep timer",
@@ -2244,8 +2092,16 @@ var ActorInstance = class {
    **/
   _startSleep() {
     var _a;
+    if (this.#stopCalled) {
+      this.#rLog.debug({
+        msg: "cannot call _startSleep if actor already stopping"
+      });
+      return;
+    }
     if (this.#sleepCalled) {
-      this.#rLog.warn({ msg: "already sleeping actor" });
+      this.#rLog.warn({
+        msg: "cannot call _startSleep twice, actor already sleeping"
+      });
       return;
     }
     this.#sleepCalled = true;
@@ -2303,13 +2159,18 @@ var ActorInstance = class {
     }
     const promises = [];
     for (const connection of this.#connections.values()) {
-      promises.push(connection.disconnect());
+      if (!connection.isHibernatable) {
+        this.#rLog.debug({
+          msg: "disconnecting non-hibernatable connection on actor stop",
+          connId: connection.id
+        });
+        promises.push(connection.disconnect());
+      }
     }
     await this.#waitBackgroundPromises(
       this.#config.options.waitUntilTimeout
     );
     if (this.#pendingSaveTimeout) clearTimeout(this.#pendingSaveTimeout);
-    if (this.#sleepTimeout) clearTimeout(this.#sleepTimeout);
     if (this.#checkConnLivenessInterval)
       clearInterval(this.#checkConnLivenessInterval);
     await this.saveState({ immediate: true, allowStoppingState: true });
@@ -2359,18 +2220,19 @@ var ActorInstance = class {
   // MARK: BARE Conversion Helpers
   #convertToBarePersisted(persist) {
     return {
-      input: persist.input !== void 0 ? bufferToArrayBuffer(cbor2.encode(persist.input)) : null,
+      input: persist.input !== void 0 ? bufferToArrayBuffer(cbor.encode(persist.input)) : null,
       hasInitialized: persist.hasInitiated,
-      state: bufferToArrayBuffer(cbor2.encode(persist.state)),
+      state: bufferToArrayBuffer(cbor.encode(persist.state)),
       connections: persist.connections.map((conn) => ({
         id: conn.connId,
         token: conn.token,
-        parameters: bufferToArrayBuffer(cbor2.encode(conn.params || {})),
-        state: bufferToArrayBuffer(cbor2.encode(conn.state || {})),
+        parameters: bufferToArrayBuffer(cbor.encode(conn.params || {})),
+        state: bufferToArrayBuffer(cbor.encode(conn.state || {})),
         subscriptions: conn.subscriptions.map((sub) => ({
           eventName: sub.eventName
         })),
-        lastSeen: BigInt(conn.lastSeen)
+        lastSeen: BigInt(conn.lastSeen),
+        hibernatableRequestId: conn.hibernatableRequestId ?? null
       })),
       scheduledEvents: persist.scheduledEvents.map((event) => ({
         eventId: event.eventId,
@@ -2392,18 +2254,19 @@ var ActorInstance = class {
   }
   #convertFromBarePersisted(bareData) {
     return {
-      input: bareData.input ? cbor2.decode(new Uint8Array(bareData.input)) : void 0,
+      input: bareData.input ? cbor.decode(new Uint8Array(bareData.input)) : void 0,
       hasInitiated: bareData.hasInitialized,
-      state: cbor2.decode(new Uint8Array(bareData.state)),
+      state: cbor.decode(new Uint8Array(bareData.state)),
       connections: bareData.connections.map((conn) => ({
         connId: conn.id,
         token: conn.token,
-        params: cbor2.decode(new Uint8Array(conn.parameters)),
-        state: cbor2.decode(new Uint8Array(conn.state)),
+        params: cbor.decode(new Uint8Array(conn.parameters)),
+        state: cbor.decode(new Uint8Array(conn.state)),
         subscriptions: conn.subscriptions.map((sub) => ({
           eventName: sub.eventName
         })),
-        lastSeen: Number(conn.lastSeen)
+        lastSeen: Number(conn.lastSeen),
+        hibernatableRequestId: conn.hibernatableRequestId ?? void 0
       })),
       scheduledEvents: bareData.scheduledEvents.map((event) => ({
         eventId: event.eventId,
@@ -2424,6 +2287,217 @@ var ActorInstance = class {
   }
 };
 
+// src/actor/conn.ts
+function generateConnId() {
+  return crypto.randomUUID();
+}
+function generateConnToken() {
+  return generateSecureToken(32);
+}
+function generateConnRequestId() {
+  return crypto.randomUUID();
+}
+var Conn = class {
+  subscriptions = /* @__PURE__ */ new Set();
+  // TODO: Remove this cyclical reference
+  #actor;
+  /**
+   * The proxied state that notifies of changes automatically.
+   *
+   * Any data that should be stored indefinitely should be held within this object.
+   */
+  __persist;
+  get __driverState() {
+    var _a;
+    return (_a = this.__socket) == null ? void 0 : _a.driverState;
+  }
+  /**
+   * Socket connected to this connection.
+   *
+   * If undefined, then nothing is connected to this.
+   */
+  __socket;
+  get __status() {
+    if (this.__socket || this.isHibernatable) {
+      return "connected";
+    } else {
+      return "reconnecting";
+    }
+  }
+  get params() {
+    return this.__persist.params;
+  }
+  get __stateEnabled() {
+    return this.#actor.connStateEnabled;
+  }
+  /**
+   * Gets the current state of the connection.
+   *
+   * Throws an error if the state is not enabled.
+   */
+  get state() {
+    this.#validateStateEnabled();
+    if (!this.__persist.state) throw new Error("state should exists");
+    return this.__persist.state;
+  }
+  /**
+   * Sets the state of the connection.
+   *
+   * Throws an error if the state is not enabled.
+   */
+  set state(value) {
+    this.#validateStateEnabled();
+    this.__persist.state = value;
+  }
+  /**
+   * Unique identifier for the connection.
+   */
+  get id() {
+    return this.__persist.connId;
+  }
+  /**
+   * Token used to authenticate this request.
+   */
+  get _token() {
+    return this.__persist.token;
+  }
+  /**
+   * Status of the connection.
+   */
+  get status() {
+    return this.__status;
+  }
+  /**
+   * @experimental
+   *
+   * If the underlying connection can hibernate.
+   */
+  get isHibernatable() {
+    if (!this.__persist.hibernatableRequestId) {
+      return false;
+    }
+    return this.#actor[PERSIST_SYMBOL].hibernatableWebSocket.findIndex(
+      (x) => arrayBuffersEqual(
+        x.requestId,
+        this.__persist.hibernatableRequestId
+      )
+    ) > -1;
+  }
+  /**
+   * Timestamp of the last time the connection was seen, i.e. the last time the connection was active and checked for liveness.
+   */
+  get lastSeen() {
+    return this.__persist.lastSeen;
+  }
+  /**
+   * Initializes a new instance of the Connection class.
+   *
+   * This should only be constructed by {@link Actor}.
+   *
+   * @protected
+   */
+  constructor(actor, persist) {
+    this.#actor = actor;
+    this.__persist = persist;
+  }
+  #validateStateEnabled() {
+    if (!this.__stateEnabled) {
+      throw new ConnStateNotEnabled();
+    }
+  }
+  /**
+   * Sends a WebSocket message to the client.
+   *
+   * @param message - The message to send.
+   *
+   * @protected
+   */
+  _sendMessage(message) {
+    if (this.__driverState) {
+      const driverKind = getConnDriverKindFromState(this.__driverState);
+      const driver = CONN_DRIVERS[driverKind];
+      if (driver.sendMessage) {
+        driver.sendMessage(
+          this.#actor,
+          this,
+          this.__driverState[driverKind],
+          message
+        );
+      } else {
+        this.#actor.rLog.debug({
+          msg: "conn driver does not support sending messages",
+          conn: this.id
+        });
+      }
+    } else {
+      this.#actor.rLog.warn({
+        msg: "missing connection driver state for send message",
+        conn: this.id
+      });
+    }
+  }
+  /**
+   * Sends an event with arguments to the client.
+   *
+   * @param eventName - The name of the event.
+   * @param args - The arguments for the event.
+   * @see {@link https://rivet.dev/docs/events|Events Documentation}
+   */
+  send(eventName, ...args) {
+    this.#actor.inspector.emitter.emit("eventFired", {
+      type: "event",
+      eventName,
+      args,
+      connId: this.id
+    });
+    this._sendMessage(
+      new CachedSerializer(
+        {
+          body: {
+            tag: "Event",
+            val: {
+              name: eventName,
+              args: bufferToArrayBuffer(cbor2.encode(args))
+            }
+          }
+        },
+        TO_CLIENT_VERSIONED
+      )
+    );
+  }
+  /**
+   * Disconnects the client with an optional reason.
+   *
+   * @param reason - The reason for disconnection.
+   */
+  async disconnect(reason) {
+    if (this.__socket && this.__driverState) {
+      const driverKind = getConnDriverKindFromState(this.__driverState);
+      const driver = CONN_DRIVERS[driverKind];
+      if (driver.disconnect) {
+        driver.disconnect(
+          this.#actor,
+          this,
+          this.__driverState[driverKind],
+          reason
+        );
+      } else {
+        this.#actor.rLog.debug({
+          msg: "no disconnect handler for conn driver",
+          conn: this.id
+        });
+      }
+      this.#actor.__connDisconnected(this, true, this.__socket.requestId);
+    } else {
+      this.#actor.rLog.warn({
+        msg: "missing connection driver state for disconnect",
+        conn: this.id
+      });
+    }
+    this.__socket = void 0;
+  }
+};
+
 // src/actor/definition.ts
 var ActorDefinition = class {
   #config;
@@ -4524,13 +4598,13 @@ var RemoteManagerDriver = class {
 };
 
 export {
-  generateConnId,
-  generateConnToken,
-  generateConnRequestId,
   createActorInspectorRouter,
   serializeActorKey,
   deserializeActorKey,
   PERSIST_SYMBOL,
+  generateConnId,
+  generateConnToken,
+  generateConnRequestId,
   ActorDefinition,
   lookupInRegistry,
   ActorClientError,
@@ -4546,4 +4620,4 @@ export {
   updateRunnerConfig,
   RemoteManagerDriver
 };
-//# sourceMappingURL=chunk-AMK3AACS.js.map
+//# sourceMappingURL=chunk-FTQ62XTN.js.map