rivetkit 2.0.5 → 2.0.7-rc.1

package/dist/tsup/chunk-BW5DPM6Z.js

@@ -0,0 +1,4071 @@
+import {
+  ColumnsSchema,
+  ForeignKeysSchema,
+  PatchSchema,
+  TablesSchema
+} from "./chunk-GZVBFXBI.js";
+import {
+  importWebSocket,
+  logger
+} from "./chunk-E4UVJKSV.js";
+import {
+  HTTP_ACTION_REQUEST_VERSIONED,
+  HTTP_ACTION_RESPONSE_VERSIONED,
+  HTTP_RESPONSE_ERROR_VERSIONED,
+  PERSISTED_ACTOR_VERSIONED,
+  TO_CLIENT_VERSIONED,
+  TO_SERVER_VERSIONED,
+  inputDataToBuffer,
+  processMessage
+} from "./chunk-JD54PXWP.js";
+import {
+  CachedSerializer,
+  DeadlineError,
+  HEADER_CONN_ID,
+  HEADER_CONN_PARAMS,
+  HEADER_CONN_TOKEN,
+  HEADER_ENCODING,
+  HEADER_RIVET_ACTOR,
+  HEADER_RIVET_TARGET,
+  HEADER_RIVET_TOKEN,
+  PATH_CONNECT_WEBSOCKET,
+  PATH_RAW_WEBSOCKET_PREFIX,
+  WS_PROTOCOL_ACTOR,
+  WS_PROTOCOL_CONN_ID,
+  WS_PROTOCOL_CONN_PARAMS,
+  WS_PROTOCOL_CONN_TOKEN,
+  WS_PROTOCOL_ENCODING,
+  WS_PROTOCOL_STANDARD,
+  WS_PROTOCOL_TARGET,
+  WS_PROTOCOL_TOKEN,
+  assertUnreachable as assertUnreachable2,
+  contentTypeForEncoding,
+  deadline,
+  deserializeWithEncoding,
+  encodeDataToString,
+  encodingIsBinary,
+  generateRandomString,
+  generateSecureToken,
+  jsonStringifyCompat,
+  serializeWithEncoding
+} from "./chunk-YQ4XQYPM.js";
+import {
+  getBaseLogger,
+  getIncludeTarget,
+  getLogger
+} from "./chunk-PUSQNDJG.js";
+import {
+  SinglePromiseQueue,
+  assertUnreachable,
+  bufferToArrayBuffer,
+  combineUrlPath,
+  deconstructError,
+  getEnvUniversal,
+  httpUserAgent,
+  isCborSerializable,
+  noopNext,
+  promiseWithResolvers,
+  stringifyError
+} from "./chunk-RVP5RUSC.js";
+import {
+  ActionNotFound,
+  ActionTimedOut,
+  ActorNotFound,
+  ConnStateNotEnabled,
+  DatabaseNotEnabled,
+  FetchHandlerNotDefined,
+  InternalError,
+  InvalidFetchResponse,
+  InvalidRequest,
+  InvalidStateType,
+  StateNotEnabled,
+  VarsNotEnabled
+} from "./chunk-YPZFLUO6.js";
+
+// src/actor/conn.ts
+import * as cbor from "cbor-x";
+
+// src/actor/conn-drivers.ts
+var WEBSOCKET_DRIVER = {
+  sendMessage: (actor, _conn, state, message) => {
+    const serialized = message.serialize(state.encoding);
+    actor.rLog.debug({
+      msg: "sending websocket message",
+      encoding: state.encoding,
+      dataType: typeof serialized,
+      isUint8Array: serialized instanceof Uint8Array,
+      isArrayBuffer: serialized instanceof ArrayBuffer,
+      dataLength: serialized.byteLength || serialized.length
+    });
+    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));
+        actor.rLog.debug({
+          msg: "converted SharedArrayBuffer to ArrayBuffer",
+          byteLength: arrayBuffer.byteLength
+        });
+        state.websocket.send(arrayBuffer);
+      } else {
+        actor.rLog.debug({
+          msg: "sending ArrayBuffer",
+          byteLength: buffer.byteLength
+        });
+        state.websocket.send(buffer);
+      }
+    } else {
+      actor.rLog.debug({
+        msg: "sending string data",
+        length: serialized.length
+      });
+      state.websocket.send(serialized);
+    }
+  },
+  disconnect: async (_actor, _conn, state, reason) => {
+    state.websocket.close(1e3, reason);
+    await state.closePromise.promise;
+  },
+  getConnectionReadyState: (_actor, _conn, state) => {
+    return state.websocket.readyState;
+  }
+};
+var SSE_DRIVER = {
+  sendMessage: (_actor, _conn, state, message) => {
+    state.stream.writeSSE({
+      data: encodeDataToString(message.serialize(state.encoding))
+    });
+  },
+  disconnect: async (_actor, _conn, state, _reason) => {
+    state.stream.close();
+  },
+  getConnectionReadyState: (_actor, _conn, state) => {
+    if (state.stream.aborted || state.stream.closed) {
+      return 3 /* CLOSED */;
+    }
+    return 1 /* OPEN */;
+  }
+};
+var HTTP_DRIVER = {
+  getConnectionReadyState(_actor, _conn) {
+    return 1 /* OPEN */;
+  },
+  disconnect: async () => {
+  }
+};
+var CONN_DRIVERS = {
+  [0 /* WEBSOCKET */]: WEBSOCKET_DRIVER,
+  [1 /* SSE */]: SSE_DRIVER,
+  [2 /* HTTP */]: HTTP_DRIVER
+};
+function getConnDriverKindFromState(state) {
+  if (0 /* WEBSOCKET */ in state) return 0 /* WEBSOCKET */;
+  else if (1 /* SSE */ in state) return 1 /* SSE */;
+  else if (2 /* HTTP */ in state) return 2 /* HTTP */;
+  else assertUnreachable(state);
+}
+
+// src/actor/conn.ts
+function generateConnId() {
+  return crypto.randomUUID();
+}
+function generateConnToken() {
+  return generateSecureToken(32);
+}
+function generateConnSocketId() {
+  return crypto.randomUUID();
+}
+var Conn = class {
+  subscriptions = /* @__PURE__ */ new Set();
+  // TODO: Remove this cyclical reference
+  #actor;
+  /**
+   * The proxied state that notifies of changes automatically.
+   *
+   * Any data that should be stored indefinitely should be held within this object.
+   */
+  __persist;
+  get __driverState() {
+    var _a;
+    return (_a = this.__socket) == null ? void 0 : _a.driverState;
+  }
+  /**
+   * Socket connected to this connection.
+   *
+   * If undefined, then nothing is connected to this.
+   */
+  __socket;
+  get __status() {
+    if (this.__socket) {
+      return "connected";
+    } else {
+      return "reconnecting";
+    }
+  }
+  get params() {
+    return this.__persist.params;
+  }
+  get __stateEnabled() {
+    return this.#actor.connStateEnabled;
+  }
+  /**
+   * Gets the current state of the connection.
+   *
+   * Throws an error if the state is not enabled.
+   */
+  get state() {
+    this.#validateStateEnabled();
+    if (!this.__persist.state) throw new Error("state should exists");
+    return this.__persist.state;
+  }
+  /**
+   * Sets the state of the connection.
+   *
+   * Throws an error if the state is not enabled.
+   */
+  set state(value) {
+    this.#validateStateEnabled();
+    this.__persist.state = value;
+  }
+  /**
+   * Unique identifier for the connection.
+   */
+  get id() {
+    return this.__persist.connId;
+  }
+  /**
+   * Token used to authenticate this request.
+   */
+  get _token() {
+    return this.__persist.token;
+  }
+  /**
+   * Status of the connection.
+   */
+  get status() {
+    return this.__status;
+  }
+  /**
+   * Timestamp of the last time the connection was seen, i.e. the last time the connection was active and checked for liveness.
+   */
+  get lastSeen() {
+    return this.__persist.lastSeen;
+  }
+  /**
+   * Initializes a new instance of the Connection class.
+   *
+   * This should only be constructed by {@link Actor}.
+   *
+   * @protected
+   */
+  constructor(actor, persist) {
+    this.#actor = actor;
+    this.__persist = persist;
+  }
+  #validateStateEnabled() {
+    if (!this.__stateEnabled) {
+      throw new ConnStateNotEnabled();
+    }
+  }
+  /**
+   * Sends a WebSocket message to the client.
+   *
+   * @param message - The message to send.
+   *
+   * @protected
+   */
+  _sendMessage(message) {
+    if (this.__driverState) {
+      const driverKind = getConnDriverKindFromState(this.__driverState);
+      const driver = CONN_DRIVERS[driverKind];
+      if (driver.sendMessage) {
+        driver.sendMessage(
+          this.#actor,
+          this,
+          this.__driverState[driverKind],
+          message
+        );
+      } else {
+        this.#actor.rLog.debug({
+          msg: "conn driver does not support sending messages",
+          conn: this.id
+        });
+      }
+    } else {
+      this.#actor.rLog.warn({
+        msg: "missing connection driver state for send message",
+        conn: this.id
+      });
+    }
+  }
+  /**
+   * Sends an event with arguments to the client.
+   *
+   * @param eventName - The name of the event.
+   * @param args - The arguments for the event.
+   * @see {@link https://rivet.dev/docs/events|Events Documentation}
+   */
+  send(eventName, ...args) {
+    this.#actor.inspector.emitter.emit("eventFired", {
+      type: "event",
+      eventName,
+      args,
+      connId: this.id
+    });
+    this._sendMessage(
+      new CachedSerializer(
+        {
+          body: {
+            tag: "Event",
+            val: {
+              name: eventName,
+              args: bufferToArrayBuffer(cbor.encode(args))
+            }
+          }
+        },
+        TO_CLIENT_VERSIONED
+      )
+    );
+  }
+  /**
+   * Disconnects the client with an optional reason.
+   *
+   * @param reason - The reason for disconnection.
+   */
+  async disconnect(reason) {
+    if (this.__socket && this.__driverState) {
+      const driverKind = getConnDriverKindFromState(this.__driverState);
+      const driver = CONN_DRIVERS[driverKind];
+      if (driver.disconnect) {
+        driver.disconnect(
+          this.#actor,
+          this,
+          this.__driverState[driverKind],
+          reason
+        );
+      } else {
+        this.#actor.rLog.debug({
+          msg: "no disconnect handler for conn driver",
+          conn: this.id
+        });
+      }
+      this.#actor.__connDisconnected(this, true, this.__socket.socketId);
+    } else {
+      this.#actor.rLog.warn({
+        msg: "missing connection driver state for disconnect",
+        conn: this.id
+      });
+    }
+    this.__socket = void 0;
+  }
+};
+
+// src/actor/instance.ts
+import * as cbor2 from "cbor-x";
+import invariant from "invariant";
+import onChange from "on-change";
+
+// src/inspector/actor.ts
+import { sValidator } from "@hono/standard-validator";
+import jsonPatch from "@rivetkit/fast-json-patch";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { createNanoEvents } from "nanoevents";
+import z from "zod/v4";
+function createActorInspectorRouter() {
+  return new Hono().get("/ping", (c) => {
+    return c.json({ message: "pong" }, 200);
+  }).get("/state", async (c) => {
+    if (await c.var.inspector.accessors.isStateEnabled()) {
+      return c.json(
+        {
+          enabled: true,
+          state: await c.var.inspector.accessors.getState()
+        },
+        200
+      );
+    }
+    return c.json({ enabled: false, state: null }, 200);
+  }).patch(
+    "/state",
+    sValidator(
+      "json",
+      z.object({ patch: PatchSchema }).or(z.object({ replace: z.any() }))
+    ),
+    async (c) => {
+      if (!await c.var.inspector.accessors.isStateEnabled()) {
+        return c.json({ enabled: false }, 200);
+      }
+      const body = c.req.valid("json");
+      if ("replace" in body) {
+        await c.var.inspector.accessors.setState(body.replace);
+        return c.json(
+          {
+            enabled: true,
+            state: await c.var.inspector.accessors.getState()
+          },
+          200
+        );
+      }
+      const state = await c.var.inspector.accessors.getState();
+      const { newDocument: newState } = jsonPatch.applyPatch(
+        state,
+        body.patch
+      );
+      await c.var.inspector.accessors.setState(newState);
+      return c.json(
+        { enabled: true, state: await c.var.inspector.accessors.getState() },
+        200
+      );
+    }
+  ).get("/state/stream", async (c) => {
+    if (!await c.var.inspector.accessors.isStateEnabled()) {
+      return c.json({ enabled: false }, 200);
+    }
+    let id = 0;
+    let unsub;
+    return streamSSE(
+      c,
+      async (stream) => {
+        unsub = c.var.inspector.emitter.on("stateUpdated", async (state) => {
+          stream.writeSSE({
+            data: JSON.stringify(state) || "",
+            event: "state-update",
+            id: String(id++)
+          });
+        });
+        const { promise } = promiseWithResolvers();
+        return promise;
+      },
+      async () => {
+        unsub == null ? void 0 : unsub();
+      }
+    );
+  }).get("/connections", async (c) => {
+    const connections = await c.var.inspector.accessors.getConnections();
+    return c.json({ connections }, 200);
+  }).get("/connections/stream", async (c) => {
+    let id = 0;
+    let unsub;
+    return streamSSE(
+      c,
+      async (stream) => {
+        unsub = c.var.inspector.emitter.on("connectionUpdated", async () => {
+          stream.writeSSE({
+            data: JSON.stringify(
+              await c.var.inspector.accessors.getConnections()
+            ),
+            event: "connection-update",
+            id: String(id++)
+          });
+        });
+        const { promise } = promiseWithResolvers();
+        return promise;
+      },
+      async () => {
+        unsub == null ? void 0 : unsub();
+      }
+    );
+  }).get("/events", async (c) => {
+    const events = c.var.inspector.lastRealtimeEvents;
+    return c.json({ events }, 200);
+  }).post("/events/clear", async (c) => {
+    c.var.inspector.lastRealtimeEvents.length = 0;
+    return c.json({ message: "Events cleared" }, 200);
+  }).get("/events/stream", async (c) => {
+    let id = 0;
+    let unsub;
+    return streamSSE(
+      c,
+      async (stream) => {
+        unsub = c.var.inspector.emitter.on("eventFired", () => {
+          stream.writeSSE({
+            data: JSON.stringify(c.var.inspector.lastRealtimeEvents),
+            event: "realtime-event",
+            id: String(id++)
+          });
+        });
+        const { promise } = promiseWithResolvers();
+        return promise;
+      },
+      async () => {
+        unsub == null ? void 0 : unsub();
+      }
+    );
+  }).get("/rpcs", async (c) => {
+    const rpcs = await c.var.inspector.accessors.getRpcs();
+    return c.json({ rpcs }, 200);
+  }).get("/db", async (c) => {
+    if (!await c.var.inspector.accessors.isDbEnabled()) {
+      return c.json({ enabled: false, db: null }, 200);
+    }
+    const db = await c.var.inspector.accessors.getDb();
+    const rows = await db.execute(`PRAGMA table_list`);
+    const tables = TablesSchema.parse(rows).filter(
+      (table) => table.schema !== "temp" && !table.name.startsWith("sqlite_")
+    );
+    const tablesInfo = await Promise.all(
+      tables.map((table) => db.execute(`PRAGMA table_info(${table.name})`))
+    );
+    const columns = tablesInfo.map((def) => ColumnsSchema.parse(def));
+    const foreignKeysList = await Promise.all(
+      tables.map(
+        (table) => db.execute(`PRAGMA foreign_key_list(${table.name})`)
+      )
+    );
+    const foreignKeys = foreignKeysList.map(
+      (def) => ForeignKeysSchema.parse(def)
+    );
+    const countInfo = await Promise.all(
+      tables.map(
+        (table) => db.execute(`SELECT COUNT(*) as count FROM ${table.name}`)
+      )
+    );
+    const counts = countInfo.map((def) => {
+      return def[0].count || 0;
+    });
+    return c.json(
+      {
+        enabled: true,
+        db: tablesInfo.map((_, index) => {
+          return {
+            table: tables[index],
+            columns: columns[index],
+            foreignKeys: foreignKeys[index],
+            records: counts[index]
+          };
+        })
+      },
+      200
+    );
+  }).post(
+    "/db",
+    sValidator(
+      "json",
+      z.object({ query: z.string(), params: z.array(z.any()).optional() })
+    ),
+    async (c) => {
+      if (!await c.var.inspector.accessors.isDbEnabled()) {
+        return c.json({ enabled: false }, 200);
+      }
+      const db = await c.var.inspector.accessors.getDb();
+      try {
+        const result = await db.execute(
+          c.req.valid("json").query,
+          ...c.req.valid("json").params || []
+        );
+        return c.json({ result }, 200);
+      } catch (error) {
+        c;
+        return c.json({ error: error.message }, 500);
+      }
+    }
+  );
+}
+var ActorInspector = class {
+  accessors;
+  emitter = createNanoEvents();
+  #lastRealtimeEvents = [];
+  get lastRealtimeEvents() {
+    return this.#lastRealtimeEvents;
+  }
+  constructor(accessors) {
+    this.accessors = accessors();
+    this.emitter.on("eventFired", (event) => {
+      this.#lastRealtimeEvents.push({
+        id: crypto.randomUUID(),
+        timestamp: Date.now(),
+        ...event
+      });
+      if (this.#lastRealtimeEvents.length > 100) {
+        this.#lastRealtimeEvents = this.#lastRealtimeEvents.slice(-100);
+      }
+    });
+  }
+};
+
+// src/actor/context.ts
+var ActorContext = class {
+  #actor;
+  constructor(actor) {
+    this.#actor = actor;
+  }
+  /**
+   * Get the actor state
+   */
+  get state() {
+    return this.#actor.state;
+  }
+  /**
+   * Get the actor variables
+   */
+  get vars() {
+    return this.#actor.vars;
+  }
+  /**
+   * Broadcasts an event to all connected clients.
+   * @param name - The name of the event.
+   * @param args - The arguments to send with the event.
+   */
+  broadcast(name, ...args) {
+    this.#actor._broadcast(name, ...args);
+    return;
+  }
+  /**
+   * Gets the logger instance.
+   */
+  get log() {
+    return this.#actor.log;
+  }
+  /**
+   * Gets actor ID.
+   */
+  get actorId() {
+    return this.#actor.id;
+  }
+  /**
+   * Gets the actor name.
+   */
+  get name() {
+    return this.#actor.name;
+  }
+  /**
+   * Gets the actor key.
+   */
+  get key() {
+    return this.#actor.key;
+  }
+  /**
+   * Gets the region.
+   */
+  get region() {
+    return this.#actor.region;
+  }
+  /**
+   * Gets the scheduler.
+   */
+  get schedule() {
+    return this.#actor.schedule;
+  }
+  /**
+   * Gets the map of connections.
+   */
+  get conns() {
+    return this.#actor.conns;
+  }
+  /**
+   * Returns the client for the given registry.
+   */
+  client() {
+    return this.#actor.inlineClient;
+  }
+  /**
+   * Gets the database.
+   * @experimental
+   * @throws {DatabaseNotEnabled} If the database is not enabled.
+   */
+  get db() {
+    return this.#actor.db;
+  }
+  /**
+   * Forces the state to get saved.
+   *
+   * @param opts - Options for saving the state.
+   */
+  async saveState(opts) {
+    return this.#actor.saveState(opts);
+  }
+  /**
+   * Prevents the actor from sleeping until promise is complete.
+   */
+  waitUntil(promise) {
+    this.#actor._waitUntil(promise);
+  }
+  /**
+   * AbortSignal that fires when the actor is stopping.
+   */
+  get abortSignal() {
+    return this.#actor.abortSignal;
+  }
+  /**
+   * Forces the actor to sleep.
+   *
+   * Not supported on all drivers.
+   *
+   * @experimental
+   */
+  sleep() {
+    this.#actor._sleep();
+  }
+};
+
+// src/actor/keys.ts
+var EMPTY_KEY = "/";
+var KEY_SEPARATOR = "/";
+function serializeActorKey(key) {
+  if (key.length === 0) {
+    return EMPTY_KEY;
+  }
+  const escapedParts = key.map((part) => {
+    if (part === "") {
+      return "\\0";
+    }
+    let escaped = part.replace(/\\/g, "\\\\");
+    escaped = escaped.replace(/\//g, `\\${KEY_SEPARATOR}`);
+    return escaped;
+  });
+  return escapedParts.join(KEY_SEPARATOR);
+}
+function deserializeActorKey(keyString) {
+  if (keyString === void 0 || keyString === null || keyString === EMPTY_KEY) {
+    return [];
+  }
+  const parts = [];
+  let currentPart = "";
+  let escaping = false;
+  let isEmptyStringMarker = false;
+  for (let i = 0; i < keyString.length; i++) {
+    const char = keyString[i];
+    if (escaping) {
+      if (char === "0") {
+        isEmptyStringMarker = true;
+      } else {
+        currentPart += char;
+      }
+      escaping = false;
+    } else if (char === "\\") {
+      escaping = true;
+    } else if (char === KEY_SEPARATOR) {
+      if (isEmptyStringMarker) {
+        parts.push("");
+        isEmptyStringMarker = false;
+      } else {
+        parts.push(currentPart);
+      }
+      currentPart = "";
+    } else {
+      currentPart += char;
+    }
+  }
+  if (escaping) {
+    parts.push(currentPart + "\\");
+  } else if (isEmptyStringMarker) {
+    parts.push("");
+  } else if (currentPart !== "" || parts.length > 0) {
+    parts.push(currentPart);
+  }
+  return parts;
+}
+
+// src/actor/schedule.ts
+var Schedule = class {
+  #actor;
+  constructor(actor) {
+    this.#actor = actor;
+  }
+  async after(duration, fn, ...args) {
+    await this.#actor.scheduleEvent(Date.now() + duration, fn, args);
+  }
+  async at(timestamp, fn, ...args) {
+    await this.#actor.scheduleEvent(timestamp, fn, args);
+  }
+};
+
+// src/actor/instance.ts
+var ActorInstance = class {
+  // Shared actor context for this instance
+  actorContext;
+  /** Actor log, intended for the user to call */
+  #log;
+  /** Runtime log, intended for internal actor logs */
+  #rLog;
+  #sleepCalled = false;
+  #stopCalled = false;
+  get isStopping() {
+    return this.#stopCalled || this.#sleepCalled;
+  }
+  #persistChanged = false;
+  #isInOnStateChange = false;
+  /**
+   * The proxied state that notifies of changes automatically.
+   *
+   * Any data that should be stored indefinitely should be held within this object.
+   */
+  #persist;
+  /** Raw state without the proxy wrapper */
+  #persistRaw;
+  #persistWriteQueue = new SinglePromiseQueue();
+  #alarmWriteQueue = new SinglePromiseQueue();
+  #lastSaveTime = 0;
+  #pendingSaveTimeout;
+  #vars;
+  #backgroundPromises = [];
+  #abortController = new AbortController();
+  #config;
+  #actorDriver;
+  #inlineClient;
+  #actorId;
+  #name;
+  #key;
+  #region;
+  #ready = false;
+  #connections = /* @__PURE__ */ new Map();
+  #subscriptionIndex = /* @__PURE__ */ new Map();
+  #checkConnLivenessInterval;
+  #sleepTimeout;
+  // Track active raw requests so sleep logic can account for them
+  #activeRawFetchCount = 0;
+  #activeRawWebSockets = /* @__PURE__ */ new Set();
+  #schedule;
+  #db;
+  #inspector = new ActorInspector(() => {
+    return {
+      isDbEnabled: async () => {
+        return this.#db !== void 0;
+      },
+      getDb: async () => {
+        return this.db;
+      },
+      isStateEnabled: async () => {
+        return this.stateEnabled;
+      },
+      getState: async () => {
+        this.#validateStateEnabled();
+        return this.#persistRaw.state;
+      },
+      getRpcs: async () => {
+        return Object.keys(this.#config.actions);
+      },
+      getConnections: async () => {
+        return Array.from(this.#connections.entries()).map(([id, conn]) => ({
+          id,
+          stateEnabled: conn.__stateEnabled,
+          params: conn.params,
+          state: conn.__stateEnabled ? conn.state : void 0
+        }));
+      },
+      setState: async (state) => {
+        this.#validateStateEnabled();
+        this.#persist.state = { ...state };
+        await this.saveState({ immediate: true });
+      }
+    };
+  });
+  get id() {
+    return this.#actorId;
+  }
+  get inlineClient() {
+    return this.#inlineClient;
+  }
+  get inspector() {
+    return this.#inspector;
+  }
+  get #sleepingSupported() {
+    return this.#actorDriver.sleep !== void 0;
+  }
+  /**
+   * This constructor should never be used directly.
+   *
+   * Constructed in {@link ActorInstance.start}.
+   *
+   * @private
+   */
+  constructor(config) {
+    this.#config = config;
+    this.actorContext = new ActorContext(this);
+  }
+  async start(actorDriver, inlineClient, actorId, name, key, region) {
+    var _a, _b;
+    const logParams = {
+      actor: name,
+      key: serializeActorKey(key),
+      actorId
+    };
+    this.#log = getBaseLogger().child(
+      Object.assign(getIncludeTarget() ? { target: "actor" } : {}, logParams)
+    );
+    this.#rLog = getBaseLogger().child(
+      Object.assign(
+        getIncludeTarget() ? { target: "actor-runtime" } : {},
+        logParams
+      )
+    );
+    this.#actorDriver = actorDriver;
+    this.#inlineClient = inlineClient;
+    this.#actorId = actorId;
+    this.#name = name;
+    this.#key = key;
+    this.#region = region;
+    this.#schedule = new Schedule(this);
+    await this.#initialize();
+    if (this.#varsEnabled) {
+      let vars;
+      if ("createVars" in this.#config) {
+        const dataOrPromise = this.#config.createVars(
+          this.actorContext,
+          this.#actorDriver.getContext(this.#actorId)
+        );
+        if (dataOrPromise instanceof Promise) {
+          vars = await deadline(
+            dataOrPromise,
+            this.#config.options.createVarsTimeout
+          );
+        } else {
+          vars = dataOrPromise;
+        }
+      } else if ("vars" in this.#config) {
+        vars = structuredClone(this.#config.vars);
+      } else {
+        throw new Error("Could not variables from 'createVars' or 'vars'");
+      }
+      this.#vars = vars;
+    }
+    this.#rLog.info({ msg: "actor starting" });
+    if (this.#config.onStart) {
+      const result = this.#config.onStart(this.actorContext);
+      if (result instanceof Promise) {
+        await result;
+      }
+    }
+    if ("db" in this.#config && this.#config.db) {
+      const client = await this.#config.db.createClient({
+        getDatabase: () => actorDriver.getDatabase(this.#actorId)
+      });
+      this.#rLog.info({ msg: "database migration starting" });
+      await ((_b = (_a = this.#config.db).onMigrate) == null ? void 0 : _b.call(_a, client));
+      this.#rLog.info({ msg: "database migration complete" });
+      this.#db = client;
+    }
+    if (this.#persist.scheduledEvents.length > 0) {
+      await this.#queueSetAlarm(this.#persist.scheduledEvents[0].timestamp);
+    }
+    this.#rLog.info({ msg: "actor ready" });
+    this.#ready = true;
+    this.#resetSleepTimer();
+    this.#checkConnLivenessInterval = setInterval(
+      this.#checkConnectionsLiveness.bind(this),
+      this.#config.options.connectionLivenessInterval
+    );
+    this.#checkConnectionsLiveness();
+  }
+  async #scheduleEventInner(newEvent) {
+    this.actorContext.log.info({ msg: "scheduling event", ...newEvent });
+    const insertIndex = this.#persist.scheduledEvents.findIndex(
+      (x) => x.timestamp > newEvent.timestamp
+    );
+    if (insertIndex === -1) {
+      this.#persist.scheduledEvents.push(newEvent);
+    } else {
+      this.#persist.scheduledEvents.splice(insertIndex, 0, newEvent);
+    }
+    if (insertIndex === 0 || this.#persist.scheduledEvents.length === 1) {
+      this.actorContext.log.info({
+        msg: "setting alarm",
+        timestamp: newEvent.timestamp,
+        eventCount: this.#persist.scheduledEvents.length
+      });
+      await this.#queueSetAlarm(newEvent.timestamp);
+    }
+  }
+  async _onAlarm() {
+    const now = Date.now();
+    this.actorContext.log.debug({
+      msg: "alarm triggered",
+      now,
+      events: this.#persist.scheduledEvents.length
+    });
+    this.#resetSleepTimer();
+    const runIndex = this.#persist.scheduledEvents.findIndex(
+      (x) => x.timestamp <= now
+    );
+    if (runIndex === -1) {
+      this.#rLog.warn({ msg: "no events are due yet, time may have broken" });
+      if (this.#persist.scheduledEvents.length > 0) {
+        const nextTs = this.#persist.scheduledEvents[0].timestamp;
+        this.actorContext.log.warn({
+          msg: "alarm fired early, rescheduling for next event",
+          now,
+          nextTs,
+          delta: nextTs - now
+        });
+        await this.#queueSetAlarm(nextTs);
+      }
+      this.actorContext.log.debug({ msg: "no events to run", now });
+      return;
+    }
+    const scheduleEvents = this.#persist.scheduledEvents.splice(
+      0,
+      runIndex + 1
+    );
+    this.actorContext.log.debug({
+      msg: "running events",
+      count: scheduleEvents.length
+    });
+    if (this.#persist.scheduledEvents.length > 0) {
+      const nextTs = this.#persist.scheduledEvents[0].timestamp;
+      this.actorContext.log.info({
+        msg: "setting next alarm",
+        nextTs,
+        remainingEvents: this.#persist.scheduledEvents.length
+      });
+      await this.#queueSetAlarm(nextTs);
+    }
+    for (const event of scheduleEvents) {
+      try {
+        this.actorContext.log.info({
+          msg: "running action for event",
+          event: event.eventId,
+          timestamp: event.timestamp,
+          action: event.kind.generic.actionName
+        });
+        const fn = this.#config.actions[event.kind.generic.actionName];
+        if (!fn)
+          throw new Error(
+            `Missing action for alarm ${event.kind.generic.actionName}`
+          );
+        if (typeof fn !== "function")
+          throw new Error(
+            `Alarm function lookup for ${event.kind.generic.actionName} returned ${typeof fn}`
+          );
+        try {
+          const args = event.kind.generic.args ? cbor2.decode(new Uint8Array(event.kind.generic.args)) : [];
+          await fn.call(void 0, this.actorContext, ...args);
+        } catch (error) {
+          this.actorContext.log.error({
+            msg: "error while running event",
+            error: stringifyError(error),
+            event: event.eventId,
+            timestamp: event.timestamp,
+            action: event.kind.generic.actionName
+          });
+        }
+      } catch (error) {
+        this.actorContext.log.error({
+          msg: "internal error while running event",
+          error: stringifyError(error),
+          ...event
+        });
+      }
+    }
+  }
+  async scheduleEvent(timestamp, action, args) {
+    return this.#scheduleEventInner({
+      eventId: crypto.randomUUID(),
+      timestamp,
+      kind: {
+        generic: {
+          actionName: action,
+          args: bufferToArrayBuffer(cbor2.encode(args))
+        }
+      }
+    });
+  }
+  get stateEnabled() {
+    return "createState" in this.#config || "state" in this.#config;
+  }
+  #validateStateEnabled() {
+    if (!this.stateEnabled) {
+      throw new StateNotEnabled();
+    }
+  }
+  get connStateEnabled() {
+    return "createConnState" in this.#config || "connState" in this.#config;
+  }
+  get #varsEnabled() {
+    return "createVars" in this.#config || "vars" in this.#config;
+  }
+  #validateVarsEnabled() {
+    if (!this.#varsEnabled) {
+      throw new VarsNotEnabled();
+    }
+  }
+  /** Promise used to wait for a save to complete. This is required since you cannot await `#saveStateThrottled`. */
+  #onPersistSavedPromise;
+  /** Throttled save state method. Used to write to KV at a reasonable cadence. */
+  #savePersistThrottled() {
+    const now = Date.now();
+    const timeSinceLastSave = now - this.#lastSaveTime;
+    const saveInterval = this.#config.options.stateSaveInterval;
+    if (timeSinceLastSave < saveInterval) {
+      if (this.#pendingSaveTimeout === void 0) {
+        this.#pendingSaveTimeout = setTimeout(() => {
+          this.#pendingSaveTimeout = void 0;
+          this.#savePersistInner();
+        }, saveInterval - timeSinceLastSave);
+      }
+    } else {
+      this.#savePersistInner();
+    }
+  }
+  /** Saves the state to KV. You probably want to use #saveStateThrottled instead except for a few edge cases. */
+  async #savePersistInner() {
+    var _a, _b;
+    try {
+      this.#lastSaveTime = Date.now();
+      if (this.#persistChanged) {
+        const finished = this.#persistWriteQueue.enqueue(async () => {
+          this.#rLog.debug({ msg: "saving persist" });
+          this.#persistChanged = false;
+          const bareData = this.#convertToBarePersisted(this.#persistRaw);
+          await this.#actorDriver.writePersistedData(
+            this.#actorId,
+            PERSISTED_ACTOR_VERSIONED.serializeWithEmbeddedVersion(bareData)
+          );
+          this.#rLog.debug({ msg: "persist saved" });
+        });
+        await finished;
+      }
+      (_a = this.#onPersistSavedPromise) == null ? void 0 : _a.resolve();
+    } catch (error) {
+      (_b = this.#onPersistSavedPromise) == null ? void 0 : _b.reject(error);
+      throw error;
+    }
+  }
+  async #queueSetAlarm(timestamp) {
+    await this.#alarmWriteQueue.enqueue(async () => {
+      await this.#actorDriver.setAlarm(this, timestamp);
+    });
+  }
+  /**
+   * Creates proxy for `#persist` that handles automatically flagging when state needs to be updated.
+   */
+  #setPersist(target) {
+    this.#persistRaw = target;
+    if (target === null || typeof target !== "object") {
+      let invalidPath = "";
+      if (!isCborSerializable(
+        target,
+        (path) => {
+          invalidPath = path;
+        },
+        ""
+      )) {
+        throw new InvalidStateType({ path: invalidPath });
+      }
+      return target;
+    }
+    if (this.#persist) {
+      onChange.unsubscribe(this.#persist);
+    }
+    this.#persist = onChange(
+      target,
+      // biome-ignore lint/suspicious/noExplicitAny: Don't know types in proxy
+      (path, value, _previousValue, _applyData) => {
+        if (path !== "state" && !path.startsWith("state.")) {
+          return;
+        }
+        let invalidPath = "";
+        if (!isCborSerializable(
+          value,
+          (invalidPathPart) => {
+            invalidPath = invalidPathPart;
+          },
+          ""
+        )) {
+          throw new InvalidStateType({
+            path: path + (invalidPath ? `.${invalidPath}` : "")
+          });
+        }
+        this.#persistChanged = true;
+        this.inspector.emitter.emit("stateUpdated", this.#persist.state);
+        if (this.#config.onStateChange && this.#ready && !this.#isInOnStateChange) {
+          try {
+            this.#isInOnStateChange = true;
+            this.#config.onStateChange(
+              this.actorContext,
+              this.#persistRaw.state
+            );
+          } catch (error) {
+            this.#rLog.error({
+              msg: "error in `_onStateChange`",
+              error: stringifyError(error)
+            });
+          } finally {
+            this.#isInOnStateChange = false;
+          }
+        }
+      },
+      { ignoreDetached: true }
+    );
+  }
+  async #initialize() {
+    const persistDataBuffer = await this.#actorDriver.readPersistedData(
+      this.#actorId
+    );
+    invariant(
+      persistDataBuffer !== void 0,
+      "persist data has not been set, it should be set when initialized"
+    );
+    const bareData = PERSISTED_ACTOR_VERSIONED.deserializeWithEmbeddedVersion(
+      persistDataBuffer
+    );
+    const persistData = this.#convertFromBarePersisted(bareData);
+    if (persistData.hasInitiated) {
+      this.#rLog.info({
+        msg: "actor restoring",
+        connections: persistData.connections.length
+      });
+      this.#setPersist(persistData);
+      for (const connPersist of this.#persist.connections) {
+        const conn = new Conn(this, connPersist);
+        this.#connections.set(conn.id, conn);
+        for (const sub of connPersist.subscriptions) {
+          this.#addSubscription(sub.eventName, conn, true);
+        }
+      }
+    } else {
+      this.#rLog.info({ msg: "actor creating" });
+      let stateData;
+      if (this.stateEnabled) {
+        this.#rLog.info({ msg: "actor state initializing" });
+        if ("createState" in this.#config) {
+          this.#config.createState;
+          stateData = await this.#config.createState(
+            this.actorContext,
+            persistData.input
+          );
+        } else if ("state" in this.#config) {
+          stateData = structuredClone(this.#config.state);
+        } else {
+          throw new Error("Both 'createState' or 'state' were not defined");
+        }
+      } else {
+        this.#rLog.debug({ msg: "state not enabled" });
+      }
+      persistData.state = stateData;
+      persistData.hasInitiated = true;
+      this.#rLog.debug({ msg: "writing state" });
+      const bareData2 = this.#convertToBarePersisted(persistData);
+      await this.#actorDriver.writePersistedData(
+        this.#actorId,
+        PERSISTED_ACTOR_VERSIONED.serializeWithEmbeddedVersion(bareData2)
+      );
+      this.#setPersist(persistData);
+      if (this.#config.onCreate) {
+        await this.#config.onCreate(this.actorContext, persistData.input);
+      }
+    }
+  }
+  __getConnForId(id) {
+    return this.#connections.get(id);
+  }
+  /**
+   * Connection disconnected.
+   *
+   * If a clean diconnect, will be removed immediately.
+   *
+   * If not a clean disconnect, will keep the connection alive for a given interval to wait for reconnect.
+   */
+  __connDisconnected(conn, wasClean, socketId) {
+    if (socketId && conn.__socket && socketId !== conn.__socket.socketId) {
+      this.rLog.debug({
+        msg: "ignoring stale disconnect event",
+        connId: conn.id,
+        eventSocketId: socketId,
+        currentSocketId: conn.__socket.socketId
+      });
+      return;
+    }
+    if (wasClean) {
+      this.#removeConn(conn);
+    } else {
+      if (!conn.__driverState) {
+        this.rLog.warn("called conn disconnected without driver state");
+      }
+      conn.__persist.lastSeen = Date.now();
+      conn.__socket = void 0;
+    }
+  }
+  /**
+   * Removes a connection and cleans up its resources.
+   */
+  #removeConn(conn) {
+    const connIdx = this.#persist.connections.findIndex(
+      (c) => c.connId === conn.id
+    );
+    if (connIdx !== -1) {
+      this.#persist.connections.splice(connIdx, 1);
+      this.saveState({ immediate: true, allowStoppingState: true });
+    } else {
+      this.#rLog.warn({
+        msg: "could not find persisted connection to remove",
+        connId: conn.id
+      });
+    }
+    this.#connections.delete(conn.id);
+    for (const eventName of [...conn.subscriptions.values()]) {
+      this.#removeSubscription(eventName, conn, true);
+    }
+    this.inspector.emitter.emit("connectionUpdated");
+    if (this.#config.onDisconnect) {
+      try {
+        const result = this.#config.onDisconnect(this.actorContext, conn);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            this.#rLog.error({
+              msg: "error in `onDisconnect`",
+              error: stringifyError(error)
+            });
+          });
+        }
+      } catch (error) {
+        this.#rLog.error({
+          msg: "error in `onDisconnect`",
+          error: stringifyError(error)
+        });
+      }
+    }
+    this.#resetSleepTimer();
+  }
+  /**
+   * Called to create a new connection or reconnect an existing one.
+   */
+  async createConn(socket, params, request, connectionId, connectionToken) {
+    this.#assertReady();
+    if (connectionId && connectionToken) {
+      this.rLog.debug({
+        msg: "checking for existing connection",
+        connectionId
+      });
+      const existingConn = this.#connections.get(connectionId);
+      if (existingConn && existingConn._token === connectionToken) {
+        this.rLog.debug({
+          msg: "reconnecting existing connection",
+          connectionId
+        });
+        if (existingConn.__driverState) {
+          const driverKind = getConnDriverKindFromState(
+            existingConn.__driverState
+          );
+          const driver = CONN_DRIVERS[driverKind];
+          if (driver.disconnect) {
+            driver.disconnect(
+              this,
+              existingConn,
+              existingConn.__driverState[driverKind],
+              "Reconnecting with new driver state"
+            );
+          }
+        }
+        existingConn.__socket = socket;
+        existingConn.__persist.lastSeen = Date.now();
+        this.#resetSleepTimer();
+        this.inspector.emitter.emit("connectionUpdated");
+        existingConn._sendMessage(
+          new CachedSerializer(
+            {
+              body: {
+                tag: "Init",
+                val: {
+                  actorId: this.id,
+                  connectionId: existingConn.id,
+                  connectionToken: existingConn._token
+                }
+              }
+            },
+            TO_CLIENT_VERSIONED
+          )
+        );
+        return existingConn;
+      }
+      this.rLog.debug({
+        msg: "connection not found or token mismatch, creating new connection",
+        connectionId
+      });
+    }
+    const newConnId = generateConnId();
+    const newConnToken = generateConnToken();
+    if (this.#connections.has(newConnId)) {
+      throw new Error(`Connection already exists: ${newConnId}`);
+    }
+    let connState;
+    const onBeforeConnectOpts = {
+      request
+    };
+    if (this.#config.onBeforeConnect) {
+      await this.#config.onBeforeConnect(
+        this.actorContext,
+        onBeforeConnectOpts,
+        params
+      );
+    }
+    if (this.connStateEnabled) {
+      if ("createConnState" in this.#config) {
+        const dataOrPromise = this.#config.createConnState(
+          this.actorContext,
+          onBeforeConnectOpts,
+          params
+        );
+        if (dataOrPromise instanceof Promise) {
+          connState = await deadline(
+            dataOrPromise,
+            this.#config.options.createConnStateTimeout
+          );
+        } else {
+          connState = dataOrPromise;
+        }
+      } else if ("connState" in this.#config) {
+        connState = structuredClone(this.#config.connState);
+      } else {
+        throw new Error(
+          "Could not create connection state from 'createConnState' or 'connState'"
+        );
+      }
+    }
+    const persist = {
+      connId: newConnId,
+      token: newConnToken,
+      params,
+      state: connState,
+      lastSeen: Date.now(),
+      subscriptions: []
+    };
+    const conn = new Conn(this, persist);
+    conn.__socket = socket;
+    this.#connections.set(conn.id, conn);
+    this.#resetSleepTimer();
+    this.#persist.connections.push(persist);
+    this.saveState({ immediate: true });
+    if (this.#config.onConnect) {
+      try {
+        const result = this.#config.onConnect(this.actorContext, conn);
+        if (result instanceof Promise) {
+          deadline(result, this.#config.options.onConnectTimeout).catch(
+            (error) => {
+              this.#rLog.error({
+                msg: "error in `onConnect`, closing socket",
+                error
+              });
+              conn == null ? void 0 : conn.disconnect("`onConnect` failed");
+            }
+          );
+        }
+      } catch (error) {
+        this.#rLog.error({
+          msg: "error in `onConnect`",
+          error: stringifyError(error)
+        });
+        conn == null ? void 0 : conn.disconnect("`onConnect` failed");
+      }
+    }
+    this.inspector.emitter.emit("connectionUpdated");
+    conn._sendMessage(
+      new CachedSerializer(
+        {
+          body: {
+            tag: "Init",
+            val: {
+              actorId: this.id,
+              connectionId: conn.id,
+              connectionToken: conn._token
+            }
+          }
+        },
+        TO_CLIENT_VERSIONED
+      )
+    );
+    return conn;
+  }
+  // MARK: Messages
+  async processMessage(message, conn) {
+    await processMessage(message, this, conn, {
+      onExecuteAction: async (ctx, name, args) => {
+        this.inspector.emitter.emit("eventFired", {
+          type: "action",
+          name,
+          args,
+          connId: conn.id
+        });
+        return await this.executeAction(ctx, name, args);
+      },
+      onSubscribe: async (eventName, conn2) => {
+        this.inspector.emitter.emit("eventFired", {
+          type: "subscribe",
+          eventName,
+          connId: conn2.id
+        });
+        this.#addSubscription(eventName, conn2, false);
+      },
+      onUnsubscribe: async (eventName, conn2) => {
+        this.inspector.emitter.emit("eventFired", {
+          type: "unsubscribe",
+          eventName,
+          connId: conn2.id
+        });
+        this.#removeSubscription(eventName, conn2, false);
+      }
+    });
+  }
+  // MARK: Events
+  #addSubscription(eventName, connection, fromPersist) {
+    if (connection.subscriptions.has(eventName)) {
+      this.#rLog.debug({
+        msg: "connection already has subscription",
+        eventName
+      });
+      return;
+    }
+    if (!fromPersist) {
+      connection.__persist.subscriptions.push({ eventName });
+      this.saveState({ immediate: true });
+    }
+    connection.subscriptions.add(eventName);
+    let subscribers = this.#subscriptionIndex.get(eventName);
+    if (!subscribers) {
+      subscribers = /* @__PURE__ */ new Set();
+      this.#subscriptionIndex.set(eventName, subscribers);
+    }
+    subscribers.add(connection);
+  }
+  #removeSubscription(eventName, connection, fromRemoveConn) {
+    if (!connection.subscriptions.has(eventName)) {
+      this.#rLog.warn({
+        msg: "connection does not have subscription",
+        eventName
+      });
+      return;
+    }
+    if (!fromRemoveConn) {
+      connection.subscriptions.delete(eventName);
+      const subIdx = connection.__persist.subscriptions.findIndex(
+        (s) => s.eventName === eventName
+      );
+      if (subIdx !== -1) {
+        connection.__persist.subscriptions.splice(subIdx, 1);
+      } else {
+        this.#rLog.warn({
+          msg: "subscription does not exist with name",
+          eventName
+        });
+      }
+      this.saveState({ immediate: true });
+    }
+    const subscribers = this.#subscriptionIndex.get(eventName);
+    if (subscribers) {
+      subscribers.delete(connection);
+      if (subscribers.size === 0) {
+        this.#subscriptionIndex.delete(eventName);
+      }
+    }
+  }
+  #assertReady(allowStoppingState = false) {
+    if (!this.#ready) throw new InternalError("Actor not ready");
+    if (!allowStoppingState && this.#sleepCalled)
+      throw new InternalError("Actor is going to sleep");
+    if (!allowStoppingState && this.#stopCalled)
+      throw new InternalError("Actor is stopping");
+  }
+  /**
+   * Check the liveness of all connections.
+   * Sets up a recurring check based on the configured interval.
+   */
+  #checkConnectionsLiveness() {
+    this.#rLog.debug({ msg: "checking connections liveness" });
+    for (const conn of this.#connections.values()) {
+      if (conn.__status === "connected") {
+        this.#rLog.debug({ msg: "connection is alive", connId: conn.id });
+      } else {
+        const lastSeen = conn.__persist.lastSeen;
+        const sinceLastSeen = Date.now() - lastSeen;
+        if (sinceLastSeen < this.#config.options.connectionLivenessTimeout) {
+          this.#rLog.debug({
+            msg: "connection might be alive, will check later",
+            connId: conn.id,
+            lastSeen,
+            sinceLastSeen
+          });
+          continue;
+        }
+        this.#rLog.warn({
+          msg: "connection is dead, removing",
+          connId: conn.id,
+          lastSeen
+        });
+        this.#removeConn(conn);
+      }
+    }
+  }
+  /**
+   * Check if the actor is ready to handle requests.
+   */
+  isReady() {
+    return this.#ready;
+  }
+  /**
+   * Execute an action call from a client.
+   *
+   * This method handles:
+   * 1. Validating the action name
+   * 2. Executing the action function
+   * 3. Processing the result through onBeforeActionResponse (if configured)
+   * 4. Handling timeouts and errors
+   * 5. Saving state changes
+   *
+   * @param ctx The action context
+   * @param actionName The name of the action being called
+   * @param args The arguments passed to the action
+   * @returns The result of the action call
+   * @throws {ActionNotFound} If the action doesn't exist
+   * @throws {ActionTimedOut} If the action times out
+   * @internal
+   */
+  async executeAction(ctx, actionName, args) {
+    invariant(this.#ready, "executing action before ready");
+    if (!(actionName in this.#config.actions)) {
+      this.#rLog.warn({ msg: "action does not exist", actionName });
+      throw new ActionNotFound(actionName);
+    }
+    const actionFunction = this.#config.actions[actionName];
+    if (typeof actionFunction !== "function") {
+      this.#rLog.warn({
+        msg: "action is not a function",
+        actionName,
+        type: typeof actionFunction
+      });
+      throw new ActionNotFound(actionName);
+    }
+    try {
+      this.#rLog.debug({
+        msg: "executing action",
+        actionName,
+        args
+      });
+      const outputOrPromise = actionFunction.call(void 0, ctx, ...args);
+      let output;
+      if (outputOrPromise instanceof Promise) {
+        this.#rLog.debug({
+          msg: "awaiting async action",
+          actionName
+        });
+        output = await deadline(
+          outputOrPromise,
+          this.#config.options.actionTimeout
+        );
+        this.#rLog.debug({
+          msg: "async action completed",
+          actionName
+        });
+      } else {
+        output = outputOrPromise;
+      }
+      if (this.#config.onBeforeActionResponse) {
+        try {
+          const processedOutput = this.#config.onBeforeActionResponse(
+            this.actorContext,
+            actionName,
+            args,
+            output
+          );
+          if (processedOutput instanceof Promise) {
+            this.#rLog.debug({
+              msg: "awaiting onBeforeActionResponse",
+              actionName
+            });
+            output = await processedOutput;
+            this.#rLog.debug({
+              msg: "onBeforeActionResponse completed",
+              actionName
+            });
+          } else {
+            output = processedOutput;
+          }
+        } catch (error) {
+          this.#rLog.error({
+            msg: "error in `onBeforeActionResponse`",
+            error: stringifyError(error)
+          });
+        }
+      }
+      this.#rLog.debug({
+        msg: "action completed",
+        actionName,
+        outputType: typeof output,
+        isPromise: output instanceof Promise
+      });
+      return output;
+    } catch (error) {
+      if (error instanceof DeadlineError) {
+        throw new ActionTimedOut();
+      }
+      this.#rLog.error({
+        msg: "action error",
+        actionName,
+        error: stringifyError(error)
+      });
+      throw error;
+    } finally {
+      this.#savePersistThrottled();
+    }
+  }
+  /**
+   * Returns a list of action methods available on this actor.
+   */
+  get actions() {
+    return Object.keys(this.#config.actions);
+  }
+  /**
+   * Handles raw HTTP requests to the actor.
+   */
+  async handleFetch(request, opts) {
+    this.#assertReady();
+    if (!this.#config.onFetch) {
+      throw new FetchHandlerNotDefined();
+    }
+    this.#activeRawFetchCount++;
+    this.#resetSleepTimer();
+    try {
+      const response = await this.#config.onFetch(
+        this.actorContext,
+        request,
+        opts
+      );
+      if (!response) {
+        throw new InvalidFetchResponse();
+      }
+      return response;
+    } catch (error) {
+      this.#rLog.error({ msg: "onFetch error", error: stringifyError(error) });
+      throw error;
+    } finally {
+      this.#activeRawFetchCount = Math.max(0, this.#activeRawFetchCount - 1);
+      this.#resetSleepTimer();
+      this.#savePersistThrottled();
+    }
+  }
+  /**
+   * Handles raw WebSocket connections to the actor.
+   */
+  async handleWebSocket(websocket, opts) {
+    this.#assertReady();
+    if (!this.#config.onWebSocket) {
+      throw new InternalError("onWebSocket handler not defined");
+    }
+    try {
+      const stateBeforeHandler = this.#persistChanged;
+      this.#activeRawWebSockets.add(websocket);
+      this.#resetSleepTimer();
+      const onSocketClosed = () => {
+        try {
+          websocket.removeEventListener("close", onSocketClosed);
+          websocket.removeEventListener("error", onSocketClosed);
+        } catch {
+        }
+        this.#activeRawWebSockets.delete(websocket);
+        this.#resetSleepTimer();
+      };
+      try {
+        websocket.addEventListener("close", onSocketClosed);
+        websocket.addEventListener("error", onSocketClosed);
+      } catch {
+      }
+      await this.#config.onWebSocket(this.actorContext, websocket, opts);
+      if (this.#persistChanged && !stateBeforeHandler) {
+        await this.saveState({ immediate: true });
+      }
+    } catch (error) {
+      this.#rLog.error({
+        msg: "onWebSocket error",
+        error: stringifyError(error)
+      });
+      throw error;
+    } finally {
+      this.#savePersistThrottled();
+    }
+  }
+  // MARK: Lifecycle hooks
+  // MARK: Exposed methods
+  get log() {
+    invariant(this.#log, "log not configured");
+    return this.#log;
+  }
+  get rLog() {
+    invariant(this.#rLog, "log not configured");
+    return this.#rLog;
+  }
+  /**
+   * Gets the name.
+   */
+  get name() {
+    return this.#name;
+  }
+  /**
+   * Gets the key.
+   */
+  get key() {
+    return this.#key;
+  }
+  /**
+   * Gets the region.
+   */
+  get region() {
+    return this.#region;
+  }
+  /**
+   * Gets the scheduler.
+   */
+  get schedule() {
+    return this.#schedule;
+  }
+  /**
+   * Gets the map of connections.
+   */
+  get conns() {
+    return this.#connections;
+  }
+  /**
+   * Gets the current state.
+   *
+   * Changing properties of this value will automatically be persisted.
+   */
+  get state() {
+    this.#validateStateEnabled();
+    return this.#persist.state;
+  }
+  /**
+   * Gets the database.
+   * @experimental
+   * @throws {DatabaseNotEnabled} If the database is not enabled.
+   */
+  get db() {
+    if (!this.#db) {
+      throw new DatabaseNotEnabled();
+    }
+    return this.#db;
+  }
+  /**
+   * Sets the current state.
+   *
+   * This property will automatically be persisted.
+   */
+  set state(value) {
+    this.#validateStateEnabled();
+    this.#persist.state = value;
+  }
+  get vars() {
+    this.#validateVarsEnabled();
+    invariant(this.#vars !== void 0, "vars not enabled");
+    return this.#vars;
+  }
+  /**
+   * Broadcasts an event to all connected clients.
+   * @param name - The name of the event.
+   * @param args - The arguments to send with the event.
+   */
+  _broadcast(name, ...args) {
+    this.#assertReady();
+    this.inspector.emitter.emit("eventFired", {
+      type: "broadcast",
+      eventName: name,
+      args
+    });
+    const subscriptions = this.#subscriptionIndex.get(name);
+    if (!subscriptions) return;
+    const toClientSerializer = new CachedSerializer(
+      {
+        body: {
+          tag: "Event",
+          val: {
+            name,
+            args: bufferToArrayBuffer(cbor2.encode(args))
+          }
+        }
+      },
+      TO_CLIENT_VERSIONED
+    );
+    for (const connection of subscriptions) {
+      connection._sendMessage(toClientSerializer);
+    }
+  }
+  /**
+   * Prevents the actor from sleeping until promise is complete.
+   *
+   * This allows the actor runtime to ensure that a promise completes while
+   * returning from an action request early.
+   *
+   * @param promise - The promise to run in the background.
+   */
+  _waitUntil(promise) {
+    this.#assertReady();
+    const nonfailablePromise = promise.then(() => {
+      this.#rLog.debug({ msg: "wait until promise complete" });
+    }).catch((error) => {
+      this.#rLog.error({
+        msg: "wait until promise failed",
+        error: stringifyError(error)
+      });
+    });
+    this.#backgroundPromises.push(nonfailablePromise);
+  }
+  /**
+   * Forces the state to get saved.
+   *
+   * This is helpful if running a long task that may fail later or when
+   * running a background job that updates the state.
+   *
+   * @param opts - Options for saving the state.
+   */
+  async saveState(opts) {
+    this.#assertReady(opts.allowStoppingState);
+    if (this.#persistChanged) {
+      if (opts.immediate) {
+        await this.#savePersistInner();
+      } else {
+        if (!this.#onPersistSavedPromise) {
+          this.#onPersistSavedPromise = promiseWithResolvers();
+        }
+        this.#savePersistThrottled();
+        await this.#onPersistSavedPromise.promise;
+      }
+    }
+  }
+  // MARK: Sleep
+  /**
+   * Reset timer from the last actor interaction that allows it to be put to sleep.
+   *
+   * This should be called any time a sleep-related event happens:
+   * - Connection opens (will clear timer)
+   * - Connection closes (will schedule timer if there are no open connections)
+   * - Alarm triggers (will reset timer)
+   *
+   * We don't need to call this on events like individual action calls, since there will always be a connection open for these.
+   **/
+  #resetSleepTimer() {
+    if (this.#config.options.noSleep || !this.#sleepingSupported) return;
+    const canSleep = this.#canSleep();
+    this.#rLog.debug({
+      msg: "resetting sleep timer",
+      canSleep,
+      existingTimeout: !!this.#sleepTimeout
+    });
+    if (this.#sleepTimeout) {
+      clearTimeout(this.#sleepTimeout);
+      this.#sleepTimeout = void 0;
+    }
+    if (this.#sleepCalled) return;
+    if (canSleep) {
+      this.#sleepTimeout = setTimeout(() => {
+        this._sleep().catch((error) => {
+          this.#rLog.error({
+            msg: "error during sleep",
+            error: stringifyError(error)
+          });
+        });
+      }, this.#config.options.sleepTimeout);
+    }
+  }
+  /** If this actor can be put in a sleeping state. */
+  #canSleep() {
+    if (!this.#ready) return false;
+    for (const conn of this.#connections.values()) {
+      if (conn.status === "connected") return false;
+    }
+    if (this.#activeRawFetchCount > 0) return false;
+    if (this.#activeRawWebSockets.size > 0) return false;
+    return true;
+  }
+  /** Puts an actor to sleep. This should just start the sleep sequence, most shutdown logic should be in _stop (which is called by the ActorDriver when sleeping). */
+  async _sleep() {
+    var _a;
+    const sleep = (_a = this.#actorDriver.sleep) == null ? void 0 : _a.bind(
+      this.#actorDriver,
+      this.#actorId
+    );
+    invariant(this.#sleepingSupported, "sleeping not supported");
+    invariant(sleep, "no sleep on driver");
+    if (this.#sleepCalled) {
+      this.#rLog.warn({ msg: "already sleeping actor" });
+      return;
+    }
+    this.#sleepCalled = true;
+    this.#rLog.info({ msg: "actor sleeping" });
+    setImmediate(async () => {
+      await sleep();
+    });
+  }
+  // MARK: Stop
+  async _stop() {
+    if (this.#stopCalled) {
+      this.#rLog.warn({ msg: "already stopping actor" });
+      return;
+    }
+    this.#stopCalled = true;
+    this.#rLog.info({ msg: "actor stopping" });
+    try {
+      this.#abortController.abort();
+    } catch {
+    }
+    if (this.#config.onStop) {
+      try {
+        this.#rLog.debug({ msg: "calling onStop" });
+        const result = this.#config.onStop(this.actorContext);
+        if (result instanceof Promise) {
+          await deadline(result, this.#config.options.onStopTimeout);
+        }
+        this.#rLog.debug({ msg: "onStop completed" });
+      } catch (error) {
+        if (error instanceof DeadlineError) {
+          this.#rLog.error({ msg: "onStop timed out" });
+        } else {
+          this.#rLog.error({
+            msg: "error in onStop",
+            error: stringifyError(error)
+          });
+        }
+      }
+    }
+    const promises = [];
+    for (const connection of this.#connections.values()) {
+      promises.push(connection.disconnect());
+    }
+    await this.#waitBackgroundPromises(this.#config.options.waitUntilTimeout);
+    if (this.#pendingSaveTimeout) clearTimeout(this.#pendingSaveTimeout);
+    if (this.#sleepTimeout) clearTimeout(this.#sleepTimeout);
+    if (this.#checkConnLivenessInterval)
+      clearInterval(this.#checkConnLivenessInterval);
+    await this.saveState({ immediate: true, allowStoppingState: true });
+    const res = Promise.race([
+      Promise.all(promises).then(() => false),
+      new Promise(
+        (res2) => globalThis.setTimeout(() => res2(true), 1500)
+      )
+    ]);
+    if (await res) {
+      this.#rLog.warn({
+        msg: "timed out waiting for connections to close, shutting down anyway"
+      });
+    }
+    if (this.#persistWriteQueue.runningDrainLoop)
+      await this.#persistWriteQueue.runningDrainLoop;
+    if (this.#alarmWriteQueue.runningDrainLoop)
+      await this.#alarmWriteQueue.runningDrainLoop;
+  }
+  /** Abort signal that fires when the actor is stopping. */
+  get abortSignal() {
+    return this.#abortController.signal;
+  }
+  /** Wait for background waitUntil promises with a timeout. */
+  async #waitBackgroundPromises(timeoutMs) {
+    const pending = this.#backgroundPromises;
+    if (pending.length === 0) {
+      this.#rLog.debug({ msg: "no background promises" });
+      return;
+    }
+    const timedOut = await Promise.race([
+      Promise.allSettled(pending).then(() => false),
+      new Promise(
+        (resolve) => setTimeout(() => resolve(true), timeoutMs)
+      )
+    ]);
+    if (timedOut) {
+      this.#rLog.error({
+        msg: "timed out waiting for background tasks, background promises may have leaked",
+        count: pending.length,
+        timeoutMs
+      });
+    } else {
+      this.#rLog.debug({ msg: "background promises finished" });
+    }
+  }
+  // MARK: BARE Conversion Helpers
+  #convertToBarePersisted(persist) {
+    return {
+      input: persist.input !== void 0 ? bufferToArrayBuffer(cbor2.encode(persist.input)) : null,
+      hasInitialized: persist.hasInitiated,
+      state: bufferToArrayBuffer(cbor2.encode(persist.state)),
+      connections: persist.connections.map((conn) => ({
+        id: conn.connId,
+        token: conn.token,
+        parameters: bufferToArrayBuffer(cbor2.encode(conn.params || {})),
+        state: bufferToArrayBuffer(cbor2.encode(conn.state || {})),
+        subscriptions: conn.subscriptions.map((sub) => ({
+          eventName: sub.eventName
+        })),
+        lastSeen: BigInt(conn.lastSeen)
+      })),
+      scheduledEvents: persist.scheduledEvents.map((event) => ({
+        eventId: event.eventId,
+        timestamp: BigInt(event.timestamp),
+        kind: {
+          tag: "GenericPersistedScheduleEvent",
+          val: {
+            action: event.kind.generic.actionName,
+            args: event.kind.generic.args ?? null
+          }
+        }
+      }))
+    };
+  }
+  #convertFromBarePersisted(bareData) {
+    return {
+      input: bareData.input ? cbor2.decode(new Uint8Array(bareData.input)) : void 0,
+      hasInitiated: bareData.hasInitialized,
+      state: cbor2.decode(new Uint8Array(bareData.state)),
+      connections: bareData.connections.map((conn) => ({
+        connId: conn.id,
+        token: conn.token,
+        params: cbor2.decode(new Uint8Array(conn.parameters)),
+        state: cbor2.decode(new Uint8Array(conn.state)),
+        subscriptions: conn.subscriptions.map((sub) => ({
+          eventName: sub.eventName
+        })),
+        lastSeen: Number(conn.lastSeen)
+      })),
+      scheduledEvents: bareData.scheduledEvents.map((event) => ({
+        eventId: event.eventId,
+        timestamp: Number(event.timestamp),
+        kind: {
+          generic: {
+            actionName: event.kind.val.action,
+            args: event.kind.val.args
+          }
+        }
+      }))
+    };
+  }
+};
+
+// src/actor/definition.ts
+var ActorDefinition = class {
+  #config;
+  constructor(config) {
+    this.#config = config;
+  }
+  get config() {
+    return this.#config;
+  }
+  instantiate() {
+    return new ActorInstance(this.#config);
+  }
+};
+function lookupInRegistry(registryConfig, name) {
+  const definition = registryConfig.use[name];
+  if (!definition) throw new Error(`no actor in registry for name ${name}`);
+  return definition;
+}
+
+// src/client/errors.ts
+var ActorClientError = class extends Error {
+};
+var InternalError2 = class extends ActorClientError {
+};
+var ManagerError = class extends ActorClientError {
+  constructor(error, opts) {
+    super(`Manager error: ${error}`, opts);
+  }
+};
+var MalformedResponseMessage = class extends ActorClientError {
+  constructor(cause) {
+    super(`Malformed response message: ${cause}`, { cause });
+  }
+};
+var ActorError = class extends ActorClientError {
+  constructor(group, code, message, metadata) {
+    super(message);
+    this.group = group;
+    this.code = code;
+    this.metadata = metadata;
+  }
+  __type = "ActorError";
+};
+var HttpRequestError = class extends ActorClientError {
+  constructor(message, opts) {
+    super(`HTTP request error: ${message}`, { cause: opts == null ? void 0 : opts.cause });
+  }
+};
+var ActorConnDisposed = class extends ActorClientError {
+  constructor() {
+    super("Attempting to interact with a disposed actor connection.");
+  }
+};
+
+// src/client/actor-conn.ts
+import * as cbor5 from "cbor-x";
+import invariant5 from "invariant";
+import pRetry from "p-retry";
+
+// src/common/eventsource.ts
+var eventSourcePromise = null;
+async function importEventSource() {
+  if (eventSourcePromise !== null) {
+    return eventSourcePromise;
+  }
+  eventSourcePromise = (async () => {
+    let _EventSource;
+    try {
+      const es = await import("eventsource");
+      _EventSource = es.EventSource;
+      logger().debug("using eventsource from npm");
+    } catch (err) {
+      _EventSource = class MockEventSource {
+        constructor() {
+          throw new Error(
+            'EventSource support requires installing the "eventsource" peer dependency.'
+          );
+        }
+      };
+      logger().debug("using mock eventsource");
+    }
+    return _EventSource;
+  })();
+  return eventSourcePromise;
+}
+
+// src/client/actor-query.ts
+async function queryActor(c, query, managerDriver) {
+  logger().debug({ msg: "querying actor", query: JSON.stringify(query) });
+  let actorOutput;
+  if ("getForId" in query) {
+    const output = await managerDriver.getForId({
+      c,
+      name: query.getForId.name,
+      actorId: query.getForId.actorId
+    });
+    if (!output) throw new ActorNotFound(query.getForId.actorId);
+    actorOutput = output;
+  } else if ("getForKey" in query) {
+    const existingActor = await managerDriver.getWithKey({
+      c,
+      name: query.getForKey.name,
+      key: query.getForKey.key
+    });
+    if (!existingActor) {
+      throw new ActorNotFound(
+        `${query.getForKey.name}:${JSON.stringify(query.getForKey.key)}`
+      );
+    }
+    actorOutput = existingActor;
+  } else if ("getOrCreateForKey" in query) {
+    const getOrCreateOutput = await managerDriver.getOrCreateWithKey({
+      c,
+      name: query.getOrCreateForKey.name,
+      key: query.getOrCreateForKey.key,
+      input: query.getOrCreateForKey.input,
+      region: query.getOrCreateForKey.region
+    });
+    actorOutput = {
+      actorId: getOrCreateOutput.actorId
+    };
+  } else if ("create" in query) {
+    const createOutput = await managerDriver.createActor({
+      c,
+      name: query.create.name,
+      key: query.create.key,
+      input: query.create.input,
+      region: query.create.region
+    });
+    actorOutput = {
+      actorId: createOutput.actorId
+    };
+  } else {
+    throw new InvalidRequest("Invalid query format");
+  }
+  logger().debug({ msg: "actor query result", actorId: actorOutput.actorId });
+  return { actorId: actorOutput.actorId };
+}
+
+// src/client/actor-handle.ts
+import * as cbor4 from "cbor-x";
+import invariant4 from "invariant";
+
+// src/client/raw-utils.ts
+import invariant2 from "invariant";
+async function rawHttpFetch(driver, actorQuery, params, input, init) {
+  let path;
+  let mergedInit = init || {};
+  if (typeof input === "string") {
+    path = input;
+  } else if (input instanceof URL) {
+    path = input.pathname + input.search;
+  } else if (input instanceof Request) {
+    const url = new URL(input.url);
+    path = url.pathname + url.search;
+    const requestHeaders = new Headers(input.headers);
+    const initHeaders = new Headers((init == null ? void 0 : init.headers) || {});
+    const mergedHeaders = new Headers(requestHeaders);
+    for (const [key, value] of initHeaders) {
+      mergedHeaders.set(key, value);
+    }
+    mergedInit = {
+      method: input.method,
+      body: input.body,
+      mode: input.mode,
+      credentials: input.credentials,
+      redirect: input.redirect,
+      referrer: input.referrer,
+      referrerPolicy: input.referrerPolicy,
+      integrity: input.integrity,
+      keepalive: input.keepalive,
+      signal: input.signal,
+      ...mergedInit,
+      // init overrides Request properties
+      headers: mergedHeaders
+      // headers must be set after spread to ensure proper merge
+    };
+    if (mergedInit.body) {
+      mergedInit.duplex = "half";
+    }
+  } else {
+    throw new TypeError("Invalid input type for fetch");
+  }
+  try {
+    const { actorId } = await queryActor(void 0, actorQuery, driver);
+    logger().debug({ msg: "found actor for raw http", actorId });
+    invariant2(actorId, "Missing actor ID");
+    const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+    const url = new URL(`http://actor/raw/http/${normalizedPath}`);
+    const proxyRequestHeaders = new Headers(mergedInit.headers);
+    if (params) {
+      proxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(params));
+    }
+    const proxyRequest = new Request(url, {
+      ...mergedInit,
+      headers: proxyRequestHeaders
+    });
+    return driver.sendRequest(actorId, proxyRequest);
+  } catch (err) {
+    const { group, code, message, metadata } = deconstructError(
+      err,
+      logger(),
+      {},
+      true
+    );
+    throw new ActorError(group, code, message, metadata);
+  }
+}
+async function rawWebSocket(driver, actorQuery, params, path, protocols) {
+  const encoding = "bare";
+  const { actorId } = await queryActor(void 0, actorQuery, driver);
+  logger().debug({ msg: "found actor for action", actorId });
+  invariant2(actorId, "Missing actor ID");
+  let pathPortion = "";
+  let queryPortion = "";
+  if (path) {
+    const queryIndex = path.indexOf("?");
+    if (queryIndex !== -1) {
+      pathPortion = path.substring(0, queryIndex);
+      queryPortion = path.substring(queryIndex);
+    } else {
+      pathPortion = path;
+    }
+    if (pathPortion.startsWith("/")) {
+      pathPortion = pathPortion.slice(1);
+    }
+  }
+  const fullPath = `${PATH_RAW_WEBSOCKET_PREFIX}${pathPortion}${queryPortion}`;
+  logger().debug({
+    msg: "opening websocket",
+    actorId,
+    encoding,
+    path: fullPath
+  });
+  const ws = await driver.openWebSocket(fullPath, actorId, encoding, params);
+  return ws;
+}
+
+// src/client/utils.ts
+import * as cbor3 from "cbor-x";
+import invariant3 from "invariant";
+function messageLength(message) {
+  if (message instanceof Blob) {
+    return message.size;
+  }
+  if (message instanceof ArrayBuffer) {
+    return message.byteLength;
+  }
+  if (message instanceof Uint8Array) {
+    return message.byteLength;
+  }
+  if (typeof message === "string") {
+    return message.length;
+  }
+  assertUnreachable(message);
+}
+async function sendHttpRequest(opts) {
+  logger().debug({
+    msg: "sending http request",
+    url: opts.url,
+    encoding: opts.encoding
+  });
+  let contentType;
+  let bodyData;
+  if (opts.method === "POST" || opts.method === "PUT") {
+    invariant3(opts.body !== void 0, "missing body");
+    contentType = contentTypeForEncoding(opts.encoding);
+    bodyData = serializeWithEncoding(
+      opts.encoding,
+      opts.body,
+      opts.requestVersionedDataHandler
+    );
+  }
+  let response;
+  try {
+    response = await (opts.customFetch ?? fetch)(
+      new Request(opts.url, {
+        method: opts.method,
+        headers: {
+          ...opts.headers,
+          ...contentType ? {
+            "Content-Type": contentType
+          } : {},
+          "User-Agent": httpUserAgent()
+        },
+        body: bodyData,
+        credentials: "include",
+        signal: opts.signal
+      })
+    );
+  } catch (error) {
+    throw new HttpRequestError(`Request failed: ${error}`, {
+      cause: error
+    });
+  }
+  if (!response.ok) {
+    const bufferResponse = await response.arrayBuffer();
+    let responseData;
+    try {
+      responseData = deserializeWithEncoding(
+        opts.encoding,
+        new Uint8Array(bufferResponse),
+        HTTP_RESPONSE_ERROR_VERSIONED
+      );
+    } catch (error) {
+      const textResponse = new TextDecoder("utf-8", { fatal: false }).decode(
+        bufferResponse
+      );
+      throw new HttpRequestError(
+        `${response.statusText} (${response.status}):
+${textResponse}`
+      );
+    }
+    throw new ActorError(
+      responseData.group,
+      responseData.code,
+      responseData.message,
+      responseData.metadata ? cbor3.decode(new Uint8Array(responseData.metadata)) : void 0
+    );
+  }
+  if (opts.skipParseResponse) {
+    return void 0;
+  }
+  try {
+    const buffer = new Uint8Array(await response.arrayBuffer());
+    return deserializeWithEncoding(
+      opts.encoding,
+      buffer,
+      opts.responseVersionedDataHandler
+    );
+  } catch (error) {
+    throw new HttpRequestError(`Failed to parse response: ${error}`, {
+      cause: error
+    });
+  }
+}
+
+// src/client/actor-handle.ts
+var ActorHandleRaw = class {
+  #client;
+  #driver;
+  #encoding;
+  #actorQuery;
+  #params;
+  /**
+   * Do not call this directly.
+   *
+   * Creates an instance of ActorHandleRaw.
+   *
+   * @protected
+   */
+  constructor(client, driver, params, encoding, actorQuery) {
+    this.#client = client;
+    this.#driver = driver;
+    this.#encoding = encoding;
+    this.#actorQuery = actorQuery;
+    this.#params = params;
+  }
+  /**
+   * Call a raw action. This method sends an HTTP request to invoke the named action.
+   *
+   * @see {@link ActorHandle}
+   * @template Args - The type of arguments to pass to the action function.
+   * @template Response - The type of the response returned by the action function.
+   */
+  async action(opts) {
+    try {
+      const { actorId } = await queryActor(
+        void 0,
+        this.#actorQuery,
+        this.#driver
+      );
+      logger().debug({ msg: "found actor for action", actorId });
+      invariant4(actorId, "Missing actor ID");
+      logger().debug({
+        msg: "handling action",
+        name: opts.name,
+        encoding: this.#encoding
+      });
+      const responseData = await sendHttpRequest({
+        url: `http://actor/action/${encodeURIComponent(opts.name)}`,
+        method: "POST",
+        headers: {
+          [HEADER_ENCODING]: this.#encoding,
+          ...this.#params !== void 0 ? { [HEADER_CONN_PARAMS]: JSON.stringify(this.#params) } : {}
+        },
+        body: {
+          args: bufferToArrayBuffer(cbor4.encode(opts.args))
+        },
+        encoding: this.#encoding,
+        customFetch: this.#driver.sendRequest.bind(this.#driver, actorId),
+        signal: opts == null ? void 0 : opts.signal,
+        requestVersionedDataHandler: HTTP_ACTION_REQUEST_VERSIONED,
+        responseVersionedDataHandler: HTTP_ACTION_RESPONSE_VERSIONED
+      });
+      return cbor4.decode(new Uint8Array(responseData.output));
+    } catch (err) {
+      const { group, code, message, metadata } = deconstructError(
+        err,
+        logger(),
+        {},
+        true
+      );
+      throw new ActorError(group, code, message, metadata);
+    }
+  }
+  /**
+   * Establishes a persistent connection to the actor.
+   *
+   * @template AD The actor class that this connection is for.
+   * @returns {ActorConn<AD>} A connection to the actor.
+   */
+  connect() {
+    logger().debug({
+      msg: "establishing connection from handle",
+      query: this.#actorQuery
+    });
+    const conn = new ActorConnRaw(
+      this.#client,
+      this.#driver,
+      this.#params,
+      this.#encoding,
+      this.#actorQuery
+    );
+    return this.#client[CREATE_ACTOR_CONN_PROXY](
+      conn
+    );
+  }
+  /**
+   * Makes a raw HTTP request to the actor.
+   *
+   * @param input - The URL, path, or Request object
+   * @param init - Standard fetch RequestInit options
+   * @returns Promise<Response> - The raw HTTP response
+   */
+  async fetch(input, init) {
+    return rawHttpFetch(
+      this.#driver,
+      this.#actorQuery,
+      this.#params,
+      input,
+      init
+    );
+  }
+  /**
+   * Creates a raw WebSocket connection to the actor.
+   *
+   * @param path - The path for the WebSocket connection (e.g., "stream")
+   * @param protocols - Optional WebSocket subprotocols
+   * @returns WebSocket - A raw WebSocket connection
+   */
+  async websocket(path, protocols) {
+    return rawWebSocket(
+      this.#driver,
+      this.#actorQuery,
+      this.#params,
+      path,
+      protocols
+    );
+  }
+  /**
+   * Resolves the actor to get its unique actor ID
+   *
+   * @returns {Promise<string>} - A promise that resolves to the actor's ID
+   */
+  async resolve({ signal } = {}) {
+    if ("getForKey" in this.#actorQuery || "getOrCreateForKey" in this.#actorQuery) {
+      let name;
+      if ("getForKey" in this.#actorQuery) {
+        name = this.#actorQuery.getForKey.name;
+      } else if ("getOrCreateForKey" in this.#actorQuery) {
+        name = this.#actorQuery.getOrCreateForKey.name;
+      } else {
+        assertUnreachable2(this.#actorQuery);
+      }
+      const { actorId } = await queryActor(
+        void 0,
+        this.#actorQuery,
+        this.#driver
+      );
+      this.#actorQuery = { getForId: { actorId, name } };
+      return actorId;
+    } else if ("getForId" in this.#actorQuery) {
+      return this.#actorQuery.getForId.actorId;
+    } else if ("create" in this.#actorQuery) {
+      invariant4(false, "actorQuery cannot be create");
+    } else {
+      assertUnreachable2(this.#actorQuery);
+    }
+  }
+};
+
+// src/client/client.ts
+var ACTOR_CONNS_SYMBOL = Symbol("actorConns");
+var CREATE_ACTOR_CONN_PROXY = Symbol("createActorConnProxy");
+var TRANSPORT_SYMBOL = Symbol("transport");
+var ClientRaw = class {
+  #disposed = false;
+  [ACTOR_CONNS_SYMBOL] = /* @__PURE__ */ new Set();
+  #driver;
+  #encodingKind;
+  [TRANSPORT_SYMBOL];
+  /**
+   * Creates an instance of Client.
+   *
+   * @param {string} managerEndpoint - The manager endpoint. See {@link https://rivet.dev/docs/setup|Initial Setup} for instructions on getting the manager endpoint.
+   * @param {ClientConfig} [opts] - Options for configuring the client.
+   * @see {@link https://rivet.dev/docs/setup|Initial Setup}
+   */
+  constructor(driver, opts) {
+    this.#driver = driver;
+    this.#encodingKind = (opts == null ? void 0 : opts.encoding) ?? "bare";
+    this[TRANSPORT_SYMBOL] = (opts == null ? void 0 : opts.transport) ?? "websocket";
+  }
+  /**
+   * Gets a stateless handle to a actor by its ID.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string} actorId - The ID of the actor.
+   * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+   * @returns {ActorHandle<AD>} - A handle to the actor.
+   */
+  getForId(name, actorId, opts) {
+    logger().debug({
+      msg: "get handle to actor with id",
+      name,
+      actorId,
+      params: opts == null ? void 0 : opts.params
+    });
+    const actorQuery = {
+      getForId: {
+        name,
+        actorId
+      }
+    };
+    const handle = this.#createHandle(opts == null ? void 0 : opts.params, actorQuery);
+    return createActorProxy(handle);
+  }
+  /**
+   * Gets a stateless handle to a actor by its key, but does not create the actor if it doesn't exist.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+   * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+   * @returns {ActorHandle<AD>} - A handle to the actor.
+   */
+  get(name, key, opts) {
+    const keyArray = typeof key === "string" ? [key] : key || [];
+    logger().debug({
+      msg: "get handle to actor",
+      name,
+      key: keyArray,
+      parameters: opts == null ? void 0 : opts.params
+    });
+    const actorQuery = {
+      getForKey: {
+        name,
+        key: keyArray
+      }
+    };
+    const handle = this.#createHandle(opts == null ? void 0 : opts.params, actorQuery);
+    return createActorProxy(handle);
+  }
+  /**
+   * Gets a stateless handle to a actor by its key, creating it if necessary.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+   * @param {GetOptions} [opts] - Options for getting the actor.
+   * @returns {ActorHandle<AD>} - A handle to the actor.
+   */
+  getOrCreate(name, key, opts) {
+    const keyArray = typeof key === "string" ? [key] : key || [];
+    logger().debug({
+      msg: "get or create handle to actor",
+      name,
+      key: keyArray,
+      parameters: opts == null ? void 0 : opts.params,
+      createInRegion: opts == null ? void 0 : opts.createInRegion
+    });
+    const actorQuery = {
+      getOrCreateForKey: {
+        name,
+        key: keyArray,
+        input: opts == null ? void 0 : opts.createWithInput,
+        region: opts == null ? void 0 : opts.createInRegion
+      }
+    };
+    const handle = this.#createHandle(opts == null ? void 0 : opts.params, actorQuery);
+    return createActorProxy(handle);
+  }
+  /**
+   * Creates a new actor with the provided key and returns a stateless handle to it.
+   * Resolves the actor ID and returns a handle with getForId query.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string | string[]} key - The key to identify the actor. Can be a single string or an array of strings.
+   * @param {CreateOptions} [opts] - Options for creating the actor (excluding name and key).
+   * @returns {Promise<ActorHandle<AD>>} - A promise that resolves to a handle to the actor.
+   */
+  async create(name, key, opts) {
+    const keyArray = typeof key === "string" ? [key] : key || [];
+    const createQuery = {
+      create: {
+        ...opts,
+        // Do these last to override `opts`
+        name,
+        key: keyArray
+      }
+    };
+    logger().debug({
+      msg: "create actor handle",
+      name,
+      key: keyArray,
+      parameters: opts == null ? void 0 : opts.params,
+      create: createQuery.create
+    });
+    const { actorId } = await queryActor(void 0, createQuery, this.#driver);
+    logger().debug({
+      msg: "created actor with ID",
+      name,
+      key: keyArray,
+      actorId
+    });
+    const getForIdQuery = {
+      getForId: {
+        name,
+        actorId
+      }
+    };
+    const handle = this.#createHandle(opts == null ? void 0 : opts.params, getForIdQuery);
+    const proxy = createActorProxy(handle);
+    return proxy;
+  }
+  #createHandle(params, actorQuery) {
+    return new ActorHandleRaw(
+      this,
+      this.#driver,
+      params,
+      this.#encodingKind,
+      actorQuery
+    );
+  }
+  [CREATE_ACTOR_CONN_PROXY](conn) {
+    this[ACTOR_CONNS_SYMBOL].add(conn);
+    conn[CONNECT_SYMBOL]();
+    return createActorProxy(conn);
+  }
+  /**
+   * Disconnects from all actors.
+   *
+   * @returns {Promise<void>} A promise that resolves when all connections are closed.
+   */
+  async dispose() {
+    if (this.#disposed) {
+      logger().warn({ msg: "client already disconnected" });
+      return;
+    }
+    this.#disposed = true;
+    logger().debug({ msg: "disposing client" });
+    const disposePromises = [];
+    for (const conn of this[ACTOR_CONNS_SYMBOL].values()) {
+      disposePromises.push(conn.dispose());
+    }
+    await Promise.all(disposePromises);
+  }
+};
+function createClientWithDriver(driver, config) {
+  const client = new ClientRaw(driver, config);
+  return new Proxy(client, {
+    get: (target, prop, receiver) => {
+      if (typeof prop === "symbol" || prop in target) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+      if (typeof prop === "string") {
+        return {
+          // Handle methods (stateless action)
+          get: (key, opts) => {
+            return target.get(
+              prop,
+              key,
+              opts
+            );
+          },
+          getOrCreate: (key, opts) => {
+            return target.getOrCreate(prop, key, opts);
+          },
+          getForId: (actorId, opts) => {
+            return target.getForId(
+              prop,
+              actorId,
+              opts
+            );
+          },
+          create: async (key, opts = {}) => {
+            return await target.create(prop, key, opts);
+          }
+        };
+      }
+      return void 0;
+    }
+  });
+}
+function createActorProxy(handle) {
+  const methodCache = /* @__PURE__ */ new Map();
+  return new Proxy(handle, {
+    get(target, prop, receiver) {
+      if (typeof prop === "symbol") {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (prop === "constructor" || prop in target) {
+        const value = Reflect.get(target, prop, target);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+      if (typeof prop === "string") {
+        if (prop === "then") return void 0;
+        let method = methodCache.get(prop);
+        if (!method) {
+          method = (...args) => target.action({ name: prop, args });
+          methodCache.set(prop, method);
+        }
+        return method;
+      }
+    },
+    // Support for 'in' operator
+    has(target, prop) {
+      if (typeof prop === "string") {
+        return true;
+      }
+      return Reflect.has(target, prop);
+    },
+    // Support instanceof checks
+    getPrototypeOf(target) {
+      return Reflect.getPrototypeOf(target);
+    },
+    // Prevent property enumeration of non-existent action methods
+    ownKeys(target) {
+      return Reflect.ownKeys(target);
+    },
+    // Support proper property descriptors
+    getOwnPropertyDescriptor(target, prop) {
+      const targetDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+      if (targetDescriptor) {
+        return targetDescriptor;
+      }
+      if (typeof prop === "string") {
+        return {
+          configurable: true,
+          enumerable: false,
+          writable: false,
+          value: (...args) => target.action({ name: prop, args })
+        };
+      }
+      return void 0;
+    }
+  });
+}
+
+// src/client/actor-conn.ts
+var CONNECT_SYMBOL = Symbol("connect");
+var ActorConnRaw = class {
+  #disposed = false;
+  /* Will be aborted on dispose. */
+  #abortController = new AbortController();
+  /** If attempting to connect. Helpful for knowing if in a retry loop when reconnecting. */
+  #connecting = false;
+  // Connection info, used for reconnection and HTTP requests
+  #actorId;
+  #connectionId;
+  #connectionToken;
+  #transport;
+  #messageQueue = [];
+  #actionsInFlight = /* @__PURE__ */ new Map();
+  // biome-ignore lint/suspicious/noExplicitAny: Unknown subscription type
+  #eventSubscriptions = /* @__PURE__ */ new Map();
+  #errorHandlers = /* @__PURE__ */ new Set();
+  #actionIdCounter = 0;
+  /**
+   * Interval that keeps the NodeJS process alive if this is the only thing running.
+   *
+   * See ttps://github.com/nodejs/node/issues/22088
+   */
+  #keepNodeAliveInterval;
+  /** Promise used to indicate the socket has connected successfully. This will be rejected if the connection fails. */
+  #onOpenPromise;
+  #client;
+  #driver;
+  #params;
+  #encoding;
+  #actorQuery;
+  // TODO: ws message queue
+  /**
+   * Do not call this directly.
+   *
+   * Creates an instance of ActorConnRaw.
+   *
+   * @protected
+   */
+  constructor(client, driver, params, encoding, actorQuery) {
+    this.#client = client;
+    this.#driver = driver;
+    this.#params = params;
+    this.#encoding = encoding;
+    this.#actorQuery = actorQuery;
+    this.#keepNodeAliveInterval = setInterval(() => 6e4);
+  }
+  /**
+   * Call a raw action connection. See {@link ActorConn} for type-safe action calls.
+   *
+   * @see {@link ActorConn}
+   * @template Args - The type of arguments to pass to the action function.
+   * @template Response - The type of the response returned by the action function.
+   * @param {string} name - The name of the action function to call.
+   * @param {...Args} args - The arguments to pass to the action function.
+   * @returns {Promise<Response>} - A promise that resolves to the response of the action function.
+   */
+  async action(opts) {
+    logger().debug({ msg: "action", name: opts.name, args: opts.args });
+    const actionId = this.#actionIdCounter;
+    this.#actionIdCounter += 1;
+    const { promise, resolve, reject } = promiseWithResolvers();
+    this.#actionsInFlight.set(actionId, { name: opts.name, resolve, reject });
+    this.#sendMessage({
+      body: {
+        tag: "ActionRequest",
+        val: {
+          id: BigInt(actionId),
+          name: opts.name,
+          args: bufferToArrayBuffer(cbor5.encode(opts.args))
+        }
+      }
+    });
+    const { id: responseId, output } = await promise;
+    if (responseId !== BigInt(actionId))
+      throw new Error(
+        `Request ID ${actionId} does not match response ID ${responseId}`
+      );
+    return cbor5.decode(new Uint8Array(output));
+  }
+  /**
+  	 * Do not call this directly.
+  enc
+  	 * Establishes a connection to the server using the specified endpoint & encoding & driver.
+  	 *
+  	 * @protected
+  	 */
+  [CONNECT_SYMBOL]() {
+    this.#connectWithRetry();
+  }
+  async #connectWithRetry() {
+    this.#connecting = true;
+    try {
+      await pRetry(this.#connectAndWait.bind(this), {
+        forever: true,
+        minTimeout: 250,
+        maxTimeout: 3e4,
+        onFailedAttempt: (error) => {
+          logger().warn({
+            msg: "failed to reconnect",
+            attempt: error.attemptNumber,
+            error: stringifyError(error)
+          });
+        },
+        // Cancel retry if aborted
+        signal: this.#abortController.signal
+      });
+    } catch (err) {
+      if (err.name === "AbortError") {
+        logger().info({ msg: "connection retry aborted" });
+        return;
+      } else {
+        throw err;
+      }
+    }
+    this.#connecting = false;
+  }
+  async #connectAndWait() {
+    try {
+      if (this.#onOpenPromise)
+        throw new Error("#onOpenPromise already defined");
+      this.#onOpenPromise = promiseWithResolvers();
+      if (this.#client[TRANSPORT_SYMBOL] === "websocket") {
+        await this.#connectWebSocket();
+      } else if (this.#client[TRANSPORT_SYMBOL] === "sse") {
+        await this.#connectSse();
+      } else {
+        assertUnreachable(this.#client[TRANSPORT_SYMBOL]);
+      }
+      await this.#onOpenPromise.promise;
+    } finally {
+      this.#onOpenPromise = void 0;
+    }
+  }
+  async #connectWebSocket() {
+    const { actorId } = await queryActor(
+      void 0,
+      this.#actorQuery,
+      this.#driver
+    );
+    const isReconnection = this.#connectionId && this.#connectionToken;
+    if (isReconnection) {
+      logger().debug({
+        msg: "attempting websocket reconnection",
+        connectionId: this.#connectionId
+      });
+    }
+    const ws = await this.#driver.openWebSocket(
+      PATH_CONNECT_WEBSOCKET,
+      actorId,
+      this.#encoding,
+      this.#params,
+      // Pass connection ID and token for reconnection if available
+      isReconnection ? this.#connectionId : void 0,
+      isReconnection ? this.#connectionToken : void 0
+    );
+    logger().debug({
+      msg: "transport set to new websocket",
+      connectionId: this.#connectionId,
+      readyState: ws.readyState,
+      messageQueueLength: this.#messageQueue.length
+    });
+    this.#transport = { websocket: ws };
+    ws.addEventListener("open", () => {
+      logger().debug({
+        msg: "client websocket open",
+        connectionId: this.#connectionId
+      });
+    });
+    ws.addEventListener("message", async (ev) => {
+      this.#handleOnMessage(ev.data);
+    });
+    ws.addEventListener("close", (ev) => {
+      this.#handleOnClose(ev);
+    });
+    ws.addEventListener("error", (_ev) => {
+      this.#handleOnError();
+    });
+  }
+  async #connectSse() {
+    const EventSource = await importEventSource();
+    const { actorId } = await queryActor(
+      void 0,
+      this.#actorQuery,
+      this.#driver
+    );
+    logger().debug({ msg: "found actor for sse connection", actorId });
+    invariant5(actorId, "Missing actor ID");
+    logger().debug({
+      msg: "opening sse connection",
+      actorId,
+      encoding: this.#encoding
+    });
+    const isReconnection = this.#connectionId && this.#connectionToken;
+    const eventSource = new EventSource("http://actor/connect/sse", {
+      fetch: (input, init) => {
+        return this.#driver.sendRequest(
+          actorId,
+          new Request(input, {
+            ...init,
+            headers: {
+              ...init == null ? void 0 : init.headers,
+              "User-Agent": httpUserAgent(),
+              [HEADER_ENCODING]: this.#encoding,
+              ...this.#params !== void 0 ? { [HEADER_CONN_PARAMS]: JSON.stringify(this.#params) } : {},
+              ...isReconnection ? {
+                [HEADER_CONN_ID]: this.#connectionId,
+                [HEADER_CONN_TOKEN]: this.#connectionToken
+              } : {}
+            }
+          })
+        );
+      }
+    });
+    this.#transport = { sse: eventSource };
+    eventSource.addEventListener("message", (ev) => {
+      if (ev.type === "ping") return;
+      this.#handleOnMessage(ev.data);
+    });
+    eventSource.addEventListener("error", (ev) => {
+      this.#handleOnError();
+    });
+  }
+  /** Called by the onopen event from drivers. */
+  #handleOnOpen() {
+    logger().debug({
+      msg: "socket open",
+      messageQueueLength: this.#messageQueue.length,
+      connectionId: this.#connectionId
+    });
+    if (this.#onOpenPromise) {
+      this.#onOpenPromise.resolve(void 0);
+    } else {
+      logger().warn({ msg: "#onOpenPromise is undefined" });
+    }
+    for (const eventName of this.#eventSubscriptions.keys()) {
+      this.#sendSubscription(eventName, true);
+    }
+    const queue = this.#messageQueue;
+    this.#messageQueue = [];
+    logger().debug({
+      msg: "flushing message queue",
+      queueLength: queue.length
+    });
+    for (const msg of queue) {
+      this.#sendMessage(msg);
+    }
+  }
+  /** Called by the onmessage event from drivers. */
+  async #handleOnMessage(data) {
+    logger().trace({
+      msg: "received message",
+      dataType: typeof data,
+      isBlob: data instanceof Blob,
+      isArrayBuffer: data instanceof ArrayBuffer
+    });
+    const response = await this.#parseMessage(data);
+    logger().trace(
+      getEnvUniversal("_RIVETKIT_LOG_MESSAGE") ? {
+        msg: "parsed message",
+        message: jsonStringifyCompat(response).substring(0, 100) + "..."
+      } : { msg: "parsed message" }
+    );
+    if (response.body.tag === "Init") {
+      this.#actorId = response.body.val.actorId;
+      this.#connectionId = response.body.val.connectionId;
+      this.#connectionToken = response.body.val.connectionToken;
+      logger().trace({
+        msg: "received init message",
+        actorId: this.#actorId,
+        connectionId: this.#connectionId
+      });
+      this.#handleOnOpen();
+    } else if (response.body.tag === "Error") {
+      const { group, code, message, metadata, actionId } = response.body.val;
+      if (actionId) {
+        const inFlight = this.#takeActionInFlight(Number(actionId));
+        logger().warn({
+          msg: "action error",
+          actionId,
+          actionName: inFlight == null ? void 0 : inFlight.name,
+          group,
+          code,
+          message,
+          metadata
+        });
+        inFlight.reject(new ActorError(group, code, message, metadata));
+      } else {
+        logger().warn({
+          msg: "connection error",
+          group,
+          code,
+          message,
+          metadata
+        });
+        const actorError = new ActorError(
+          group,
+          code,
+          message,
+          metadata
+        );
+        if (this.#onOpenPromise) {
+          this.#onOpenPromise.reject(actorError);
+        }
+        for (const [id, inFlight] of this.#actionsInFlight.entries()) {
+          inFlight.reject(actorError);
+          this.#actionsInFlight.delete(id);
+        }
+        this.#dispatchActorError(actorError);
+      }
+    } else if (response.body.tag === "ActionResponse") {
+      const { id: actionId } = response.body.val;
+      logger().trace({
+        msg: "received action response",
+        actionId
+      });
+      const inFlight = this.#takeActionInFlight(Number(actionId));
+      logger().trace({
+        msg: "resolving action promise",
+        actionId,
+        actionName: inFlight == null ? void 0 : inFlight.name
+      });
+      inFlight.resolve(response.body.val);
+    } else if (response.body.tag === "Event") {
+      logger().trace({ msg: "received event", name: response.body.val.name });
+      this.#dispatchEvent(response.body.val);
+    } else {
+      assertUnreachable(response.body);
+    }
+  }
+  /** Called by the onclose event from drivers. */
+  #handleOnClose(event) {
+    if (this.#onOpenPromise) {
+      this.#onOpenPromise.reject(new Error("Closed"));
+    }
+    const closeEvent = event;
+    const wasClean = closeEvent.wasClean;
+    logger().info({
+      msg: "socket closed",
+      code: closeEvent.code,
+      reason: closeEvent.reason,
+      wasClean,
+      connectionId: this.#connectionId,
+      messageQueueLength: this.#messageQueue.length,
+      actionsInFlight: this.#actionsInFlight.size
+    });
+    if (this.#actionsInFlight.size > 0) {
+      logger().debug({
+        msg: "rejecting in-flight actions after disconnect",
+        count: this.#actionsInFlight.size,
+        connectionId: this.#connectionId,
+        wasClean
+      });
+      const disconnectError = new Error(
+        wasClean ? "Connection closed" : "Connection lost"
+      );
+      for (const actionInfo of this.#actionsInFlight.values()) {
+        actionInfo.reject(disconnectError);
+      }
+      this.#actionsInFlight.clear();
+    }
+    this.#transport = void 0;
+    if (!this.#disposed && !this.#connecting) {
+      logger().debug({
+        msg: "triggering reconnect",
+        connectionId: this.#connectionId,
+        messageQueueLength: this.#messageQueue.length
+      });
+      this.#connectWithRetry();
+    }
+  }
+  /** Called by the onerror event from drivers. */
+  #handleOnError() {
+    if (this.#disposed) return;
+    logger().warn("socket error");
+  }
+  #takeActionInFlight(id) {
+    const inFlight = this.#actionsInFlight.get(id);
+    if (!inFlight) {
+      throw new InternalError2(`No in flight response for ${id}`);
+    }
+    this.#actionsInFlight.delete(id);
+    return inFlight;
+  }
+  #dispatchEvent(event) {
+    const { name, args: argsRaw } = event;
+    const args = cbor5.decode(new Uint8Array(argsRaw));
+    const listeners = this.#eventSubscriptions.get(name);
+    if (!listeners) return;
+    for (const listener of [...listeners]) {
+      listener.callback(...args);
+      if (listener.once) {
+        listeners.delete(listener);
+      }
+    }
+    if (listeners.size === 0) {
+      this.#eventSubscriptions.delete(name);
+    }
+  }
+  #dispatchActorError(error) {
+    for (const handler of [...this.#errorHandlers]) {
+      try {
+        handler(error);
+      } catch (err) {
+        logger().error({
+          msg: "error in connection error handler",
+          error: stringifyError(err)
+        });
+      }
+    }
+  }
+  #addEventSubscription(eventName, callback, once) {
+    const listener = {
+      callback,
+      once
+    };
+    let subscriptionSet = this.#eventSubscriptions.get(eventName);
+    if (subscriptionSet === void 0) {
+      subscriptionSet = /* @__PURE__ */ new Set();
+      this.#eventSubscriptions.set(eventName, subscriptionSet);
+      this.#sendSubscription(eventName, true);
+    }
+    subscriptionSet.add(listener);
+    return () => {
+      const listeners = this.#eventSubscriptions.get(eventName);
+      if (listeners) {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          this.#eventSubscriptions.delete(eventName);
+          this.#sendSubscription(eventName, false);
+        }
+      }
+    };
+  }
+  /**
+   * Subscribes to an event that will happen repeatedly.
+   *
+   * @template Args - The type of arguments the event callback will receive.
+   * @param {string} eventName - The name of the event to subscribe to.
+   * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
+   * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
+   * @see {@link https://rivet.dev/docs/events|Events Documentation}
+   */
+  on(eventName, callback) {
+    return this.#addEventSubscription(eventName, callback, false);
+  }
+  /**
+   * Subscribes to an event that will be triggered only once.
+   *
+   * @template Args - The type of arguments the event callback will receive.
+   * @param {string} eventName - The name of the event to subscribe to.
+   * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
+   * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
+   * @see {@link https://rivet.dev/docs/events|Events Documentation}
+   */
+  once(eventName, callback) {
+    return this.#addEventSubscription(eventName, callback, true);
+  }
+  /**
+   * Subscribes to connection errors.
+   *
+   * @param {ActorErrorCallback} callback - The callback function to execute when a connection error occurs.
+   * @returns {() => void} - A function to unsubscribe from the error handler.
+   */
+  onError(callback) {
+    this.#errorHandlers.add(callback);
+    return () => {
+      this.#errorHandlers.delete(callback);
+    };
+  }
+  #sendMessage(message, opts) {
+    var _a, _b;
+    if (this.#disposed) {
+      throw new ActorConnDisposed();
+    }
+    let queueMessage = false;
+    if (!this.#transport) {
+      logger().debug({ msg: "no transport, queueing message" });
+      queueMessage = true;
+    } else if ("websocket" in this.#transport) {
+      const readyState = this.#transport.websocket.readyState;
+      logger().debug({
+        msg: "websocket send attempt",
+        readyState,
+        readyStateString: readyState === 0 ? "CONNECTING" : readyState === 1 ? "OPEN" : readyState === 2 ? "CLOSING" : "CLOSED",
+        connectionId: this.#connectionId,
+        messageType: message.body.tag,
+        actionName: (_a = message.body.val) == null ? void 0 : _a.name
+      });
+      if (readyState === 1) {
+        try {
+          const messageSerialized = serializeWithEncoding(
+            this.#encoding,
+            message,
+            TO_SERVER_VERSIONED
+          );
+          this.#transport.websocket.send(messageSerialized);
+          logger().trace({
+            msg: "sent websocket message",
+            len: messageLength(messageSerialized)
+          });
+        } catch (error) {
+          logger().warn({
+            msg: "failed to send message, added to queue",
+            error,
+            connectionId: this.#connectionId
+          });
+          queueMessage = true;
+        }
+      } else {
+        logger().debug({
+          msg: "websocket not open, queueing message",
+          readyState
+        });
+        queueMessage = true;
+      }
+    } else if ("sse" in this.#transport) {
+      if (this.#transport.sse.readyState === 1) {
+        this.#sendHttpMessage(message, opts);
+      } else {
+        queueMessage = true;
+      }
+    } else {
+      assertUnreachable(this.#transport);
+    }
+    if (!(opts == null ? void 0 : opts.ephemeral) && queueMessage) {
+      this.#messageQueue.push(message);
+      logger().debug({
+        msg: "queued connection message",
+        queueLength: this.#messageQueue.length,
+        connectionId: this.#connectionId,
+        messageType: message.body.tag,
+        actionName: (_b = message.body.val) == null ? void 0 : _b.name
+      });
+    }
+  }
+  async #sendHttpMessage(message, opts) {
+    try {
+      if (!this.#actorId || !this.#connectionId || !this.#connectionToken)
+        throw new InternalError2("Missing connection ID or token.");
+      logger().trace(
+        getEnvUniversal("_RIVETKIT_LOG_MESSAGE") ? {
+          msg: "sent http message",
+          message: `${jsonStringifyCompat(message).substring(0, 100)}...`
+        } : { msg: "sent http message" }
+      );
+      logger().debug({
+        msg: "sending http message",
+        actorId: this.#actorId,
+        connectionId: this.#connectionId
+      });
+      await sendHttpRequest({
+        url: "http://actor/connections/message",
+        method: "POST",
+        headers: {
+          [HEADER_ENCODING]: this.#encoding,
+          [HEADER_CONN_ID]: this.#connectionId,
+          [HEADER_CONN_TOKEN]: this.#connectionToken
+        },
+        body: message,
+        encoding: this.#encoding,
+        skipParseResponse: true,
+        customFetch: this.#driver.sendRequest.bind(this.#driver, this.#actorId),
+        requestVersionedDataHandler: TO_SERVER_VERSIONED,
+        responseVersionedDataHandler: TO_CLIENT_VERSIONED
+      });
+    } catch (error) {
+      logger().warn({ msg: "failed to send message, added to queue", error });
+      if (!(opts == null ? void 0 : opts.ephemeral)) {
+        this.#messageQueue.unshift(message);
+      }
+    }
+  }
+  async #parseMessage(data) {
+    invariant5(this.#transport, "transport must be defined");
+    if (encodingIsBinary(this.#encoding) && "sse" in this.#transport) {
+      if (typeof data === "string") {
+        const binaryString = atob(data);
+        data = new Uint8Array(
+          [...binaryString].map((char) => char.charCodeAt(0))
+        );
+      } else {
+        throw new InternalError2(
+          `Expected data to be a string for SSE, got ${data}.`
+        );
+      }
+    }
+    const buffer = await inputDataToBuffer(data);
+    return deserializeWithEncoding(this.#encoding, buffer, TO_CLIENT_VERSIONED);
+  }
+  /**
+   * Get the actor ID (for testing purposes).
+   * @internal
+   */
+  get actorId() {
+    return this.#actorId;
+  }
+  /**
+   * Get the connection ID (for testing purposes).
+   * @internal
+   */
+  get connectionId() {
+    return this.#connectionId;
+  }
+  /**
+   * Disconnects from the actor.
+   *
+   * @returns {Promise<void>} A promise that resolves when the socket is gracefully closed.
+   */
+  async dispose() {
+    if (this.#disposed) {
+      logger().warn({ msg: "connection already disconnected" });
+      return;
+    }
+    this.#disposed = true;
+    logger().debug({ msg: "disposing actor conn" });
+    clearInterval(this.#keepNodeAliveInterval);
+    this.#abortController.abort();
+    this.#client[ACTOR_CONNS_SYMBOL].delete(this);
+    if (!this.#transport) {
+    } else if ("websocket" in this.#transport) {
+      const ws = this.#transport.websocket;
+      if (ws.readyState === 2 || ws.readyState === 3) {
+        logger().debug({ msg: "ws already closed or closing" });
+      } else {
+        const { promise, resolve } = promiseWithResolvers();
+        ws.addEventListener("close", () => {
+          logger().debug({ msg: "ws closed" });
+          resolve(void 0);
+        });
+        ws.close();
+        await promise;
+      }
+    } else if ("sse" in this.#transport) {
+      if (this.#connectionId && this.#connectionToken) {
+        try {
+          await sendHttpRequest({
+            url: "http://actor/connections/close",
+            method: "POST",
+            headers: {
+              [HEADER_CONN_ID]: this.#connectionId,
+              [HEADER_CONN_TOKEN]: this.#connectionToken
+            },
+            encoding: this.#encoding,
+            skipParseResponse: true,
+            customFetch: this.#driver.sendRequest.bind(
+              this.#driver,
+              this.#actorId
+            ),
+            requestVersionedDataHandler: TO_SERVER_VERSIONED,
+            responseVersionedDataHandler: TO_CLIENT_VERSIONED
+          });
+        } catch (error) {
+          logger().warn({ msg: "failed to send close request", error });
+        }
+      }
+      this.#transport.sse.close();
+    } else {
+      assertUnreachable(this.#transport);
+    }
+    this.#transport = void 0;
+  }
+  #sendSubscription(eventName, subscribe) {
+    this.#sendMessage(
+      {
+        body: {
+          tag: "SubscriptionRequest",
+          val: {
+            eventName,
+            subscribe
+          }
+        }
+      },
+      { ephemeral: true }
+    );
+  }
+};
+
+// src/remote-manager-driver/mod.ts
+import * as cbor6 from "cbor-x";
+import invariant6 from "invariant";
+
+// src/remote-manager-driver/log.ts
+function logger2() {
+  return getLogger("remote-manager-driver");
+}
+
+// src/remote-manager-driver/api-utils.ts
+var EngineApiError = class extends Error {
+  constructor(group, code, message) {
+    super(message || `Engine API error: ${group}/${code}`);
+    this.group = group;
+    this.code = code;
+    this.name = "EngineApiError";
+  }
+};
+function getEndpoint(config) {
+  return config.endpoint ?? "http://127.0.0.1:6420";
+}
+async function apiCall(config, method, path, body) {
+  const endpoint = getEndpoint(config);
+  const url = combineUrlPath(endpoint, path, {
+    namespace: config.namespace
+  });
+  logger2().debug({ msg: "making api call", method, url });
+  const headers = {
+    ...config.headers
+  };
+  if (config.token) {
+    headers.Authorization = `Bearer ${config.token}`;
+  }
+  return await sendHttpRequest({
+    method,
+    url,
+    headers,
+    body,
+    encoding: "json",
+    skipParseResponse: false,
+    requestVersionedDataHandler: void 0,
+    responseVersionedDataHandler: void 0
+  });
+}
+
+// src/remote-manager-driver/actor-http-client.ts
+async function sendHttpRequestToActor(runConfig, actorId, actorRequest) {
+  const url = new URL(actorRequest.url);
+  const endpoint = getEndpoint(runConfig);
+  const guardUrl = combineUrlPath(endpoint, url.pathname + url.search);
+  let bodyToSend = null;
+  const guardHeaders = buildGuardHeadersForHttp(
+    runConfig,
+    actorRequest,
+    actorId
+  );
+  if (actorRequest.method !== "GET" && actorRequest.method !== "HEAD") {
+    if (actorRequest.bodyUsed) {
+      throw new Error("Request body has already been consumed");
+    }
+    const reqBody = await actorRequest.arrayBuffer();
+    if (reqBody.byteLength !== 0) {
+      bodyToSend = reqBody;
+      guardHeaders.delete("transfer-encoding");
+      guardHeaders.set("content-length", String(bodyToSend.byteLength));
+    }
+  }
+  const guardRequest = new Request(guardUrl, {
+    method: actorRequest.method,
+    headers: guardHeaders,
+    body: bodyToSend,
+    signal: actorRequest.signal
+  });
+  return mutableResponse(await fetch(guardRequest));
+}
+function mutableResponse(fetchRes) {
+  return new Response(fetchRes.body, fetchRes);
+}
+function buildGuardHeadersForHttp(runConfig, actorRequest, actorId) {
+  const headers = new Headers();
+  for (const [key, value] of actorRequest.headers.entries()) {
+    headers.set(key, value);
+  }
+  for (const [key, value] of Object.entries(runConfig.headers)) {
+    headers.set(key, value);
+  }
+  headers.set(HEADER_RIVET_TARGET, "actor");
+  headers.set(HEADER_RIVET_ACTOR, actorId);
+  if (runConfig.token) {
+    headers.set(HEADER_RIVET_TOKEN, runConfig.token);
+  }
+  return headers;
+}
+
+// src/remote-manager-driver/actor-websocket-client.ts
+async function openWebSocketToActor(runConfig, path, actorId, encoding, params, connId, connToken) {
+  const WebSocket2 = await importWebSocket();
+  const endpoint = getEndpoint(runConfig);
+  const guardUrl = combineUrlPath(endpoint, path);
+  logger2().debug({
+    msg: "opening websocket to actor via guard",
+    actorId,
+    path,
+    guardUrl
+  });
+  const ws = new WebSocket2(
+    guardUrl,
+    buildWebSocketProtocols(
+      runConfig,
+      actorId,
+      encoding,
+      params,
+      connId,
+      connToken
+    )
+  );
+  ws.binaryType = "arraybuffer";
+  logger2().debug({ msg: "websocket connection opened", actorId });
+  return ws;
+}
+function buildWebSocketProtocols(runConfig, actorId, encoding, params, connId, connToken) {
+  const protocols = [];
+  protocols.push(WS_PROTOCOL_STANDARD);
+  protocols.push(`${WS_PROTOCOL_TARGET}actor`);
+  protocols.push(`${WS_PROTOCOL_ACTOR}${actorId}`);
+  protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
+  if (runConfig.token) {
+    protocols.push(`${WS_PROTOCOL_TOKEN}${runConfig.token}`);
+  }
+  if (params) {
+    protocols.push(
+      `${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+    );
+  }
+  if (connId) {
+    protocols.push(`${WS_PROTOCOL_CONN_ID}${connId}`);
+  }
+  if (connToken) {
+    protocols.push(`${WS_PROTOCOL_CONN_TOKEN}${connToken}`);
+  }
+  return protocols;
+}
+
+// src/remote-manager-driver/api-endpoints.ts
+async function getActor(config, name, actorId) {
+  return apiCall(
+    config,
+    "GET",
+    `/actors?name=${name}&actor_ids=${encodeURIComponent(actorId)}`
+  );
+}
+async function getActorByKey(config, name, key) {
+  const serializedKey = serializeActorKey(key);
+  return apiCall(
+    config,
+    "GET",
+    `/actors?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`
+  );
+}
+async function getOrCreateActor(config, request) {
+  return apiCall(
+    config,
+    "PUT",
+    `/actors`,
+    request
+  );
+}
+async function createActor(config, request) {
+  return apiCall(
+    config,
+    "POST",
+    `/actors`,
+    request
+  );
+}
+async function destroyActor(config, actorId) {
+  return apiCall(
+    config,
+    "DELETE",
+    `/actors/${encodeURIComponent(actorId)}`
+  );
+}
+
+// src/remote-manager-driver/ws-proxy.ts
+async function createWebSocketProxy(c, targetUrl, protocols) {
+  const WebSocket2 = await importWebSocket();
+  const state = {};
+  return {
+    onOpen: async (event, clientWs) => {
+      logger2().debug({ msg: "client websocket connected", targetUrl });
+      if (clientWs.readyState !== 1) {
+        logger2().warn({
+          msg: "client websocket not open on connection",
+          targetUrl,
+          readyState: clientWs.readyState
+        });
+        return;
+      }
+      const targetWs = new WebSocket2(targetUrl, protocols);
+      state.targetWs = targetWs;
+      state.connectPromise = new Promise((resolve, reject) => {
+        targetWs.addEventListener("open", () => {
+          logger2().debug({ msg: "target websocket connected", targetUrl });
+          if (clientWs.readyState !== 1) {
+            logger2().warn({
+              msg: "client websocket closed before target connected",
+              targetUrl,
+              clientReadyState: clientWs.readyState
+            });
+            targetWs.close(1001, "Client disconnected");
+            reject(new Error("Client disconnected"));
+            return;
+          }
+          resolve();
+        });
+        targetWs.addEventListener("error", (error) => {
+          logger2().warn({
+            msg: "target websocket error during connection",
+            targetUrl
+          });
+          reject(error);
+        });
+      });
+      state.targetWs.addEventListener("message", (event2) => {
+        if (typeof event2.data === "string" || event2.data instanceof ArrayBuffer) {
+          clientWs.send(event2.data);
+        } else if (event2.data instanceof Blob) {
+          event2.data.arrayBuffer().then((buffer) => {
+            clientWs.send(buffer);
+          });
+        }
+      });
+      state.targetWs.addEventListener("close", (event2) => {
+        logger2().debug({
+          msg: "target websocket closed",
+          targetUrl,
+          code: event2.code,
+          reason: event2.reason
+        });
+        closeWebSocketIfOpen(clientWs, event2.code, event2.reason);
+      });
+      state.targetWs.addEventListener("error", (error) => {
+        logger2().error({
+          msg: "target websocket error",
+          targetUrl,
+          error: stringifyError(error)
+        });
+        closeWebSocketIfOpen(clientWs, 1011, "Target WebSocket error");
+      });
+    },
+    onMessage: async (event, clientWs) => {
+      if (!state.targetWs || !state.connectPromise) {
+        logger2().error({ msg: "websocket state not initialized", targetUrl });
+        return;
+      }
+      try {
+        await state.connectPromise;
+        if (state.targetWs.readyState === WebSocket2.OPEN) {
+          state.targetWs.send(event.data);
+        } else {
+          logger2().warn({
+            msg: "target websocket not open",
+            targetUrl,
+            readyState: state.targetWs.readyState
+          });
+        }
+      } catch (error) {
+        logger2().error({
+          msg: "failed to connect to target websocket",
+          targetUrl,
+          error
+        });
+        closeWebSocketIfOpen(clientWs, 1011, "Failed to connect to target");
+      }
+    },
+    onClose: (event, clientWs) => {
+      logger2().debug({
+        msg: "client websocket closed",
+        targetUrl,
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean
+      });
+      if (state.targetWs) {
+        if (state.targetWs.readyState === WebSocket2.OPEN || state.targetWs.readyState === WebSocket2.CONNECTING) {
+          state.targetWs.close(1e3, event.reason || "Client disconnected");
+        }
+      }
+    },
+    onError: (event, clientWs) => {
+      logger2().error({ msg: "client websocket error", targetUrl, event });
+      if (state.targetWs) {
+        if (state.targetWs.readyState === WebSocket2.OPEN) {
+          state.targetWs.close(1011, "Client WebSocket error");
+        } else if (state.targetWs.readyState === WebSocket2.CONNECTING) {
+          state.targetWs.close();
+        }
+      }
+    }
+  };
+}
+function closeWebSocketIfOpen(ws, code, reason) {
+  if (ws.readyState === 1) {
+    ws.close(code, reason);
+  } else if ("close" in ws && ws.readyState === WebSocket.OPEN) {
+    ws.close(code, reason);
+  }
+}
+
+// src/remote-manager-driver/mod.ts
+var RemoteManagerDriver = class {
+  #config;
+  constructor(runConfig) {
+    this.#config = runConfig;
+  }
+  async getForId({
+    c,
+    name,
+    actorId
+  }) {
+    const response = await getActor(this.#config, name, actorId);
+    const actor = response.actors[0];
+    if (!actor) return void 0;
+    if (actor.name !== name) {
+      logger2().debug({
+        msg: "actor name mismatch from api",
+        actorId,
+        apiName: actor.name,
+        requestedName: name
+      });
+      return void 0;
+    }
+    const keyRaw = actor.key;
+    invariant6(keyRaw, `actor ${actorId} should have key`);
+    const key = deserializeActorKey(keyRaw);
+    return {
+      actorId,
+      name,
+      key
+    };
+  }
+  async getWithKey({
+    c,
+    name,
+    key
+  }) {
+    logger2().debug({ msg: "getWithKey: searching for actor", name, key });
+    try {
+      const response = await getActorByKey(this.#config, name, key);
+      const actor = response.actors[0];
+      if (!actor) return void 0;
+      const actorId = actor.actor_id;
+      logger2().debug({
+        msg: "getWithKey: found actor via api",
+        actorId,
+        name,
+        key
+      });
+      return {
+        actorId,
+        name,
+        key
+      };
+    } catch (error) {
+      if (error instanceof EngineApiError && error.group === "actor" && error.code === "not_found") {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async getOrCreateWithKey(input) {
+    const { c, name, key, input: actorInput, region } = input;
+    logger2().info({
+      msg: "getOrCreateWithKey: getting or creating actor via engine api",
+      name,
+      key
+    });
+    const { actor, created } = await getOrCreateActor(this.#config, {
+      name,
+      key: serializeActorKey(key),
+      runner_name_selector: this.#config.runnerName,
+      input: actorInput ? cbor6.encode(actorInput).toString("base64") : void 0,
+      crash_policy: "sleep"
+    });
+    const actorId = actor.actor_id;
+    logger2().info({
+      msg: "getOrCreateWithKey: actor ready",
+      actorId,
+      name,
+      key,
+      created
+    });
+    return {
+      actorId,
+      name,
+      key
+    };
+  }
+  async createActor({
+    c,
+    name,
+    key,
+    input
+  }) {
+    logger2().info({ msg: "creating actor via engine api", name, key });
+    const result = await createActor(this.#config, {
+      name,
+      runner_name_selector: this.#config.runnerName,
+      key: serializeActorKey(key),
+      input: input ? cbor6.encode(input).toString("base64") : null,
+      crash_policy: "sleep"
+    });
+    const actorId = result.actor.actor_id;
+    logger2().info({ msg: "actor created", actorId, name, key });
+    return {
+      actorId,
+      name,
+      key
+    };
+  }
+  async destroyActor(actorId) {
+    logger2().info({ msg: "destroying actor via engine api", actorId });
+    await destroyActor(this.#config, actorId);
+    logger2().info({ msg: "actor destroyed", actorId });
+  }
+  async sendRequest(actorId, actorRequest) {
+    return await sendHttpRequestToActor(this.#config, actorId, actorRequest);
+  }
+  async openWebSocket(path, actorId, encoding, params, connId, connToken) {
+    return await openWebSocketToActor(
+      this.#config,
+      path,
+      actorId,
+      encoding,
+      params,
+      connId,
+      connToken
+    );
+  }
+  async proxyRequest(_c, actorRequest, actorId) {
+    return await sendHttpRequestToActor(this.#config, actorId, actorRequest);
+  }
+  async proxyWebSocket(c, path, actorId, encoding, params, connId, connToken) {
+    var _a, _b;
+    const upgradeWebSocket = (_b = (_a = this.#config).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
+    invariant6(upgradeWebSocket, "missing getUpgradeWebSocket");
+    const endpoint = getEndpoint(this.#config);
+    const guardUrl = combineUrlPath(endpoint, path);
+    const wsGuardUrl = guardUrl.replace("http://", "ws://");
+    logger2().debug({
+      msg: "forwarding websocket to actor via guard",
+      actorId,
+      path,
+      guardUrl
+    });
+    const protocols = buildWebSocketProtocols(
+      this.#config,
+      actorId,
+      encoding,
+      params,
+      connId,
+      connToken
+    );
+    const args = await createWebSocketProxy(c, wsGuardUrl, protocols);
+    return await upgradeWebSocket(() => args)(c, noopNext());
+  }
+  displayInformation() {
+    return { name: "Remote", properties: {} };
+  }
+  getOrCreateInspectorAccessToken() {
+    return generateRandomString();
+  }
+};
+
+export {
+  generateConnId,
+  generateConnToken,
+  generateConnSocketId,
+  createActorInspectorRouter,
+  serializeActorKey,
+  deserializeActorKey,
+  ActorDefinition,
+  lookupInRegistry,
+  ActorClientError,
+  InternalError2 as InternalError,
+  ManagerError,
+  MalformedResponseMessage,
+  ActorError,
+  ActorConnRaw,
+  ActorHandleRaw,
+  createClientWithDriver,
+  RemoteManagerDriver
+};
+//# sourceMappingURL=chunk-BW5DPM6Z.js.map