rivetkit 2.0.22-rc.1 → 2.0.22

package/dist/tsup/{chunk-FETQGZN4.js → chunk-3BJJSSTM.js}

@@ -3,11 +3,11 @@ import {
   ForeignKeysSchema,
   PatchSchema,
   TablesSchema
-} from "./chunk-RPI45FGS.js";
+} from "./chunk-TQ4OAC2G.js";
 import {
   importWebSocket,
   logger
-} from "./chunk-UBCUW7HD.js";
+} from "./chunk-D7AA2DK5.js";
 import {
   ActionContext,
   HTTP_ACTION_REQUEST_VERSIONED,
@@ -18,7 +18,7 @@ import {
   TO_SERVER_VERSIONED,
   inputDataToBuffer,
   processMessage
-} from "./chunk-I7EJWHYV.js";
+} from "./chunk-EBSGEDD3.js";
 import {
   CachedSerializer,
   DeadlineError,
@@ -26,18 +26,14 @@ import {
   HEADER_CONN_PARAMS,
   HEADER_CONN_TOKEN,
   HEADER_ENCODING,
-  HEADER_RIVET_ACTOR,
-  HEADER_RIVET_TARGET,
   HEADER_RIVET_TOKEN,
   PATH_CONNECT_WEBSOCKET,
   PATH_RAW_WEBSOCKET_PREFIX,
-  WS_PROTOCOL_ACTOR,
   WS_PROTOCOL_CONN_ID,
   WS_PROTOCOL_CONN_PARAMS,
   WS_PROTOCOL_CONN_TOKEN,
   WS_PROTOCOL_ENCODING,
   WS_PROTOCOL_STANDARD,
-  WS_PROTOCOL_TARGET,
   WS_PROTOCOL_TOKEN,
   assertUnreachable as assertUnreachable2,
   contentTypeForEncoding,
@@ -50,14 +46,16 @@ import {
   jsonStringifyCompat,
   serializeWithEncoding,
   uint8ArrayToBase64
-} from "./chunk-ZVEDMBFT.js";
+} from "./chunk-PBFLG45S.js";
 import {
   getBaseLogger,
   getIncludeTarget,
   getLogger
-} from "./chunk-GJPOIJHZ.js";
+} from "./chunk-ST6FGRCH.js";
 import {
+  EXTRA_ERROR_LOG,
   SinglePromiseQueue,
+  arrayBuffersEqual,
   assertUnreachable,
   bufferToArrayBuffer,
   combineUrlPath,
@@ -68,7 +66,7 @@ import {
   noopNext,
   promiseWithResolvers,
   stringifyError
-} from "./chunk-JKNDUKFI.js";
+} from "./chunk-WWAZJHTS.js";
 import {
   ActionNotFound,
   ActionTimedOut,
@@ -89,7 +87,15 @@ import * as cbor from "cbor-x";
 
 // src/actor/conn-drivers.ts
 var WEBSOCKET_DRIVER = {
-  sendMessage: (actor, _conn, state, message) => {
+  sendMessage: (actor, conn, state, message) => {
+    if (state.websocket.readyState !== 1 /* OPEN */) {
+      actor.rLog.warn({
+        msg: "attempting to send message to closed websocket, this is likely a bug in RivetKit",
+        connId: conn.id,
+        wsReadyState: state.websocket.readyState
+      });
+      return;
+    }
     const serialized = message.serialize(state.encoding);
     actor.rLog.debug({
       msg: "sending websocket message",
@@ -133,6 +139,15 @@ 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 = {
@@ -149,6 +164,9 @@ var SSE_DRIVER = {
       return 3 /* CLOSED */;
     }
     return 1 /* OPEN */;
+  },
+  isHibernatable() {
+    return false;
   }
 };
 var HTTP_DRIVER = {
@@ -156,6 +174,9 @@ var HTTP_DRIVER = {
     return 1 /* OPEN */;
   },
   disconnect: async () => {
+  },
+  isHibernatable() {
+    return false;
   }
 };
 var CONN_DRIVERS = {
@@ -177,7 +198,7 @@ function generateConnId() {
 function generateConnToken() {
   return generateSecureToken(32);
 }
-function generateConnSocketId() {
+function generateConnRequestId() {
   return crypto.randomUUID();
 }
 var Conn = class {
@@ -250,6 +271,24 @@ var Conn = class {
   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.
    */
@@ -354,7 +393,7 @@ var Conn = class {
           conn: this.id
         });
       }
-      this.#actor.__connDisconnected(this, true, this.__socket.socketId);
+      this.#actor.__connDisconnected(this, true, this.__socket.requestId);
     } else {
       this.#actor.rLog.warn({
         msg: "missing connection driver state for disconnect",
@@ -733,7 +772,7 @@ var ActorContext = class {
    * @experimental
    */
   sleep() {
-    this.#actor._sleep();
+    this.#actor._startSleep();
   }
 };
 
@@ -810,6 +849,15 @@ var Schedule = class {
 };
 
 // src/actor/instance.ts
+var PERSIST_SYMBOL = Symbol("persist");
+var CanSleep = /* @__PURE__ */ ((CanSleep2) => {
+  CanSleep2[CanSleep2["Yes"] = 0] = "Yes";
+  CanSleep2[CanSleep2["NotReady"] = 1] = "NotReady";
+  CanSleep2[CanSleep2["ActiveConns"] = 2] = "ActiveConns";
+  CanSleep2[CanSleep2["ActiveHonoHttpRequests"] = 3] = "ActiveHonoHttpRequests";
+  CanSleep2[CanSleep2["ActiveRawWebSockets"] = 4] = "ActiveRawWebSockets";
+  return CanSleep2;
+})(CanSleep || {});
 var ActorInstance = class {
   // Shared actor context for this instance
   actorContext;
@@ -820,7 +868,7 @@ var ActorInstance = class {
   #sleepCalled = false;
   #stopCalled = false;
   get isStopping() {
-    return this.#stopCalled || this.#sleepCalled;
+    return this.#stopCalled;
   }
   #persistChanged = false;
   #isInOnStateChange = false;
@@ -830,6 +878,9 @@ var ActorInstance = class {
    * Any data that should be stored indefinitely should be held within this object.
    */
   #persist;
+  get [PERSIST_SYMBOL]() {
+    return this.#persist;
+  }
   /** Raw state without the proxy wrapper */
   #persistRaw;
   #persistWriteQueue = new SinglePromiseQueue();
@@ -851,8 +902,11 @@ var ActorInstance = class {
   #subscriptionIndex = /* @__PURE__ */ new Map();
   #checkConnLivenessInterval;
   #sleepTimeout;
-  // Track active raw requests so sleep logic can account for them
-  #activeRawFetchCount = 0;
+  /**
+   * Track active HTTP requests through Hono router so sleep logic can
+   * account for them. Does not include WebSockets.
+   **/
+  #activeHonoHttpRequests = 0;
   #activeRawWebSockets = /* @__PURE__ */ new Set();
   #schedule;
   #db;
@@ -876,12 +930,21 @@ var ActorInstance = class {
       },
       getConnections: async () => {
         return Array.from(this.#connections.entries()).map(
-          ([id, conn]) => ({
-            id,
-            stateEnabled: conn.__stateEnabled,
-            params: conn.params,
-            state: conn.__stateEnabled ? conn.state : void 0
-          })
+          ([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
+            };
+          }
         );
       },
       setState: async (state) => {
@@ -890,10 +953,10 @@ var ActorInstance = class {
         await this.saveState({ immediate: true });
       },
       executeAction: async (name, params) => {
-        const socketId = generateConnSocketId();
+        const requestId = generateConnRequestId();
         const conn = await this.createConn(
           {
-            socketId,
+            requestId,
             driverState: { [2 /* HTTP */]: {} }
           },
           void 0,
@@ -906,7 +969,7 @@ var ActorInstance = class {
             params || []
           );
         } finally {
-          this.__connDisconnected(conn, true, socketId);
+          this.__connDisconnected(conn, true, requestId);
         }
       }
     };
@@ -921,7 +984,7 @@ var ActorInstance = class {
     return this.#inspector;
   }
   get #sleepingSupported() {
-    return this.#actorDriver.sleep !== void 0;
+    return this.#actorDriver.startSleep !== void 0;
   }
   /**
    * This constructor should never be used directly.
@@ -935,12 +998,14 @@ var ActorInstance = class {
     this.actorContext = new ActorContext(this);
   }
   async start(actorDriver, inlineClient, actorId, name, key, region) {
-    var _a, _b;
+    var _a, _b, _c;
     const logParams = {
       actor: name,
       key: serializeActorKey(key),
       actorId
     };
+    const extraLogParams = (_a = actorDriver.getExtraActorLogParams) == null ? void 0 : _a.call(actorDriver);
+    if (extraLogParams) Object.assign(logParams, extraLogParams);
     this.#log = getBaseLogger().child(
       Object.assign(
         getIncludeTarget() ? { target: "actor" } : {},
@@ -997,7 +1062,7 @@ var ActorInstance = class {
         getDatabase: () => actorDriver.getDatabase(this.#actorId)
       });
       this.#rLog.info({ msg: "database migration starting" });
-      await ((_b = (_a = this.#config.db).onMigrate) == null ? void 0 : _b.call(_a, client));
+      await ((_c = (_b = this.#config.db).onMigrate) == null ? void 0 : _c.call(_b, client));
       this.#rLog.info({ msg: "database migration complete" });
       this.#db = client;
     }
@@ -1344,13 +1409,13 @@ var ActorInstance = class {
    *
    * If not a clean disconnect, will keep the connection alive for a given interval to wait for reconnect.
    */
-  __connDisconnected(conn, wasClean, socketId) {
-    if (socketId && conn.__socket && socketId !== conn.__socket.socketId) {
+  __connDisconnected(conn, wasClean, requestId) {
+    if (requestId && conn.__socket && requestId !== conn.__socket.requestId) {
       this.#rLog.debug({
         msg: "ignoring stale disconnect event",
         connId: conn.id,
-        eventSocketId: socketId,
-        currentSocketId: conn.__socket.socketId
+        eventRequestId: requestId,
+        currentRequestId: conn.__socket.requestId
       });
       return;
     }
@@ -1644,8 +1709,6 @@ var ActorInstance = class {
   }
   #assertReady(allowStoppingState = false) {
     if (!this.#ready) throw new InternalError("Actor not ready");
-    if (!allowStoppingState && this.#sleepCalled)
-      throw new InternalError("Actor is going to sleep");
     if (!allowStoppingState && this.#stopCalled)
       throw new InternalError("Actor is stopping");
   }
@@ -1655,13 +1718,18 @@ var ActorInstance = class {
    */
   #checkConnectionsLiveness() {
     this.#rLog.debug({ msg: "checking connections liveness" });
+    let connected = 0;
+    let reconnecting = 0;
+    let removed = 0;
     for (const conn of this.#connections.values()) {
       if (conn.__status === "connected") {
+        connected += 1;
         this.#rLog.debug({
           msg: "connection is alive",
           connId: conn.id
         });
       } else {
+        reconnecting += 1;
         const lastSeen = conn.__persist.lastSeen;
         const sinceLastSeen = Date.now() - lastSeen;
         if (sinceLastSeen < this.#config.options.connectionLivenessTimeout) {
@@ -1678,9 +1746,17 @@ var ActorInstance = class {
           connId: conn.id,
           lastSeen
         });
+        removed += 1;
         this.#removeConn(conn);
       }
     }
+    this.#rLog.debug({
+      msg: "checked connection liveness",
+      total: connected + reconnecting,
+      connected,
+      reconnecting,
+      removed
+    });
   }
   /**
    * Check if the actor is ready to handle requests.
@@ -1812,8 +1888,6 @@ var ActorInstance = class {
     if (!this.#config.onFetch) {
       throw new FetchHandlerNotDefined();
     }
-    this.#activeRawFetchCount++;
-    this.#resetSleepTimer();
     try {
       const response = await this.#config.onFetch(
         this.actorContext,
@@ -1831,11 +1905,6 @@ var ActorInstance = class {
       });
       throw error;
     } finally {
-      this.#activeRawFetchCount = Math.max(
-        0,
-        this.#activeRawFetchCount - 1
-      );
-      this.#resetSleepTimer();
       this.#savePersistThrottled();
     }
   }
@@ -1851,8 +1920,81 @@ var ActorInstance = class {
       const stateBeforeHandler = this.#persistChanged;
       this.#activeRawWebSockets.add(websocket);
       this.#resetSleepTimer();
-      const onSocketClosed = () => {
+      let rivetRequestId;
+      let persistedHibernatableWebSocket;
+      const onSocketOpened = (event) => {
+        rivetRequestId = event == null ? void 0 : event.rivetRequestId;
+        if (rivetRequestId) {
+          const rivetRequestIdLocal = rivetRequestId;
+          persistedHibernatableWebSocket = this.#persist.hibernatableWebSocket.find(
+            (ws) => arrayBuffersEqual(
+              ws.requestId,
+              rivetRequestIdLocal
+            )
+          );
+          if (persistedHibernatableWebSocket) {
+            persistedHibernatableWebSocket.lastSeenTimestamp = BigInt(Date.now());
+          }
+        }
+        this.#rLog.debug({
+          msg: "actor instance onSocketOpened",
+          rivetRequestId,
+          isHibernatable: !!persistedHibernatableWebSocket,
+          hibernationMsgIndex: persistedHibernatableWebSocket == null ? void 0 : persistedHibernatableWebSocket.msgIndex
+        });
+      };
+      const onSocketMessage = (event) => {
+        if (persistedHibernatableWebSocket) {
+          persistedHibernatableWebSocket.lastSeenTimestamp = BigInt(
+            Date.now()
+          );
+          persistedHibernatableWebSocket.msgIndex = BigInt(
+            event.rivetMessageIndex
+          );
+        }
+        this.#rLog.debug({
+          msg: "actor instance onSocketMessage",
+          rivetRequestId,
+          isHibernatable: !!persistedHibernatableWebSocket,
+          hibernationMsgIndex: persistedHibernatableWebSocket == null ? void 0 : persistedHibernatableWebSocket.msgIndex
+        });
+      };
+      const onSocketClosed = (_event) => {
+        if (rivetRequestId) {
+          const rivetRequestIdLocal = rivetRequestId;
+          const wsIndex = this.#persist.hibernatableWebSocket.findIndex(
+            (ws) => arrayBuffersEqual(
+              ws.requestId,
+              rivetRequestIdLocal
+            )
+          );
+          const removed = this.#persist.hibernatableWebSocket.splice(
+            wsIndex,
+            1
+          );
+          if (removed.length > 0) {
+            this.#rLog.debug({
+              msg: "removed hibernatable websocket",
+              rivetRequestId,
+              hibernationMsgIndex: persistedHibernatableWebSocket == null ? void 0 : persistedHibernatableWebSocket.msgIndex
+            });
+          } else {
+            this.#rLog.warn({
+              msg: "could not find hibernatable websocket to remove",
+              rivetRequestId,
+              hibernationMsgIndex: persistedHibernatableWebSocket == null ? void 0 : persistedHibernatableWebSocket.msgIndex
+            });
+          }
+        }
+        this.#rLog.debug({
+          msg: "actor instance onSocketMessage",
+          rivetRequestId,
+          isHibernatable: !!persistedHibernatableWebSocket,
+          hibernatableWebSocketCount: this.#persist.hibernatableWebSocket.length
+        });
         try {
+          websocket.removeEventListener("open", onSocketOpened);
+          websocket.removeEventListener("message", onSocketMessage);
           websocket.removeEventListener("close", onSocketClosed);
           websocket.removeEventListener("error", onSocketClosed);
         } catch {
@@ -1861,6 +2003,8 @@ var ActorInstance = class {
         this.#resetSleepTimer();
       };
       try {
+        websocket.addEventListener("open", onSocketOpened);
+        websocket.addEventListener("message", onSocketMessage);
         websocket.addEventListener("close", onSocketClosed);
         websocket.addEventListener("error", onSocketClosed);
       } catch {
@@ -2025,6 +2169,27 @@ var ActorInstance = class {
       }
     }
   }
+  /**
+   * Called by router middleware when an HTTP request begins.
+   */
+  __beginHonoHttpRequest() {
+    this.#activeHonoHttpRequests++;
+    this.#resetSleepTimer();
+  }
+  /**
+   * Called by router middleware when an HTTP request ends.
+   */
+  __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: Sleep
   /**
    * Reset timer from the last actor interaction that allows it to be put to sleep.
@@ -2041,56 +2206,68 @@ var ActorInstance = class {
     const canSleep = this.#canSleep();
     this.#rLog.debug({
       msg: "resetting sleep timer",
-      canSleep,
-      existingTimeout: !!this.#sleepTimeout
+      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) {
+    if (canSleep === 0 /* Yes */) {
       this.#sleepTimeout = setTimeout(() => {
-        this._sleep().catch((error) => {
-          this.#rLog.error({
-            msg: "error during sleep",
-            error: stringifyError(error)
-          });
-        });
+        this._startSleep();
       }, this.#config.options.sleepTimeout);
     }
   }
   /** If this actor can be put in a sleeping state. */
   #canSleep() {
-    if (!this.#ready) return false;
+    if (!this.#ready) return 1 /* NotReady */;
+    if (this.#activeHonoHttpRequests > 0)
+      return 3 /* ActiveHonoHttpRequests */;
+    if (this.#activeRawWebSockets.size > 0)
+      return 4 /* ActiveRawWebSockets */;
     for (const conn of this.#connections.values()) {
-      if (conn.status === "connected") return false;
+      if (conn.status === "connected") return 2 /* ActiveConns */;
     }
-    if (this.#activeRawFetchCount > 0) return false;
-    if (this.#activeRawWebSockets.size > 0) return false;
-    return true;
+    return 0 /* Yes */;
   }
-  /** Puts an actor to sleep. This should just start the sleep sequence, most shutdown logic should be in _stop (which is called by the ActorDriver when sleeping). */
-  async _sleep() {
+  /**
+   * Puts an actor to sleep. This should just start the sleep sequence, most shutdown logic should be in _stop (which is called by the ActorDriver when sleeping).
+   *
+   * For the engine, this will:
+   * 1. Publish EventActorIntent with ActorIntentSleep (via driver.startSleep)
+   * 2. Engine runner will wait for CommandStopActor
+   * 3. Engine runner will call _onStop and wait for it to finish
+   * 4. Engine runner will publish EventActorStateUpdate with ActorStateSTop
+   **/
+  _startSleep() {
     var _a;
-    const sleep = (_a = this.#actorDriver.sleep) == null ? void 0 : _a.bind(
-      this.#actorDriver,
-      this.#actorId
-    );
-    invariant(this.#sleepingSupported, "sleeping not supported");
-    invariant(sleep, "no sleep on driver");
     if (this.#sleepCalled) {
       this.#rLog.warn({ msg: "already sleeping actor" });
       return;
     }
     this.#sleepCalled = true;
+    const sleep = (_a = this.#actorDriver.startSleep) == null ? void 0 : _a.bind(
+      this.#actorDriver,
+      this.#actorId
+    );
+    invariant(this.#sleepingSupported, "sleeping not supported");
+    invariant(sleep, "no sleep on driver");
     this.#rLog.info({ msg: "actor sleeping" });
-    setImmediate(async () => {
-      await sleep();
+    setImmediate(() => {
+      sleep();
     });
   }
   // MARK: Stop
-  async _stop() {
+  /**
+   * For the engine:
+   * 1. Engine runner receives CommandStopActor
+   * 2. Engine runner calls _onStop and waits for it to finish
+   * 3. Engine runner publishes EventActorStateUpdate with ActorStateSTop
+   */
+  async _onStop() {
     if (this.#stopCalled) {
       this.#rLog.warn({ msg: "already stopping actor" });
       return;
@@ -2205,6 +2382,11 @@ var ActorInstance = class {
             args: event.kind.generic.args ?? null
           }
         }
+      })),
+      hibernatableWebSocket: persist.hibernatableWebSocket.map((ws) => ({
+        requestId: ws.requestId,
+        lastSeenTimestamp: ws.lastSeenTimestamp,
+        msgIndex: ws.msgIndex
       }))
     };
   }
@@ -2232,6 +2414,11 @@ var ActorInstance = class {
             args: event.kind.val.args
           }
         }
+      })),
+      hibernatableWebSocket: bareData.hibernatableWebSocket.map((ws) => ({
+        requestId: ws.requestId,
+        lastSeenTimestamp: ws.lastSeenTimestamp,
+        msgIndex: ws.msgIndex
       }))
     };
   }
@@ -3389,11 +3576,15 @@ var ActorConnRaw = class {
   }
   /** Called by the onclose event from drivers. */
   #handleOnClose(event) {
-    if (this.#onOpenPromise) {
-      this.#onOpenPromise.reject(new Error("Closed"));
-    }
     const closeEvent = event;
     const wasClean = closeEvent.wasClean;
+    if (this.#onOpenPromise) {
+      this.#onOpenPromise.reject(
+        new Error(
+          `websocket closed with code ${closeEvent.code}: ${closeEvent.reason}`
+        )
+      );
+    }
     logger().info({
       msg: "socket closed",
       code: closeEvent.code,
@@ -3801,7 +3992,10 @@ async function apiCall(config, method, path, body) {
 async function sendHttpRequestToActor(runConfig, actorId, actorRequest) {
   const url = new URL(actorRequest.url);
   const endpoint = getEndpoint(runConfig);
-  const guardUrl = combineUrlPath(endpoint, url.pathname + url.search);
+  const guardUrl = combineUrlPath(
+    endpoint,
+    `/gateway/${actorId}${url.pathname}${url.search}`
+  );
   let bodyToSend = null;
   const guardHeaders = buildGuardHeadersForHttp(
     runConfig,
@@ -3838,8 +4032,6 @@ function buildGuardHeadersForHttp(runConfig, actorRequest, actorId) {
   for (const [key, value] of Object.entries(runConfig.headers)) {
     headers.set(key, value);
   }
-  headers.set(HEADER_RIVET_TARGET, "actor");
-  headers.set(HEADER_RIVET_ACTOR, actorId);
   if (runConfig.token) {
     headers.set(HEADER_RIVET_TOKEN, runConfig.token);
   }
@@ -3850,7 +4042,7 @@ function buildGuardHeadersForHttp(runConfig, actorRequest, actorId) {
 async function openWebSocketToActor(runConfig, path, actorId, encoding, params, connId, connToken) {
   const WebSocket2 = await importWebSocket();
   const endpoint = getEndpoint(runConfig);
-  const guardUrl = combineUrlPath(endpoint, path);
+  const guardUrl = combineUrlPath(endpoint, `/gateway/${actorId}${path}`);
   logger2().debug({
     msg: "opening websocket to actor via guard",
     actorId,
@@ -3859,24 +4051,15 @@ async function openWebSocketToActor(runConfig, path, actorId, encoding, params,
   });
   const ws = new WebSocket2(
     guardUrl,
-    buildWebSocketProtocols(
-      runConfig,
-      actorId,
-      encoding,
-      params,
-      connId,
-      connToken
-    )
+    buildWebSocketProtocols(runConfig, encoding, params, connId, connToken)
   );
   ws.binaryType = "arraybuffer";
   logger2().debug({ msg: "websocket connection opened", actorId });
   return ws;
 }
-function buildWebSocketProtocols(runConfig, actorId, encoding, params, connId, connToken) {
+function buildWebSocketProtocols(runConfig, encoding, params, connId, connToken) {
   const protocols = [];
   protocols.push(WS_PROTOCOL_STANDARD);
-  protocols.push(`${WS_PROTOCOL_TARGET}actor`);
-  protocols.push(`${WS_PROTOCOL_ACTOR}${actorId}`);
   protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
   if (runConfig.token) {
     protocols.push(`${WS_PROTOCOL_TOKEN}${runConfig.token}`);
@@ -4324,7 +4507,6 @@ var RemoteManagerDriver = class {
     });
     const protocols = buildWebSocketProtocols(
       this.#config,
-      actorId,
       encoding,
       params,
       connId,
@@ -4344,10 +4526,11 @@ var RemoteManagerDriver = class {
 export {
   generateConnId,
   generateConnToken,
-  generateConnSocketId,
+  generateConnRequestId,
   createActorInspectorRouter,
   serializeActorKey,
   deserializeActorKey,
+  PERSIST_SYMBOL,
   ActorDefinition,
   lookupInRegistry,
   ActorClientError,
@@ -4363,4 +4546,4 @@ export {
   updateRunnerConfig,
   RemoteManagerDriver
 };
-//# sourceMappingURL=chunk-FETQGZN4.js.map
+//# sourceMappingURL=chunk-3BJJSSTM.js.map