rivetkit 2.0.24-rc.1 → 2.0.25-rc.1

package/dist/tsup/chunk-O44LFKSB.cjs

@@ -1,4623 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class; var _class2; var _class3; var _class4;
-
-
-
-
-var _chunkINNFK746cjs = require('./chunk-INNFK746.cjs');
-
-
-
-var _chunkZTH3KYFHcjs = require('./chunk-ZTH3KYFH.cjs');
-
-
-
-
-
-
-
-
-
-
-var _chunkVFB23BYZcjs = require('./chunk-VFB23BYZ.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkHHFKKVLRcjs = require('./chunk-HHFKKVLR.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunk7L65NNWPcjs = require('./chunk-7L65NNWP.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkKSRXX3Z4cjs = require('./chunk-KSRXX3Z4.cjs');
-
-// src/actor/conn.ts
-var _cborx = require('cbor-x'); var cbor2 = _interopRequireWildcard(_cborx); var cbor = _interopRequireWildcard(_cborx); var cbor5 = _interopRequireWildcard(_cborx); var cbor4 = _interopRequireWildcard(_cborx); var cbor3 = _interopRequireWildcard(_cborx); var cbor6 = _interopRequireWildcard(_cborx);
-
-// src/actor/conn-drivers.ts
-var WEBSOCKET_DRIVER = {
-  sendMessage: (actor, conn, state, message) => {
-    if (state.websocket.readyState !== 1 /* OPEN */) {
-      actor.rLog.warn({
-        msg: "attempting to send message to closed websocket, this is likely a bug in RivetKit",
-        connId: conn.id,
-        wsReadyState: state.websocket.readyState
-      });
-      return;
-    }
-    const serialized = message.serialize(state.encoding);
-    actor.rLog.debug({
-      msg: "sending websocket message",
-      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: _chunkHHFKKVLRcjs.encodeDataToString.call(void 0, 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 _chunk7L65NNWPcjs.assertUnreachable.call(void 0, state);
-}
-
-// src/actor/instance.ts
-
-var _invariant = require('invariant'); var _invariant2 = _interopRequireDefault(_invariant);
-var _onchange = require('on-change'); var _onchange2 = _interopRequireDefault(_onchange);
-
-// src/inspector/actor.ts
-var _standardvalidator = require('@hono/standard-validator');
-var _fastjsonpatch = require('@rivetkit/fast-json-patch'); var _fastjsonpatch2 = _interopRequireDefault(_fastjsonpatch);
-var _hono = require('hono');
-var _streaming = require('hono/streaming');
-var _nanoevents = require('nanoevents');
-var _v4 = require('zod/v4'); var _v42 = _interopRequireDefault(_v4);
-function createActorInspectorRouter() {
-  return new (0, _hono.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",
-    _standardvalidator.sValidator.call(void 0, 
-      "json",
-      _v42.default.object({ patch: _chunkINNFK746cjs.PatchSchema }).or(_v42.default.object({ replace: _v42.default.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 } = _fastjsonpatch2.default.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 _streaming.streamSSE.call(void 0, 
-      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 } = _chunk7L65NNWPcjs.promiseWithResolvers.call(void 0, );
-        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 _streaming.streamSSE.call(void 0, 
-      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 } = _chunk7L65NNWPcjs.promiseWithResolvers.call(void 0, );
-        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 _streaming.streamSSE.call(void 0, 
-      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 } = _chunk7L65NNWPcjs.promiseWithResolvers.call(void 0, );
-        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 = _chunkINNFK746cjs.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) => _chunkINNFK746cjs.ColumnsSchema.parse(def));
-    const foreignKeysList = await Promise.all(
-      tables.map(
-        (table) => db.execute(`PRAGMA foreign_key_list(${table.name})`)
-      )
-    );
-    const foreignKeys = foreignKeysList.map(
-      (def) => _chunkINNFK746cjs.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",
-    _standardvalidator.sValidator.call(void 0, 
-      "json",
-      _v42.default.object({
-        query: _v42.default.string(),
-        params: _v42.default.array(_v42.default.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);
-      }
-    }
-  ).post(
-    "/action",
-    _standardvalidator.sValidator.call(void 0, 
-      "json",
-      _v42.default.object({
-        name: _v42.default.string(),
-        params: _v42.default.array(_v42.default.any()).optional()
-      })
-    ),
-    async (c) => {
-      const { name, params } = c.req.valid("json");
-      const result = await c.var.inspector.accessors.executeAction(
-        name,
-        params
-      );
-      return c.json({ result }, 200);
-    }
-  );
-}
-var ActorInspector = (_class = class {
-  
-  __init() {this.emitter = _nanoevents.createNanoEvents.call(void 0, )}
-  #lastRealtimeEvents = [];
-  get lastRealtimeEvents() {
-    return this.#lastRealtimeEvents;
-  }
-  constructor(accessors) {;_class.prototype.__init.call(this);
-    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);
-      }
-    });
-  }
-}, _class);
-
-// 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._startSleep();
-  }
-};
-
-// 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 PERSIST_SYMBOL = Symbol("persist");
-var CanSleep = /* @__PURE__ */ ((CanSleep2) => {
-  CanSleep2[CanSleep2["Yes"] = 0] = "Yes";
-  CanSleep2[CanSleep2["NotReady"] = 1] = "NotReady";
-  CanSleep2[CanSleep2["ActiveConns"] = 2] = "ActiveConns";
-  CanSleep2[CanSleep2["ActiveHonoHttpRequests"] = 3] = "ActiveHonoHttpRequests";
-  CanSleep2[CanSleep2["ActiveRawWebSockets"] = 4] = "ActiveRawWebSockets";
-  return CanSleep2;
-})(CanSleep || {});
-var ActorInstance = class {
-  // Shared actor context for this instance
-  
-  /** 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;
-  }
-  #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;
-  get [PERSIST_SYMBOL]() {
-    return this.#persist;
-  }
-  /** Raw state without the proxy wrapper */
-  #persistRaw;
-  #persistWriteQueue = new (0, _chunk7L65NNWPcjs.SinglePromiseQueue)();
-  #alarmWriteQueue = new (0, _chunk7L65NNWPcjs.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 HTTP requests through Hono router so sleep logic can
-   * account for them. Does not include WebSockets.
-   **/
-  #activeHonoHttpRequests = 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,
-            params: conn.params,
-            state: conn.__stateEnabled ? conn.state : void 0,
-            status: conn.status,
-            subscriptions: conn.subscriptions.size,
-            lastSeen: conn.lastSeen,
-            stateEnabled: conn.__stateEnabled,
-            isHibernatable: conn.isHibernatable,
-            hibernatableRequestId: conn.__persist.hibernatableRequestId ? _chunk7L65NNWPcjs.idToStr.call(void 0, conn.__persist.hibernatableRequestId) : void 0,
-            driver: conn.__driverState ? getConnDriverKindFromState(conn.__driverState) : void 0
-          })
-        );
-      },
-      setState: async (state) => {
-        this.#validateStateEnabled();
-        this.#persist.state = { ...state };
-        await this.saveState({ immediate: true });
-      },
-      executeAction: async (name, params) => {
-        const requestId = generateConnRequestId();
-        const conn = await this.createConn(
-          {
-            requestId,
-            hibernatable: false,
-            driverState: { [2 /* HTTP */]: {} }
-          },
-          void 0,
-          void 0
-        );
-        try {
-          return await this.executeAction(
-            new (0, _chunkVFB23BYZcjs.ActionContext)(this.actorContext, conn),
-            name,
-            params || []
-          );
-        } finally {
-          this.__connDisconnected(conn, true, requestId);
-        }
-      }
-    };
-  });
-  get id() {
-    return this.#actorId;
-  }
-  get inlineClient() {
-    return this.#inlineClient;
-  }
-  get inspector() {
-    return this.#inspector;
-  }
-  get #sleepingSupported() {
-    return this.#actorDriver.startSleep !== 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, _c;
-    const logParams = {
-      actor: name,
-      key: serializeActorKey(key),
-      actorId
-    };
-    const extraLogParams = (_a = actorDriver.getExtraActorLogParams) == null ? void 0 : _a.call(actorDriver);
-    if (extraLogParams) Object.assign(logParams, extraLogParams);
-    this.#log = _chunk7L65NNWPcjs.getBaseLogger.call(void 0, ).child(
-      Object.assign(
-        _chunk7L65NNWPcjs.getIncludeTarget.call(void 0, ) ? { target: "actor" } : {},
-        logParams
-      )
-    );
-    this.#rLog = _chunk7L65NNWPcjs.getBaseLogger.call(void 0, ).child(
-      Object.assign(
-        _chunk7L65NNWPcjs.getIncludeTarget.call(void 0, ) ? { 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 _chunkHHFKKVLRcjs.deadline.call(void 0, 
-            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 ((_c = (_b = this.#config.db).onMigrate) == null ? void 0 : _c.call(_b, 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();
-    await this._onAlarm();
-  }
-  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);
-    }
-  }
-  /**
-   * Triggers any pending alarms.
-   *
-   * This method is idempotent. It's called automatically when the actor wakes
-   * in order to trigger any pending alarms.
-   */
-  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.debug({ msg: "no events are due yet" });
-      if (this.#persist.scheduledEvents.length > 0) {
-        const nextTs = this.#persist.scheduledEvents[0].timestamp;
-        this.actorContext.log.debug({
-          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 ? cbor.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: _chunk7L65NNWPcjs.stringifyError.call(void 0, 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: _chunk7L65NNWPcjs.stringifyError.call(void 0, error),
-          ...event
-        });
-      }
-    }
-  }
-  async scheduleEvent(timestamp, action, args) {
-    return this.#scheduleEventInner({
-      eventId: crypto.randomUUID(),
-      timestamp,
-      kind: {
-        generic: {
-          actionName: action,
-          args: _chunk7L65NNWPcjs.bufferToArrayBuffer.call(void 0, cbor.encode(args))
-        }
-      }
-    });
-  }
-  get stateEnabled() {
-    return "createState" in this.#config || "state" in this.#config;
-  }
-  #validateStateEnabled() {
-    if (!this.stateEnabled) {
-      throw new (0, _chunkKSRXX3Z4cjs.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 (0, _chunkKSRXX3Z4cjs.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,
-            _chunkVFB23BYZcjs.PERSISTED_ACTOR_VERSIONED.serializeWithEmbeddedVersion(
-              bareData
-            )
-          );
-          this.#rLog.debug({ msg: "persist saved" });
-        });
-        await finished;
-      }
-      (_a = this.#onPersistSavedPromise) == null ? void 0 : _a.resolve();
-    } catch (error) {
-      this.#rLog.error({
-        msg: "error saving persist",
-        error: _chunk7L65NNWPcjs.stringifyError.call(void 0, 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 (!_chunk7L65NNWPcjs.isCborSerializable.call(void 0, 
-        target,
-        (path) => {
-          invalidPath = path;
-        },
-        ""
-      )) {
-        throw new (0, _chunkKSRXX3Z4cjs.InvalidStateType)({ path: invalidPath });
-      }
-      return target;
-    }
-    if (this.#persist) {
-      _onchange2.default.unsubscribe(this.#persist);
-    }
-    this.#persist = _onchange2.default.call(void 0, 
-      target,
-      // biome-ignore lint/suspicious/noExplicitAny: Don't know types in proxy
-      (path, value, _previousValue, _applyData) => {
-        const actorStatePath = _chunkHHFKKVLRcjs.isStatePath.call(void 0, path);
-        const connStatePath = _chunkHHFKKVLRcjs.isConnStatePath.call(void 0, path);
-        if (actorStatePath || connStatePath) {
-          let invalidPath = "";
-          if (!_chunk7L65NNWPcjs.isCborSerializable.call(void 0, 
-            value,
-            (invalidPathPart) => {
-              invalidPath = invalidPathPart;
-            },
-            ""
-          )) {
-            throw new (0, _chunkKSRXX3Z4cjs.InvalidStateType)({
-              path: path + (invalidPath ? `.${invalidPath}` : "")
-            });
-          }
-        }
-        this.#rLog.debug({
-          msg: "onChange triggered, setting persistChanged=true",
-          path
-        });
-        this.#persistChanged = true;
-        if (actorStatePath) {
-          this.inspector.emitter.emit(
-            "stateUpdated",
-            this.#persist.state
-          );
-        }
-        if (actorStatePath && this.#config.onStateChange && this.#ready && !this.#isInOnStateChange) {
-          try {
-            this.#isInOnStateChange = true;
-            this.#config.onStateChange(
-              this.actorContext,
-              this.#persistRaw.state
-            );
-          } catch (error) {
-            this.#rLog.error({
-              msg: "error in `_onStateChange`",
-              error: _chunk7L65NNWPcjs.stringifyError.call(void 0, error)
-            });
-          } finally {
-            this.#isInOnStateChange = false;
-          }
-        }
-      },
-      { ignoreDetached: true }
-    );
-  }
-  async #initialize() {
-    const persistDataBuffer = await this.#actorDriver.readPersistedData(
-      this.#actorId
-    );
-    _invariant2.default.call(void 0, 
-      persistDataBuffer !== void 0,
-      "persist data has not been set, it should be set when initialized"
-    );
-    const bareData = _chunkVFB23BYZcjs.PERSISTED_ACTOR_VERSIONED.deserializeWithEmbeddedVersion(
-      persistDataBuffer
-    );
-    const persistData = this.#convertFromBarePersisted(bareData);
-    if (persistData.hasInitiated) {
-      this.#rLog.info({
-        msg: "actor restoring",
-        connections: persistData.connections.length,
-        hibernatableWebSockets: persistData.hibernatableWebSocket.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,
-        _chunkVFB23BYZcjs.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);
-  }
-  /**
-   * Call when conn is disconnected. Used by transports.
-   *
-   * 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, requestId) {
-    if (requestId && conn.__socket && requestId !== conn.__socket.requestId) {
-      this.#rLog.debug({
-        msg: "ignoring stale disconnect event",
-        connId: conn.id,
-        eventRequestId: requestId,
-        currentRequestId: conn.__socket.requestId
-      });
-      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;
-      this.#resetSleepTimer();
-    }
-  }
-  /**
-   * 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);
-    this.#rLog.debug({ msg: "removed conn", connId: 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: _chunk7L65NNWPcjs.stringifyError.call(void 0, error)
-            });
-          });
-        }
-      } catch (error) {
-        this.#rLog.error({
-          msg: "error in `onDisconnect`",
-          error: _chunk7L65NNWPcjs.stringifyError.call(void 0, error)
-        });
-      }
-    }
-    this.#resetSleepTimer();
-  }
-  /**
-   * Called to create a new connection or reconnect an existing one.
-   */
-  async createConn(socket, params, request, connectionId, connectionToken) {
-    this.#assertReady();
-    if (socket.requestIdBuf && socket.hibernatable) {
-      this.rLog.debug({
-        msg: "checking for hibernatable websocket connection",
-        requestId: socket.requestId,
-        existingConnectionsCount: this.#connections.size
-      });
-      const existingConn = Array.from(this.#connections.values()).find(
-        (conn2) => conn2.__persist.hibernatableRequestId && _chunk7L65NNWPcjs.arrayBuffersEqual.call(void 0, 
-          conn2.__persist.hibernatableRequestId,
-          socket.requestIdBuf
-        )
-      );
-      if (existingConn) {
-        this.rLog.debug({
-          msg: "reconnecting hibernatable websocket connection",
-          connectionId: existingConn.id,
-          requestId: socket.requestId
-        });
-        if (existingConn.__driverState) {
-          this.#rLog.warn({
-            msg: "found existing driver state on hibernatable websocket",
-            connectionId: existingConn.id,
-            requestId: socket.requestId
-          });
-          const driverKind = getConnDriverKindFromState(
-            existingConn.__driverState
-          );
-          const driver = CONN_DRIVERS[driverKind];
-          if (driver.disconnect) {
-            driver.disconnect(
-              this,
-              existingConn,
-              existingConn.__driverState[driverKind],
-              "Reconnecting hibernatable websocket with new driver state"
-            );
-          }
-        }
-        existingConn.__socket = socket;
-        existingConn.__persist.lastSeen = Date.now();
-        this.#resetSleepTimer();
-        this.inspector.emitter.emit("connectionUpdated");
-        return existingConn;
-      } else {
-        this.rLog.debug({
-          msg: "no existing hibernatable connection found, creating new connection",
-          requestId: socket.requestId
-        });
-      }
-    }
-    if (connectionId && connectionToken) {
-      this.rLog.debug({
-        msg: "checking for existing connection",
-        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 (0, _chunkHHFKKVLRcjs.CachedSerializer)(
-            {
-              body: {
-                tag: "Init",
-                val: {
-                  actorId: this.id,
-                  connectionId: existingConn.id,
-                  connectionToken: existingConn._token
-                }
-              }
-            },
-            _chunkVFB23BYZcjs.TO_CLIENT_VERSIONED
-          )
-        );
-        return existingConn;
-      } else {
-        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 _chunkHHFKKVLRcjs.deadline.call(void 0, 
-            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: []
-    };
-    if (socket.requestIdBuf) {
-      const isHibernatable = this.#persist.hibernatableWebSocket.findIndex(
-        (ws) => _chunk7L65NNWPcjs.arrayBuffersEqual.call(void 0, ws.requestId, socket.requestIdBuf)
-      ) !== -1;
-      if (isHibernatable) {
-        persist.hibernatableRequestId = socket.requestIdBuf;
-      }
-    }
-    const conn = new Conn(this, persist);
-    conn.__socket = socket;
-    this.#connections.set(conn.id, conn);
-    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) {
-          _chunkHHFKKVLRcjs.deadline.call(void 0, 
-            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: _chunk7L65NNWPcjs.stringifyError.call(void 0, error)
-        });
-        conn == null ? void 0 : conn.disconnect("`onConnect` failed");
-      }
-    }
-    this.inspector.emitter.emit("connectionUpdated");
-    conn._sendMessage(
-      new (0, _chunkHHFKKVLRcjs.CachedSerializer)(
-        {
-          body: {
-            tag: "Init",
-            val: {
-              actorId: this.id,
-              connectionId: conn.id,
-              connectionToken: conn._token
-            }
-          }
-        },
-        _chunkVFB23BYZcjs.TO_CLIENT_VERSIONED
-      )
-    );
-    return conn;
-  }
-  // MARK: Messages
-  async processMessage(message, conn) {
-    await _chunkVFB23BYZcjs.processMessage.call(void 0, 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 (0, _chunkKSRXX3Z4cjs.InternalError)("Actor not ready");
-    if (!allowStoppingState && this.#stopCalled)
-      throw new (0, _chunkKSRXX3Z4cjs.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" });
-    let connected = 0;
-    let reconnecting = 0;
-    let removed = 0;
-    for (const conn of this.#connections.values()) {
-      if (conn.__status === "connected") {
-        connected += 1;
-        this.#rLog.debug({
-          msg: "connection is alive",
-          connId: conn.id
-        });
-      } else {
-        reconnecting += 1;
-        const lastSeen = conn.__persist.lastSeen;
-        const sinceLastSeen = Date.now() - lastSeen;
-        if (sinceLastSeen < this.#config.options.connectionLivenessTimeout) {
-          this.#rLog.debug({
-            msg: "connection might be alive, will check later",
-            connId: conn.id,
-            lastSeen,
-            sinceLastSeen
-          });
-          continue;
-        }
-        this.#rLog.info({
-          msg: "connection is dead, removing",
-          connId: conn.id,
-          lastSeen
-        });
-        removed += 1;
-        this.#removeConn(conn);
-      }
-    }
-    this.#rLog.debug({
-      msg: "checked connection liveness",
-      total: connected + reconnecting,
-      connected,
-      reconnecting,
-      removed
-    });
-  }
-  /**
-   * Check if the actor is ready to handle requests.
-   */
-  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) {
-    _invariant2.default.call(void 0, this.#ready, "executing action before ready");
-    if (!(actionName in this.#config.actions)) {
-      this.#rLog.warn({ msg: "action does not exist", actionName });
-      throw new (0, _chunkKSRXX3Z4cjs.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 (0, _chunkKSRXX3Z4cjs.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 _chunkHHFKKVLRcjs.deadline.call(void 0, 
-          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: _chunk7L65NNWPcjs.stringifyError.call(void 0, error)
-          });
-        }
-      }
-      this.#rLog.debug({
-        msg: "action completed",
-        actionName,
-        outputType: typeof output,
-        isPromise: output instanceof Promise
-      });
-      return output;
-    } catch (error) {
-      if (error instanceof _chunkHHFKKVLRcjs.DeadlineError) {
-        throw new (0, _chunkKSRXX3Z4cjs.ActionTimedOut)();
-      }
-      this.#rLog.error({
-        msg: "action error",
-        actionName,
-        error: _chunk7L65NNWPcjs.stringifyError.call(void 0, 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 (0, _chunkKSRXX3Z4cjs.FetchHandlerNotDefined)();
-    }
-    try {
-      const response = await this.#config.onFetch(
-        this.actorContext,
-        request,
-        opts
-      );
-      if (!response) {
-        throw new (0, _chunkKSRXX3Z4cjs.InvalidFetchResponse)();
-      }
-      return response;
-    } catch (error) {
-      this.#rLog.error({
-        msg: "onFetch error",
-        error: _chunk7L65NNWPcjs.stringifyError.call(void 0, error)
-      });
-      throw error;
-    } finally {
-      this.#savePersistThrottled();
-    }
-  }
-  /**
-   * Handles raw WebSocket connections to the actor.
-   */
-  async handleWebSocket(websocket, opts) {
-    this.#assertReady();
-    if (!this.#config.onWebSocket) {
-      throw new (0, _chunkKSRXX3Z4cjs.InternalError)("onWebSocket handler not defined");
-    }
-    try {
-      const stateBeforeHandler = this.#persistChanged;
-      this.#activeRawWebSockets.add(websocket);
-      this.#resetSleepTimer();
-      let rivetRequestId;
-      let persistedHibernatableWebSocket;
-      const onSocketOpened = (event) => {
-        rivetRequestId = event == null ? void 0 : event.rivetRequestId;
-        if (rivetRequestId) {
-          const rivetRequestIdLocal = rivetRequestId;
-          persistedHibernatableWebSocket = this.#persist.hibernatableWebSocket.find(
-            (ws) => _chunk7L65NNWPcjs.arrayBuffersEqual.call(void 0, 
-              ws.requestId,
-              rivetRequestIdLocal
-            )
-          );
-          if (persistedHibernatableWebSocket) {
-            persistedHibernatableWebSocket.lastSeenTimestamp = BigInt(Date.now());
-          }
-        }
-        this.#rLog.debug({
-          msg: "actor instance onSocketOpened",
-          rivetRequestId,
-          isHibernatable: !!persistedHibernatableWebSocket,
-          hibernationMsgIndex: persistedHibernatableWebSocket == null ? void 0 : persistedHibernatableWebSocket.msgIndex
-        });
-      };
-      const onSocketMessage = (event) => {
-        if (persistedHibernatableWebSocket) {
-          persistedHibernatableWebSocket.lastSeenTimestamp = BigInt(
-            Date.now()
-          );
-          persistedHibernatableWebSocket.msgIndex = BigInt(
-            event.rivetMessageIndex
-          );
-        }
-        this.#rLog.debug({
-          msg: "actor instance onSocketMessage",
-          rivetRequestId,
-          isHibernatable: !!persistedHibernatableWebSocket,
-          hibernationMsgIndex: persistedHibernatableWebSocket == null ? void 0 : persistedHibernatableWebSocket.msgIndex
-        });
-      };
-      const onSocketClosed = (_event) => {
-        if (rivetRequestId) {
-          const rivetRequestIdLocal = rivetRequestId;
-          const wsIndex = this.#persist.hibernatableWebSocket.findIndex(
-            (ws) => _chunk7L65NNWPcjs.arrayBuffersEqual.call(void 0, 
-              ws.requestId,
-              rivetRequestIdLocal
-            )
-          );
-          const removed = this.#persist.hibernatableWebSocket.splice(
-            wsIndex,
-            1
-          );
-          if (removed.length > 0) {
-            this.#rLog.debug({
-              msg: "removed hibernatable websocket",
-              rivetRequestId,
-              hibernationMsgIndex: persistedHibernatableWebSocket == null ? void 0 : persistedHibernatableWebSocket.msgIndex
-            });
-          } else {
-            this.#rLog.warn({
-              msg: "could not find hibernatable websocket to remove",
-              rivetRequestId,
-              hibernationMsgIndex: persistedHibernatableWebSocket == null ? void 0 : persistedHibernatableWebSocket.msgIndex
-            });
-          }
-        }
-        this.#rLog.debug({
-          msg: "actor instance onSocketMessage",
-          rivetRequestId,
-          isHibernatable: !!persistedHibernatableWebSocket,
-          hibernatableWebSocketCount: this.#persist.hibernatableWebSocket.length
-        });
-        try {
-          websocket.removeEventListener("open", onSocketOpened);
-          websocket.removeEventListener("message", onSocketMessage);
-          websocket.removeEventListener("close", onSocketClosed);
-          websocket.removeEventListener("error", onSocketClosed);
-        } catch (e) {
-        }
-        this.#activeRawWebSockets.delete(websocket);
-        this.#resetSleepTimer();
-      };
-      try {
-        websocket.addEventListener("open", onSocketOpened);
-        websocket.addEventListener("message", onSocketMessage);
-        websocket.addEventListener("close", onSocketClosed);
-        websocket.addEventListener("error", onSocketClosed);
-      } catch (e2) {
-      }
-      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: _chunk7L65NNWPcjs.stringifyError.call(void 0, error)
-      });
-      throw error;
-    } finally {
-      this.#savePersistThrottled();
-    }
-  }
-  // MARK: Lifecycle hooks
-  // MARK: Exposed methods
-  get log() {
-    _invariant2.default.call(void 0, this.#log, "log not configured");
-    return this.#log;
-  }
-  get rLog() {
-    _invariant2.default.call(void 0, 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 (0, _chunkKSRXX3Z4cjs.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();
-    _invariant2.default.call(void 0, 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 (0, _chunkHHFKKVLRcjs.CachedSerializer)(
-      {
-        body: {
-          tag: "Event",
-          val: {
-            name,
-            args: _chunk7L65NNWPcjs.bufferToArrayBuffer.call(void 0, cbor.encode(args))
-          }
-        }
-      },
-      _chunkVFB23BYZcjs.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: _chunk7L65NNWPcjs.stringifyError.call(void 0, 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);
-    this.#rLog.debug({
-      msg: "saveState called",
-      persistChanged: this.#persistChanged,
-      allowStoppingState: opts.allowStoppingState,
-      immediate: opts.immediate
-    });
-    if (this.#persistChanged) {
-      if (opts.immediate) {
-        await this.#savePersistInner();
-      } else {
-        if (!this.#onPersistSavedPromise) {
-          this.#onPersistSavedPromise = _chunk7L65NNWPcjs.promiseWithResolvers.call(void 0, );
-        }
-        this.#savePersistThrottled();
-        await this.#onPersistSavedPromise.promise;
-      }
-    }
-  }
-  /**
-   * Called by router middleware when an HTTP request begins.
-   */
-  __beginHonoHttpRequest() {
-    this.#activeHonoHttpRequests++;
-    this.#resetSleepTimer();
-  }
-  /**
-   * Called by router middleware when an HTTP request ends.
-   */
-  __endHonoHttpRequest() {
-    this.#activeHonoHttpRequests--;
-    if (this.#activeHonoHttpRequests < 0) {
-      this.#activeHonoHttpRequests = 0;
-      this.#rLog.warn({
-        msg: "active hono requests went below 0, this is a RivetKit bug",
-        ..._chunk7L65NNWPcjs.EXTRA_ERROR_LOG
-      });
-    }
-    this.#resetSleepTimer();
-  }
-  // 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;
-    if (this.#stopCalled) return;
-    const canSleep = this.#canSleep();
-    this.#rLog.debug({
-      msg: "resetting sleep timer",
-      canSleep: CanSleep[canSleep],
-      existingTimeout: !!this.#sleepTimeout,
-      timeout: this.#config.options.sleepTimeout
-    });
-    if (this.#sleepTimeout) {
-      clearTimeout(this.#sleepTimeout);
-      this.#sleepTimeout = void 0;
-    }
-    if (this.#sleepCalled) return;
-    if (canSleep === 0 /* Yes */) {
-      this.#sleepTimeout = setTimeout(() => {
-        this._startSleep();
-      }, this.#config.options.sleepTimeout);
-    }
-  }
-  /** If this actor can be put in a sleeping state. */
-  #canSleep() {
-    if (!this.#ready) return 1 /* NotReady */;
-    if (this.#activeHonoHttpRequests > 0)
-      return 3 /* ActiveHonoHttpRequests */;
-    if (this.#activeRawWebSockets.size > 0)
-      return 4 /* ActiveRawWebSockets */;
-    for (const conn of this.#connections.values()) {
-      if (conn.status === "connected") return 2 /* ActiveConns */;
-    }
-    return 0 /* Yes */;
-  }
-  /**
-   * Puts an actor to sleep. This should just start the sleep sequence, most shutdown logic should be in _stop (which is called by the ActorDriver when sleeping).
-   *
-   * For the engine, this will:
-   * 1. Publish EventActorIntent with ActorIntentSleep (via driver.startSleep)
-   * 2. Engine runner will wait for CommandStopActor
-   * 3. Engine runner will call _onStop and wait for it to finish
-   * 4. Engine runner will publish EventActorStateUpdate with ActorStateSTop
-   **/
-  _startSleep() {
-    var _a;
-    if (this.#stopCalled) {
-      this.#rLog.debug({
-        msg: "cannot call _startSleep if actor already stopping"
-      });
-      return;
-    }
-    if (this.#sleepCalled) {
-      this.#rLog.warn({
-        msg: "cannot call _startSleep twice, actor already sleeping"
-      });
-      return;
-    }
-    this.#sleepCalled = true;
-    const sleep = (_a = this.#actorDriver.startSleep) == null ? void 0 : _a.bind(
-      this.#actorDriver,
-      this.#actorId
-    );
-    _invariant2.default.call(void 0, this.#sleepingSupported, "sleeping not supported");
-    _invariant2.default.call(void 0, sleep, "no sleep on driver");
-    this.#rLog.info({ msg: "actor sleeping" });
-    setImmediate(() => {
-      sleep();
-    });
-  }
-  // MARK: Stop
-  /**
-   * For the engine:
-   * 1. Engine runner receives CommandStopActor
-   * 2. Engine runner calls _onStop and waits for it to finish
-   * 3. Engine runner publishes EventActorStateUpdate with ActorStateSTop
-   */
-  async _onStop() {
-    if (this.#stopCalled) {
-      this.#rLog.warn({ msg: "already stopping actor" });
-      return;
-    }
-    this.#stopCalled = true;
-    this.#rLog.info({ msg: "actor stopping" });
-    if (this.#sleepTimeout) {
-      clearTimeout(this.#sleepTimeout);
-      this.#sleepTimeout = void 0;
-    }
-    try {
-      this.#abortController.abort();
-    } catch (e3) {
-    }
-    if (this.#config.onStop) {
-      try {
-        this.#rLog.debug({ msg: "calling onStop" });
-        const result = this.#config.onStop(this.actorContext);
-        if (result instanceof Promise) {
-          await _chunkHHFKKVLRcjs.deadline.call(void 0, result, this.#config.options.onStopTimeout);
-        }
-        this.#rLog.debug({ msg: "onStop completed" });
-      } catch (error) {
-        if (error instanceof _chunkHHFKKVLRcjs.DeadlineError) {
-          this.#rLog.error({ msg: "onStop timed out" });
-        } else {
-          this.#rLog.error({
-            msg: "error in onStop",
-            error: _chunk7L65NNWPcjs.stringifyError.call(void 0, error)
-          });
-        }
-      }
-    }
-    const promises = [];
-    for (const connection of this.#connections.values()) {
-      if (!connection.isHibernatable) {
-        this.#rLog.debug({
-          msg: "disconnecting non-hibernatable connection on actor stop",
-          connId: connection.id
-        });
-        promises.push(connection.disconnect());
-      }
-    }
-    await this.#waitBackgroundPromises(
-      this.#config.options.waitUntilTimeout
-    );
-    if (this.#pendingSaveTimeout) clearTimeout(this.#pendingSaveTimeout);
-    if (this.#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 ? _chunk7L65NNWPcjs.bufferToArrayBuffer.call(void 0, cbor.encode(persist.input)) : null,
-      hasInitialized: persist.hasInitiated,
-      state: _chunk7L65NNWPcjs.bufferToArrayBuffer.call(void 0, cbor.encode(persist.state)),
-      connections: persist.connections.map((conn) => ({
-        id: conn.connId,
-        token: conn.token,
-        parameters: _chunk7L65NNWPcjs.bufferToArrayBuffer.call(void 0, cbor.encode(conn.params || {})),
-        state: _chunk7L65NNWPcjs.bufferToArrayBuffer.call(void 0, cbor.encode(conn.state || {})),
-        subscriptions: conn.subscriptions.map((sub) => ({
-          eventName: sub.eventName
-        })),
-        lastSeen: BigInt(conn.lastSeen),
-        hibernatableRequestId: _nullishCoalesce(conn.hibernatableRequestId, () => ( null))
-      })),
-      scheduledEvents: persist.scheduledEvents.map((event) => ({
-        eventId: event.eventId,
-        timestamp: BigInt(event.timestamp),
-        kind: {
-          tag: "GenericPersistedScheduleEvent",
-          val: {
-            action: event.kind.generic.actionName,
-            args: _nullishCoalesce(event.kind.generic.args, () => ( null))
-          }
-        }
-      })),
-      hibernatableWebSocket: persist.hibernatableWebSocket.map((ws) => ({
-        requestId: ws.requestId,
-        lastSeenTimestamp: ws.lastSeenTimestamp,
-        msgIndex: ws.msgIndex
-      }))
-    };
-  }
-  #convertFromBarePersisted(bareData) {
-    return {
-      input: bareData.input ? cbor.decode(new Uint8Array(bareData.input)) : void 0,
-      hasInitiated: bareData.hasInitialized,
-      state: cbor.decode(new Uint8Array(bareData.state)),
-      connections: bareData.connections.map((conn) => ({
-        connId: conn.id,
-        token: conn.token,
-        params: cbor.decode(new Uint8Array(conn.parameters)),
-        state: cbor.decode(new Uint8Array(conn.state)),
-        subscriptions: conn.subscriptions.map((sub) => ({
-          eventName: sub.eventName
-        })),
-        lastSeen: Number(conn.lastSeen),
-        hibernatableRequestId: _nullishCoalesce(conn.hibernatableRequestId, () => ( void 0))
-      })),
-      scheduledEvents: bareData.scheduledEvents.map((event) => ({
-        eventId: event.eventId,
-        timestamp: Number(event.timestamp),
-        kind: {
-          generic: {
-            actionName: event.kind.val.action,
-            args: event.kind.val.args
-          }
-        }
-      })),
-      hibernatableWebSocket: bareData.hibernatableWebSocket.map((ws) => ({
-        requestId: ws.requestId,
-        lastSeenTimestamp: ws.lastSeenTimestamp,
-        msgIndex: ws.msgIndex
-      }))
-    };
-  }
-};
-
-// src/actor/conn.ts
-function generateConnId() {
-  return crypto.randomUUID();
-}
-function generateConnToken() {
-  return _chunkHHFKKVLRcjs.generateSecureToken.call(void 0, 32);
-}
-function generateConnRequestId() {
-  return crypto.randomUUID();
-}
-var Conn = (_class2 = class {
-  __init2() {this.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.
-   */
-  
-  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.
-   */
-  
-  get __status() {
-    if (this.__socket || this.isHibernatable) {
-      return "connected";
-    } else {
-      return "reconnecting";
-    }
-  }
-  get params() {
-    return this.__persist.params;
-  }
-  get __stateEnabled() {
-    return this.#actor.connStateEnabled;
-  }
-  /**
-   * Gets the current state of the connection.
-   *
-   * Throws an error if the state is not enabled.
-   */
-  get state() {
-    this.#validateStateEnabled();
-    if (!this.__persist.state) throw new Error("state should exists");
-    return this.__persist.state;
-  }
-  /**
-   * Sets the state of the connection.
-   *
-   * Throws an error if the state is not enabled.
-   */
-  set state(value) {
-    this.#validateStateEnabled();
-    this.__persist.state = value;
-  }
-  /**
-   * Unique identifier for the connection.
-   */
-  get id() {
-    return this.__persist.connId;
-  }
-  /**
-   * Token used to authenticate this request.
-   */
-  get _token() {
-    return this.__persist.token;
-  }
-  /**
-   * Status of the connection.
-   */
-  get status() {
-    return this.__status;
-  }
-  /**
-   * @experimental
-   *
-   * If the underlying connection can hibernate.
-   */
-  get isHibernatable() {
-    if (!this.__persist.hibernatableRequestId) {
-      return false;
-    }
-    return this.#actor[PERSIST_SYMBOL].hibernatableWebSocket.findIndex(
-      (x) => _chunk7L65NNWPcjs.arrayBuffersEqual.call(void 0, 
-        x.requestId,
-        this.__persist.hibernatableRequestId
-      )
-    ) > -1;
-  }
-  /**
-   * Timestamp of the last time the connection was seen, i.e. the last time the connection was active and checked for liveness.
-   */
-  get lastSeen() {
-    return this.__persist.lastSeen;
-  }
-  /**
-   * Initializes a new instance of the Connection class.
-   *
-   * This should only be constructed by {@link Actor}.
-   *
-   * @protected
-   */
-  constructor(actor, persist) {;_class2.prototype.__init2.call(this);
-    this.#actor = actor;
-    this.__persist = persist;
-  }
-  #validateStateEnabled() {
-    if (!this.__stateEnabled) {
-      throw new (0, _chunkKSRXX3Z4cjs.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 (0, _chunkHHFKKVLRcjs.CachedSerializer)(
-        {
-          body: {
-            tag: "Event",
-            val: {
-              name: eventName,
-              args: _chunk7L65NNWPcjs.bufferToArrayBuffer.call(void 0, cbor2.encode(args))
-            }
-          }
-        },
-        _chunkVFB23BYZcjs.TO_CLIENT_VERSIONED
-      )
-    );
-  }
-  /**
-   * Disconnects the client with an optional reason.
-   *
-   * @param reason - The reason for disconnection.
-   */
-  async disconnect(reason) {
-    if (this.__socket && this.__driverState) {
-      const driverKind = getConnDriverKindFromState(this.__driverState);
-      const driver = CONN_DRIVERS[driverKind];
-      if (driver.disconnect) {
-        driver.disconnect(
-          this.#actor,
-          this,
-          this.__driverState[driverKind],
-          reason
-        );
-      } else {
-        this.#actor.rLog.debug({
-          msg: "no disconnect handler for conn driver",
-          conn: this.id
-        });
-      }
-      this.#actor.__connDisconnected(this, true, this.__socket.requestId);
-    } else {
-      this.#actor.rLog.warn({
-        msg: "missing connection driver state for disconnect",
-        conn: this.id
-      });
-    }
-    this.__socket = void 0;
-  }
-}, _class2);
-
-// 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 = (_class3 = class extends ActorClientError {
-  constructor(group, code, message, metadata) {
-    super(message);_class3.prototype.__init3.call(this);;
-    this.group = group;
-    this.code = code;
-    this.metadata = metadata;
-  }
-  __init3() {this.__type = "ActorError"}
-}, _class3);
-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
-
-
-var _pretry = require('p-retry'); var _pretry2 = _interopRequireDefault(_pretry);
-
-// src/common/eventsource.ts
-var eventSourcePromise = null;
-async function importEventSource() {
-  if (eventSourcePromise !== null) {
-    return eventSourcePromise;
-  }
-  eventSourcePromise = (async () => {
-    let _EventSource;
-    try {
-      const moduleName = "eventsource";
-      const es = await Promise.resolve().then(() => _interopRequireWildcard(require(
-        /* webpackIgnore: true */
-        moduleName
-      )));
-      _EventSource = es.EventSource;
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).debug("using eventsource from npm");
-    } catch (err) {
-      _EventSource = class MockEventSource {
-        constructor() {
-          throw new Error(
-            'EventSource support requires installing the "eventsource" peer dependency.'
-          );
-        }
-      };
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).debug("using mock eventsource");
-    }
-    return _EventSource;
-  })();
-  return eventSourcePromise;
-}
-
-// src/client/actor-query.ts
-async function queryActor(c, query, managerDriver) {
-  _chunkZTH3KYFHcjs.logger.call(void 0, ).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 (0, _chunkKSRXX3Z4cjs.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 (0, _chunkKSRXX3Z4cjs.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 (0, _chunkKSRXX3Z4cjs.InvalidRequest)("Invalid query format");
-  }
-  _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({ msg: "actor query result", actorId: actorOutput.actorId });
-  return { actorId: actorOutput.actorId };
-}
-
-// src/client/actor-handle.ts
-
-
-
-// src/client/raw-utils.ts
-
-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);
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({ msg: "found actor for raw http", actorId });
-    _invariant2.default.call(void 0, 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(_chunkHHFKKVLRcjs.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 } = _chunk7L65NNWPcjs.deconstructError.call(void 0, 
-      err,
-      _chunkZTH3KYFHcjs.logger.call(void 0, ),
-      {},
-      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);
-  _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({ msg: "found actor for action", actorId });
-  _invariant2.default.call(void 0, 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 = `${_chunkHHFKKVLRcjs.PATH_RAW_WEBSOCKET_PREFIX}${pathPortion}${queryPortion}`;
-  _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({
-    msg: "opening websocket",
-    actorId,
-    encoding,
-    path: fullPath
-  });
-  const ws = await driver.openWebSocket(fullPath, actorId, encoding, params);
-  return ws;
-}
-
-// src/client/utils.ts
-
-
-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;
-  }
-  _chunk7L65NNWPcjs.assertUnreachable.call(void 0, message);
-}
-async function sendHttpRequest(opts) {
-  _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({
-    msg: "sending http request",
-    url: opts.url,
-    encoding: opts.encoding
-  });
-  let contentType;
-  let bodyData;
-  if (opts.method === "POST" || opts.method === "PUT") {
-    _invariant2.default.call(void 0, opts.body !== void 0, "missing body");
-    contentType = _chunkHHFKKVLRcjs.contentTypeForEncoding.call(void 0, opts.encoding);
-    bodyData = _chunkHHFKKVLRcjs.serializeWithEncoding.call(void 0, 
-      opts.encoding,
-      opts.body,
-      opts.requestVersionedDataHandler
-    );
-  }
-  let response;
-  try {
-    response = await (_nullishCoalesce(opts.customFetch, () => ( fetch)))(
-      new Request(opts.url, {
-        method: opts.method,
-        headers: {
-          ...opts.headers,
-          ...contentType ? {
-            "Content-Type": contentType
-          } : {},
-          "User-Agent": _chunk7L65NNWPcjs.httpUserAgent.call(void 0, )
-        },
-        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 = _chunkHHFKKVLRcjs.deserializeWithEncoding.call(void 0, 
-        opts.encoding,
-        new Uint8Array(bufferResponse),
-        _chunkVFB23BYZcjs.HTTP_RESPONSE_ERROR_VERSIONED
-      );
-    } catch (error) {
-      const textResponse = new TextDecoder("utf-8", {
-        fatal: false
-      }).decode(bufferResponse);
-      const rayId = response.headers.get("x-rivet-ray-id");
-      if (rayId) {
-        throw new HttpRequestError(
-          `${response.statusText} (${response.status}) (Ray ID: ${rayId}):
-${textResponse}`
-        );
-      } else {
-        throw new HttpRequestError(
-          `${response.statusText} (${response.status}):
-${textResponse}`
-        );
-      }
-    }
-    let decodedMetadata;
-    if (responseData.metadata && _chunkHHFKKVLRcjs.encodingIsBinary.call(void 0, opts.encoding)) {
-      decodedMetadata = cbor3.decode(
-        new Uint8Array(responseData.metadata)
-      );
-    }
-    throw new ActorError(
-      responseData.group,
-      responseData.code,
-      responseData.message,
-      decodedMetadata
-    );
-  }
-  if (opts.skipParseResponse) {
-    return void 0;
-  }
-  try {
-    const buffer = new Uint8Array(await response.arrayBuffer());
-    return _chunkHHFKKVLRcjs.deserializeWithEncoding.call(void 0, 
-      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
-      );
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({ msg: "found actor for action", actorId });
-      _invariant2.default.call(void 0, actorId, "Missing actor ID");
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({
-        msg: "handling action",
-        name: opts.name,
-        encoding: this.#encoding
-      });
-      const responseData = await sendHttpRequest({
-        url: `http://actor/action/${encodeURIComponent(opts.name)}`,
-        method: "POST",
-        headers: {
-          [_chunkHHFKKVLRcjs.HEADER_ENCODING]: this.#encoding,
-          ...this.#params !== void 0 ? { [_chunkHHFKKVLRcjs.HEADER_CONN_PARAMS]: JSON.stringify(this.#params) } : {}
-        },
-        body: {
-          args: _chunk7L65NNWPcjs.bufferToArrayBuffer.call(void 0, cbor4.encode(opts.args))
-        },
-        encoding: this.#encoding,
-        customFetch: this.#driver.sendRequest.bind(
-          this.#driver,
-          actorId
-        ),
-        signal: opts == null ? void 0 : opts.signal,
-        requestVersionedDataHandler: _chunkVFB23BYZcjs.HTTP_ACTION_REQUEST_VERSIONED,
-        responseVersionedDataHandler: _chunkVFB23BYZcjs.HTTP_ACTION_RESPONSE_VERSIONED
-      });
-      return cbor4.decode(new Uint8Array(responseData.output));
-    } catch (err) {
-      const { group, code, message, metadata } = _chunk7L65NNWPcjs.deconstructError.call(void 0, 
-        err,
-        _chunkZTH3KYFHcjs.logger.call(void 0, ),
-        {},
-        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() {
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).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 {
-        _chunkHHFKKVLRcjs.assertUnreachable.call(void 0, 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) {
-      _invariant2.default.call(void 0, false, "actorQuery cannot be create");
-    } else {
-      _chunkHHFKKVLRcjs.assertUnreachable.call(void 0, 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 = (_class4 = class {
-  #disposed = false;
-  __init4() {this[ACTOR_CONNS_SYMBOL] = /* @__PURE__ */ new Set()}
-  #driver;
-  #encodingKind;
-  
-  /**
-   * Creates an instance of Client.
-   */
-  constructor(driver, config) {;_class4.prototype.__init4.call(this);
-    this.#driver = driver;
-    this.#encodingKind = _nullishCoalesce(config.encoding, () => ( "bare"));
-    this[TRANSPORT_SYMBOL] = _nullishCoalesce(config.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) {
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).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 || [];
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).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 || [];
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).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
-      }
-    };
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).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
-    );
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).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) {
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).warn({ msg: "client already disconnected" });
-      return;
-    }
-    this.#disposed = true;
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({ msg: "disposing client" });
-    const disposePromises = [];
-    for (const conn of this[ACTOR_CONNS_SYMBOL].values()) {
-      disposePromises.push(conn.dispose());
-    }
-    await Promise.all(disposePromises);
-  }
-}, _class4);
-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) {
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({ msg: "action", name: opts.name, args: opts.args });
-    const actionId = this.#actionIdCounter;
-    this.#actionIdCounter += 1;
-    const { promise, resolve, reject } = _chunk7L65NNWPcjs.promiseWithResolvers.call(void 0, );
-    this.#actionsInFlight.set(actionId, {
-      name: opts.name,
-      resolve,
-      reject
-    });
-    this.#sendMessage({
-      body: {
-        tag: "ActionRequest",
-        val: {
-          id: BigInt(actionId),
-          name: opts.name,
-          args: _chunk7L65NNWPcjs.bufferToArrayBuffer.call(void 0, 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 _pretry2.default.call(void 0, this.#connectAndWait.bind(this), {
-        forever: true,
-        minTimeout: 250,
-        maxTimeout: 3e4,
-        onFailedAttempt: (error) => {
-          _chunkZTH3KYFHcjs.logger.call(void 0, ).warn({
-            msg: "failed to reconnect",
-            attempt: error.attemptNumber,
-            error: _chunk7L65NNWPcjs.stringifyError.call(void 0, error)
-          });
-        },
-        // Cancel retry if aborted
-        signal: this.#abortController.signal
-      });
-    } catch (err) {
-      if (err.name === "AbortError") {
-        _chunkZTH3KYFHcjs.logger.call(void 0, ).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 = _chunk7L65NNWPcjs.promiseWithResolvers.call(void 0, );
-      if (this.#client[TRANSPORT_SYMBOL] === "websocket") {
-        await this.#connectWebSocket();
-      } else if (this.#client[TRANSPORT_SYMBOL] === "sse") {
-        await this.#connectSse();
-      } else {
-        _chunk7L65NNWPcjs.assertUnreachable.call(void 0, 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) {
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({
-        msg: "attempting websocket reconnection",
-        connectionId: this.#connectionId
-      });
-    }
-    const ws = await this.#driver.openWebSocket(
-      _chunkHHFKKVLRcjs.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
-    );
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({
-      msg: "transport set to new websocket",
-      connectionId: this.#connectionId,
-      readyState: ws.readyState,
-      messageQueueLength: this.#messageQueue.length
-    });
-    this.#transport = { websocket: ws };
-    ws.addEventListener("open", () => {
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({
-        msg: "client websocket open",
-        connectionId: this.#connectionId
-      });
-    });
-    ws.addEventListener("message", async (ev) => {
-      try {
-        await this.#handleOnMessage(ev.data);
-      } catch (err) {
-        _chunkZTH3KYFHcjs.logger.call(void 0, ).error({
-          msg: "error in websocket message handler",
-          error: _chunk7L65NNWPcjs.stringifyError.call(void 0, err)
-        });
-      }
-    });
-    ws.addEventListener("close", (ev) => {
-      try {
-        this.#handleOnClose(ev);
-      } catch (err) {
-        _chunkZTH3KYFHcjs.logger.call(void 0, ).error({
-          msg: "error in websocket close handler",
-          error: _chunk7L65NNWPcjs.stringifyError.call(void 0, err)
-        });
-      }
-    });
-    ws.addEventListener("error", (_ev) => {
-      try {
-        this.#handleOnError();
-      } catch (err) {
-        _chunkZTH3KYFHcjs.logger.call(void 0, ).error({
-          msg: "error in websocket error handler",
-          error: _chunk7L65NNWPcjs.stringifyError.call(void 0, err)
-        });
-      }
-    });
-  }
-  async #connectSse() {
-    const EventSource = await importEventSource();
-    const { actorId } = await queryActor(
-      void 0,
-      this.#actorQuery,
-      this.#driver
-    );
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({ msg: "found actor for sse connection", actorId });
-    _invariant2.default.call(void 0, actorId, "Missing actor ID");
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).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": _chunk7L65NNWPcjs.httpUserAgent.call(void 0, ),
-              [_chunkHHFKKVLRcjs.HEADER_ENCODING]: this.#encoding,
-              ...this.#params !== void 0 ? {
-                [_chunkHHFKKVLRcjs.HEADER_CONN_PARAMS]: JSON.stringify(
-                  this.#params
-                )
-              } : {},
-              ...isReconnection ? {
-                [_chunkHHFKKVLRcjs.HEADER_CONN_ID]: this.#connectionId,
-                [_chunkHHFKKVLRcjs.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() {
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({
-      msg: "socket open",
-      messageQueueLength: this.#messageQueue.length,
-      connectionId: this.#connectionId
-    });
-    if (this.#onOpenPromise) {
-      this.#onOpenPromise.resolve(void 0);
-    } else {
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).warn({ msg: "#onOpenPromise is undefined" });
-    }
-    for (const eventName of this.#eventSubscriptions.keys()) {
-      this.#sendSubscription(eventName, true);
-    }
-    const queue = this.#messageQueue;
-    this.#messageQueue = [];
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).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) {
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).trace({
-      msg: "received message",
-      dataType: typeof data,
-      isBlob: data instanceof Blob,
-      isArrayBuffer: data instanceof ArrayBuffer
-    });
-    const response = await this.#parseMessage(data);
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).trace(
-      _chunk7L65NNWPcjs.getEnvUniversal.call(void 0, "_RIVETKIT_LOG_MESSAGE") ? {
-        msg: "parsed message",
-        message: _chunkHHFKKVLRcjs.jsonStringifyCompat.call(void 0, 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;
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).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));
-        _chunkZTH3KYFHcjs.logger.call(void 0, ).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 {
-        _chunkZTH3KYFHcjs.logger.call(void 0, ).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;
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).trace({
-        msg: "received action response",
-        actionId
-      });
-      const inFlight = this.#takeActionInFlight(Number(actionId));
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).trace({
-        msg: "resolving action promise",
-        actionId,
-        actionName: inFlight == null ? void 0 : inFlight.name
-      });
-      inFlight.resolve(response.body.val);
-    } else if (response.body.tag === "Event") {
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).trace({
-        msg: "received event",
-        name: response.body.val.name
-      });
-      this.#dispatchEvent(response.body.val);
-    } else {
-      _chunk7L65NNWPcjs.assertUnreachable.call(void 0, response.body);
-    }
-  }
-  /** Called by the onclose event from drivers. */
-  #handleOnClose(event) {
-    const closeEvent = event;
-    const wasClean = closeEvent.wasClean;
-    if (this.#onOpenPromise) {
-      this.#onOpenPromise.reject(
-        new Error(
-          `websocket closed with code ${closeEvent.code}: ${closeEvent.reason}`
-        )
-      );
-    }
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).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) {
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).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) {
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).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;
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).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) {
-        _chunkZTH3KYFHcjs.logger.call(void 0, ).error({
-          msg: "error in connection error handler",
-          error: _chunk7L65NNWPcjs.stringifyError.call(void 0, 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) {
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({ msg: "no transport, queueing message" });
-      queueMessage = true;
-    } else if ("websocket" in this.#transport) {
-      const readyState = this.#transport.websocket.readyState;
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).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 = _chunkHHFKKVLRcjs.serializeWithEncoding.call(void 0, 
-            this.#encoding,
-            message,
-            _chunkVFB23BYZcjs.TO_SERVER_VERSIONED
-          );
-          this.#transport.websocket.send(messageSerialized);
-          _chunkZTH3KYFHcjs.logger.call(void 0, ).trace({
-            msg: "sent websocket message",
-            len: messageLength(messageSerialized)
-          });
-        } catch (error) {
-          _chunkZTH3KYFHcjs.logger.call(void 0, ).warn({
-            msg: "failed to send message, added to queue",
-            error,
-            connectionId: this.#connectionId
-          });
-          queueMessage = true;
-        }
-      } else {
-        _chunkZTH3KYFHcjs.logger.call(void 0, ).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 {
-      _chunk7L65NNWPcjs.assertUnreachable.call(void 0, this.#transport);
-    }
-    if (!(opts == null ? void 0 : opts.ephemeral) && queueMessage) {
-      this.#messageQueue.push(message);
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).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."
-        );
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).trace(
-        _chunk7L65NNWPcjs.getEnvUniversal.call(void 0, "_RIVETKIT_LOG_MESSAGE") ? {
-          msg: "sent http message",
-          message: `${_chunkHHFKKVLRcjs.jsonStringifyCompat.call(void 0, message).substring(0, 100)}...`
-        } : { msg: "sent http message" }
-      );
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({
-        msg: "sending http message",
-        actorId: this.#actorId,
-        connectionId: this.#connectionId
-      });
-      await sendHttpRequest({
-        url: "http://actor/connections/message",
-        method: "POST",
-        headers: {
-          [_chunkHHFKKVLRcjs.HEADER_ENCODING]: this.#encoding,
-          [_chunkHHFKKVLRcjs.HEADER_CONN_ID]: this.#connectionId,
-          [_chunkHHFKKVLRcjs.HEADER_CONN_TOKEN]: this.#connectionToken
-        },
-        body: message,
-        encoding: this.#encoding,
-        skipParseResponse: true,
-        customFetch: this.#driver.sendRequest.bind(
-          this.#driver,
-          this.#actorId
-        ),
-        requestVersionedDataHandler: _chunkVFB23BYZcjs.TO_SERVER_VERSIONED,
-        responseVersionedDataHandler: _chunkVFB23BYZcjs.TO_CLIENT_VERSIONED
-      });
-    } catch (error) {
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).warn({
-        msg: "failed to send message, added to queue",
-        error
-      });
-      if (!(opts == null ? void 0 : opts.ephemeral)) {
-        this.#messageQueue.unshift(message);
-      }
-    }
-  }
-  async #parseMessage(data) {
-    _invariant2.default.call(void 0, this.#transport, "transport must be defined");
-    if (_chunkHHFKKVLRcjs.encodingIsBinary.call(void 0, 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 _chunkVFB23BYZcjs.inputDataToBuffer.call(void 0, data);
-    return _chunkHHFKKVLRcjs.deserializeWithEncoding.call(void 0, 
-      this.#encoding,
-      buffer,
-      _chunkVFB23BYZcjs.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) {
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).warn({ msg: "connection already disconnected" });
-      return;
-    }
-    this.#disposed = true;
-    _chunkZTH3KYFHcjs.logger.call(void 0, ).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) {
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).debug("closing ws");
-      const ws = this.#transport.websocket;
-      if (ws.readyState === 2 || ws.readyState === 3) {
-        _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({ msg: "ws already closed or closing" });
-      } else {
-        const { promise, resolve } = _chunk7L65NNWPcjs.promiseWithResolvers.call(void 0, );
-        ws.addEventListener("close", () => {
-          _chunkZTH3KYFHcjs.logger.call(void 0, ).debug({ msg: "ws closed" });
-          resolve(void 0);
-        });
-        ws.close(1e3, "Normal closure");
-        await promise;
-      }
-    } else if ("sse" in this.#transport) {
-      _chunkZTH3KYFHcjs.logger.call(void 0, ).debug("closing sse");
-      if (this.#connectionId && this.#connectionToken) {
-        try {
-          await sendHttpRequest({
-            url: "http://actor/connections/close",
-            method: "POST",
-            headers: {
-              [_chunkHHFKKVLRcjs.HEADER_CONN_ID]: this.#connectionId,
-              [_chunkHHFKKVLRcjs.HEADER_CONN_TOKEN]: this.#connectionToken
-            },
-            encoding: this.#encoding,
-            skipParseResponse: true,
-            customFetch: this.#driver.sendRequest.bind(
-              this.#driver,
-              this.#actorId
-            ),
-            requestVersionedDataHandler: _chunkVFB23BYZcjs.TO_SERVER_VERSIONED,
-            responseVersionedDataHandler: _chunkVFB23BYZcjs.TO_CLIENT_VERSIONED
-          });
-        } catch (error) {
-          _chunkZTH3KYFHcjs.logger.call(void 0, ).warn({
-            msg: "failed to send close request",
-            error
-          });
-        }
-      }
-      this.#transport.sse.close();
-    } else {
-      _chunk7L65NNWPcjs.assertUnreachable.call(void 0, 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
-
-
-
-// src/remote-manager-driver/log.ts
-function logger2() {
-  return _chunk7L65NNWPcjs.getLogger.call(void 0, "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 _nullishCoalesce(config.endpoint, () => ( "http://127.0.0.1:6420"));
-}
-async function apiCall(config, method, path, body) {
-  const endpoint = getEndpoint(config);
-  const url = _chunk7L65NNWPcjs.combineUrlPath.call(void 0, 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 = _chunk7L65NNWPcjs.combineUrlPath.call(void 0, 
-    endpoint,
-    `/gateway/${actorId}${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);
-  }
-  if (runConfig.token) {
-    headers.set(_chunkHHFKKVLRcjs.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 _chunkZTH3KYFHcjs.importWebSocket.call(void 0, );
-  const endpoint = getEndpoint(runConfig);
-  const guardUrl = _chunk7L65NNWPcjs.combineUrlPath.call(void 0, endpoint, `/gateway/${actorId}${path}`);
-  logger2().debug({
-    msg: "opening websocket to actor via guard",
-    actorId,
-    path,
-    guardUrl
-  });
-  const ws = new WebSocket2(
-    guardUrl,
-    buildWebSocketProtocols(runConfig, encoding, params, connId, connToken)
-  );
-  ws.binaryType = "arraybuffer";
-  logger2().debug({ msg: "websocket connection opened", actorId });
-  return ws;
-}
-function buildWebSocketProtocols(runConfig, encoding, params, connId, connToken) {
-  const protocols = [];
-  protocols.push(_chunkHHFKKVLRcjs.WS_PROTOCOL_STANDARD);
-  protocols.push(`${_chunkHHFKKVLRcjs.WS_PROTOCOL_ENCODING}${encoding}`);
-  if (runConfig.token) {
-    protocols.push(`${_chunkHHFKKVLRcjs.WS_PROTOCOL_TOKEN}${runConfig.token}`);
-  }
-  if (params) {
-    protocols.push(
-      `${_chunkHHFKKVLRcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
-    );
-  }
-  if (connId) {
-    protocols.push(`${_chunkHHFKKVLRcjs.WS_PROTOCOL_CONN_ID}${connId}`);
-  }
-  if (connToken) {
-    protocols.push(`${_chunkHHFKKVLRcjs.WS_PROTOCOL_CONN_TOKEN}${connToken}`);
-  }
-  return protocols;
-}
-
-// src/remote-manager-driver/api-endpoints.ts
-async function getActor(config, _, actorId) {
-  return apiCall(
-    config,
-    "GET",
-    `/actors?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)}`
-  );
-}
-async function getMetadata(config) {
-  return apiCall(config, "GET", `/metadata`);
-}
-async function getDatacenters(config) {
-  return apiCall(config, "GET", `/datacenters`);
-}
-async function updateRunnerConfig(config, runnerName, request) {
-  return apiCall(
-    config,
-    "PUT",
-    `/runner-configs/${runnerName}`,
-    request
-  );
-}
-
-// src/remote-manager-driver/ws-proxy.ts
-async function createWebSocketProxy(c, targetUrl, protocols) {
-  const WebSocket2 = await _chunkZTH3KYFHcjs.importWebSocket.call(void 0, );
-  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: _chunk7L65NNWPcjs.stringifyError.call(void 0, 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 metadataCheckCache = /* @__PURE__ */ new Map();
-var RemoteManagerDriver = class {
-  #config;
-  #metadataPromise;
-  constructor(runConfig) {
-    if (_chunk7L65NNWPcjs.getEnvUniversal.call(void 0, "NEXT_PHASE") === "phase-production-build") {
-      logger2().info(
-        "detected next.js build phase, disabling health check"
-      );
-      runConfig.disableHealthCheck = true;
-    }
-    this.#config = runConfig;
-    if (!runConfig.disableHealthCheck) {
-      this.#metadataPromise = this.#performMetadataCheck(runConfig);
-      this.#metadataPromise.catch((error) => {
-        logger2().error({
-          msg: "metadata check failed",
-          error: error instanceof Error ? error.message : String(error)
-        });
-      });
-    }
-  }
-  async #performMetadataCheck(config) {
-    const endpoint = getEndpoint(config);
-    const existingPromise = metadataCheckCache.get(endpoint);
-    if (existingPromise) {
-      return existingPromise;
-    }
-    const metadataCheckPromise = (async () => {
-      try {
-        const metadataData = await getMetadata(config);
-        if (metadataData.clientEndpoint) {
-          logger2().info({
-            msg: "received new client endpoint from metadata",
-            endpoint: metadataData.clientEndpoint
-          });
-          this.#config.endpoint = metadataData.clientEndpoint;
-        }
-        logger2().info({
-          msg: "connected to rivetkit manager",
-          runtime: metadataData.runtime,
-          version: metadataData.version,
-          runner: metadataData.runner
-        });
-      } catch (error) {
-        logger2().error({
-          msg: "health check failed, validate the Rivet endpoint is configured correctly",
-          endpoint,
-          error: _chunk7L65NNWPcjs.stringifyError.call(void 0, error)
-        });
-      }
-    })();
-    metadataCheckCache.set(endpoint, metadataCheckPromise);
-    return metadataCheckPromise;
-  }
-  async getForId({
-    c,
-    name,
-    actorId
-  }) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    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;
-    _invariant2.default.call(void 0, keyRaw, `actor ${actorId} should have key`);
-    const key = deserializeActorKey(keyRaw);
-    return {
-      actorId,
-      name,
-      key
-    };
-  }
-  async getWithKey({
-    c,
-    name,
-    key
-  }) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    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) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    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, {
-      datacenter: region,
-      name,
-      key: serializeActorKey(key),
-      runner_name_selector: this.#config.runnerName,
-      input: actorInput ? _chunkHHFKKVLRcjs.uint8ArrayToBase64.call(void 0, cbor6.encode(actorInput)) : 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,
-    region
-  }) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    logger2().info({ msg: "creating actor via engine api", name, key });
-    const result = await createActor(this.#config, {
-      datacenter: region,
-      name,
-      runner_name_selector: this.#config.runnerName,
-      key: serializeActorKey(key),
-      input: input ? _chunkHHFKKVLRcjs.uint8ArrayToBase64.call(void 0, cbor6.encode(input)) : void 0,
-      crash_policy: "sleep"
-    });
-    const actorId = result.actor.actor_id;
-    logger2().info({ msg: "actor created", actorId, name, key });
-    return {
-      actorId,
-      name,
-      key
-    };
-  }
-  async destroyActor(actorId) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    logger2().info({ msg: "destroying actor via engine api", actorId });
-    await destroyActor(this.#config, actorId);
-    logger2().info({ msg: "actor destroyed", actorId });
-  }
-  async sendRequest(actorId, actorRequest) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    return await sendHttpRequestToActor(
-      this.#config,
-      actorId,
-      actorRequest
-    );
-  }
-  async openWebSocket(path, actorId, encoding, params, connId, connToken) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    return await openWebSocketToActor(
-      this.#config,
-      path,
-      actorId,
-      encoding,
-      params,
-      connId,
-      connToken
-    );
-  }
-  async proxyRequest(_c, actorRequest, actorId) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    return await sendHttpRequestToActor(
-      this.#config,
-      actorId,
-      actorRequest
-    );
-  }
-  async proxyWebSocket(c, path, actorId, encoding, params, connId, connToken) {
-    var _a, _b;
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    const upgradeWebSocket = (_b = (_a = this.#config).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
-    _invariant2.default.call(void 0, upgradeWebSocket, "missing getUpgradeWebSocket");
-    const endpoint = getEndpoint(this.#config);
-    const guardUrl = _chunk7L65NNWPcjs.combineUrlPath.call(void 0, 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,
-      encoding,
-      params,
-      connId,
-      connToken
-    );
-    const args = await createWebSocketProxy(c, wsGuardUrl, protocols);
-    return await upgradeWebSocket(() => args)(c, _chunk7L65NNWPcjs.noopNext.call(void 0, ));
-  }
-  displayInformation() {
-    return { name: "Remote", properties: {} };
-  }
-  getOrCreateInspectorAccessToken() {
-    return _chunkHHFKKVLRcjs.generateRandomString.call(void 0, );
-  }
-};
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.createActorInspectorRouter = createActorInspectorRouter; exports.serializeActorKey = serializeActorKey; exports.deserializeActorKey = deserializeActorKey; exports.PERSIST_SYMBOL = PERSIST_SYMBOL; exports.generateConnId = generateConnId; exports.generateConnToken = generateConnToken; exports.generateConnRequestId = generateConnRequestId; exports.ActorDefinition = ActorDefinition; exports.lookupInRegistry = lookupInRegistry; exports.ActorClientError = ActorClientError; exports.InternalError = InternalError2; exports.ManagerError = ManagerError; exports.MalformedResponseMessage = MalformedResponseMessage; exports.ActorError = ActorError; exports.getEndpoint = getEndpoint; exports.ActorConnRaw = ActorConnRaw; exports.ActorHandleRaw = ActorHandleRaw; exports.createClientWithDriver = createClientWithDriver; exports.getDatacenters = getDatacenters; exports.updateRunnerConfig = updateRunnerConfig; exports.RemoteManagerDriver = RemoteManagerDriver;
-//# sourceMappingURL=chunk-O44LFKSB.cjs.map