rivetkit 2.0.24-rc.1 → 2.0.24

package/dist/tsup/{chunk-BYMKMOBS.js → chunk-MBBJUHSP.js}

@@ -4,64 +4,64 @@ import {
   inspectorLogger,
   isInspectorEnabled,
   secureInspector
-} from "./chunk-FX7TWFQR.js";
+} from "./chunk-YC7YPM2T.js";
 import {
+  ActionContext,
   ActorDefinition,
-  PERSIST_SYMBOL,
+  CONN_DRIVER_SYMBOL,
+  CONN_STATE_MANAGER_SYMBOL,
+  HTTP_ACTION_REQUEST_VERSIONED,
+  HTTP_ACTION_RESPONSE_VERSIONED,
+  HTTP_RESPONSE_ERROR_VERSIONED,
+  HttpActionRequestSchema,
+  HttpActionResponseSchema,
+  HttpResponseErrorSchema,
   RemoteManagerDriver,
   createActorInspectorRouter,
   createClientWithDriver,
+  createHttpDriver,
   deserializeActorKey,
-  generateConnRequestId,
   getDatacenters,
   getEndpoint,
+  getValueLength,
   lookupInRegistry,
+  parseMessage,
   serializeActorKey,
   updateRunnerConfig
-} from "./chunk-227FEWMB.js";
+} from "./chunk-ZSPU5R4C.js";
 import {
   CreateActorSchema
-} from "./chunk-YBG6R7LX.js";
+} from "./chunk-DUJQWGYD.js";
 import {
-  ActionContext,
   ClientConfigSchema,
-  HTTP_ACTION_REQUEST_VERSIONED,
-  HTTP_ACTION_RESPONSE_VERSIONED,
-  HTTP_RESPONSE_ERROR_VERSIONED,
+  KEYS,
   RunnerConfigSchema,
-  TO_SERVER_VERSIONED,
   createVersionedDataHandler,
-  parseMessage,
-  serializeEmptyPersistData
-} from "./chunk-S4UJG7ZE.js";
+  getInitialActorKvState
+} from "./chunk-OFOTPKAH.js";
 import {
   EncodingSchema,
   HEADER_ACTOR_ID,
-  HEADER_CONN_ID,
   HEADER_CONN_PARAMS,
-  HEADER_CONN_TOKEN,
   HEADER_ENCODING,
   HEADER_RIVET_ACTOR,
   HEADER_RIVET_TARGET,
-  PATH_CONNECT_WEBSOCKET,
-  PATH_RAW_WEBSOCKET_PREFIX,
+  PATH_CONNECT,
+  PATH_INSPECTOR_CONNECT,
+  PATH_WEBSOCKET_BASE,
+  PATH_WEBSOCKET_PREFIX,
   WS_PROTOCOL_ACTOR,
-  WS_PROTOCOL_CONN_ID,
   WS_PROTOCOL_CONN_PARAMS,
-  WS_PROTOCOL_CONN_TOKEN,
   WS_PROTOCOL_ENCODING,
-  WS_PROTOCOL_PATH,
   WS_PROTOCOL_TARGET,
-  WS_PROTOCOL_TRANSPORT,
+  WS_TEST_PROTOCOL_PATH,
   contentTypeForEncoding,
   deserializeWithEncoding,
-  encodingIsBinary,
   generateRandomString,
   loggerWithoutContext,
   serializeWithEncoding
-} from "./chunk-BLK27ES3.js";
+} from "./chunk-I3XT7WOF.js";
 import {
-  EXTRA_ERROR_LOG,
   VERSION,
   arrayBuffersEqual,
   assertUnreachable,
@@ -71,18 +71,15 @@ import {
   deconstructError,
   getEnvUniversal,
   getLogger,
-  idToStr,
   noopNext,
   package_default,
   promiseWithResolvers,
   setLongTimeout,
   stringifyError
-} from "./chunk-PLUN2NQT.js";
+} from "./chunk-BAIGSF64.js";
 import {
-  ActorAlreadyExists,
-  ConnNotFound,
-  IncorrectConnToken,
-  InternalError,
+  ActorDuplicateKey,
+  ActorStopping,
   InvalidEncoding,
   InvalidParams,
   InvalidRequest,
@@ -90,20 +87,21 @@ import {
   Unsupported,
   UserError,
   WebSocketsNotEnabled
-} from "./chunk-G64QUEDJ.js";
+} from "./chunk-W6RDS6NW.js";
 
 // src/actor/config.ts
 import { z } from "zod";
 var ActorConfigSchema = z.object({
   onCreate: z.function().optional(),
-  onStart: z.function().optional(),
-  onStop: z.function().optional(),
+  onDestroy: z.function().optional(),
+  onWake: z.function().optional(),
+  onSleep: z.function().optional(),
   onStateChange: z.function().optional(),
   onBeforeConnect: z.function().optional(),
   onConnect: z.function().optional(),
   onDisconnect: z.function().optional(),
   onBeforeActionResponse: z.function().optional(),
-  onFetch: z.function().optional(),
+  onRequest: z.function().optional(),
   onWebSocket: z.function().optional(),
   actions: z.record(z.function()).default({}),
   state: z.any().optional(),
@@ -118,7 +116,8 @@ var ActorConfigSchema = z.object({
     createConnStateTimeout: z.number().positive().default(5e3),
     onConnectTimeout: z.number().positive().default(5e3),
     // This must be less than ACTOR_STOP_THRESHOLD_MS
-    onStopTimeout: z.number().positive().default(5e3),
+    onSleepTimeout: z.number().positive().default(5e3),
+    onDestroyTimeout: z.number().positive().default(5e3),
     stateSaveInterval: z.number().positive().default(1e4),
     actionTimeout: z.number().positive().default(6e4),
     // Max time to wait for waitUntil background promises during shutdown
@@ -127,8 +126,14 @@ var ActorConfigSchema = z.object({
     connectionLivenessInterval: z.number().positive().default(5e3),
     noSleep: z.boolean().default(false),
     sleepTimeout: z.number().positive().default(3e4),
-    /** @experimental */
-    canHibernatWebSocket: z.union([
+    /**
+     * Can hibernate WebSockets for onWebSocket.
+     *
+     * WebSockets using actions/events are hibernatable by default.
+     *
+     * @experimental
+     **/
+    canHibernateWebSocket: z.union([
       z.boolean(),
       z.function().args(z.custom()).returns(z.boolean())
     ]).default(false)
@@ -159,359 +164,434 @@ import invariant2 from "invariant";
 
 // src/actor/router-endpoints.ts
 import * as cbor from "cbor-x";
-import { streamSSE } from "hono/streaming";
-import invariant from "invariant";
 
-// src/manager/log.ts
-function logger() {
-  return getLogger("actor-manager");
+// src/actor/conn/drivers/raw-request.ts
+function createRawRequestDriver() {
+  return {
+    type: "raw-request",
+    disconnect: async () => {
+    },
+    getConnectionReadyState: () => {
+      return 1 /* OPEN */;
+    }
+  };
 }
 
-// src/manager/hono-websocket-adapter.ts
-var HonoWebSocketAdapter = class {
-  // WebSocket readyState values
-  CONNECTING = 0;
-  OPEN = 1;
-  CLOSING = 2;
-  CLOSED = 3;
-  #ws;
-  #readyState = 1;
-  // Start as OPEN since WSContext is already connected
-  #eventListeners = /* @__PURE__ */ new Map();
-  #closeCode;
-  #closeReason;
-  rivetRequestId;
-  isHibernatable;
-  constructor(ws, rivetRequestId, isHibernatable) {
-    this.#ws = ws;
-    this.rivetRequestId = rivetRequestId;
-    this.isHibernatable = isHibernatable;
-    this.#readyState = this.OPEN;
-    setTimeout(() => {
-      this.#fireEvent("open", {
-        type: "open",
-        target: this,
-        rivetRequestId: this.rivetRequestId
-      });
-    }, 0);
-  }
-  get readyState() {
-    return this.#readyState;
+// src/actor/router-endpoints.ts
+async function handleAction(c, _runConfig, actorDriver, actionName, actorId) {
+  const encoding = getRequestEncoding(c.req);
+  const parameters = getRequestConnParams(c.req);
+  const arrayBuffer = await c.req.arrayBuffer();
+  const request = deserializeWithEncoding(
+    encoding,
+    new Uint8Array(arrayBuffer),
+    HTTP_ACTION_REQUEST_VERSIONED,
+    HttpActionRequestSchema,
+    // JSON: args is already the decoded value (raw object/array)
+    (json) => json.args,
+    // BARE/CBOR: args is ArrayBuffer that needs CBOR-decoding
+    (bare2) => cbor.decode(new Uint8Array(bare2.args))
+  );
+  const actionArgs = request;
+  let actor2;
+  let conn;
+  let output;
+  try {
+    actor2 = await actorDriver.loadActor(actorId);
+    actor2.rLog.debug({ msg: "handling action", actionName, encoding });
+    conn = await actor2.connectionManager.prepareAndConnectConn(
+      createHttpDriver(),
+      parameters,
+      c.req.raw,
+      c.req.path,
+      c.req.header()
+    );
+    const ctx = new ActionContext(actor2, conn);
+    output = await actor2.executeAction(ctx, actionName, actionArgs);
+  } finally {
+    if (conn) {
+      conn.disconnect();
+    }
   }
-  get binaryType() {
-    return "arraybuffer";
+  const serialized = serializeWithEncoding(
+    encoding,
+    output,
+    HTTP_ACTION_RESPONSE_VERSIONED,
+    HttpActionResponseSchema,
+    // JSON: output is the raw value (will be serialized by jsonStringifyCompat)
+    (value) => ({ output: value }),
+    // BARE/CBOR: output needs to be CBOR-encoded to ArrayBuffer
+    (value) => ({
+      output: bufferToArrayBuffer(cbor.encode(value))
+    })
+  );
+  return c.body(serialized, 200, {
+    "Content-Type": contentTypeForEncoding(encoding)
+  });
+}
+async function handleRawRequest(c, req, actorDriver, actorId) {
+  const actor2 = await actorDriver.loadActor(actorId);
+  const parameters = getRequestConnParams(c.req);
+  let createdConn;
+  try {
+    const conn = await actor2.connectionManager.prepareAndConnectConn(
+      createRawRequestDriver(),
+      parameters,
+      req,
+      c.req.path,
+      c.req.header()
+    );
+    createdConn = conn;
+    return await actor2.handleRawRequest(conn, req);
+  } finally {
+    if (createdConn) {
+      createdConn.disconnect();
+    }
   }
-  set binaryType(value) {
+}
+function getRequestEncoding(req) {
+  const encodingParam = req.header(HEADER_ENCODING);
+  if (!encodingParam) {
+    return "json";
   }
-  get bufferedAmount() {
-    return 0;
+  const result = EncodingSchema.safeParse(encodingParam);
+  if (!result.success) {
+    throw new InvalidEncoding(encodingParam);
   }
-  get extensions() {
-    return "";
+  return result.data;
+}
+function getRequestExposeInternalError(_req) {
+  return false;
+}
+function getRequestConnParams(req) {
+  const paramsParam = req.header(HEADER_CONN_PARAMS);
+  if (!paramsParam) {
+    return null;
   }
-  get protocol() {
-    return "";
+  try {
+    return JSON.parse(paramsParam);
+  } catch (err) {
+    throw new InvalidParams(
+      `Invalid params JSON: ${stringifyError(err)}`
+    );
   }
-  get url() {
-    return "";
+}
+
+// src/common/router.ts
+import * as cbor2 from "cbor-x";
+
+// src/registry/config.ts
+import { z as z2 } from "zod";
+var ActorsSchema = z2.record(
+  z2.string(),
+  z2.custom()
+);
+var TestConfigSchema = z2.object({ enabled: z2.boolean() });
+var RegistryConfigSchema = z2.object({
+  use: z2.record(z2.string(), z2.custom()),
+  // TODO: Find a better way of passing around the test config
+  /**
+   * Test configuration.
+   *
+   * DO NOT MANUALLY ENABLE. THIS IS USED INTERNALLY.
+   * @internal
+   **/
+  test: TestConfigSchema.optional().default({ enabled: false })
+});
+function buildActorNames(registryConfig) {
+  return Object.fromEntries(
+    Object.keys(registryConfig.use).map((name) => [name, { metadata: {} }])
+  );
+}
+
+// src/common/router.ts
+function logger() {
+  return getLogger("router");
+}
+function loggerMiddleware(logger8) {
+  return async (c, next) => {
+    const method = c.req.method;
+    const path = c.req.path;
+    const startTime = Date.now();
+    await next();
+    const duration = Date.now() - startTime;
+    logger8.debug({
+      msg: "http request",
+      method,
+      path,
+      status: c.res.status,
+      dt: `${duration}ms`,
+      reqSize: c.req.header("content-length"),
+      resSize: c.res.headers.get("content-length"),
+      userAgent: c.req.header("user-agent"),
+      ...getEnvUniversal("_RIVET_LOG_HEADERS") ? { allHeaders: JSON.stringify(c.req.header()) } : {}
+    });
+  };
+}
+function handleRouteNotFound(c) {
+  return c.text("Not Found (RivetKit)", 404);
+}
+function handleRouteError(error, c) {
+  const exposeInternalError = getRequestExposeInternalError(c.req.raw);
+  const { statusCode, group, code, message, metadata } = deconstructError(
+    error,
+    logger(),
+    {
+      method: c.req.method,
+      path: c.req.path
+    },
+    exposeInternalError
+  );
+  let encoding;
+  try {
+    encoding = getRequestEncoding(c.req);
+  } catch (_) {
+    encoding = "json";
   }
-  send(data) {
-    if (this.readyState !== this.OPEN) {
-      throw new Error("WebSocket is not open");
-    }
-    try {
-      logger().debug({
-        msg: "bridge sending data",
-        dataType: typeof data,
-        isString: typeof data === "string",
-        isArrayBuffer: data instanceof ArrayBuffer,
-        dataStr: typeof data === "string" ? data.substring(0, 100) : "<non-string>"
-      });
-      if (typeof data === "string") {
-        this.#ws.send(data);
-      } else if (data instanceof ArrayBuffer) {
-        this.#ws.send(data);
-      } else if (ArrayBuffer.isView(data)) {
-        const buffer = data.buffer.slice(
-          data.byteOffset,
-          data.byteOffset + data.byteLength
+  const errorData = { group, code, message, metadata };
+  const output = serializeWithEncoding(
+    encoding,
+    errorData,
+    HTTP_RESPONSE_ERROR_VERSIONED,
+    HttpResponseErrorSchema,
+    // JSON: metadata is the raw value (will be serialized by jsonStringifyCompat)
+    (value) => ({
+      group: value.group,
+      code: value.code,
+      message: value.message,
+      metadata: value.metadata
+    }),
+    // BARE/CBOR: metadata needs to be CBOR-encoded to ArrayBuffer
+    (value) => ({
+      group: value.group,
+      code: value.code,
+      message: value.message,
+      metadata: value.metadata ? bufferToArrayBuffer(cbor2.encode(value.metadata)) : null
+    })
+  );
+  return c.body(output, { status: statusCode });
+}
+function handleMetadataRequest(c, registryConfig, runConfig) {
+  const response = {
+    runtime: "rivetkit",
+    version: VERSION,
+    runner: {
+      kind: runConfig.runnerKind === "serverless" ? { serverless: {} } : { normal: {} }
+    },
+    actorNames: buildActorNames(registryConfig),
+    // If server address is changed, return a different client endpoint.
+    // Otherwise, return null indicating the client should use the current
+    // endpoint it's already configured with.
+    clientEndpoint: runConfig.overrideServerAddress
+  };
+  return c.json(response);
+}
+function handleHealthRequest(c) {
+  return c.json({
+    status: "ok",
+    runtime: "rivetkit",
+    version: VERSION
+  });
+}
+
+// src/actor/router-websocket-endpoints.ts
+import invariant from "invariant";
+
+// src/actor/conn/drivers/raw-websocket.ts
+function createRawWebSocketDriver(hibernatable, closePromise) {
+  let websocket;
+  const driver = {
+    type: "raw-websocket",
+    hibernatable,
+    // No sendMessage implementation since this is a raw WebSocket that doesn't
+    // handle messages from the RivetKit protocol
+    disconnect: async (_actor, _conn, reason) => {
+      if (!websocket) {
+        loggerWithoutContext().warn(
+          "disconnecting raw ws without websocket"
         );
-        if (buffer instanceof SharedArrayBuffer) {
-          const arrayBuffer = new ArrayBuffer(buffer.byteLength);
-          new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));
-          this.#ws.send(arrayBuffer);
-        } else {
-          this.#ws.send(buffer);
-        }
-      } else if (data instanceof Blob) {
-        data.arrayBuffer().then((buffer) => {
-          this.#ws.send(buffer);
-        }).catch((error) => {
-          logger().error({
-            msg: "failed to convert blob to arraybuffer",
-            error
+        return;
+      }
+      websocket.close(1e3, reason);
+      await closePromise;
+    },
+    terminate: () => {
+      var _a;
+      (_a = websocket == null ? void 0 : websocket.terminate) == null ? void 0 : _a.call(websocket);
+    },
+    getConnectionReadyState: (_actor, _conn) => {
+      return (websocket == null ? void 0 : websocket.readyState) ?? 0 /* CONNECTING */;
+    }
+  };
+  return {
+    driver,
+    setWebSocket(ws) {
+      websocket = ws;
+    }
+  };
+}
+
+// src/actor/conn/drivers/websocket.ts
+function createWebSocketDriver(hibernatable, encoding, closePromise) {
+  loggerWithoutContext().debug({
+    msg: "createWebSocketDriver creating driver",
+    hibernatable
+  });
+  let websocket;
+  const driver = {
+    type: "websocket",
+    hibernatable,
+    rivetKitProtocol: {
+      sendMessage: (actor2, conn, message) => {
+        if (!websocket) {
+          actor2.rLog.warn({
+            msg: "websocket not open",
+            connId: conn.id
           });
-          this.#fireEvent("error", {
-            type: "error",
-            target: this,
-            error
+          return;
+        }
+        if (websocket.readyState !== 1 /* OPEN */) {
+          actor2.rLog.warn({
+            msg: "attempting to send message to closed websocket, this is likely a bug in RivetKit",
+            connId: conn.id,
+            wsReadyState: websocket.readyState
           });
+          return;
+        }
+        const serialized = message.serialize(encoding);
+        actor2.rLog.debug({
+          msg: "sending websocket message",
+          encoding,
+          dataType: typeof serialized,
+          isUint8Array: serialized instanceof Uint8Array,
+          isArrayBuffer: serialized instanceof ArrayBuffer,
+          dataLength: serialized.byteLength || serialized.length
         });
-      } else {
-        logger().warn({
-          msg: "unsupported data type, converting to string",
-          dataType: typeof data,
-          data
-        });
-        this.#ws.send(String(data));
+        if (serialized instanceof Uint8Array) {
+          const buffer = serialized.buffer.slice(
+            serialized.byteOffset,
+            serialized.byteOffset + serialized.byteLength
+          );
+          if (buffer instanceof SharedArrayBuffer) {
+            const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+            new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));
+            actor2.rLog.debug({
+              msg: "converted SharedArrayBuffer to ArrayBuffer",
+              byteLength: arrayBuffer.byteLength
+            });
+            websocket.send(arrayBuffer);
+          } else {
+            actor2.rLog.debug({
+              msg: "sending ArrayBuffer",
+              byteLength: buffer.byteLength
+            });
+            websocket.send(buffer);
+          }
+        } else {
+          actor2.rLog.debug({
+            msg: "sending string data",
+            length: serialized.length
+          });
+          websocket.send(serialized);
+        }
       }
-    } catch (error) {
-      logger().error({ msg: "error sending websocket data", error });
-      this.#fireEvent("error", { type: "error", target: this, error });
-      throw error;
+    },
+    disconnect: async (_actor, _conn, reason) => {
+      if (!websocket) {
+        loggerWithoutContext().warn(
+          "disconnecting ws without websocket"
+        );
+        return;
+      }
+      websocket.close(1e3, reason);
+      await closePromise;
+    },
+    terminate: () => {
+      websocket.terminate();
+    },
+    getConnectionReadyState: (_actor, _conn) => {
+      return (websocket == null ? void 0 : websocket.readyState) ?? 0 /* CONNECTING */;
     }
-  }
-  close(code = 1e3, reason = "") {
-    if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
-      return;
+  };
+  return {
+    driver,
+    setWebSocket(ws) {
+      websocket = ws;
     }
-    this.#readyState = this.CLOSING;
-    this.#closeCode = code;
-    this.#closeReason = reason;
-    try {
-      this.#ws.close(code, reason);
-      this.#readyState = this.CLOSED;
-      this.#fireEvent("close", {
-        type: "close",
-        target: this,
-        code,
-        reason,
-        wasClean: code === 1e3,
-        rivetRequestId: this.rivetRequestId
-      });
-    } catch (error) {
-      logger().error({ msg: "error closing websocket", error });
-      this.#readyState = this.CLOSED;
-      this.#fireEvent("close", {
-        type: "close",
-        target: this,
-        code: 1006,
-        reason: "Abnormal closure",
-        wasClean: false,
-        rivetRequestId: this.rivetRequestId
-      });
-    }
-  }
-  addEventListener(type, listener) {
-    if (!this.#eventListeners.has(type)) {
-      this.#eventListeners.set(type, /* @__PURE__ */ new Set());
-    }
-    this.#eventListeners.get(type).add(listener);
-  }
-  removeEventListener(type, listener) {
-    const listeners = this.#eventListeners.get(type);
-    if (listeners) {
-      listeners.delete(listener);
-    }
-  }
-  dispatchEvent(event) {
-    const listeners = this.#eventListeners.get(event.type);
-    if (listeners) {
-      for (const listener of listeners) {
-        try {
-          listener(event);
-        } catch (error) {
-          logger().error({
-            msg: `error in ${event.type} event listener`,
-            error
-          });
-        }
-      }
-    }
-    return true;
-  }
-  // Internal method to handle incoming messages from WSContext
-  _handleMessage(data) {
-    let messageData;
-    let rivetRequestId;
-    let rivetMessageIndex;
-    if (typeof data === "string") {
-      messageData = data;
-    } else if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
-      messageData = data;
-    } else if (data && typeof data === "object" && "data" in data) {
-      messageData = data.data;
-      if ("rivetRequestId" in data) {
-        rivetRequestId = data.rivetRequestId;
-      }
-      if ("rivetMessageIndex" in data) {
-        rivetMessageIndex = data.rivetMessageIndex;
-      }
-    } else {
-      messageData = String(data);
-    }
-    logger().debug({
-      msg: "bridge handling message",
-      dataType: typeof messageData,
-      isArrayBuffer: messageData instanceof ArrayBuffer,
-      dataStr: typeof messageData === "string" ? messageData : "<binary>",
-      rivetMessageIndex
-    });
-    this.#fireEvent("message", {
-      type: "message",
-      target: this,
-      data: messageData,
-      rivetRequestId,
-      rivetMessageIndex
-    });
-  }
-  // Internal method to handle close from WSContext
-  _handleClose(code, reason) {
-    this.#ws.close(1e3, "hack_force_close");
-    if (this.readyState === this.CLOSED) return;
-    this.#readyState = this.CLOSED;
-    this.#closeCode = code;
-    this.#closeReason = reason;
-    this.#fireEvent("close", {
-      type: "close",
-      target: this,
-      code,
-      reason,
-      wasClean: code === 1e3,
-      rivetRequestId: this.rivetRequestId
-    });
-  }
-  // Internal method to handle errors from WSContext
-  _handleError(error) {
-    this.#fireEvent("error", {
-      type: "error",
-      target: this,
-      error
-    });
-  }
-  #fireEvent(type, event) {
-    const listeners = this.#eventListeners.get(type);
-    if (listeners) {
-      for (const listener of listeners) {
-        try {
-          listener(event);
-        } catch (error) {
-          logger().error({
-            msg: `error in ${type} event listener`,
-            error
-          });
-        }
-      }
-    }
-    switch (type) {
-      case "open":
-        if (this.#onopen) {
-          try {
-            this.#onopen(event);
-          } catch (error) {
-            logger().error({
-              msg: "error in onopen handler",
-              error
-            });
-          }
-        }
-        break;
-      case "close":
-        if (this.#onclose) {
-          try {
-            this.#onclose(event);
-          } catch (error) {
-            logger().error({
-              msg: "error in onclose handler",
-              error
-            });
-          }
-        }
-        break;
-      case "error":
-        if (this.#onerror) {
-          try {
-            this.#onerror(event);
-          } catch (error) {
-            logger().error({
-              msg: "error in onerror handler",
-              error
-            });
-          }
-        }
-        break;
-      case "message":
-        if (this.#onmessage) {
-          try {
-            this.#onmessage(event);
-          } catch (error) {
-            logger().error({
-              msg: "error in onmessage handler",
-              error
-            });
-          }
-        }
-        break;
-    }
-  }
-  // Event handler properties with getters/setters
-  #onopen = null;
-  #onclose = null;
-  #onerror = null;
-  #onmessage = null;
-  get onopen() {
-    return this.#onopen;
-  }
-  set onopen(handler) {
-    this.#onopen = handler;
-  }
-  get onclose() {
-    return this.#onclose;
-  }
-  set onclose(handler) {
-    this.#onclose = handler;
-  }
-  get onerror() {
-    return this.#onerror;
-  }
-  set onerror(handler) {
-    this.#onerror = handler;
-  }
-  get onmessage() {
-    return this.#onmessage;
-  }
-  set onmessage(handler) {
-    this.#onmessage = handler;
-  }
-};
+  };
+}
 
-// src/actor/router-endpoints.ts
-var SSE_PING_INTERVAL = 1e3;
-async function handleWebSocketConnect(req, runConfig, actorDriver, actorId, encoding, parameters, requestId, requestIdBuf, connId, connToken) {
-  const exposeInternalError = req ? getRequestExposeInternalError(req) : false;
-  const {
-    promise: handlersPromise,
-    resolve: handlersResolve,
-    reject: handlersReject
-  } = promiseWithResolvers();
-  let actor2;
+// src/actor/router-websocket-endpoints.ts
+async function routeWebSocket(request, requestPath, requestHeaders, runConfig, actorDriver, actorId, encoding, parameters, gatewayId, requestId, isHibernatable, isRestoringHibernatable) {
+  const exposeInternalError = request ? getRequestExposeInternalError(request) : false;
+  let createdConn;
   try {
-    actor2 = await actorDriver.loadActor(actorId);
+    const actor2 = await actorDriver.loadActor(actorId);
+    actor2.rLog.debug({
+      msg: "new websocket connection",
+      actorId,
+      requestPath,
+      isHibernatable
+    });
+    const closePromiseResolvers = promiseWithResolvers();
+    let handler;
+    let connDriver;
+    if (requestPath === PATH_CONNECT) {
+      const { driver, setWebSocket } = createWebSocketDriver(
+        isHibernatable ? { gatewayId, requestId } : void 0,
+        encoding,
+        closePromiseResolvers.promise
+      );
+      handler = handleWebSocketConnect.bind(void 0, setWebSocket);
+      connDriver = driver;
+    } else if (requestPath === PATH_WEBSOCKET_BASE || requestPath.startsWith(PATH_WEBSOCKET_PREFIX)) {
+      const { driver, setWebSocket } = createRawWebSocketDriver(
+        isHibernatable ? { gatewayId, requestId } : void 0,
+        closePromiseResolvers.promise
+      );
+      handler = handleRawWebSocket.bind(void 0, setWebSocket);
+      connDriver = driver;
+    } else if (requestPath === PATH_INSPECTOR_CONNECT) {
+      return await handleWebSocketInspectorConnect();
+    } else {
+      throw `WebSocket Path Not Found: ${requestPath}`;
+    }
+    const conn = await actor2.connectionManager.prepareConn(
+      connDriver,
+      parameters,
+      request,
+      requestPath,
+      requestHeaders,
+      isHibernatable,
+      isRestoringHibernatable
+    );
+    createdConn = conn;
+    return await handler({
+      runConfig,
+      request,
+      encoding,
+      actor: actor2,
+      closePromiseResolvers,
+      conn,
+      exposeInternalError
+    });
   } catch (error) {
+    const { group, code } = deconstructError(
+      error,
+      loggerWithoutContext(),
+      {},
+      exposeInternalError
+    );
+    if (createdConn) {
+      createdConn.disconnect(`${group}.${code}`);
+    }
     return {
+      conn: createdConn,
       onOpen: (_evt, ws) => {
-        const { code } = deconstructError(
-          error,
-          actor2.rLog,
-          {
-            wsEvent: "open"
-          },
-          exposeInternalError
-        );
         ws.close(1011, code);
       },
       onMessage: (_evt, ws) => {
-        ws.close(1011, "Actor not loaded");
+        ws.close(1011, "actor.not_loaded");
       },
       onClose: (_event, _ws) => {
       },
@@ -519,79 +599,38 @@ async function handleWebSocketConnect(req, runConfig, actorDriver, actorId, enco
       }
     };
   }
-  const closePromise = promiseWithResolvers();
-  let createdConn;
+}
+async function handleWebSocketConnect(setWebSocket, {
+  runConfig,
+  encoding,
+  actor: actor2,
+  closePromiseResolvers,
+  conn,
+  exposeInternalError
+}) {
   return {
+    conn,
+    actor: actor2,
+    onRestore: (ws) => {
+      setWebSocket(ws);
+    },
+    // NOTE: onOpen cannot be async since this messes up the open event listener order
     onOpen: (_evt, ws) => {
       actor2.rLog.debug("actor websocket open");
-      (async () => {
-        try {
-          let conn;
-          actor2.rLog.debug({
-            msg: connId ? "websocket reconnection attempt" : "new websocket connection",
-            connId,
-            actorId
-          });
-          const isHibernatable = !!requestIdBuf && actor2[PERSIST_SYMBOL].hibernatableWebSocket.findIndex(
-            (ws2) => arrayBuffersEqual(ws2.requestId, requestIdBuf)
-          ) !== -1;
-          conn = await actor2.createConn(
-            {
-              requestId,
-              requestIdBuf,
-              hibernatable: isHibernatable,
-              driverState: {
-                [0 /* WEBSOCKET */]: {
-                  encoding,
-                  websocket: ws,
-                  closePromise
-                }
-              }
-            },
-            parameters,
-            req,
-            connId,
-            connToken
-          );
-          createdConn = conn;
-          handlersResolve({ conn, actor: actor2, connId: conn.id });
-        } catch (error) {
-          handlersReject(error);
-          const { code } = deconstructError(
-            error,
-            actor2.rLog,
-            {
-              wsEvent: "open"
-            },
-            exposeInternalError
-          );
-          ws.close(1011, code);
-        }
-      })();
+      setWebSocket(ws);
+      actor2.connectionManager.connectConn(conn);
     },
     onMessage: (evt, ws) => {
-      handlersPromise.then(({ conn, actor: actor3 }) => {
-        actor3.rLog.debug({ msg: "received message" });
-        const value = evt.data.valueOf();
-        parseMessage(value, {
-          encoding,
-          maxIncomingMessageSize: runConfig.maxIncomingMessageSize
-        }).then((message) => {
-          actor3.processMessage(message, conn).catch((error) => {
-            const { code } = deconstructError(
-              error,
-              actor3.rLog,
-              {
-                wsEvent: "message"
-              },
-              exposeInternalError
-            );
-            ws.close(1011, code);
-          });
-        }).catch((error) => {
+      actor2.rLog.debug({ msg: "received message" });
+      const value = evt.data.valueOf();
+      parseMessage(value, {
+        encoding,
+        maxIncomingMessageSize: runConfig.maxIncomingMessageSize
+      }).then((message) => {
+        actor2.processMessage(message, conn).catch((error) => {
           const { code } = deconstructError(
             error,
-            actor3.rLog,
+            actor2.rLog,
             {
               wsEvent: "message"
             },
@@ -612,8 +651,7 @@ async function handleWebSocketConnect(req, runConfig, actorDriver, actorId, enco
       });
     },
     onClose: (event, ws) => {
-      handlersReject(`WebSocket closed (${event.code}): ${event.reason}`);
-      closePromise.resolve();
+      closePromiseResolvers.resolve();
       if (event.wasClean) {
         actor2.rLog.info({
           msg: "websocket closed",
@@ -630,12 +668,7 @@ async function handleWebSocketConnect(req, runConfig, actorDriver, actorId, enco
         });
       }
       ws.close(1e3, "hack_force_close");
-      handlersPromise.finally(() => {
-        if (createdConn) {
-          const wasClean = event.wasClean || event.code === 1e3;
-          actor2.__connDisconnected(createdConn, wasClean, requestId);
-        }
-      });
+      conn.disconnect(event == null ? void 0 : event.reason);
     },
     onError: (_error) => {
       try {
@@ -651,192 +684,24 @@ async function handleWebSocketConnect(req, runConfig, actorDriver, actorId, enco
     }
   };
 }
-async function handleSseConnect(c, _runConfig, actorDriver, actorId) {
-  c.header("Content-Encoding", "Identity");
-  const encoding = getRequestEncoding(c.req);
-  const parameters = getRequestConnParams(c.req);
-  const requestId = generateConnRequestId();
-  const connId = c.req.header(HEADER_CONN_ID);
-  const connToken = c.req.header(HEADER_CONN_TOKEN);
-  return streamSSE(c, async (stream) => {
-    let actor2;
-    let conn;
-    try {
-      actor2 = await actorDriver.loadActor(actorId);
-      actor2.rLog.debug({
-        msg: connId ? "sse reconnection attempt" : "sse open",
-        connId
-      });
-      conn = await actor2.createConn(
-        {
-          requestId,
-          hibernatable: false,
-          driverState: {
-            [1 /* SSE */]: {
-              encoding,
-              stream
-            }
-          }
-        },
-        parameters,
-        c.req.raw,
-        connId,
-        connToken
-      );
-      const abortResolver = promiseWithResolvers();
-      stream.onAbort(() => {
-      });
-      c.req.raw.signal.addEventListener("abort", async () => {
-        invariant(actor2, "actor should exist");
-        const rLog = actor2.rLog ?? loggerWithoutContext();
-        try {
-          rLog.debug("sse stream aborted");
-          if (conn) {
-            actor2.__connDisconnected(conn, false, requestId);
-          }
-          abortResolver.resolve(void 0);
-        } catch (error) {
-          rLog.error({ msg: "error closing sse connection", error });
-          abortResolver.resolve(void 0);
-        }
-      });
-      while (true) {
-        if (stream.closed || stream.aborted) {
-          actor2 == null ? void 0 : actor2.rLog.debug({
-            msg: "sse stream closed",
-            closed: stream.closed,
-            aborted: stream.aborted
-          });
-          break;
-        }
-        await stream.writeSSE({ event: "ping", data: "" });
-        await stream.sleep(SSE_PING_INTERVAL);
-      }
-    } catch (error) {
-      loggerWithoutContext().error({
-        msg: "error in sse connection",
-        error
-      });
-      if (conn && actor2 !== void 0) {
-        actor2.__connDisconnected(conn, false, requestId);
-      }
-      stream.close();
-    }
-  });
-}
-async function handleAction(c, _runConfig, actorDriver, actionName, actorId) {
-  const encoding = getRequestEncoding(c.req);
-  const parameters = getRequestConnParams(c.req);
-  const arrayBuffer = await c.req.arrayBuffer();
-  const request = deserializeWithEncoding(
-    encoding,
-    new Uint8Array(arrayBuffer),
-    HTTP_ACTION_REQUEST_VERSIONED
-  );
-  const actionArgs = cbor.decode(new Uint8Array(request.args));
-  const requestId = generateConnRequestId();
-  let actor2;
-  let conn;
-  let output;
-  try {
-    actor2 = await actorDriver.loadActor(actorId);
-    actor2.rLog.debug({ msg: "handling action", actionName, encoding });
-    conn = await actor2.createConn(
-      {
-        requestId,
-        hibernatable: false,
-        driverState: { [2 /* HTTP */]: {} }
-      },
-      parameters,
-      c.req.raw
-    );
-    const ctx = new ActionContext(actor2.actorContext, conn);
-    output = await actor2.executeAction(ctx, actionName, actionArgs);
-  } finally {
-    if (conn) {
-      actor2 == null ? void 0 : actor2.__connDisconnected(conn, true, requestId);
-    }
-  }
-  const responseData = {
-    output: bufferToArrayBuffer(cbor.encode(output))
-  };
-  const serialized = serializeWithEncoding(
-    encoding,
-    responseData,
-    HTTP_ACTION_RESPONSE_VERSIONED
-  );
-  return c.body(serialized, 200, {
-    "Content-Type": contentTypeForEncoding(encoding)
-  });
-}
-async function handleConnectionMessage(c, _runConfig, actorDriver, connId, connToken, actorId) {
-  const encoding = getRequestEncoding(c.req);
-  const arrayBuffer = await c.req.arrayBuffer();
-  const message = deserializeWithEncoding(
-    encoding,
-    new Uint8Array(arrayBuffer),
-    TO_SERVER_VERSIONED
-  );
-  const actor2 = await actorDriver.loadActor(actorId);
-  const conn = actor2.conns.get(connId);
-  if (!conn) {
-    throw new ConnNotFound(connId);
-  }
-  if (conn._token !== connToken) {
-    throw new IncorrectConnToken();
-  }
-  await actor2.processMessage(message, conn);
-  return c.json({});
-}
-async function handleConnectionClose(c, _runConfig, actorDriver, connId, connToken, actorId) {
-  var _a;
-  const actor2 = await actorDriver.loadActor(actorId);
-  const conn = actor2.conns.get(connId);
-  if (!conn) {
-    throw new ConnNotFound(connId);
-  }
-  if (conn._token !== connToken) {
-    throw new IncorrectConnToken();
-  }
-  if (!((_a = conn.__socket) == null ? void 0 : _a.driverState) || !(1 /* SSE */ in conn.__socket.driverState)) {
-    throw new UserError(
-      "Connection close is only supported for SSE connections"
-    );
-  }
-  await conn.disconnect("Connection closed by client request");
-  return c.json({});
-}
-async function handleRawWebSocketHandler(req, path4, actorDriver, actorId, requestIdBuf) {
-  const actor2 = await actorDriver.loadActor(actorId);
+async function handleRawWebSocket(setWebSocket, { request, actor: actor2, closePromiseResolvers, conn }) {
   return {
-    onOpen: (evt, ws) => {
-      const rivetRequestId = evt == null ? void 0 : evt.rivetRequestId;
-      const isHibernatable = actor2[PERSIST_SYMBOL].hibernatableWebSocket.findIndex(
-        (ws2) => arrayBuffersEqual(ws2.requestId, rivetRequestId)
-      ) !== -1;
-      const adapter = new HonoWebSocketAdapter(
-        ws,
-        rivetRequestId,
-        isHibernatable
-      );
-      ws.__adapter = adapter;
-      const newPath = truncateRawWebSocketPathPrefix(path4);
-      let newRequest;
-      if (req) {
-        newRequest = new Request(`http://actor${newPath}`, req);
-      } else {
-        newRequest = new Request(`http://actor${newPath}`, {
-          method: "GET"
-        });
-      }
-      actor2.rLog.debug({
-        msg: "rewriting websocket url",
-        fromPath: path4,
-        toUrl: newRequest.url
-      });
-      actor2.handleWebSocket(adapter, {
-        request: newRequest
-      });
+    conn,
+    actor: actor2,
+    onRestore: (wsContext) => {
+      const ws = wsContext.raw;
+      invariant(ws, "missing wsContext.raw");
+      setWebSocket(ws);
+    },
+    // NOTE: onOpen cannot be async since this will cause the client's open
+    // event to be called before this completes. Do all async work in
+    // handleRawWebSocket root.
+    onOpen: (_evt, wsContext) => {
+      const ws = wsContext.raw;
+      invariant(ws, "missing wsContext.raw");
+      setWebSocket(ws);
+      actor2.connectionManager.connectConn(conn);
+      actor2.handleRawWebSocket(conn, ws, request);
     },
     onMessage: (event, ws) => {
       const adapter = ws.__adapter;
@@ -844,157 +709,53 @@ async function handleRawWebSocketHandler(req, path4, actorDriver, actorId, reque
         adapter._handleMessage(event);
       }
     },
-    onClose: (evt, ws) => {
-      const adapter = ws.__adapter;
-      if (adapter) {
-        adapter._handleClose((evt == null ? void 0 : evt.code) || 1006, (evt == null ? void 0 : evt.reason) || "");
-      }
-    },
-    onError: (error, ws) => {
-      const adapter = ws.__adapter;
-      if (adapter) {
-        adapter._handleError(error);
-      }
-    }
-  };
-}
-function getRequestEncoding(req) {
-  const encodingParam = req.header(HEADER_ENCODING);
-  if (!encodingParam) {
-    throw new InvalidEncoding("undefined");
-  }
-  const result = EncodingSchema.safeParse(encodingParam);
-  if (!result.success) {
-    throw new InvalidEncoding(encodingParam);
-  }
-  return result.data;
-}
-function getRequestExposeInternalError(_req) {
-  return false;
-}
-function getRequestConnParams(req) {
-  const paramsParam = req.header(HEADER_CONN_PARAMS);
-  if (!paramsParam) {
-    return null;
-  }
-  try {
-    return JSON.parse(paramsParam);
-  } catch (err) {
-    throw new InvalidParams(
-      `Invalid params JSON: ${stringifyError(err)}`
-    );
-  }
-}
-function truncateRawWebSocketPathPrefix(path4) {
-  const url = new URL(path4, "http://actor");
-  const pathname = url.pathname.replace(/^\/raw\/websocket\/?/, "") || "/";
-  const normalizedPath = (pathname.startsWith("/") ? pathname : "/" + pathname) + url.search;
-  return normalizedPath;
-}
-
-// src/common/router.ts
-import * as cbor2 from "cbor-x";
-
-// src/registry/config.ts
-import { z as z2 } from "zod";
-var ActorsSchema = z2.record(
-  z2.string(),
-  z2.custom()
-);
-var TestConfigSchema = z2.object({ enabled: z2.boolean() });
-var RegistryConfigSchema = z2.object({
-  use: z2.record(z2.string(), z2.custom()),
-  // TODO: Find a better way of passing around the test config
-  /**
-   * Test configuration.
-   *
-   * DO NOT MANUALLY ENABLE. THIS IS USED INTERNALLY.
-   * @internal
-   **/
-  test: TestConfigSchema.optional().default({ enabled: false })
-});
-function buildActorNames(registryConfig) {
-  return Object.fromEntries(
-    Object.keys(registryConfig.use).map((name) => [name, { metadata: {} }])
-  );
-}
-
-// src/common/router.ts
-function logger2() {
-  return getLogger("router");
-}
-function loggerMiddleware(logger8) {
-  return async (c, next) => {
-    const method = c.req.method;
-    const path4 = c.req.path;
-    const startTime = Date.now();
-    await next();
-    const duration = Date.now() - startTime;
-    logger8.debug({
-      msg: "http request",
-      method,
-      path: path4,
-      status: c.res.status,
-      dt: `${duration}ms`,
-      reqSize: c.req.header("content-length"),
-      resSize: c.res.headers.get("content-length"),
-      userAgent: c.req.header("user-agent"),
-      ...getEnvUniversal("_RIVET_LOG_HEADERS") ? { allHeaders: JSON.stringify(c.req.header()) } : {}
-    });
+    onClose: (evt, ws) => {
+      closePromiseResolvers.resolve();
+      conn.disconnect(evt == null ? void 0 : evt.reason);
+    },
+    onError: (error, ws) => {
+    }
   };
 }
-function handleRouteNotFound(c) {
-  return c.text("Not Found (RivetKit)", 404);
-}
-function handleRouteError(error, c) {
-  const exposeInternalError = getRequestExposeInternalError(c.req.raw);
-  const { statusCode, group, code, message, metadata } = deconstructError(
-    error,
-    logger2(),
-    {
-      method: c.req.method,
-      path: c.req.path
+async function handleWebSocketInspectorConnect() {
+  return {
+    // NOTE: onOpen cannot be async since this messes up the open event listener order
+    onOpen: (_evt, ws) => {
+      ws.send("Hello world");
     },
-    exposeInternalError
-  );
-  let encoding;
-  try {
-    encoding = getRequestEncoding(c.req);
-  } catch (_) {
-    encoding = "json";
-  }
-  const output = serializeWithEncoding(
-    encoding,
-    {
-      group,
-      code,
-      message,
-      // TODO: Cannot serialize non-binary meta since it requires ArrayBuffer atm
-      metadata: encodingIsBinary(encoding) ? bufferToArrayBuffer(cbor2.encode(metadata)) : null
+    onMessage: (evt, ws) => {
+      ws.send("Pong");
     },
-    HTTP_RESPONSE_ERROR_VERSIONED
-  );
-  return c.body(output, { status: statusCode });
-}
-function handleMetadataRequest(c, registryConfig, runConfig) {
-  const response = {
-    runtime: "rivetkit",
-    version: VERSION,
-    runner: {
-      kind: runConfig.runnerKind === "serverless" ? { serverless: {} } : { normal: {} }
+    onClose: (event, ws) => {
     },
-    actorNames: buildActorNames(registryConfig),
-    // Do not return client endpoint if default server disabled
-    clientEndpoint: runConfig.overrideServerAddress ?? (runConfig.disableDefaultServer ? void 0 : getEndpoint(runConfig))
+    onError: (_error) => {
+    }
   };
-  return c.json(response);
 }
-function handleHealthRequest(c) {
-  return c.json({
-    status: "ok",
-    runtime: "rivetkit",
-    version: VERSION
-  });
+function parseWebSocketProtocols(protocols) {
+  let encodingRaw;
+  let connParamsRaw;
+  if (protocols) {
+    const protocolList = protocols.split(",").map((p) => p.trim());
+    for (const protocol of protocolList) {
+      if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
+        encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
+      } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
+        connParamsRaw = decodeURIComponent(
+          protocol.substring(WS_PROTOCOL_CONN_PARAMS.length)
+        );
+      }
+    }
+  }
+  const encoding = EncodingSchema.parse(encodingRaw);
+  const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
+  return { encoding, connParams };
+}
+function truncateRawWebSocketPathPrefix(path) {
+  const url = new URL(path, "http://actor");
+  const pathname = url.pathname.replace(/^\/websocket\/?/, "") || "/";
+  const normalizedPath = (pathname.startsWith("/") ? pathname : `/${pathname}`) + url.search;
+  return normalizedPath;
 }
 
 // src/actor/router.ts
@@ -1005,11 +766,11 @@ function createActorRouter(runConfig, actorDriver, isTest) {
   router.use("*", loggerMiddleware(loggerWithoutContext()));
   router.use("*", async (c, next) => {
     const actor2 = await actorDriver.loadActor(c.env.actorId);
-    actor2.__beginHonoHttpRequest();
+    actor2.beginHonoHttpRequest();
     try {
       await next();
     } finally {
-      actor2.__endHonoHttpRequest();
+      actor2.endHonoHttpRequest();
     }
   });
   router.get("/", (c) => {
@@ -1022,85 +783,55 @@ function createActorRouter(runConfig, actorDriver, isTest) {
   });
   if (isTest) {
     router.post("/.test/force-disconnect", async (c) => {
+      var _a;
       const connId = c.req.query("conn");
       if (!connId) {
         return c.text("Missing conn query parameter", 400);
       }
       const actor2 = await actorDriver.loadActor(c.env.actorId);
-      const conn = actor2.__getConnForId(connId);
+      const conn = actor2.connectionManager.getConnForId(connId);
       if (!conn) {
         return c.text(`Connection not found: ${connId}`, 404);
       }
-      const driverState = conn.__driverState;
-      if (driverState && 0 /* WEBSOCKET */ in driverState) {
-        const ws = driverState[0 /* WEBSOCKET */].websocket;
-        ws.raw.terminate();
-      } else if (driverState && 1 /* SSE */ in driverState) {
-        const stream = driverState[1 /* SSE */].stream;
-        stream.abort();
+      if ((_a = conn[CONN_DRIVER_SYMBOL]) == null ? void 0 : _a.terminate) {
+        conn[CONN_DRIVER_SYMBOL].terminate(actor2, conn);
       }
       return c.json({ success: true });
     });
   }
-  router.get(PATH_CONNECT_WEBSOCKET, async (c) => {
-    var _a;
-    const upgradeWebSocket = (_a = runConfig.getUpgradeWebSocket) == null ? void 0 : _a.call(runConfig);
-    if (upgradeWebSocket) {
-      return upgradeWebSocket(async (c2) => {
-        const protocols = c2.req.header("sec-websocket-protocol");
-        let encodingRaw;
-        let connParamsRaw;
-        let connIdRaw;
-        let connTokenRaw;
-        if (protocols) {
-          const protocolList = protocols.split(",").map((p) => p.trim());
-          for (const protocol of protocolList) {
-            if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
-              encodingRaw = protocol.substring(
-                WS_PROTOCOL_ENCODING.length
-              );
-            } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
-              connParamsRaw = decodeURIComponent(
-                protocol.substring(
-                  WS_PROTOCOL_CONN_PARAMS.length
-                )
-              );
-            } else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
-              connIdRaw = protocol.substring(
-                WS_PROTOCOL_CONN_ID.length
-              );
-            } else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
-              connTokenRaw = protocol.substring(
-                WS_PROTOCOL_CONN_TOKEN.length
-              );
-            }
-          }
-        }
-        const encoding = EncodingSchema.parse(encodingRaw);
-        const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
-        return await handleWebSocketConnect(
-          c2.req.raw,
-          runConfig,
-          actorDriver,
-          c2.env.actorId,
-          encoding,
-          connParams,
-          generateConnRequestId(),
-          void 0,
-          connIdRaw,
-          connTokenRaw
+  router.on(
+    "GET",
+    [PATH_CONNECT, `${PATH_WEBSOCKET_PREFIX}*`, PATH_INSPECTOR_CONNECT],
+    async (c) => {
+      var _a;
+      const upgradeWebSocket = (_a = runConfig.getUpgradeWebSocket) == null ? void 0 : _a.call(runConfig);
+      if (upgradeWebSocket) {
+        return upgradeWebSocket(async (c2) => {
+          const protocols = c2.req.header("sec-websocket-protocol");
+          const { encoding, connParams } = parseWebSocketProtocols(protocols);
+          return await routeWebSocket(
+            c2.req.raw,
+            c2.req.path,
+            c2.req.header(),
+            runConfig,
+            actorDriver,
+            c2.env.actorId,
+            encoding,
+            connParams,
+            void 0,
+            void 0,
+            false,
+            false
+          );
+        })(c, noopNext());
+      } else {
+        return c.text(
+          "WebSockets are not enabled for this driver.",
+          400
         );
-      })(c, noopNext());
-    } else {
-      return c.text(
-        "WebSockets are not enabled for this driver. Use SSE instead.",
-        400
-      );
+      }
     }
-  });
-  router.get("/connect/sse", async (c) => {
-    return handleSseConnect(c, runConfig, actorDriver, c.env.actorId);
-  });
+  );
   router.post("/action/:action", async (c) => {
     const actionName = c.req.param("action");
     return handleAction(
@@ -1111,40 +842,9 @@ function createActorRouter(runConfig, actorDriver, isTest) {
       c.env.actorId
     );
   });
-  router.post("/connections/message", async (c) => {
-    const connId = c.req.header(HEADER_CONN_ID);
-    const connToken = c.req.header(HEADER_CONN_TOKEN);
-    if (!connId || !connToken) {
-      throw new Error("Missing required parameters");
-    }
-    return handleConnectionMessage(
-      c,
-      runConfig,
-      actorDriver,
-      connId,
-      connToken,
-      c.env.actorId
-    );
-  });
-  router.post("/connections/close", async (c) => {
-    const connId = c.req.header(HEADER_CONN_ID);
-    const connToken = c.req.header(HEADER_CONN_TOKEN);
-    if (!connId || !connToken) {
-      throw new Error("Missing required parameters");
-    }
-    return handleConnectionClose(
-      c,
-      runConfig,
-      actorDriver,
-      connId,
-      connToken,
-      c.env.actorId
-    );
-  });
-  router.all("/raw/http/*", async (c) => {
-    const actor2 = await actorDriver.loadActor(c.env.actorId);
+  router.all("/request/*", async (c) => {
     const url = new URL(c.req.url);
-    const originalPath = url.pathname.replace(/^\/raw\/http/, "") || "/";
+    const originalPath = url.pathname.replace(/^\/request/, "") || "/";
     const correctedUrl = new URL(originalPath + url.search, url.origin);
     const correctedRequest = new Request(correctedUrl, {
       method: c.req.method,
@@ -1157,40 +857,12 @@ function createActorRouter(runConfig, actorDriver, isTest) {
       from: c.req.url,
       to: correctedRequest.url
     });
-    const response = await actor2.handleFetch(correctedRequest, {});
-    if (!response) {
-      throw new InternalError("handleFetch returned void unexpectedly");
-    }
-    return response;
-  });
-  router.get(`${PATH_RAW_WEBSOCKET_PREFIX}*`, async (c) => {
-    var _a;
-    const upgradeWebSocket = (_a = runConfig.getUpgradeWebSocket) == null ? void 0 : _a.call(runConfig);
-    if (upgradeWebSocket) {
-      return upgradeWebSocket(async (c2) => {
-        const url = new URL(c2.req.url);
-        const pathWithQuery = c2.req.path + url.search;
-        loggerWithoutContext().debug({
-          msg: "actor router raw websocket",
-          path: c2.req.path,
-          url: c2.req.url,
-          search: url.search,
-          pathWithQuery
-        });
-        return await handleRawWebSocketHandler(
-          c2.req.raw,
-          pathWithQuery,
-          actorDriver,
-          c2.env.actorId,
-          void 0
-        );
-      })(c, noopNext());
-    } else {
-      return c.text(
-        "WebSockets are not enabled for this driver. Use SSE instead.",
-        400
-      );
-    }
+    return await handleRawRequest(
+      c,
+      correctedRequest,
+      actorDriver,
+      c.env.actorId
+    );
   });
   if (isInspectorEnabled(runConfig, "actor")) {
     router.route(
@@ -1217,12 +889,12 @@ function actor(input) {
   return new ActorDefinition(config2);
 }
 
-// src/common/inline-websocket-adapter2.ts
+// src/common/inline-websocket-adapter.ts
 import { WSContext } from "hono/ws";
-function logger3() {
+function logger2() {
   return getLogger("fake-event-source2");
 }
-var InlineWebSocketAdapter2 = class {
+var InlineWebSocketAdapter = class {
   // WebSocket readyState values
   CONNECTING = 0;
   OPEN = 1;
@@ -1234,27 +906,26 @@ var InlineWebSocketAdapter2 = class {
   #readyState = 0;
   // Start in CONNECTING state
   #queuedMessages = [];
-  // Event buffering is needed since events can be fired
-  // before JavaScript has a chance to add event listeners (e.g. within the same tick)
-  #bufferedEvents = [];
-  // Event listeners with buffering
+  // Event listeners
   #eventListeners = /* @__PURE__ */ new Map();
   constructor(handler) {
     this.#handler = handler;
     this.#wsContext = new WSContext({
       raw: this,
       send: (data) => {
-        logger3().debug({ msg: "WSContext.send called" });
+        logger2().debug({ msg: "WSContext.send called" });
         this.#handleMessage(data);
       },
       close: (code, reason) => {
-        logger3().debug({ msg: "WSContext.close called", code, reason });
+        logger2().debug({ msg: "WSContext.close called", code, reason });
         this.#handleClose(code || 1e3, reason || "");
       },
       // Set readyState to 1 (OPEN) since handlers expect an open connection
       readyState: 1
     });
-    this.#initialize();
+    setTimeout(() => {
+      this.#initialize();
+    }, 0);
   }
   get readyState() {
     return this.#readyState;
@@ -1277,17 +948,18 @@ var InlineWebSocketAdapter2 = class {
     return "";
   }
   send(data) {
-    logger3().debug({ msg: "send called", readyState: this.readyState });
-    if (this.readyState !== this.OPEN) {
-      const error = new Error("WebSocket is not open");
-      logger3().warn({
-        msg: "cannot send message, websocket not open",
-        readyState: this.readyState,
-        dataType: typeof data,
-        dataLength: typeof data === "string" ? data.length : "binary",
-        error
+    logger2().debug({ msg: "send called", readyState: this.readyState });
+    if (this.readyState === this.CONNECTING) {
+      throw new DOMException(
+        "WebSocket is still in CONNECTING state",
+        "InvalidStateError"
+      );
+    }
+    if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
+      logger2().debug({
+        msg: "ignoring send, websocket is closing or closed",
+        readyState: this.readyState
       });
-      this.#fireError(error);
       return;
     }
     this.#handler.onMessage({ data }, this.#wsContext);
@@ -1299,7 +971,7 @@ var InlineWebSocketAdapter2 = class {
     if (this.readyState === this.CLOSED || this.readyState === this.CLOSING) {
       return;
     }
-    logger3().debug({ msg: "closing fake websocket", code, reason });
+    logger2().debug({ msg: "closing fake websocket", code, reason });
     this.#readyState = this.CLOSING;
     try {
       this.#handler.onClose(
@@ -1307,7 +979,7 @@ var InlineWebSocketAdapter2 = class {
         this.#wsContext
       );
     } catch (err) {
-      logger3().error({ msg: "error closing websocket", error: err });
+      logger2().error({ msg: "error closing websocket", error: err });
     } finally {
       this.#readyState = this.CLOSED;
       const closeEvent = {
@@ -1326,31 +998,31 @@ var InlineWebSocketAdapter2 = class {
    */
   async #initialize() {
     try {
-      logger3().debug({ msg: "fake websocket initializing" });
-      logger3().debug({ msg: "calling handler.onOpen with WSContext" });
+      logger2().debug({ msg: "fake websocket initializing" });
+      logger2().debug({ msg: "calling handler.onOpen with WSContext" });
       this.#handler.onOpen(void 0, this.#wsContext);
       this.#readyState = this.OPEN;
-      logger3().debug({ msg: "fake websocket initialized and now OPEN" });
+      logger2().debug({ msg: "fake websocket initialized and now OPEN" });
       this.#fireOpen();
       if (this.#queuedMessages.length > 0) {
         if (this.readyState !== this.OPEN) {
-          logger3().warn({
+          logger2().warn({
             msg: "socket no longer open, dropping queued messages"
           });
           return;
         }
-        logger3().debug({
+        logger2().debug({
           msg: `now processing ${this.#queuedMessages.length} queued messages`
         });
         const messagesToProcess = [...this.#queuedMessages];
         this.#queuedMessages = [];
         for (const message of messagesToProcess) {
-          logger3().debug({ msg: "processing queued message" });
+          logger2().debug({ msg: "processing queued message" });
           this.#handleMessage(message);
         }
       }
     } catch (err) {
-      logger3().error({
+      logger2().error({
         msg: "error opening fake websocket",
         error: err,
         errorMessage: err instanceof Error ? err.message : String(err),
@@ -1365,7 +1037,7 @@ var InlineWebSocketAdapter2 = class {
    */
   #handleMessage(data) {
     if (this.readyState !== this.OPEN) {
-      logger3().debug({
+      logger2().debug({
         msg: "message received before socket is OPEN, queuing",
         readyState: this.readyState,
         dataType: typeof data,
@@ -1374,7 +1046,7 @@ var InlineWebSocketAdapter2 = class {
       this.#queuedMessages.push(data);
       return;
     }
-    logger3().debug({
+    logger2().debug({
       msg: "fake websocket received message from server",
       dataType: typeof data,
       dataLength: typeof data === "string" ? data.length : data instanceof ArrayBuffer ? data.byteLength : data instanceof Uint8Array ? data.byteLength : "unknown"
@@ -1405,7 +1077,6 @@ var InlineWebSocketAdapter2 = class {
       this.#eventListeners.set(type, []);
     }
     this.#eventListeners.get(type).push(listener);
-    this.#flushBufferedEvents(type);
   }
   removeEventListener(type, listener) {
     const listeners = this.#eventListeners.get(type);
@@ -1419,24 +1090,19 @@ var InlineWebSocketAdapter2 = class {
   #dispatchEvent(type, event) {
     const listeners = this.#eventListeners.get(type);
     if (listeners && listeners.length > 0) {
-      logger3().debug(
+      logger2().debug(
         `dispatching ${type} event to ${listeners.length} listeners`
       );
       for (const listener of listeners) {
         try {
           listener(event);
         } catch (err) {
-          logger3().error({
+          logger2().error({
             msg: `error in ${type} event listener`,
             error: err
           });
         }
       }
-    } else {
-      logger3().debug({
-        msg: `no ${type} listeners registered, buffering event`
-      });
-      this.#bufferedEvents.push({ type, event });
     }
     switch (type) {
       case "open":
@@ -1444,7 +1110,7 @@ var InlineWebSocketAdapter2 = class {
           try {
             this.#onopen(event);
           } catch (error) {
-            logger3().error({
+            logger2().error({
               msg: "error in onopen handler",
               error
             });
@@ -1456,7 +1122,7 @@ var InlineWebSocketAdapter2 = class {
           try {
             this.#onclose(event);
           } catch (error) {
-            logger3().error({
+            logger2().error({
               msg: "error in onclose handler",
               error
             });
@@ -1468,7 +1134,7 @@ var InlineWebSocketAdapter2 = class {
           try {
             this.#onerror(event);
           } catch (error) {
-            logger3().error({
+            logger2().error({
               msg: "error in onerror handler",
               error
             });
@@ -1480,7 +1146,7 @@ var InlineWebSocketAdapter2 = class {
           try {
             this.#onmessage(event);
           } catch (error) {
-            logger3().error({
+            logger2().error({
               msg: "error in onmessage handler",
               error
             });
@@ -1493,17 +1159,6 @@ var InlineWebSocketAdapter2 = class {
     this.#dispatchEvent(event.type, event);
     return true;
   }
-  #flushBufferedEvents(type) {
-    const eventsToFlush = this.#bufferedEvents.filter(
-      (buffered) => buffered.type === type
-    );
-    this.#bufferedEvents = this.#bufferedEvents.filter(
-      (buffered) => buffered.type !== type
-    );
-    for (const { event } of eventsToFlush) {
-      this.#dispatchEvent(type, event);
-    }
-  }
   #fireOpen() {
     try {
       const event = {
@@ -1513,14 +1168,14 @@ var InlineWebSocketAdapter2 = class {
       };
       this.#dispatchEvent("open", event);
     } catch (err) {
-      logger3().error({ msg: "error in open event", error: err });
+      logger2().error({ msg: "error in open event", error: err });
     }
   }
   #fireClose(event) {
     try {
       this.#dispatchEvent("close", event);
     } catch (err) {
-      logger3().error({ msg: "error in close event", error: err });
+      logger2().error({ msg: "error in close event", error: err });
     }
   }
   #fireError(error) {
@@ -1534,9 +1189,9 @@ var InlineWebSocketAdapter2 = class {
       };
       this.#dispatchEvent("error", event);
     } catch (err) {
-      logger3().error({ msg: "error in error event", error: err });
+      logger2().error({ msg: "error in error event", error: err });
     }
-    logger3().error({ msg: "websocket error", error });
+    logger2().error({ msg: "websocket error", error });
   }
   // Event handler properties with getters/setters
   #onopen = null;
@@ -1570,24 +1225,21 @@ var InlineWebSocketAdapter2 = class {
 };
 
 // src/drivers/engine/actor-driver.ts
-import { Runner } from "@rivetkit/engine-runner";
+import { idToStr, Runner } from "@rivetkit/engine-runner";
 import * as cbor3 from "cbor-x";
-import { streamSSE as streamSSE2 } from "hono/streaming";
+import { streamSSE } from "hono/streaming";
 import { WSContext as WSContext2 } from "hono/ws";
 import invariant3 from "invariant";
 
-// src/drivers/engine/kv.ts
-var KEYS = {
-  PERSIST_DATA: Uint8Array.from([1])
-};
-
 // src/drivers/engine/log.ts
-function logger4() {
+function logger3() {
   return getLogger("driver-engine");
 }
 
 // src/drivers/engine/actor-driver.ts
 var RUNNER_SSE_PING_INTERVAL = 1e3;
+var CONN_MESSAGE_ACK_DEADLINE = 5e3;
+var CONN_BUFFERED_MESSAGE_SIZE_THRESHOLD = 5e5;
 var EngineActorDriver = class {
   #registryConfig;
   #runConfig;
@@ -1602,9 +1254,23 @@ var EngineActorDriver = class {
   #runnerStarted = promiseWithResolvers();
   #runnerStopped = promiseWithResolvers();
   #isRunnerStopped = false;
-  // WebSocket message acknowledgment debouncing
-  #wsAckQueue = /* @__PURE__ */ new Map();
-  #wsAckFlushInterval;
+  // HACK: Track actor stop intent locally since the runner protocol doesn't
+  // pass the stop reason to onActorStop. This will be fixed when the runner
+  // protocol is updated to send the intent directly (see RVT-5284)
+  #actorStopIntent = /* @__PURE__ */ new Map();
+  // Map of conn IDs to message index waiting to be persisted before sending
+  // an ack
+  //
+  // serverMessageIndex is updated and pendingAck is flagged in needed in
+  // onBeforePersistConnect, then the HWS ack message is sent in
+  // onAfterPersistConn. This allows us to track what's about to be written
+  // to storage to prevent race conditions with the serverMessageIndex being
+  // updated while writing the existing state.
+  //
+  // bufferedMessageSize tracks the total bytes received since last persist
+  // to force a saveState when threshold is reached. This is the amount of
+  // data currently buffered on the gateway.
+  #hwsMessageIndex = /* @__PURE__ */ new Map();
   constructor(registryConfig, runConfig, managerDriver, inlineClient) {
     this.#registryConfig = registryConfig;
     this.#runConfig = runConfig;
@@ -1642,147 +1308,24 @@ var EngineActorDriver = class {
       },
       fetch: this.#runnerFetch.bind(this),
       websocket: this.#runnerWebSocket.bind(this),
+      hibernatableWebSocket: {
+        canHibernate: this.#hwsCanHibernate.bind(this)
+      },
       onActorStart: this.#runnerOnActorStart.bind(this),
       onActorStop: this.#runnerOnActorStop.bind(this),
-      logger: getLogger("engine-runner"),
-      getActorHibernationConfig: (actorId, requestId, request) => {
-        var _a;
-        const url = new URL(request.url);
-        const path4 = url.pathname;
-        const actorInstance = this.#runner.getActor(actorId);
-        if (!actorInstance) {
-          logger4().warn({
-            msg: "actor not found in getActorHibernationConfig",
-            actorId
-          });
-          return { enabled: false, lastMsgIndex: void 0 };
-        }
-        const handler = this.#actors.get(actorId);
-        if (!handler) {
-          logger4().warn({
-            msg: "actor handler not found in getActorHibernationConfig",
-            actorId
-          });
-          return { enabled: false, lastMsgIndex: void 0 };
-        }
-        if (!handler.actor) {
-          logger4().warn({
-            msg: "actor not found in getActorHibernationConfig",
-            actorId
-          });
-          return { enabled: false, lastMsgIndex: void 0 };
-        }
-        const hibernatableArray = handler.actor[PERSIST_SYMBOL].hibernatableWebSocket;
-        logger4().debug({
-          msg: "checking hibernatable websockets",
-          requestId: idToStr(requestId),
-          existingHibernatableWebSockets: hibernatableArray.length
-        });
-        const existingWs = hibernatableArray.find(
-          (ws) => arrayBuffersEqual(ws.requestId, requestId)
-        );
-        let hibernationConfig;
-        if (existingWs) {
-          logger4().debug({
-            msg: "found existing hibernatable websocket",
-            requestId: idToStr(requestId),
-            lastMsgIndex: existingWs.msgIndex
-          });
-          hibernationConfig = {
-            enabled: true,
-            lastMsgIndex: Number(existingWs.msgIndex)
-          };
-        } else {
-          logger4().debug({
-            msg: "no existing hibernatable websocket found",
-            requestId: idToStr(requestId)
-          });
-          if (path4 === PATH_CONNECT_WEBSOCKET) {
-            hibernationConfig = {
-              enabled: true,
-              lastMsgIndex: void 0
-            };
-          } else if (path4.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {
-            const definition = lookupInRegistry(
-              this.#registryConfig,
-              actorInstance.config.name
-            );
-            const canHibernatWebSocket = (_a = definition.config.options) == null ? void 0 : _a.canHibernatWebSocket;
-            if (canHibernatWebSocket === true) {
-              hibernationConfig = {
-                enabled: true,
-                lastMsgIndex: void 0
-              };
-            } else if (typeof canHibernatWebSocket === "function") {
-              try {
-                const newPath = truncateRawWebSocketPathPrefix(
-                  url.pathname
-                );
-                const truncatedRequest = new Request(
-                  `http://actor${newPath}`,
-                  request
-                );
-                const canHibernate = canHibernatWebSocket(truncatedRequest);
-                hibernationConfig = {
-                  enabled: canHibernate,
-                  lastMsgIndex: void 0
-                };
-              } catch (error) {
-                logger4().error({
-                  msg: "error calling canHibernatWebSocket",
-                  error
-                });
-                hibernationConfig = {
-                  enabled: false,
-                  lastMsgIndex: void 0
-                };
-              }
-            } else {
-              hibernationConfig = {
-                enabled: false,
-                lastMsgIndex: void 0
-              };
-            }
-          } else {
-            logger4().warn({
-              msg: "unexpected path for getActorHibernationConfig",
-              path: path4
-            });
-            hibernationConfig = {
-              enabled: false,
-              lastMsgIndex: void 0
-            };
-          }
-        }
-        if (existingWs) {
-          logger4().debug({
-            msg: "updated existing hibernatable websocket timestamp",
-            requestId: idToStr(requestId)
-          });
-          existingWs.lastSeenTimestamp = BigInt(Date.now());
-        } else {
-          logger4().debug({
-            msg: "created new hibernatable websocket entry",
-            requestId: idToStr(requestId)
-          });
-          handler.actor[PERSIST_SYMBOL].hibernatableWebSocket.push({
-            requestId,
-            lastSeenTimestamp: BigInt(Date.now()),
-            msgIndex: -1n
-          });
-        }
-        return hibernationConfig;
-      }
+      logger: getLogger("engine-runner")
     };
     this.#runner = new Runner(engineRunnerConfig);
     this.#runner.start();
-    logger4().debug({
+    logger3().debug({
       msg: "engine runner started",
       endpoint: runConfig.endpoint,
       namespace: runConfig.namespace,
       runnerName: runConfig.runnerName
     });
-    this.#wsAckFlushInterval = setInterval(() => this.#flushWsAcks(), 1e3);
+  }
+  getExtraActorLogParams() {
+    return { runnerId: this.#runner.runnerId ?? "-" };
   }
   async #loadActorHandler(actorId) {
     const handler = this.#actors.get(actorId);
@@ -1792,40 +1335,9 @@ var EngineActorDriver = class {
     if (!handler.actor) throw new Error("Actor should be loaded");
     return handler;
   }
-  async loadActor(actorId) {
-    const handler = await this.#loadActorHandler(actorId);
-    if (!handler.actor) throw new Error(`Actor ${actorId} failed to load`);
-    return handler.actor;
-  }
-  #flushWsAcks() {
-    if (this.#wsAckQueue.size === 0) return;
-    for (const {
-      requestIdBuf: requestId,
-      messageIndex: index
-    } of this.#wsAckQueue.values()) {
-      this.#runner.sendWebsocketMessageAck(requestId, index);
-    }
-    this.#wsAckQueue.clear();
-  }
   getContext(actorId) {
     return {};
   }
-  async readPersistedData(actorId) {
-    const handler = this.#actors.get(actorId);
-    if (!handler) throw new Error(`Actor ${actorId} not loaded`);
-    return handler.persistedData;
-  }
-  async writePersistedData(actorId, data) {
-    const handler = this.#actors.get(actorId);
-    if (!handler) throw new Error(`Actor ${actorId} not loaded`);
-    handler.persistedData = data;
-    logger4().debug({
-      msg: "writing persisted data for actor",
-      actorId,
-      dataSize: data.byteLength
-    });
-    await this.#runner.kvPut(actorId, [[KEYS.PERSIST_DATA, data]]);
-  }
   async setAlarm(actor2, timestamp) {
     if (this.#alarmTimeout) {
       this.#alarmTimeout.abort();
@@ -1833,7 +1345,7 @@ var EngineActorDriver = class {
     }
     const delay = Math.max(0, timestamp - Date.now());
     this.#alarmTimeout = setLongTimeout(() => {
-      actor2._onAlarm();
+      actor2.onAlarm();
       this.#alarmTimeout = void 0;
     }, delay);
     this.#runner.setAlarm(actor2.id, timestamp);
@@ -1841,10 +1353,114 @@ var EngineActorDriver = class {
   async getDatabase(_actorId) {
     return void 0;
   }
-  // Runner lifecycle callbacks
+  // MARK: - Batch KV operations
+  async kvBatchPut(actorId, entries) {
+    await this.#runner.kvPut(actorId, entries);
+  }
+  async kvBatchGet(actorId, keys) {
+    return await this.#runner.kvGet(actorId, keys);
+  }
+  async kvBatchDelete(actorId, keys) {
+    await this.#runner.kvDelete(actorId, keys);
+  }
+  async kvList(actorId) {
+    const entries = await this.#runner.kvListPrefix(
+      actorId,
+      new Uint8Array()
+    );
+    const keys = entries.map(([key]) => key);
+    logger3().info({
+      msg: "kvList called",
+      actorId,
+      keysCount: keys.length,
+      keys: keys.map((k) => new TextDecoder().decode(k))
+    });
+    return keys;
+  }
+  async kvListPrefix(actorId, prefix) {
+    const result = await this.#runner.kvListPrefix(actorId, prefix);
+    logger3().info({
+      msg: "kvListPrefix called",
+      actorId,
+      prefixStr: new TextDecoder().decode(prefix),
+      entriesCount: result.length,
+      keys: result.map(([key]) => new TextDecoder().decode(key))
+    });
+    return result;
+  }
+  // MARK: - Actor Lifecycle
+  async loadActor(actorId) {
+    const handler = await this.#loadActorHandler(actorId);
+    if (!handler.actor) throw new Error(`Actor ${actorId} failed to load`);
+    return handler.actor;
+  }
+  startSleep(actorId) {
+    this.#actorStopIntent.set(actorId, "sleep");
+    this.#runner.sleepActor(actorId);
+  }
+  startDestroy(actorId) {
+    this.#actorStopIntent.set(actorId, "destroy");
+    this.#runner.stopActor(actorId);
+  }
+  async shutdownRunner(immediate) {
+    logger3().info({ msg: "stopping engine actor driver", immediate });
+    logger3().debug({
+      msg: "stopping all actors before shutdown",
+      actorCount: this.#actors.size
+    });
+    const stopPromises = [];
+    for (const [_actorId, handler] of this.#actors.entries()) {
+      if (handler.actor) {
+        stopPromises.push(
+          handler.actor.onStop("sleep").catch((err) => {
+            var _a;
+            (_a = handler.actor) == null ? void 0 : _a.rLog.error({
+              msg: "onStop errored",
+              error: stringifyError(err)
+            });
+          })
+        );
+      }
+    }
+    await Promise.all(stopPromises);
+    logger3().debug({ msg: "all actors stopped" });
+    await this.#runner.shutdown(immediate);
+  }
+  async serverlessHandleStart(c) {
+    return streamSSE(c, async (stream) => {
+      stream.onAbort(() => {
+      });
+      c.req.raw.signal.addEventListener("abort", () => {
+        logger3().debug("SSE aborted, shutting down runner");
+        this.shutdownRunner(false);
+      });
+      await this.#runnerStarted.promise;
+      const payload = this.#runner.getServerlessInitPacket();
+      invariant3(payload, "runnerId not set");
+      await stream.writeSSE({ data: payload });
+      while (true) {
+        if (this.#isRunnerStopped) {
+          logger3().debug({
+            msg: "runner is stopped"
+          });
+          break;
+        }
+        if (stream.closed || stream.aborted) {
+          logger3().debug({
+            msg: "runner sse stream closed",
+            closed: stream.closed,
+            aborted: stream.aborted
+          });
+          break;
+        }
+        await stream.writeSSE({ event: "ping", data: "" });
+        await stream.sleep(RUNNER_SSE_PING_INTERVAL);
+      }
+      await this.#runnerStopped.promise;
+    });
+  }
   async #runnerOnActorStart(actorId, generation, actorConfig) {
-    var _a, _b;
-    logger4().debug({
+    logger3().debug({
       msg: "runner actor starting",
       actorId,
       name: actorConfig.name,
@@ -1858,24 +1474,30 @@ var EngineActorDriver = class {
     let handler = this.#actors.get(actorId);
     if (!handler) {
       handler = {
-        actorStartPromise: promiseWithResolvers(),
-        persistedData: void 0
+        actorStartPromise: promiseWithResolvers()
       };
       this.#actors.set(actorId, handler);
-      const [persistedValue] = await this.#runner.kvGet(actorId, [
-        KEYS.PERSIST_DATA
-      ]);
-      handler.persistedData = persistedValue !== null ? persistedValue : serializeEmptyPersistData(input);
-      logger4().debug({
-        msg: "loaded persisted data for actor",
-        actorId,
-        dataSize: (_a = handler.persistedData) == null ? void 0 : _a.byteLength,
-        wasInStorage: persistedValue !== null
-      });
     }
     const name = actorConfig.name;
     invariant3(actorConfig.key, "actor should have a key");
     const key = deserializeActorKey(actorConfig.key);
+    const [persistDataBuffer] = await this.#runner.kvGet(actorId, [
+      KEYS.PERSIST_DATA
+    ]);
+    if (persistDataBuffer === null) {
+      const initialKvState = getInitialActorKvState(input);
+      await this.#runner.kvPut(actorId, initialKvState);
+      logger3().debug({
+        msg: "initialized persist data for new actor",
+        actorId
+      });
+    } else {
+      logger3().debug({
+        msg: "found existing persist data for actor",
+        actorId,
+        dataSize: persistDataBuffer.byteLength
+      });
+    }
     const definition = lookupInRegistry(
       this.#registryConfig,
       actorConfig.name
@@ -1890,28 +1512,29 @@ var EngineActorDriver = class {
       "unknown"
       // TODO: Add regions
     );
-    (_b = handler.actorStartPromise) == null ? void 0 : _b.resolve();
-    handler.actorStartPromise = void 0;
-    logger4().debug({ msg: "runner actor started", actorId, name, key });
+    logger3().debug({ msg: "runner actor started", actorId, name, key });
   }
   async #runnerOnActorStop(actorId, generation) {
-    logger4().debug({ msg: "runner actor stopping", actorId, generation });
+    logger3().debug({ msg: "runner actor stopping", actorId, generation });
+    const reason = this.#actorStopIntent.get(actorId) ?? "sleep";
+    this.#actorStopIntent.delete(actorId);
     const handler = this.#actors.get(actorId);
     if (handler == null ? void 0 : handler.actor) {
       try {
-        await handler.actor._onStop();
+        await handler.actor.onStop(reason);
       } catch (err) {
-        logger4().error({
-          msg: "error in _onStop, proceeding with removing actor",
+        logger3().error({
+          msg: "error in onStop, proceeding with removing actor",
           err: stringifyError(err)
         });
       }
       this.#actors.delete(actorId);
     }
-    logger4().debug({ msg: "runner actor stopped", actorId });
+    logger3().debug({ msg: "runner actor stopped", actorId, reason });
   }
-  async #runnerFetch(_runner, actorId, _requestIdBuf, request) {
-    logger4().debug({
+  // MARK: - Runner Networking
+  async #runnerFetch(_runner, actorId, _gatewayIdBuf, _requestIdBuf, request) {
+    logger3().debug({
       msg: "runner fetch",
       actorId,
       url: request.url,
@@ -1919,183 +1542,302 @@ var EngineActorDriver = class {
     });
     return await this.#actorRouter.fetch(request, { actorId });
   }
-  async #runnerWebSocket(_runner, actorId, websocketRaw, requestIdBuf, request) {
+  async #runnerWebSocket(_runner, actorId, websocketRaw, gatewayIdBuf, requestIdBuf, request, requestPath, requestHeaders, isHibernatable, isRestoringHibernatable) {
+    var _a, _b, _c, _d;
     const websocket = websocketRaw;
-    const requestId = idToStr(requestIdBuf);
-    logger4().debug({ msg: "runner websocket", actorId, url: request.url });
-    const url = new URL(request.url);
+    const wsUniqueId = `ws_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    websocket.__rivet_ws_id = wsUniqueId;
+    logger3().debug({
+      msg: "runner websocket",
+      actorId,
+      url: request.url,
+      isRestoringHibernatable,
+      websocketObjectId: websocketRaw ? Object.prototype.toString.call(websocketRaw) : "null",
+      websocketType: (_a = websocketRaw == null ? void 0 : websocketRaw.constructor) == null ? void 0 : _a.name,
+      wsUniqueId,
+      websocketProps: websocketRaw ? Object.keys(websocketRaw).join(", ") : "null"
+    });
     const protocols = request.headers.get("sec-websocket-protocol");
-    let encodingRaw;
-    let connParamsRaw;
-    if (protocols) {
-      const protocolList = protocols.split(",").map((p) => p.trim());
-      for (const protocol of protocolList) {
-        if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
-          encodingRaw = protocol.substring(
-            WS_PROTOCOL_ENCODING.length
-          );
-        } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
-          connParamsRaw = decodeURIComponent(
-            protocol.substring(WS_PROTOCOL_CONN_PARAMS.length)
-          );
-        }
-      }
-    }
-    const encoding = EncodingSchema.parse(encodingRaw);
-    const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
-    let wsHandlerPromise;
-    if (url.pathname === PATH_CONNECT_WEBSOCKET) {
-      wsHandlerPromise = handleWebSocketConnect(
+    const { encoding, connParams } = parseWebSocketProtocols(protocols);
+    let wsHandler;
+    try {
+      wsHandler = await routeWebSocket(
         request,
+        requestPath,
+        requestHeaders,
         this.#runConfig,
         this,
         actorId,
         encoding,
         connParams,
-        requestId,
+        gatewayIdBuf,
         requestIdBuf,
-        // Extract connId and connToken from protocols if needed
-        void 0,
-        void 0
+        isHibernatable,
+        isRestoringHibernatable
       );
-    } else if (url.pathname.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {
-      wsHandlerPromise = handleRawWebSocketHandler(
-        request,
-        url.pathname + url.search,
-        this,
-        actorId,
-        requestIdBuf
-      );
-    } else {
-      throw new Error(`Unreachable path: ${url.pathname}`);
+    } catch (err) {
+      logger3().error({ msg: "building websocket handlers errored", err });
+      websocketRaw.close(1011, "ws.route_error");
+      return;
     }
+    websocket.raw = websocket;
     const wsContext = new WSContext2(websocket);
-    wsHandlerPromise.catch((err) => {
-      logger4().error({ msg: "building websocket handlers errored", err });
-      wsContext.close(1011, `${err}`);
+    const conn = wsHandler.conn;
+    const actor2 = wsHandler.actor;
+    const connStateManager = conn == null ? void 0 : conn[CONN_STATE_MANAGER_SYMBOL];
+    logger3().debug({
+      msg: "attaching websocket event listeners",
+      actorId,
+      connId: conn == null ? void 0 : conn.id,
+      wsUniqueId: websocket.__rivet_ws_id,
+      isRestoringHibernatable,
+      websocketType: (_b = websocket == null ? void 0 : websocket.constructor) == null ? void 0 : _b.name
     });
-    if (websocket.readyState === 1) {
-      wsHandlerPromise.then(
-        (x) => {
-          var _a;
-          return (_a = x.onOpen) == null ? void 0 : _a.call(x, new Event("open"), wsContext);
-        }
-      );
-    } else {
-      websocket.addEventListener("open", (event) => {
-        wsHandlerPromise.then((x) => {
-          var _a;
-          return (_a = x.onOpen) == null ? void 0 : _a.call(x, event, wsContext);
-        });
-      });
+    if (isRestoringHibernatable) {
+      (_c = wsHandler.onRestore) == null ? void 0 : _c.call(wsHandler, wsContext);
     }
+    websocket.addEventListener("open", (event) => {
+      wsHandler.onOpen(event, wsContext);
+    });
     websocket.addEventListener("message", (event) => {
-      wsHandlerPromise.then((x) => {
-        var _a;
-        return (_a = x.onMessage) == null ? void 0 : _a.call(x, event, wsContext);
+      var _a2, _b2;
+      logger3().debug({
+        msg: "websocket message event listener triggered",
+        connId: conn == null ? void 0 : conn.id,
+        actorId: actor2 == null ? void 0 : actor2.id,
+        messageIndex: event.rivetMessageIndex,
+        hasWsHandler: !!wsHandler,
+        hasOnMessage: !!(wsHandler == null ? void 0 : wsHandler.onMessage),
+        actorIsStopping: actor2 == null ? void 0 : actor2.isStopping,
+        websocketType: (_a2 = websocket == null ? void 0 : websocket.constructor) == null ? void 0 : _a2.name,
+        wsUniqueId: websocket.__rivet_ws_id,
+        eventTargetWsId: (_b2 = event.target) == null ? void 0 : _b2.__rivet_ws_id
       });
-      invariant3(event.rivetRequestId, "missing rivetRequestId");
-      invariant3(event.rivetMessageIndex, "missing rivetMessageIndex");
-      const currentEntry = this.#wsAckQueue.get(requestId);
-      if (currentEntry) {
-        if (event.rivetMessageIndex > currentEntry.messageIndex) {
-          currentEntry.messageIndex = event.rivetMessageIndex;
+      if (actor2 == null ? void 0 : actor2.isStopping) {
+        logger3().debug({
+          msg: "ignoring ws message, actor is stopping",
+          connId: conn == null ? void 0 : conn.id,
+          actorId: actor2 == null ? void 0 : actor2.id,
+          messageIndex: event.rivetMessageIndex
+        });
+        return;
+      }
+      logger3().debug({
+        msg: "calling wsHandler.onMessage",
+        connId: conn == null ? void 0 : conn.id,
+        messageIndex: event.rivetMessageIndex
+      });
+      wsHandler.onMessage(event, wsContext);
+      const hibernate = connStateManager == null ? void 0 : connStateManager.hibernatableData;
+      if (hibernate && conn && actor2) {
+        invariant3(
+          typeof event.rivetMessageIndex === "number",
+          "missing event.rivetMessageIndex"
+        );
+        const previousMsgIndex = hibernate.serverMessageIndex;
+        hibernate.serverMessageIndex = event.rivetMessageIndex;
+        logger3().info({
+          msg: "persisting message index",
+          connId: conn.id,
+          previousMsgIndex,
+          newMsgIndex: event.rivetMessageIndex
+        });
+        const entry = this.#hwsMessageIndex.get(conn.id);
+        if (entry) {
+          const messageLength = getValueLength(event.data);
+          entry.bufferedMessageSize += messageLength;
+          if (entry.bufferedMessageSize >= CONN_BUFFERED_MESSAGE_SIZE_THRESHOLD) {
+            entry.bufferedMessageSize = 0;
+            entry.pendingAckFromBufferSize = true;
+            actor2.stateManager.saveState({
+              immediate: true
+            });
+          } else {
+            actor2.stateManager.saveState({
+              maxWait: CONN_MESSAGE_ACK_DEADLINE
+            });
+          }
         } else {
-          logger4().warn({
-            msg: "received lower index than ack queue for message",
-            requestId,
-            queuedMessageIndex: currentEntry,
-            eventMessageIndex: event.rivetMessageIndex
+          actor2.stateManager.saveState({
+            maxWait: CONN_MESSAGE_ACK_DEADLINE
           });
         }
-      } else {
-        this.#wsAckQueue.set(requestId, {
-          requestIdBuf,
-          messageIndex: event.rivetMessageIndex
-        });
       }
     });
     websocket.addEventListener("close", (event) => {
-      this.#flushWsAcks();
-      wsHandlerPromise.then((x) => {
-        var _a;
-        return (_a = x.onClose) == null ? void 0 : _a.call(x, event, wsContext);
-      });
+      wsHandler.onClose(event, wsContext);
     });
     websocket.addEventListener("error", (event) => {
-      wsHandlerPromise.then((x) => {
-        var _a;
-        return (_a = x.onError) == null ? void 0 : _a.call(x, event, wsContext);
-      });
-    });
-  }
-  startSleep(actorId) {
-    this.#runner.sleepActor(actorId);
-  }
-  async shutdownRunner(immediate) {
-    logger4().info({ msg: "stopping engine actor driver", immediate });
-    logger4().debug({
-      msg: "stopping all actors before shutdown",
-      actorCount: this.#actors.size
+      wsHandler.onError(event, wsContext);
     });
-    const stopPromises = [];
-    for (const [_actorId, handler] of this.#actors.entries()) {
-      if (handler.actor) {
-        stopPromises.push(
-          handler.actor._onStop().catch((err) => {
-            var _a;
-            (_a = handler.actor) == null ? void 0 : _a.rLog.error({
-              msg: "_onStop errored",
-              error: stringifyError(err)
-            });
-          })
-        );
-      }
-    }
-    await Promise.all(stopPromises);
-    logger4().debug({ msg: "all actors stopped" });
-    if (this.#wsAckFlushInterval) {
-      clearInterval(this.#wsAckFlushInterval);
-      this.#wsAckFlushInterval = void 0;
+    if (isRestoringHibernatable) {
+      logger3().info({
+        msg: "event listeners attached to restored websocket",
+        actorId,
+        connId: conn == null ? void 0 : conn.id,
+        gatewayId: idToStr(gatewayIdBuf),
+        requestId: idToStr(requestIdBuf),
+        websocketType: (_d = websocket == null ? void 0 : websocket.constructor) == null ? void 0 : _d.name,
+        hasMessageListener: !!websocket.addEventListener
+      });
     }
-    this.#flushWsAcks();
-    await this.#runner.shutdown(immediate);
   }
-  async serverlessHandleStart(c) {
-    return streamSSE2(c, async (stream) => {
-      stream.onAbort(() => {
+  // MARK: - Hibernating WebSockets
+  #hwsCanHibernate(actorId, gatewayId, requestId, request) {
+    var _a;
+    const url = new URL(request.url);
+    const path = url.pathname;
+    const actorInstance = this.#runner.getActor(actorId);
+    if (!actorInstance) {
+      logger3().warn({
+        msg: "actor not found in #hwsCanHibernate",
+        actorId
       });
-      c.req.raw.signal.addEventListener("abort", () => {
-        logger4().debug("SSE aborted, shutting down runner");
-        this.shutdownRunner(false);
+      return false;
+    }
+    const handler = this.#actors.get(actorId);
+    if (!handler) {
+      logger3().warn({
+        msg: "actor handler not found in #hwsCanHibernate",
+        actorId
       });
-      await this.#runnerStarted.promise;
-      const payload = this.#runner.getServerlessInitPacket();
-      invariant3(payload, "runnerId not set");
-      await stream.writeSSE({ data: payload });
-      while (true) {
-        if (this.#isRunnerStopped) {
-          logger4().debug({
-            msg: "runner is stopped"
-          });
-          break;
-        }
-        if (stream.closed || stream.aborted) {
-          logger4().debug({
-            msg: "runner sse stream closed",
-            closed: stream.closed,
-            aborted: stream.aborted
+      return false;
+    }
+    if (!handler.actor) {
+      logger3().warn({
+        msg: "actor not found in #hwsCanHibernate",
+        actorId
+      });
+      return false;
+    }
+    logger3().debug({
+      msg: "no existing hibernatable websocket found",
+      gatewayId: idToStr(gatewayId),
+      requestId: idToStr(requestId)
+    });
+    if (path === PATH_CONNECT) {
+      return true;
+    } else if (path === PATH_WEBSOCKET_BASE || path.startsWith(PATH_WEBSOCKET_PREFIX)) {
+      const definition = lookupInRegistry(
+        this.#registryConfig,
+        actorInstance.config.name
+      );
+      const canHibernateWebSocket = (_a = definition.config.options) == null ? void 0 : _a.canHibernateWebSocket;
+      if (canHibernateWebSocket === true) {
+        return true;
+      } else if (typeof canHibernateWebSocket === "function") {
+        try {
+          const newPath = truncateRawWebSocketPathPrefix(
+            url.pathname
+          );
+          const truncatedRequest = new Request(
+            `http://actor${newPath}`,
+            request
+          );
+          const canHibernate = canHibernateWebSocket(truncatedRequest);
+          return canHibernate;
+        } catch (error) {
+          logger3().error({
+            msg: "error calling canHibernateWebSocket",
+            error
           });
-          break;
+          return false;
         }
-        await stream.writeSSE({ event: "ping", data: "" });
-        await stream.sleep(RUNNER_SSE_PING_INTERVAL);
+      } else {
+        return false;
       }
-      await this.#runnerStopped.promise;
+    } else if (path === PATH_INSPECTOR_CONNECT) {
+      return false;
+    } else {
+      logger3().warn({
+        msg: "unexpected path for getActorHibernationConfig",
+        path
+      });
+      return false;
+    }
+  }
+  async #hwsLoadAll(actorId) {
+    const actor2 = await this.loadActor(actorId);
+    return actor2.conns.values().map((conn) => {
+      const connStateManager = conn[CONN_STATE_MANAGER_SYMBOL];
+      const hibernatable = connStateManager.hibernatableData;
+      if (!hibernatable) return void 0;
+      return {
+        gatewayId: hibernatable.gatewayId,
+        requestId: hibernatable.requestId,
+        serverMessageIndex: hibernatable.serverMessageIndex,
+        clientMessageIndex: hibernatable.clientMessageIndex,
+        path: hibernatable.requestPath,
+        headers: hibernatable.requestHeaders
+      };
+    }).filter((x) => x !== void 0).toArray();
+  }
+  async onBeforeActorStart(actor2) {
+    var _a;
+    const handler = this.#actors.get(actor2.id);
+    invariant3(handler, "missing actor handler in onBeforeActorReady");
+    (_a = handler.actorStartPromise) == null ? void 0 : _a.resolve();
+    handler.actorStartPromise = void 0;
+    const metaEntries = await this.#hwsLoadAll(actor2.id);
+    await this.#runner.restoreHibernatingRequests(actor2.id, metaEntries);
+  }
+  onCreateConn(conn) {
+    const hibernatable = conn[CONN_STATE_MANAGER_SYMBOL].hibernatableData;
+    if (!hibernatable) return;
+    this.#hwsMessageIndex.set(conn.id, {
+      serverMessageIndex: hibernatable.serverMessageIndex,
+      bufferedMessageSize: 0,
+      pendingAckFromMessageIndex: false,
+      pendingAckFromBufferSize: false
+    });
+    logger3().debug({
+      msg: "created #hwsMessageIndex entry",
+      connId: conn.id,
+      serverMessageIndex: hibernatable.serverMessageIndex
     });
   }
-  getExtraActorLogParams() {
-    return { runnerId: this.#runner.runnerId ?? "-" };
+  onDestroyConn(conn) {
+    this.#hwsMessageIndex.delete(conn.id);
+    logger3().debug({
+      msg: "removed #hwsMessageIndex entry",
+      connId: conn.id
+    });
+  }
+  onBeforePersistConn(conn) {
+    const stateManager = conn[CONN_STATE_MANAGER_SYMBOL];
+    const hibernatable = stateManager.hibernatableDataOrError();
+    const entry = this.#hwsMessageIndex.get(conn.id);
+    if (!entry) {
+      logger3().warn({
+        msg: "missing EngineActorDriver.#hwsMessageIndex entry for conn",
+        connId: conn.id
+      });
+      return;
+    }
+    entry.pendingAckFromMessageIndex = hibernatable.serverMessageIndex > entry.serverMessageIndex;
+    entry.serverMessageIndex = hibernatable.serverMessageIndex;
+  }
+  onAfterPersistConn(conn) {
+    const stateManager = conn[CONN_STATE_MANAGER_SYMBOL];
+    const hibernatable = stateManager.hibernatableDataOrError();
+    const entry = this.#hwsMessageIndex.get(conn.id);
+    if (!entry) {
+      logger3().warn({
+        msg: "missing EngineActorDriver.#hwsMessageIndex entry for conn",
+        connId: conn.id
+      });
+      return;
+    }
+    if (entry.pendingAckFromMessageIndex || entry.pendingAckFromBufferSize) {
+      this.#runner.sendHibernatableWebSocketMessageAck(
+        hibernatable.gatewayId,
+        hibernatable.requestId,
+        entry.serverMessageIndex
+      );
+      entry.pendingAckFromMessageIndex = false;
+      entry.pendingAckFromBufferSize = false;
+      entry.bufferedMessageSize = 0;
+    }
   }
 };
 
@@ -2117,6 +1859,117 @@ function createEngineDriver() {
   };
 }
 
+// src/utils/node.ts
+import { createRequire } from "module";
+var nodeCrypto;
+var nodeFsSync;
+var nodeFs;
+var nodePath;
+var nodeOs;
+var nodeChildProcess;
+var nodeStream;
+var hasImportedDependencies = false;
+function getRequireFn() {
+  return createRequire(import.meta.url);
+}
+function importNodeDependencies() {
+  if (hasImportedDependencies) return;
+  try {
+    const requireFn = getRequireFn();
+    nodeCrypto = requireFn(
+      /* webpackIgnore: true */
+      "node:crypto"
+    );
+    nodeFsSync = requireFn(
+      /* webpackIgnore: true */
+      "node:fs"
+    );
+    nodeFs = requireFn(
+      /* webpackIgnore: true */
+      "node:fs/promises"
+    );
+    nodePath = requireFn(
+      /* webpackIgnore: true */
+      "node:path"
+    );
+    nodeOs = requireFn(
+      /* webpackIgnore: true */
+      "node:os"
+    );
+    nodeChildProcess = requireFn(
+      /* webpackIgnore: true */
+      "node:child_process"
+    );
+    nodeStream = requireFn(
+      /* webpackIgnore: true */
+      "node:stream/promises"
+    );
+    hasImportedDependencies = true;
+  } catch (err) {
+    console.warn(
+      "Node.js modules not available, file system driver will not work",
+      err
+    );
+    throw err;
+  }
+}
+function getNodeCrypto() {
+  if (!nodeCrypto) {
+    throw new Error(
+      "Node crypto module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeCrypto;
+}
+function getNodeFsSync() {
+  if (!nodeFsSync) {
+    throw new Error(
+      "Node fs module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeFsSync;
+}
+function getNodeFs() {
+  if (!nodeFs) {
+    throw new Error(
+      "Node fs/promises module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeFs;
+}
+function getNodePath() {
+  if (!nodePath) {
+    throw new Error(
+      "Node path module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodePath;
+}
+function getNodeOs() {
+  if (!nodeOs) {
+    throw new Error(
+      "Node os module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeOs;
+}
+function getNodeChildProcess() {
+  if (!nodeChildProcess) {
+    throw new Error(
+      "Node child_process module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeChildProcess;
+}
+function getNodeStream() {
+  if (!nodeStream) {
+    throw new Error(
+      "Node stream/promises module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeStream;
+}
+
 // src/drivers/file-system/actor.ts
 var FileSystemActorDriver = class {
   #registryConfig;
@@ -2149,17 +2002,17 @@ var FileSystemActorDriver = class {
   getContext(_actorId) {
     return {};
   }
-  async readPersistedData(actorId) {
-    return new Uint8Array(
-      (await this.#state.loadActorStateOrError(actorId)).persistedData
-    );
+  async kvBatchPut(actorId, entries) {
+    await this.#state.kvBatchPut(actorId, entries);
   }
-  async writePersistedData(actorId, data) {
-    const state = await this.#state.loadActorStateOrError(actorId);
-    await this.#state.writeActor(actorId, {
-      ...state,
-      persistedData: bufferToArrayBuffer(data)
-    });
+  async kvBatchGet(actorId, keys) {
+    return await this.#state.kvBatchGet(actorId, keys);
+  }
+  async kvBatchDelete(actorId, keys) {
+    await this.#state.kvBatchDelete(actorId, keys);
+  }
+  async kvListPrefix(actorId, prefix) {
+    return await this.#state.kvListPrefix(actorId, prefix);
   }
   async setAlarm(actor2, timestamp) {
     await this.#state.setActorAlarm(actor2.id, timestamp);
@@ -2170,18 +2023,27 @@ var FileSystemActorDriver = class {
   startSleep(actorId) {
     this.#state.sleepActor(actorId);
   }
+  async startDestroy(actorId) {
+    await this.#state.destroyActor(actorId);
+  }
 };
 
 // src/drivers/file-system/global-state.ts
-import * as crypto3 from "crypto";
-import * as fsSync2 from "fs";
-import * as fs2 from "fs/promises";
-import * as path2 from "path";
 import invariant4 from "invariant";
 
-// dist/schemas/file-system-driver/v1.ts
+// dist/schemas/file-system-driver/v2.ts
 import * as bare from "@bare-ts/lib";
 var config = /* @__PURE__ */ bare.Config({});
+function readActorKvEntry(bc) {
+  return {
+    key: bare.readData(bc),
+    value: bare.readData(bc)
+  };
+}
+function writeActorKvEntry(bc, x) {
+  bare.writeData(bc, x.key);
+  bare.writeData(bc, x.value);
+}
 function read0(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
@@ -2199,12 +2061,29 @@ function write0(bc, x) {
     bare.writeString(bc, x[i]);
   }
 }
+function read1(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readActorKvEntry(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readActorKvEntry(bc);
+  }
+  return result;
+}
+function write1(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeActorKvEntry(bc, x[i]);
+  }
+}
 function readActorState(bc) {
   return {
     actorId: bare.readString(bc),
     name: bare.readString(bc),
     key: read0(bc),
-    persistedData: bare.readData(bc),
+    kvStorage: read1(bc),
     createdAt: bare.readU64(bc)
   };
 }
@@ -2212,7 +2091,7 @@ function writeActorState(bc, x) {
   bare.writeString(bc, x.actorId);
   bare.writeString(bc, x.name);
   write0(bc, x.key);
-  bare.writeData(bc, x.persistedData);
+  write1(bc, x.kvStorage);
   bare.writeU64(bc, x.createdAt);
 }
 function encodeActorState(x) {
@@ -2259,8 +2138,29 @@ function decodeActorAlarm(bytes) {
 }
 
 // src/schemas/file-system-driver/versioned.ts
-var CURRENT_VERSION = 1;
-var migrations = /* @__PURE__ */ new Map();
+var CURRENT_VERSION = 2;
+var migrations = /* @__PURE__ */ new Map([
+  [
+    2,
+    (v1State) => {
+      const kvStorage = [];
+      if (v1State.persistedData) {
+        const key = new Uint8Array([1]);
+        kvStorage.push({
+          key: bufferToArrayBuffer(key),
+          value: v1State.persistedData
+        });
+      }
+      return {
+        actorId: v1State.actorId,
+        name: v1State.name,
+        key: v1State.key,
+        kvStorage,
+        createdAt: v1State.createdAt
+      };
+    }
+  ]
+]);
 var ACTOR_STATE_VERSIONED = createVersionedDataHandler({
   currentVersion: CURRENT_VERSION,
   migrations,
@@ -2275,36 +2175,35 @@ var ACTOR_ALARM_VERSIONED = createVersionedDataHandler({
 });
 
 // src/drivers/file-system/log.ts
-function logger5() {
+function logger4() {
   return getLogger("driver-fs");
 }
 
 // src/drivers/file-system/utils.ts
-import * as crypto2 from "crypto";
-import * as fsSync from "fs";
-import * as fs from "fs/promises";
-import * as os from "os";
-import * as path from "path";
 function generateActorId(name, key) {
   const jsonString = JSON.stringify([name, key]);
+  const crypto2 = getNodeCrypto();
   const hash = crypto2.createHash("sha256").update(jsonString).digest("hex").substring(0, 16);
   return hash;
 }
 function createHashForPath(dirPath) {
+  const path = getNodePath();
   const normalizedPath = path.normalize(dirPath);
   const lastComponent = path.basename(normalizedPath);
+  const crypto2 = getNodeCrypto();
   const hash = crypto2.createHash("sha256").update(normalizedPath).digest("hex").substring(0, 8);
   return `${lastComponent}-${hash}`;
 }
-function getStoragePath(customPath) {
+function getStoragePath() {
   const dataPath = getDataPath("rivetkit");
-  const pathToHash = customPath || process.cwd();
-  const dirHash = createHashForPath(pathToHash);
+  const dirHash = createHashForPath(process.cwd());
+  const path = getNodePath();
   return path.join(dataPath, dirHash);
 }
-async function pathExists(path4) {
+async function pathExists(path) {
   try {
-    await fs.access(path4);
+    const fs = getNodeFs();
+    await fs.access(path);
     return true;
   } catch {
     return false;
@@ -2312,17 +2211,21 @@ async function pathExists(path4) {
 }
 async function ensureDirectoryExists(directoryPath) {
   if (!await pathExists(directoryPath)) {
+    const fs = getNodeFs();
     await fs.mkdir(directoryPath, { recursive: true });
   }
 }
 function ensureDirectoryExistsSync(directoryPath) {
+  const fsSync = getNodeFsSync();
   if (!fsSync.existsSync(directoryPath)) {
     fsSync.mkdirSync(directoryPath, { recursive: true });
   }
 }
 function getDataPath(appName) {
   const platform = process.platform;
+  const os = getNodeOs();
   const homeDir = os.homedir();
+  const path = getNodePath();
   switch (platform) {
     case "win32":
       return path.join(
@@ -2351,6 +2254,9 @@ var FileSystemGlobalState = class {
   #dbsDir;
   #alarmsDir;
   #persist;
+  // IMPORTANT: Never delete from this map. Doing so will result in race
+  // conditions since the actor generation will cease to be tracked
+  // correctly. Always increment generation if a new actor is created.
   #actors = /* @__PURE__ */ new Map();
   #actorCountOnStartup = 0;
   #runnerParams;
@@ -2365,21 +2271,23 @@ var FileSystemGlobalState = class {
   }
   constructor(persist = true, customPath) {
     this.#persist = persist;
-    this.#storagePath = persist ? getStoragePath(customPath) : "/tmp";
-    this.#stateDir = path2.join(this.#storagePath, "state");
-    this.#dbsDir = path2.join(this.#storagePath, "databases");
-    this.#alarmsDir = path2.join(this.#storagePath, "alarms");
+    this.#storagePath = persist ? customPath ?? getStoragePath() : "/tmp";
+    const path = getNodePath();
+    this.#stateDir = path.join(this.#storagePath, "state");
+    this.#dbsDir = path.join(this.#storagePath, "databases");
+    this.#alarmsDir = path.join(this.#storagePath, "alarms");
     if (this.#persist) {
       ensureDirectoryExistsSync(this.#stateDir);
       ensureDirectoryExistsSync(this.#dbsDir);
       ensureDirectoryExistsSync(this.#alarmsDir);
       try {
-        const actorIds = fsSync2.readdirSync(this.#stateDir);
+        const fsSync = getNodeFsSync();
+        const actorIds = fsSync.readdirSync(this.#stateDir);
         this.#actorCountOnStartup = actorIds.length;
       } catch (error) {
-        logger5().error({ msg: "failed to count actors", error });
+        logger4().error({ msg: "failed to count actors", error });
       }
-      logger5().debug({
+      logger4().debug({
         msg: "file system driver ready",
         dir: this.#storagePath,
         actorCount: this.#actorCountOnStartup
@@ -2387,28 +2295,29 @@ var FileSystemGlobalState = class {
       try {
         this.#cleanupTempFilesSync();
       } catch (err) {
-        logger5().error({
+        logger4().error({
           msg: "failed to cleanup temp files",
           error: err
         });
       }
     } else {
-      logger5().debug({ msg: "memory driver ready" });
+      logger4().debug({ msg: "memory driver ready" });
     }
   }
   getActorStatePath(actorId) {
-    return path2.join(this.#stateDir, actorId);
+    return getNodePath().join(this.#stateDir, actorId);
   }
   getActorDbPath(actorId) {
-    return path2.join(this.#dbsDir, `${actorId}.db`);
+    return getNodePath().join(this.#dbsDir, `${actorId}.db`);
   }
   getActorAlarmPath(actorId) {
-    return path2.join(this.#alarmsDir, actorId);
+    return getNodePath().join(this.#alarmsDir, actorId);
   }
   async *getActorsIterator(params) {
     let actorIds = Array.from(this.#actors.keys()).sort();
-    if (fsSync2.existsSync(this.#stateDir)) {
-      actorIds = fsSync2.readdirSync(this.#stateDir).filter((id) => !id.includes(".tmp")).sort();
+    const fsSync = getNodeFsSync();
+    if (fsSync.existsSync(this.#stateDir)) {
+      actorIds = fsSync.readdirSync(this.#stateDir).filter((id) => !id.includes(".tmp")).sort();
     }
     const startIndex = params.cursor ? actorIds.indexOf(params.cursor) + 1 : 0;
     for (let i = startIndex; i < actorIds.length; i++) {
@@ -2420,7 +2329,7 @@ var FileSystemGlobalState = class {
         const state = await this.loadActorStateOrError(actorId);
         yield state;
       } catch (error) {
-        logger5().error({
+        logger4().error({
           msg: "failed to load actor state",
           actorId,
           error
@@ -2440,7 +2349,8 @@ var FileSystemGlobalState = class {
     }
     entry = {
       id: actorId,
-      removed: false
+      lifecycleState: 0 /* NONEXISTENT */,
+      generation: crypto.randomUUID()
     };
     this.#actors.set(actorId, entry);
     return entry;
@@ -2449,20 +2359,34 @@ var FileSystemGlobalState = class {
    * Creates a new actor and writes to file system.
    */
   async createActor(actorId, name, key, input) {
-    if (this.#actors.has(actorId)) {
-      throw new ActorAlreadyExists(name, key);
-    }
     const entry = this.#upsertEntry(actorId);
+    if (entry.state) {
+      throw new ActorDuplicateKey(name, key);
+    }
+    if (this.isActorStopping(actorId)) {
+      throw new Error(`Actor ${actorId} is stopping`);
+    }
+    if (entry.lifecycleState === 4 /* DESTROYED */) {
+      entry.lifecycleState = 0 /* NONEXISTENT */;
+      entry.generation = crypto.randomUUID();
+    }
+    const kvStorage = [];
+    const initialKvState = getInitialActorKvState(input);
+    for (const [key2, value] of initialKvState) {
+      kvStorage.push({
+        key: bufferToArrayBuffer(key2),
+        value: bufferToArrayBuffer(value)
+      });
+    }
     entry.state = {
       actorId,
       name,
       key,
       createdAt: BigInt(Date.now()),
-      persistedData: bufferToArrayBuffer(
-        serializeEmptyPersistData(input)
-      )
+      kvStorage
     };
-    await this.writeActor(actorId, entry.state);
+    entry.lifecycleState = 1 /* AWAKE */;
+    await this.writeActor(actorId, entry.generation, entry.state);
     return entry;
   }
   /**
@@ -2470,6 +2394,9 @@ var FileSystemGlobalState = class {
    */
   async loadActor(actorId) {
     const entry = this.#upsertEntry(actorId);
+    if (entry.lifecycleState === 4 /* DESTROYED */) {
+      return entry;
+    }
     if (entry.state) {
       return entry;
     }
@@ -2486,7 +2413,8 @@ var FileSystemGlobalState = class {
   async loadActorState(entry) {
     const stateFilePath = this.getActorStatePath(entry.id);
     try {
-      const stateData = await fs2.readFile(stateFilePath);
+      const fs = getNodeFs();
+      const stateData = await fs.readFile(stateFilePath);
       entry.state = ACTOR_STATE_VERSIONED.deserializeWithEmbeddedVersion(
         new Uint8Array(stateData)
       );
@@ -2505,16 +2433,29 @@ var FileSystemGlobalState = class {
   async loadOrCreateActor(actorId, name, key, input) {
     const entry = await this.loadActor(actorId);
     if (!entry.state) {
+      if (this.isActorStopping(actorId)) {
+        throw new Error(`Actor ${actorId} stopping`);
+      }
+      if (entry.lifecycleState === 4 /* DESTROYED */) {
+        entry.lifecycleState = 0 /* NONEXISTENT */;
+        entry.generation = crypto.randomUUID();
+      }
+      const kvStorage = [];
+      const initialKvState = getInitialActorKvState(input);
+      for (const [key2, value] of initialKvState) {
+        kvStorage.push({
+          key: bufferToArrayBuffer(key2),
+          value: bufferToArrayBuffer(value)
+        });
+      }
       entry.state = {
         actorId,
         name,
         key,
         createdAt: BigInt(Date.now()),
-        persistedData: bufferToArrayBuffer(
-          serializeEmptyPersistData(input)
-        )
+        kvStorage
       };
-      await this.writeActor(actorId, entry.state);
+      await this.writeActor(actorId, entry.generation, entry.state);
     }
     return entry;
   }
@@ -2524,35 +2465,127 @@ var FileSystemGlobalState = class {
       this.#persist,
       "cannot sleep actor with memory driver, must use file system driver"
     );
-    const actor2 = this.#actors.get(actorId);
+    const actor2 = this.#upsertEntry(actorId);
     invariant4(actor2, `tried to sleep ${actorId}, does not exist`);
+    if (this.isActorStopping(actorId)) {
+      return;
+    }
+    actor2.lifecycleState = 2 /* STARTING_SLEEP */;
     if (actor2.loadPromise) await actor2.loadPromise.catch();
     if ((_a = actor2.startPromise) == null ? void 0 : _a.promise)
       await actor2.startPromise.promise.catch();
-    actor2.removed = true;
     invariant4(actor2.actor, "actor should be loaded");
-    await actor2.actor._onStop();
+    await actor2.actor.onStop("sleep");
     this.#actors.delete(actorId);
   }
+  async destroyActor(actorId) {
+    var _a;
+    const actor2 = this.#upsertEntry(actorId);
+    if (this.isActorStopping(actorId)) {
+      return;
+    }
+    actor2.lifecycleState = 3 /* STARTING_DESTROY */;
+    if (actor2.loadPromise) await actor2.loadPromise.catch();
+    if ((_a = actor2.startPromise) == null ? void 0 : _a.promise)
+      await actor2.startPromise.promise.catch();
+    if (actor2.actor) {
+      await actor2.actor.onStop("destroy");
+    }
+    if (actor2.alarmTimeout) {
+      actor2.alarmTimeout.abort();
+    }
+    if (this.#persist) {
+      const fs = getNodeFs();
+      await Promise.all([
+        // Delete actor state file
+        (async () => {
+          try {
+            await fs.unlink(this.getActorStatePath(actorId));
+          } catch (err) {
+            if ((err == null ? void 0 : err.code) !== "ENOENT") {
+              logger4().error({
+                msg: "failed to delete actor state file",
+                actorId,
+                error: stringifyError(err)
+              });
+            }
+          }
+        })(),
+        // Delete actor database file
+        (async () => {
+          try {
+            await fs.unlink(this.getActorDbPath(actorId));
+          } catch (err) {
+            if ((err == null ? void 0 : err.code) !== "ENOENT") {
+              logger4().error({
+                msg: "failed to delete actor database file",
+                actorId,
+                error: stringifyError(err)
+              });
+            }
+          }
+        })(),
+        // Delete actor alarm file
+        (async () => {
+          try {
+            await fs.unlink(this.getActorAlarmPath(actorId));
+          } catch (err) {
+            if ((err == null ? void 0 : err.code) !== "ENOENT") {
+              logger4().error({
+                msg: "failed to delete actor alarm file",
+                actorId,
+                error: stringifyError(err)
+              });
+            }
+          }
+        })()
+      ]);
+    }
+    actor2.state = void 0;
+    actor2.loadPromise = void 0;
+    actor2.actor = void 0;
+    actor2.startPromise = void 0;
+    actor2.alarmTimeout = void 0;
+    actor2.alarmTimeout = void 0;
+    actor2.pendingWriteResolver = void 0;
+    actor2.lifecycleState = 4 /* DESTROYED */;
+  }
   /**
    * Save actor state to disk.
    */
-  async writeActor(actorId, state) {
+  async writeActor(actorId, generation, state) {
     if (!this.#persist) {
       return;
     }
     const entry = this.#actors.get(actorId);
     invariant4(entry, "actor entry does not exist");
-    await this.#performWrite(actorId, state);
+    await this.#performWrite(actorId, generation, state);
+  }
+  isGenerationCurrentAndNotDestroyed(actorId, generation) {
+    const entry = this.#upsertEntry(actorId);
+    if (!entry) return false;
+    return entry.generation === generation && entry.lifecycleState !== 3 /* STARTING_DESTROY */;
+  }
+  isActorStopping(actorId) {
+    const entry = this.#upsertEntry(actorId);
+    if (!entry) return false;
+    return entry.lifecycleState === 2 /* STARTING_SLEEP */ || entry.lifecycleState === 3 /* STARTING_DESTROY */;
   }
   async setActorAlarm(actorId, timestamp) {
     const entry = this.#actors.get(actorId);
     invariant4(entry, "actor entry does not exist");
+    const writeGeneration = entry.generation;
+    if (this.isActorStopping(actorId)) {
+      logger4().info("skipping set alarm since actor stopping");
+      return;
+    }
     if (this.#persist) {
       const alarmPath = this.getActorAlarmPath(actorId);
-      const tempPath = `${alarmPath}.tmp.${crypto3.randomUUID()}`;
+      const crypto2 = getNodeCrypto();
+      const tempPath = `${alarmPath}.tmp.${crypto2.randomUUID()}`;
       try {
-        await ensureDirectoryExists(path2.dirname(alarmPath));
+        const path = getNodePath();
+        await ensureDirectoryExists(path.dirname(alarmPath));
         const alarmData = {
           actorId,
           timestamp: BigInt(timestamp)
@@ -2560,14 +2593,25 @@ var FileSystemGlobalState = class {
         const data = ACTOR_ALARM_VERSIONED.serializeWithEmbeddedVersion(
           alarmData
         );
-        await fs2.writeFile(tempPath, data);
-        await fs2.rename(tempPath, alarmPath);
+        const fs = getNodeFs();
+        await fs.writeFile(tempPath, data);
+        if (!this.isGenerationCurrentAndNotDestroyed(
+          actorId,
+          writeGeneration
+        )) {
+          logger4().debug(
+            "skipping writing alarm since actor destroying or new generation"
+          );
+          return;
+        }
+        await fs.rename(tempPath, alarmPath);
       } catch (error) {
         try {
-          await fs2.unlink(tempPath);
+          const fs = getNodeFs();
+          await fs.unlink(tempPath);
         } catch {
         }
-        logger5().error({
+        logger4().error({
           msg: "failed to write alarm",
           actorId,
           error
@@ -2580,27 +2624,37 @@ var FileSystemGlobalState = class {
   /**
    * Perform the actual write operation with atomic writes
    */
-  async #performWrite(actorId, state) {
+  async #performWrite(actorId, generation, state) {
     const dataPath = this.getActorStatePath(actorId);
-    const tempPath = `${dataPath}.tmp.${crypto3.randomUUID()}`;
+    const crypto2 = getNodeCrypto();
+    const tempPath = `${dataPath}.tmp.${crypto2.randomUUID()}`;
     try {
-      await ensureDirectoryExists(path2.dirname(dataPath));
+      const path = getNodePath();
+      await ensureDirectoryExists(path.dirname(dataPath));
       const bareState = {
         actorId: state.actorId,
         name: state.name,
         key: state.key,
         createdAt: state.createdAt,
-        persistedData: state.persistedData
+        kvStorage: state.kvStorage
       };
       const serializedState = ACTOR_STATE_VERSIONED.serializeWithEmbeddedVersion(bareState);
-      await fs2.writeFile(tempPath, serializedState);
-      await fs2.rename(tempPath, dataPath);
+      const fs = getNodeFs();
+      await fs.writeFile(tempPath, serializedState);
+      if (!this.isGenerationCurrentAndNotDestroyed(actorId, generation)) {
+        logger4().debug(
+          "skipping writing alarm since actor destroying or new generation"
+        );
+        return;
+      }
+      await fs.rename(tempPath, dataPath);
     } catch (error) {
       try {
-        await fs2.unlink(tempPath);
+        const fs = getNodeFs();
+        await fs.unlink(tempPath);
       } catch {
       }
-      logger5().error({
+      logger4().error({
         msg: "failed to save actor state",
         actorId,
         error
@@ -2628,7 +2682,7 @@ var FileSystemGlobalState = class {
     try {
       this.#loadAlarmsSync();
     } catch (err) {
-      logger5().error({
+      logger4().error({
         msg: "failed to load alarms on startup",
         error: err
       });
@@ -2696,12 +2750,14 @@ var FileSystemGlobalState = class {
    */
   #loadAlarmsSync() {
     try {
-      const files = fsSync2.existsSync(this.#alarmsDir) ? fsSync2.readdirSync(this.#alarmsDir) : [];
+      const fsSync = getNodeFsSync();
+      const files = fsSync.existsSync(this.#alarmsDir) ? fsSync.readdirSync(this.#alarmsDir) : [];
       for (const file of files) {
         if (file.includes(".tmp.")) continue;
-        const fullPath = path2.join(this.#alarmsDir, file);
+        const path = getNodePath();
+        const fullPath = path.join(this.#alarmsDir, file);
         try {
-          const buf = fsSync2.readFileSync(fullPath);
+          const buf = fsSync.readFileSync(fullPath);
           const alarmData = ACTOR_ALARM_VERSIONED.deserializeWithEmbeddedVersion(
             new Uint8Array(buf)
           );
@@ -2712,13 +2768,13 @@ var FileSystemGlobalState = class {
               timestamp
             );
           } else {
-            logger5().debug({
+            logger4().debug({
               msg: "invalid alarm file contents",
               file
             });
           }
         } catch (err) {
-          logger5().error({
+          logger4().error({
             msg: "failed to read alarm file",
             file,
             error: stringifyError(err)
@@ -2726,7 +2782,7 @@ var FileSystemGlobalState = class {
         }
       }
     } catch (err) {
-      logger5().error({
+      logger4().error({
         msg: "failed to list alarms directory",
         error: err
       });
@@ -2739,7 +2795,7 @@ var FileSystemGlobalState = class {
     var _a;
     const entry = this.#upsertEntry(actorId);
     if (entry.alarmTimestamp !== void 0 && timestamp >= entry.alarmTimestamp) {
-      logger5().debug({
+      logger4().debug({
         msg: "skipping alarm schedule (later than existing)",
         actorId,
         timestamp,
@@ -2747,7 +2803,7 @@ var FileSystemGlobalState = class {
       });
       return;
     }
-    logger5().debug({ msg: "scheduling alarm", actorId, timestamp });
+    logger4().debug({ msg: "scheduling alarm", actorId, timestamp });
     (_a = entry.alarmTimeout) == null ? void 0 : _a.abort();
     entry.alarmTimestamp = timestamp;
     const delay = Math.max(0, timestamp - Date.now());
@@ -2755,10 +2811,11 @@ var FileSystemGlobalState = class {
       entry.alarmTimestamp = void 0;
       if (this.#persist) {
         try {
-          await fs2.unlink(this.getActorAlarmPath(actorId));
+          const fs = getNodeFs();
+          await fs.unlink(this.getActorAlarmPath(actorId));
         } catch (err) {
           if ((err == null ? void 0 : err.code) !== "ENOENT") {
-            logger5().debug({
+            logger4().debug({
               msg: "failed to remove alarm file",
               actorId,
               error: stringifyError(err)
@@ -2767,7 +2824,7 @@ var FileSystemGlobalState = class {
         }
       }
       try {
-        logger5().debug({ msg: "triggering alarm", actorId, timestamp });
+        logger4().debug({ msg: "triggering alarm", actorId, timestamp });
         const loaded = await this.loadActor(actorId);
         if (!loaded.state)
           throw new Error(`Actor does not exist: ${actorId}`);
@@ -2783,9 +2840,9 @@ var FileSystemGlobalState = class {
           );
         }
         invariant4(loaded.actor, "actor should be loaded after wake");
-        await loaded.actor._onAlarm();
+        await loaded.actor.onAlarm();
       } catch (err) {
-        logger5().error({
+        logger4().error({
           msg: "failed to handle alarm",
           actorId,
           error: stringifyError(err)
@@ -2794,12 +2851,14 @@ var FileSystemGlobalState = class {
     }, delay);
   }
   getOrCreateInspectorAccessToken() {
-    const tokenPath = path2.join(this.#storagePath, "inspector-token");
-    if (fsSync2.existsSync(tokenPath)) {
-      return fsSync2.readFileSync(tokenPath, "utf-8");
+    const path = getNodePath();
+    const fsSync = getNodeFsSync();
+    const tokenPath = path.join(this.#storagePath, "inspector-token");
+    if (fsSync.existsSync(tokenPath)) {
+      return fsSync.readFileSync(tokenPath, "utf-8");
     }
     const newToken = generateRandomString();
-    fsSync2.writeFileSync(tokenPath, newToken);
+    fsSync.writeFileSync(tokenPath, newToken);
     return newToken;
   }
   /**
@@ -2807,22 +2866,24 @@ var FileSystemGlobalState = class {
    */
   #cleanupTempFilesSync() {
     try {
-      const files = fsSync2.readdirSync(this.#stateDir);
+      const fsSync = getNodeFsSync();
+      const files = fsSync.readdirSync(this.#stateDir);
       const tempFiles = files.filter((f) => f.includes(".tmp."));
       const oneHourAgo = Date.now() - 36e5;
       for (const tempFile of tempFiles) {
         try {
-          const fullPath = path2.join(this.#stateDir, tempFile);
-          const stat2 = fsSync2.statSync(fullPath);
-          if (stat2.mtimeMs < oneHourAgo) {
-            fsSync2.unlinkSync(fullPath);
-            logger5().info({
+          const path = getNodePath();
+          const fullPath = path.join(this.#stateDir, tempFile);
+          const stat = fsSync.statSync(fullPath);
+          if (stat.mtimeMs < oneHourAgo) {
+            fsSync.unlinkSync(fullPath);
+            logger4().info({
               msg: "cleaned up stale temp file",
               file: tempFile
             });
           }
         } catch (err) {
-          logger5().debug({
+          logger4().debug({
             msg: "failed to cleanup temp file",
             file: tempFile,
             error: err
@@ -2830,12 +2891,129 @@ var FileSystemGlobalState = class {
         }
       }
     } catch (err) {
-      logger5().error({
+      logger4().error({
         msg: "failed to read actors directory for cleanup",
         error: err
       });
     }
   }
+  /**
+   * Batch put KV entries for an actor.
+   */
+  async kvBatchPut(actorId, entries) {
+    const entry = await this.loadActor(actorId);
+    if (!entry.state) {
+      if (this.isActorStopping(actorId)) {
+        return;
+      } else {
+        throw new Error(`Actor ${actorId} state not loaded`);
+      }
+    }
+    const newKvStorage = [...entry.state.kvStorage];
+    for (const [key, value] of entries) {
+      const existingIndex = newKvStorage.findIndex(
+        (e) => arrayBuffersEqual(e.key, bufferToArrayBuffer(key))
+      );
+      if (existingIndex >= 0) {
+        newKvStorage[existingIndex] = {
+          key: bufferToArrayBuffer(key),
+          value: bufferToArrayBuffer(value)
+        };
+      } else {
+        newKvStorage.push({
+          key: bufferToArrayBuffer(key),
+          value: bufferToArrayBuffer(value)
+        });
+      }
+    }
+    entry.state = {
+      ...entry.state,
+      kvStorage: newKvStorage
+    };
+    await this.writeActor(actorId, entry.generation, entry.state);
+  }
+  /**
+   * Batch get KV entries for an actor.
+   */
+  async kvBatchGet(actorId, keys) {
+    const entry = await this.loadActor(actorId);
+    if (!entry.state) {
+      if (this.isActorStopping(actorId)) {
+        throw new Error(`Actor ${actorId} is stopping`);
+      } else {
+        throw new Error(`Actor ${actorId} state not loaded`);
+      }
+    }
+    const results = [];
+    for (const key of keys) {
+      const foundEntry = entry.state.kvStorage.find(
+        (e) => arrayBuffersEqual(e.key, bufferToArrayBuffer(key))
+      );
+      if (foundEntry) {
+        results.push(new Uint8Array(foundEntry.value));
+      } else {
+        results.push(null);
+      }
+    }
+    return results;
+  }
+  /**
+   * Batch delete KV entries for an actor.
+   */
+  async kvBatchDelete(actorId, keys) {
+    const entry = await this.loadActor(actorId);
+    if (!entry.state) {
+      if (this.isActorStopping(actorId)) {
+        return;
+      } else {
+        throw new Error(`Actor ${actorId} state not loaded`);
+      }
+    }
+    const newKvStorage = [...entry.state.kvStorage];
+    for (const key of keys) {
+      const indexToDelete = newKvStorage.findIndex(
+        (e) => arrayBuffersEqual(e.key, bufferToArrayBuffer(key))
+      );
+      if (indexToDelete >= 0) {
+        newKvStorage.splice(indexToDelete, 1);
+      }
+    }
+    entry.state = {
+      ...entry.state,
+      kvStorage: newKvStorage
+    };
+    await this.writeActor(actorId, entry.generation, entry.state);
+  }
+  /**
+   * List KV entries with a given prefix for an actor.
+   */
+  async kvListPrefix(actorId, prefix) {
+    const entry = await this.loadActor(actorId);
+    if (!entry.state) {
+      if (this.isActorStopping(actorId)) {
+        throw new Error(`Actor ${actorId} is destroying`);
+      } else {
+        throw new Error(`Actor ${actorId} state not loaded`);
+      }
+    }
+    const results = [];
+    for (const kvEntry of entry.state.kvStorage) {
+      const keyBytes = new Uint8Array(kvEntry.key);
+      if (keyBytes.length >= prefix.length) {
+        let hasPrefix = true;
+        for (let i = 0; i < prefix.length; i++) {
+          if (keyBytes[i] !== prefix[i]) {
+            hasPrefix = false;
+            break;
+          }
+        }
+        if (hasPrefix) {
+          results.push([keyBytes, new Uint8Array(kvEntry.value)]);
+        }
+      }
+    }
+    return results;
+  }
 };
 
 // src/drivers/file-system/manager.ts
@@ -2994,73 +3172,53 @@ var FileSystemManagerDriver = class {
       actorId
     });
   }
-  async openWebSocket(path4, actorId, encoding, params, connId, connToken) {
-    const pathOnly = path4.split("?")[0];
+  async openWebSocket(path, actorId, encoding, params) {
+    const pathOnly = path.split("?")[0];
     const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
-    if (normalizedPath === PATH_CONNECT_WEBSOCKET) {
-      const wsHandler = await handleWebSocketConnect(
-        void 0,
-        this.#runConfig,
-        this.#actorDriver,
-        actorId,
-        encoding,
-        params,
-        generateConnRequestId(),
-        void 0,
-        connId,
-        connToken
-      );
-      return new InlineWebSocketAdapter2(wsHandler);
-    } else if (normalizedPath.startsWith(PATH_RAW_WEBSOCKET_PREFIX) || normalizedPath === "/raw/websocket") {
-      const wsHandler = await handleRawWebSocketHandler(
-        void 0,
-        path4,
-        this.#actorDriver,
-        actorId,
-        void 0
-      );
-      return new InlineWebSocketAdapter2(wsHandler);
-    } else {
-      throw new Error(`Unreachable path: ${path4}`);
-    }
+    const wsHandler = await routeWebSocket(
+      // TODO: Create fake request
+      void 0,
+      normalizedPath,
+      {},
+      this.#runConfig,
+      this.#actorDriver,
+      actorId,
+      encoding,
+      params,
+      void 0,
+      void 0,
+      false,
+      false
+    );
+    return new InlineWebSocketAdapter(wsHandler);
   }
   async proxyRequest(c, actorRequest, actorId) {
     return await this.#actorRouter.fetch(actorRequest, {
       actorId
     });
   }
-  async proxyWebSocket(c, path4, actorId, encoding, connParams, connId, connToken) {
+  async proxyWebSocket(c, path, actorId, encoding, params) {
     var _a, _b;
     const upgradeWebSocket = (_b = (_a = this.#runConfig).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
     invariant5(upgradeWebSocket, "missing getUpgradeWebSocket");
-    const pathOnly = path4.split("?")[0];
+    const pathOnly = path.split("?")[0];
     const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
-    if (normalizedPath === PATH_CONNECT_WEBSOCKET) {
-      const wsHandler = await handleWebSocketConnect(
-        c.req.raw,
-        this.#runConfig,
-        this.#actorDriver,
-        actorId,
-        encoding,
-        connParams,
-        generateConnRequestId(),
-        void 0,
-        connId,
-        connToken
-      );
-      return upgradeWebSocket(() => wsHandler)(c, noopNext());
-    } else if (normalizedPath.startsWith(PATH_RAW_WEBSOCKET_PREFIX) || normalizedPath === "/raw/websocket") {
-      const wsHandler = await handleRawWebSocketHandler(
-        c.req.raw,
-        path4,
-        this.#actorDriver,
-        actorId,
-        void 0
-      );
-      return upgradeWebSocket(() => wsHandler)(c, noopNext());
-    } else {
-      throw new Error(`Unreachable path: ${path4}`);
-    }
+    const wsHandler = await routeWebSocket(
+      // TODO: Create new request with new path
+      c.req.raw,
+      normalizedPath,
+      c.req.header(),
+      this.#runConfig,
+      this.#actorDriver,
+      actorId,
+      encoding,
+      params,
+      void 0,
+      void 0,
+      false,
+      false
+    );
+    return upgradeWebSocket(() => wsHandler)(c, noopNext());
   }
   async getForId({
     actorId
@@ -3069,6 +3227,9 @@ var FileSystemManagerDriver = class {
     if (!actor2.state) {
       return void 0;
     }
+    if (this.#state.isActorStopping(actorId)) {
+      throw new ActorStopping(actorId);
+    }
     try {
       return {
         actorId,
@@ -3076,7 +3237,7 @@ var FileSystemManagerDriver = class {
         key: actor2.state.key
       };
     } catch (error) {
-      logger5().error({
+      logger4().error({
         msg: "failed to read actor state",
         actorId,
         error
@@ -3123,6 +3284,26 @@ var FileSystemManagerDriver = class {
       key
     };
   }
+  async listActors({ name }) {
+    const actors = [];
+    const itr = this.#state.getActorsIterator({});
+    for await (const actor2 of itr) {
+      if (actor2.name === name) {
+        actors.push({
+          actorId: actor2.actorId,
+          name: actor2.name,
+          key: actor2.key,
+          createTs: Number(actor2.createdAt)
+        });
+      }
+    }
+    actors.sort((a, b) => {
+      const aTs = a.createTs ?? 0;
+      const bTs = b.createTs ?? 0;
+      return bTs - aTs;
+    });
+    return actors;
+  }
   displayInformation() {
     return {
       name: this.#state.persist ? "File System" : "Memory",
@@ -3145,6 +3326,7 @@ var FileSystemManagerDriver = class {
 
 // src/drivers/file-system/mod.ts
 function createFileSystemOrMemoryDriver(persist = true, customPath) {
+  importNodeDependencies();
   const state = new FileSystemGlobalState(persist, customPath);
   const driverConfig = {
     name: persist ? "file-system" : "memory",
@@ -3204,16 +3386,8 @@ function chooseDefaultDriver(runConfig) {
   return createFileSystemOrMemoryDriver(true);
 }
 
-// src/engine-process/mod.ts
-import { spawn } from "child_process";
-import { randomUUID as randomUUID2 } from "crypto";
-import { createWriteStream } from "fs";
-import * as fs3 from "fs/promises";
-import * as path3 from "path";
-import { pipeline } from "stream/promises";
-
 // src/engine-process/log.ts
-function logger6() {
+function logger5() {
   return getLogger("engine-process");
 }
 
@@ -3223,30 +3397,32 @@ var ENGINE_ENDPOINT = `http://localhost:${ENGINE_PORT}`;
 var ENGINE_BASE_URL = "https://releases.rivet.gg/engine";
 var ENGINE_BINARY_NAME = "rivet-engine";
 async function ensureEngineProcess(options) {
-  logger6().debug({
+  importNodeDependencies();
+  logger5().debug({
     msg: "ensuring engine process",
     version: options.version
   });
+  const path = getNodePath();
   const storageRoot = getStoragePath();
-  const binDir = path3.join(storageRoot, "bin");
-  const varDir = path3.join(storageRoot, "var");
-  const logsDir = path3.join(varDir, "logs", "rivet-engine");
+  const binDir = path.join(storageRoot, "bin");
+  const varDir = path.join(storageRoot, "var");
+  const logsDir = path.join(varDir, "logs", "rivet-engine");
   await ensureDirectoryExists(binDir);
   await ensureDirectoryExists(varDir);
   await ensureDirectoryExists(logsDir);
   const executableName = process.platform === "win32" ? `${ENGINE_BINARY_NAME}-${options.version}.exe` : `${ENGINE_BINARY_NAME}-${options.version}`;
-  const binaryPath = path3.join(binDir, executableName);
+  const binaryPath = path.join(binDir, executableName);
   await downloadEngineBinaryIfNeeded(binaryPath, options.version, varDir);
   if (await isEngineRunning()) {
     try {
       await waitForEngineHealth();
-      logger6().debug({
+      logger5().debug({
         msg: "engine already running and healthy",
         version: options.version
       });
       return;
     } catch (error) {
-      logger6().warn({
+      logger5().warn({
         msg: "existing engine process not healthy, cannot restart automatically",
         error
       });
@@ -3256,39 +3432,26 @@ async function ensureEngineProcess(options) {
     }
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").replace(/\./g, "-");
-  const stdoutLogPath = path3.join(logsDir, `engine-${timestamp}-stdout.log`);
-  const stderrLogPath = path3.join(logsDir, `engine-${timestamp}-stderr.log`);
-  const stdoutStream = createWriteStream(stdoutLogPath, { flags: "a" });
-  const stderrStream = createWriteStream(stderrLogPath, { flags: "a" });
-  logger6().debug({
+  const stdoutLogPath = path.join(logsDir, `engine-${timestamp}-stdout.log`);
+  const stderrLogPath = path.join(logsDir, `engine-${timestamp}-stderr.log`);
+  const fsSync = getNodeFsSync();
+  const stdoutStream = fsSync.createWriteStream(stdoutLogPath, {
+    flags: "a"
+  });
+  const stderrStream = fsSync.createWriteStream(stderrLogPath, {
+    flags: "a"
+  });
+  logger5().debug({
     msg: "creating engine log files",
     stdout: stdoutLogPath,
     stderr: stderrLogPath
   });
-  const child = spawn(binaryPath, ["start"], {
-    cwd: path3.dirname(binaryPath),
+  const childProcess = getNodeChildProcess();
+  const child = childProcess.spawn(binaryPath, ["start"], {
+    cwd: path.dirname(binaryPath),
     stdio: ["inherit", "pipe", "pipe"],
     env: {
-      ...process.env,
-      // In development, runners can be terminated without a graceful
-      // shutdown (i.e. SIGKILL instead of SIGTERM). This is treated as a
-      // crash by Rivet Engine in production and implements a backoff for
-      // rescheduling actors in case of a crash loop.
-      //
-      // This is problematic in development since this will cause actors
-      // to become unresponsive if frequently killing your dev server.
-      //
-      // We reduce the timeouts for resetting a runner as healthy in
-      // order to account for this.
-      RIVET__PEGBOARD__RETRY_RESET_DURATION: "100",
-      RIVET__PEGBOARD__BASE_RETRY_TIMEOUT: "100",
-      // Set max exponent to 1 to have a maximum of base_retry_timeout
-      RIVET__PEGBOARD__RESCHEDULE_BACKOFF_MAX_EXPONENT: "1",
-      // Reduce thresholds for faster development iteration
-      //
-      // Default ping interval is 3s, this gives a 2s & 4s grace
-      RIVET__PEGBOARD__RUNNER_ELIGIBLE_THRESHOLD: "5000",
-      RIVET__PEGBOARD__RUNNER_LOST_THRESHOLD: "7000"
+      ...process.env
     }
   });
   if (!child.pid) {
@@ -3300,23 +3463,24 @@ async function ensureEngineProcess(options) {
   if (child.stderr) {
     child.stderr.pipe(stderrStream);
   }
-  logger6().debug({
+  logger5().debug({
     msg: "spawned engine process",
     pid: child.pid,
-    cwd: path3.dirname(binaryPath)
+    cwd: path.dirname(binaryPath)
   });
   child.once("exit", (code, signal) => {
-    logger6().warn({
+    logger5().warn({
       msg: "engine process exited, please report this error",
       code,
       signal,
-      ...EXTRA_ERROR_LOG
+      issues: "https://github.com/rivet-dev/rivetkit/issues",
+      support: "https://rivet.dev/discord"
     });
     stdoutStream.end();
     stderrStream.end();
   });
   child.once("error", (error) => {
-    logger6().error({
+    logger5().error({
       msg: "engine process failed",
       error
     });
@@ -3324,7 +3488,7 @@ async function ensureEngineProcess(options) {
     stderrStream.end();
   });
   await waitForEngineHealth();
-  logger6().info({
+  logger5().info({
     msg: "engine process started",
     pid: child.pid,
     version: options.version,
@@ -3337,7 +3501,7 @@ async function ensureEngineProcess(options) {
 async function downloadEngineBinaryIfNeeded(binaryPath, version, varDir) {
   const binaryExists = await fileExists(binaryPath);
   if (binaryExists) {
-    logger6().debug({
+    logger5().debug({
       msg: "engine binary already cached",
       version,
       path: binaryPath
@@ -3347,7 +3511,7 @@ async function downloadEngineBinaryIfNeeded(binaryPath, version, varDir) {
   const { targetTriplet, extension } = resolveTargetTriplet();
   const remoteFile = `${ENGINE_BINARY_NAME}-${targetTriplet}${extension}`;
   const downloadUrl = `${ENGINE_BASE_URL}/${version}/${remoteFile}`;
-  logger6().info({
+  logger5().info({
     msg: "downloading engine binary",
     url: downloadUrl,
     path: binaryPath,
@@ -3359,50 +3523,59 @@ async function downloadEngineBinaryIfNeeded(binaryPath, version, varDir) {
       `failed to download rivet engine binary from ${downloadUrl}: ${response.status} ${response.statusText}`
     );
   }
-  const tempPath = `${binaryPath}.${randomUUID2()}.tmp`;
+  const crypto2 = getNodeCrypto();
+  const tempPath = `${binaryPath}.${crypto2.randomUUID()}.tmp`;
   const startTime = Date.now();
-  logger6().debug({
+  logger5().debug({
     msg: "starting binary download",
     tempPath,
     contentLength: response.headers.get("content-length")
   });
   const slowDownloadWarning = setTimeout(() => {
-    logger6().warn({
+    logger5().warn({
       msg: "engine binary download is taking longer than expected, please be patient",
       version
     });
   }, 5e3);
   try {
-    await pipeline(response.body, createWriteStream(tempPath));
+    const stream = getNodeStream();
+    const fsSync = getNodeFsSync();
+    await stream.pipeline(
+      response.body,
+      fsSync.createWriteStream(tempPath)
+    );
     clearTimeout(slowDownloadWarning);
-    const stats = await fs3.stat(tempPath);
+    const fs = getNodeFs();
+    const stats = await fs.stat(tempPath);
     const downloadDuration = Date.now() - startTime;
     if (process.platform !== "win32") {
-      await fs3.chmod(tempPath, 493);
+      await fs.chmod(tempPath, 493);
     }
-    await fs3.rename(tempPath, binaryPath);
-    logger6().debug({
+    await fs.rename(tempPath, binaryPath);
+    logger5().debug({
       msg: "engine binary download complete",
       version,
       path: binaryPath,
       size: stats.size,
       durationMs: downloadDuration
     });
-    logger6().info({
+    logger5().info({
       msg: "engine binary downloaded",
       version,
       path: binaryPath
     });
   } catch (error) {
     clearTimeout(slowDownloadWarning);
-    logger6().warn({
+    logger5().warn({
       msg: "engine download failed, please report this error",
       tempPath,
       error,
-      ...EXTRA_ERROR_LOG
+      issues: "https://github.com/rivet-dev/rivetkit/issues",
+      support: "https://rivet.dev/discord"
     });
     try {
-      await fs3.unlink(tempPath);
+      const fs = getNodeFs();
+      await fs.unlink(tempPath);
     } catch (unlinkError) {
     }
     throw error;
@@ -3455,13 +3628,13 @@ async function checkIfEngineAlreadyRunningOnPort(port) {
   if (response.ok) {
     const health = await response.json();
     if (health.runtime === "engine") {
-      logger6().debug({
+      logger5().debug({
         msg: "rivet engine already running on port",
         port
       });
       return true;
     } else if (health.runtime === "rivetkit") {
-      logger6().error({
+      logger5().error({
         msg: "another rivetkit process is already running on port",
         port
       });
@@ -3478,7 +3651,8 @@ async function checkIfEngineAlreadyRunningOnPort(port) {
 }
 async function fileExists(filePath) {
   try {
-    await fs3.access(filePath);
+    const fs = getNodeFs();
+    await fs.access(filePath);
     return true;
   } catch {
     return false;
@@ -3488,12 +3662,12 @@ var HEALTH_MAX_WAIT = 1e4;
 var HEALTH_INTERVAL = 100;
 async function waitForEngineHealth() {
   const maxRetries = Math.ceil(HEALTH_MAX_WAIT / HEALTH_INTERVAL);
-  logger6().debug({ msg: "waiting for engine health check" });
+  logger5().debug({ msg: "waiting for engine health check" });
   for (let i = 0; i < maxRetries; i++) {
     try {
       const response = await fetch(`${ENGINE_ENDPOINT}/health`);
       if (response.ok) {
-        logger6().debug({ msg: "engine health check passed" });
+        logger5().debug({ msg: "engine health check passed" });
         return;
       }
     } catch (error) {
@@ -3504,7 +3678,7 @@ async function waitForEngineHealth() {
       }
     }
     if (i < maxRetries - 1) {
-      logger6().trace({
+      logger5().trace({
         msg: "engine not ready, retrying",
         attempt: i + 1,
         maxRetries
@@ -3579,6 +3753,9 @@ var ActorSchema = z4.object({
   sleep_ts: z4.number().nullable().optional(),
   start_ts: z4.number().nullable().optional()
 });
+var ActorNameSchema = z4.object({
+  metadata: z4.record(z4.string(), z4.unknown())
+});
 var ActorsListResponseSchema = z4.object({
   actors: z4.array(ActorSchema)
 });
@@ -3606,6 +3783,14 @@ var ActorsGetOrCreateResponseSchema = z4.object({
   created: z4.boolean()
 });
 var ActorsDeleteResponseSchema = z4.object({});
+var ActorsListNamesResponseSchema = z4.object({
+  names: z4.record(z4.string(), ActorNameSchema)
+});
+
+// src/manager/log.ts
+function logger6() {
+  return getLogger("actor-manager");
+}
 
 // src/manager/gateway.ts
 async function handleWebSocketGatewayPathBased(runConfig, managerDriver, c, actorPathInfo) {
@@ -3617,8 +3802,6 @@ async function handleWebSocketGatewayPathBased(runConfig, managerDriver, c, acto
   const protocols = c.req.header("sec-websocket-protocol");
   let encodingRaw;
   let connParamsRaw;
-  let connIdRaw;
-  let connTokenRaw;
   if (protocols) {
     const protocolList = protocols.split(",").map((p) => p.trim());
     for (const protocol of protocolList) {
@@ -3628,16 +3811,10 @@ async function handleWebSocketGatewayPathBased(runConfig, managerDriver, c, acto
         connParamsRaw = decodeURIComponent(
           protocol.substring(WS_PROTOCOL_CONN_PARAMS.length)
         );
-      } else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
-        connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
-      } else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
-        connTokenRaw = protocol.substring(
-          WS_PROTOCOL_CONN_TOKEN.length
-        );
       }
     }
   }
-  logger().debug({
+  logger6().debug({
     msg: "proxying websocket to actor via path-based routing",
     actorId: actorPathInfo.actorId,
     path: actorPathInfo.remainingPath,
@@ -3651,13 +3828,11 @@ async function handleWebSocketGatewayPathBased(runConfig, managerDriver, c, acto
     actorPathInfo.actorId,
     encoding,
     // Will be validated by driver
-    connParams,
-    connIdRaw,
-    connTokenRaw
+    connParams
   );
 }
 async function handleHttpGatewayPathBased(managerDriver, c, actorPathInfo) {
-  logger().debug({
+  logger6().debug({
     msg: "proxying request to actor via path-based routing",
     actorId: actorPathInfo.actorId,
     path: actorPathInfo.remainingPath,
@@ -3692,7 +3867,7 @@ async function actorGateway(runConfig, managerDriver, c, next) {
   const pathWithQuery = c.req.url.includes("?") ? strippedPath + c.req.url.substring(c.req.url.indexOf("?")) : strippedPath;
   const actorPathInfo = parseActorPath(pathWithQuery);
   if (actorPathInfo) {
-    logger().debug({
+    logger6().debug({
       msg: "routing using path-based actor routing",
       actorPathInfo
     });
@@ -3732,27 +3907,19 @@ async function handleWebSocketGateway(runConfig, managerDriver, c, strippedPath)
   let actorId;
   let encodingRaw;
   let connParamsRaw;
-  let connIdRaw;
-  let connTokenRaw;
   if (protocols) {
     const protocolList = protocols.split(",").map((p) => p.trim());
     for (const protocol of protocolList) {
       if (protocol.startsWith(WS_PROTOCOL_TARGET)) {
         target = protocol.substring(WS_PROTOCOL_TARGET.length);
       } else if (protocol.startsWith(WS_PROTOCOL_ACTOR)) {
-        actorId = protocol.substring(WS_PROTOCOL_ACTOR.length);
+        actorId = decodeURIComponent(protocol.substring(WS_PROTOCOL_ACTOR.length));
       } else if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
         encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
       } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
         connParamsRaw = decodeURIComponent(
           protocol.substring(WS_PROTOCOL_CONN_PARAMS.length)
         );
-      } else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
-        connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
-      } else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
-        connTokenRaw = protocol.substring(
-          WS_PROTOCOL_CONN_TOKEN.length
-        );
       }
     }
   }
@@ -3762,7 +3929,7 @@ async function handleWebSocketGateway(runConfig, managerDriver, c, strippedPath)
   if (!actorId) {
     throw new MissingActorHeader();
   }
-  logger().debug({
+  logger6().debug({
     msg: "proxying websocket to actor",
     actorId,
     path: strippedPath,
@@ -3777,9 +3944,7 @@ async function handleWebSocketGateway(runConfig, managerDriver, c, strippedPath)
     actorId,
     encoding,
     // Will be validated by driver
-    connParams,
-    connIdRaw,
-    connTokenRaw
+    connParams
   );
 }
 async function handleHttpGateway(managerDriver, c, next, strippedPath) {
@@ -3791,7 +3956,7 @@ async function handleHttpGateway(managerDriver, c, next, strippedPath) {
   if (!actorId) {
     throw new MissingActorHeader();
   }
-  logger().debug({
+  logger6().debug({
     msg: "proxying request to actor",
     actorId,
     path: strippedPath,
@@ -3811,22 +3976,22 @@ async function handleHttpGateway(managerDriver, c, next, strippedPath) {
   });
   return await managerDriver.proxyRequest(c, proxyRequest, actorId);
 }
-function parseActorPath(path4) {
-  const queryPos = path4.indexOf("?");
-  const fragmentPos = path4.indexOf("#");
+function parseActorPath(path) {
+  const queryPos = path.indexOf("?");
+  const fragmentPos = path.indexOf("#");
   let queryString = "";
   if (queryPos !== -1) {
     if (fragmentPos !== -1 && queryPos < fragmentPos) {
-      queryString = path4.slice(queryPos, fragmentPos);
+      queryString = path.slice(queryPos, fragmentPos);
     } else {
-      queryString = path4.slice(queryPos);
+      queryString = path.slice(queryPos);
     }
   }
-  let basePath = path4;
+  let basePath = path;
   if (queryPos !== -1) {
-    basePath = path4.slice(0, queryPos);
+    basePath = path.slice(0, queryPos);
   } else if (fragmentPos !== -1) {
-    basePath = path4.slice(0, fragmentPos);
+    basePath = path.slice(0, fragmentPos);
   }
   if (basePath.includes("//")) {
     return null;
@@ -3895,22 +4060,22 @@ async function createTestWebSocketProxy(clientWsPromise) {
     reject: serverWsReject
   } = promiseWithResolvers();
   try {
-    logger().debug({ msg: "awaiting client websocket promise" });
+    logger6().debug({ msg: "awaiting client websocket promise" });
     const ws = await clientWsPromise;
     clientWs = ws;
-    logger().debug({
+    logger6().debug({
       msg: "client websocket promise resolved",
       constructor: ws == null ? void 0 : ws.constructor.name
     });
     await new Promise((resolve, reject) => {
       const onOpen = () => {
-        logger().debug({
+        logger6().debug({
           msg: "test websocket connection to actor opened"
         });
         resolve();
       };
       const onError = (error) => {
-        logger().error({
+        logger6().error({
           msg: "test websocket connection failed",
           error
         });
@@ -3926,7 +4091,7 @@ async function createTestWebSocketProxy(clientWsPromise) {
       ws.addEventListener("message", async (clientEvt) => {
         var _a, _b;
         const serverWs = await serverWsPromise;
-        logger().debug({
+        logger6().debug({
           msg: `test websocket connection message from client`,
           dataType: typeof clientEvt.data,
           isBlob: clientEvt.data instanceof Blob,
@@ -3937,19 +4102,19 @@ async function createTestWebSocketProxy(clientWsPromise) {
         if (serverWs.readyState === 1) {
           if (clientEvt.data instanceof Blob) {
             clientEvt.data.arrayBuffer().then((buffer) => {
-              logger().debug({
+              logger6().debug({
                 msg: "converted client blob to arraybuffer, sending to server",
                 bufferSize: buffer.byteLength
               });
               serverWs.send(buffer);
             }).catch((error) => {
-              logger().error({
+              logger6().error({
                 msg: "failed to convert blob to arraybuffer",
                 error
               });
             });
           } else {
-            logger().debug({
+            logger6().debug({
               msg: "sending client data directly to server",
               dataType: typeof clientEvt.data,
               dataLength: typeof clientEvt.data === "string" ? clientEvt.data.length : void 0
@@ -3960,7 +4125,7 @@ async function createTestWebSocketProxy(clientWsPromise) {
       });
       ws.addEventListener("close", async (clientEvt) => {
         const serverWs = await serverWsPromise;
-        logger().debug({
+        logger6().debug({
           msg: `test websocket connection closed`
         });
         if (serverWs.readyState !== 3) {
@@ -3969,7 +4134,7 @@ async function createTestWebSocketProxy(clientWsPromise) {
       });
       ws.addEventListener("error", async () => {
         const serverWs = await serverWsPromise;
-        logger().debug({
+        logger6().debug({
           msg: `test websocket connection error`
         });
         if (serverWs.readyState !== 3) {
@@ -3978,7 +4143,7 @@ async function createTestWebSocketProxy(clientWsPromise) {
       });
     });
   } catch (error) {
-    logger().error({
+    logger6().error({
       msg: `failed to establish client websocket connection`,
       error
     });
@@ -3996,10 +4161,10 @@ async function createTestWebSocketProxy(clientWsPromise) {
   }
   return {
     onOpen: (_evt, serverWs) => {
-      logger().debug({
+      logger6().debug({
         msg: `test websocket connection from client opened`
       });
-      logger().debug({
+      logger6().debug({
         msg: "clientWs info",
         constructor: clientWs.constructor.name,
         hasAddEventListener: typeof clientWs.addEventListener === "function",
@@ -4009,7 +4174,7 @@ async function createTestWebSocketProxy(clientWsPromise) {
     },
     onMessage: (evt) => {
       var _a, _b;
-      logger().debug({
+      logger6().debug({
         msg: "received message from server",
         dataType: typeof evt.data,
         isBlob: evt.data instanceof Blob,
@@ -4020,19 +4185,19 @@ async function createTestWebSocketProxy(clientWsPromise) {
       if (clientWs.readyState === 1) {
         if (evt.data instanceof Blob) {
           evt.data.arrayBuffer().then((buffer) => {
-            logger().debug({
+            logger6().debug({
               msg: "converted blob to arraybuffer, sending",
               bufferSize: buffer.byteLength
             });
             clientWs.send(buffer);
           }).catch((error) => {
-            logger().error({
+            logger6().error({
               msg: "failed to convert blob to arraybuffer",
               error
             });
           });
         } else {
-          logger().debug({
+          logger6().debug({
             msg: "sending data directly",
             dataType: typeof evt.data,
             dataLength: typeof evt.data === "string" ? evt.data.length : void 0
@@ -4042,7 +4207,7 @@ async function createTestWebSocketProxy(clientWsPromise) {
       }
     },
     onClose: (event, serverWs) => {
-      logger().debug({
+      logger6().debug({
         msg: `server websocket closed`,
         wasClean: event.wasClean,
         code: event.code,
@@ -4054,7 +4219,7 @@ async function createTestWebSocketProxy(clientWsPromise) {
       }
     },
     onError: (error) => {
-      logger().error({
+      logger6().error({
         msg: `error in server websocket`,
         error
       });
@@ -4103,11 +4268,21 @@ function buildOpenApiResponses(schema) {
     }
   };
 }
+function buildOpenApiRequestBody(schema) {
+  return {
+    required: true,
+    content: {
+      "application/json": {
+        schema
+      }
+    }
+  };
+}
 function createManagerRouter(registryConfig, runConfig, managerDriver, driverConfig, client) {
   const router = new OpenAPIHono({ strict: false }).basePath(
     runConfig.basePath
   );
-  router.use("*", loggerMiddleware(logger()), cors());
+  router.use("*", loggerMiddleware(logger6()), cors());
   router.use(
     "*",
     createMiddleware(async (c, next) => {
@@ -4159,7 +4334,7 @@ function addServerlessRoutes(driverConfig, registryConfig, runConfig, managerDri
       );
     }
     const { endpoint, token, totalSlots, runnerName, namespace } = parseResult.data;
-    logger().debug({
+    logger6().debug({
       msg: "received serverless runner start request",
       endpoint,
       totalSlots,
@@ -4173,7 +4348,7 @@ function addServerlessRoutes(driverConfig, registryConfig, runConfig, managerDri
     newRunConfig.runnerName = runnerName;
     newRunConfig.namespace = namespace;
     if (newRunConfig.runnerKey) {
-      logger().warn({
+      logger6().warn({
         msg: "runner keys are not supported by serverless runners, this will be overwritten with a random runner key",
         oldRunnerKey: newRunConfig.runnerKey
       });
@@ -4245,15 +4420,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
       if (key && !name) {
         return c.json(
           {
-            error: "When providing 'key', 'name' must also be provided."
-          },
-          400
-        );
-      }
-      if (!actorIdsParsed && !key) {
-        return c.json(
-          {
-            error: "Must provide either 'actor_ids' or both 'name' and 'key'."
+            error: "Name is required when key is provided."
           },
           400
         );
@@ -4298,7 +4465,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
             }
           }
         }
-      } else if (key) {
+      } else if (key && name) {
         const actorOutput = await managerDriver.getWithKey({
           c,
           name,
@@ -4308,6 +4475,22 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
         if (actorOutput) {
           actors.push(actorOutput);
         }
+      } else {
+        if (!name) {
+          return c.json(
+            {
+              error: "Name is required when not using actor_ids."
+            },
+            400
+          );
+        }
+        const actorOutputs = await managerDriver.listActors({
+          c,
+          name,
+          key,
+          includeDestroyed: false
+        });
+        actors.push(...actorOutputs);
       }
       return c.json({
         actors: actors.map(
@@ -4316,18 +4499,30 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
       });
     });
   }
+  {
+    const route = createRoute({
+      method: "get",
+      path: "/actors/names",
+      request: {
+        query: z6.object({
+          namespace: z6.string()
+        })
+      },
+      responses: buildOpenApiResponses(ActorsListNamesResponseSchema)
+    });
+    router.openapi(route, async (c) => {
+      const names = buildActorNames(registryConfig);
+      return c.json({
+        names
+      });
+    });
+  }
   {
     const route = createRoute({
       method: "put",
       path: "/actors",
       request: {
-        body: {
-          content: {
-            "application/json": {
-              schema: ActorsGetOrCreateRequestSchema
-            }
-          }
-        }
+        body: buildOpenApiRequestBody(ActorsGetOrCreateRequestSchema)
       },
       responses: buildOpenApiResponses(ActorsGetOrCreateResponseSchema)
     });
@@ -4365,13 +4560,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
       method: "post",
       path: "/actors",
       request: {
-        body: {
-          content: {
-            "application/json": {
-              schema: ActorsCreateRequestSchema
-            }
-          }
-        }
+        body: buildOpenApiRequestBody(ActorsCreateRequestSchema)
       },
       responses: buildOpenApiResponses(ActorsCreateResponseSchema)
     });
@@ -4393,18 +4582,10 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
   if (registryConfig.test.enabled) {
     router.post(".test/inline-driver/call", async (c) => {
       const buffer = await c.req.arrayBuffer();
-      const {
-        encoding,
-        transport,
-        method,
-        args
-      } = cbor4.decode(
-        new Uint8Array(buffer)
-      );
-      logger().debug({
+      const { encoding, method, args } = cbor4.decode(new Uint8Array(buffer));
+      logger6().debug({
         msg: "received inline request",
         encoding,
-        transport,
         method,
         args
       });
@@ -4415,7 +4596,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
         );
         response = { ok: output };
       } catch (rawErr) {
-        const err = deconstructError(rawErr, logger(), {}, true);
+        const err = deconstructError(rawErr, logger6(), {}, true);
         response = { err };
       }
       return c.body(cbor4.encode(response));
@@ -4432,54 +4613,38 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
         const protocols = protocolHeader.split(/,\s*/);
         let actorId = "";
         let encoding = "bare";
-        let transport = "websocket";
-        let path4 = "";
+        let path = "";
         let params;
-        let connId;
-        let connToken;
         for (const protocol of protocols) {
           if (protocol.startsWith(WS_PROTOCOL_ACTOR)) {
-            actorId = protocol.substring(WS_PROTOCOL_ACTOR.length);
+            actorId = decodeURIComponent(protocol.substring(WS_PROTOCOL_ACTOR.length));
           } else if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
             encoding = protocol.substring(
               WS_PROTOCOL_ENCODING.length
             );
-          } else if (protocol.startsWith(WS_PROTOCOL_TRANSPORT)) {
-            transport = protocol.substring(
-              WS_PROTOCOL_TRANSPORT.length
-            );
-          } else if (protocol.startsWith(WS_PROTOCOL_PATH)) {
-            path4 = decodeURIComponent(
-              protocol.substring(WS_PROTOCOL_PATH.length)
+          } else if (protocol.startsWith(WS_TEST_PROTOCOL_PATH)) {
+            path = decodeURIComponent(
+              protocol.substring(WS_TEST_PROTOCOL_PATH.length)
             );
           } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
             const paramsRaw = decodeURIComponent(
               protocol.substring(WS_PROTOCOL_CONN_PARAMS.length)
             );
             params = JSON.parse(paramsRaw);
-          } else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
-            connId = protocol.substring(WS_PROTOCOL_CONN_ID.length);
-          } else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
-            connToken = protocol.substring(
-              WS_PROTOCOL_CONN_TOKEN.length
-            );
           }
         }
-        logger().debug({
+        logger6().debug({
           msg: "received test inline driver websocket",
           actorId,
           params,
           encodingKind: encoding,
-          transport,
-          path: path4
+          path
         });
         const clientWsPromise = managerDriver.openWebSocket(
-          path4,
+          path,
           actorId,
           encoding,
-          params,
-          connId,
-          connToken
+          params
         );
         return await createTestWebSocketProxy(clientWsPromise);
       })(c, noopNext());
@@ -4492,7 +4657,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
       const pathOnly = c.req.path.split("/.test/inline-driver/send-request/")[1] || "";
       const url = new URL(c.req.url);
       const pathWithQuery = pathOnly + url.search;
-      logger().debug({
+      logger6().debug({
         msg: "received test inline driver raw http",
         actorId,
         path: pathWithQuery,
@@ -4510,11 +4675,11 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
         );
         return response;
       } catch (error) {
-        logger().error({
+        logger6().error({
           msg: "error in test inline raw http",
           error: stringifyError(error)
         });
-        const err = deconstructError(error, logger(), {}, true);
+        const err = deconstructError(error, logger6(), {}, true);
         return c.json(
           {
             error: {
@@ -4533,7 +4698,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
       if (!actorId || !connId) {
         return c.text("Missing actor or conn query parameters", 400);
       }
-      logger().debug({
+      logger6().debug({
         msg: "forcing unclean disconnect",
         actorId,
         connId
@@ -4557,7 +4722,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
         }
         return c.json({ success: true });
       } catch (error) {
-        logger().error({
+        logger6().error({
           msg: "error forcing disconnect",
           error: stringifyError(error)
         });
@@ -4584,7 +4749,7 @@ function createApiActor(actor2, runnerName = "default") {
     namespace_id: "default",
     // Assert default namespace
     runner_name_selector: runnerName,
-    create_ts: Date.now(),
+    create_ts: actor2.createTs ?? Date.now(),
     connectable_ts: null,
     destroy_ts: null,
     sleep_ts: null,
@@ -4598,14 +4763,13 @@ function logger7() {
 }
 
 // src/registry/serve.ts
-import { Hono as Hono4 } from "hono";
-async function crossPlatformServe(runConfig, rivetKitRouter, userRouter) {
-  const app = userRouter ?? new Hono4();
+async function crossPlatformServe(runConfig, app) {
+  const nodeServerModule = "@hono/node-server";
   let serve;
   try {
     const dep = await import(
       /* webpackIgnore: true */
-      "@hono/node-server"
+      nodeServerModule
     );
     serve = dep.serve;
   } catch (err) {
@@ -4614,12 +4778,12 @@ async function crossPlatformServe(runConfig, rivetKitRouter, userRouter) {
     );
     process.exit(1);
   }
-  app.route("/", rivetKitRouter);
+  const nodeWsModule = "@hono/node-ws";
   let createNodeWebSocket;
   try {
     const dep = await import(
       /* webpackIgnore: true */
-      "@hono/node-ws"
+      nodeWsModule
     );
     createNodeWebSocket = dep.createNodeWebSocket;
   } catch (err) {
@@ -4663,7 +4827,7 @@ var Registry = class {
     const readyPromises = [];
     if (config2.runnerKind === "serverless") {
       logger7().debug("disabling health check since using serverless");
-      config2.disableHealthCheck = true;
+      config2.disableMetadataLookup = true;
     }
     if (process.env.NODE_ENV !== "production" && config2.runnerKind === "serverless") {
       if ((inputConfig == null ? void 0 : inputConfig.runEngine) === void 0) config2.runEngine = true;
@@ -4753,17 +4917,6 @@ var Registry = class {
       }
       console.log();
     }
-    if (!config2.disableActorDriver) {
-      Promise.all(readyPromises).then(async () => {
-        logger7().debug("starting actor driver");
-        driver.actor(this.#config, config2, managerDriver, client);
-      });
-    }
-    if (config2.runnerKind === "serverless" && config2.autoConfigureServerless) {
-      Promise.all(readyPromises).then(async () => {
-        await configureServerlessRunner(config2);
-      });
-    }
     const { router: hono } = createManagerRouter(
       this.#config,
       config2,
@@ -4772,10 +4925,22 @@ var Registry = class {
       client
     );
     if (!config2.disableDefaultServer) {
-      (async () => {
-        const out = await crossPlatformServe(config2, hono, void 0);
+      const serverPromise = (async () => {
+        const out = await crossPlatformServe(config2, hono);
         upgradeWebSocket = out.upgradeWebSocket;
       })();
+      readyPromises.push(serverPromise);
+    }
+    if (!config2.disableActorDriver) {
+      Promise.all(readyPromises).then(async () => {
+        logger7().debug("starting actor driver");
+        driver.actor(this.#config, config2, managerDriver, client);
+      });
+    }
+    if (config2.runnerKind === "serverless" && config2.autoConfigureServerless) {
+      Promise.all(readyPromises).then(async () => {
+        await configureServerlessRunner(config2);
+      });
     }
     return {
       client,
@@ -4808,10 +4973,9 @@ async function configureServerlessRunner(config2) {
       namespace: config2.namespace,
       runnerName: config2.runnerName,
       encoding: config2.encoding,
-      transport: config2.transport,
       headers: config2.headers,
       getUpgradeWebSocket: config2.getUpgradeWebSocket,
-      disableHealthCheck: true
+      disableMetadataLookup: true
       // We don't need health check for this operation
     };
     logger7().debug({
@@ -4859,12 +5023,11 @@ function setup(input) {
 }
 
 export {
-  handleWebSocketConnect,
-  handleRawWebSocketHandler,
   RegistryConfigSchema,
+  routeWebSocket,
   createActorRouter,
   actor,
-  InlineWebSocketAdapter2,
+  InlineWebSocketAdapter,
   createEngineDriver,
   createFileSystemOrMemoryDriver,
   createFileSystemDriver,
@@ -4874,4 +5037,4 @@ export {
   setup
 };
 //! These configs configs hold anything that's not platform-specific about running actors.
-//# sourceMappingURL=chunk-BYMKMOBS.js.map
+//# sourceMappingURL=chunk-MBBJUHSP.js.map