rivetkit 2.0.42 → 2.1.0-rc.1

package/dist/tsup/chunk-GD7UXGOE.cjs

@@ -1,4762 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class; var _class2; var _class3;
-
-
-var _chunkEJVBH5VFcjs = require('./chunk-EJVBH5VF.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkRZW2DNNDcjs = require('./chunk-RZW2DNND.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkH4TB4X25cjs = require('./chunk-H4TB4X25.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunk2XQS746Mcjs = require('./chunk-2XQS746M.cjs');
-
-// src/devtools-loader/log.ts
-function logger2() {
-  return _chunkH4TB4X25cjs.getLogger.call(void 0, "devtools");
-}
-
-// src/devtools-loader/index.ts
-var DEFAULT_DEVTOOLS_URL = (version = _chunkH4TB4X25cjs.VERSION) => `https://releases.rivet.dev/rivet/latest/devtools/mod.js?v=${version}`;
-var scriptId = "rivetkit-devtools-script";
-function injectDevtools(config) {
-  if (!window) {
-    logger2().warn("devtools not available outside browser environment");
-    return;
-  }
-  if (!document.getElementById(scriptId)) {
-    const script = document.createElement("script");
-    script.id = scriptId;
-    script.src = DEFAULT_DEVTOOLS_URL();
-    script.async = true;
-    document.head.appendChild(script);
-  }
-  window.__rivetkit = window.__rivetkit || [];
-  window.__rivetkit.push(config);
-}
-
-// src/remote-manager-driver/mod.ts
-var _cborx = require('cbor-x'); var cbor2 = _interopRequireWildcard(_cborx); var cbor = _interopRequireWildcard(_cborx); var cbor3 = _interopRequireWildcard(_cborx); var cbor4 = _interopRequireWildcard(_cborx); var cbor5 = _interopRequireWildcard(_cborx); var cbor6 = _interopRequireWildcard(_cborx); var cbor7 = _interopRequireWildcard(_cborx); var cbor8 = _interopRequireWildcard(_cborx); var cbor9 = _interopRequireWildcard(_cborx);
-var _invariant = require('invariant'); var _invariant2 = _interopRequireDefault(_invariant);
-
-// src/remote-manager-driver/api-utils.ts
-var _zod = require('zod'); var _zod2 = _interopRequireDefault(_zod);
-
-// src/client/utils.ts
-
-
-
-// src/client/errors.ts
-var ActorClientError = class extends Error {
-};
-var InternalError2 = class extends ActorClientError {
-};
-var ManagerError = class extends ActorClientError {
-  constructor(error, opts) {
-    super(`Manager error: ${error}`, opts);
-  }
-};
-var MalformedResponseMessage = class extends ActorClientError {
-  constructor(cause) {
-    super(`Malformed response message: ${cause}`, { cause });
-  }
-};
-var ActorError = (_class = class extends ActorClientError {
-  constructor(group, code, message, metadata) {
-    super(message);_class.prototype.__init.call(this);;
-    this.group = group;
-    this.code = code;
-    this.metadata = metadata;
-  }
-  __init() {this.__type = "ActorError"}
-}, _class);
-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.");
-  }
-};
-function isSchedulingError(group, code) {
-  return group === "guard" && (code === "actor_ready_timeout" || code === "actor_runner_failed");
-}
-var ActorSchedulingError = class extends ActorError {
-  
-  
-  constructor(group, code, actorId, details) {
-    super(
-      group,
-      code,
-      `Actor failed to start (${actorId}): ${JSON.stringify(details)}`,
-      { actorId, details }
-    );
-    this.name = "ActorSchedulingError";
-    this.actorId = actorId;
-    this.details = details;
-  }
-};
-
-// src/client/utils.ts
-function parseWebSocketCloseReason(reason) {
-  const [mainPart, rayId] = reason.split("#");
-  const [group, code] = mainPart.split(".");
-  if (!group || !code) {
-    _chunkEJVBH5VFcjs.logger.call(void 0, ).warn({ msg: "failed to parse close reason", reason });
-    return void 0;
-  }
-  return {
-    group,
-    code,
-    rayId
-  };
-}
-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;
-  }
-  _chunkH4TB4X25cjs.assertUnreachable.call(void 0, message);
-}
-async function sendHttpRequest(opts) {
-  _chunkEJVBH5VFcjs.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 = _chunkRZW2DNNDcjs.contentTypeForEncoding.call(void 0, opts.encoding);
-    bodyData = _chunkRZW2DNNDcjs.serializeWithEncoding.call(void 0, 
-      opts.encoding,
-      opts.body,
-      opts.requestVersionedDataHandler,
-      opts.requestVersion,
-      opts.requestZodSchema,
-      opts.requestToJson,
-      opts.requestToBare
-    );
-  }
-  let response;
-  try {
-    response = await (_nullishCoalesce(opts.customFetch, () => ( fetch)))(
-      new globalThis.Request(opts.url, {
-        method: opts.method,
-        headers: {
-          ...opts.headers,
-          ...contentType ? {
-            "Content-Type": contentType
-          } : {},
-          "User-Agent": _chunkH4TB4X25cjs.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();
-    const contentType2 = response.headers.get("content-type");
-    const rayId = response.headers.get("x-rivet-ray-id");
-    const encoding = (contentType2 == null ? void 0 : contentType2.includes("application/json")) ? "json" : opts.encoding;
-    try {
-      const responseData = _chunkRZW2DNNDcjs.deserializeWithEncoding.call(void 0, 
-        encoding,
-        new Uint8Array(bufferResponse),
-        _chunkRZW2DNNDcjs.HTTP_RESPONSE_ERROR_VERSIONED,
-        _chunkRZW2DNNDcjs.HttpResponseErrorSchema,
-        // JSON: metadata is already unknown
-        (json) => json,
-        // BARE: decode ArrayBuffer metadata to unknown
-        (bare) => ({
-          group: bare.group,
-          code: bare.code,
-          message: bare.message,
-          metadata: bare.metadata ? cbor.decode(new Uint8Array(bare.metadata)) : void 0
-        })
-      );
-      throw new ActorError(
-        responseData.group,
-        responseData.code,
-        responseData.message,
-        responseData.metadata
-      );
-    } catch (error) {
-      if (error instanceof ActorError) {
-        throw error;
-      }
-      const textResponse = new TextDecoder("utf-8", {
-        fatal: false
-      }).decode(bufferResponse);
-      if (rayId) {
-        throw new HttpRequestError(
-          `${response.statusText} (${response.status}) (Ray ID: ${rayId}):
-${textResponse}`
-        );
-      } else {
-        throw new HttpRequestError(
-          `${response.statusText} (${response.status}):
-${textResponse}`
-        );
-      }
-    }
-  }
-  if (opts.skipParseResponse) {
-    return void 0;
-  }
-  try {
-    const buffer = new Uint8Array(await response.arrayBuffer());
-    return _chunkRZW2DNNDcjs.deserializeWithEncoding.call(void 0, 
-      opts.encoding,
-      buffer,
-      opts.responseVersionedDataHandler,
-      opts.responseZodSchema,
-      opts.responseFromJson,
-      opts.responseFromBare
-    );
-  } catch (error) {
-    throw new HttpRequestError(`Failed to parse response: ${error}`, {
-      cause: error
-    });
-  }
-}
-
-// src/remote-manager-driver/log.ts
-function logger3() {
-  return _chunkH4TB4X25cjs.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 = _chunkH4TB4X25cjs.combineUrlPath.call(void 0, endpoint, path, {
-    namespace: config.namespace
-  });
-  logger3().debug({ msg: "making api call", method, url });
-  const headers = {
-    ...config.headers
-  };
-  if (config.token) {
-    headers.Authorization = `Bearer ${config.token}`;
-  }
-  return await sendHttpRequest({
-    method,
-    url,
-    headers,
-    body,
-    encoding: "json",
-    skipParseResponse: false,
-    requestVersionedDataHandler: void 0,
-    requestVersion: void 0,
-    responseVersionedDataHandler: void 0,
-    responseVersion: void 0,
-    requestZodSchema: _zod.z.any(),
-    responseZodSchema: _zod.z.any(),
-    // Identity conversions (passthrough for generic API calls)
-    requestToJson: (value) => value,
-    requestToBare: (value) => value,
-    responseFromJson: (value) => value,
-    responseFromBare: (value) => value
-  });
-}
-
-// src/remote-manager-driver/actor-websocket-client.ts
-function buildActorGatewayUrl(endpoint, actorId, token, path = "") {
-  const tokenSegment = token !== void 0 ? `@${encodeURIComponent(token)}` : "";
-  const gatewayPath = `/gateway/${encodeURIComponent(actorId)}${tokenSegment}${path}`;
-  return _chunkH4TB4X25cjs.combineUrlPath.call(void 0, endpoint, gatewayPath);
-}
-async function openWebSocketToActor(runConfig, path, actorId, encoding, params) {
-  const WebSocket2 = await _chunkEJVBH5VFcjs.importWebSocket.call(void 0, );
-  const endpoint = getEndpoint(runConfig);
-  const guardUrl = buildActorGatewayUrl(
-    endpoint,
-    actorId,
-    runConfig.token,
-    path
-  );
-  logger3().debug({
-    msg: "opening websocket to actor via guard",
-    actorId,
-    path,
-    guardUrl
-  });
-  const ws = new WebSocket2(
-    guardUrl,
-    buildWebSocketProtocols(runConfig, encoding, params)
-  );
-  ws.binaryType = "arraybuffer";
-  logger3().debug({ msg: "websocket connection opened", actorId });
-  return ws;
-}
-function buildWebSocketProtocols(runConfig, encoding, params) {
-  const protocols = [];
-  protocols.push(_chunkRZW2DNNDcjs.WS_PROTOCOL_STANDARD);
-  protocols.push(`${_chunkRZW2DNNDcjs.WS_PROTOCOL_ENCODING}${encoding}`);
-  if (params) {
-    protocols.push(
-      `${_chunkRZW2DNNDcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
-    );
-  }
-  return protocols;
-}
-
-// 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 = buildActorGatewayUrl(
-    endpoint,
-    actorId,
-    runConfig.token,
-    `${url.pathname}${url.search}`
-  );
-  let bodyToSend = null;
-  const guardHeaders = buildGuardHeadersForHttp(
-    runConfig,
-    actorRequest,
-    actorId
-  );
-  if (actorRequest.method !== "GET" && actorRequest.method !== "HEAD") {
-    if (actorRequest.bodyUsed) {
-      throw new Error("Request body has already been consumed");
-    }
-    const reqBody = await actorRequest.arrayBuffer();
-    if (reqBody.byteLength !== 0) {
-      bodyToSend = reqBody;
-      guardHeaders.delete("transfer-encoding");
-      guardHeaders.set("content-length", String(bodyToSend.byteLength));
-    }
-  }
-  const guardRequest = new Request(guardUrl, {
-    method: actorRequest.method,
-    headers: guardHeaders,
-    body: bodyToSend,
-    signal: actorRequest.signal
-  });
-  return mutableResponse(await fetch(guardRequest));
-}
-function mutableResponse(fetchRes) {
-  return new Response(fetchRes.body, fetchRes);
-}
-function buildGuardHeadersForHttp(runConfig, actorRequest, actorId) {
-  const headers = new Headers();
-  actorRequest.headers.forEach((value, key) => {
-    headers.set(key, value);
-  });
-  for (const [key, value] of Object.entries(runConfig.headers)) {
-    headers.set(key, value);
-  }
-  if (runConfig.token) {
-    headers.set(_chunkRZW2DNNDcjs.HEADER_RIVET_TOKEN, runConfig.token);
-  }
-  return headers;
-}
-
-// src/remote-manager-driver/api-endpoints.ts
-async function getActor(config, _, actorId) {
-  return apiCall(
-    config,
-    "GET",
-    `/actors?actor_ids=${encodeURIComponent(actorId)}`
-  );
-}
-async function getActorByKey(config, name, key) {
-  const serializedKey = _chunkRZW2DNNDcjs.serializeActorKey.call(void 0, key);
-  return apiCall(
-    config,
-    "GET",
-    `/actors?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`
-  );
-}
-async function listActorsByName(config, name) {
-  return apiCall(
-    config,
-    "GET",
-    `/actors?name=${encodeURIComponent(name)}`
-  );
-}
-async function getOrCreateActor(config, request) {
-  return apiCall(
-    config,
-    "PUT",
-    `/actors`,
-    request
-  );
-}
-async function createActor(config, request) {
-  return apiCall(
-    config,
-    "POST",
-    `/actors`,
-    request
-  );
-}
-async function destroyActor(config, actorId) {
-  return apiCall(
-    config,
-    "DELETE",
-    `/actors/${encodeURIComponent(actorId)}`
-  );
-}
-async function getMetadata(config) {
-  return apiCall(config, "GET", `/metadata`);
-}
-async function getDatacenters(config) {
-  return apiCall(config, "GET", `/datacenters`);
-}
-async function updateRunnerConfig(config, runnerName, request) {
-  return apiCall(
-    config,
-    "PUT",
-    `/runner-configs/${runnerName}`,
-    request
-  );
-}
-async function kvGet(config, actorId, key) {
-  return apiCall(
-    config,
-    "GET",
-    `/actors/${encodeURIComponent(actorId)}/kv/keys/${encodeURIComponent(key)}`
-  );
-}
-
-// src/remote-manager-driver/metadata.ts
-var _pretry = require('p-retry'); var _pretry2 = _interopRequireDefault(_pretry);
-var metadataLookupCache = /* @__PURE__ */ new Map();
-async function lookupMetadataCached(config) {
-  const endpoint = getEndpoint(config);
-  const existingPromise = metadataLookupCache.get(endpoint);
-  if (existingPromise) {
-    return existingPromise;
-  }
-  const metadataLookupPromise = _pretry2.default.call(void 0, 
-    async () => {
-      logger3().debug({
-        msg: "fetching metadata",
-        endpoint
-      });
-      const metadataData = await getMetadata(config);
-      logger3().debug({
-        msg: "received metadata",
-        endpoint,
-        clientEndpoint: metadataData.clientEndpoint
-      });
-      return metadataData;
-    },
-    {
-      forever: true,
-      minTimeout: 500,
-      maxTimeout: 15e3,
-      onFailedAttempt: (error) => {
-        if (error.attemptNumber > 1) {
-          logger3().warn({
-            msg: "failed to fetch metadata, retrying",
-            endpoint,
-            attempt: error.attemptNumber,
-            error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-          });
-        }
-      }
-    }
-  );
-  metadataLookupCache.set(endpoint, metadataLookupPromise);
-  return metadataLookupPromise;
-}
-
-// src/remote-manager-driver/ws-proxy.ts
-async function createWebSocketProxy(c, targetUrl, protocols) {
-  const WebSocket2 = await _chunkEJVBH5VFcjs.importWebSocket.call(void 0, );
-  const state = {};
-  return {
-    onOpen: async (event, clientWs) => {
-      logger3().debug({ msg: "client websocket connected", targetUrl });
-      if (clientWs.readyState !== 1) {
-        logger3().warn({
-          msg: "client websocket not open on connection",
-          targetUrl,
-          readyState: clientWs.readyState
-        });
-        return;
-      }
-      const targetWs = new WebSocket2(targetUrl, protocols);
-      state.targetWs = targetWs;
-      state.connectPromise = new Promise((resolve, reject) => {
-        targetWs.addEventListener("open", () => {
-          logger3().debug({
-            msg: "target websocket connected",
-            targetUrl
-          });
-          if (clientWs.readyState !== 1) {
-            logger3().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) => {
-          logger3().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) => {
-        logger3().debug({
-          msg: "target websocket closed",
-          targetUrl,
-          code: event2.code,
-          reason: event2.reason
-        });
-        closeWebSocketIfOpen(clientWs, event2.code, event2.reason);
-      });
-      state.targetWs.addEventListener("error", (error) => {
-        logger3().error({
-          msg: "target websocket error",
-          targetUrl,
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-        });
-        closeWebSocketIfOpen(clientWs, 1011, "Target WebSocket error");
-      });
-    },
-    onMessage: async (event, clientWs) => {
-      if (!state.targetWs || !state.connectPromise) {
-        logger3().error({
-          msg: "websocket state not initialized",
-          targetUrl
-        });
-        return;
-      }
-      try {
-        await state.connectPromise;
-        if (state.targetWs.readyState === WebSocket2.OPEN) {
-          state.targetWs.send(event.data);
-        } else {
-          logger3().warn({
-            msg: "target websocket not open",
-            targetUrl,
-            readyState: state.targetWs.readyState
-          });
-        }
-      } catch (error) {
-        logger3().error({
-          msg: "failed to connect to target websocket",
-          targetUrl,
-          error
-        });
-        closeWebSocketIfOpen(
-          clientWs,
-          1011,
-          "Failed to connect to target"
-        );
-      }
-    },
-    onClose: (event, clientWs) => {
-      logger3().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) => {
-      logger3().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;
-  #metadataPromise;
-  constructor(runConfig) {
-    if (_chunkH4TB4X25cjs.getNextPhase.call(void 0, ) === "phase-production-build") {
-      logger3().info(
-        "detected next.js build phase, disabling health check"
-      );
-      runConfig.disableMetadataLookup = true;
-    }
-    this.#config = { ...runConfig };
-    if (!runConfig.disableMetadataLookup) {
-      this.#metadataPromise = lookupMetadataCached(this.#config).then(
-        (metadataData) => {
-          if (metadataData.clientEndpoint) {
-            this.#config.endpoint = metadataData.clientEndpoint;
-            if (metadataData.clientNamespace) {
-              this.#config.namespace = metadataData.clientNamespace;
-            }
-            if (metadataData.clientToken) {
-              this.#config.token = metadataData.clientToken;
-            }
-            logger3().info({
-              msg: "overriding client endpoint",
-              endpoint: metadataData.clientEndpoint,
-              namespace: metadataData.clientNamespace,
-              token: metadataData.clientToken
-            });
-          }
-          logger3().info({
-            msg: "connected to rivetkit manager",
-            runtime: metadataData.runtime,
-            version: metadataData.version,
-            runner: metadataData.runner
-          });
-        }
-      );
-    }
-  }
-  async getForId({
-    c,
-    name,
-    actorId
-  }) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    const response = await getActor(this.#config, name, actorId);
-    const actor = response.actors[0];
-    if (!actor) return void 0;
-    if (actor.name !== name) {
-      logger3().debug({
-        msg: "actor name mismatch from api",
-        actorId,
-        apiName: actor.name,
-        requestedName: name
-      });
-      return void 0;
-    }
-    return apiActorToOutput(actor);
-  }
-  async getWithKey({
-    c,
-    name,
-    key
-  }) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    logger3().debug({ msg: "getWithKey: searching for actor", name, key });
-    try {
-      const response = await getActorByKey(this.#config, name, key);
-      const actor = response.actors[0];
-      if (!actor) return void 0;
-      logger3().debug({
-        msg: "getWithKey: found actor via api",
-        actorId: actor.actor_id,
-        name,
-        key
-      });
-      return apiActorToOutput(actor);
-    } catch (error) {
-      if (error instanceof EngineApiError && error.group === "actor" && error.code === "not_found") {
-        return void 0;
-      }
-      throw error;
-    }
-  }
-  async getOrCreateWithKey(input) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    const { c, name, key, input: actorInput, region } = input;
-    logger3().info({
-      msg: "getOrCreateWithKey: getting or creating actor via engine api",
-      name,
-      key
-    });
-    const { actor, created } = await getOrCreateActor(this.#config, {
-      datacenter: region,
-      name,
-      key: _chunkRZW2DNNDcjs.serializeActorKey.call(void 0, key),
-      runner_name_selector: this.#config.runnerName,
-      input: actorInput ? _chunkRZW2DNNDcjs.uint8ArrayToBase64.call(void 0, cbor2.encode(actorInput)) : void 0,
-      crash_policy: "sleep"
-    });
-    logger3().info({
-      msg: "getOrCreateWithKey: actor ready",
-      actorId: actor.actor_id,
-      name,
-      key,
-      created
-    });
-    return apiActorToOutput(actor);
-  }
-  async createActor({
-    c,
-    name,
-    key,
-    input,
-    region
-  }) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    logger3().info({ msg: "creating actor via engine api", name, key });
-    const result = await createActor(this.#config, {
-      datacenter: region,
-      name,
-      runner_name_selector: this.#config.runnerName,
-      key: _chunkRZW2DNNDcjs.serializeActorKey.call(void 0, key),
-      input: input ? _chunkRZW2DNNDcjs.uint8ArrayToBase64.call(void 0, cbor2.encode(input)) : void 0,
-      crash_policy: "sleep"
-    });
-    logger3().info({
-      msg: "actor created",
-      actorId: result.actor.actor_id,
-      name,
-      key
-    });
-    return apiActorToOutput(result.actor);
-  }
-  async listActors({ c, name }) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    logger3().debug({ msg: "listing actors via engine api", name });
-    const response = await listActorsByName(this.#config, name);
-    return response.actors.map(apiActorToOutput);
-  }
-  async destroyActor(actorId) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    logger3().info({ msg: "destroying actor via engine api", actorId });
-    await destroyActor(this.#config, actorId);
-    logger3().info({ msg: "actor destroyed", actorId });
-  }
-  async sendRequest(actorId, actorRequest) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    return await sendHttpRequestToActor(
-      this.#config,
-      actorId,
-      actorRequest
-    );
-  }
-  async openWebSocket(path, actorId, encoding, params) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    return await openWebSocketToActor(
-      this.#config,
-      path,
-      actorId,
-      encoding,
-      params
-    );
-  }
-  async buildGatewayUrl(actorId) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    const endpoint = getEndpoint(this.#config);
-    return buildActorGatewayUrl(endpoint, actorId, this.#config.token);
-  }
-  async proxyRequest(_c, actorRequest, actorId) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    return await sendHttpRequestToActor(
-      this.#config,
-      actorId,
-      actorRequest
-    );
-  }
-  async proxyWebSocket(c, path, actorId, encoding, params) {
-    var _a, _b;
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    const upgradeWebSocket = (_b = (_a = this.#config).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
-    _invariant2.default.call(void 0, upgradeWebSocket, "missing getUpgradeWebSocket");
-    const endpoint = getEndpoint(this.#config);
-    const guardUrl = _chunkH4TB4X25cjs.combineUrlPath.call(void 0, endpoint, path);
-    const wsGuardUrl = guardUrl.replace("http://", "ws://");
-    logger3().debug({
-      msg: "forwarding websocket to actor via guard",
-      actorId,
-      path,
-      guardUrl
-    });
-    const protocols = buildWebSocketProtocols(
-      this.#config,
-      encoding,
-      params
-    );
-    const args = await createWebSocketProxy(c, wsGuardUrl, protocols);
-    return await upgradeWebSocket(() => args)(c, _chunkH4TB4X25cjs.noopNext.call(void 0, ));
-  }
-  async kvGet(actorId, key) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    logger3().debug({ msg: "getting kv value via engine api", key });
-    const response = await kvGet(
-      this.#config,
-      actorId,
-      new TextDecoder("utf8").decode(key)
-    );
-    return response.value;
-  }
-  displayInformation() {
-    return { properties: {} };
-  }
-  setGetUpgradeWebSocket(getUpgradeWebSocket) {
-    this.#config.getUpgradeWebSocket = getUpgradeWebSocket;
-  }
-};
-function apiActorToOutput(actor) {
-  return {
-    actorId: actor.actor_id,
-    name: actor.name,
-    key: _chunkRZW2DNNDcjs.deserializeActorKey.call(void 0, actor.key),
-    createTs: actor.create_ts,
-    startTs: _nullishCoalesce(actor.start_ts, () => ( null)),
-    connectableTs: _nullishCoalesce(actor.connectable_ts, () => ( null)),
-    sleepTs: _nullishCoalesce(actor.sleep_ts, () => ( null)),
-    destroyTs: _nullishCoalesce(actor.destroy_ts, () => ( null)),
-    error: _nullishCoalesce(actor.error, () => ( void 0))
-  };
-}
-
-// src/client/actor-conn.ts
-
-
-
-
-// src/client/actor-query.ts
-async function queryActor(c, query, managerDriver) {
-  _chunkEJVBH5VFcjs.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, _chunk2XQS746Mcjs.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, _chunk2XQS746Mcjs.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, _chunk2XQS746Mcjs.InvalidRequest)("Invalid query format");
-  }
-  _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({ msg: "actor query result", actorId: actorOutput.actorId });
-  return { actorId: actorOutput.actorId };
-}
-function getActorNameFromQuery(query) {
-  if ("getForId" in query) return query.getForId.name;
-  if ("getForKey" in query) return query.getForKey.name;
-  if ("getOrCreateForKey" in query) return query.getOrCreateForKey.name;
-  if ("create" in query) return query.create.name;
-  throw new (0, _chunk2XQS746Mcjs.InvalidRequest)("Invalid query format");
-}
-async function checkForSchedulingError(group, code, actorId, query, driver) {
-  const name = getActorNameFromQuery(query);
-  try {
-    const actor = await driver.getForId({ name, actorId });
-    if (actor == null ? void 0 : actor.error) {
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).info({
-        msg: "found actor scheduling error",
-        actorId,
-        error: actor.error
-      });
-      return new ActorSchedulingError(group, code, actorId, actor.error);
-    }
-  } catch (err) {
-    _chunkEJVBH5VFcjs.logger.call(void 0, ).warn({
-      msg: "failed to fetch actor details for scheduling error check",
-      actorId,
-      error: _chunkH4TB4X25cjs.stringifyError.call(void 0, err)
-    });
-  }
-  return null;
-}
-
-// src/client/actor-conn.ts
-var CONNECT_SYMBOL = Symbol("connect");
-var ActorConnRaw = class {
-  #disposed = false;
-  /* Will be aborted on dispose. */
-  #abortController = new AbortController();
-  #connStatus = "idle";
-  #actorId;
-  #connId;
-  #messageQueue = [];
-  #actionsInFlight = /* @__PURE__ */ new Map();
-  // biome-ignore lint/suspicious/noExplicitAny: Unknown subscription type
-  #eventSubscriptions = /* @__PURE__ */ new Map();
-  #errorHandlers = /* @__PURE__ */ new Set();
-  #openHandlers = /* @__PURE__ */ new Set();
-  #closeHandlers = /* @__PURE__ */ new Set();
-  #statusChangeHandlers = /* @__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;
-  #websocket;
-  #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) {
-    _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({ msg: "action", name: opts.name, args: opts.args });
-    const actionId = this.#actionIdCounter;
-    this.#actionIdCounter += 1;
-    const { promise, resolve, reject } = _chunkH4TB4X25cjs.promiseWithResolvers.call(void 0, );
-    this.#actionsInFlight.set(actionId, {
-      name: opts.name,
-      resolve,
-      reject
-    });
-    _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({
-      msg: "added action to in-flight map",
-      actionId,
-      actionName: opts.name,
-      inFlightCount: this.#actionsInFlight.size
-    });
-    this.#sendMessage({
-      body: {
-        tag: "ActionRequest",
-        val: {
-          id: BigInt(actionId),
-          name: opts.name,
-          args: 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 output;
-  }
-  /**
-  	 * Do not call this directly.
-  enc
-  	 * Establishes a connection to the server using the specified endpoint & encoding & driver.
-  	 *
-  	 * @protected
-  	 */
-  [CONNECT_SYMBOL]() {
-    this.#connectWithRetry();
-  }
-  #setConnStatus(status) {
-    const prevStatus = this.#connStatus;
-    if (prevStatus === status) return;
-    this.#connStatus = status;
-    for (const handler of [...this.#statusChangeHandlers]) {
-      try {
-        handler(status);
-      } catch (err) {
-        _chunkEJVBH5VFcjs.logger.call(void 0, ).error({
-          msg: "error in status change handler",
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, err)
-        });
-      }
-    }
-    if (status === "connected") {
-      for (const handler of [...this.#openHandlers]) {
-        try {
-          handler();
-        } catch (err) {
-          _chunkEJVBH5VFcjs.logger.call(void 0, ).error({
-            msg: "error in open handler",
-            error: _chunkH4TB4X25cjs.stringifyError.call(void 0, err)
-          });
-        }
-      }
-    }
-    if ((status === "disconnected" || status === "idle") && prevStatus === "connected") {
-      for (const handler of [...this.#closeHandlers]) {
-        try {
-          handler();
-        } catch (err) {
-          _chunkEJVBH5VFcjs.logger.call(void 0, ).error({
-            msg: "error in close handler",
-            error: _chunkH4TB4X25cjs.stringifyError.call(void 0, err)
-          });
-        }
-      }
-    }
-  }
-  #connectWithRetry() {
-    this.#setConnStatus("connecting");
-    _pretry2.default.call(void 0, this.#connectAndWait.bind(this), {
-      forever: true,
-      minTimeout: 250,
-      maxTimeout: 3e4,
-      onFailedAttempt: (error) => {
-        _chunkEJVBH5VFcjs.logger.call(void 0, ).warn({
-          msg: "failed to reconnect",
-          attempt: error.attemptNumber,
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-        });
-      },
-      // Cancel retry if aborted
-      signal: this.#abortController.signal
-    }).catch((err) => {
-      if (err.name === "AbortError") {
-        _chunkEJVBH5VFcjs.logger.call(void 0, ).info({ msg: "connection retry aborted" });
-      } else {
-        _chunkEJVBH5VFcjs.logger.call(void 0, ).error({
-          msg: "unexpected error in connection retry",
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, err)
-        });
-      }
-    });
-  }
-  async #connectAndWait() {
-    try {
-      if (this.#onOpenPromise)
-        throw new Error("#onOpenPromise already defined");
-      this.#onOpenPromise = _chunkH4TB4X25cjs.promiseWithResolvers.call(void 0, );
-      await this.#connectWebSocket();
-      await this.#onOpenPromise.promise;
-    } finally {
-      this.#onOpenPromise = void 0;
-    }
-  }
-  async #connectWebSocket() {
-    const { actorId } = await queryActor(
-      void 0,
-      this.#actorQuery,
-      this.#driver
-    );
-    this.#actorId = actorId;
-    const ws = await this.#driver.openWebSocket(
-      _chunkRZW2DNNDcjs.PATH_CONNECT,
-      actorId,
-      this.#encoding,
-      this.#params
-    );
-    _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({
-      msg: "opened websocket",
-      connId: this.#connId,
-      readyState: ws.readyState,
-      messageQueueLength: this.#messageQueue.length
-    });
-    this.#websocket = ws;
-    ws.addEventListener("open", () => {
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({
-        msg: "client websocket open",
-        connId: this.#connId
-      });
-    });
-    ws.addEventListener("message", async (ev) => {
-      try {
-        await this.#handleOnMessage(ev.data);
-      } catch (err) {
-        _chunkEJVBH5VFcjs.logger.call(void 0, ).error({
-          msg: "error in websocket message handler",
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, err)
-        });
-      }
-    });
-    ws.addEventListener("close", async (ev) => {
-      try {
-        await this.#handleOnClose(ev);
-      } catch (err) {
-        _chunkEJVBH5VFcjs.logger.call(void 0, ).error({
-          msg: "error in websocket close handler",
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, err)
-        });
-      }
-    });
-    ws.addEventListener("error", (_ev) => {
-      try {
-        this.#handleOnError();
-      } catch (err) {
-        _chunkEJVBH5VFcjs.logger.call(void 0, ).error({
-          msg: "error in websocket error handler",
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, err)
-        });
-      }
-    });
-  }
-  /** Called by the onopen event from drivers. */
-  #handleOnOpen() {
-    if (this.#disposed) {
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({
-        msg: "handleOnOpen called after dispose, closing websocket"
-      });
-      if (this.#websocket) {
-        this.#websocket.close(1e3, "Disposed");
-        this.#websocket = void 0;
-      }
-      return;
-    }
-    _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({
-      msg: "socket open",
-      messageQueueLength: this.#messageQueue.length,
-      connId: this.#connId
-    });
-    this.#setConnStatus("connected");
-    if (this.#onOpenPromise) {
-      this.#onOpenPromise.resolve(void 0);
-    } else {
-      _chunkEJVBH5VFcjs.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 = [];
-    _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({
-      msg: "flushing message queue",
-      queueLength: queue.length
-    });
-    for (const msg of queue) {
-      this.#sendMessage(msg);
-    }
-  }
-  /** Called by the onmessage event from drivers. */
-  async #handleOnMessage(data) {
-    _chunkEJVBH5VFcjs.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);
-    _chunkEJVBH5VFcjs.logger.call(void 0, ).trace(
-      _chunkH4TB4X25cjs.getLogMessage.call(void 0, ) ? {
-        msg: "parsed message",
-        message: _chunkRZW2DNNDcjs.jsonStringifyCompat.call(void 0, response).substring(0, 100) + "..."
-      } : { msg: "parsed message" }
-    );
-    if (response.body.tag === "Init") {
-      this.#actorId = response.body.val.actorId;
-      this.#connId = response.body.val.connectionId;
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).trace({
-        msg: "received init message",
-        actorId: this.#actorId,
-        connId: this.#connId
-      });
-      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));
-        _chunkEJVBH5VFcjs.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 {
-        _chunkEJVBH5VFcjs.logger.call(void 0, ).warn({
-          msg: "connection error",
-          group,
-          code,
-          message,
-          metadata
-        });
-        let errorToThrow = new ActorError(
-          group,
-          code,
-          message,
-          metadata
-        );
-        if (isSchedulingError(group, code) && this.#actorId) {
-          const schedulingError = await checkForSchedulingError(
-            group,
-            code,
-            this.#actorId,
-            this.#actorQuery,
-            this.#driver
-          );
-          if (schedulingError) {
-            errorToThrow = schedulingError;
-          }
-        }
-        if (this.#onOpenPromise) {
-          this.#onOpenPromise.reject(errorToThrow);
-        }
-        for (const [id, inFlight] of this.#actionsInFlight.entries()) {
-          inFlight.reject(errorToThrow);
-          this.#actionsInFlight.delete(id);
-        }
-        this.#dispatchActorError(errorToThrow);
-      }
-    } else if (response.body.tag === "ActionResponse") {
-      const { id: actionId } = response.body.val;
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({
-        msg: "received action response",
-        actionId: Number(actionId),
-        inFlightCount: this.#actionsInFlight.size,
-        inFlightIds: Array.from(this.#actionsInFlight.keys())
-      });
-      const inFlight = this.#takeActionInFlight(Number(actionId));
-      _chunkEJVBH5VFcjs.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") {
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).trace({
-        msg: "received event",
-        name: response.body.val.name
-      });
-      this.#dispatchEvent(response.body.val);
-    } else {
-      _chunkH4TB4X25cjs.assertUnreachable.call(void 0, response.body);
-    }
-  }
-  /** Called by the onclose event from drivers. */
-  async #handleOnClose(event) {
-    const closeEvent = event;
-    const wasClean = closeEvent.wasClean;
-    const wasConnected = this.#connStatus === "connected";
-    _chunkEJVBH5VFcjs.logger.call(void 0, ).info({
-      msg: "socket closed",
-      code: closeEvent.code,
-      reason: closeEvent.reason,
-      wasClean,
-      disposed: this.#disposed,
-      connId: this.#connId
-    });
-    this.#websocket = void 0;
-    if (this.#disposed) {
-      this.#rejectPendingPromises(new ActorConnDisposed(), true);
-    } else {
-      this.#setConnStatus("disconnected");
-      let error;
-      const reason = closeEvent.reason || "";
-      const parsed = parseWebSocketCloseReason(reason);
-      if (parsed) {
-        const { group, code } = parsed;
-        if (isSchedulingError(group, code) && this.#actorId) {
-          const schedulingError = await checkForSchedulingError(
-            group,
-            code,
-            this.#actorId,
-            this.#actorQuery,
-            this.#driver
-          );
-          if (schedulingError) {
-            error = schedulingError;
-          } else {
-            error = new ActorError(
-              group,
-              code,
-              `Connection closed: ${reason}`,
-              void 0
-            );
-          }
-        } else {
-          error = new ActorError(
-            group,
-            code,
-            `Connection closed: ${reason}`,
-            void 0
-          );
-        }
-      } else {
-        error = new Error(
-          `${wasClean ? "Connection closed" : "Connection lost"} (code: ${closeEvent.code}, reason: ${reason})`
-        );
-      }
-      this.#rejectPendingPromises(error, false);
-      if (error instanceof ActorError) {
-        this.#dispatchActorError(error);
-      }
-      if (wasConnected) {
-        _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({
-          msg: "triggering reconnect",
-          connId: this.#connId
-        });
-        this.#connectWithRetry();
-      }
-    }
-  }
-  #rejectPendingPromises(error, suppressUnhandled) {
-    if (this.#onOpenPromise) {
-      if (suppressUnhandled) {
-        this.#onOpenPromise.promise.catch(() => {
-        });
-      }
-      this.#onOpenPromise.reject(error);
-    }
-    for (const actionInfo of this.#actionsInFlight.values()) {
-      actionInfo.reject(error);
-    }
-    this.#actionsInFlight.clear();
-  }
-  /** Called by the onerror event from drivers. */
-  #handleOnError() {
-    if (this.#disposed) return;
-    _chunkEJVBH5VFcjs.logger.call(void 0, ).warn("socket error");
-  }
-  #takeActionInFlight(id) {
-    const inFlight = this.#actionsInFlight.get(id);
-    if (!inFlight) {
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).error({
-        msg: "action not found in in-flight map",
-        lookupId: id,
-        inFlightCount: this.#actionsInFlight.size,
-        inFlightIds: Array.from(this.#actionsInFlight.keys()),
-        inFlightActions: Array.from(
-          this.#actionsInFlight.entries()
-        ).map(([id2, action]) => ({
-          id: id2,
-          name: action.name
-        }))
-      });
-      throw new InternalError2(`No in flight response for ${id}`);
-    }
-    this.#actionsInFlight.delete(id);
-    _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({
-      msg: "removed action from in-flight map",
-      actionId: id,
-      actionName: inFlight.name,
-      inFlightCount: this.#actionsInFlight.size
-    });
-    return inFlight;
-  }
-  #dispatchEvent(event) {
-    const { name, args } = event;
-    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) {
-        _chunkEJVBH5VFcjs.logger.call(void 0, ).error({
-          msg: "error in connection error handler",
-          error: _chunkH4TB4X25cjs.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);
-    };
-  }
-  /**
-   * Returns the current connection status.
-   *
-   * @returns {ActorConnStatus} - The current connection status.
-   */
-  get connStatus() {
-    return this.#connStatus;
-  }
-  /**
-   * Returns whether the connection is currently open.
-   *
-   * @deprecated Use `connStatus` instead.
-   * @returns {boolean} - True if the connection is open, false otherwise.
-   */
-  get isConnected() {
-    return this.#connStatus === "connected";
-  }
-  /**
-   * Subscribes to connection open events.
-   *
-   * This is called when the WebSocket connection is established and the Init message is received.
-   *
-   * @param {ConnectionStateCallback} callback - The callback function to execute when the connection opens.
-   * @returns {() => void} - A function to unsubscribe from the open handler.
-   */
-  onOpen(callback) {
-    this.#openHandlers.add(callback);
-    return () => {
-      this.#openHandlers.delete(callback);
-    };
-  }
-  /**
-   * Subscribes to connection close events.
-   *
-   * This is called when the WebSocket connection is closed. The connection will automatically
-   * attempt to reconnect unless disposed.
-   *
-   * @param {ConnectionStateCallback} callback - The callback function to execute when the connection closes.
-   * @returns {() => void} - A function to unsubscribe from the close handler.
-   */
-  onClose(callback) {
-    this.#closeHandlers.add(callback);
-    return () => {
-      this.#closeHandlers.delete(callback);
-    };
-  }
-  /**
-   * Subscribes to connection status changes.
-   *
-   * This is called whenever the connection status changes between Disconnected, Connecting, and Connected.
-   *
-   * @param {StatusChangeCallback} callback - The callback function to execute when the status changes.
-   * @returns {() => void} - A function to unsubscribe from the status change handler.
-   */
-  onStatusChange(callback) {
-    this.#statusChangeHandlers.add(callback);
-    return () => {
-      this.#statusChangeHandlers.delete(callback);
-    };
-  }
-  #sendMessage(message, opts) {
-    var _a, _b;
-    if (this.#disposed) {
-      if (opts == null ? void 0 : opts.ephemeral) {
-        return;
-      } else {
-        throw new ActorConnDisposed();
-      }
-    }
-    let queueMessage = false;
-    if (this.#websocket) {
-      const readyState = this.#websocket.readyState;
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({
-        msg: "websocket send attempt",
-        readyState,
-        readyStateString: readyState === 0 ? "CONNECTING" : readyState === 1 ? "OPEN" : readyState === 2 ? "CLOSING" : "CLOSED",
-        connId: this.#connId,
-        messageType: message.body.tag,
-        actionName: (_a = message.body.val) == null ? void 0 : _a.name
-      });
-      if (readyState === 1) {
-        try {
-          const messageSerialized = _chunkRZW2DNNDcjs.serializeWithEncoding.call(void 0, 
-            this.#encoding,
-            message,
-            _chunkRZW2DNNDcjs.TO_SERVER_VERSIONED,
-            _chunkRZW2DNNDcjs.CURRENT_VERSION,
-            _chunkRZW2DNNDcjs.ToServerSchema,
-            // JSON: args is the raw value
-            (msg) => msg,
-            // BARE: args needs to be CBOR-encoded to ArrayBuffer
-            (msg) => {
-              if (msg.body.tag === "ActionRequest") {
-                return {
-                  body: {
-                    tag: "ActionRequest",
-                    val: {
-                      id: msg.body.val.id,
-                      name: msg.body.val.name,
-                      args: _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, 
-                        cbor3.encode(msg.body.val.args)
-                      )
-                    }
-                  }
-                };
-              } else {
-                return msg;
-              }
-            }
-          );
-          this.#websocket.send(messageSerialized);
-          _chunkEJVBH5VFcjs.logger.call(void 0, ).trace({
-            msg: "sent websocket message",
-            len: messageLength(messageSerialized)
-          });
-        } catch (error) {
-          _chunkEJVBH5VFcjs.logger.call(void 0, ).warn({
-            msg: "failed to send message, added to queue",
-            error,
-            connId: this.#connId
-          });
-          queueMessage = true;
-        }
-      } else {
-        _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({
-          msg: "websocket not open, queueing message",
-          readyState
-        });
-        queueMessage = true;
-      }
-    } else {
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({ msg: "no websocket, queueing message" });
-      queueMessage = true;
-    }
-    if (!(opts == null ? void 0 : opts.ephemeral) && queueMessage) {
-      this.#messageQueue.push(message);
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({
-        msg: "queued connection message",
-        queueLength: this.#messageQueue.length,
-        connId: this.#connId,
-        messageType: message.body.tag,
-        actionName: (_b = message.body.val) == null ? void 0 : _b.name
-      });
-    }
-  }
-  async #parseMessage(data) {
-    _invariant2.default.call(void 0, this.#websocket, "websocket must be defined");
-    const buffer = await _chunkRZW2DNNDcjs.inputDataToBuffer.call(void 0, data);
-    return _chunkRZW2DNNDcjs.deserializeWithEncoding.call(void 0, 
-      this.#encoding,
-      buffer,
-      _chunkRZW2DNNDcjs.TO_CLIENT_VERSIONED,
-      _chunkRZW2DNNDcjs.ToClientSchema,
-      // JSON: values are already the correct type
-      (msg) => msg,
-      // BARE: need to decode ArrayBuffer fields back to unknown
-      (msg) => {
-        if (msg.body.tag === "Error") {
-          return {
-            body: {
-              tag: "Error",
-              val: {
-                group: msg.body.val.group,
-                code: msg.body.val.code,
-                message: msg.body.val.message,
-                metadata: msg.body.val.metadata ? cbor3.decode(
-                  new Uint8Array(
-                    msg.body.val.metadata
-                  )
-                ) : null,
-                actionId: msg.body.val.actionId
-              }
-            }
-          };
-        } else if (msg.body.tag === "ActionResponse") {
-          return {
-            body: {
-              tag: "ActionResponse",
-              val: {
-                id: msg.body.val.id,
-                output: cbor3.decode(
-                  new Uint8Array(msg.body.val.output)
-                )
-              }
-            }
-          };
-        } else if (msg.body.tag === "Event") {
-          return {
-            body: {
-              tag: "Event",
-              val: {
-                name: msg.body.val.name,
-                args: cbor3.decode(
-                  new Uint8Array(msg.body.val.args)
-                )
-              }
-            }
-          };
-        } else {
-          return msg;
-        }
-      }
-    );
-  }
-  /**
-   * Get the actor ID (for testing purposes).
-   * @internal
-   */
-  get actorId() {
-    return this.#actorId;
-  }
-  /**
-   * Get the connection ID (for testing purposes).
-   * @internal
-   */
-  get connId() {
-    return this.#connId;
-  }
-  /**
-   * Get the connection ID (for testing purposes).
-   * @internal
-   * @deprecated Use `connId` instead.
-   */
-  get connectionId() {
-    return this.#connId;
-  }
-  /**
-   * Disconnects from the actor.
-   *
-   * @returns {Promise<void>} A promise that resolves when the socket is gracefully closed.
-   */
-  async dispose() {
-    if (this.#disposed) {
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).warn({ msg: "connection already disconnected" });
-      return;
-    }
-    this.#disposed = true;
-    _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({ msg: "disposing actor conn" });
-    this.#setConnStatus("idle");
-    clearInterval(this.#keepNodeAliveInterval);
-    this.#abortController.abort();
-    this.#client[ACTOR_CONNS_SYMBOL].delete(this);
-    if (this.#websocket) {
-      const ws = this.#websocket;
-      if (ws.readyState !== 2 && ws.readyState !== 3) {
-        const { promise, resolve } = _chunkH4TB4X25cjs.promiseWithResolvers.call(void 0, );
-        ws.addEventListener("close", () => resolve(void 0));
-        ws.close(1e3, "Disposed");
-        await promise;
-      }
-    } else {
-      this.#rejectPendingPromises(new ActorConnDisposed(), true);
-    }
-    this.#websocket = void 0;
-  }
-  #sendSubscription(eventName, subscribe) {
-    this.#sendMessage(
-      {
-        body: {
-          tag: "SubscriptionRequest",
-          val: {
-            eventName,
-            subscribe
-          }
-        }
-      },
-      { ephemeral: true }
-    );
-  }
-};
-
-// 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);
-    initHeaders.forEach((value, key) => {
-      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);
-    _chunkEJVBH5VFcjs.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/request/${normalizedPath}`);
-    const proxyRequestHeaders = new Headers(mergedInit.headers);
-    if (params) {
-      proxyRequestHeaders.set(_chunkRZW2DNNDcjs.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 } = _chunkH4TB4X25cjs.deconstructError.call(void 0, 
-      err,
-      _chunkEJVBH5VFcjs.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);
-  _chunkEJVBH5VFcjs.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 = `${_chunkRZW2DNNDcjs.PATH_WEBSOCKET_PREFIX}${pathPortion}${queryPortion}`;
-  _chunkEJVBH5VFcjs.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/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) {
-    let actorId;
-    try {
-      const result = await queryActor(
-        void 0,
-        this.#actorQuery,
-        this.#driver
-      );
-      actorId = result.actorId;
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).debug({ msg: "found actor for action", actorId });
-      _invariant2.default.call(void 0, actorId, "Missing actor ID");
-      _chunkEJVBH5VFcjs.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: {
-          [_chunkRZW2DNNDcjs.HEADER_ENCODING]: this.#encoding,
-          ...this.#params !== void 0 ? { [_chunkRZW2DNNDcjs.HEADER_CONN_PARAMS]: JSON.stringify(this.#params) } : {}
-        },
-        body: opts.args,
-        encoding: this.#encoding,
-        customFetch: this.#driver.sendRequest.bind(
-          this.#driver,
-          actorId
-        ),
-        signal: opts == null ? void 0 : opts.signal,
-        requestVersion: _chunkRZW2DNNDcjs.CURRENT_VERSION,
-        requestVersionedDataHandler: _chunkRZW2DNNDcjs.HTTP_ACTION_REQUEST_VERSIONED,
-        responseVersion: _chunkRZW2DNNDcjs.CURRENT_VERSION,
-        responseVersionedDataHandler: _chunkRZW2DNNDcjs.HTTP_ACTION_RESPONSE_VERSIONED,
-        requestZodSchema: _chunkRZW2DNNDcjs.HttpActionRequestSchema,
-        responseZodSchema: _chunkRZW2DNNDcjs.HttpActionResponseSchema,
-        // JSON Request: args is the raw value
-        requestToJson: (args) => ({
-          args
-        }),
-        // BARE Request: args needs to be CBOR-encoded
-        requestToBare: (args) => ({
-          args: _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, cbor4.encode(args))
-        }),
-        // JSON Response: output is the raw value
-        responseFromJson: (json) => json.output,
-        // BARE Response: output is ArrayBuffer that needs CBOR-decoding
-        responseFromBare: (bare) => cbor4.decode(new Uint8Array(bare.output))
-      });
-      return responseData;
-    } catch (err) {
-      const { group, code, message, metadata } = _chunkH4TB4X25cjs.deconstructError.call(void 0, 
-        err,
-        _chunkEJVBH5VFcjs.logger.call(void 0, ),
-        {},
-        true
-      );
-      if (actorId && isSchedulingError(group, code)) {
-        const schedulingError = await checkForSchedulingError(
-          group,
-          code,
-          actorId,
-          this.#actorQuery,
-          this.#driver
-        );
-        if (schedulingError) {
-          throw schedulingError;
-        }
-      }
-      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() {
-    _chunkEJVBH5VFcjs.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.
-   */
-  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 {
-        _chunkRZW2DNNDcjs.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 {
-      _chunkRZW2DNNDcjs.assertUnreachable.call(void 0, this.#actorQuery);
-    }
-  }
-  /**
-   * Returns the raw URL for routing traffic to the actor.
-   */
-  async getGatewayUrl() {
-    const { actorId } = await queryActor(
-      void 0,
-      this.#actorQuery,
-      this.#driver
-    );
-    return await this.#driver.buildGatewayUrl(actorId);
-  }
-};
-
-// src/client/client.ts
-var ACTOR_CONNS_SYMBOL = Symbol("actorConns");
-var CREATE_ACTOR_CONN_PROXY = Symbol("createActorConnProxy");
-var ClientRaw = (_class2 = class {
-  #disposed = false;
-  __init2() {this[ACTOR_CONNS_SYMBOL] = /* @__PURE__ */ new Set()}
-  #driver;
-  #encodingKind;
-  /**
-   * Creates an instance of Client.
-   */
-  constructor(driver, encoding) {;_class2.prototype.__init2.call(this);
-    this.#driver = driver;
-    this.#encodingKind = _nullishCoalesce(encoding, () => ( "bare"));
-  }
-  /**
-   * 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) {
-    _chunkEJVBH5VFcjs.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 || [];
-    _chunkEJVBH5VFcjs.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 || [];
-    _chunkEJVBH5VFcjs.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
-      }
-    };
-    _chunkEJVBH5VFcjs.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
-    );
-    _chunkEJVBH5VFcjs.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) {
-      _chunkEJVBH5VFcjs.logger.call(void 0, ).warn({ msg: "client already disconnected" });
-      return;
-    }
-    this.#disposed = true;
-    _chunkEJVBH5VFcjs.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);
-  }
-}, _class2);
-function createClientWithDriver(driver, config = {}) {
-  const client = new ClientRaw(driver, config.encoding);
-  return new Proxy(client, {
-    get: (target, prop, receiver) => {
-      if (typeof prop === "symbol" || prop in target) {
-        const value = Reflect.get(target, prop, receiver);
-        if (typeof value === "function") {
-          return value.bind(target);
-        }
-        return value;
-      }
-      if (typeof prop === "string") {
-        return {
-          // Handle methods (stateless action)
-          get: (key, opts) => {
-            return target.get(prop, key, opts);
-          },
-          getOrCreate: (key, opts) => {
-            return target.getOrCreate(prop, key, opts);
-          },
-          getForId: (actorId, opts) => {
-            return target.getForId(prop, actorId, opts);
-          },
-          create: async (key, opts = {}) => {
-            return await target.create(prop, key, opts);
-          }
-        };
-      }
-      return void 0;
-    }
-  });
-}
-function createActorProxy(handle) {
-  const methodCache = /* @__PURE__ */ new Map();
-  return new Proxy(handle, {
-    get(target, prop, receiver) {
-      if (typeof prop === "symbol") {
-        return Reflect.get(target, prop, receiver);
-      }
-      if (prop === "constructor" || prop in target) {
-        const value = Reflect.get(target, prop, target);
-        if (typeof value === "function") {
-          return value.bind(target);
-        }
-        return value;
-      }
-      if (typeof prop === "string") {
-        if (prop === "then") return void 0;
-        let method = methodCache.get(prop);
-        if (!method) {
-          method = (...args) => target.action({ name: prop, args });
-          methodCache.set(prop, method);
-        }
-        return method;
-      }
-    },
-    // Support for 'in' operator
-    has(target, prop) {
-      if (typeof prop === "string") {
-        return true;
-      }
-      return Reflect.has(target, prop);
-    },
-    // Support instanceof checks
-    getPrototypeOf(target) {
-      return Reflect.getPrototypeOf(target);
-    },
-    // Prevent property enumeration of non-existent action methods
-    ownKeys(target) {
-      return Reflect.ownKeys(target);
-    },
-    // Support proper property descriptors
-    getOwnPropertyDescriptor(target, prop) {
-      const targetDescriptor = Reflect.getOwnPropertyDescriptor(
-        target,
-        prop
-      );
-      if (targetDescriptor) {
-        return targetDescriptor;
-      }
-      if (typeof prop === "string") {
-        return {
-          configurable: true,
-          enumerable: false,
-          writable: false,
-          value: (...args) => target.action({ name: prop, args })
-        };
-      }
-      return void 0;
-    }
-  });
-}
-
-// src/client/config.ts
-
-function getDefaultEndpoint() {
-  var _a;
-  if (typeof window !== "undefined" && ((_a = window.location) == null ? void 0 : _a.origin)) {
-    return `${window.location.origin}/api/rivet`;
-  }
-  return "http://127.0.0.1:6420";
-}
-var ClientConfigSchemaBase = _zod2.default.object({
-  /**
-   * Endpoint to connect to for Rivet Engine or RivetKit manager API.
-   *
-   * Supports URL auth syntax for namespace and token:
-   * - `https://namespace:token@api.rivet.dev`
-   * - `https://namespace@api.rivet.dev`
-   *
-   * Can also be set via RIVET_ENDPOINT environment variables.
-   *
-   * Defaults to current origin + /api/rivet in browser, or 127.0.0.1:6420 server-side.
-   */
-  endpoint: _zod2.default.string().optional().transform(
-    (val) => _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(val, () => ( _chunkH4TB4X25cjs.getRivetEngine.call(void 0, ))), () => ( _chunkH4TB4X25cjs.getRivetEndpoint.call(void 0, ))), () => ( getDefaultEndpoint()))
-  ),
-  /** Token to use to authenticate with the API. */
-  token: _zod2.default.string().optional().transform((val) => _nullishCoalesce(val, () => ( _chunkH4TB4X25cjs.getRivetToken.call(void 0, )))),
-  /** Namespace to connect to. */
-  namespace: _zod2.default.string().optional().transform((val) => _nullishCoalesce(val, () => ( _chunkH4TB4X25cjs.getRivetNamespace.call(void 0, )))),
-  /** Name of the runner. This is used to group together runners in to different pools. */
-  runnerName: _zod2.default.string().default(() => _nullishCoalesce(_chunkH4TB4X25cjs.getRivetRunner.call(void 0, ), () => ( "default"))),
-  encoding: _chunkRZW2DNNDcjs.EncodingSchema.default("bare"),
-  headers: _zod2.default.record(_zod2.default.string(), _zod2.default.string()).optional().default(() => ({})),
-  // See RunConfig.getUpgradeWebSocket
-  //
-  // This is required in the client config in order to support
-  // `proxyWebSocket`
-  getUpgradeWebSocket: _zod2.default.custom().optional(),
-  /** Whether to automatically perform health checks when the client is created. */
-  disableMetadataLookup: _zod2.default.boolean().optional().default(false),
-  /** Whether to enable RivetKit Devtools integration. */
-  devtools: _zod2.default.boolean().default(
-    () => {
-      var _a, _b;
-      return typeof window !== "undefined" && (((_a = window == null ? void 0 : window.location) == null ? void 0 : _a.hostname) === "127.0.0.1" || ((_b = window.location) == null ? void 0 : _b.hostname) === "localhost");
-    }
-  )
-});
-var ClientConfigSchema = ClientConfigSchemaBase.transform(
-  (config, ctx) => transformClientConfig(config, ctx)
-);
-function transformClientConfig(config, ctx) {
-  const parsedEndpoint = _chunkRZW2DNNDcjs.tryParseEndpoint.call(void 0, ctx, {
-    endpoint: config.endpoint,
-    path: ["endpoint"],
-    namespace: config.namespace,
-    token: config.token
-  });
-  return {
-    ...config,
-    endpoint: parsedEndpoint == null ? void 0 : parsedEndpoint.endpoint,
-    namespace: _nullishCoalesce(_nullishCoalesce((parsedEndpoint == null ? void 0 : parsedEndpoint.namespace), () => ( config.namespace)), () => ( "default")),
-    token: _nullishCoalesce((parsedEndpoint == null ? void 0 : parsedEndpoint.token), () => ( config.token))
-  };
-}
-function convertRegistryConfigToClientConfig(config) {
-  var _a, _b;
-  return {
-    endpoint: config.endpoint,
-    token: config.token,
-    namespace: config.namespace,
-    runnerName: config.runner.runnerName,
-    headers: config.headers,
-    encoding: "bare",
-    getUpgradeWebSocket: void 0,
-    // We don't need health checks for internal clients
-    disableMetadataLookup: true,
-    devtools: typeof window !== "undefined" && (((_a = window == null ? void 0 : window.location) == null ? void 0 : _a.hostname) === "127.0.0.1" || ((_b = window == null ? void 0 : window.location) == null ? void 0 : _b.hostname) === "localhost")
-  };
-}
-
-// src/actor/instance/mod.ts
-
-
-// src/inspector/actor-inspector.ts
-
-var _nanoevents = require('nanoevents');
-var ActorInspector = (_class3 = class {
-  constructor(actor) {;_class3.prototype.__init3.call(this);
-    this.actor = actor;
-    this.emitter.on("eventFired", (event) => {
-      const commonParams = {
-        id: crypto.randomUUID(),
-        timestamp: BigInt(Date.now())
-      };
-      this.#lastEvents.push({
-        ...commonParams,
-        ...transformEvent(event)
-      });
-      if (this.#lastEvents.length > 100) {
-        this.#lastEvents = this.#lastEvents.slice(-100);
-      }
-    });
-  }
-  __init3() {this.emitter = _nanoevents.createNanoEvents.call(void 0, )}
-  #lastEvents = [];
-  getLastEvents() {
-    return this.#lastEvents;
-  }
-  clearEvents() {
-    this.#lastEvents = [];
-    this.emitter.emit("eventsChanged");
-  }
-  // actor accessor methods
-  isDatabaseEnabled() {
-    try {
-      return this.actor.db !== void 0;
-    } catch (e2) {
-      return false;
-    }
-  }
-  isStateEnabled() {
-    return this.actor.stateEnabled;
-  }
-  getState() {
-    if (!this.actor.stateEnabled) {
-      throw new (0, _chunk2XQS746Mcjs.StateNotEnabled)();
-    }
-    return _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, 
-      cbor5.encode(this.actor.stateManager.persistRaw.state)
-    );
-  }
-  getRpcs() {
-    return this.actor.actions;
-  }
-  getConnections() {
-    return Array.from(
-      this.actor.connectionManager.connections.entries()
-    ).map(([id, conn]) => {
-      var _a, _b;
-      const connStateManager = conn[_chunkRZW2DNNDcjs.CONN_STATE_MANAGER_SYMBOL];
-      return {
-        type: (_a = conn[_chunkRZW2DNNDcjs.CONN_DRIVER_SYMBOL]) == null ? void 0 : _a.type,
-        id,
-        details: _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, 
-          cbor5.encode({
-            type: (_b = conn[_chunkRZW2DNNDcjs.CONN_DRIVER_SYMBOL]) == null ? void 0 : _b.type,
-            params: conn.params,
-            stateEnabled: connStateManager.stateEnabled,
-            state: connStateManager.stateEnabled ? connStateManager.state : void 0,
-            subscriptions: conn.subscriptions.size,
-            isHibernatable: conn.isHibernatable
-            // TODO: Include underlying hibernatable metadata +
-            // path + headers
-          })
-        )
-      };
-    });
-  }
-  async setState(state) {
-    if (!this.actor.stateEnabled) {
-      throw new (0, _chunk2XQS746Mcjs.StateNotEnabled)();
-    }
-    this.actor.stateManager.state = cbor5.decode(Buffer.from(state));
-    await this.actor.stateManager.saveState({ immediate: true });
-  }
-  async executeAction(name, params) {
-    const conn = await this.actor.connectionManager.prepareAndConnectConn(
-      _chunkRZW2DNNDcjs.createHttpDriver.call(void 0, ),
-      // TODO: This may cause issues
-      void 0,
-      void 0,
-      void 0,
-      void 0
-    );
-    try {
-      return _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, 
-        cbor5.encode(
-          await this.actor.executeAction(
-            new (0, _chunkRZW2DNNDcjs.ActionContext)(this.actor, conn),
-            name,
-            cbor5.decode(Buffer.from(params))
-          )
-        )
-      );
-    } finally {
-      conn.disconnect();
-    }
-  }
-}, _class3);
-function transformEvent(event) {
-  if (event.type === "action") {
-    return {
-      body: {
-        tag: "ActionEvent",
-        val: {
-          name: event.name,
-          args: _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, cbor5.encode(event.args)),
-          connId: event.connId
-        }
-      }
-    };
-  } else if (event.type === "subscribe") {
-    return {
-      body: {
-        tag: "SubscribeEvent",
-        val: {
-          eventName: event.eventName,
-          connId: event.connId
-        }
-      }
-    };
-  } else if (event.type === "unsubscribe") {
-    return {
-      body: {
-        tag: "UnSubscribeEvent",
-        val: {
-          eventName: event.eventName,
-          connId: event.connId
-        }
-      }
-    };
-  } else if (event.type === "event") {
-    return {
-      body: {
-        tag: "FiredEvent",
-        val: {
-          eventName: event.eventName,
-          args: _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, cbor5.encode(event.args)),
-          connId: event.connId
-        }
-      }
-    };
-  } else if (event.type === "broadcast") {
-    return {
-      body: {
-        tag: "BroadcastEvent",
-        val: {
-          eventName: event.eventName,
-          args: _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, cbor5.encode(event.args))
-        }
-      }
-    };
-  } else {
-    _chunkH4TB4X25cjs.assertUnreachable.call(void 0, event);
-  }
-}
-
-// src/actor/conn/persisted.ts
-
-function convertConnToBarePersistedConn(persist) {
-  return {
-    id: persist.id,
-    parameters: _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, cbor6.encode(persist.parameters)),
-    state: _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, cbor6.encode(persist.state)),
-    subscriptions: persist.subscriptions.map((sub) => ({
-      eventName: sub.eventName
-    })),
-    gatewayId: persist.gatewayId,
-    requestId: persist.requestId,
-    serverMessageIndex: persist.serverMessageIndex,
-    clientMessageIndex: persist.clientMessageIndex,
-    requestPath: persist.requestPath,
-    requestHeaders: new Map(Object.entries(persist.requestHeaders))
-  };
-}
-function convertConnFromBarePersistedConn(bareData) {
-  return {
-    id: bareData.id,
-    parameters: cbor6.decode(new Uint8Array(bareData.parameters)),
-    state: cbor6.decode(new Uint8Array(bareData.state)),
-    subscriptions: bareData.subscriptions.map((sub) => ({
-      eventName: sub.eventName
-    })),
-    gatewayId: bareData.gatewayId,
-    requestId: bareData.requestId,
-    serverMessageIndex: bareData.serverMessageIndex,
-    clientMessageIndex: bareData.clientMessageIndex,
-    requestPath: bareData.requestPath,
-    requestHeaders: Object.fromEntries(bareData.requestHeaders)
-  };
-}
-
-// 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/connection-manager.ts
-
-var ConnectionManager = class {
-  #actor;
-  #connections = /* @__PURE__ */ new Map();
-  /** Connections that have had their state changed and need to be persisted. */
-  #connsWithPersistChanged = /* @__PURE__ */ new Set();
-  constructor(actor) {
-    this.#actor = actor;
-  }
-  get connections() {
-    return this.#connections;
-  }
-  getConnForId(id) {
-    return this.#connections.get(id);
-  }
-  get connsWithPersistChanged() {
-    return this.#connsWithPersistChanged;
-  }
-  clearConnWithPersistChanged() {
-    this.#connsWithPersistChanged.clear();
-  }
-  markConnWithPersistChanged(conn) {
-    _invariant2.default.call(void 0, 
-      conn.isHibernatable,
-      "cannot mark non-hibernatable conn for persist"
-    );
-    this.#actor.rLog.debug({
-      msg: "marked connection as changed",
-      connId: conn.id,
-      totalChanged: this.#connsWithPersistChanged.size
-    });
-    this.#connsWithPersistChanged.add(conn.id);
-    this.#actor.stateManager.savePersistThrottled();
-  }
-  // MARK: - Connection Lifecycle
-  /**
-   * Handles pre-connection logic (i.e. auth & create state) before actually connecting the connection.
-   */
-  async prepareConn(driver, params, request, requestPath, requestHeaders, isHibernatable, isRestoringHibernatable) {
-    this.#actor.assertReady();
-    if (isRestoringHibernatable) {
-      return this.#reconnectHibernatableConn(driver);
-    }
-    if (this.#actor.config.onBeforeConnect) {
-      const ctx = new (0, _chunkRZW2DNNDcjs.BeforeConnectContext)(this.#actor, request);
-      await this.#actor.config.onBeforeConnect(ctx, params);
-    }
-    let connState;
-    if (this.#actor.connStateEnabled) {
-      connState = await this.#createConnState(params, request);
-    }
-    let connData;
-    if (isHibernatable) {
-      const hibernatable = driver.hibernatable;
-      _invariant2.default.call(void 0, hibernatable, "must have hibernatable");
-      _invariant2.default.call(void 0, requestPath, "missing requestPath for hibernatable ws");
-      _invariant2.default.call(void 0, 
-        requestHeaders,
-        "missing requestHeaders for hibernatable ws"
-      );
-      connData = {
-        hibernatable: {
-          id: crypto.randomUUID(),
-          parameters: params,
-          state: connState,
-          subscriptions: [],
-          gatewayId: hibernatable.gatewayId,
-          requestId: hibernatable.requestId,
-          clientMessageIndex: 0,
-          // First message index will be 1, so we start at 0
-          serverMessageIndex: 0,
-          requestPath,
-          requestHeaders
-        }
-      };
-    } else {
-      connData = {
-        ephemeral: {
-          id: crypto.randomUUID(),
-          parameters: params,
-          state: connState
-        }
-      };
-    }
-    const conn = new (0, _chunkRZW2DNNDcjs.Conn)(this.#actor, connData);
-    conn[_chunkRZW2DNNDcjs.CONN_DRIVER_SYMBOL] = driver;
-    return conn;
-  }
-  /**
-   * Adds a connection form prepareConn to the actor and calls onConnect.
-   *
-   * This method is intentionally not async since it needs to be called in
-   * `onOpen` for WebSockets. If this is async, the order of open events will
-   * be messed up and cause race conditions that can drop WebSocket messages.
-   * So all async work in prepareConn.
-   */
-  connectConn(conn) {
-    _invariant2.default.call(void 0, !this.#connections.has(conn.id), "conn already connected");
-    this.#connections.set(conn.id, conn);
-    if (this.#actor.driver.onCreateConn) {
-      this.#actor.driver.onCreateConn(conn);
-    }
-    if (conn.isHibernatable) {
-      this.markConnWithPersistChanged(conn);
-    }
-    this.#callOnConnect(conn);
-    this.#actor.inspector.emitter.emit("connectionsUpdated");
-    this.#actor.resetSleepTimer();
-    conn[_chunkRZW2DNNDcjs.CONN_CONNECTED_SYMBOL] = true;
-    if (conn[_chunkRZW2DNNDcjs.CONN_SPEAKS_RIVETKIT_SYMBOL]) {
-      const initData = { actorId: this.#actor.id, connectionId: conn.id };
-      conn[_chunkRZW2DNNDcjs.CONN_SEND_MESSAGE_SYMBOL](
-        new (0, _chunkRZW2DNNDcjs.CachedSerializer)(
-          initData,
-          _chunkRZW2DNNDcjs.TO_CLIENT_VERSIONED,
-          _chunkRZW2DNNDcjs.CURRENT_VERSION,
-          _chunkRZW2DNNDcjs.ToClientSchema,
-          // JSON: identity conversion (no nested data to encode)
-          (value) => ({
-            body: {
-              tag: "Init",
-              val: value
-            }
-          }),
-          // BARE/CBOR: identity conversion (no nested data to encode)
-          (value) => ({
-            body: {
-              tag: "Init",
-              val: value
-            }
-          })
-        )
-      );
-    }
-  }
-  #reconnectHibernatableConn(driver) {
-    _invariant2.default.call(void 0, driver.hibernatable, "missing requestIdBuf");
-    const existingConn = this.findHibernatableConn(
-      driver.hibernatable.gatewayId,
-      driver.hibernatable.requestId
-    );
-    _invariant2.default.call(void 0, 
-      existingConn,
-      "cannot find connection for restoring connection"
-    );
-    this.#actor.rLog.debug({
-      msg: "reconnecting hibernatable websocket connection",
-      connectionId: existingConn.id
-    });
-    if (existingConn[_chunkRZW2DNNDcjs.CONN_DRIVER_SYMBOL]) {
-      this.#disconnectExistingDriver(existingConn);
-    }
-    existingConn[_chunkRZW2DNNDcjs.CONN_DRIVER_SYMBOL] = driver;
-    this.#actor.resetSleepTimer();
-    existingConn[_chunkRZW2DNNDcjs.CONN_CONNECTED_SYMBOL] = true;
-    this.#actor.inspector.emitter.emit("connectionsUpdated");
-    return existingConn;
-  }
-  #disconnectExistingDriver(conn) {
-    const driver = conn[_chunkRZW2DNNDcjs.CONN_DRIVER_SYMBOL];
-    if (driver == null ? void 0 : driver.disconnect) {
-      driver.disconnect(
-        this.#actor,
-        conn,
-        "Reconnecting hibernatable websocket with new driver state"
-      );
-    }
-  }
-  /**
-   * Handle connection disconnection.
-   *
-   * This is called by `Conn.disconnect`. This should not call `Conn.disconnect.`
-   */
-  async connDisconnected(conn) {
-    this.#connections.delete(conn.id);
-    this.#actor.rLog.debug({ msg: "removed conn", connId: conn.id });
-    if (this.#actor.driver.onDestroyConn) {
-      this.#actor.driver.onDestroyConn(conn);
-    }
-    for (const eventName of [...conn.subscriptions.values()]) {
-      this.#actor.eventManager.removeSubscription(eventName, conn, true);
-    }
-    this.#actor.resetSleepTimer();
-    this.#actor.inspector.emitter.emit("connectionsUpdated");
-    if (this.#actor.config.onDisconnect) {
-      try {
-        const result = this.#actor.config.onDisconnect(
-          this.#actor.actorContext,
-          conn
-        );
-        if (result instanceof Promise) {
-          result.catch((error) => {
-            this.#actor.rLog.error({
-              msg: "error in `onDisconnect`",
-              error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-            });
-          });
-        }
-      } catch (error) {
-        this.#actor.rLog.error({
-          msg: "error in `onDisconnect`",
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-        });
-      }
-    }
-    this.#connsWithPersistChanged.delete(conn.id);
-    if (conn.isHibernatable) {
-      const key = _chunkRZW2DNNDcjs.makeConnKey.call(void 0, conn.id);
-      try {
-        await this.#actor.driver.kvBatchDelete(this.#actor.id, [key]);
-        this.#actor.rLog.debug({
-          msg: "removed connection from KV",
-          connId: conn.id
-        });
-      } catch (err) {
-        this.#actor.rLog.error({
-          msg: "kvBatchDelete failed for conn",
-          err: _chunkH4TB4X25cjs.stringifyError.call(void 0, err)
-        });
-      }
-    }
-  }
-  /**
-   * Utilify function for call sites that don't need a separate prepare and connect phase.
-   */
-  async prepareAndConnectConn(driver, params, request, requestPath, requestHeaders) {
-    const conn = await this.prepareConn(
-      driver,
-      params,
-      request,
-      requestPath,
-      requestHeaders,
-      false,
-      false
-    );
-    this.connectConn(conn);
-    return conn;
-  }
-  // MARK: - Persistence
-  /**
-   * Restores connections from persisted data during actor initialization.
-   */
-  restoreConnections(connections) {
-    for (const connPersist of connections) {
-      const conn = new (0, _chunkRZW2DNNDcjs.Conn)(this.#actor, {
-        hibernatable: connPersist
-      });
-      this.#connections.set(conn.id, conn);
-      if (this.#actor.driver.onCreateConn) {
-        this.#actor.driver.onCreateConn(conn);
-      }
-      for (const sub of connPersist.subscriptions) {
-        this.#actor.eventManager.addSubscription(
-          sub.eventName,
-          conn,
-          true
-        );
-      }
-    }
-  }
-  // MARK: - Private Helpers
-  findHibernatableConn(gatewayIdBuf, requestIdBuf) {
-    return Array.from(this.#connections.values()).find((conn) => {
-      const connStateManager = conn[_chunkRZW2DNNDcjs.CONN_STATE_MANAGER_SYMBOL];
-      const h = connStateManager.hibernatableDataRaw;
-      return h && _chunkH4TB4X25cjs.arrayBuffersEqual.call(void 0, h.gatewayId, gatewayIdBuf) && _chunkH4TB4X25cjs.arrayBuffersEqual.call(void 0, h.requestId, requestIdBuf);
-    });
-  }
-  async #createConnState(params, request) {
-    if ("createConnState" in this.#actor.config) {
-      const ctx = new (0, _chunkRZW2DNNDcjs.CreateConnStateContext)(this.#actor, request);
-      const dataOrPromise = this.#actor.config.createConnState(
-        ctx,
-        params
-      );
-      if (dataOrPromise instanceof Promise) {
-        return await _chunkRZW2DNNDcjs.deadline.call(void 0, 
-          dataOrPromise,
-          this.#actor.config.options.createConnStateTimeout
-        );
-      }
-      return dataOrPromise;
-    } else if ("connState" in this.#actor.config) {
-      return structuredClone(this.#actor.config.connState);
-    }
-    throw new Error(
-      "Could not create connection state from 'createConnState' or 'connState'"
-    );
-  }
-  #callOnConnect(conn) {
-    if (this.#actor.config.onConnect) {
-      try {
-        const ctx = new (0, _chunkRZW2DNNDcjs.ConnectContext)(this.#actor, conn);
-        const result = this.#actor.config.onConnect(ctx, conn);
-        if (result instanceof Promise) {
-          _chunkRZW2DNNDcjs.deadline.call(void 0, 
-            result,
-            this.#actor.config.options.onConnectTimeout
-          ).catch((error) => {
-            this.#actor.rLog.error({
-              msg: "error in `onConnect`, closing socket",
-              error
-            });
-            conn == null ? void 0 : conn.disconnect("`onConnect` failed");
-          });
-        }
-      } catch (error) {
-        this.#actor.rLog.error({
-          msg: "error in `onConnect`",
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-        });
-        conn == null ? void 0 : conn.disconnect("`onConnect` failed");
-      }
-    }
-  }
-};
-
-// src/actor/instance/event-manager.ts
-
-var EventManager = class {
-  #actor;
-  #subscriptionIndex = /* @__PURE__ */ new Map();
-  constructor(actor) {
-    this.#actor = actor;
-  }
-  // MARK: - Public API
-  /**
-   * Adds a subscription for a connection to an event.
-   *
-   * @param eventName - The name of the event to subscribe to
-   * @param connection - The connection subscribing to the event
-   * @param fromPersist - Whether this subscription is being restored from persistence
-   */
-  addSubscription(eventName, connection, fromPersist) {
-    if (connection.subscriptions.has(eventName)) {
-      this.#actor.rLog.debug({
-        msg: "connection already has subscription",
-        eventName,
-        connId: connection.id
-      });
-      return;
-    }
-    connection.subscriptions.add(eventName);
-    let subscribers = this.#subscriptionIndex.get(eventName);
-    if (!subscribers) {
-      subscribers = /* @__PURE__ */ new Set();
-      this.#subscriptionIndex.set(eventName, subscribers);
-    }
-    subscribers.add(connection);
-    if (!fromPersist) {
-      connection[_chunkRZW2DNNDcjs.CONN_STATE_MANAGER_SYMBOL].addSubscription({
-        eventName
-      });
-      this.#actor.stateManager.saveState({ immediate: true });
-    }
-    this.#actor.rLog.debug({
-      msg: "subscription added",
-      eventName,
-      connId: connection.id,
-      totalSubscribers: subscribers.size
-    });
-  }
-  /**
-   * Removes a subscription for a connection from an event.
-   *
-   * @param eventName - The name of the event to unsubscribe from
-   * @param connection - The connection unsubscribing from the event
-   * @param fromRemoveConn - Whether this is being called as part of connection removal
-   */
-  removeSubscription(eventName, connection, fromRemoveConn) {
-    if (!connection.subscriptions.has(eventName)) {
-      this.#actor.rLog.warn({
-        msg: "connection does not have subscription",
-        eventName,
-        connId: connection.id
-      });
-      return;
-    }
-    connection.subscriptions.delete(eventName);
-    const subscribers = this.#subscriptionIndex.get(eventName);
-    if (subscribers) {
-      subscribers.delete(connection);
-      if (subscribers.size === 0) {
-        this.#subscriptionIndex.delete(eventName);
-      }
-    }
-    if (!fromRemoveConn) {
-      const removed = connection[_chunkRZW2DNNDcjs.CONN_STATE_MANAGER_SYMBOL].removeSubscription({ eventName });
-      if (!removed) {
-        this.#actor.rLog.warn({
-          msg: "subscription does not exist in persist",
-          eventName,
-          connId: connection.id
-        });
-      }
-      this.#actor.stateManager.saveState({ immediate: true });
-    }
-    this.#actor.rLog.debug({
-      msg: "subscription removed",
-      eventName,
-      connId: connection.id,
-      remainingSubscribers: (subscribers == null ? void 0 : subscribers.size) || 0
-    });
-  }
-  /**
-   * Broadcasts an event to all subscribed connections.
-   *
-   * @param name - The name of the event to broadcast
-   * @param args - The arguments to send with the event
-   */
-  broadcast(name, ...args) {
-    this.#actor.assertReady();
-    this.#actor.inspector.emitter.emit("eventFired", {
-      type: "broadcast",
-      eventName: name,
-      args
-    });
-    const subscribers = this.#subscriptionIndex.get(name);
-    if (!subscribers || subscribers.size === 0) {
-      this.#actor.rLog.debug({
-        msg: "no subscribers for event",
-        eventName: name
-      });
-      return;
-    }
-    const eventData = { name, args };
-    const toClientSerializer = new (0, _chunkRZW2DNNDcjs.CachedSerializer)(
-      eventData,
-      _chunkRZW2DNNDcjs.TO_CLIENT_VERSIONED,
-      _chunkRZW2DNNDcjs.CURRENT_VERSION,
-      _chunkRZW2DNNDcjs.ToClientSchema,
-      // JSON: args is the raw value (array of arguments)
-      (value) => ({
-        body: {
-          tag: "Event",
-          val: {
-            name: value.name,
-            args: value.args
-          }
-        }
-      }),
-      // BARE/CBOR: args needs to be CBOR-encoded to ArrayBuffer
-      (value) => ({
-        body: {
-          tag: "Event",
-          val: {
-            name: value.name,
-            args: _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, cbor7.encode(value.args))
-          }
-        }
-      })
-    );
-    let sentCount = 0;
-    for (const connection of subscribers) {
-      if (connection[_chunkRZW2DNNDcjs.CONN_SPEAKS_RIVETKIT_SYMBOL]) {
-        try {
-          connection[_chunkRZW2DNNDcjs.CONN_SEND_MESSAGE_SYMBOL](toClientSerializer);
-          sentCount++;
-        } catch (error) {
-          if (error instanceof _chunk2XQS746Mcjs.OutgoingMessageTooLong) {
-            throw error;
-          }
-          this.#actor.rLog.error({
-            msg: "failed to send event to connection",
-            eventName: name,
-            connId: connection.id,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-    }
-    this.#actor.rLog.debug({
-      msg: "event broadcasted",
-      eventName: name,
-      subscriberCount: subscribers.size,
-      sentCount
-    });
-  }
-  /**
-   * Gets all subscribers for a specific event.
-   *
-   * @param eventName - The name of the event
-   * @returns Set of connections subscribed to the event, or undefined if no subscribers
-   */
-  getSubscribers(eventName) {
-    return this.#subscriptionIndex.get(eventName);
-  }
-  /**
-   * Gets all events and their subscriber counts.
-   *
-   * @returns Map of event names to subscriber counts
-   */
-  getEventStats() {
-    const stats = /* @__PURE__ */ new Map();
-    for (const [eventName, subscribers] of this.#subscriptionIndex) {
-      stats.set(eventName, subscribers.size);
-    }
-    return stats;
-  }
-  /**
-   * Clears all subscriptions for a connection.
-   * Used during connection cleanup.
-   *
-   * @param connection - The connection to clear subscriptions for
-   */
-  clearConnectionSubscriptions(connection) {
-    for (const eventName of [...connection.subscriptions.values()]) {
-      this.removeSubscription(eventName, connection, true);
-    }
-  }
-  /**
-   * Gets the total number of unique events being subscribed to.
-   */
-  get eventCount() {
-    return this.#subscriptionIndex.size;
-  }
-  /**
-   * Gets the total number of subscriptions across all events.
-   */
-  get totalSubscriptionCount() {
-    let total = 0;
-    for (const subscribers of this.#subscriptionIndex.values()) {
-      total += subscribers.size;
-    }
-    return total;
-  }
-  /**
-   * Checks if an event has any subscribers.
-   *
-   * @param eventName - The name of the event to check
-   * @returns True if the event has at least one subscriber
-   */
-  hasSubscribers(eventName) {
-    const subscribers = this.#subscriptionIndex.get(eventName);
-    return subscribers !== void 0 && subscribers.size > 0;
-  }
-};
-
-// src/actor/instance/persisted.ts
-
-function convertActorToBarePersisted(persist) {
-  return {
-    input: persist.input !== void 0 ? _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, cbor8.encode(persist.input)) : null,
-    hasInitialized: persist.hasInitialized,
-    state: _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, cbor8.encode(persist.state)),
-    scheduledEvents: persist.scheduledEvents.map((event) => ({
-      eventId: event.eventId,
-      timestamp: BigInt(event.timestamp),
-      action: event.action,
-      args: _nullishCoalesce(event.args, () => ( null))
-    }))
-  };
-}
-function convertActorFromBarePersisted(bareData) {
-  return {
-    input: bareData.input ? cbor8.decode(new Uint8Array(bareData.input)) : void 0,
-    hasInitialized: bareData.hasInitialized,
-    state: cbor8.decode(new Uint8Array(bareData.state)),
-    scheduledEvents: bareData.scheduledEvents.map((event) => ({
-      eventId: event.eventId,
-      timestamp: Number(event.timestamp),
-      action: event.action,
-      args: _nullishCoalesce(event.args, () => ( void 0))
-    }))
-  };
-}
-
-// src/actor/instance/schedule-manager.ts
-
-var ScheduleManager = class {
-  #actor;
-  #actorDriver;
-  #alarmWriteQueue = new (0, _chunkH4TB4X25cjs.SinglePromiseQueue)();
-  #config;
-  // ActorConfig type
-  #persist;
-  // Reference to PersistedActor
-  constructor(actor, actorDriver, config) {
-    this.#actor = actor;
-    this.#actorDriver = actorDriver;
-    this.#config = config;
-  }
-  // MARK: - Public API
-  /**
-   * Sets the persist object reference.
-   * Called after StateManager initializes the persist proxy.
-   */
-  setPersist(persist) {
-    this.#persist = persist;
-  }
-  /**
-   * Schedules an event to be executed at a specific timestamp.
-   *
-   * @param timestamp - Unix timestamp in milliseconds when the event should fire
-   * @param action - The name of the action to execute
-   * @param args - Arguments to pass to the action
-   */
-  async scheduleEvent(timestamp, action, args) {
-    const newEvent = {
-      eventId: crypto.randomUUID(),
-      timestamp,
-      action,
-      args: _chunkH4TB4X25cjs.bufferToArrayBuffer.call(void 0, cbor9.encode(args))
-    };
-    await this.#scheduleEventInner(newEvent);
-  }
-  /**
-   * Triggers any pending alarms that are due.
-   * This method is idempotent and safe to call multiple times.
-   */
-  async onAlarm() {
-    var _a, _b, _c;
-    const now = Date.now();
-    this.#actor.log.debug({
-      msg: "alarm triggered",
-      now,
-      events: ((_b = (_a = this.#persist) == null ? void 0 : _a.scheduledEvents) == null ? void 0 : _b.length) || 0
-    });
-    if (!((_c = this.#persist) == null ? void 0 : _c.scheduledEvents)) {
-      this.#actor.rLog.debug({ msg: "no scheduled events" });
-      return;
-    }
-    const dueIndex = this.#persist.scheduledEvents.findIndex(
-      (x) => x.timestamp <= now
-    );
-    if (dueIndex === -1) {
-      this.#actor.rLog.debug({ msg: "no events are due yet" });
-      if (this.#persist.scheduledEvents.length > 0) {
-        const nextTs = this.#persist.scheduledEvents[0].timestamp;
-        this.#actor.log.debug({
-          msg: "alarm fired early, rescheduling for next event",
-          now,
-          nextTs,
-          delta: nextTs - now
-        });
-        await this.#queueSetAlarm(nextTs);
-      }
-      return;
-    }
-    const dueEvents = this.#persist.scheduledEvents.splice(0, dueIndex + 1);
-    this.#actor.log.debug({
-      msg: "running events",
-      count: dueEvents.length
-    });
-    if (this.#persist.scheduledEvents.length > 0) {
-      const nextTs = this.#persist.scheduledEvents[0].timestamp;
-      this.#actor.log.info({
-        msg: "setting next alarm",
-        nextTs,
-        remainingEvents: this.#persist.scheduledEvents.length
-      });
-      await this.#queueSetAlarm(nextTs);
-    }
-    await this.#executeDueEvents(dueEvents);
-  }
-  /**
-   * Initializes alarms on actor startup.
-   * Sets the alarm for the next scheduled event if any exist.
-   */
-  async initializeAlarms() {
-    var _a, _b;
-    if (((_b = (_a = this.#persist) == null ? void 0 : _a.scheduledEvents) == null ? void 0 : _b.length) > 0) {
-      await this.#queueSetAlarm(
-        this.#persist.scheduledEvents[0].timestamp
-      );
-    }
-  }
-  /**
-   * Waits for any pending alarm write operations to complete.
-   */
-  async waitForPendingAlarmWrites() {
-    if (this.#alarmWriteQueue.runningDrainLoop) {
-      await this.#alarmWriteQueue.runningDrainLoop;
-    }
-  }
-  /**
-   * Gets statistics about scheduled events.
-   */
-  getScheduleStats() {
-    var _a;
-    if (!((_a = this.#persist) == null ? void 0 : _a.scheduledEvents)) {
-      return {
-        totalEvents: 0,
-        nextEventTime: null,
-        overdueCount: 0
-      };
-    }
-    const now = Date.now();
-    const events = this.#persist.scheduledEvents;
-    return {
-      totalEvents: events.length,
-      nextEventTime: events.length > 0 ? events[0].timestamp : null,
-      overdueCount: events.filter(
-        (e) => e.timestamp <= now
-      ).length
-    };
-  }
-  /**
-   * Cancels a scheduled event by its ID.
-   *
-   * @param eventId - The ID of the event to cancel
-   * @returns True if the event was found and cancelled
-   */
-  async cancelEvent(eventId) {
-    var _a;
-    if (!((_a = this.#persist) == null ? void 0 : _a.scheduledEvents)) {
-      return false;
-    }
-    const index = this.#persist.scheduledEvents.findIndex(
-      (e) => e.eventId === eventId
-    );
-    if (index === -1) {
-      return false;
-    }
-    const wasFirst = index === 0;
-    this.#persist.scheduledEvents.splice(index, 1);
-    if (wasFirst && this.#persist.scheduledEvents.length > 0) {
-      await this.#queueSetAlarm(
-        this.#persist.scheduledEvents[0].timestamp
-      );
-    }
-    this.#actor.log.info({
-      msg: "cancelled scheduled event",
-      eventId,
-      remainingEvents: this.#persist.scheduledEvents.length
-    });
-    return true;
-  }
-  // MARK: - Private Helpers
-  async #scheduleEventInner(newEvent) {
-    var _a;
-    this.#actor.log.info({
-      msg: "scheduling event",
-      eventId: newEvent.eventId,
-      timestamp: newEvent.timestamp,
-      action: newEvent.action
-    });
-    if (!((_a = this.#persist) == null ? void 0 : _a.scheduledEvents)) {
-      throw new Error("Persist not initialized");
-    }
-    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.#actor.log.info({
-        msg: "setting alarm for new event",
-        timestamp: newEvent.timestamp,
-        eventCount: this.#persist.scheduledEvents.length
-      });
-      await this.#queueSetAlarm(newEvent.timestamp);
-    }
-  }
-  async #executeDueEvents(events) {
-    for (const event of events) {
-      try {
-        this.#actor.log.info({
-          msg: "executing scheduled event",
-          eventId: event.eventId,
-          timestamp: event.timestamp,
-          action: event.action
-        });
-        const actions = _nullishCoalesce(this.#config.actions, () => ( {}));
-        const fn = actions[event.action];
-        if (!fn) {
-          throw new Error(
-            `Missing action for scheduled event: ${event.action}`
-          );
-        }
-        if (typeof fn !== "function") {
-          throw new Error(
-            `Scheduled event action ${event.action} is not a function (got ${typeof fn})`
-          );
-        }
-        const args = event.args ? cbor9.decode(new Uint8Array(event.args)) : [];
-        const result = fn.call(
-          void 0,
-          this.#actor.actorContext,
-          ...args
-        );
-        if (result instanceof Promise) {
-          await result;
-        }
-        this.#actor.log.debug({
-          msg: "scheduled event completed",
-          eventId: event.eventId,
-          action: event.action
-        });
-      } catch (error) {
-        this.#actor.log.error({
-          msg: "error executing scheduled event",
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error),
-          eventId: event.eventId,
-          timestamp: event.timestamp,
-          action: event.action
-        });
-      }
-    }
-  }
-  async #queueSetAlarm(timestamp) {
-    await this.#alarmWriteQueue.enqueue(async () => {
-      await this.#actorDriver.setAlarm(this.#actor, timestamp);
-    });
-  }
-  /**
-   * Gets the next scheduled event, if any.
-   */
-  getNextEvent() {
-    var _a;
-    if (!((_a = this.#persist) == null ? void 0 : _a.scheduledEvents) || this.#persist.scheduledEvents.length === 0) {
-      return null;
-    }
-    return this.#persist.scheduledEvents[0];
-  }
-  /**
-   * Gets all scheduled events.
-   */
-  getAllEvents() {
-    var _a;
-    return ((_a = this.#persist) == null ? void 0 : _a.scheduledEvents) || [];
-  }
-  /**
-   * Clears all scheduled events.
-   * Use with caution - this removes all pending scheduled events.
-   */
-  clearAllEvents() {
-    var _a;
-    if ((_a = this.#persist) == null ? void 0 : _a.scheduledEvents) {
-      this.#persist.scheduledEvents = [];
-      this.#actor.log.warn({ msg: "cleared all scheduled events" });
-    }
-  }
-};
-
-// src/actor/instance/state-manager.ts
-var _enginerunner = require('@rivetkit/engine-runner');
-var _onchange = require('@rivetkit/on-change'); var _onchange2 = _interopRequireDefault(_onchange);
-var StateManager = class {
-  #actor;
-  #actorDriver;
-  // State tracking
-  #persist;
-  #persistRaw;
-  #persistChanged = false;
-  #isInOnStateChange = false;
-  // Save management
-  #persistWriteQueue = new (0, _chunkH4TB4X25cjs.SinglePromiseQueue)();
-  #lastSaveTime = 0;
-  #pendingSaveTimeout;
-  #pendingSaveScheduledTimestamp;
-  #onPersistSavedPromise;
-  // Configuration
-  #config;
-  // ActorConfig type
-  #stateSaveInterval;
-  constructor(actor, actorDriver, config) {
-    this.#actor = actor;
-    this.#actorDriver = actorDriver;
-    this.#config = config;
-    this.#stateSaveInterval = config.options.stateSaveInterval || 100;
-  }
-  // MARK: - Public API
-  get persist() {
-    return this.#persist;
-  }
-  get persistRaw() {
-    return this.#persistRaw;
-  }
-  get persistChanged() {
-    return this.#persistChanged;
-  }
-  get state() {
-    this.#validateStateEnabled();
-    return this.#persist.state;
-  }
-  set state(value) {
-    this.#validateStateEnabled();
-    this.#persist.state = value;
-  }
-  get stateEnabled() {
-    return "createState" in this.#config || "state" in this.#config;
-  }
-  // MARK: - Initialization
-  /**
-   * Initializes state from persisted data or creates new state.
-   */
-  async initializeState(persistData) {
-    if (!persistData.hasInitialized) {
-      let stateData;
-      if (this.stateEnabled) {
-        this.#actor.rLog.info({ msg: "actor state initializing" });
-        if ("createState" in this.#config) {
-          stateData = await this.#config.createState(
-            this.#actor.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.#actor.rLog.debug({ msg: "state not enabled" });
-      }
-      persistData.state = stateData;
-      persistData.hasInitialized = true;
-      const bareData = convertActorToBarePersisted(persistData);
-      await this.#actorDriver.kvBatchPut(this.#actor.id, [
-        [
-          _chunkRZW2DNNDcjs.KEYS.PERSIST_DATA,
-          _chunkRZW2DNNDcjs.ACTOR_VERSIONED.serializeWithEmbeddedVersion(
-            bareData,
-            _chunkRZW2DNNDcjs.CURRENT_VERSION2
-          )
-        ]
-      ]);
-    }
-    this.initPersistProxy(persistData);
-  }
-  /**
-   * Creates proxy for persist object that handles automatic state change detection.
-   */
-  initPersistProxy(target) {
-    this.#persistRaw = target;
-    if (target === null || typeof target !== "object") {
-      let invalidPath = "";
-      if (!_chunkH4TB4X25cjs.isCborSerializable.call(void 0, 
-        target,
-        (path) => {
-          invalidPath = path;
-        },
-        ""
-      )) {
-        throw new (0, _chunk2XQS746Mcjs.InvalidStateType)({ path: invalidPath });
-      }
-      return target;
-    }
-    if (this.#persist) {
-      _onchange2.default.unsubscribe(this.#persist);
-    }
-    this.#persist = _onchange2.default.call(void 0, 
-      target,
-      (path, value, _previousValue, _applyData) => {
-        this.#handleStateChange(path, value);
-      },
-      { ignoreDetached: true }
-    );
-  }
-  // MARK: - State Persistence
-  /**
-   * Forces the state to get saved.
-   */
-  async saveState(opts) {
-    var _a;
-    this.#actor.assertReady(opts.allowStoppingState);
-    if (this.#persistChanged) {
-      if (opts.immediate) {
-        await this.#savePersistInner();
-      } else {
-        if (!this.#onPersistSavedPromise) {
-          this.#onPersistSavedPromise = _chunkH4TB4X25cjs.promiseWithResolvers.call(void 0, );
-        }
-        this.savePersistThrottled(opts.maxWait);
-        await ((_a = this.#onPersistSavedPromise) == null ? void 0 : _a.promise);
-      }
-    }
-  }
-  /**
-   * Throttled save state method. Used to write to KV at a reasonable cadence.
-   *
-   * Passing a maxWait will override the stateSaveInterval with the min
-   * between that and the maxWait.
-   */
-  savePersistThrottled(maxWait) {
-    const now = Date.now();
-    const timeSinceLastSave = now - this.#lastSaveTime;
-    let saveDelay = Math.max(
-      0,
-      this.#stateSaveInterval - timeSinceLastSave
-    );
-    if (maxWait !== void 0) {
-      saveDelay = Math.min(saveDelay, maxWait);
-    }
-    if (this.#pendingSaveTimeout !== void 0 && this.#pendingSaveScheduledTimestamp !== void 0) {
-      const newScheduledTimestamp = now + saveDelay;
-      if (newScheduledTimestamp < this.#pendingSaveScheduledTimestamp) {
-        clearTimeout(this.#pendingSaveTimeout);
-        this.#pendingSaveTimeout = void 0;
-        this.#pendingSaveScheduledTimestamp = void 0;
-      } else {
-        return;
-      }
-    }
-    if (saveDelay > 0) {
-      this.#pendingSaveScheduledTimestamp = now + saveDelay;
-      this.#pendingSaveTimeout = setTimeout(() => {
-        this.#pendingSaveTimeout = void 0;
-        this.#pendingSaveScheduledTimestamp = void 0;
-        this.#savePersistInner().catch((error) => {
-          this.#actor.rLog.error({
-            msg: "error saving persist data in scheduled save",
-            error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-          });
-        });
-      }, saveDelay);
-    } else {
-      this.#savePersistInner().catch((error) => {
-        this.#actor.rLog.error({
-          msg: "error saving persist data immediately",
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-        });
-      });
-    }
-  }
-  /**
-   * Clears any pending save timeout.
-   */
-  clearPendingSaveTimeout() {
-    if (this.#pendingSaveTimeout) {
-      clearTimeout(this.#pendingSaveTimeout);
-      this.#pendingSaveTimeout = void 0;
-      this.#pendingSaveScheduledTimestamp = void 0;
-    }
-  }
-  /**
-   * Waits for any pending write operations to complete.
-   */
-  async waitForPendingWrites() {
-    if (this.#persistWriteQueue.runningDrainLoop) {
-      await this.#persistWriteQueue.runningDrainLoop;
-    }
-  }
-  // MARK: - Private Helpers
-  #validateStateEnabled() {
-    if (!this.stateEnabled) {
-      throw new (0, _chunk2XQS746Mcjs.StateNotEnabled)();
-    }
-  }
-  #handleStateChange(path, value) {
-    const actorStatePath = _chunkRZW2DNNDcjs.isStatePath.call(void 0, path);
-    const connStatePath = _chunkRZW2DNNDcjs.isConnStatePath.call(void 0, path);
-    if (actorStatePath || connStatePath) {
-      let invalidPath = "";
-      if (!_chunkH4TB4X25cjs.isCborSerializable.call(void 0, 
-        value,
-        (invalidPathPart) => {
-          invalidPath = invalidPathPart;
-        },
-        ""
-      )) {
-        throw new (0, _chunk2XQS746Mcjs.InvalidStateType)({
-          path: path + (invalidPath ? `.${invalidPath}` : "")
-        });
-      }
-    }
-    this.#actor.rLog.debug({
-      msg: "onChange triggered, setting persistChanged=true",
-      path
-    });
-    this.#persistChanged = true;
-    if (actorStatePath) {
-      this.#actor.inspector.emitter.emit(
-        "stateUpdated",
-        this.#persist.state
-      );
-    }
-    if (actorStatePath && this.#config.onStateChange && this.#actor.isReady() && !this.#isInOnStateChange) {
-      try {
-        this.#isInOnStateChange = true;
-        this.#config.onStateChange(
-          this.#actor.actorContext,
-          this.#persistRaw.state
-        );
-      } catch (error) {
-        this.#actor.rLog.error({
-          msg: "error in `_onStateChange`",
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-        });
-      } finally {
-        this.#isInOnStateChange = false;
-      }
-    }
-  }
-  async #savePersistInner() {
-    var _a, _b;
-    this.#actor.rLog.info({
-      msg: "savePersistInner called",
-      persistChanged: this.#persistChanged,
-      connsWithPersistChangedSize: this.#actor.connectionManager.connsWithPersistChanged.size,
-      connsWithPersistChangedIds: Array.from(
-        this.#actor.connectionManager.connsWithPersistChanged
-      )
-    });
-    try {
-      this.#lastSaveTime = Date.now();
-      const hasChanges = this.#persistChanged || this.#actor.connectionManager.connsWithPersistChanged.size > 0;
-      if (hasChanges) {
-        await this.#persistWriteQueue.enqueue(async () => {
-          this.#actor.rLog.debug({
-            msg: "saving persist",
-            actorChanged: this.#persistChanged,
-            connectionsChanged: this.#actor.connectionManager.connsWithPersistChanged.size
-          });
-          const entries = [];
-          if (this.#persistChanged) {
-            this.#persistChanged = false;
-            const bareData = convertActorToBarePersisted(
-              this.#persistRaw
-            );
-            entries.push([
-              _chunkRZW2DNNDcjs.KEYS.PERSIST_DATA,
-              _chunkRZW2DNNDcjs.ACTOR_VERSIONED.serializeWithEmbeddedVersion(
-                bareData,
-                _chunkRZW2DNNDcjs.CURRENT_VERSION2
-              )
-            ]);
-          }
-          const connections = [];
-          for (const connId of this.#actor.connectionManager.connsWithPersistChanged) {
-            const conn = this.#actor.conns.get(connId);
-            if (!conn) {
-              this.#actor.rLog.warn({
-                msg: "connection not found in conns map",
-                connId
-              });
-              continue;
-            }
-            const connStateManager = conn[_chunkRZW2DNNDcjs.CONN_STATE_MANAGER_SYMBOL];
-            const hibernatableDataRaw = connStateManager.hibernatableDataRaw;
-            if (!hibernatableDataRaw) {
-              this.#actor.log.warn({
-                msg: "missing raw hibernatable data for conn in getChangedConnectionsData",
-                connId: conn.id
-              });
-              continue;
-            }
-            this.#actor.rLog.info({
-              msg: "persisting connection",
-              connId,
-              gatewayId: _enginerunner.idToStr.call(void 0, hibernatableDataRaw.requestId),
-              requestId: _enginerunner.idToStr.call(void 0, hibernatableDataRaw.requestId),
-              serverMessageIndex: hibernatableDataRaw.serverMessageIndex,
-              clientMessageIndex: hibernatableDataRaw.clientMessageIndex,
-              hasState: hibernatableDataRaw.state !== void 0
-            });
-            const bareData = convertConnToBarePersistedConn(
-              hibernatableDataRaw
-            );
-            const connData = _chunkRZW2DNNDcjs.CONN_VERSIONED.serializeWithEmbeddedVersion(
-              bareData,
-              _chunkRZW2DNNDcjs.CURRENT_VERSION2
-            );
-            entries.push([_chunkRZW2DNNDcjs.makeConnKey.call(void 0, connId), connData]);
-            connections.push(conn);
-          }
-          this.#actor.rLog.info({
-            msg: "prepared entries for kvBatchPut",
-            totalEntries: entries.length,
-            connectionEntries: connections.length,
-            connectionIds: connections.map((c) => c.id)
-          });
-          if (this.#actorDriver.onBeforePersistConn) {
-            for (const conn of connections) {
-              this.#actorDriver.onBeforePersistConn(conn);
-            }
-          }
-          this.#actor.connectionManager.clearConnWithPersistChanged();
-          this.#actor.rLog.info({
-            msg: "calling kvBatchPut",
-            actorId: this.#actor.id,
-            entriesCount: entries.length
-          });
-          await this.#actorDriver.kvBatchPut(this.#actor.id, entries);
-          this.#actor.rLog.info({
-            msg: "kvBatchPut completed successfully"
-          });
-          if (this.#actorDriver.onAfterPersistConn) {
-            for (const conn of connections) {
-              this.#actorDriver.onAfterPersistConn(conn);
-            }
-          }
-          this.#actor.rLog.debug({ msg: "persist saved" });
-        });
-      } else {
-        this.#actor.rLog.info({
-          msg: "savePersistInner skipped - no changes"
-        });
-      }
-      (_a = this.#onPersistSavedPromise) == null ? void 0 : _a.resolve();
-    } catch (error) {
-      this.#actor.rLog.error({
-        msg: "error saving persist",
-        error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-      });
-      (_b = this.#onPersistSavedPromise) == null ? void 0 : _b.reject(error);
-      throw error;
-    }
-  }
-};
-
-// src/actor/instance/mod.ts
-var CanSleep = /* @__PURE__ */ ((CanSleep2) => {
-  CanSleep2[CanSleep2["Yes"] = 0] = "Yes";
-  CanSleep2[CanSleep2["NotReady"] = 1] = "NotReady";
-  CanSleep2[CanSleep2["NotStarted"] = 2] = "NotStarted";
-  CanSleep2[CanSleep2["ActiveConns"] = 3] = "ActiveConns";
-  CanSleep2[CanSleep2["ActiveHonoHttpRequests"] = 4] = "ActiveHonoHttpRequests";
-  return CanSleep2;
-})(CanSleep || {});
-var ActorInstance = class {
-  // MARK: - Core Properties
-  
-  #config;
-  
-  #inlineClient;
-  #actorId;
-  #name;
-  #key;
-  #region;
-  // MARK: - Managers
-  
-  
-  
-  #scheduleManager;
-  // MARK: - Logging
-  #log;
-  #rLog;
-  // MARK: - Lifecycle State
-  /**
-   * If the core actor initiation has set up.
-   *
-   * Almost all actions on this actor will throw an error if false.
-   **/
-  #ready = false;
-  /**
-   * If the actor has fully started.
-   *
-   * The only purpose of this is to prevent sleeping until started.
-   */
-  #started = false;
-  #sleepCalled = false;
-  #destroyCalled = false;
-  #stopCalled = false;
-  #sleepTimeout;
-  #abortController = new AbortController();
-  // MARK: - Variables & Database
-  #vars;
-  #db;
-  // MARK: - Background Tasks
-  #backgroundPromises = [];
-  // MARK: - HTTP/WebSocket Tracking
-  #activeHonoHttpRequests = 0;
-  // MARK: - Deprecated (kept for compatibility)
-  #schedule;
-  // MARK: - Inspector
-  #inspectorToken;
-  #inspector = new ActorInspector(this);
-  // MARK: - Constructor
-  constructor(config) {
-    this.#config = config;
-    this.actorContext = new (0, _chunkRZW2DNNDcjs.ActorContext)(this);
-  }
-  // MARK: - Public Getters
-  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;
-  }
-  get isStopping() {
-    return this.#stopCalled;
-  }
-  get id() {
-    return this.#actorId;
-  }
-  get name() {
-    return this.#name;
-  }
-  get key() {
-    return this.#key;
-  }
-  get region() {
-    return this.#region;
-  }
-  get inlineClient() {
-    return this.#inlineClient;
-  }
-  get inspector() {
-    return this.#inspector;
-  }
-  get inspectorToken() {
-    return this.#inspectorToken;
-  }
-  get conns() {
-    return this.connectionManager.connections;
-  }
-  get schedule() {
-    return this.#schedule;
-  }
-  get abortSignal() {
-    return this.#abortController.signal;
-  }
-  get actions() {
-    return Object.keys(_nullishCoalesce(this.#config.actions, () => ( {})));
-  }
-  get config() {
-    return this.#config;
-  }
-  // MARK: - State Access
-  get persist() {
-    return this.stateManager.persist;
-  }
-  get state() {
-    return this.stateManager.state;
-  }
-  set state(value) {
-    this.stateManager.state = value;
-  }
-  get stateEnabled() {
-    return this.stateManager.stateEnabled;
-  }
-  get connStateEnabled() {
-    return "createConnState" in this.#config || "connState" in this.#config;
-  }
-  // MARK: - Variables & Database
-  get vars() {
-    this.#validateVarsEnabled();
-    _invariant2.default.call(void 0, this.#vars !== void 0, "vars not enabled");
-    return this.#vars;
-  }
-  get db() {
-    if (!this.#db) {
-      throw new (0, _chunk2XQS746Mcjs.DatabaseNotEnabled)();
-    }
-    return this.#db;
-  }
-  // MARK: - Initialization
-  async start(actorDriver, inlineClient, actorId, name, key, region) {
-    var _a, _b;
-    this.driver = actorDriver;
-    this.#inlineClient = inlineClient;
-    this.#actorId = actorId;
-    this.#name = name;
-    this.#key = key;
-    this.#region = region;
-    this.#initializeLogging();
-    this.connectionManager = new ConnectionManager(this);
-    this.stateManager = new StateManager(this, actorDriver, this.#config);
-    this.eventManager = new EventManager(this);
-    this.#scheduleManager = new ScheduleManager(
-      this,
-      actorDriver,
-      this.#config
-    );
-    this.#schedule = new Schedule(this);
-    await this.#loadState();
-    await this.#initializeInspectorToken();
-    if (this.#varsEnabled) {
-      await this.#initializeVars();
-    }
-    await this.#callOnStart();
-    await this.#setupDatabase();
-    await this.#scheduleManager.initializeAlarms();
-    this.#ready = true;
-    await ((_b = (_a = this.driver).onBeforeActorStart) == null ? void 0 : _b.call(_a, this));
-    this.#started = true;
-    this.#rLog.info({ msg: "actor started" });
-    this.resetSleepTimer();
-    await this.onAlarm();
-  }
-  // MARK: - Ready Check
-  isReady() {
-    return this.#ready;
-  }
-  assertReady(allowStoppingState = false) {
-    if (!this.#ready) throw new (0, _chunk2XQS746Mcjs.InternalError)("Actor not ready");
-    if (!allowStoppingState && this.#stopCalled)
-      throw new (0, _chunk2XQS746Mcjs.InternalError)("Actor is stopping");
-  }
-  // MARK: - Stop
-  async onStop(mode) {
-    if (this.#stopCalled) {
-      this.#rLog.warn({ msg: "already stopping actor" });
-      return;
-    }
-    this.#stopCalled = true;
-    this.#rLog.info({
-      msg: "setting stopCalled=true",
-      mode
-    });
-    if (this.#sleepTimeout) {
-      clearTimeout(this.#sleepTimeout);
-      this.#sleepTimeout = void 0;
-    }
-    try {
-      this.#abortController.abort();
-    } catch (e3) {
-    }
-    if (mode === "sleep") {
-      await this.#callOnSleep();
-    } else if (mode === "destroy") {
-      await this.#callOnDestroy();
-    } else {
-      _chunkRZW2DNNDcjs.assertUnreachable.call(void 0, mode);
-    }
-    await this.#disconnectConnections();
-    await this.#waitBackgroundPromises(
-      this.#config.options.waitUntilTimeout
-    );
-    this.#rLog.info({ msg: "clearing pending save timeouts" });
-    this.stateManager.clearPendingSaveTimeout();
-    this.#rLog.info({ msg: "saving state immediately" });
-    await this.stateManager.saveState({
-      immediate: true,
-      allowStoppingState: true
-    });
-    await this.stateManager.waitForPendingWrites();
-    await this.#scheduleManager.waitForPendingAlarmWrites();
-  }
-  // MARK: - Sleep
-  startSleep() {
-    var _a;
-    if (this.#stopCalled || this.#destroyCalled) {
-      this.#rLog.debug({
-        msg: "cannot call startSleep if actor already stopping"
-      });
-      return;
-    }
-    if (this.#sleepCalled) {
-      this.#rLog.warn({
-        msg: "cannot call startSleep twice, actor already sleeping"
-      });
-      return;
-    }
-    this.#sleepCalled = true;
-    const sleep = (_a = this.driver.startSleep) == null ? void 0 : _a.bind(this.driver, this.#actorId);
-    _invariant2.default.call(void 0, this.#sleepingSupported, "sleeping not supported");
-    _invariant2.default.call(void 0, sleep, "no sleep on driver");
-    this.#rLog.info({ msg: "actor sleeping" });
-    setImmediate(() => {
-      sleep();
-    });
-  }
-  // MARK: - Destroy
-  startDestroy() {
-    if (this.#stopCalled || this.#sleepCalled) {
-      this.#rLog.debug({
-        msg: "cannot call startDestroy if actor already stopping or sleeping"
-      });
-      return;
-    }
-    if (this.#destroyCalled) {
-      this.#rLog.warn({
-        msg: "cannot call startDestroy twice, actor already destroying"
-      });
-      return;
-    }
-    this.#destroyCalled = true;
-    const destroy = this.driver.startDestroy.bind(
-      this.driver,
-      this.#actorId
-    );
-    this.#rLog.info({ msg: "actor destroying" });
-    setImmediate(() => {
-      destroy();
-    });
-  }
-  // MARK: - HTTP Request Tracking
-  beginHonoHttpRequest() {
-    this.#activeHonoHttpRequests++;
-    this.resetSleepTimer();
-  }
-  endHonoHttpRequest() {
-    this.#activeHonoHttpRequests--;
-    if (this.#activeHonoHttpRequests < 0) {
-      this.#activeHonoHttpRequests = 0;
-      this.#rLog.warn({
-        msg: "active hono requests went below 0, this is a RivetKit bug",
-        ..._chunkH4TB4X25cjs.EXTRA_ERROR_LOG
-      });
-    }
-    this.resetSleepTimer();
-  }
-  // MARK: - Message Processing
-  async processMessage(message, conn) {
-    await _chunkRZW2DNNDcjs.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.eventManager.addSubscription(eventName, conn2, false);
-      },
-      onUnsubscribe: async (eventName, conn2) => {
-        this.inspector.emitter.emit("eventFired", {
-          type: "unsubscribe",
-          eventName,
-          connId: conn2.id
-        });
-        this.eventManager.removeSubscription(eventName, conn2, false);
-      }
-    });
-  }
-  // MARK: - Action Execution
-  async executeAction(ctx, actionName, args) {
-    this.assertReady();
-    const actions = _nullishCoalesce(this.#config.actions, () => ( {}));
-    if (!(actionName in actions)) {
-      this.#rLog.warn({ msg: "action does not exist", actionName });
-      throw new (0, _chunk2XQS746Mcjs.ActionNotFound)(actionName);
-    }
-    const actionFunction = actions[actionName];
-    if (typeof actionFunction !== "function") {
-      this.#rLog.warn({
-        msg: "action is not a function",
-        actionName,
-        type: typeof actionFunction
-      });
-      throw new (0, _chunk2XQS746Mcjs.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) {
-        output = await _chunkRZW2DNNDcjs.deadline.call(void 0, 
-          outputOrPromise,
-          this.#config.options.actionTimeout
-        );
-      } else {
-        output = outputOrPromise;
-      }
-      if (this.#config.onBeforeActionResponse) {
-        try {
-          const processedOutput = this.#config.onBeforeActionResponse(
-            this.actorContext,
-            actionName,
-            args,
-            output
-          );
-          if (processedOutput instanceof Promise) {
-            output = await processedOutput;
-          } else {
-            output = processedOutput;
-          }
-        } catch (error) {
-          this.#rLog.error({
-            msg: "error in `onBeforeActionResponse`",
-            error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-          });
-        }
-      }
-      return output;
-    } catch (error) {
-      if (error instanceof _chunkRZW2DNNDcjs.DeadlineError) {
-        throw new (0, _chunk2XQS746Mcjs.ActionTimedOut)();
-      }
-      this.#rLog.error({
-        msg: "action error",
-        actionName,
-        error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-      });
-      throw error;
-    } finally {
-      this.stateManager.savePersistThrottled();
-    }
-  }
-  // MARK: - HTTP/WebSocket Handlers
-  async handleRawRequest(conn, request) {
-    this.assertReady();
-    if (!this.#config.onRequest) {
-      throw new (0, _chunk2XQS746Mcjs.RequestHandlerNotDefined)();
-    }
-    try {
-      const ctx = new (0, _chunkRZW2DNNDcjs.RequestContext)(this, conn, request);
-      const response = await this.#config.onRequest(ctx, request);
-      if (!response) {
-        throw new (0, _chunk2XQS746Mcjs.InvalidRequestHandlerResponse)();
-      }
-      return response;
-    } catch (error) {
-      this.#rLog.error({
-        msg: "onRequest error",
-        error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-      });
-      throw error;
-    } finally {
-      this.stateManager.savePersistThrottled();
-    }
-  }
-  handleRawWebSocket(conn, websocket, request) {
-    this.assertReady();
-    if (!this.#config.onWebSocket) {
-      throw new (0, _chunk2XQS746Mcjs.InternalError)("onWebSocket handler not defined");
-    }
-    try {
-      this.resetSleepTimer();
-      const ctx = new (0, _chunkRZW2DNNDcjs.WebSocketContext)(this, conn, request);
-      const voidOrPromise = this.#config.onWebSocket(ctx, websocket);
-      if (voidOrPromise instanceof Promise) {
-        voidOrPromise.then(() => {
-          this.stateManager.savePersistThrottled();
-        });
-      } else {
-        this.stateManager.savePersistThrottled();
-      }
-    } catch (error) {
-      this.#rLog.error({
-        msg: "onWebSocket error",
-        error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-      });
-      throw error;
-    }
-  }
-  // MARK: - Scheduling
-  async scheduleEvent(timestamp, action, args) {
-    await this.#scheduleManager.scheduleEvent(timestamp, action, args);
-  }
-  async onAlarm() {
-    this.resetSleepTimer();
-    await this.#scheduleManager.onAlarm();
-  }
-  // MARK: - Background Tasks
-  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: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-      });
-    });
-    this.#backgroundPromises.push(nonfailablePromise);
-  }
-  // MARK: - Private Helper Methods
-  #initializeLogging() {
-    var _a, _b;
-    const logParams = {
-      actor: this.#name,
-      key: _chunkRZW2DNNDcjs.serializeActorKey.call(void 0, this.#key),
-      actorId: this.#actorId
-    };
-    const extraLogParams = (_b = (_a = this.driver).getExtraActorLogParams) == null ? void 0 : _b.call(_a);
-    if (extraLogParams) Object.assign(logParams, extraLogParams);
-    this.#log = _chunkH4TB4X25cjs.getBaseLogger.call(void 0, ).child(
-      Object.assign(
-        _chunkH4TB4X25cjs.getIncludeTarget.call(void 0, ) ? { target: "actor" } : {},
-        logParams
-      )
-    );
-    this.#rLog = _chunkH4TB4X25cjs.getBaseLogger.call(void 0, ).child(
-      Object.assign(
-        _chunkH4TB4X25cjs.getIncludeTarget.call(void 0, ) ? { target: "actor-runtime" } : {},
-        logParams
-      )
-    );
-  }
-  async #loadState() {
-    const [persistDataBuffer] = await this.driver.kvBatchGet(
-      this.#actorId,
-      [_chunkRZW2DNNDcjs.KEYS.PERSIST_DATA]
-    );
-    _invariant2.default.call(void 0, 
-      persistDataBuffer !== null,
-      "persist data has not been set, it should be set when initialized"
-    );
-    const bareData = _chunkRZW2DNNDcjs.ACTOR_VERSIONED.deserializeWithEmbeddedVersion(persistDataBuffer);
-    const persistData = convertActorFromBarePersisted(bareData);
-    if (persistData.hasInitialized) {
-      await this.#restoreExistingActor(persistData);
-    } else {
-      await this.#createNewActor(persistData);
-    }
-    this.#scheduleManager.setPersist(this.stateManager.persist);
-  }
-  async #createNewActor(persistData) {
-    this.#rLog.info({ msg: "actor creating" });
-    await this.stateManager.initializeState(persistData);
-    if (this.#config.onCreate) {
-      await this.#config.onCreate(
-        this.actorContext,
-        persistData.input
-      );
-    }
-  }
-  async #restoreExistingActor(persistData) {
-    const connEntries = await this.driver.kvListPrefix(
-      this.#actorId,
-      _chunkRZW2DNNDcjs.KEYS.CONN_PREFIX
-    );
-    const connections = [];
-    for (const [_key, value] of connEntries) {
-      try {
-        const bareData = _chunkRZW2DNNDcjs.CONN_VERSIONED.deserializeWithEmbeddedVersion(
-          new Uint8Array(value)
-        );
-        const conn = convertConnFromBarePersistedConn(bareData);
-        connections.push(conn);
-      } catch (error) {
-        this.#rLog.error({
-          msg: "failed to decode connection",
-          error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-        });
-      }
-    }
-    this.#rLog.info({
-      msg: "actor restoring",
-      connections: connections.length
-    });
-    this.stateManager.initPersistProxy(persistData);
-    this.connectionManager.restoreConnections(connections);
-  }
-  async #initializeInspectorToken() {
-    const [tokenBuffer] = await this.driver.kvBatchGet(this.#actorId, [
-      _chunkRZW2DNNDcjs.KEYS.INSPECTOR_TOKEN
-    ]);
-    if (tokenBuffer !== null) {
-      const decoder = new TextDecoder();
-      this.#inspectorToken = decoder.decode(tokenBuffer);
-      this.#rLog.debug({ msg: "loaded existing inspector token" });
-    } else {
-      this.#inspectorToken = _chunkRZW2DNNDcjs.generateSecureToken.call(void 0, );
-      const tokenBytes = new TextEncoder().encode(this.#inspectorToken);
-      await this.driver.kvBatchPut(this.#actorId, [
-        [_chunkRZW2DNNDcjs.KEYS.INSPECTOR_TOKEN, tokenBytes]
-      ]);
-      this.#rLog.debug({ msg: "generated new inspector token" });
-    }
-  }
-  async #initializeVars() {
-    let vars;
-    if ("createVars" in this.#config) {
-      const dataOrPromise = this.#config.createVars(
-        this.actorContext,
-        this.driver.getContext(this.#actorId)
-      );
-      if (dataOrPromise instanceof Promise) {
-        vars = await _chunkRZW2DNNDcjs.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 create variables from 'createVars' or 'vars'"
-      );
-    }
-    this.#vars = vars;
-  }
-  async #callOnStart() {
-    this.#rLog.info({ msg: "actor starting" });
-    if (this.#config.onWake) {
-      const result = this.#config.onWake(this.actorContext);
-      if (result instanceof Promise) {
-        await result;
-      }
-    }
-  }
-  async #callOnSleep() {
-    if (this.#config.onSleep) {
-      try {
-        this.#rLog.debug({ msg: "calling onSleep" });
-        const result = this.#config.onSleep(this.actorContext);
-        if (result instanceof Promise) {
-          await _chunkRZW2DNNDcjs.deadline.call(void 0, result, this.#config.options.onSleepTimeout);
-        }
-        this.#rLog.debug({ msg: "onSleep completed" });
-      } catch (error) {
-        if (error instanceof _chunkRZW2DNNDcjs.DeadlineError) {
-          this.#rLog.error({ msg: "onSleep timed out" });
-        } else {
-          this.#rLog.error({
-            msg: "error in onSleep",
-            error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-          });
-        }
-      }
-    }
-  }
-  async #callOnDestroy() {
-    if (this.#config.onDestroy) {
-      try {
-        this.#rLog.debug({ msg: "calling onDestroy" });
-        const result = this.#config.onDestroy(this.actorContext);
-        if (result instanceof Promise) {
-          await _chunkRZW2DNNDcjs.deadline.call(void 0, 
-            result,
-            this.#config.options.onDestroyTimeout
-          );
-        }
-        this.#rLog.debug({ msg: "onDestroy completed" });
-      } catch (error) {
-        if (error instanceof _chunkRZW2DNNDcjs.DeadlineError) {
-          this.#rLog.error({ msg: "onDestroy timed out" });
-        } else {
-          this.#rLog.error({
-            msg: "error in onDestroy",
-            error: _chunkH4TB4X25cjs.stringifyError.call(void 0, error)
-          });
-        }
-      }
-    }
-  }
-  async #setupDatabase() {
-    var _a, _b;
-    if ("db" in this.#config && this.#config.db) {
-      const client = await this.#config.db.createClient({
-        getDatabase: () => this.driver.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;
-    }
-  }
-  async #disconnectConnections() {
-    const promises = [];
-    this.#rLog.debug({
-      msg: "disconnecting connections on actor stop",
-      totalConns: this.connectionManager.connections.size
-    });
-    for (const connection of this.connectionManager.connections.values()) {
-      this.#rLog.debug({
-        msg: "checking connection for disconnect",
-        connId: connection.id,
-        isHibernatable: connection.isHibernatable
-      });
-      if (!connection.isHibernatable) {
-        this.#rLog.debug({
-          msg: "disconnecting non-hibernatable connection on actor stop",
-          connId: connection.id
-        });
-        promises.push(connection.disconnect());
-      } else {
-        this.#rLog.debug({
-          msg: "preserving hibernatable connection on actor stop",
-          connId: connection.id
-        });
-      }
-    }
-    const res = await Promise.race([
-      Promise.all(promises).then(() => false),
-      new Promise(
-        (res2) => globalThis.setTimeout(() => res2(true), 1500)
-      )
-    ]);
-    if (res) {
-      this.#rLog.warn({
-        msg: "timed out waiting for connections to close, shutting down anyway"
-      });
-    }
-  }
-  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",
-        count: pending.length,
-        timeoutMs
-      });
-    } else {
-      this.#rLog.debug({ msg: "background promises finished" });
-    }
-  }
-  resetSleepTimer() {
-    if (this.#config.options.noSleep || !this.#sleepingSupported) return;
-    if (this.#stopCalled) return;
-    const canSleep = this.#canSleep();
-    this.#rLog.debug({
-      msg: "resetting sleep timer",
-      canSleep: CanSleep[canSleep],
-      existingTimeout: !!this.#sleepTimeout,
-      timeout: this.#config.options.sleepTimeout
-    });
-    if (this.#sleepTimeout) {
-      clearTimeout(this.#sleepTimeout);
-      this.#sleepTimeout = void 0;
-    }
-    if (this.#sleepCalled) return;
-    if (canSleep === 0 /* Yes */) {
-      this.#sleepTimeout = setTimeout(() => {
-        this.startSleep();
-      }, this.#config.options.sleepTimeout);
-    }
-  }
-  #canSleep() {
-    if (!this.#ready) return 1 /* NotReady */;
-    if (!this.#started) return 1 /* NotReady */;
-    if (this.#activeHonoHttpRequests > 0)
-      return 4 /* ActiveHonoHttpRequests */;
-    for (const _conn of this.connectionManager.connections.values()) {
-      return 3 /* ActiveConns */;
-    }
-    return 0 /* Yes */;
-  }
-  get #sleepingSupported() {
-    return this.driver.startSleep !== void 0;
-  }
-  get #varsEnabled() {
-    return "createVars" in this.#config || "vars" in this.#config;
-  }
-  #validateVarsEnabled() {
-    if (!this.#varsEnabled) {
-      throw new (0, _chunk2XQS746Mcjs.VarsNotEnabled)();
-    }
-  }
-};
-
-// 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(config, name) {
-  const definition = config.use[name];
-  if (!definition) throw new Error(`no actor in registry for name ${name}`);
-  return definition;
-}
-
-// src/client/mod.ts
-function createClient(endpointOrConfig) {
-  const configInput = endpointOrConfig === void 0 ? {} : typeof endpointOrConfig === "string" ? { endpoint: endpointOrConfig } : endpointOrConfig;
-  const config = ClientConfigSchema.parse(configInput);
-  const driver = new RemoteManagerDriver(config);
-  if (config.devtools) {
-    injectDevtools(config);
-  }
-  return createClientWithDriver(driver, config);
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.ActorDefinition = ActorDefinition; exports.lookupInRegistry = lookupInRegistry; exports.ActorClientError = ActorClientError; exports.InternalError = InternalError2; exports.ManagerError = ManagerError; exports.MalformedResponseMessage = MalformedResponseMessage; exports.ActorError = ActorError; exports.ActorConnDisposed = ActorConnDisposed; exports.ActorConnRaw = ActorConnRaw; exports.ActorHandleRaw = ActorHandleRaw; exports.createClientWithDriver = createClientWithDriver; exports.ClientConfigSchemaBase = ClientConfigSchemaBase; exports.ClientConfigSchema = ClientConfigSchema; exports.transformClientConfig = transformClientConfig; exports.convertRegistryConfigToClientConfig = convertRegistryConfigToClientConfig; exports.getEndpoint = getEndpoint; exports.getDatacenters = getDatacenters; exports.updateRunnerConfig = updateRunnerConfig; exports.RemoteManagerDriver = RemoteManagerDriver; exports.createClient = createClient;
-//# sourceMappingURL=chunk-GD7UXGOE.cjs.map