rivetkit 2.0.5 → 2.0.6

package/dist/tsup/chunk-UFWAK3X2.cjs

@@ -0,0 +1,3796 @@
+"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 _chunkDIAYNQTEcjs = require('./chunk-DIAYNQTE.cjs');
+
+
+
+var _chunkKG3C7MKRcjs = require('./chunk-KG3C7MKR.cjs');
+
+
+
+
+
+
+
+
+
+var _chunkNTCUGYSDcjs = require('./chunk-NTCUGYSD.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkTCUI5JFEcjs = require('./chunk-TCUI5JFE.cjs');
+
+
+
+
+var _chunkMRRT2CZDcjs = require('./chunk-MRRT2CZD.cjs');
+
+
+
+
+
+
+
+
+
+
+
+var _chunk5JBFVV4Ccjs = require('./chunk-5JBFVV4C.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk5QGQK44Lcjs = require('./chunk-5QGQK44L.cjs');
+
+// src/actor/connection.ts
+var _cborx = require('cbor-x'); var cbor = _interopRequireWildcard(_cborx); var cbor2 = _interopRequireWildcard(_cborx); var cbor5 = _interopRequireWildcard(_cborx); var cbor4 = _interopRequireWildcard(_cborx); var cbor3 = _interopRequireWildcard(_cborx); var cbor6 = _interopRequireWildcard(_cborx);
+function generateConnId() {
+  return crypto.randomUUID();
+}
+function generateConnToken() {
+  return _chunkTCUI5JFEcjs.generateSecureToken.call(void 0, 32);
+}
+var CONNECTION_DRIVER_WEBSOCKET = "webSocket";
+var CONNECTION_DRIVER_SSE = "sse";
+var CONNECTION_DRIVER_HTTP = "http";
+var CONNECTION_CHECK_LIVENESS_SYMBOL = Symbol("checkLiveness");
+var Conn = (_class = class {
+  __init() {this.subscriptions = /* @__PURE__ */ new Set()}
+  #stateEnabled;
+  // TODO: Remove this cyclical reference
+  #actor;
+  #status = "connected";
+  /**
+   * The proxied state that notifies of changes automatically.
+   *
+   * Any data that should be stored indefinitely should be held within this object.
+   */
+  
+  /**
+   * Driver used to manage realtime connection communication.
+   *
+   * @protected
+   */
+  #driver;
+  get params() {
+    return this.__persist.params;
+  }
+  get driver() {
+    return this.__persist.connDriver;
+  }
+  get _stateEnabled() {
+    return this.#stateEnabled;
+  }
+  /**
+   * Gets the current state of the connection.
+   *
+   * Throws an error if the state is not enabled.
+   */
+  get state() {
+    this.#validateStateEnabled();
+    if (!this.__persist.state) throw new Error("state should exists");
+    return this.__persist.state;
+  }
+  /**
+   * Sets the state of the connection.
+   *
+   * Throws an error if the state is not enabled.
+   */
+  set state(value) {
+    this.#validateStateEnabled();
+    this.__persist.state = value;
+  }
+  /**
+   * Unique identifier for the connection.
+   */
+  get id() {
+    return this.__persist.connId;
+  }
+  /**
+   * Token used to authenticate this request.
+   */
+  get _token() {
+    return this.__persist.token;
+  }
+  /**
+   * Status of the connection.
+   */
+  get status() {
+    return this.#status;
+  }
+  /**
+   * Timestamp of the last time the connection was seen, i.e. the last time the connection was active and checked for liveness.
+   */
+  get lastSeen() {
+    return this.__persist.lastSeen;
+  }
+  /**
+   * Initializes a new instance of the Connection class.
+   *
+   * This should only be constructed by {@link Actor}.
+   *
+   * @protected
+   */
+  constructor(actor, persist, driver, stateEnabled) {;_class.prototype.__init.call(this);
+    this.#actor = actor;
+    this.__persist = persist;
+    this.#driver = driver;
+    this.#stateEnabled = stateEnabled;
+  }
+  #validateStateEnabled() {
+    if (!this.#stateEnabled) {
+      throw new (0, _chunk5QGQK44Lcjs.ConnStateNotEnabled)();
+    }
+  }
+  /**
+   * Sends a WebSocket message to the client.
+   *
+   * @param message - The message to send.
+   *
+   * @protected
+   */
+  _sendMessage(message) {
+    var _a, _b;
+    (_b = (_a = this.#driver).sendMessage) == null ? void 0 : _b.call(
+      _a,
+      this.#actor,
+      this,
+      this.__persist.connDriverState,
+      message
+    );
+  }
+  /**
+   * 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, _chunkTCUI5JFEcjs.CachedSerializer)(
+        {
+          body: {
+            tag: "Event",
+            val: {
+              name: eventName,
+              args: _chunk5JBFVV4Ccjs.bufferToArrayBuffer.call(void 0, cbor.encode(args))
+            }
+          }
+        },
+        _chunkNTCUGYSDcjs.TO_CLIENT_VERSIONED
+      )
+    );
+  }
+  /**
+   * Disconnects the client with an optional reason.
+   *
+   * @param reason - The reason for disconnection.
+   */
+  async disconnect(reason) {
+    this.#status = "reconnecting";
+    await this.#driver.disconnect(
+      this.#actor,
+      this,
+      this.__persist.connDriverState,
+      reason
+    );
+  }
+  /**
+   * This method checks the connection's liveness by querying the driver for its ready state.
+   * If the connection is not closed, it updates the last liveness timestamp and returns `true`.
+   * Otherwise, it returns `false`.
+   * @internal
+   */
+  [CONNECTION_CHECK_LIVENESS_SYMBOL]() {
+    const readyState = this.#driver.getConnectionReadyState(this.#actor, this);
+    const isConnectionClosed = readyState === 3 /* CLOSED */ || readyState === 2 /* CLOSING */ || readyState === void 0;
+    const newLastSeen = Date.now();
+    const newStatus = isConnectionClosed ? "reconnecting" : "connected";
+    this.#actor.rLog.debug({
+      msg: "liveness probe for connection",
+      connId: this.id,
+      actorId: this.#actor.id,
+      readyState,
+      status: this.#status,
+      newStatus,
+      lastSeen: this.__persist.lastSeen,
+      currentTs: newLastSeen
+    });
+    if (!isConnectionClosed) {
+      this.__persist.lastSeen = newLastSeen;
+    }
+    this.#status = newStatus;
+    return {
+      status: this.#status,
+      lastSeen: this.__persist.lastSeen
+    };
+  }
+}, _class);
+
+// 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: _chunkDIAYNQTEcjs.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 } = Promise.withResolvers();
+        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 } = Promise.withResolvers();
+        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 } = Promise.withResolvers();
+        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 = _chunkDIAYNQTEcjs.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) => _chunkDIAYNQTEcjs.ColumnsSchema.parse(def));
+    const foreignKeysList = await Promise.all(
+      tables.map(
+        (table) => db.execute(`PRAGMA foreign_key_list(${table.name})`)
+      )
+    );
+    const foreignKeys = foreignKeysList.map(
+      (def) => _chunkDIAYNQTEcjs.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);
+      }
+    }
+  );
+}
+var ActorInspector = (_class2 = class {
+  
+  __init2() {this.emitter = _nanoevents.createNanoEvents.call(void 0, )}
+  #lastRealtimeEvents = [];
+  get lastRealtimeEvents() {
+    return this.#lastRealtimeEvents;
+  }
+  constructor(accessors) {;_class2.prototype.__init2.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);
+      }
+    });
+  }
+}, _class2);
+
+// src/actor/context.ts
+var ActorContext = class {
+  #actor;
+  constructor(actor) {
+    this.#actor = actor;
+  }
+  /**
+   * Get the actor state
+   */
+  get state() {
+    return this.#actor.state;
+  }
+  /**
+   * Get the actor variables
+   */
+  get vars() {
+    return this.#actor.vars;
+  }
+  /**
+   * Broadcasts an event to all connected clients.
+   * @param name - The name of the event.
+   * @param args - The arguments to send with the event.
+   */
+  broadcast(name, ...args) {
+    this.#actor._broadcast(name, ...args);
+    return;
+  }
+  /**
+   * Gets the logger instance.
+   */
+  get log() {
+    return this.#actor.log;
+  }
+  /**
+   * Gets actor ID.
+   */
+  get actorId() {
+    return this.#actor.id;
+  }
+  /**
+   * Gets the actor name.
+   */
+  get name() {
+    return this.#actor.name;
+  }
+  /**
+   * Gets the actor key.
+   */
+  get key() {
+    return this.#actor.key;
+  }
+  /**
+   * Gets the region.
+   */
+  get region() {
+    return this.#actor.region;
+  }
+  /**
+   * Gets the scheduler.
+   */
+  get schedule() {
+    return this.#actor.schedule;
+  }
+  /**
+   * Gets the map of connections.
+   */
+  get conns() {
+    return this.#actor.conns;
+  }
+  /**
+   * Returns the client for the given registry.
+   */
+  client() {
+    return this.#actor.inlineClient;
+  }
+  /**
+   * Gets the database.
+   * @experimental
+   * @throws {DatabaseNotEnabled} If the database is not enabled.
+   */
+  get db() {
+    return this.#actor.db;
+  }
+  /**
+   * Forces the state to get saved.
+   *
+   * @param opts - Options for saving the state.
+   */
+  async saveState(opts) {
+    return this.#actor.saveState(opts);
+  }
+  /**
+   * Prevents the actor from sleeping until promise is complete.
+   */
+  waitUntil(promise) {
+    this.#actor._waitUntil(promise);
+  }
+  /**
+   * AbortSignal that fires when the actor is stopping.
+   */
+  get abortSignal() {
+    return this.#actor.abortSignal;
+  }
+  /**
+   * Forces the actor to sleep.
+   *
+   * Not supported on all drivers.
+   *
+   * @experimental
+   */
+  sleep() {
+    this.#actor._sleep();
+  }
+};
+
+// src/actor/keys.ts
+var EMPTY_KEY = "/";
+var KEY_SEPARATOR = "/";
+function serializeActorKey(key) {
+  if (key.length === 0) {
+    return EMPTY_KEY;
+  }
+  const escapedParts = key.map((part) => {
+    if (part === "") {
+      return "\\0";
+    }
+    let escaped = part.replace(/\\/g, "\\\\");
+    escaped = escaped.replace(/\//g, `\\${KEY_SEPARATOR}`);
+    return escaped;
+  });
+  return escapedParts.join(KEY_SEPARATOR);
+}
+function deserializeActorKey(keyString) {
+  if (keyString === void 0 || keyString === null || keyString === EMPTY_KEY) {
+    return [];
+  }
+  const parts = [];
+  let currentPart = "";
+  let escaping = false;
+  let isEmptyStringMarker = false;
+  for (let i = 0; i < keyString.length; i++) {
+    const char = keyString[i];
+    if (escaping) {
+      if (char === "0") {
+        isEmptyStringMarker = true;
+      } else {
+        currentPart += char;
+      }
+      escaping = false;
+    } else if (char === "\\") {
+      escaping = true;
+    } else if (char === KEY_SEPARATOR) {
+      if (isEmptyStringMarker) {
+        parts.push("");
+        isEmptyStringMarker = false;
+      } else {
+        parts.push(currentPart);
+      }
+      currentPart = "";
+    } else {
+      currentPart += char;
+    }
+  }
+  if (escaping) {
+    parts.push(currentPart + "\\");
+  } else if (isEmptyStringMarker) {
+    parts.push("");
+  } else if (currentPart !== "" || parts.length > 0) {
+    parts.push(currentPart);
+  }
+  return parts;
+}
+
+// src/actor/schedule.ts
+var Schedule = class {
+  #actor;
+  constructor(actor) {
+    this.#actor = actor;
+  }
+  async after(duration, fn, ...args) {
+    await this.#actor.scheduleEvent(Date.now() + duration, fn, args);
+  }
+  async at(timestamp, fn, ...args) {
+    await this.#actor.scheduleEvent(timestamp, fn, args);
+  }
+};
+
+// src/actor/instance.ts
+var ActorInstance = class {
+  // Shared actor context for this instance
+  
+  /** Actor log, intended for the user to call */
+  #log;
+  /** Runtime log, intended for internal actor logs */
+  #rLog;
+  #sleepCalled = false;
+  #stopCalled = false;
+  get isStopping() {
+    return this.#stopCalled || this.#sleepCalled;
+  }
+  #persistChanged = false;
+  #isInOnStateChange = false;
+  /**
+   * The proxied state that notifies of changes automatically.
+   *
+   * Any data that should be stored indefinitely should be held within this object.
+   */
+  #persist;
+  /** Raw state without the proxy wrapper */
+  #persistRaw;
+  #persistWriteQueue = new (0, _chunk5JBFVV4Ccjs.SinglePromiseQueue)();
+  #alarmWriteQueue = new (0, _chunk5JBFVV4Ccjs.SinglePromiseQueue)();
+  #lastSaveTime = 0;
+  #pendingSaveTimeout;
+  #vars;
+  #backgroundPromises = [];
+  #abortController = new AbortController();
+  #config;
+  #connectionDrivers;
+  #actorDriver;
+  #inlineClient;
+  #actorId;
+  #name;
+  #key;
+  #region;
+  #ready = false;
+  #connections = /* @__PURE__ */ new Map();
+  #subscriptionIndex = /* @__PURE__ */ new Map();
+  #checkConnLivenessInterval;
+  #sleepTimeout;
+  // Track active raw requests so sleep logic can account for them
+  #activeRawFetchCount = 0;
+  #activeRawWebSockets = /* @__PURE__ */ new Set();
+  #schedule;
+  #db;
+  #inspector = new ActorInspector(() => {
+    return {
+      isDbEnabled: async () => {
+        return this.#db !== void 0;
+      },
+      getDb: async () => {
+        return this.db;
+      },
+      isStateEnabled: async () => {
+        return this.stateEnabled;
+      },
+      getState: async () => {
+        this.#validateStateEnabled();
+        return this.#persistRaw.state;
+      },
+      getRpcs: async () => {
+        return Object.keys(this.#config.actions);
+      },
+      getConnections: async () => {
+        return Array.from(this.#connections.entries()).map(([id, conn]) => ({
+          id,
+          stateEnabled: conn._stateEnabled,
+          params: conn.params,
+          state: conn._stateEnabled ? conn.state : void 0
+        }));
+      },
+      setState: async (state) => {
+        this.#validateStateEnabled();
+        this.#persist.state = { ...state };
+        await this.saveState({ immediate: true });
+      }
+    };
+  });
+  get id() {
+    return this.#actorId;
+  }
+  get inlineClient() {
+    return this.#inlineClient;
+  }
+  get inspector() {
+    return this.#inspector;
+  }
+  get #sleepingSupported() {
+    return this.#actorDriver.sleep !== void 0;
+  }
+  /**
+   * This constructor should never be used directly.
+   *
+   * Constructed in {@link ActorInstance.start}.
+   *
+   * @private
+   */
+  constructor(config) {
+    this.#config = config;
+    this.actorContext = new ActorContext(this);
+  }
+  async start(connectionDrivers, actorDriver, inlineClient, actorId, name, key, region) {
+    var _a, _b;
+    const logParams = {
+      actor: name,
+      key: serializeActorKey(key),
+      actorId
+    };
+    this.#log = _chunkMRRT2CZDcjs.getBaseLogger.call(void 0, ).child(
+      Object.assign(_chunkMRRT2CZDcjs.getIncludeTarget.call(void 0, ) ? { target: "actor" } : {}, logParams)
+    );
+    this.#rLog = _chunkMRRT2CZDcjs.getBaseLogger.call(void 0, ).child(
+      Object.assign(
+        _chunkMRRT2CZDcjs.getIncludeTarget.call(void 0, ) ? { target: "actor-runtime" } : {},
+        logParams
+      )
+    );
+    this.#connectionDrivers = connectionDrivers;
+    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 _chunkTCUI5JFEcjs.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 ((_b = (_a = this.#config.db).onMigrate) == null ? void 0 : _b.call(_a, client));
+      this.#rLog.info({ msg: "database migration complete" });
+      this.#db = client;
+    }
+    if (this.#persist.scheduledEvents.length > 0) {
+      await this.#queueSetAlarm(this.#persist.scheduledEvents[0].timestamp);
+    }
+    this.#rLog.info({ msg: "actor ready" });
+    this.#ready = true;
+    this.#resetSleepTimer();
+    this.#checkConnLivenessInterval = setInterval(
+      this.#checkConnectionsLiveness.bind(this),
+      this.#config.options.connectionLivenessInterval
+    );
+    this.#checkConnectionsLiveness();
+  }
+  async #scheduleEventInner(newEvent) {
+    this.actorContext.log.info({ msg: "scheduling event", ...newEvent });
+    const insertIndex = this.#persist.scheduledEvents.findIndex(
+      (x) => x.timestamp > newEvent.timestamp
+    );
+    if (insertIndex === -1) {
+      this.#persist.scheduledEvents.push(newEvent);
+    } else {
+      this.#persist.scheduledEvents.splice(insertIndex, 0, newEvent);
+    }
+    if (insertIndex === 0 || this.#persist.scheduledEvents.length === 1) {
+      this.actorContext.log.info({
+        msg: "setting alarm",
+        timestamp: newEvent.timestamp,
+        eventCount: this.#persist.scheduledEvents.length
+      });
+      await this.#queueSetAlarm(newEvent.timestamp);
+    }
+  }
+  async _onAlarm() {
+    const now = Date.now();
+    this.actorContext.log.debug({
+      msg: "alarm triggered",
+      now,
+      events: this.#persist.scheduledEvents.length
+    });
+    this.#resetSleepTimer();
+    const runIndex = this.#persist.scheduledEvents.findIndex(
+      (x) => x.timestamp <= now
+    );
+    if (runIndex === -1) {
+      this.#rLog.warn({ msg: "no events are due yet, time may have broken" });
+      if (this.#persist.scheduledEvents.length > 0) {
+        const nextTs = this.#persist.scheduledEvents[0].timestamp;
+        this.actorContext.log.warn({
+          msg: "alarm fired early, rescheduling for next event",
+          now,
+          nextTs,
+          delta: nextTs - now
+        });
+        await this.#queueSetAlarm(nextTs);
+      }
+      this.actorContext.log.debug({ msg: "no events to run", now });
+      return;
+    }
+    const scheduleEvents = this.#persist.scheduledEvents.splice(
+      0,
+      runIndex + 1
+    );
+    this.actorContext.log.debug({
+      msg: "running events",
+      count: scheduleEvents.length
+    });
+    if (this.#persist.scheduledEvents.length > 0) {
+      const nextTs = this.#persist.scheduledEvents[0].timestamp;
+      this.actorContext.log.info({
+        msg: "setting next alarm",
+        nextTs,
+        remainingEvents: this.#persist.scheduledEvents.length
+      });
+      await this.#queueSetAlarm(nextTs);
+    }
+    for (const event of scheduleEvents) {
+      try {
+        this.actorContext.log.info({
+          msg: "running action for event",
+          event: event.eventId,
+          timestamp: event.timestamp,
+          action: event.kind.generic.actionName
+        });
+        const fn = this.#config.actions[event.kind.generic.actionName];
+        if (!fn)
+          throw new Error(
+            `Missing action for alarm ${event.kind.generic.actionName}`
+          );
+        if (typeof fn !== "function")
+          throw new Error(
+            `Alarm function lookup for ${event.kind.generic.actionName} returned ${typeof fn}`
+          );
+        try {
+          const args = event.kind.generic.args ? cbor2.decode(new Uint8Array(event.kind.generic.args)) : [];
+          await fn.call(void 0, this.actorContext, ...args);
+        } catch (error) {
+          this.actorContext.log.error({
+            msg: "error while running event",
+            error: _chunk5JBFVV4Ccjs.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: _chunk5JBFVV4Ccjs.stringifyError.call(void 0, error),
+          ...event
+        });
+      }
+    }
+  }
+  async scheduleEvent(timestamp, action, args) {
+    return this.#scheduleEventInner({
+      eventId: crypto.randomUUID(),
+      timestamp,
+      kind: {
+        generic: {
+          actionName: action,
+          args: _chunk5JBFVV4Ccjs.bufferToArrayBuffer.call(void 0, cbor2.encode(args))
+        }
+      }
+    });
+  }
+  get stateEnabled() {
+    return "createState" in this.#config || "state" in this.#config;
+  }
+  #validateStateEnabled() {
+    if (!this.stateEnabled) {
+      throw new (0, _chunk5QGQK44Lcjs.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, _chunk5QGQK44Lcjs.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,
+            _chunkNTCUGYSDcjs.PERSISTED_ACTOR_VERSIONED.serializeWithEmbeddedVersion(bareData)
+          );
+          this.#rLog.debug({ msg: "persist saved" });
+        });
+        await finished;
+      }
+      (_a = this.#onPersistSavedPromise) == null ? void 0 : _a.resolve();
+    } catch (error) {
+      (_b = this.#onPersistSavedPromise) == null ? void 0 : _b.reject(error);
+      throw error;
+    }
+  }
+  async #queueSetAlarm(timestamp) {
+    await this.#alarmWriteQueue.enqueue(async () => {
+      await this.#actorDriver.setAlarm(this, timestamp);
+    });
+  }
+  /**
+   * Creates proxy for `#persist` that handles automatically flagging when state needs to be updated.
+   */
+  #setPersist(target) {
+    this.#persistRaw = target;
+    if (target === null || typeof target !== "object") {
+      let invalidPath = "";
+      if (!_chunk5JBFVV4Ccjs.isCborSerializable.call(void 0, 
+        target,
+        (path) => {
+          invalidPath = path;
+        },
+        ""
+      )) {
+        throw new (0, _chunk5QGQK44Lcjs.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) => {
+        if (path !== "state" && !path.startsWith("state.")) {
+          return;
+        }
+        let invalidPath = "";
+        if (!_chunk5JBFVV4Ccjs.isCborSerializable.call(void 0, 
+          value,
+          (invalidPathPart) => {
+            invalidPath = invalidPathPart;
+          },
+          ""
+        )) {
+          throw new (0, _chunk5QGQK44Lcjs.InvalidStateType)({
+            path: path + (invalidPath ? `.${invalidPath}` : "")
+          });
+        }
+        this.#persistChanged = true;
+        this.inspector.emitter.emit("stateUpdated", this.#persist.state);
+        if (this.#config.onStateChange && this.#ready && !this.#isInOnStateChange) {
+          try {
+            this.#isInOnStateChange = true;
+            this.#config.onStateChange(
+              this.actorContext,
+              this.#persistRaw.state
+            );
+          } catch (error) {
+            this.#rLog.error({
+              msg: "error in `_onStateChange`",
+              error: _chunk5JBFVV4Ccjs.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 = _chunkNTCUGYSDcjs.PERSISTED_ACTOR_VERSIONED.deserializeWithEmbeddedVersion(
+      persistDataBuffer
+    );
+    const persistData = this.#convertFromBarePersisted(bareData);
+    if (persistData.hasInitiated) {
+      this.#rLog.info({
+        msg: "actor restoring",
+        connections: persistData.connections.length
+      });
+      this.#setPersist(persistData);
+      for (const connPersist of this.#persist.connections) {
+        const driver = this.__getConnDriver(connPersist.connDriver);
+        const conn = new Conn(
+          this,
+          connPersist,
+          driver,
+          this.#connStateEnabled
+        );
+        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,
+        _chunkNTCUGYSDcjs.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);
+  }
+  /**
+   * Removes a connection and cleans up its resources.
+   */
+  __removeConn(conn) {
+    if (!conn) {
+      this.#rLog.warn({ msg: "`conn` does not exist" });
+      return;
+    }
+    const connIdx = this.#persist.connections.findIndex(
+      (c) => c.connId === conn.id
+    );
+    if (connIdx !== -1) {
+      this.#persist.connections.splice(connIdx, 1);
+      this.saveState({ immediate: true, allowStoppingState: true });
+    } else {
+      this.#rLog.warn({
+        msg: "could not find persisted connection to remove",
+        connId: conn.id
+      });
+    }
+    this.#connections.delete(conn.id);
+    for (const eventName of [...conn.subscriptions.values()]) {
+      this.#removeSubscription(eventName, conn, true);
+    }
+    this.inspector.emitter.emit("connectionUpdated");
+    if (this.#config.onDisconnect) {
+      try {
+        const result = this.#config.onDisconnect(this.actorContext, conn);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            this.#rLog.error({
+              msg: "error in `onDisconnect`",
+              error: _chunk5JBFVV4Ccjs.stringifyError.call(void 0, error)
+            });
+          });
+        }
+      } catch (error) {
+        this.#rLog.error({
+          msg: "error in `onDisconnect`",
+          error: _chunk5JBFVV4Ccjs.stringifyError.call(void 0, error)
+        });
+      }
+    }
+    this.#resetSleepTimer();
+  }
+  async prepareConn(params, request) {
+    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 _chunkTCUI5JFEcjs.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'"
+        );
+      }
+    }
+    return connState;
+  }
+  __getConnDriver(driverId) {
+    const driver = this.#connectionDrivers[driverId];
+    if (!driver) throw new Error(`No connection driver: ${driverId}`);
+    return driver;
+  }
+  /**
+   * Called after establishing a connection handshake.
+   */
+  async createConn(connectionId, connectionToken, params, state, driverId, driverState, authData) {
+    this.#assertReady();
+    if (this.#connections.has(connectionId)) {
+      throw new Error(`Connection already exists: ${connectionId}`);
+    }
+    const driver = this.__getConnDriver(driverId);
+    const persist = {
+      connId: connectionId,
+      token: connectionToken,
+      connDriver: driverId,
+      connDriverState: driverState,
+      params,
+      state,
+      authData,
+      lastSeen: Date.now(),
+      subscriptions: []
+    };
+    const conn = new Conn(
+      this,
+      persist,
+      driver,
+      this.#connStateEnabled
+    );
+    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) {
+          _chunkTCUI5JFEcjs.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: _chunk5JBFVV4Ccjs.stringifyError.call(void 0, error)
+        });
+        conn == null ? void 0 : conn.disconnect("`onConnect` failed");
+      }
+    }
+    this.inspector.emitter.emit("connectionUpdated");
+    conn._sendMessage(
+      new (0, _chunkTCUI5JFEcjs.CachedSerializer)(
+        {
+          body: {
+            tag: "Init",
+            val: {
+              actorId: this.id,
+              connectionId: conn.id,
+              connectionToken: conn._token
+            }
+          }
+        },
+        _chunkNTCUGYSDcjs.TO_CLIENT_VERSIONED
+      )
+    );
+    return conn;
+  }
+  // MARK: Messages
+  async processMessage(message, conn) {
+    await _chunkNTCUGYSDcjs.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, _chunk5QGQK44Lcjs.InternalError)("Actor not ready");
+    if (!allowStoppingState && this.#sleepCalled)
+      throw new (0, _chunk5QGQK44Lcjs.InternalError)("Actor is going to sleep");
+    if (!allowStoppingState && this.#stopCalled)
+      throw new (0, _chunk5QGQK44Lcjs.InternalError)("Actor is stopping");
+  }
+  /**
+   * Check the liveness of all connections.
+   * Sets up a recurring check based on the configured interval.
+   */
+  #checkConnectionsLiveness() {
+    this.#rLog.debug({ msg: "checking connections liveness" });
+    for (const conn of this.#connections.values()) {
+      const liveness = conn[CONNECTION_CHECK_LIVENESS_SYMBOL]();
+      if (liveness.status === "connected") {
+        this.#rLog.debug({ msg: "connection is alive", connId: conn.id });
+      } else {
+        const lastSeen = liveness.lastSeen;
+        const sinceLastSeen = Date.now() - lastSeen;
+        if (sinceLastSeen < this.#config.options.connectionLivenessTimeout) {
+          this.#rLog.debug({
+            msg: "connection might be alive, will check later",
+            connId: conn.id,
+            lastSeen,
+            sinceLastSeen
+          });
+          continue;
+        }
+        this.#rLog.warn({
+          msg: "connection is dead, removing",
+          connId: conn.id,
+          lastSeen
+        });
+        this.__removeConn(conn);
+      }
+    }
+  }
+  /**
+   * Check if the actor is ready to handle requests.
+   */
+  isReady() {
+    return this.#ready;
+  }
+  /**
+   * Execute an action call from a client.
+   *
+   * This method handles:
+   * 1. Validating the action name
+   * 2. Executing the action function
+   * 3. Processing the result through onBeforeActionResponse (if configured)
+   * 4. Handling timeouts and errors
+   * 5. Saving state changes
+   *
+   * @param ctx The action context
+   * @param actionName The name of the action being called
+   * @param args The arguments passed to the action
+   * @returns The result of the action call
+   * @throws {ActionNotFound} If the action doesn't exist
+   * @throws {ActionTimedOut} If the action times out
+   * @internal
+   */
+  async executeAction(ctx, actionName, args) {
+    _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, _chunk5QGQK44Lcjs.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, _chunk5QGQK44Lcjs.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 _chunkTCUI5JFEcjs.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: _chunk5JBFVV4Ccjs.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 _chunkTCUI5JFEcjs.DeadlineError) {
+        throw new (0, _chunk5QGQK44Lcjs.ActionTimedOut)();
+      }
+      this.#rLog.error({
+        msg: "action error",
+        actionName,
+        error: _chunk5JBFVV4Ccjs.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, _chunk5QGQK44Lcjs.FetchHandlerNotDefined)();
+    }
+    this.#activeRawFetchCount++;
+    this.#resetSleepTimer();
+    try {
+      const response = await this.#config.onFetch(
+        this.actorContext,
+        request,
+        opts
+      );
+      if (!response) {
+        throw new (0, _chunk5QGQK44Lcjs.InvalidFetchResponse)();
+      }
+      return response;
+    } catch (error) {
+      this.#rLog.error({ msg: "onFetch error", error: _chunk5JBFVV4Ccjs.stringifyError.call(void 0, error) });
+      throw error;
+    } finally {
+      this.#activeRawFetchCount = Math.max(0, this.#activeRawFetchCount - 1);
+      this.#resetSleepTimer();
+      this.#savePersistThrottled();
+    }
+  }
+  /**
+   * Handles raw WebSocket connections to the actor.
+   */
+  async handleWebSocket(websocket, opts) {
+    this.#assertReady();
+    if (!this.#config.onWebSocket) {
+      throw new (0, _chunk5QGQK44Lcjs.InternalError)("onWebSocket handler not defined");
+    }
+    try {
+      const stateBeforeHandler = this.#persistChanged;
+      this.#activeRawWebSockets.add(websocket);
+      this.#resetSleepTimer();
+      const onSocketClosed = () => {
+        try {
+          websocket.removeEventListener("close", onSocketClosed);
+          websocket.removeEventListener("error", onSocketClosed);
+        } catch (e) {
+        }
+        this.#activeRawWebSockets.delete(websocket);
+        this.#resetSleepTimer();
+      };
+      try {
+        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: _chunk5JBFVV4Ccjs.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, _chunk5QGQK44Lcjs.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, _chunkTCUI5JFEcjs.CachedSerializer)(
+      {
+        body: {
+          tag: "Event",
+          val: {
+            name,
+            args: _chunk5JBFVV4Ccjs.bufferToArrayBuffer.call(void 0, cbor2.encode(args))
+          }
+        }
+      },
+      _chunkNTCUGYSDcjs.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: _chunk5JBFVV4Ccjs.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);
+    if (this.#persistChanged) {
+      if (opts.immediate) {
+        await this.#savePersistInner();
+      } else {
+        if (!this.#onPersistSavedPromise) {
+          this.#onPersistSavedPromise = Promise.withResolvers();
+        }
+        this.#savePersistThrottled();
+        await this.#onPersistSavedPromise.promise;
+      }
+    }
+  }
+  // MARK: Sleep
+  /**
+   * Reset timer from the last actor interaction that allows it to be put to sleep.
+   *
+   * This should be called any time a sleep-related event happens:
+   * - Connection opens (will clear timer)
+   * - Connection closes (will schedule timer if there are no open connections)
+   * - Alarm triggers (will reset timer)
+   *
+   * We don't need to call this on events like individual action calls, since there will always be a connection open for these.
+   **/
+  #resetSleepTimer() {
+    if (this.#config.options.noSleep || !this.#sleepingSupported) return;
+    const canSleep = this.#canSleep();
+    this.#rLog.debug({
+      msg: "resetting sleep timer",
+      canSleep,
+      existingTimeout: !!this.#sleepTimeout
+    });
+    if (this.#sleepTimeout) {
+      clearTimeout(this.#sleepTimeout);
+      this.#sleepTimeout = void 0;
+    }
+    if (this.#sleepCalled) return;
+    if (canSleep) {
+      this.#sleepTimeout = setTimeout(() => {
+        this._sleep().catch((error) => {
+          this.#rLog.error({
+            msg: "error during sleep",
+            error: _chunk5JBFVV4Ccjs.stringifyError.call(void 0, error)
+          });
+        });
+      }, this.#config.options.sleepTimeout);
+    }
+  }
+  /** If this actor can be put in a sleeping state. */
+  #canSleep() {
+    if (!this.#ready) return false;
+    for (const conn of this.#connections.values()) {
+      if (conn.status === "connected") return false;
+    }
+    if (this.#activeRawFetchCount > 0) return false;
+    if (this.#activeRawWebSockets.size > 0) return false;
+    return true;
+  }
+  /** Puts an actor to sleep. This should just start the sleep sequence, most shutdown logic should be in _stop (which is called by the ActorDriver when sleeping). */
+  async _sleep() {
+    var _a;
+    const sleep = (_a = this.#actorDriver.sleep) == null ? void 0 : _a.bind(
+      this.#actorDriver,
+      this.#actorId
+    );
+    _invariant2.default.call(void 0, this.#sleepingSupported, "sleeping not supported");
+    _invariant2.default.call(void 0, sleep, "no sleep on driver");
+    if (this.#sleepCalled) {
+      this.#rLog.warn({ msg: "already sleeping actor" });
+      return;
+    }
+    this.#sleepCalled = true;
+    this.#rLog.info({ msg: "actor sleeping" });
+    setImmediate(async () => {
+      await sleep();
+    });
+  }
+  // MARK: Stop
+  async _stop() {
+    if (this.#stopCalled) {
+      this.#rLog.warn({ msg: "already stopping actor" });
+      return;
+    }
+    this.#stopCalled = true;
+    this.#rLog.info({ msg: "actor stopping" });
+    try {
+      this.#abortController.abort();
+    } catch (e3) {
+    }
+    if (this.#config.onStop) {
+      try {
+        this.#rLog.debug({ msg: "calling onStop" });
+        const result = this.#config.onStop(this.actorContext);
+        if (result instanceof Promise) {
+          await _chunkTCUI5JFEcjs.deadline.call(void 0, result, this.#config.options.onStopTimeout);
+        }
+        this.#rLog.debug({ msg: "onStop completed" });
+      } catch (error) {
+        if (error instanceof _chunkTCUI5JFEcjs.DeadlineError) {
+          this.#rLog.error({ msg: "onStop timed out" });
+        } else {
+          this.#rLog.error({
+            msg: "error in onStop",
+            error: _chunk5JBFVV4Ccjs.stringifyError.call(void 0, error)
+          });
+        }
+      }
+    }
+    const promises = [];
+    for (const connection of this.#connections.values()) {
+      promises.push(connection.disconnect());
+    }
+    await this.#waitBackgroundPromises(this.#config.options.waitUntilTimeout);
+    if (this.#pendingSaveTimeout) clearTimeout(this.#pendingSaveTimeout);
+    if (this.#sleepTimeout) clearTimeout(this.#sleepTimeout);
+    if (this.#checkConnLivenessInterval)
+      clearInterval(this.#checkConnLivenessInterval);
+    await this.saveState({ immediate: true, allowStoppingState: true });
+    const res = Promise.race([
+      Promise.all(promises).then(() => false),
+      new Promise(
+        (res2) => globalThis.setTimeout(() => res2(true), 1500)
+      )
+    ]);
+    if (await res) {
+      this.#rLog.warn({
+        msg: "timed out waiting for connections to close, shutting down anyway"
+      });
+    }
+    if (this.#persistWriteQueue.runningDrainLoop)
+      await this.#persistWriteQueue.runningDrainLoop;
+    if (this.#alarmWriteQueue.runningDrainLoop)
+      await this.#alarmWriteQueue.runningDrainLoop;
+  }
+  /** Abort signal that fires when the actor is stopping. */
+  get abortSignal() {
+    return this.#abortController.signal;
+  }
+  /** Wait for background waitUntil promises with a timeout. */
+  async #waitBackgroundPromises(timeoutMs) {
+    const pending = this.#backgroundPromises;
+    if (pending.length === 0) {
+      this.#rLog.debug({ msg: "no background promises" });
+      return;
+    }
+    const timedOut = await Promise.race([
+      Promise.allSettled(pending).then(() => false),
+      new Promise(
+        (resolve) => setTimeout(() => resolve(true), timeoutMs)
+      )
+    ]);
+    if (timedOut) {
+      this.#rLog.error({
+        msg: "timed out waiting for background tasks, background promises may have leaked",
+        count: pending.length,
+        timeoutMs
+      });
+    } else {
+      this.#rLog.debug({ msg: "background promises finished" });
+    }
+  }
+  // MARK: BARE Conversion Helpers
+  #convertToBarePersisted(persist) {
+    return {
+      input: persist.input !== void 0 ? _chunk5JBFVV4Ccjs.bufferToArrayBuffer.call(void 0, cbor2.encode(persist.input)) : null,
+      hasInitialized: persist.hasInitiated,
+      state: _chunk5JBFVV4Ccjs.bufferToArrayBuffer.call(void 0, cbor2.encode(persist.state)),
+      connections: persist.connections.map((conn) => ({
+        id: conn.connId,
+        token: conn.token,
+        driver: conn.connDriver,
+        driverState: _chunk5JBFVV4Ccjs.bufferToArrayBuffer.call(void 0, 
+          cbor2.encode(conn.connDriverState || {})
+        ),
+        parameters: _chunk5JBFVV4Ccjs.bufferToArrayBuffer.call(void 0, cbor2.encode(conn.params || {})),
+        state: _chunk5JBFVV4Ccjs.bufferToArrayBuffer.call(void 0, cbor2.encode(conn.state || {})),
+        subscriptions: conn.subscriptions.map((sub) => ({
+          eventName: sub.eventName
+        })),
+        lastSeen: BigInt(conn.lastSeen)
+      })),
+      scheduledEvents: persist.scheduledEvents.map((event) => ({
+        eventId: event.eventId,
+        timestamp: BigInt(event.timestamp),
+        kind: {
+          tag: "GenericPersistedScheduleEvent",
+          val: {
+            action: event.kind.generic.actionName,
+            args: _nullishCoalesce(event.kind.generic.args, () => ( null))
+          }
+        }
+      }))
+    };
+  }
+  #convertFromBarePersisted(bareData) {
+    return {
+      input: bareData.input ? cbor2.decode(new Uint8Array(bareData.input)) : void 0,
+      hasInitiated: bareData.hasInitialized,
+      state: cbor2.decode(new Uint8Array(bareData.state)),
+      connections: bareData.connections.map((conn) => ({
+        connId: conn.id,
+        token: conn.token,
+        connDriver: conn.driver,
+        connDriverState: cbor2.decode(new Uint8Array(conn.driverState)),
+        params: cbor2.decode(new Uint8Array(conn.parameters)),
+        state: cbor2.decode(new Uint8Array(conn.state)),
+        subscriptions: conn.subscriptions.map((sub) => ({
+          eventName: sub.eventName
+        })),
+        lastSeen: Number(conn.lastSeen)
+      })),
+      scheduledEvents: bareData.scheduledEvents.map((event) => ({
+        eventId: event.eventId,
+        timestamp: Number(event.timestamp),
+        kind: {
+          generic: {
+            actionName: event.kind.val.action,
+            args: event.kind.val.args
+          }
+        }
+      }))
+    };
+  }
+};
+
+// src/actor/definition.ts
+var ActorDefinition = class {
+  #config;
+  constructor(config) {
+    this.#config = config;
+  }
+  get config() {
+    return this.#config;
+  }
+  instantiate() {
+    return new ActorInstance(this.#config);
+  }
+};
+function lookupInRegistry(registryConfig, name) {
+  const definition = registryConfig.use[name];
+  if (!definition) throw new Error(`no actor in registry for name ${name}`);
+  return definition;
+}
+
+// src/client/errors.ts
+var ActorClientError = class extends Error {
+};
+var InternalError2 = class extends ActorClientError {
+};
+var ManagerError = class extends ActorClientError {
+  constructor(error, opts) {
+    super(`Manager error: ${error}`, opts);
+  }
+};
+var MalformedResponseMessage = class extends ActorClientError {
+  constructor(cause) {
+    super(`Malformed response message: ${cause}`, { cause });
+  }
+};
+var ActorError = (_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 es = await Promise.resolve().then(() => _interopRequireWildcard(require("eventsource")));
+      _EventSource = es.EventSource;
+      _chunkKG3C7MKRcjs.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.'
+          );
+        }
+      };
+      _chunkKG3C7MKRcjs.logger.call(void 0, ).debug("using mock eventsource");
+    }
+    return _EventSource;
+  })();
+  return eventSourcePromise;
+}
+
+// src/client/actor-query.ts
+async function queryActor(c, query, managerDriver) {
+  _chunkKG3C7MKRcjs.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, _chunk5QGQK44Lcjs.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, _chunk5QGQK44Lcjs.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, _chunk5QGQK44Lcjs.InvalidRequest)("Invalid query format");
+  }
+  _chunkKG3C7MKRcjs.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);
+    _chunkKG3C7MKRcjs.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(_chunkTCUI5JFEcjs.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 } = _chunk5JBFVV4Ccjs.deconstructError.call(void 0, 
+      err,
+      _chunkKG3C7MKRcjs.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);
+  _chunkKG3C7MKRcjs.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 = `${_chunkTCUI5JFEcjs.PATH_RAW_WEBSOCKET_PREFIX}${pathPortion}${queryPortion}`;
+  _chunkKG3C7MKRcjs.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;
+  }
+  _chunk5JBFVV4Ccjs.assertUnreachable.call(void 0, message);
+}
+async function sendHttpRequest(opts) {
+  _chunkKG3C7MKRcjs.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 = _chunkTCUI5JFEcjs.contentTypeForEncoding.call(void 0, opts.encoding);
+    bodyData = _chunkTCUI5JFEcjs.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": _chunk5JBFVV4Ccjs.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 = _chunkTCUI5JFEcjs.deserializeWithEncoding.call(void 0, 
+        opts.encoding,
+        new Uint8Array(bufferResponse),
+        _chunkNTCUGYSDcjs.HTTP_RESPONSE_ERROR_VERSIONED
+      );
+    } catch (error) {
+      const textResponse = new TextDecoder("utf-8", { fatal: false }).decode(
+        bufferResponse
+      );
+      throw new HttpRequestError(
+        `${response.statusText} (${response.status}):
+${textResponse}`
+      );
+    }
+    throw new ActorError(
+      responseData.group,
+      responseData.code,
+      responseData.message,
+      responseData.metadata ? cbor3.decode(new Uint8Array(responseData.metadata)) : void 0
+    );
+  }
+  if (opts.skipParseResponse) {
+    return void 0;
+  }
+  try {
+    const buffer = new Uint8Array(await response.arrayBuffer());
+    return _chunkTCUI5JFEcjs.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
+      );
+      _chunkKG3C7MKRcjs.logger.call(void 0, ).debug({ msg: "found actor for action", actorId });
+      _invariant2.default.call(void 0, actorId, "Missing actor ID");
+      _chunkKG3C7MKRcjs.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: {
+          [_chunkTCUI5JFEcjs.HEADER_ENCODING]: this.#encoding,
+          ...this.#params !== void 0 ? { [_chunkTCUI5JFEcjs.HEADER_CONN_PARAMS]: JSON.stringify(this.#params) } : {}
+        },
+        body: {
+          args: _chunk5JBFVV4Ccjs.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: _chunkNTCUGYSDcjs.HTTP_ACTION_REQUEST_VERSIONED,
+        responseVersionedDataHandler: _chunkNTCUGYSDcjs.HTTP_ACTION_RESPONSE_VERSIONED
+      });
+      return cbor4.decode(new Uint8Array(responseData.output));
+    } catch (err) {
+      const { group, code, message, metadata } = _chunk5JBFVV4Ccjs.deconstructError.call(void 0, 
+        err,
+        _chunkKG3C7MKRcjs.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() {
+    _chunkKG3C7MKRcjs.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 {
+        _chunkTCUI5JFEcjs.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 {
+      _chunkTCUI5JFEcjs.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.
+   *
+   * @param {string} managerEndpoint - The manager endpoint. See {@link https://rivet.dev/docs/setup|Initial Setup} for instructions on getting the manager endpoint.
+   * @param {ClientConfig} [opts] - Options for configuring the client.
+   * @see {@link https://rivet.dev/docs/setup|Initial Setup}
+   */
+  constructor(driver, opts) {;_class4.prototype.__init4.call(this);
+    this.#driver = driver;
+    this.#encodingKind = _nullishCoalesce((opts == null ? void 0 : opts.encoding), () => ( "bare"));
+    this[TRANSPORT_SYMBOL] = _nullishCoalesce((opts == null ? void 0 : opts.transport), () => ( "websocket"));
+  }
+  /**
+   * Gets a stateless handle to a actor by its ID.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string} actorId - The ID of the actor.
+   * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+   * @returns {ActorHandle<AD>} - A handle to the actor.
+   */
+  getForId(name, actorId, opts) {
+    _chunkKG3C7MKRcjs.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 || [];
+    _chunkKG3C7MKRcjs.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 || [];
+    _chunkKG3C7MKRcjs.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
+      }
+    };
+    _chunkKG3C7MKRcjs.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);
+    _chunkKG3C7MKRcjs.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) {
+      _chunkKG3C7MKRcjs.logger.call(void 0, ).warn({ msg: "client already disconnected" });
+      return;
+    }
+    this.#disposed = true;
+    _chunkKG3C7MKRcjs.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, receiver);
+        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;
+  // These will only be set on SSE driver
+  #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) {
+    _chunkKG3C7MKRcjs.logger.call(void 0, ).debug({ msg: "action", name: opts.name, args: opts.args });
+    const actionId = this.#actionIdCounter;
+    this.#actionIdCounter += 1;
+    const { promise, resolve, reject } = Promise.withResolvers();
+    this.#actionsInFlight.set(actionId, { name: opts.name, resolve, reject });
+    this.#sendMessage({
+      body: {
+        tag: "ActionRequest",
+        val: {
+          id: BigInt(actionId),
+          name: opts.name,
+          args: _chunk5JBFVV4Ccjs.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) => {
+          _chunkKG3C7MKRcjs.logger.call(void 0, ).warn({
+            msg: "failed to reconnect",
+            attempt: error.attemptNumber,
+            error: _chunk5JBFVV4Ccjs.stringifyError.call(void 0, error)
+          });
+        },
+        // Cancel retry if aborted
+        signal: this.#abortController.signal
+      });
+    } catch (err) {
+      if (err.name === "AbortError") {
+        _chunkKG3C7MKRcjs.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 = Promise.withResolvers();
+      if (this.#client[TRANSPORT_SYMBOL] === "websocket") {
+        await this.#connectWebSocket();
+      } else if (this.#client[TRANSPORT_SYMBOL] === "sse") {
+        await this.#connectSse();
+      } else {
+        _chunk5JBFVV4Ccjs.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 ws = await this.#driver.openWebSocket(
+      _chunkTCUI5JFEcjs.PATH_CONNECT_WEBSOCKET,
+      actorId,
+      this.#encoding,
+      this.#params
+    );
+    this.#transport = { websocket: ws };
+    ws.addEventListener("open", () => {
+      _chunkKG3C7MKRcjs.logger.call(void 0, ).debug({ msg: "websocket open" });
+    });
+    ws.addEventListener("message", async (ev) => {
+      this.#handleOnMessage(ev.data);
+    });
+    ws.addEventListener("close", (ev) => {
+      this.#handleOnClose(ev);
+    });
+    ws.addEventListener("error", (_ev) => {
+      this.#handleOnError();
+    });
+  }
+  async #connectSse() {
+    const EventSource = await importEventSource();
+    const { actorId } = await queryActor(
+      void 0,
+      this.#actorQuery,
+      this.#driver
+    );
+    _chunkKG3C7MKRcjs.logger.call(void 0, ).debug({ msg: "found actor for sse connection", actorId });
+    _invariant2.default.call(void 0, actorId, "Missing actor ID");
+    _chunkKG3C7MKRcjs.logger.call(void 0, ).debug({
+      msg: "opening sse connection",
+      actorId,
+      encoding: this.#encoding
+    });
+    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": _chunk5JBFVV4Ccjs.httpUserAgent.call(void 0, ),
+              [_chunkTCUI5JFEcjs.HEADER_ENCODING]: this.#encoding,
+              ...this.#params !== void 0 ? { [_chunkTCUI5JFEcjs.HEADER_CONN_PARAMS]: JSON.stringify(this.#params) } : {}
+            }
+          })
+        );
+      }
+    });
+    this.#transport = { sse: eventSource };
+    eventSource.addEventListener("message", (ev) => {
+      this.#handleOnMessage(ev.data);
+    });
+    eventSource.addEventListener("error", (ev) => {
+      this.#handleOnError();
+    });
+  }
+  /** Called by the onopen event from drivers. */
+  #handleOnOpen() {
+    _chunkKG3C7MKRcjs.logger.call(void 0, ).debug({
+      msg: "socket open",
+      messageQueueLength: this.#messageQueue.length
+    });
+    if (this.#onOpenPromise) {
+      this.#onOpenPromise.resolve(void 0);
+    } else {
+      _chunkKG3C7MKRcjs.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 = [];
+    for (const msg of queue) {
+      this.#sendMessage(msg);
+    }
+  }
+  /** Called by the onmessage event from drivers. */
+  async #handleOnMessage(data) {
+    _chunkKG3C7MKRcjs.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);
+    _chunkKG3C7MKRcjs.logger.call(void 0, ).trace(
+      _chunk5JBFVV4Ccjs.getEnvUniversal.call(void 0, "_RIVETKIT_LOG_MESSAGE") ? {
+        msg: "parsed message",
+        message: _chunkTCUI5JFEcjs.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;
+      _chunkKG3C7MKRcjs.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));
+        _chunkKG3C7MKRcjs.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 {
+        _chunkKG3C7MKRcjs.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;
+      _chunkKG3C7MKRcjs.logger.call(void 0, ).trace({
+        msg: "received action response",
+        actionId
+      });
+      const inFlight = this.#takeActionInFlight(Number(actionId));
+      _chunkKG3C7MKRcjs.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") {
+      _chunkKG3C7MKRcjs.logger.call(void 0, ).trace({ msg: "received event", name: response.body.val.name });
+      this.#dispatchEvent(response.body.val);
+    } else {
+      _chunk5JBFVV4Ccjs.assertUnreachable.call(void 0, response.body);
+    }
+  }
+  /** Called by the onclose event from drivers. */
+  #handleOnClose(event) {
+    if (this.#onOpenPromise) {
+      this.#onOpenPromise.reject(new Error("Closed"));
+    }
+    const closeEvent = event;
+    if (closeEvent.wasClean) {
+      _chunkKG3C7MKRcjs.logger.call(void 0, ).info({
+        msg: "socket closed",
+        code: closeEvent.code,
+        reason: closeEvent.reason,
+        wasClean: closeEvent.wasClean
+      });
+    } else {
+      _chunkKG3C7MKRcjs.logger.call(void 0, ).warn({
+        msg: "socket closed",
+        code: closeEvent.code,
+        reason: closeEvent.reason,
+        wasClean: closeEvent.wasClean
+      });
+    }
+    this.#transport = void 0;
+    if (!this.#disposed && !this.#connecting) {
+      this.#connectWithRetry();
+    }
+  }
+  /** Called by the onerror event from drivers. */
+  #handleOnError() {
+    if (this.#disposed) return;
+    _chunkKG3C7MKRcjs.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) {
+        _chunkKG3C7MKRcjs.logger.call(void 0, ).error({
+          msg: "error in connection error handler",
+          error: _chunk5JBFVV4Ccjs.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) {
+    if (this.#disposed) {
+      throw new ActorConnDisposed();
+    }
+    let queueMessage = false;
+    if (!this.#transport) {
+      queueMessage = true;
+    } else if ("websocket" in this.#transport) {
+      if (this.#transport.websocket.readyState === 1) {
+        try {
+          const messageSerialized = _chunkTCUI5JFEcjs.serializeWithEncoding.call(void 0, 
+            this.#encoding,
+            message,
+            _chunkNTCUGYSDcjs.TO_SERVER_VERSIONED
+          );
+          this.#transport.websocket.send(messageSerialized);
+          _chunkKG3C7MKRcjs.logger.call(void 0, ).trace({
+            msg: "sent websocket message",
+            len: messageLength(messageSerialized)
+          });
+        } catch (error) {
+          _chunkKG3C7MKRcjs.logger.call(void 0, ).warn({
+            msg: "failed to send message, added to queue",
+            error
+          });
+          queueMessage = true;
+        }
+      } else {
+        queueMessage = true;
+      }
+    } else if ("sse" in this.#transport) {
+      if (this.#transport.sse.readyState === 1) {
+        this.#sendHttpMessage(message, opts);
+      } else {
+        queueMessage = true;
+      }
+    } else {
+      _chunk5JBFVV4Ccjs.assertUnreachable.call(void 0, this.#transport);
+    }
+    if (!(opts == null ? void 0 : opts.ephemeral) && queueMessage) {
+      this.#messageQueue.push(message);
+      _chunkKG3C7MKRcjs.logger.call(void 0, ).debug({ msg: "queued connection message" });
+    }
+  }
+  async #sendHttpMessage(message, opts) {
+    try {
+      if (!this.#actorId || !this.#connectionId || !this.#connectionToken)
+        throw new InternalError2("Missing connection ID or token.");
+      _chunkKG3C7MKRcjs.logger.call(void 0, ).trace(
+        _chunk5JBFVV4Ccjs.getEnvUniversal.call(void 0, "_RIVETKIT_LOG_MESSAGE") ? {
+          msg: "sent http message",
+          message: `${_chunkTCUI5JFEcjs.jsonStringifyCompat.call(void 0, message).substring(0, 100)}...`
+        } : { msg: "sent http message" }
+      );
+      _chunkKG3C7MKRcjs.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: {
+          [_chunkTCUI5JFEcjs.HEADER_ENCODING]: this.#encoding,
+          [_chunkTCUI5JFEcjs.HEADER_CONN_ID]: this.#connectionId,
+          [_chunkTCUI5JFEcjs.HEADER_CONN_TOKEN]: this.#connectionToken
+        },
+        body: message,
+        encoding: this.#encoding,
+        skipParseResponse: true,
+        customFetch: this.#driver.sendRequest.bind(this.#driver, this.#actorId),
+        requestVersionedDataHandler: _chunkNTCUGYSDcjs.TO_SERVER_VERSIONED,
+        responseVersionedDataHandler: _chunkNTCUGYSDcjs.TO_CLIENT_VERSIONED
+      });
+    } catch (error) {
+      _chunkKG3C7MKRcjs.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 (_chunkTCUI5JFEcjs.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 _chunkNTCUGYSDcjs.inputDataToBuffer.call(void 0, data);
+    return _chunkTCUI5JFEcjs.deserializeWithEncoding.call(void 0, this.#encoding, buffer, _chunkNTCUGYSDcjs.TO_CLIENT_VERSIONED);
+  }
+  /**
+   * Disconnects from the actor.
+   *
+   * @returns {Promise<void>} A promise that resolves when the socket is gracefully closed.
+   */
+  async dispose() {
+    if (this.#disposed) {
+      _chunkKG3C7MKRcjs.logger.call(void 0, ).warn({ msg: "connection already disconnected" });
+      return;
+    }
+    this.#disposed = true;
+    _chunkKG3C7MKRcjs.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) {
+      const ws = this.#transport.websocket;
+      if (ws.readyState === 2 || ws.readyState === 3) {
+        _chunkKG3C7MKRcjs.logger.call(void 0, ).debug({ msg: "ws already closed or closing" });
+      } else {
+        const { promise, resolve } = Promise.withResolvers();
+        ws.addEventListener("close", () => {
+          _chunkKG3C7MKRcjs.logger.call(void 0, ).debug({ msg: "ws closed" });
+          resolve(void 0);
+        });
+        ws.close();
+        await promise;
+      }
+    } else if ("sse" in this.#transport) {
+      this.#transport.sse.close();
+    } else {
+      _chunk5JBFVV4Ccjs.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 _chunkMRRT2CZDcjs.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 = _chunk5JBFVV4Ccjs.combineUrlPath.call(void 0, endpoint, path, {
+    namespace: config.namespace
+  });
+  logger2().debug({ msg: "making api call", method, url });
+  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 = _chunk5JBFVV4Ccjs.combineUrlPath.call(void 0, endpoint, url.pathname + url.search);
+  let bodyToSend = null;
+  const guardHeaders = buildGuardHeadersForHttp(actorRequest, actorId);
+  if (actorRequest.body && actorRequest.method !== "GET" && actorRequest.method !== "HEAD") {
+    if (actorRequest.bodyUsed) {
+      throw new Error("Request body has already been consumed");
+    }
+    const clonedRequest = actorRequest.clone();
+    bodyToSend = await clonedRequest.arrayBuffer();
+    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(actorRequest, actorId) {
+  const headers = new Headers();
+  for (const [key, value] of actorRequest.headers.entries()) {
+    headers.set(key, value);
+  }
+  headers.set("x-rivet-target", "actor");
+  headers.set("x-rivet-actor", actorId);
+  headers.set("x-rivet-port", "main");
+  return headers;
+}
+
+// src/remote-manager-driver/actor-websocket-client.ts
+async function openWebSocketToActor(runConfig, path, actorId, encoding, params) {
+  const WebSocket2 = await _chunkKG3C7MKRcjs.importWebSocket.call(void 0, );
+  const endpoint = getEndpoint(runConfig);
+  const guardUrl = _chunk5JBFVV4Ccjs.combineUrlPath.call(void 0, endpoint, path);
+  logger2().debug({
+    msg: "opening websocket to actor via guard",
+    actorId,
+    path,
+    guardUrl
+  });
+  const ws = new WebSocket2(guardUrl, {
+    headers: buildGuardHeadersForWebSocket(actorId, encoding, params)
+  });
+  ws.binaryType = "arraybuffer";
+  logger2().debug({ msg: "websocket connection opened", actorId });
+  return ws;
+}
+function buildGuardHeadersForWebSocket(actorId, encoding, params, authData) {
+  const headers = {};
+  headers["x-rivet-target"] = "actor";
+  headers["x-rivet-actor"] = actorId;
+  headers["x-rivet-port"] = "main";
+  headers[_chunkTCUI5JFEcjs.HEADER_ENCODING] = encoding;
+  if (params) {
+    headers[_chunkTCUI5JFEcjs.HEADER_CONN_PARAMS] = JSON.stringify(params);
+  }
+  if (authData) {
+    headers[_chunkTCUI5JFEcjs.HEADER_AUTH_DATA] = JSON.stringify(authData);
+  }
+  return headers;
+}
+
+// src/remote-manager-driver/api-endpoints.ts
+async function getActor(config, actorId) {
+  return apiCall(
+    config,
+    "GET",
+    `/actors/${encodeURIComponent(actorId)}`
+  );
+}
+async function getActorById(config, name, key) {
+  const serializedKey = serializeActorKey(key);
+  return apiCall(
+    config,
+    "GET",
+    `/actors/by-id?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`
+  );
+}
+async function getOrCreateActorById(config, request) {
+  return apiCall(
+    config,
+    "PUT",
+    `/actors/by-id`,
+    request
+  );
+}
+async function createActor(config, request) {
+  return apiCall(
+    config,
+    "POST",
+    `/actors`,
+    request
+  );
+}
+async function destroyActor(config, actorId) {
+  return apiCall(
+    config,
+    "DELETE",
+    `/actors/${encodeURIComponent(actorId)}`
+  );
+}
+
+// src/remote-manager-driver/ws-proxy.ts
+async function createWebSocketProxy(c, targetUrl, headers) {
+  const WebSocket2 = await _chunkKG3C7MKRcjs.importWebSocket.call(void 0, );
+  for (const [k, v] of c.req.raw.headers.entries()) {
+    if (!k.startsWith("sec-") && k !== "connection" && k !== "upgrade") {
+      headers[k] = v;
+    }
+  }
+  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, { headers });
+      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: _chunk5JBFVV4Ccjs.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 RemoteManagerDriver = class {
+  #config;
+  constructor(runConfig) {
+    this.#config = runConfig;
+  }
+  async getForId({
+    c,
+    name,
+    actorId
+  }) {
+    try {
+      const response = await getActor(this.#config, actorId);
+      if (response.actor.name !== name) {
+        logger2().debug({
+          msg: "actor name mismatch from api",
+          actorId,
+          apiName: response.actor.name,
+          requestedName: name
+        });
+        return void 0;
+      }
+      const keyRaw = response.actor.key;
+      _invariant2.default.call(void 0, keyRaw, `actor ${actorId} should have key`);
+      const key = deserializeActorKey(keyRaw);
+      return {
+        actorId,
+        name,
+        key
+      };
+    } catch (error) {
+      if (error instanceof EngineApiError && error.group === "actor" && error.code === "not_found") {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async getWithKey({
+    c,
+    name,
+    key
+  }) {
+    logger2().debug({ msg: "getWithKey: searching for actor", name, key });
+    try {
+      const response = await getActorById(this.#config, name, key);
+      if (!response.actor_id) {
+        return void 0;
+      }
+      const actorId = response.actor_id;
+      logger2().debug({
+        msg: "getWithKey: found actor via api",
+        actorId,
+        name,
+        key
+      });
+      return {
+        actorId,
+        name,
+        key
+      };
+    } catch (error) {
+      if (error instanceof EngineApiError && error.group === "actor" && error.code === "not_found") {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async getOrCreateWithKey(input) {
+    const { c, name, key, input: actorInput, region } = input;
+    logger2().info({
+      msg: "getOrCreateWithKey: getting or creating actor via engine api",
+      name,
+      key
+    });
+    const response = await getOrCreateActorById(this.#config, {
+      name,
+      key: serializeActorKey(key),
+      runner_name_selector: this.#config.runnerName,
+      input: input ? cbor6.encode(actorInput).toString("base64") : void 0,
+      crash_policy: "sleep"
+    });
+    const actorId = response.actor_id;
+    logger2().info({
+      msg: "getOrCreateWithKey: actor ready",
+      actorId,
+      name,
+      key,
+      created: response.created
+    });
+    return {
+      actorId,
+      name,
+      key
+    };
+  }
+  async createActor({
+    c,
+    name,
+    key,
+    input
+  }) {
+    logger2().info({ msg: "creating actor via engine api", name, key });
+    const result = await createActor(this.#config, {
+      name,
+      runner_name_selector: this.#config.runnerName,
+      key: serializeActorKey(key),
+      input: input ? cbor6.encode(input).toString("base64") : null,
+      crash_policy: "sleep"
+    });
+    const actorId = result.actor.actor_id;
+    logger2().info({ msg: "actor created", actorId, name, key });
+    return {
+      actorId,
+      name,
+      key
+    };
+  }
+  async destroyActor(actorId) {
+    logger2().info({ msg: "destroying actor via engine api", actorId });
+    await destroyActor(this.#config, actorId);
+    logger2().info({ msg: "actor destroyed", actorId });
+  }
+  async sendRequest(actorId, actorRequest) {
+    return await sendHttpRequestToActor(this.#config, actorId, actorRequest);
+  }
+  async openWebSocket(path, actorId, encoding, params) {
+    return await openWebSocketToActor(
+      this.#config,
+      path,
+      actorId,
+      encoding,
+      params
+    );
+  }
+  async proxyRequest(_c, actorRequest, actorId) {
+    return await sendHttpRequestToActor(this.#config, actorId, actorRequest);
+  }
+  async proxyWebSocket(c, path, actorId, encoding, params, authData) {
+    var _a, _b;
+    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 = _chunk5JBFVV4Ccjs.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 headers = buildGuardHeadersForWebSocket(
+      actorId,
+      encoding,
+      params,
+      authData
+    );
+    const args = await createWebSocketProxy(c, wsGuardUrl, headers);
+    return await upgradeWebSocket(() => args)(c, _chunk5JBFVV4Ccjs.noopNext.call(void 0, ));
+  }
+  displayInformation() {
+    return { name: "Remote", properties: {} };
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.generateConnId = generateConnId; exports.generateConnToken = generateConnToken; exports.CONNECTION_DRIVER_WEBSOCKET = CONNECTION_DRIVER_WEBSOCKET; exports.CONNECTION_DRIVER_SSE = CONNECTION_DRIVER_SSE; exports.CONNECTION_DRIVER_HTTP = CONNECTION_DRIVER_HTTP; exports.createActorInspectorRouter = createActorInspectorRouter; exports.deserializeActorKey = deserializeActorKey; exports.ActorDefinition = ActorDefinition; exports.lookupInRegistry = lookupInRegistry; exports.ActorClientError = ActorClientError; exports.InternalError = InternalError2; exports.ManagerError = ManagerError; exports.MalformedResponseMessage = MalformedResponseMessage; exports.ActorError = ActorError; exports.ActorConnRaw = ActorConnRaw; exports.ActorHandleRaw = ActorHandleRaw; exports.createClientWithDriver = createClientWithDriver; exports.RemoteManagerDriver = RemoteManagerDriver;
+//# sourceMappingURL=chunk-UFWAK3X2.cjs.map