rivetkit 2.0.3 → 2.0.4

package/dist/tsup/chunk-OV6AYD4S.js

@@ -1,4406 +0,0 @@
-import {
-  ActorDefinition,
-  ActorError as ActorError2,
-  createActorInspectorRouter,
-  createClientWithDriver,
-  importEventSource,
-  lookupInRegistry,
-  sendHttpRequest
-} from "./chunk-EGVZZFE2.js";
-import {
-  ActorQuerySchema,
-  ConnMessageRequestSchema,
-  ConnectRequestSchema,
-  ConnectWebSocketRequestSchema,
-  CreateActorSchema,
-  ResolveRequestSchema
-} from "./chunk-FLMTTN27.js";
-import {
-  importWebSocket
-} from "./chunk-PO4VLDWA.js";
-import {
-  RunConfigSchema,
-  serializeEmptyPersistData
-} from "./chunk-KJCJLKRM.js";
-import {
-  ALLOWED_PUBLIC_HEADERS,
-  CONNECTION_DRIVER_HTTP,
-  CONNECTION_DRIVER_SSE,
-  CONNECTION_DRIVER_WEBSOCKET,
-  EncodingSchema,
-  HEADER_ACTOR_ID,
-  HEADER_ACTOR_QUERY,
-  HEADER_AUTH_DATA,
-  HEADER_CONN_ID,
-  HEADER_CONN_PARAMS,
-  HEADER_CONN_TOKEN,
-  HEADER_ENCODING,
-  HEADER_EXPOSE_INTERNAL_ERROR,
-  HTTP_ACTION_REQUEST_VERSIONED,
-  HTTP_ACTION_RESPONSE_VERSIONED,
-  HTTP_RESOLVE_RESPONSE_VERSIONED,
-  HTTP_RESPONSE_ERROR_VERSIONED,
-  TO_CLIENT_VERSIONED,
-  TO_SERVER_VERSIONED,
-  createVersionedDataHandler,
-  encodeDataToString,
-  generateRandomString,
-  getRequestEncoding,
-  getRequestExposeInternalError,
-  getRequestQuery,
-  handleAction,
-  handleConnectionMessage,
-  handleRawWebSocketHandler,
-  handleSseConnect,
-  handleWebSocketConnect,
-  logger,
-  logger2,
-  serializeWithEncoding
-} from "./chunk-4NSUQZ2H.js";
-import {
-  getLogger
-} from "./chunk-XFSS33EQ.js";
-import {
-  bufferToArrayBuffer,
-  deconstructError,
-  getEnvUniversal,
-  httpUserAgent,
-  noopNext,
-  setLongTimeout,
-  stringifyError
-} from "./chunk-3H7O2A7I.js";
-import {
-  ActorAlreadyExists,
-  ActorError,
-  ActorNotFound,
-  Forbidden,
-  InternalError,
-  InvalidParams,
-  InvalidQueryJSON,
-  InvalidRequest,
-  ProxyError,
-  UserError
-} from "./chunk-INGJP237.js";
-
-// src/actor/config.ts
-import { z } from "zod";
-var ActorConfigSchema = z.object({
-  onAuth: z.function().optional(),
-  onCreate: z.function().optional(),
-  onStart: z.function().optional(),
-  onStop: z.function().optional(),
-  onStateChange: z.function().optional(),
-  onBeforeConnect: z.function().optional(),
-  onConnect: z.function().optional(),
-  onDisconnect: z.function().optional(),
-  onBeforeActionResponse: z.function().optional(),
-  onFetch: z.function().optional(),
-  onWebSocket: z.function().optional(),
-  actions: z.record(z.function()).default({}),
-  state: z.any().optional(),
-  createState: z.function().optional(),
-  connState: z.any().optional(),
-  createConnState: z.function().optional(),
-  vars: z.any().optional(),
-  db: z.any().optional(),
-  createVars: z.function().optional(),
-  options: z.object({
-    createVarsTimeout: z.number().positive().default(5e3),
-    createConnStateTimeout: z.number().positive().default(5e3),
-    onConnectTimeout: z.number().positive().default(5e3),
-    // This must be less than ACTOR_STOP_THRESHOLD_MS
-    onStopTimeout: z.number().positive().default(5e3),
-    stateSaveInterval: z.number().positive().default(1e4),
-    actionTimeout: z.number().positive().default(6e4),
-    // Max time to wait for waitUntil background promises during shutdown
-    waitUntilTimeout: z.number().positive().default(15e3),
-    connectionLivenessTimeout: z.number().positive().default(2500),
-    connectionLivenessInterval: z.number().positive().default(5e3),
-    noSleep: z.boolean().default(false),
-    sleepTimeout: z.number().positive().default(3e4)
-  }).strict().default({})
-}).strict().refine(
-  (data) => !(data.state !== void 0 && data.createState !== void 0),
-  {
-    message: "Cannot define both 'state' and 'createState'",
-    path: ["state"]
-  }
-).refine(
-  (data) => !(data.connState !== void 0 && data.createConnState !== void 0),
-  {
-    message: "Cannot define both 'connState' and 'createConnState'",
-    path: ["connState"]
-  }
-).refine(
-  (data) => !(data.vars !== void 0 && data.createVars !== void 0),
-  {
-    message: "Cannot define both 'vars' and 'createVars'",
-    path: ["vars"]
-  }
-);
-
-// src/actor/generic-conn-driver.ts
-var GenericConnGlobalState = class {
-  websockets = /* @__PURE__ */ new Map();
-  sseStreams = /* @__PURE__ */ new Map();
-};
-function createGenericConnDrivers(globalState) {
-  return {
-    [CONNECTION_DRIVER_WEBSOCKET]: createGenericWebSocketDriver(globalState),
-    [CONNECTION_DRIVER_SSE]: createGenericSseDriver(globalState),
-    [CONNECTION_DRIVER_HTTP]: createGenericHttpDriver()
-  };
-}
-function createGenericWebSocketDriver(globalState) {
-  return {
-    sendMessage: (actor2, conn, state, message) => {
-      const ws = globalState.websockets.get(conn.id);
-      if (!ws) {
-        logger().warn("missing ws for sendMessage", {
-          actorId: actor2.id,
-          connId: conn.id,
-          totalCount: globalState.websockets.size
-        });
-        return;
-      }
-      const serialized = message.serialize(state.encoding);
-      logger().debug("sending websocket message", {
-        encoding: state.encoding,
-        dataType: typeof serialized,
-        isUint8Array: serialized instanceof Uint8Array,
-        isArrayBuffer: serialized instanceof ArrayBuffer,
-        dataLength: serialized.byteLength || serialized.length
-      });
-      if (serialized instanceof Uint8Array) {
-        const buffer = serialized.buffer.slice(
-          serialized.byteOffset,
-          serialized.byteOffset + serialized.byteLength
-        );
-        if (buffer instanceof SharedArrayBuffer) {
-          const arrayBuffer = new ArrayBuffer(buffer.byteLength);
-          new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));
-          logger().debug("converted SharedArrayBuffer to ArrayBuffer", {
-            byteLength: arrayBuffer.byteLength
-          });
-          ws.send(arrayBuffer);
-        } else {
-          logger().debug("sending ArrayBuffer", {
-            byteLength: buffer.byteLength
-          });
-          ws.send(buffer);
-        }
-      } else {
-        logger().debug("sending string data", {
-          length: serialized.length
-        });
-        ws.send(serialized);
-      }
-    },
-    disconnect: async (actor2, conn, _state, reason) => {
-      const ws = globalState.websockets.get(conn.id);
-      if (!ws) {
-        logger().warn("missing ws for disconnect", {
-          actorId: actor2.id,
-          connId: conn.id,
-          totalCount: globalState.websockets.size
-        });
-        return;
-      }
-      const raw = ws.raw;
-      if (!raw) {
-        logger().warn("ws.raw does not exist");
-        return;
-      }
-      const { promise, resolve } = Promise.withResolvers();
-      raw.addEventListener("close", () => resolve());
-      ws.close(1e3, reason);
-      await promise;
-    },
-    getConnectionReadyState: (_actor, conn) => {
-      const ws = globalState.websockets.get(conn.id);
-      if (!ws) {
-        logger().warn("missing ws for getConnectionReadyState", {
-          connId: conn.id
-        });
-        return void 0;
-      }
-      const raw = ws.raw;
-      return raw.readyState;
-    }
-  };
-}
-function createGenericSseDriver(globalState) {
-  return {
-    sendMessage: (_actor, conn, state, message) => {
-      const stream = globalState.sseStreams.get(conn.id);
-      if (!stream) {
-        logger().warn("missing sse stream for sendMessage", {
-          connId: conn.id
-        });
-        return;
-      }
-      stream.writeSSE({
-        data: encodeDataToString(message.serialize(state.encoding))
-      });
-    },
-    disconnect: async (_actor, conn, _state, _reason) => {
-      const stream = globalState.sseStreams.get(conn.id);
-      if (!stream) {
-        logger().warn("missing sse stream for disconnect", { connId: conn.id });
-        return;
-      }
-      stream.close();
-    },
-    getConnectionReadyState: (_actor, conn) => {
-      const stream = globalState.sseStreams.get(conn.id);
-      if (!stream) {
-        logger().warn("missing sse stream for getConnectionReadyState", {
-          connId: conn.id
-        });
-        return void 0;
-      }
-      if (stream.aborted || stream.closed) {
-        return 3 /* CLOSED */;
-      }
-      return 1 /* OPEN */;
-    }
-  };
-}
-function createGenericHttpDriver() {
-  return {
-    getConnectionReadyState(_actor, _conn) {
-      return 1 /* OPEN */;
-    },
-    disconnect: async () => {
-    }
-  };
-}
-
-// src/actor/router.ts
-import { Hono } from "hono";
-import invariant from "invariant";
-
-// src/common/router.ts
-import * as cbor from "cbor-x";
-function logger3() {
-  return getLogger("router");
-}
-function loggerMiddleware(logger9) {
-  return async (c, next) => {
-    const method = c.req.method;
-    const path3 = c.req.path;
-    const startTime = Date.now();
-    await next();
-    const duration = Date.now() - startTime;
-    logger9.debug("http request", {
-      method,
-      path: path3,
-      status: c.res.status,
-      dt: `${duration}ms`,
-      reqSize: c.req.header("content-length"),
-      resSize: c.res.headers.get("content-length"),
-      userAgent: c.req.header("user-agent")
-    });
-  };
-}
-function handleRouteNotFound(c) {
-  return c.text("Not Found (RivetKit)", 404);
-}
-function handleRouteError(opts, error, c) {
-  const exposeInternalError = opts.enableExposeInternalError && getRequestExposeInternalError(c.req.raw);
-  const { statusCode, code, message, metadata } = deconstructError(
-    error,
-    logger3(),
-    {
-      method: c.req.method,
-      path: c.req.path
-    },
-    exposeInternalError
-  );
-  let encoding;
-  try {
-    encoding = getRequestEncoding(c.req);
-  } catch (err) {
-    logger3().debug("failed to extract encoding", {
-      error: stringifyError(err)
-    });
-    encoding = "json";
-  }
-  const output = serializeWithEncoding(
-    encoding,
-    {
-      code,
-      message,
-      metadata: bufferToArrayBuffer(cbor.encode(metadata))
-    },
-    HTTP_RESPONSE_ERROR_VERSIONED
-  );
-  return c.body(output, { status: statusCode });
-}
-
-// src/inspector/utils.ts
-import crypto2 from "crypto";
-import { createMiddleware } from "hono/factory";
-
-// src/inspector/log.ts
-function inspectorLogger() {
-  return getLogger("inspector");
-}
-
-// src/inspector/utils.ts
-function compareSecrets(providedSecret, validSecret) {
-  if (providedSecret.length !== validSecret.length) {
-    return false;
-  }
-  const encoder = new TextEncoder();
-  const a = encoder.encode(providedSecret);
-  const b = encoder.encode(validSecret);
-  if (a.byteLength !== b.byteLength) {
-    return false;
-  }
-  if (!crypto2.timingSafeEqual(a, b)) {
-    return false;
-  }
-  return true;
-}
-var secureInspector = (runConfig) => createMiddleware(async (c, next) => {
-  var _a, _b, _c;
-  if (!runConfig.inspector.enabled) {
-    return c.text("Inspector is not enabled", 503);
-  }
-  const userToken = (_a = c.req.header("Authorization")) == null ? void 0 : _a.replace("Bearer ", "");
-  if (!userToken) {
-    return c.text("Unauthorized", 401);
-  }
-  const inspectorToken = (_c = (_b = runConfig.inspector).token) == null ? void 0 : _c.call(_b);
-  if (!inspectorToken) {
-    return c.text("Unauthorized", 401);
-  }
-  const isValid = compareSecrets(userToken, inspectorToken);
-  if (!isValid) {
-    return c.text("Unauthorized", 401);
-  }
-  await next();
-});
-function getInspectorUrl(runConfig) {
-  var _a, _b, _c, _d;
-  if (!((_a = runConfig == null ? void 0 : runConfig.inspector) == null ? void 0 : _a.enabled)) {
-    return "disabled";
-  }
-  const accessToken = (_c = (_b = runConfig == null ? void 0 : runConfig.inspector) == null ? void 0 : _b.token) == null ? void 0 : _c.call(_b);
-  if (!accessToken) {
-    inspectorLogger().warn(
-      "Inspector Token is not set, but Inspector is enabled. Please set it in the run configuration `inspector.token` or via `RIVETKIT_INSPECTOR_TOKEN` environment variable. Inspector will not be accessible."
-    );
-    return "disabled";
-  }
-  const url = new URL("https://studio.rivet.gg");
-  url.searchParams.set("t", accessToken);
-  if ((_d = runConfig == null ? void 0 : runConfig.inspector) == null ? void 0 : _d.defaultEndpoint) {
-    url.searchParams.set("u", runConfig.inspector.defaultEndpoint);
-  }
-  return url.href;
-}
-
-// src/actor/router.ts
-var PATH_CONNECT_WEBSOCKET = "/connect/websocket";
-var PATH_RAW_WEBSOCKET_PREFIX = "/raw/websocket/";
-function createActorRouter(runConfig, actorDriver) {
-  const router = new Hono({ strict: false });
-  router.use("*", loggerMiddleware(logger()));
-  router.get("/", (c) => {
-    return c.text(
-      "This is an RivetKit actor.\n\nLearn more at https://rivetkit.org"
-    );
-  });
-  router.get("/health", (c) => {
-    return c.text("ok");
-  });
-  router.get(PATH_CONNECT_WEBSOCKET, async (c) => {
-    var _a;
-    const upgradeWebSocket = (_a = runConfig.getUpgradeWebSocket) == null ? void 0 : _a.call(runConfig);
-    if (upgradeWebSocket) {
-      return upgradeWebSocket(async (c2) => {
-        const encodingRaw = c2.req.header(HEADER_ENCODING);
-        const connParamsRaw = c2.req.header(HEADER_CONN_PARAMS);
-        const authDataRaw = c2.req.header(HEADER_AUTH_DATA);
-        const encoding = EncodingSchema.parse(encodingRaw);
-        const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
-        const authData = authDataRaw ? JSON.parse(authDataRaw) : void 0;
-        return await handleWebSocketConnect(
-          c2.req.raw,
-          runConfig,
-          actorDriver,
-          c2.env.actorId,
-          encoding,
-          connParams,
-          authData
-        );
-      })(c, noopNext());
-    } else {
-      return c.text(
-        "WebSockets are not enabled for this driver. Use SSE instead.",
-        400
-      );
-    }
-  });
-  router.get("/connect/sse", async (c) => {
-    const authDataRaw = c.req.header(HEADER_AUTH_DATA);
-    let authData;
-    if (authDataRaw) {
-      authData = JSON.parse(authDataRaw);
-    }
-    return handleSseConnect(c, runConfig, actorDriver, c.env.actorId, authData);
-  });
-  router.post("/action/:action", async (c) => {
-    const actionName = c.req.param("action");
-    const authDataRaw = c.req.header(HEADER_AUTH_DATA);
-    let authData;
-    if (authDataRaw) {
-      authData = JSON.parse(authDataRaw);
-    }
-    return handleAction(
-      c,
-      runConfig,
-      actorDriver,
-      actionName,
-      c.env.actorId,
-      authData
-    );
-  });
-  router.post("/connections/message", async (c) => {
-    const connId = c.req.header(HEADER_CONN_ID);
-    const connToken = c.req.header(HEADER_CONN_TOKEN);
-    if (!connId || !connToken) {
-      throw new Error("Missing required parameters");
-    }
-    return handleConnectionMessage(
-      c,
-      runConfig,
-      actorDriver,
-      connId,
-      connToken,
-      c.env.actorId
-    );
-  });
-  router.all("/raw/http/*", async (c) => {
-    const authDataRaw = c.req.header(HEADER_AUTH_DATA);
-    let authData;
-    if (authDataRaw) {
-      authData = JSON.parse(authDataRaw);
-    }
-    const actor2 = await actorDriver.loadActor(c.env.actorId);
-    const url = new URL(c.req.url);
-    const originalPath = url.pathname.replace(/^\/raw\/http/, "") || "/";
-    const correctedUrl = new URL(originalPath + url.search, url.origin);
-    const correctedRequest = new Request(correctedUrl, {
-      method: c.req.method,
-      headers: c.req.raw.headers,
-      body: c.req.raw.body
-    });
-    logger().debug("rewriting http url", {
-      from: c.req.url,
-      to: correctedRequest.url
-    });
-    const response = await actor2.handleFetch(correctedRequest, {
-      auth: authData
-    });
-    if (!response) {
-      throw new InternalError("handleFetch returned void unexpectedly");
-    }
-    return response;
-  });
-  router.get(`${PATH_RAW_WEBSOCKET_PREFIX}*`, async (c) => {
-    var _a;
-    const upgradeWebSocket = (_a = runConfig.getUpgradeWebSocket) == null ? void 0 : _a.call(runConfig);
-    if (upgradeWebSocket) {
-      return upgradeWebSocket(async (c2) => {
-        const encodingRaw = c2.req.header(HEADER_ENCODING);
-        const connParamsRaw = c2.req.header(HEADER_CONN_PARAMS);
-        const authDataRaw = c2.req.header(HEADER_AUTH_DATA);
-        const encoding = EncodingSchema.parse(encodingRaw);
-        const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
-        const authData = authDataRaw ? JSON.parse(authDataRaw) : void 0;
-        const url = new URL(c2.req.url);
-        const pathWithQuery = c2.req.path + url.search;
-        logger().debug("actor router raw websocket", {
-          path: c2.req.path,
-          url: c2.req.url,
-          search: url.search,
-          pathWithQuery
-        });
-        return await handleRawWebSocketHandler(
-          c2.req.raw,
-          pathWithQuery,
-          actorDriver,
-          c2.env.actorId,
-          authData
-        );
-      })(c, noopNext());
-    } else {
-      return c.text(
-        "WebSockets are not enabled for this driver. Use SSE instead.",
-        400
-      );
-    }
-  });
-  if (runConfig.inspector.enabled) {
-    router.route(
-      "/inspect",
-      new Hono().use(secureInspector(runConfig), async (c, next) => {
-        const inspector = (await actorDriver.loadActor(c.env.actorId)).inspector;
-        invariant(inspector, "inspector not supported on this platform");
-        c.set("inspector", inspector);
-        await next();
-      }).route("/", createActorInspectorRouter())
-    );
-  }
-  router.notFound(handleRouteNotFound);
-  router.onError(
-    handleRouteError.bind(void 0, {
-      // All headers to this endpoint are considered secure, so we can enable the expose internal error header for requests from the internal client
-      enableExposeInternalError: true
-    })
-  );
-  return router;
-}
-
-// src/actor/mod.ts
-function actor(input) {
-  const config2 = ActorConfigSchema.parse(input);
-  return new ActorDefinition(config2);
-}
-
-// src/common/inline-websocket-adapter2.ts
-import { WSContext } from "hono/ws";
-var LOGGER_NAME = "fake-event-source2";
-function logger4() {
-  return getLogger(LOGGER_NAME);
-}
-var InlineWebSocketAdapter2 = class {
-  // WebSocket readyState values
-  CONNECTING = 0;
-  OPEN = 1;
-  CLOSING = 2;
-  CLOSED = 3;
-  // Private properties
-  #handler;
-  #wsContext;
-  #readyState = 0;
-  // Start in CONNECTING state
-  #queuedMessages = [];
-  // Event buffering is needed since events can be fired
-  // before JavaScript has a chance to add event listeners (e.g. within the same tick)
-  #bufferedEvents = [];
-  // Event listeners with buffering
-  #eventListeners = /* @__PURE__ */ new Map();
-  constructor(handler) {
-    this.#handler = handler;
-    this.#wsContext = new WSContext({
-      raw: this,
-      send: (data) => {
-        logger4().debug("WSContext.send called");
-        this.#handleMessage(data);
-      },
-      close: (code, reason) => {
-        logger4().debug("WSContext.close called", { code, reason });
-        this.#handleClose(code || 1e3, reason || "");
-      },
-      // Set readyState to 1 (OPEN) since handlers expect an open connection
-      readyState: 1
-    });
-    this.#initialize();
-  }
-  get readyState() {
-    return this.#readyState;
-  }
-  get binaryType() {
-    return "arraybuffer";
-  }
-  set binaryType(value) {
-  }
-  get bufferedAmount() {
-    return 0;
-  }
-  get extensions() {
-    return "";
-  }
-  get protocol() {
-    return "";
-  }
-  get url() {
-    return "";
-  }
-  send(data) {
-    logger4().debug("send called", { readyState: this.readyState });
-    if (this.readyState !== this.OPEN) {
-      const error = new Error("WebSocket is not open");
-      logger4().warn("cannot send message, websocket not open", {
-        readyState: this.readyState,
-        dataType: typeof data,
-        dataLength: typeof data === "string" ? data.length : "binary",
-        error
-      });
-      this.#fireError(error);
-      return;
-    }
-    this.#handler.onMessage({ data }, this.#wsContext);
-  }
-  /**
-   * Closes the connection
-   */
-  close(code = 1e3, reason = "") {
-    if (this.readyState === this.CLOSED || this.readyState === this.CLOSING) {
-      return;
-    }
-    logger4().debug("closing fake websocket", { code, reason });
-    this.#readyState = this.CLOSING;
-    try {
-      this.#handler.onClose({ code, reason, wasClean: true }, this.#wsContext);
-    } catch (err) {
-      logger4().error("error closing websocket", { error: err });
-    } finally {
-      this.#readyState = this.CLOSED;
-      const closeEvent = {
-        type: "close",
-        wasClean: code === 1e3,
-        code,
-        reason,
-        target: this,
-        currentTarget: this
-      };
-      this.#fireClose(closeEvent);
-    }
-  }
-  /**
-   * Initialize the connection with the handler
-   */
-  async #initialize() {
-    try {
-      logger4().debug("fake websocket initializing");
-      logger4().debug("calling handler.onOpen with WSContext");
-      this.#handler.onOpen(void 0, this.#wsContext);
-      this.#readyState = this.OPEN;
-      logger4().debug("fake websocket initialized and now OPEN");
-      this.#fireOpen();
-      if (this.#queuedMessages.length > 0) {
-        if (this.readyState !== this.OPEN) {
-          logger4().warn("socket no longer open, dropping queued messages");
-          return;
-        }
-        logger4().debug(
-          `now processing ${this.#queuedMessages.length} queued messages`
-        );
-        const messagesToProcess = [...this.#queuedMessages];
-        this.#queuedMessages = [];
-        for (const message of messagesToProcess) {
-          logger4().debug("processing queued message");
-          this.#handleMessage(message);
-        }
-      }
-    } catch (err) {
-      logger4().error("error opening fake websocket", {
-        error: err,
-        errorMessage: err instanceof Error ? err.message : String(err),
-        stack: err instanceof Error ? err.stack : void 0
-      });
-      this.#fireError(err);
-      this.close(1011, "Internal error during initialization");
-    }
-  }
-  /**
-   * Handle messages received from the server via the WSContext
-   */
-  #handleMessage(data) {
-    if (this.readyState !== this.OPEN) {
-      logger4().debug("message received before socket is OPEN, queuing", {
-        readyState: this.readyState,
-        dataType: typeof data,
-        dataLength: typeof data === "string" ? data.length : data instanceof ArrayBuffer ? data.byteLength : data instanceof Uint8Array ? data.byteLength : "unknown"
-      });
-      this.#queuedMessages.push(data);
-      return;
-    }
-    logger4().debug("fake websocket received message from server", {
-      dataType: typeof data,
-      dataLength: typeof data === "string" ? data.length : data instanceof ArrayBuffer ? data.byteLength : data instanceof Uint8Array ? data.byteLength : "unknown"
-    });
-    const event = {
-      type: "message",
-      data,
-      target: this,
-      currentTarget: this
-    };
-    this.#dispatchEvent("message", event);
-  }
-  #handleClose(code, reason) {
-    if (this.readyState === this.CLOSED) return;
-    this.#readyState = this.CLOSED;
-    const event = {
-      type: "close",
-      code,
-      reason,
-      wasClean: code === 1e3,
-      target: this,
-      currentTarget: this
-    };
-    this.#dispatchEvent("close", event);
-  }
-  addEventListener(type, listener) {
-    if (!this.#eventListeners.has(type)) {
-      this.#eventListeners.set(type, []);
-    }
-    this.#eventListeners.get(type).push(listener);
-    this.#flushBufferedEvents(type);
-  }
-  removeEventListener(type, listener) {
-    const listeners = this.#eventListeners.get(type);
-    if (listeners) {
-      const index = listeners.indexOf(listener);
-      if (index !== -1) {
-        listeners.splice(index, 1);
-      }
-    }
-  }
-  #dispatchEvent(type, event) {
-    const listeners = this.#eventListeners.get(type);
-    if (listeners && listeners.length > 0) {
-      logger4().debug(
-        `dispatching ${type} event to ${listeners.length} listeners`
-      );
-      for (const listener of listeners) {
-        try {
-          listener(event);
-        } catch (err) {
-          logger4().error(`error in ${type} event listener`, { error: err });
-        }
-      }
-    } else {
-      logger4().debug(`no ${type} listeners registered, buffering event`);
-      this.#bufferedEvents.push({ type, event });
-    }
-    switch (type) {
-      case "open":
-        if (this.#onopen) {
-          try {
-            this.#onopen(event);
-          } catch (error) {
-            logger4().error("error in onopen handler", { error });
-          }
-        }
-        break;
-      case "close":
-        if (this.#onclose) {
-          try {
-            this.#onclose(event);
-          } catch (error) {
-            logger4().error("error in onclose handler", { error });
-          }
-        }
-        break;
-      case "error":
-        if (this.#onerror) {
-          try {
-            this.#onerror(event);
-          } catch (error) {
-            logger4().error("error in onerror handler", { error });
-          }
-        }
-        break;
-      case "message":
-        if (this.#onmessage) {
-          try {
-            this.#onmessage(event);
-          } catch (error) {
-            logger4().error("error in onmessage handler", { error });
-          }
-        }
-        break;
-    }
-  }
-  dispatchEvent(event) {
-    this.#dispatchEvent(event.type, event);
-    return true;
-  }
-  #flushBufferedEvents(type) {
-    const eventsToFlush = this.#bufferedEvents.filter(
-      (buffered) => buffered.type === type
-    );
-    this.#bufferedEvents = this.#bufferedEvents.filter(
-      (buffered) => buffered.type !== type
-    );
-    for (const { event } of eventsToFlush) {
-      this.#dispatchEvent(type, event);
-    }
-  }
-  #fireOpen() {
-    try {
-      const event = {
-        type: "open",
-        target: this,
-        currentTarget: this
-      };
-      this.#dispatchEvent("open", event);
-    } catch (err) {
-      logger4().error("error in open event", { error: err });
-    }
-  }
-  #fireClose(event) {
-    try {
-      this.#dispatchEvent("close", event);
-    } catch (err) {
-      logger4().error("error in close event", { error: err });
-    }
-  }
-  #fireError(error) {
-    try {
-      const event = {
-        type: "error",
-        target: this,
-        currentTarget: this,
-        error,
-        message: error instanceof Error ? error.message : String(error)
-      };
-      this.#dispatchEvent("error", event);
-    } catch (err) {
-      logger4().error("error in error event", { error: err });
-    }
-    logger4().error("websocket error", { error });
-  }
-  // Event handler properties with getters/setters
-  #onopen = null;
-  #onclose = null;
-  #onerror = null;
-  #onmessage = null;
-  get onopen() {
-    return this.#onopen;
-  }
-  set onopen(handler) {
-    this.#onopen = handler;
-  }
-  get onclose() {
-    return this.#onclose;
-  }
-  set onclose(handler) {
-    this.#onclose = handler;
-  }
-  get onerror() {
-    return this.#onerror;
-  }
-  set onerror(handler) {
-    this.#onerror = handler;
-  }
-  get onmessage() {
-    return this.#onmessage;
-  }
-  set onmessage(handler) {
-    this.#onmessage = handler;
-  }
-};
-
-// src/drivers/engine/actor-driver.ts
-import { Runner } from "@rivetkit/engine-runner";
-import * as cbor2 from "cbor-x";
-import { WSContext as WSContext2 } from "hono/ws";
-import invariant2 from "invariant";
-
-// src/drivers/engine/keys.ts
-var EMPTY_KEY = "/";
-var KEY_SEPARATOR = "/";
-function serializeActorKey(key) {
-  if (key.length === 0) {
-    return EMPTY_KEY;
-  }
-  const escapedParts = key.map((part) => {
-    if (part === "") {
-      return "\\0";
-    }
-    let escaped = part.replace(/\\/g, "\\\\");
-    escaped = escaped.replace(/\//g, `\\${KEY_SEPARATOR}`);
-    return escaped;
-  });
-  return escapedParts.join(KEY_SEPARATOR);
-}
-function deserializeActorKey(keyString) {
-  if (keyString === void 0 || keyString === null || keyString === EMPTY_KEY) {
-    return [];
-  }
-  const parts = [];
-  let currentPart = "";
-  let escaping = false;
-  let isEmptyStringMarker = false;
-  for (let i = 0; i < keyString.length; i++) {
-    const char = keyString[i];
-    if (escaping) {
-      if (char === "0") {
-        isEmptyStringMarker = true;
-      } else {
-        currentPart += char;
-      }
-      escaping = false;
-    } else if (char === "\\") {
-      escaping = true;
-    } else if (char === KEY_SEPARATOR) {
-      if (isEmptyStringMarker) {
-        parts.push("");
-        isEmptyStringMarker = false;
-      } else {
-        parts.push(currentPart);
-      }
-      currentPart = "";
-    } else {
-      currentPart += char;
-    }
-  }
-  if (escaping) {
-    parts.push(currentPart + "\\");
-  } else if (isEmptyStringMarker) {
-    parts.push("");
-  } else if (currentPart !== "" || parts.length > 0) {
-    parts.push(currentPart);
-  }
-  return parts;
-}
-
-// src/drivers/engine/kv.ts
-var KEYS = {
-  PERSIST_DATA: Uint8Array.from([1, 1])
-};
-
-// src/drivers/engine/log.ts
-var LOGGER_NAME2 = "driver-engine";
-function logger5() {
-  return getLogger(LOGGER_NAME2);
-}
-
-// src/drivers/engine/actor-driver.ts
-var EngineActorDriver = class {
-  #registryConfig;
-  #runConfig;
-  #managerDriver;
-  #inlineClient;
-  #config;
-  #runner;
-  #actors = /* @__PURE__ */ new Map();
-  #actorRouter;
-  #version = 1;
-  // Version for the runner protocol
-  constructor(registryConfig, runConfig, managerDriver, inlineClient, config2) {
-    this.#registryConfig = registryConfig;
-    this.#runConfig = runConfig;
-    this.#managerDriver = managerDriver;
-    this.#inlineClient = inlineClient;
-    this.#config = config2;
-    this.#actorRouter = createActorRouter(runConfig, this);
-    let hasDisconnected = false;
-    const runnerConfig = {
-      version: this.#version,
-      endpoint: config2.endpoint,
-      pegboardEndpoint: config2.pegboardEndpoint,
-      namespace: config2.namespace,
-      totalSlots: config2.totalSlots,
-      runnerName: config2.runnerName,
-      runnerKey: config2.runnerKey,
-      metadata: {
-        inspectorToken: this.#runConfig.inspector.token()
-      },
-      prepopulateActorNames: Object.fromEntries(
-        Object.keys(this.#registryConfig.use).map((name) => [
-          name,
-          { metadata: {} }
-        ])
-      ),
-      onConnected: () => {
-        if (hasDisconnected) {
-          logger5().info("runner reconnected", {
-            namespace: this.#config.namespace,
-            runnerName: this.#config.runnerName
-          });
-        } else {
-          logger5().debug("runner connected", {
-            namespace: this.#config.namespace,
-            runnerName: this.#config.runnerName
-          });
-        }
-      },
-      onDisconnected: () => {
-        logger5().warn("runner disconnected", {
-          namespace: this.#config.namespace,
-          runnerName: this.#config.runnerName
-        });
-        hasDisconnected = true;
-      },
-      fetch: this.#runnerFetch.bind(this),
-      websocket: this.#runnerWebSocket.bind(this),
-      onActorStart: this.#runnerOnActorStart.bind(this),
-      onActorStop: this.#runnerOnActorStop.bind(this)
-    };
-    this.#runner = new Runner(runnerConfig);
-    this.#runner.start();
-    logger5().debug("engine runner started", {
-      endpoint: config2.endpoint,
-      namespace: config2.namespace,
-      runnerName: config2.runnerName
-    });
-  }
-  async #loadActorHandler(actorId) {
-    const handler = this.#actors.get(actorId);
-    if (!handler) throw new Error(`Actor handler does not exist ${actorId}`);
-    if (handler.actorStartPromise) await handler.actorStartPromise.promise;
-    if (!handler.actor) throw new Error("Actor should be loaded");
-    return handler;
-  }
-  async loadActor(actorId) {
-    const handler = await this.#loadActorHandler(actorId);
-    if (!handler.actor) throw new Error(`Actor ${actorId} failed to load`);
-    return handler.actor;
-  }
-  getGenericConnGlobalState(actorId) {
-    const handler = this.#actors.get(actorId);
-    if (!handler) {
-      throw new Error(`Actor ${actorId} not loaded`);
-    }
-    return handler.genericConnGlobalState;
-  }
-  getContext(actorId) {
-    return {};
-  }
-  async readPersistedData(actorId) {
-    const handler = this.#actors.get(actorId);
-    if (!handler) throw new Error(`Actor ${actorId} not loaded`);
-    if (handler.persistedData) return handler.persistedData;
-    const [value] = await this.#runner.kvGet(actorId, [KEYS.PERSIST_DATA]);
-    if (value !== null) {
-      handler.persistedData = value;
-      return value;
-    } else {
-      return void 0;
-    }
-  }
-  async writePersistedData(actorId, data) {
-    const handler = this.#actors.get(actorId);
-    if (!handler) throw new Error(`Actor ${actorId} not loaded`);
-    handler.persistedData = data;
-    await this.#runner.kvPut(actorId, [[KEYS.PERSIST_DATA, data]]);
-  }
-  async setAlarm(actor2, timestamp) {
-  }
-  async getDatabase(_actorId) {
-    return void 0;
-  }
-  // Runner lifecycle callbacks
-  async #runnerOnActorStart(actorId, generation, config2) {
-    var _a;
-    logger5().debug("runner actor starting", {
-      actorId,
-      name: config2.name,
-      key: config2.key,
-      generation
-    });
-    let input;
-    if (config2.input) {
-      input = cbor2.decode(config2.input);
-    }
-    let handler = this.#actors.get(actorId);
-    if (!handler) {
-      handler = {
-        genericConnGlobalState: new GenericConnGlobalState(),
-        actorStartPromise: Promise.withResolvers(),
-        persistedData: serializeEmptyPersistData(input)
-      };
-      this.#actors.set(actorId, handler);
-    }
-    const name = config2.name;
-    invariant2(config2.key, "actor should have a key");
-    const key = deserializeActorKey(config2.key);
-    const definition = lookupInRegistry(
-      this.#registryConfig,
-      config2.name
-      // TODO: Remove cast
-    );
-    handler.actor = definition.instantiate();
-    const connDrivers = createGenericConnDrivers(
-      handler.genericConnGlobalState
-    );
-    await handler.actor.start(
-      connDrivers,
-      this,
-      this.#inlineClient,
-      actorId,
-      name,
-      key,
-      "unknown"
-      // TODO: Add regions
-    );
-    (_a = handler.actorStartPromise) == null ? void 0 : _a.resolve();
-    handler.actorStartPromise = void 0;
-    logger5().debug("runner actor started", { actorId, name, key });
-  }
-  async #runnerOnActorStop(actorId, generation) {
-    logger5().debug("runner actor stopping", { actorId, generation });
-    const handler = this.#actors.get(actorId);
-    if (handler == null ? void 0 : handler.actor) {
-      await handler.actor._stop();
-      this.#actors.delete(actorId);
-    }
-    logger5().debug("runner actor stopped", { actorId });
-  }
-  async #runnerFetch(actorId, request) {
-    logger5().debug("runner fetch", {
-      actorId,
-      url: request.url,
-      method: request.method
-    });
-    return await this.#actorRouter.fetch(request, { actorId });
-  }
-  async #runnerWebSocket(actorId, websocketRaw, request) {
-    const websocket = websocketRaw;
-    logger5().debug("runner websocket", { actorId, url: request.url });
-    const url = new URL(request.url);
-    const encodingRaw = request.headers.get(HEADER_ENCODING);
-    const connParamsRaw = request.headers.get(HEADER_CONN_PARAMS);
-    const authDataRaw = request.headers.get(HEADER_AUTH_DATA);
-    const encoding = EncodingSchema.parse(encodingRaw);
-    const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
-    const authData = authDataRaw ? JSON.parse(authDataRaw) : void 0;
-    let wsHandlerPromise;
-    if (url.pathname === PATH_CONNECT_WEBSOCKET) {
-      wsHandlerPromise = handleWebSocketConnect(
-        request,
-        this.#runConfig,
-        this,
-        actorId,
-        encoding,
-        connParams,
-        authData
-      );
-    } else if (url.pathname.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {
-      wsHandlerPromise = handleRawWebSocketHandler(
-        request,
-        url.pathname + url.search,
-        this,
-        actorId,
-        authData
-      );
-    } else {
-      throw new Error(`Unreachable path: ${url.pathname}`);
-    }
-    const wsContext = new WSContext2(websocket);
-    wsHandlerPromise.catch((err) => {
-      logger5().error("building websocket handlers errored", { err });
-      wsContext.close(1011, `${err}`);
-    });
-    if (websocket.readyState === 1) {
-      wsHandlerPromise.then((x) => {
-        var _a;
-        return (_a = x.onOpen) == null ? void 0 : _a.call(x, new Event("open"), wsContext);
-      });
-    } else {
-      websocket.addEventListener("open", (event) => {
-        wsHandlerPromise.then((x) => {
-          var _a;
-          return (_a = x.onOpen) == null ? void 0 : _a.call(x, event, wsContext);
-        });
-      });
-    }
-    websocket.addEventListener("message", (event) => {
-      wsHandlerPromise.then((x) => {
-        var _a;
-        return (_a = x.onMessage) == null ? void 0 : _a.call(x, event, wsContext);
-      });
-    });
-    websocket.addEventListener("close", (event) => {
-      wsHandlerPromise.then((x) => {
-        var _a;
-        return (_a = x.onClose) == null ? void 0 : _a.call(x, event, wsContext);
-      });
-    });
-    websocket.addEventListener("error", (event) => {
-      wsHandlerPromise.then((x) => {
-        var _a;
-        return (_a = x.onError) == null ? void 0 : _a.call(x, event, wsContext);
-      });
-    });
-  }
-  async sleep(actorId) {
-    this.#runner.sleepActor(actorId);
-  }
-  async shutdown(immediate) {
-    logger5().info("stopping engine actor driver");
-    await this.#runner.shutdown(immediate);
-  }
-};
-
-// src/drivers/engine/config.ts
-import { z as z2 } from "zod";
-var ConfigSchema = z2.object({
-  app: z2.custom().optional(),
-  endpoint: z2.string().default(
-    () => getEnvUniversal("RIVET_ENGINE") ?? "http://localhost:7080"
-  ),
-  pegboardEndpoint: z2.string().optional(),
-  namespace: z2.string().default(() => getEnvUniversal("RIVET_NAMESPACE") ?? "default"),
-  runnerName: z2.string().default(() => getEnvUniversal("RIVET_RUNNER") ?? "rivetkit"),
-  // TODO: Automatically attempt ot determine key by common env vars (e.g. k8s pod name)
-  runnerKey: z2.string().default(
-    () => getEnvUniversal("RIVET_RUNNER_KEY") ?? crypto.randomUUID()
-  ),
-  totalSlots: z2.number().default(1e5),
-  addresses: z2.record(
-    z2.object({
-      host: z2.string(),
-      port: z2.number()
-    })
-  ).default({ main: { host: "127.0.0.1", port: 5051 } })
-}).default({});
-
-// src/drivers/engine/manager-driver.ts
-import * as cbor3 from "cbor-x";
-import invariant3 from "invariant";
-
-// src/drivers/engine/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";
-  }
-};
-async function apiCall(endpoint, namespace, method, path3, body) {
-  const url = `${endpoint}${path3}${path3.includes("?") ? "&" : "?"}namespace=${encodeURIComponent(namespace)}`;
-  const options = {
-    method,
-    headers: {
-      "Content-Type": "application/json"
-    }
-  };
-  if (body !== void 0 && method !== "GET") {
-    options.body = JSON.stringify(body);
-  }
-  logger5().debug("making api call", { method, url });
-  const response = await fetch(url, options);
-  if (!response.ok) {
-    const errorText = await response.text();
-    logger5().error("api call failed", {
-      status: response.status,
-      statusText: response.statusText,
-      error: errorText,
-      method,
-      path: path3
-    });
-    try {
-      const errorData = JSON.parse(errorText);
-      if (errorData.kind === "error" && errorData.group && errorData.code) {
-        throw new EngineApiError(
-          errorData.group,
-          errorData.code,
-          errorData.message
-        );
-      }
-    } catch (parseError) {
-    }
-    throw new Error(
-      `API call failed: ${response.status} ${response.statusText}`
-    );
-  }
-  return response.json();
-}
-
-// src/drivers/engine/api-endpoints.ts
-async function getActor(config2, actorId) {
-  return apiCall(
-    config2.endpoint,
-    config2.namespace,
-    "GET",
-    `/actors/${encodeURIComponent(actorId)}`
-  );
-}
-async function getActorById(config2, name, key) {
-  const serializedKey = serializeActorKey(key);
-  return apiCall(
-    config2.endpoint,
-    config2.namespace,
-    "GET",
-    `/actors/by-id?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`
-  );
-}
-async function getOrCreateActorById(config2, request) {
-  return apiCall(
-    config2.endpoint,
-    config2.namespace,
-    "PUT",
-    `/actors/by-id`,
-    request
-  );
-}
-async function createActor(config2, request) {
-  return apiCall(
-    config2.endpoint,
-    config2.namespace,
-    "POST",
-    `/actors`,
-    request
-  );
-}
-async function destroyActor(config2, actorId) {
-  return apiCall(
-    config2.endpoint,
-    config2.namespace,
-    "DELETE",
-    `/actors/${encodeURIComponent(actorId)}`
-  );
-}
-
-// src/drivers/engine/ws-proxy.ts
-async function createWebSocketProxy(c, targetUrl, headers) {
-  const WebSocket2 = await importWebSocket();
-  for (const [k, v] of c.req.raw.headers.entries()) {
-    if (!k.startsWith("sec-") && k !== "connection" && k !== "upgrade") {
-      headers[k] = v;
-    }
-  }
-  const state = {};
-  return {
-    onOpen: async (event, clientWs) => {
-      logger5().debug("client websocket connected", { targetUrl });
-      if (clientWs.readyState !== 1) {
-        logger5().warn("client websocket not open on connection", {
-          targetUrl,
-          readyState: clientWs.readyState
-        });
-        return;
-      }
-      const targetWs = new WebSocket2(targetUrl, { headers });
-      state.targetWs = targetWs;
-      state.connectPromise = new Promise((resolve, reject) => {
-        targetWs.addEventListener("open", () => {
-          logger5().debug("target websocket connected", { targetUrl });
-          if (clientWs.readyState !== 1) {
-            logger5().warn("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) => {
-          logger5().warn("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) => {
-        logger5().debug("target websocket closed", {
-          targetUrl,
-          code: event2.code,
-          reason: event2.reason
-        });
-        closeWebSocketIfOpen(clientWs, event2.code, event2.reason);
-      });
-      state.targetWs.addEventListener("error", (error) => {
-        logger5().error("target websocket error", { targetUrl, error });
-        closeWebSocketIfOpen(clientWs, 1011, "Target WebSocket error");
-      });
-    },
-    onMessage: async (event, clientWs) => {
-      if (!state.targetWs || !state.connectPromise) {
-        logger5().error("websocket state not initialized", { targetUrl });
-        return;
-      }
-      try {
-        await state.connectPromise;
-        if (state.targetWs.readyState === WebSocket2.OPEN) {
-          state.targetWs.send(event.data);
-        } else {
-          logger5().warn("target websocket not open", {
-            targetUrl,
-            readyState: state.targetWs.readyState
-          });
-        }
-      } catch (error) {
-        logger5().error("failed to connect to target websocket", {
-          targetUrl,
-          error
-        });
-        closeWebSocketIfOpen(clientWs, 1011, "Failed to connect to target");
-      }
-    },
-    onClose: (event, clientWs) => {
-      logger5().debug("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) => {
-      logger5().error("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/drivers/engine/manager-driver.ts
-var EngineManagerDriver = class {
-  #config;
-  #runConfig;
-  #importWebSocketPromise;
-  constructor(config2, runConfig) {
-    this.#config = config2;
-    this.#runConfig = runConfig;
-    if (!this.#runConfig.inspector.token()) {
-      const token = generateRandomString();
-      this.#runConfig.inspector.token = () => token;
-    }
-    this.#importWebSocketPromise = importWebSocket();
-  }
-  async sendRequest(actorId, actorRequest) {
-    logger5().debug("sending request to actor via guard", {
-      actorId,
-      method: actorRequest.method,
-      url: actorRequest.url
-    });
-    return this.#forwardHttpRequest(actorRequest, actorId);
-  }
-  async openWebSocket(path3, actorId, encoding, params) {
-    const WebSocket2 = await this.#importWebSocketPromise;
-    const guardUrl = `${this.#config.endpoint}${path3}`;
-    logger5().debug("opening websocket to actor via guard", {
-      actorId,
-      path: path3,
-      guardUrl
-    });
-    const ws = new WebSocket2(guardUrl, {
-      headers: buildGuardHeadersForWebSocket(actorId, encoding, params)
-    });
-    logger5().debug("websocket connection opened", { actorId });
-    return ws;
-  }
-  async proxyRequest(_c, actorRequest, actorId) {
-    logger5().debug("forwarding request to actor via guard", {
-      actorId,
-      method: actorRequest.method,
-      url: actorRequest.url,
-      hasBody: !!actorRequest.body
-    });
-    return this.#forwardHttpRequest(actorRequest, actorId);
-  }
-  async proxyWebSocket(c, path3, actorId, encoding, params, authData) {
-    var _a, _b;
-    const upgradeWebSocket = (_b = (_a = this.#runConfig).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
-    invariant3(upgradeWebSocket, "missing getUpgradeWebSocket");
-    const guardUrl = `${this.#config.endpoint}${path3}`;
-    const wsGuardUrl = guardUrl.replace("http://", "ws://");
-    logger5().debug("forwarding websocket to actor via guard", {
-      actorId,
-      path: path3,
-      guardUrl
-    });
-    const headers = buildGuardHeadersForWebSocket(
-      actorId,
-      encoding,
-      params,
-      authData
-    );
-    const args = await createWebSocketProxy(c, wsGuardUrl, headers);
-    return await upgradeWebSocket(() => args)(c, noopNext());
-  }
-  extraStartupLog() {
-    return {
-      engine: this.#config.endpoint,
-      namespace: this.#config.namespace,
-      runner: this.#config.runnerName,
-      address: Object.values(this.#config.addresses).map((v) => `${v.host}:${v.port}`).join(", ")
-    };
-  }
-  async getForId({
-    c,
-    name,
-    actorId
-  }) {
-    try {
-      const response = await getActor(this.#config, actorId);
-      if (response.actor.name !== name) {
-        logger5().debug("actor name mismatch from api", {
-          actorId,
-          apiName: response.actor.name,
-          requestedName: name
-        });
-        return void 0;
-      }
-      const keyRaw = response.actor.key;
-      invariant3(keyRaw, `actor ${actorId} should have key`);
-      const key = deserializeActorKey(keyRaw);
-      return {
-        actorId,
-        name,
-        key
-      };
-    } catch (error) {
-      if (error instanceof EngineApiError && error.group === "actor" && error.code === "not_found") {
-        return void 0;
-      }
-      throw error;
-    }
-  }
-  async getWithKey({
-    c,
-    name,
-    key
-  }) {
-    logger5().debug("getWithKey: searching for actor", { name, key });
-    try {
-      const response = await getActorById(this.#config, name, key);
-      if (!response.actor_id) {
-        return void 0;
-      }
-      const actorId = response.actor_id;
-      logger5().debug("getWithKey: found actor via api", {
-        actorId,
-        name,
-        key
-      });
-      return {
-        actorId,
-        name,
-        key
-      };
-    } catch (error) {
-      if (error instanceof EngineApiError && error.group === "actor" && error.code === "not_found") {
-        return void 0;
-      }
-      throw error;
-    }
-  }
-  async getOrCreateWithKey(input) {
-    const { c, name, key, input: actorInput, region } = input;
-    logger5().info(
-      "getOrCreateWithKey: getting or creating actor via engine api",
-      {
-        name,
-        key
-      }
-    );
-    const response = await getOrCreateActorById(this.#config, {
-      name,
-      key: serializeActorKey(key),
-      runner_name_selector: this.#config.runnerName,
-      input: input ? cbor3.encode(actorInput).toString("base64") : void 0,
-      crash_policy: "sleep"
-    });
-    const actorId = response.actor_id;
-    logger5().info("getOrCreateWithKey: actor ready", {
-      actorId,
-      name,
-      key,
-      created: response.created
-    });
-    return {
-      actorId,
-      name,
-      key
-    };
-  }
-  async createActor({
-    c,
-    name,
-    key,
-    input
-  }) {
-    const existingActor = await this.getWithKey({ c, name, key });
-    if (existingActor) {
-      throw new ActorAlreadyExists(name, key);
-    }
-    logger5().info("creating actor via engine api", { name, key });
-    const result = await createActor(this.#config, {
-      name,
-      runner_name_selector: this.#config.runnerName,
-      key: serializeActorKey(key),
-      input: input ? cbor3.encode(input).toString("base64") : null,
-      crash_policy: "sleep"
-    });
-    const actorId = result.actor.actor_id;
-    logger5().info("actor created", { actorId, name, key });
-    return {
-      actorId,
-      name,
-      key
-    };
-  }
-  async destroyActor(actorId) {
-    logger5().info("destroying actor via engine api", { actorId });
-    await destroyActor(this.#config, actorId);
-    logger5().info("actor destroyed", { actorId });
-  }
-  async #forwardHttpRequest(actorRequest, actorId) {
-    const url = new URL(actorRequest.url);
-    const guardUrl = `${this.#config.endpoint}${url.pathname}${url.search}`;
-    let bodyToSend = null;
-    const guardHeaders = buildGuardHeadersForHttp(actorRequest, actorId);
-    if (actorRequest.body && actorRequest.method !== "GET" && actorRequest.method !== "HEAD") {
-      if (actorRequest.bodyUsed) {
-        throw new Error("Request body has already been consumed");
-      }
-      const clonedRequest = actorRequest.clone();
-      bodyToSend = await clonedRequest.arrayBuffer();
-      guardHeaders.delete("transfer-encoding");
-      guardHeaders.set(
-        "content-length",
-        String(bodyToSend.byteLength)
-      );
-    }
-    const guardRequest = new Request(guardUrl, {
-      method: actorRequest.method,
-      headers: guardHeaders,
-      body: bodyToSend
-    });
-    return mutableResponse(await fetch(guardRequest));
-  }
-};
-function mutableResponse(fetchRes) {
-  return new Response(fetchRes.body, fetchRes);
-}
-function buildGuardHeadersForHttp(actorRequest, actorId) {
-  const headers = new Headers();
-  for (const [key, value] of actorRequest.headers.entries()) {
-    headers.set(key, value);
-  }
-  headers.set("x-rivet-target", "actor");
-  headers.set("x-rivet-actor", actorId);
-  headers.set("x-rivet-port", "main");
-  return headers;
-}
-function buildGuardHeadersForWebSocket(actorId, encoding, params, authData) {
-  const headers = {};
-  headers["x-rivet-target"] = "actor";
-  headers["x-rivet-actor"] = actorId;
-  headers["x-rivet-port"] = "main";
-  headers[HEADER_EXPOSE_INTERNAL_ERROR] = "true";
-  headers[HEADER_ENCODING] = encoding;
-  if (params) {
-    headers[HEADER_CONN_PARAMS] = JSON.stringify(params);
-  }
-  if (authData) {
-    headers[HEADER_AUTH_DATA] = JSON.stringify(authData);
-  }
-  return headers;
-}
-
-// src/drivers/engine/mod.ts
-function createEngineDriver(inputConfig) {
-  const config2 = ConfigSchema.parse(inputConfig);
-  return {
-    name: "engine",
-    manager: (_registryConfig, runConfig) => {
-      return new EngineManagerDriver(config2, runConfig);
-    },
-    actor: (registryConfig, runConfig, managerDriver, inlineClient) => {
-      return new EngineActorDriver(
-        registryConfig,
-        runConfig,
-        managerDriver,
-        inlineClient,
-        config2
-      );
-    }
-  };
-}
-
-// src/drivers/file-system/actor.ts
-var FileSystemActorDriver = class {
-  #registryConfig;
-  #runConfig;
-  #managerDriver;
-  #inlineClient;
-  #state;
-  constructor(registryConfig, runConfig, managerDriver, inlineClient, state) {
-    this.#registryConfig = registryConfig;
-    this.#runConfig = runConfig;
-    this.#managerDriver = managerDriver;
-    this.#inlineClient = inlineClient;
-    this.#state = state;
-  }
-  async loadActor(actorId) {
-    return this.#state.startActor(
-      this.#registryConfig,
-      this.#runConfig,
-      this.#inlineClient,
-      this,
-      actorId
-    );
-  }
-  getGenericConnGlobalState(actorId) {
-    return this.#state.getActorOrError(actorId).genericConnGlobalState;
-  }
-  /**
-   * Get the current storage directory path
-   */
-  get storagePath() {
-    return this.#state.storagePath;
-  }
-  getContext(_actorId) {
-    return {};
-  }
-  async readPersistedData(actorId) {
-    return new Uint8Array(
-      (await this.#state.loadActorStateOrError(actorId)).persistedData
-    );
-  }
-  async writePersistedData(actorId, data) {
-    const state = await this.#state.loadActorStateOrError(actorId);
-    await this.#state.writeActor(actorId, {
-      ...state,
-      persistedData: bufferToArrayBuffer(data)
-    });
-  }
-  async setAlarm(actor2, timestamp) {
-    await this.#state.setActorAlarm(actor2.id, timestamp);
-  }
-  getDatabase(actorId) {
-    return this.#state.createDatabase(actorId);
-  }
-  sleep(actorId) {
-    return this.#state.sleepActor(actorId);
-  }
-};
-
-// src/drivers/file-system/global-state.ts
-import * as crypto4 from "crypto";
-import * as fsSync2 from "fs";
-import * as fs2 from "fs/promises";
-import * as path2 from "path";
-import invariant4 from "invariant";
-
-// dist/schemas/file-system-driver/v1.ts
-import * as bare from "@bare-ts/lib";
-var config = /* @__PURE__ */ bare.Config({});
-function read0(bc) {
-  const len = bare.readUintSafe(bc);
-  if (len === 0) {
-    return [];
-  }
-  const result = [bare.readString(bc)];
-  for (let i = 1; i < len; i++) {
-    result[i] = bare.readString(bc);
-  }
-  return result;
-}
-function write0(bc, x) {
-  bare.writeUintSafe(bc, x.length);
-  for (let i = 0; i < x.length; i++) {
-    bare.writeString(bc, x[i]);
-  }
-}
-function readActorState(bc) {
-  return {
-    actorId: bare.readString(bc),
-    name: bare.readString(bc),
-    key: read0(bc),
-    persistedData: bare.readData(bc),
-    createdAt: bare.readU64(bc)
-  };
-}
-function writeActorState(bc, x) {
-  bare.writeString(bc, x.actorId);
-  bare.writeString(bc, x.name);
-  write0(bc, x.key);
-  bare.writeData(bc, x.persistedData);
-  bare.writeU64(bc, x.createdAt);
-}
-function encodeActorState(x) {
-  const bc = new bare.ByteCursor(
-    new Uint8Array(config.initialBufferLength),
-    config
-  );
-  writeActorState(bc, x);
-  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
-}
-function decodeActorState(bytes) {
-  const bc = new bare.ByteCursor(bytes, config);
-  const result = readActorState(bc);
-  if (bc.offset < bc.view.byteLength) {
-    throw new bare.BareError(bc.offset, "remaining bytes");
-  }
-  return result;
-}
-function readActorAlarm(bc) {
-  return {
-    actorId: bare.readString(bc),
-    timestamp: bare.readUint(bc)
-  };
-}
-function writeActorAlarm(bc, x) {
-  bare.writeString(bc, x.actorId);
-  bare.writeUint(bc, x.timestamp);
-}
-function encodeActorAlarm(x) {
-  const bc = new bare.ByteCursor(
-    new Uint8Array(config.initialBufferLength),
-    config
-  );
-  writeActorAlarm(bc, x);
-  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
-}
-function decodeActorAlarm(bytes) {
-  const bc = new bare.ByteCursor(bytes, config);
-  const result = readActorAlarm(bc);
-  if (bc.offset < bc.view.byteLength) {
-    throw new bare.BareError(bc.offset, "remaining bytes");
-  }
-  return result;
-}
-
-// src/schemas/file-system-driver/versioned.ts
-var CURRENT_VERSION = 1;
-var migrations = /* @__PURE__ */ new Map();
-var ACTOR_STATE_VERSIONED = createVersionedDataHandler({
-  currentVersion: CURRENT_VERSION,
-  migrations,
-  serializeVersion: (data) => encodeActorState(data),
-  deserializeVersion: (bytes) => decodeActorState(bytes)
-});
-var ACTOR_ALARM_VERSIONED = createVersionedDataHandler({
-  currentVersion: CURRENT_VERSION,
-  migrations,
-  serializeVersion: (data) => encodeActorAlarm(data),
-  deserializeVersion: (bytes) => decodeActorAlarm(bytes)
-});
-
-// src/drivers/file-system/log.ts
-var LOGGER_NAME3 = "driver-fs";
-function logger6() {
-  return getLogger(LOGGER_NAME3);
-}
-
-// src/drivers/file-system/utils.ts
-import * as crypto3 from "crypto";
-import * as fsSync from "fs";
-import * as fs from "fs/promises";
-import * as os from "os";
-import * as path from "path";
-function generateActorId(name, key) {
-  const jsonString = JSON.stringify([name, key]);
-  const hash = crypto3.createHash("sha256").update(jsonString).digest("hex").substring(0, 16);
-  return hash;
-}
-function createHashForPath(dirPath) {
-  const normalizedPath = path.normalize(dirPath);
-  const lastComponent = path.basename(normalizedPath);
-  const hash = crypto3.createHash("sha256").update(normalizedPath).digest("hex").substring(0, 8);
-  return `${lastComponent}-${hash}`;
-}
-function getStoragePath(customPath) {
-  const dataPath = getDataPath("rivetkit");
-  const pathToHash = customPath || process.cwd();
-  const dirHash = createHashForPath(pathToHash);
-  return path.join(dataPath, dirHash);
-}
-async function pathExists(path3) {
-  try {
-    await fs.access(path3);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function ensureDirectoryExists(directoryPath) {
-  if (!await pathExists(directoryPath)) {
-    await fs.mkdir(directoryPath, { recursive: true });
-  }
-}
-function ensureDirectoryExistsSync(directoryPath) {
-  if (!fsSync.existsSync(directoryPath)) {
-    fsSync.mkdirSync(directoryPath, { recursive: true });
-  }
-}
-function getDataPath(appName) {
-  const platform = process.platform;
-  const homeDir = os.homedir();
-  switch (platform) {
-    case "win32":
-      return path.join(
-        process.env.APPDATA || path.join(homeDir, "AppData", "Roaming"),
-        appName
-      );
-    case "darwin":
-      return path.join(homeDir, "Library", "Application Support", appName);
-    default:
-      return path.join(
-        process.env.XDG_DATA_HOME || path.join(homeDir, ".local", "share"),
-        appName
-      );
-  }
-}
-
-// src/drivers/file-system/global-state.ts
-var FileSystemGlobalState = class {
-  #storagePath;
-  #stateDir;
-  #dbsDir;
-  #alarmsDir;
-  #persist;
-  #actors = /* @__PURE__ */ new Map();
-  #actorCountOnStartup = 0;
-  #runnerParams;
-  get storagePath() {
-    return this.#storagePath;
-  }
-  get actorCountOnStartup() {
-    return this.#actorCountOnStartup;
-  }
-  constructor(persist = true, customPath) {
-    this.#persist = persist;
-    this.#storagePath = persist ? getStoragePath(customPath) : "/tmp";
-    this.#stateDir = path2.join(this.#storagePath, "state");
-    this.#dbsDir = path2.join(this.#storagePath, "databases");
-    this.#alarmsDir = path2.join(this.#storagePath, "alarms");
-    if (this.#persist) {
-      ensureDirectoryExistsSync(this.#stateDir);
-      ensureDirectoryExistsSync(this.#dbsDir);
-      ensureDirectoryExistsSync(this.#alarmsDir);
-      try {
-        const actorIds = fsSync2.readdirSync(this.#stateDir);
-        this.#actorCountOnStartup = actorIds.length;
-      } catch (error) {
-        logger6().error("failed to count actors", { error });
-      }
-      logger6().debug("file system driver ready", {
-        dir: this.#storagePath,
-        actorCount: this.#actorCountOnStartup
-      });
-      try {
-        this.#cleanupTempFilesSync();
-      } catch (err) {
-        logger6().error("failed to cleanup temp files", { error: err });
-      }
-    } else {
-      logger6().debug("memory driver ready");
-    }
-  }
-  getActorStatePath(actorId) {
-    return path2.join(this.#stateDir, actorId);
-  }
-  getActorDbPath(actorId) {
-    return path2.join(this.#dbsDir, `${actorId}.db`);
-  }
-  getActorAlarmPath(actorId) {
-    return path2.join(this.#alarmsDir, actorId);
-  }
-  async *getActorsIterator(params) {
-    let actorIds = Array.from(this.#actors.keys()).sort();
-    if (fsSync2.existsSync(this.#stateDir)) {
-      actorIds = fsSync2.readdirSync(this.#stateDir).filter((id) => !id.includes(".tmp")).sort();
-    }
-    const startIndex = params.cursor ? actorIds.indexOf(params.cursor) + 1 : 0;
-    for (let i = startIndex; i < actorIds.length; i++) {
-      const actorId = actorIds[i];
-      if (!actorId) {
-        continue;
-      }
-      try {
-        const state = await this.loadActorStateOrError(actorId);
-        yield state;
-      } catch (error) {
-        logger6().error("failed to load actor state", { actorId, error });
-      }
-    }
-  }
-  /**
-   * Ensures an entry exists for this actor.
-   *
-   * Used for #createActor and #loadActor.
-   */
-  #upsertEntry(actorId) {
-    let entry = this.#actors.get(actorId);
-    if (entry) {
-      return entry;
-    }
-    entry = {
-      id: actorId,
-      genericConnGlobalState: new GenericConnGlobalState(),
-      removed: false
-    };
-    this.#actors.set(actorId, entry);
-    return entry;
-  }
-  /**
-   * Creates a new actor and writes to file system.
-   */
-  async createActor(actorId, name, key, input) {
-    if (this.#actors.has(actorId)) {
-      throw new ActorAlreadyExists(name, key);
-    }
-    const entry = this.#upsertEntry(actorId);
-    entry.state = {
-      actorId,
-      name,
-      key,
-      createdAt: BigInt(Date.now()),
-      persistedData: bufferToArrayBuffer(serializeEmptyPersistData(input))
-    };
-    await this.writeActor(actorId, entry.state);
-    return entry;
-  }
-  /**
-   * Loads the actor from disk or returns the existing actor entry. This will return an entry even if the actor does not actually exist.
-   */
-  async loadActor(actorId) {
-    const entry = this.#upsertEntry(actorId);
-    if (entry.state) {
-      return entry;
-    }
-    if (!this.#persist) {
-      return entry;
-    }
-    if (entry.loadPromise) {
-      await entry.loadPromise;
-      return entry;
-    }
-    entry.loadPromise = this.loadActorState(entry);
-    return entry.loadPromise;
-  }
-  async loadActorState(entry) {
-    const stateFilePath = this.getActorStatePath(entry.id);
-    try {
-      const stateData = await fs2.readFile(stateFilePath);
-      entry.state = ACTOR_STATE_VERSIONED.deserializeWithEmbeddedVersion(
-        new Uint8Array(stateData)
-      );
-      return entry;
-    } catch (innerError) {
-      if (innerError.code === "ENOENT") {
-        entry.loadPromise = void 0;
-        return entry;
-      }
-      const error = new Error(`Failed to load actor state: ${innerError}`);
-      throw error;
-    }
-  }
-  async loadOrCreateActor(actorId, name, key, input) {
-    const entry = await this.loadActor(actorId);
-    if (!entry.state) {
-      entry.state = {
-        actorId,
-        name,
-        key,
-        createdAt: BigInt(Date.now()),
-        persistedData: bufferToArrayBuffer(serializeEmptyPersistData(input))
-      };
-      await this.writeActor(actorId, entry.state);
-    }
-    return entry;
-  }
-  async sleepActor(actorId) {
-    var _a;
-    invariant4(
-      this.#persist,
-      "cannot sleep actor with memory driver, must use file system driver"
-    );
-    const actor2 = this.#actors.get(actorId);
-    invariant4(actor2, `tried to sleep ${actorId}, does not exist`);
-    if (actor2.loadPromise) await actor2.loadPromise.catch();
-    if ((_a = actor2.startPromise) == null ? void 0 : _a.promise) await actor2.startPromise.promise.catch();
-    actor2.removed = true;
-    invariant4(actor2.actor, "actor should be loaded");
-    await actor2.actor._stop();
-    this.#actors.delete(actorId);
-  }
-  /**
-   * Save actor state to disk.
-   */
-  async writeActor(actorId, state) {
-    if (!this.#persist) {
-      return;
-    }
-    const entry = this.#actors.get(actorId);
-    invariant4(entry, "actor entry does not exist");
-    await this.#performWrite(actorId, state);
-  }
-  async setActorAlarm(actorId, timestamp) {
-    const entry = this.#actors.get(actorId);
-    invariant4(entry, "actor entry does not exist");
-    if (this.#persist) {
-      const alarmPath = this.getActorAlarmPath(actorId);
-      const tempPath = `${alarmPath}.tmp.${crypto4.randomUUID()}`;
-      try {
-        await ensureDirectoryExists(path2.dirname(alarmPath));
-        const alarmData = {
-          actorId,
-          timestamp: BigInt(timestamp)
-        };
-        const data = ACTOR_ALARM_VERSIONED.serializeWithEmbeddedVersion(alarmData);
-        await fs2.writeFile(tempPath, data);
-        await fs2.rename(tempPath, alarmPath);
-      } catch (error) {
-        try {
-          await fs2.unlink(tempPath);
-        } catch {
-        }
-        logger6().error("failed to write alarm", { actorId, error });
-        throw new Error(`Failed to write alarm: ${error}`);
-      }
-    }
-    this.#scheduleAlarmTimeout(actorId, timestamp);
-  }
-  /**
-   * Perform the actual write operation with atomic writes
-   */
-  async #performWrite(actorId, state) {
-    const dataPath = this.getActorStatePath(actorId);
-    const tempPath = `${dataPath}.tmp.${crypto4.randomUUID()}`;
-    try {
-      await ensureDirectoryExists(path2.dirname(dataPath));
-      const bareState = {
-        actorId: state.actorId,
-        name: state.name,
-        key: state.key,
-        createdAt: state.createdAt,
-        persistedData: state.persistedData
-      };
-      const serializedState = ACTOR_STATE_VERSIONED.serializeWithEmbeddedVersion(bareState);
-      await fs2.writeFile(tempPath, serializedState);
-      await fs2.rename(tempPath, dataPath);
-    } catch (error) {
-      try {
-        await fs2.unlink(tempPath);
-      } catch {
-      }
-      logger6().error("failed to save actor state", { actorId, error });
-      throw new Error(`Failed to save actor state: ${error}`);
-    }
-  }
-  /**
-   * Call this method after the actor driver has been initiated.
-   *
-   * This will trigger all initial alarms from the file system.
-   *
-   * This needs to be sync since DriverConfig.actor is sync
-   */
-  onRunnerStart(registryConfig, runConfig, inlineClient, actorDriver) {
-    if (this.#runnerParams) {
-      logger6().warn("already called onRunnerStart");
-      return;
-    }
-    this.#runnerParams = {
-      registryConfig,
-      runConfig,
-      inlineClient,
-      actorDriver
-    };
-    try {
-      this.#loadAlarmsSync();
-    } catch (err) {
-      logger6().error("failed to load alarms on startup", { error: err });
-    }
-  }
-  async startActor(registryConfig, runConfig, inlineClient, actorDriver, actorId) {
-    var _a;
-    const entry = await this.loadActor(actorId);
-    if (!entry.state) {
-      throw new Error(`Actor does exist and cannot be started: ${actorId}`);
-    }
-    if (entry.startPromise) {
-      await entry.startPromise.promise;
-      invariant4(entry.actor, "actor should have loaded");
-      return entry.actor;
-    }
-    if (entry.actor) {
-      return entry.actor;
-    }
-    entry.startPromise = Promise.withResolvers();
-    try {
-      const definition = lookupInRegistry(registryConfig, entry.state.name);
-      entry.actor = definition.instantiate();
-      const connDrivers = createGenericConnDrivers(
-        entry.genericConnGlobalState
-      );
-      await entry.actor.start(
-        connDrivers,
-        actorDriver,
-        inlineClient,
-        actorId,
-        entry.state.name,
-        entry.state.key,
-        "unknown"
-      );
-      entry.startPromise.resolve();
-      entry.startPromise = void 0;
-      return entry.actor;
-    } catch (innerError) {
-      const error = new Error(
-        `Failed to start actor ${actorId}: ${innerError}`,
-        { cause: innerError }
-      );
-      (_a = entry.startPromise) == null ? void 0 : _a.reject(error);
-      entry.startPromise = void 0;
-      throw error;
-    }
-  }
-  async loadActorStateOrError(actorId) {
-    const state = (await this.loadActor(actorId)).state;
-    if (!state) throw new Error(`Actor does not exist: ${actorId}`);
-    return state;
-  }
-  getActorOrError(actorId) {
-    const entry = this.#actors.get(actorId);
-    if (!entry) throw new Error(`No entry for actor: ${actorId}`);
-    return entry;
-  }
-  async createDatabase(actorId) {
-    return this.getActorDbPath(actorId);
-  }
-  /**
-   * Load all persisted alarms from disk and schedule their timers.
-   */
-  #loadAlarmsSync() {
-    try {
-      const files = fsSync2.existsSync(this.#alarmsDir) ? fsSync2.readdirSync(this.#alarmsDir) : [];
-      for (const file of files) {
-        if (file.includes(".tmp.")) continue;
-        const fullPath = path2.join(this.#alarmsDir, file);
-        try {
-          const buf = fsSync2.readFileSync(fullPath);
-          const alarmData = ACTOR_ALARM_VERSIONED.deserializeWithEmbeddedVersion(
-            new Uint8Array(buf)
-          );
-          const timestamp = Number(alarmData.timestamp);
-          if (Number.isFinite(timestamp)) {
-            this.#scheduleAlarmTimeout(alarmData.actorId, timestamp);
-          } else {
-            logger6().debug("invalid alarm file contents", { file });
-          }
-        } catch (err) {
-          logger6().error("failed to read alarm file", {
-            file,
-            error: stringifyError(err)
-          });
-        }
-      }
-    } catch (err) {
-      logger6().error("failed to list alarms directory", { error: err });
-    }
-  }
-  /**
-   * Schedule an alarm timer for an actor without writing to disk.
-   */
-  #scheduleAlarmTimeout(actorId, timestamp) {
-    var _a;
-    const entry = this.#upsertEntry(actorId);
-    if (entry.alarmTimestamp !== void 0 && timestamp >= entry.alarmTimestamp) {
-      logger6().debug("skipping alarm schedule (later than existing)", {
-        actorId,
-        timestamp,
-        current: entry.alarmTimestamp
-      });
-      return;
-    }
-    logger6().debug("scheduling alarm", { actorId, timestamp });
-    (_a = entry.alarmTimeout) == null ? void 0 : _a.abort();
-    entry.alarmTimestamp = timestamp;
-    const delay = Math.max(0, timestamp - Date.now());
-    entry.alarmTimeout = setLongTimeout(async () => {
-      entry.alarmTimestamp = void 0;
-      if (this.#persist) {
-        try {
-          await fs2.unlink(this.getActorAlarmPath(actorId));
-        } catch (err) {
-          if ((err == null ? void 0 : err.code) !== "ENOENT") {
-            logger6().debug("failed to remove alarm file", {
-              actorId,
-              error: stringifyError(err)
-            });
-          }
-        }
-      }
-      try {
-        logger6().debug("triggering alarm", { actorId, timestamp });
-        const loaded = await this.loadActor(actorId);
-        if (!loaded.state) throw new Error(`Actor does not exist: ${actorId}`);
-        const runnerParams = this.#runnerParams;
-        invariant4(runnerParams, "missing runner params");
-        if (!loaded.actor) {
-          await this.startActor(
-            runnerParams.registryConfig,
-            runnerParams.runConfig,
-            runnerParams.inlineClient,
-            runnerParams.actorDriver,
-            actorId
-          );
-        }
-        invariant4(loaded.actor, "actor should be loaded after wake");
-        await loaded.actor._onAlarm();
-      } catch (err) {
-        logger6().error("failed to handle alarm", {
-          actorId,
-          error: stringifyError(err)
-        });
-      }
-    }, delay);
-  }
-  getOrCreateInspectorAccessToken() {
-    const tokenPath = path2.join(this.#storagePath, "inspector-token");
-    if (fsSync2.existsSync(tokenPath)) {
-      return fsSync2.readFileSync(tokenPath, "utf-8");
-    }
-    const newToken = generateRandomString();
-    fsSync2.writeFileSync(tokenPath, newToken);
-    return newToken;
-  }
-  /**
-   * Cleanup stale temp files on startup (synchronous)
-   */
-  #cleanupTempFilesSync() {
-    try {
-      const files = fsSync2.readdirSync(this.#stateDir);
-      const tempFiles = files.filter((f) => f.includes(".tmp."));
-      const oneHourAgo = Date.now() - 36e5;
-      for (const tempFile of tempFiles) {
-        try {
-          const fullPath = path2.join(this.#stateDir, tempFile);
-          const stat = fsSync2.statSync(fullPath);
-          if (stat.mtimeMs < oneHourAgo) {
-            fsSync2.unlinkSync(fullPath);
-            logger6().info("cleaned up stale temp file", { file: tempFile });
-          }
-        } catch (err) {
-          logger6().debug("failed to cleanup temp file", {
-            file: tempFile,
-            error: err
-          });
-        }
-      }
-    } catch (err) {
-      logger6().error("failed to read actors directory for cleanup", {
-        error: err
-      });
-    }
-  }
-};
-
-// src/drivers/file-system/manager.ts
-import invariant6 from "invariant";
-
-// src/inline-client-driver/mod.ts
-import * as cbor4 from "cbor-x";
-import invariant5 from "invariant";
-import onChange from "on-change";
-
-// src/inline-client-driver/log.ts
-var LOGGER_NAME4 = "inline-client-driver";
-function logger7() {
-  return getLogger(LOGGER_NAME4);
-}
-
-// src/inline-client-driver/mod.ts
-function createInlineClientDriver(managerDriver) {
-  const driver = {
-    action: async (c, actorQuery, encoding, params, actionName, args, opts) => {
-      try {
-        const { actorId } = await queryActor(c, actorQuery, managerDriver);
-        logger7().debug("found actor for action", { actorId });
-        invariant5(actorId, "Missing actor ID");
-        logger7().debug("handling action", { actionName, encoding });
-        const responseData = await sendHttpRequest({
-          url: `http://actor/action/${encodeURIComponent(actionName)}`,
-          method: "POST",
-          headers: {
-            [HEADER_ENCODING]: encoding,
-            ...params !== void 0 ? { [HEADER_CONN_PARAMS]: JSON.stringify(params) } : {},
-            [HEADER_EXPOSE_INTERNAL_ERROR]: "true"
-          },
-          body: {
-            args: bufferToArrayBuffer(cbor4.encode(args))
-          },
-          encoding,
-          customFetch: managerDriver.sendRequest.bind(managerDriver, actorId),
-          signal: opts == null ? void 0 : opts.signal,
-          requestVersionedDataHandler: HTTP_ACTION_REQUEST_VERSIONED,
-          responseVersionedDataHandler: HTTP_ACTION_RESPONSE_VERSIONED
-        });
-        return cbor4.decode(new Uint8Array(responseData.output));
-      } catch (err) {
-        const { code, message, metadata } = deconstructError(
-          err,
-          logger7(),
-          {},
-          true
-        );
-        const x = new ActorError2(code, message, metadata);
-        throw new ActorError2(code, message, metadata);
-      }
-    },
-    resolveActorId: async (c, actorQuery, _encodingKind) => {
-      const { actorId } = await queryActor(c, actorQuery, managerDriver);
-      logger7().debug("resolved actor", { actorId });
-      invariant5(actorId, "missing actor ID");
-      return actorId;
-    },
-    connectWebSocket: async (c, actorQuery, encodingKind, params) => {
-      const { actorId } = await queryActor(c, actorQuery, managerDriver);
-      logger7().debug("found actor for action", { actorId });
-      invariant5(actorId, "Missing actor ID");
-      logger7().debug("opening websocket", { actorId, encoding: encodingKind });
-      const ws = await managerDriver.openWebSocket(
-        PATH_CONNECT_WEBSOCKET,
-        actorId,
-        encodingKind,
-        params
-      );
-      return ws;
-    },
-    connectSse: async (c, actorQuery, encodingKind, params) => {
-      const { actorId } = await queryActor(c, actorQuery, managerDriver);
-      logger7().debug("found actor for sse connection", { actorId });
-      invariant5(actorId, "Missing actor ID");
-      logger7().debug("opening sse connection", {
-        actorId,
-        encoding: encodingKind
-      });
-      const EventSourceClass = await importEventSource();
-      const eventSource = new EventSourceClass("http://actor/connect/sse", {
-        fetch: (input, init) => {
-          return fetch(input, {
-            ...init,
-            headers: {
-              ...init == null ? void 0 : init.headers,
-              "User-Agent": httpUserAgent(),
-              [HEADER_ENCODING]: encodingKind,
-              ...params !== void 0 ? { [HEADER_CONN_PARAMS]: JSON.stringify(params) } : {},
-              [HEADER_EXPOSE_INTERNAL_ERROR]: "true"
-            }
-          });
-        }
-      });
-      return eventSource;
-    },
-    sendHttpMessage: async (c, actorId, encoding, connectionId, connectionToken, message) => {
-      logger7().debug("sending http message", { actorId, connectionId });
-      await sendHttpRequest({
-        url: "http://actor/connections/message",
-        method: "POST",
-        headers: {
-          [HEADER_ENCODING]: encoding,
-          [HEADER_CONN_ID]: connectionId,
-          [HEADER_CONN_TOKEN]: connectionToken,
-          [HEADER_EXPOSE_INTERNAL_ERROR]: "true"
-        },
-        body: message,
-        encoding,
-        skipParseResponse: true,
-        customFetch: managerDriver.sendRequest.bind(managerDriver, actorId),
-        requestVersionedDataHandler: TO_SERVER_VERSIONED,
-        responseVersionedDataHandler: TO_CLIENT_VERSIONED
-      });
-    },
-    rawHttpRequest: async (c, actorQuery, encoding, params, path3, init) => {
-      try {
-        const { actorId } = await queryActor(c, actorQuery, managerDriver);
-        logger7().debug("found actor for raw http", { actorId });
-        invariant5(actorId, "Missing actor ID");
-        const normalizedPath = path3.startsWith("/") ? path3.slice(1) : path3;
-        const url = new URL(`http://actor/raw/http/${normalizedPath}`);
-        const proxyRequestHeaders = new Headers(init.headers);
-        if (params) {
-          proxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(params));
-        }
-        const proxyRequest = new Request(url, {
-          ...init,
-          headers: proxyRequestHeaders
-        });
-        return await managerDriver.sendRequest(actorId, proxyRequest);
-      } catch (err) {
-        const { code, message, metadata } = deconstructError(
-          err,
-          logger7(),
-          {},
-          true
-        );
-        throw new ActorError2(code, message, metadata);
-      }
-    },
-    rawWebSocket: async (c, actorQuery, encoding, params, path3, protocols) => {
-      const { actorId } = await queryActor(c, actorQuery, managerDriver);
-      logger7().debug("found actor for action", { actorId });
-      invariant5(actorId, "Missing actor ID");
-      const normalizedPath = path3.startsWith("/") ? path3.slice(1) : path3;
-      logger7().debug("opening websocket", {
-        actorId,
-        encoding,
-        path: normalizedPath
-      });
-      const ws = await managerDriver.openWebSocket(
-        `${PATH_RAW_WEBSOCKET_PREFIX}${normalizedPath}`,
-        actorId,
-        encoding,
-        params
-      );
-      return ws;
-    }
-  };
-  return driver;
-}
-async function queryActor(c, query, driver) {
-  logger7().debug("querying actor", { query });
-  let actorOutput;
-  if ("getForId" in query) {
-    const output = await driver.getForId({
-      c,
-      name: query.getForId.name,
-      actorId: query.getForId.actorId
-    });
-    if (!output) throw new ActorNotFound(query.getForId.actorId);
-    actorOutput = output;
-  } else if ("getForKey" in query) {
-    const existingActor = await driver.getWithKey({
-      c,
-      name: query.getForKey.name,
-      key: query.getForKey.key
-    });
-    if (!existingActor) {
-      throw new ActorNotFound(
-        `${query.getForKey.name}:${JSON.stringify(query.getForKey.key)}`
-      );
-    }
-    actorOutput = existingActor;
-  } else if ("getOrCreateForKey" in query) {
-    const getOrCreateOutput = await driver.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 driver.createActor({
-      c,
-      name: query.create.name,
-      key: query.create.key,
-      input: query.create.input,
-      region: query.create.region
-    });
-    actorOutput = {
-      actorId: createOutput.actorId
-    };
-  } else {
-    throw new InvalidRequest("Invalid query format");
-  }
-  logger7().debug("actor query result", {
-    actorId: actorOutput.actorId
-  });
-  return { actorId: actorOutput.actorId };
-}
-
-// src/inspector/manager.ts
-import { sValidator } from "@hono/standard-validator";
-import { Hono as Hono2 } from "hono";
-function createManagerInspectorRouter() {
-  return new Hono2().get("/ping", (c) => {
-    return c.json({ message: "pong" }, 200);
-  }).get("/actors", async (c) => {
-    const limit = Number.parseInt(c.req.query("limit") ?? "") || void 0;
-    const cursor = c.req.query("cursor") || void 0;
-    if (!limit || limit && limit <= 0) {
-      return c.json("Invalid limit", 400);
-    }
-    try {
-      const actors = await c.var.inspector.accessors.getAllActors({
-        limit,
-        cursor
-      });
-      return c.json(actors, 200);
-    } catch (error) {
-      inspectorLogger().error("Failed to fetch actors", error);
-      return c.json("Failed to fetch actors", 500);
-    }
-  }).post("/actors", sValidator("json", CreateActorSchema), async (c) => {
-    const actor2 = await c.var.inspector.accessors.createActor(
-      c.req.valid("json")
-    );
-    return c.json(actor2, 201);
-  }).get("/builds", async (c) => {
-    const builds = await c.var.inspector.accessors.getBuilds();
-    return c.json(builds, 200);
-  }).get("/actor/:id", async (c) => {
-    const id = c.req.param("id");
-    const actor2 = await c.var.inspector.accessors.getActorById(id);
-    if (!actor2) {
-      return c.json({ error: "Actor not found" }, 404);
-    }
-    return c.json(actor2, 200);
-  }).get("/bootstrap", async (c) => {
-    const actors = await c.var.inspector.accessors.getAllActors({
-      limit: 10
-    });
-    return c.json({ actors }, 200);
-  });
-}
-var ManagerInspector = class {
-  accessors;
-  constructor(accessors) {
-    this.accessors = accessors();
-    inspectorLogger().debug("Manager Inspector enabled and ready");
-  }
-};
-
-// src/drivers/file-system/manager.ts
-var FileSystemManagerDriver = class {
-  #registryConfig;
-  #runConfig;
-  #state;
-  #driverConfig;
-  #actorDriver;
-  #actorRouter;
-  inspector;
-  constructor(registryConfig, runConfig, state, driverConfig) {
-    this.#registryConfig = registryConfig;
-    this.#runConfig = runConfig;
-    this.#state = state;
-    this.#driverConfig = driverConfig;
-    if (runConfig.inspector.enabled) {
-      let transformActor2 = function(actorState) {
-        return {
-          id: actorState.actorId,
-          name: actorState.name,
-          key: actorState.key,
-          startedAt,
-          createdAt: new Date(Number(actorState.createdAt)).toISOString(),
-          features: [
-            "state" /* State */,
-            "connections" /* Connections */,
-            "console" /* Console */,
-            "events-monitoring" /* EventsMonitoring */,
-            "database" /* Database */
-          ]
-        };
-      };
-      var transformActor = transformActor2;
-      if (!this.#runConfig.inspector.token()) {
-        this.#runConfig.inspector.token = () => this.#state.getOrCreateInspectorAccessToken();
-      }
-      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-      this.inspector = new ManagerInspector(() => {
-        return {
-          getAllActors: async ({ cursor, limit }) => {
-            const itr = this.#state.getActorsIterator({ cursor });
-            const actors = [];
-            for await (const actor2 of itr) {
-              actors.push(transformActor2(actor2));
-              if (limit && actors.length >= limit) {
-                break;
-              }
-            }
-            return actors;
-          },
-          getActorById: async (id) => {
-            try {
-              const result = await this.#state.loadActorStateOrError(id);
-              return transformActor2(result);
-            } catch {
-              return null;
-            }
-          },
-          getBuilds: async () => {
-            return Object.keys(this.#registryConfig.use).map((name) => ({
-              name
-            }));
-          },
-          createActor: async (input) => {
-            const { actorId } = await this.createActor(input);
-            try {
-              const result = await this.#state.loadActorStateOrError(actorId);
-              return transformActor2(result);
-            } catch {
-              return null;
-            }
-          }
-        };
-      });
-    }
-    const inlineClient = createClientWithDriver(createInlineClientDriver(this));
-    this.#actorDriver = this.#driverConfig.actor(
-      registryConfig,
-      runConfig,
-      this,
-      inlineClient
-    );
-    this.#actorRouter = createActorRouter(this.#runConfig, this.#actorDriver);
-  }
-  async sendRequest(actorId, actorRequest) {
-    return await this.#actorRouter.fetch(actorRequest, {
-      actorId
-    });
-  }
-  async openWebSocket(path3, actorId, encoding, params) {
-    if (path3 === PATH_CONNECT_WEBSOCKET) {
-      const wsHandler = await handleWebSocketConnect(
-        void 0,
-        this.#runConfig,
-        this.#actorDriver,
-        actorId,
-        encoding,
-        params,
-        void 0
-      );
-      return new InlineWebSocketAdapter2(wsHandler);
-    } else if (path3.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {
-      const wsHandler = await handleRawWebSocketHandler(
-        void 0,
-        path3,
-        this.#actorDriver,
-        actorId,
-        void 0
-      );
-      return new InlineWebSocketAdapter2(wsHandler);
-    } else {
-      throw new Error(`Unreachable path: ${path3}`);
-    }
-  }
-  async proxyRequest(c, actorRequest, actorId) {
-    return await this.#actorRouter.fetch(actorRequest, {
-      actorId
-    });
-  }
-  async proxyWebSocket(c, path3, actorId, encoding, connParams, authData) {
-    var _a, _b;
-    const upgradeWebSocket = (_b = (_a = this.#runConfig).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
-    invariant6(upgradeWebSocket, "missing getUpgradeWebSocket");
-    if (path3 === PATH_CONNECT_WEBSOCKET) {
-      const wsHandler = await handleWebSocketConnect(
-        c.req.raw,
-        this.#runConfig,
-        this.#actorDriver,
-        actorId,
-        encoding,
-        connParams,
-        authData
-      );
-      return upgradeWebSocket(() => wsHandler)(c, noopNext());
-    } else if (path3.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {
-      const wsHandler = await handleRawWebSocketHandler(
-        c.req.raw,
-        path3,
-        this.#actorDriver,
-        actorId,
-        authData
-      );
-      return upgradeWebSocket(() => wsHandler)(c, noopNext());
-    } else {
-      throw new Error(`Unreachable path: ${path3}`);
-    }
-  }
-  async getForId({ actorId }) {
-    const actor2 = await this.#state.loadActor(actorId);
-    if (!actor2.state) {
-      return void 0;
-    }
-    try {
-      return {
-        actorId,
-        name: actor2.state.name,
-        key: actor2.state.key
-      };
-    } catch (error) {
-      logger6().error("failed to read actor state", { actorId, error });
-      return void 0;
-    }
-  }
-  async getWithKey({
-    name,
-    key
-  }) {
-    const actorId = generateActorId(name, key);
-    const actor2 = await this.#state.loadActor(actorId);
-    if (actor2.state) {
-      return {
-        actorId,
-        name,
-        key
-      };
-    }
-    return void 0;
-  }
-  async getOrCreateWithKey(input) {
-    const actorId = generateActorId(input.name, input.key);
-    const actorEntry = await this.#state.loadOrCreateActor(
-      actorId,
-      input.name,
-      input.key,
-      input.input
-    );
-    invariant6(actorEntry.state, "must have state");
-    return {
-      actorId: actorEntry.state.actorId,
-      name: actorEntry.state.name,
-      key: actorEntry.state.key
-    };
-  }
-  async createActor({ name, key, input }) {
-    const actorId = generateActorId(name, key);
-    await this.#state.createActor(actorId, name, key, input);
-    return {
-      actorId,
-      name,
-      key
-    };
-  }
-  extraStartupLog() {
-    return {
-      instances: this.#state.actorCountOnStartup,
-      data: this.#state.storagePath
-    };
-  }
-};
-
-// src/drivers/file-system/mod.ts
-function createFileSystemOrMemoryDriver(persist = true, customPath) {
-  const state = new FileSystemGlobalState(persist, customPath);
-  const driverConfig = {
-    name: persist ? "file-system" : "memory",
-    manager: (registryConfig, runConfig) => new FileSystemManagerDriver(
-      registryConfig,
-      runConfig,
-      state,
-      driverConfig
-    ),
-    actor: (registryConfig, runConfig, managerDriver, inlineClient) => {
-      const actorDriver = new FileSystemActorDriver(
-        registryConfig,
-        runConfig,
-        managerDriver,
-        inlineClient,
-        state
-      );
-      state.onRunnerStart(registryConfig, runConfig, inlineClient, actorDriver);
-      return actorDriver;
-    }
-  };
-  return driverConfig;
-}
-function createFileSystemDriver(opts) {
-  return createFileSystemOrMemoryDriver(true, opts == null ? void 0 : opts.path);
-}
-function createMemoryDriver() {
-  return createFileSystemOrMemoryDriver(false);
-}
-
-// src/drivers/default.ts
-function chooseDefaultDriver(runConfig) {
-  const engineEndpoint = runConfig.engine || getEnvUniversal("RIVET_ENGINE");
-  if (engineEndpoint && runConfig.driver) {
-    throw new UserError(
-      "Cannot specify both 'engine' and 'driver' in configuration"
-    );
-  }
-  if (runConfig.driver) {
-    return runConfig.driver;
-  }
-  if (engineEndpoint) {
-    logger().debug("using rivet engine driver", { endpoint: engineEndpoint });
-    return createEngineDriver({ endpoint: engineEndpoint });
-  }
-  logger().debug("using default file system driver");
-  return createFileSystemOrMemoryDriver(true);
-}
-
-// src/manager/router.ts
-import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
-import * as cbor5 from "cbor-x";
-import {
-  Hono as Hono3
-} from "hono";
-import { cors } from "hono/cors";
-import { streamSSE } from "hono/streaming";
-import invariant7 from "invariant";
-import { z as z3 } from "zod";
-
-// src/manager/auth.ts
-function getIntentsFromQuery(query) {
-  const intents = /* @__PURE__ */ new Set();
-  if ("getForId" in query) {
-    intents.add("get");
-  } else if ("getForKey" in query) {
-    intents.add("get");
-  } else if ("getOrCreateForKey" in query) {
-    intents.add("get");
-    intents.add("create");
-  } else if ("create" in query) {
-    intents.add("create");
-  }
-  return intents;
-}
-async function getActorNameFromQuery(c, driver, query) {
-  if ("getForId" in query) {
-    const output = await driver.getForId({
-      c,
-      name: query.getForId.name,
-      actorId: query.getForId.actorId
-    });
-    if (!output) throw new ActorNotFound(query.getForId.actorId);
-    return output.name;
-  } else if ("getForKey" in query) {
-    return query.getForKey.name;
-  } else if ("getOrCreateForKey" in query) {
-    return query.getOrCreateForKey.name;
-  } else if ("create" in query) {
-    return query.create.name;
-  } else {
-    throw new InvalidRequest("Invalid query format");
-  }
-}
-async function authenticateRequest(c, actorDefinition, intents, params) {
-  if (!("onAuth" in actorDefinition.config)) {
-    throw new Forbidden(
-      "Actor requires authentication but no onAuth handler is defined (https://rivet.gg/docs/actors/authentication/). Provide an empty handler to disable auth: `onAuth: () => {}`"
-    );
-  }
-  try {
-    const dataOrPromise = actorDefinition.config.onAuth(
-      {
-        request: c.req.raw,
-        intents
-      },
-      params
-    );
-    if (dataOrPromise instanceof Promise) {
-      return await dataOrPromise;
-    } else {
-      return dataOrPromise;
-    }
-  } catch (error) {
-    logger2().info("authentication error", { error: stringifyError(error) });
-    throw error;
-  }
-}
-async function authenticateEndpoint(c, driver, registryConfig, query, additionalIntents, params) {
-  const intents = getIntentsFromQuery(query);
-  for (const intent of additionalIntents) {
-    intents.add(intent);
-  }
-  const actorName = await getActorNameFromQuery(c, driver, query);
-  const actorDefinition = registryConfig.use[actorName];
-  if (!actorDefinition) {
-    throw new ActorNotFound(actorName);
-  }
-  return await authenticateRequest(c, actorDefinition, intents, params);
-}
-
-// src/manager/router.ts
-function parseWebSocketProtocols(protocols) {
-  let queryRaw;
-  let encodingRaw;
-  let connParamsRaw;
-  if (protocols) {
-    const protocolList = protocols.split(",").map((p) => p.trim());
-    for (const protocol of protocolList) {
-      if (protocol.startsWith("query.")) {
-        queryRaw = decodeURIComponent(protocol.substring("query.".length));
-      } else if (protocol.startsWith("encoding.")) {
-        encodingRaw = protocol.substring("encoding.".length);
-      } else if (protocol.startsWith("conn_params.")) {
-        connParamsRaw = decodeURIComponent(
-          protocol.substring("conn_params.".length)
-        );
-      }
-    }
-  }
-  return { queryRaw, encodingRaw, connParamsRaw };
-}
-var OPENAPI_ENCODING = z3.string().openapi({
-  description: "The encoding format to use for the response (json, cbor)",
-  example: "json"
-});
-var OPENAPI_ACTOR_QUERY = z3.string().openapi({
-  description: "Actor query information"
-});
-var OPENAPI_CONN_PARAMS = z3.string().openapi({
-  description: "Connection parameters"
-});
-var OPENAPI_ACTOR_ID = z3.string().openapi({
-  description: "Actor ID (used in some endpoints)",
-  example: "actor-123456"
-});
-var OPENAPI_CONN_ID = z3.string().openapi({
-  description: "Connection ID",
-  example: "conn-123456"
-});
-var OPENAPI_CONN_TOKEN = z3.string().openapi({
-  description: "Connection token"
-});
-function buildOpenApiResponses(schema, validateBody) {
-  return {
-    200: {
-      description: "Success",
-      content: validateBody ? {
-        "application/json": {
-          schema
-        }
-      } : {}
-    },
-    400: {
-      description: "User error"
-    },
-    500: {
-      description: "Internal error"
-    }
-  };
-}
-function createManagerRouter(registryConfig, runConfig, inlineClientDriver, managerDriver, validateBody) {
-  var _a, _b, _c;
-  const router = new OpenAPIHono({ strict: false }).basePath(
-    runConfig.basePath
-  );
-  router.use("*", loggerMiddleware(logger2()));
-  if (runConfig.cors || ((_a = runConfig.inspector) == null ? void 0 : _a.cors)) {
-    router.use("*", async (c, next) => {
-      var _a2, _b2, _c2, _d, _e, _f, _g;
-      const path3 = c.req.path;
-      if (path3.endsWith("/actors/connect/websocket") || path3.includes("/actors/raw/websocket/") || // inspectors implement their own CORS handling
-      path3.endsWith("/inspect") || path3.endsWith("/actors/inspect")) {
-        return next();
-      }
-      return cors({
-        ...runConfig.cors ?? {},
-        ...((_a2 = runConfig.inspector) == null ? void 0 : _a2.cors) ?? {},
-        origin: (origin, c2) => {
-          var _a3, _b3, _c3;
-          const inspectorOrigin = (_b3 = (_a3 = runConfig.inspector) == null ? void 0 : _a3.cors) == null ? void 0 : _b3.origin;
-          if (inspectorOrigin !== void 0) {
-            if (typeof inspectorOrigin === "function") {
-              const allowed = inspectorOrigin(origin, c2);
-              if (allowed) return allowed;
-            } else if (Array.isArray(inspectorOrigin)) {
-              return inspectorOrigin.includes(origin) ? origin : void 0;
-            } else {
-              return inspectorOrigin;
-            }
-          }
-          if (((_c3 = runConfig.cors) == null ? void 0 : _c3.origin) !== void 0) {
-            if (typeof runConfig.cors.origin === "function") {
-              const allowed = runConfig.cors.origin(origin, c2);
-              if (allowed) return allowed;
-            } else {
-              return runConfig.cors.origin;
-            }
-          }
-          return null;
-        },
-        allowMethods: (origin, c2) => {
-          var _a3, _b3, _c3;
-          const inspectorMethods = (_b3 = (_a3 = runConfig.inspector) == null ? void 0 : _a3.cors) == null ? void 0 : _b3.allowMethods;
-          if (inspectorMethods) {
-            if (typeof inspectorMethods === "function") {
-              return inspectorMethods(origin, c2);
-            }
-            return inspectorMethods;
-          }
-          if ((_c3 = runConfig.cors) == null ? void 0 : _c3.allowMethods) {
-            if (typeof runConfig.cors.allowMethods === "function") {
-              return runConfig.cors.allowMethods(origin, c2);
-            }
-            return runConfig.cors.allowMethods;
-          }
-          return [];
-        },
-        allowHeaders: [
-          ...((_b2 = runConfig.cors) == null ? void 0 : _b2.allowHeaders) ?? [],
-          ...((_d = (_c2 = runConfig.inspector) == null ? void 0 : _c2.cors) == null ? void 0 : _d.allowHeaders) ?? [],
-          ...ALLOWED_PUBLIC_HEADERS,
-          "Content-Type",
-          "User-Agent"
-        ],
-        credentials: ((_e = runConfig.cors) == null ? void 0 : _e.credentials) ?? ((_g = (_f = runConfig.inspector) == null ? void 0 : _f.cors) == null ? void 0 : _g.credentials) ?? true
-      })(c, next);
-    });
-  }
-  router.get("/", (c) => {
-    return c.text(
-      "This is an RivetKit registry.\n\nLearn more at https://rivetkit.org"
-    );
-  });
-  {
-    const ResolveQuerySchema = z3.object({
-      query: z3.any().openapi({
-        example: { getForId: { actorId: "actor-123" } }
-      })
-    }).openapi("ResolveQuery");
-    const ResolveResponseSchema = z3.object({
-      i: z3.string().openapi({
-        example: "actor-123"
-      })
-    }).openapi("ResolveResponse");
-    const resolveRoute = createRoute({
-      method: "post",
-      path: "/actors/resolve",
-      request: {
-        body: {
-          content: validateBody ? {
-            "application/json": {
-              schema: ResolveQuerySchema
-            }
-          } : {}
-        },
-        headers: z3.object({
-          [HEADER_ACTOR_QUERY]: OPENAPI_ACTOR_QUERY
-        })
-      },
-      responses: buildOpenApiResponses(ResolveResponseSchema, validateBody)
-    });
-    router.openapi(
-      resolveRoute,
-      (c) => handleResolveRequest(c, registryConfig, managerDriver)
-    );
-  }
-  {
-    router.use("*", (c, next) => {
-      if (c.req.path.endsWith("/actors/connect/websocket")) {
-        return handleWebSocketConnectRequest(
-          c,
-          registryConfig,
-          runConfig,
-          managerDriver
-        );
-      }
-      return next();
-    });
-    const wsRoute = createRoute({
-      method: "get",
-      path: "/actors/connect/websocket",
-      responses: {
-        101: {
-          description: "WebSocket upgrade"
-        }
-      }
-    });
-    router.openapi(wsRoute, () => {
-      throw new Error("Should be unreachable");
-    });
-  }
-  {
-    const sseRoute = createRoute({
-      method: "get",
-      path: "/actors/connect/sse",
-      request: {
-        headers: z3.object({
-          [HEADER_ENCODING]: OPENAPI_ENCODING,
-          [HEADER_ACTOR_QUERY]: OPENAPI_ACTOR_QUERY,
-          [HEADER_CONN_PARAMS]: OPENAPI_CONN_PARAMS.optional()
-        })
-      },
-      responses: {
-        200: {
-          description: "SSE stream",
-          content: {
-            "text/event-stream": {
-              schema: z3.unknown()
-            }
-          }
-        }
-      }
-    });
-    router.openapi(
-      sseRoute,
-      (c) => handleSseConnectRequest(c, registryConfig, runConfig, managerDriver)
-    );
-  }
-  {
-    const ActionParamsSchema = z3.object({
-      action: z3.string().openapi({
-        param: {
-          name: "action",
-          in: "path"
-        },
-        example: "myAction"
-      })
-    }).openapi("ActionParams");
-    const ActionRequestSchema = z3.object({
-      query: z3.any().openapi({
-        example: { getForId: { actorId: "actor-123" } }
-      }),
-      body: z3.any().optional().openapi({
-        example: { param1: "value1", param2: 123 }
-      })
-    }).openapi("ActionRequest");
-    const ActionResponseSchema = z3.any().openapi("ActionResponse");
-    const actionRoute = createRoute({
-      method: "post",
-      path: "/actors/actions/{action}",
-      request: {
-        params: ActionParamsSchema,
-        body: {
-          content: validateBody ? {
-            "application/json": {
-              schema: ActionRequestSchema
-            }
-          } : {}
-        },
-        headers: z3.object({
-          [HEADER_ENCODING]: OPENAPI_ENCODING,
-          [HEADER_CONN_PARAMS]: OPENAPI_CONN_PARAMS.optional()
-        })
-      },
-      responses: buildOpenApiResponses(ActionResponseSchema, validateBody)
-    });
-    router.openapi(
-      actionRoute,
-      (c) => handleActionRequest(c, registryConfig, runConfig, managerDriver)
-    );
-  }
-  {
-    const ConnectionMessageRequestSchema = z3.object({
-      message: z3.any().openapi({
-        example: { type: "message", content: "Hello, actor!" }
-      })
-    }).openapi("ConnectionMessageRequest");
-    const ConnectionMessageResponseSchema = z3.any().openapi("ConnectionMessageResponse");
-    const messageRoute = createRoute({
-      method: "post",
-      path: "/actors/message",
-      request: {
-        body: {
-          content: validateBody ? {
-            "application/json": {
-              schema: ConnectionMessageRequestSchema
-            }
-          } : {}
-        },
-        headers: z3.object({
-          [HEADER_ACTOR_ID]: OPENAPI_ACTOR_ID,
-          [HEADER_CONN_ID]: OPENAPI_CONN_ID,
-          [HEADER_ENCODING]: OPENAPI_ENCODING,
-          [HEADER_CONN_TOKEN]: OPENAPI_CONN_TOKEN
-        })
-      },
-      responses: buildOpenApiResponses(
-        ConnectionMessageResponseSchema,
-        validateBody
-      )
-    });
-    router.openapi(
-      messageRoute,
-      (c) => handleMessageRequest(c, registryConfig, runConfig, managerDriver)
-    );
-  }
-  {
-    const RawHttpRequestBodySchema = z3.any().optional().openapi({
-      description: "Raw request body (can be any content type)"
-    });
-    const RawHttpResponseSchema = z3.any().openapi({
-      description: "Raw response from actor's onFetch handler"
-    });
-    const rawHttpRouteConfig = {
-      path: "/actors/raw/http/*",
-      request: {
-        headers: z3.object({
-          [HEADER_ACTOR_QUERY]: OPENAPI_ACTOR_QUERY.optional(),
-          [HEADER_CONN_PARAMS]: OPENAPI_CONN_PARAMS.optional()
-        }),
-        body: {
-          content: {
-            "*/*": {
-              schema: RawHttpRequestBodySchema
-            }
-          }
-        }
-      },
-      responses: {
-        200: {
-          description: "Success - response from actor's onFetch handler",
-          content: {
-            "*/*": {
-              schema: RawHttpResponseSchema
-            }
-          }
-        },
-        404: {
-          description: "Actor does not have an onFetch handler"
-        },
-        500: {
-          description: "Internal server error or invalid response from actor"
-        }
-      }
-    };
-    const httpMethods = [
-      "get",
-      "post",
-      "put",
-      "delete",
-      "patch",
-      "head",
-      "options"
-    ];
-    for (const method of httpMethods) {
-      const route = createRoute({
-        method,
-        ...rawHttpRouteConfig
-      });
-      router.openapi(route, async (c) => {
-        return handleRawHttpRequest(
-          c,
-          registryConfig,
-          runConfig,
-          managerDriver
-        );
-      });
-    }
-  }
-  {
-    router.use("*", async (c, next) => {
-      if (c.req.path.includes("/raw/websocket/")) {
-        return handleRawWebSocketRequest(
-          c,
-          registryConfig,
-          runConfig,
-          managerDriver
-        );
-      }
-      return next();
-    });
-    const rawWebSocketRoute = createRoute({
-      method: "get",
-      path: "/actors/raw/websocket/*",
-      request: {},
-      responses: {
-        101: {
-          description: "WebSocket upgrade successful"
-        },
-        400: {
-          description: "WebSockets not enabled or invalid request"
-        },
-        404: {
-          description: "Actor does not have an onWebSocket handler"
-        }
-      }
-    });
-    router.openapi(rawWebSocketRoute, () => {
-      throw new Error("Should be unreachable");
-    });
-  }
-  if ((_b = runConfig.inspector) == null ? void 0 : _b.enabled) {
-    router.route(
-      "/actors/inspect",
-      new Hono3().use(
-        cors(runConfig.inspector.cors),
-        secureInspector(runConfig),
-        universalActorProxy({
-          registryConfig,
-          runConfig,
-          driver: managerDriver
-        })
-      ).all(
-        "/",
-        (c) => (
-          // this should be handled by the actor proxy, but just in case
-          c.text("Unreachable.", 404)
-        )
-      )
-    );
-    router.route(
-      "/inspect",
-      new Hono3().use(
-        cors(runConfig.inspector.cors),
-        secureInspector(runConfig),
-        async (c, next) => {
-          const inspector = managerDriver.inspector;
-          invariant7(inspector, "inspector not supported on this platform");
-          c.set("inspector", inspector);
-          await next();
-        }
-      ).route("/", createManagerInspectorRouter())
-    );
-  }
-  if (registryConfig.test.enabled) {
-    router.post(".test/inline-driver/call", async (c) => {
-      const buffer = await c.req.arrayBuffer();
-      const { encoding, transport, method, args } = cbor5.decode(new Uint8Array(buffer));
-      logger2().debug("received inline request", {
-        encoding,
-        transport,
-        method,
-        args
-      });
-      let response;
-      try {
-        const output = await inlineClientDriver[method](
-          ...args
-        );
-        response = { ok: output };
-      } catch (rawErr) {
-        const err = deconstructError(rawErr, logger2(), {}, true);
-        response = { err };
-      }
-      return c.body(cbor5.encode(response));
-    });
-    router.get(".test/inline-driver/connect-websocket", async (c) => {
-      var _a2;
-      const upgradeWebSocket = (_a2 = runConfig.getUpgradeWebSocket) == null ? void 0 : _a2.call(runConfig);
-      invariant7(upgradeWebSocket, "websockets not supported on this platform");
-      return upgradeWebSocket(async (c2) => {
-        const {
-          actorQuery: actorQueryRaw,
-          params: paramsRaw,
-          encodingKind
-        } = c2.req.query();
-        const actorQuery = JSON.parse(actorQueryRaw);
-        const params = paramsRaw !== void 0 ? JSON.parse(paramsRaw) : void 0;
-        logger2().debug("received test inline driver websocket", {
-          actorQuery,
-          params,
-          encodingKind
-        });
-        const clientWsPromise = inlineClientDriver.connectWebSocket(
-          void 0,
-          actorQuery,
-          encodingKind,
-          params,
-          void 0
-        );
-        return await createTestWebSocketProxy(clientWsPromise, "standard");
-      })(c, noopNext());
-    });
-    router.get(".test/inline-driver/raw-websocket", async (c) => {
-      var _a2;
-      const upgradeWebSocket = (_a2 = runConfig.getUpgradeWebSocket) == null ? void 0 : _a2.call(runConfig);
-      invariant7(upgradeWebSocket, "websockets not supported on this platform");
-      return upgradeWebSocket(async (c2) => {
-        const {
-          actorQuery: actorQueryRaw,
-          params: paramsRaw,
-          encodingKind,
-          path: path3,
-          protocols: protocolsRaw
-        } = c2.req.query();
-        const actorQuery = JSON.parse(actorQueryRaw);
-        const params = paramsRaw !== void 0 ? JSON.parse(paramsRaw) : void 0;
-        const protocols = protocolsRaw !== void 0 ? JSON.parse(protocolsRaw) : void 0;
-        logger2().debug("received test inline driver raw websocket", {
-          actorQuery,
-          params,
-          encodingKind,
-          path: path3,
-          protocols
-        });
-        logger2().debug("calling inlineClientDriver.rawWebSocket");
-        const clientWsPromise = inlineClientDriver.rawWebSocket(
-          void 0,
-          actorQuery,
-          encodingKind,
-          params,
-          path3,
-          protocols,
-          void 0
-        );
-        logger2().debug("calling createTestWebSocketProxy");
-        return await createTestWebSocketProxy(clientWsPromise, "raw");
-      })(c, noopNext());
-    });
-    router.all(".test/inline-driver/raw-http/*", async (c) => {
-      const actorQueryHeader = c.req.header(HEADER_ACTOR_QUERY);
-      const paramsHeader = c.req.header(HEADER_CONN_PARAMS);
-      const encodingHeader = c.req.header(HEADER_ENCODING);
-      if (!actorQueryHeader || !encodingHeader) {
-        return c.text("Missing required headers", 400);
-      }
-      const actorQuery = JSON.parse(actorQueryHeader);
-      const params = paramsHeader ? JSON.parse(paramsHeader) : void 0;
-      const encoding = encodingHeader;
-      const fullPath = c.req.path;
-      const pathOnly = fullPath.split("/.test/inline-driver/raw-http/")[1] || "";
-      const url = new URL(c.req.url);
-      const pathWithQuery = pathOnly + url.search;
-      logger2().debug("received test inline driver raw http", {
-        actorQuery,
-        params,
-        encoding,
-        path: pathWithQuery,
-        method: c.req.method
-      });
-      try {
-        const response = await inlineClientDriver.rawHttpRequest(
-          void 0,
-          actorQuery,
-          encoding,
-          params,
-          pathWithQuery,
-          {
-            method: c.req.method,
-            headers: c.req.raw.headers,
-            body: c.req.raw.body
-          },
-          void 0
-        );
-        return response;
-      } catch (error) {
-        logger2().error("error in test inline raw http", {
-          error: stringifyError(error)
-        });
-        const err = deconstructError(error, logger2(), {}, true);
-        return c.json(
-          {
-            error: {
-              code: err.code,
-              message: err.message,
-              metadata: err.metadata
-            }
-          },
-          err.statusCode
-        );
-      }
-    });
-  }
-  (_c = managerDriver.modifyManagerRouter) == null ? void 0 : _c.call(
-    managerDriver,
-    registryConfig,
-    router
-  );
-  const mountedRouter = new Hono3();
-  mountedRouter.route("/", router);
-  mountedRouter.route("/registry", router);
-  mountedRouter.notFound(handleRouteNotFound);
-  mountedRouter.onError(handleRouteError.bind(void 0, {}));
-  return { router: mountedRouter, openapi: router };
-}
-async function queryActor2(c, query, driver) {
-  logger2().debug("querying actor", { query });
-  let actorOutput;
-  if ("getForId" in query) {
-    const output = await driver.getForId({
-      c,
-      name: query.getForId.name,
-      actorId: query.getForId.actorId
-    });
-    if (!output) throw new ActorNotFound(query.getForId.actorId);
-    actorOutput = output;
-  } else if ("getForKey" in query) {
-    const existingActor = await driver.getWithKey({
-      c,
-      name: query.getForKey.name,
-      key: query.getForKey.key
-    });
-    if (!existingActor) {
-      throw new ActorNotFound(
-        `${query.getForKey.name}:${JSON.stringify(query.getForKey.key)}`
-      );
-    }
-    actorOutput = existingActor;
-  } else if ("getOrCreateForKey" in query) {
-    const getOrCreateOutput = await driver.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 driver.createActor({
-      c,
-      name: query.create.name,
-      key: query.create.key,
-      input: query.create.input,
-      region: query.create.region
-    });
-    actorOutput = {
-      actorId: createOutput.actorId
-    };
-  } else {
-    throw new InvalidRequest("Invalid query format");
-  }
-  logger2().debug("actor query result", {
-    actorId: actorOutput.actorId
-  });
-  return { actorId: actorOutput.actorId };
-}
-async function createTestWebSocketProxy(clientWsPromise, connectionType) {
-  let clientWs = null;
-  try {
-    logger2().debug("awaiting client websocket promise");
-    const ws = await clientWsPromise;
-    clientWs = ws;
-    logger2().debug("client websocket promise resolved", {
-      constructor: ws == null ? void 0 : ws.constructor.name
-    });
-    await new Promise((resolve, reject) => {
-      const onOpen = () => {
-        logger2().debug("test websocket connection opened");
-        resolve();
-      };
-      const onError = (error) => {
-        logger2().error("test websocket connection failed", { error });
-        reject(
-          new Error(`Failed to open WebSocket: ${error.message || error}`)
-        );
-      };
-      ws.addEventListener("open", onOpen);
-      ws.addEventListener("error", onError);
-    });
-  } catch (error) {
-    logger2().error(
-      `failed to establish client ${connectionType} websocket connection`,
-      { error }
-    );
-    return {
-      onOpen: (_evt, serverWs) => {
-        serverWs.close(1011, "Failed to establish connection");
-      },
-      onMessage: () => {
-      },
-      onError: () => {
-      },
-      onClose: () => {
-      }
-    };
-  }
-  return {
-    onOpen: (_evt, serverWs) => {
-      logger2().debug(`test ${connectionType} websocket connection opened`);
-      logger2().debug("clientWs info", {
-        constructor: clientWs.constructor.name,
-        hasAddEventListener: typeof clientWs.addEventListener === "function",
-        readyState: clientWs.readyState
-      });
-      clientWs.addEventListener("message", (clientEvt) => {
-        var _a, _b;
-        logger2().debug(
-          `test ${connectionType} websocket connection message from client`,
-          {
-            dataType: typeof clientEvt.data,
-            isBlob: clientEvt.data instanceof Blob,
-            isArrayBuffer: clientEvt.data instanceof ArrayBuffer,
-            dataConstructor: (_b = (_a = clientEvt.data) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name,
-            dataStr: typeof clientEvt.data === "string" ? clientEvt.data.substring(0, 100) : void 0
-          }
-        );
-        if (serverWs.readyState === 1) {
-          if (clientEvt.data instanceof Blob) {
-            clientEvt.data.arrayBuffer().then((buffer) => {
-              logger2().debug(
-                "converted client blob to arraybuffer, sending to server",
-                {
-                  bufferSize: buffer.byteLength
-                }
-              );
-              serverWs.send(buffer);
-            }).catch((error) => {
-              logger2().error("failed to convert blob to arraybuffer", {
-                error
-              });
-            });
-          } else {
-            logger2().debug("sending client data directly to server", {
-              dataType: typeof clientEvt.data,
-              dataLength: typeof clientEvt.data === "string" ? clientEvt.data.length : void 0
-            });
-            serverWs.send(clientEvt.data);
-          }
-        }
-      });
-      clientWs.addEventListener("close", (clientEvt) => {
-        logger2().debug(`test ${connectionType} websocket connection closed`);
-        if (serverWs.readyState !== 3) {
-          serverWs.close(clientEvt.code, clientEvt.reason);
-        }
-      });
-      clientWs.addEventListener("error", () => {
-        logger2().debug(`test ${connectionType} websocket connection error`);
-        if (serverWs.readyState !== 3) {
-          serverWs.close(1011, "Error in client websocket");
-        }
-      });
-    },
-    onMessage: (evt) => {
-      var _a, _b;
-      logger2().debug("received message from server", {
-        dataType: typeof evt.data,
-        isBlob: evt.data instanceof Blob,
-        isArrayBuffer: evt.data instanceof ArrayBuffer,
-        dataConstructor: (_b = (_a = evt.data) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name,
-        dataStr: typeof evt.data === "string" ? evt.data.substring(0, 100) : void 0
-      });
-      if (clientWs.readyState === 1) {
-        if (evt.data instanceof Blob) {
-          evt.data.arrayBuffer().then((buffer) => {
-            logger2().debug("converted blob to arraybuffer, sending", {
-              bufferSize: buffer.byteLength
-            });
-            clientWs.send(buffer);
-          }).catch((error) => {
-            logger2().error("failed to convert blob to arraybuffer", {
-              error
-            });
-          });
-        } else {
-          logger2().debug("sending data directly", {
-            dataType: typeof evt.data,
-            dataLength: typeof evt.data === "string" ? evt.data.length : void 0
-          });
-          clientWs.send(evt.data);
-        }
-      }
-    },
-    onClose: (event, serverWs) => {
-      logger2().debug(`server ${connectionType} websocket closed`, {
-        wasClean: event.wasClean,
-        code: event.code,
-        reason: event.reason
-      });
-      serverWs.close(1e3, "hack_force_close");
-      if (clientWs && clientWs.readyState !== clientWs.CLOSED && clientWs.readyState !== clientWs.CLOSING) {
-        clientWs.close(1e3, event.reason);
-      }
-    },
-    onError: (error) => {
-      logger2().error(`error in server ${connectionType} websocket`, { error });
-      if (clientWs && clientWs.readyState !== clientWs.CLOSED && clientWs.readyState !== clientWs.CLOSING) {
-        clientWs.close(1011, "Error in server websocket");
-      }
-    }
-  };
-}
-async function handleSseConnectRequest(c, registryConfig, _runConfig, driver) {
-  let encoding;
-  try {
-    encoding = getRequestEncoding(c.req);
-    logger2().debug("sse connection request received", { encoding });
-    const params = ConnectRequestSchema.safeParse({
-      query: getRequestQuery(c),
-      encoding: c.req.header(HEADER_ENCODING),
-      connParams: c.req.header(HEADER_CONN_PARAMS)
-    });
-    if (!params.success) {
-      logger2().error("invalid connection parameters", {
-        error: params.error
-      });
-      throw new InvalidRequest(params.error);
-    }
-    const query = params.data.query;
-    const connParams = params.data.connParams ? JSON.parse(params.data.connParams) : void 0;
-    const authData = await authenticateEndpoint(
-      c,
-      driver,
-      registryConfig,
-      query,
-      ["connect"],
-      connParams
-    );
-    const { actorId } = await queryActor2(c, query, driver);
-    invariant7(actorId, "Missing actor ID");
-    logger2().debug("sse connection to actor", { actorId });
-    logger2().debug("using custom proxy mode for sse connection");
-    const url = new URL("http://actor/connect/sse");
-    const proxyRequestHeaderes = new Headers();
-    proxyRequestHeaderes.set(HEADER_ENCODING, params.data.encoding);
-    if (params.data.connParams) {
-      proxyRequestHeaderes.set(HEADER_CONN_PARAMS, params.data.connParams);
-    }
-    if (authData) {
-      proxyRequestHeaderes.set(HEADER_AUTH_DATA, JSON.stringify(authData));
-    }
-    const proxyRequest = new Request(url, { headers: proxyRequestHeaderes });
-    return await driver.proxyRequest(c, proxyRequest, actorId);
-  } catch (error) {
-    const { code, message, metadata } = deconstructError(error, logger2(), {
-      sseEvent: "setup"
-    });
-    return streamSSE(c, async (stream) => {
-      try {
-        if (encoding) {
-          const errorMsg = {
-            body: {
-              tag: "Error",
-              val: {
-                code,
-                message,
-                metadata: bufferToArrayBuffer(cbor5.encode(metadata)),
-                actionId: null
-              }
-            }
-          };
-          const serialized = serializeWithEncoding(
-            encoding,
-            errorMsg,
-            TO_CLIENT_VERSIONED
-          );
-          await stream.writeSSE({
-            data: typeof serialized === "string" ? serialized : Buffer.from(serialized).toString("base64")
-          });
-        } else {
-          await stream.writeSSE({
-            data: code,
-            event: "error"
-          });
-        }
-      } catch (serializeError) {
-        logger2().error("failed to send error to sse client", {
-          error: serializeError
-        });
-        await stream.writeSSE({
-          data: "internal error during error handling",
-          event: "error"
-        });
-      }
-    });
-  }
-}
-async function handleWebSocketConnectRequest(c, registryConfig, runConfig, driver) {
-  var _a;
-  const upgradeWebSocket = (_a = runConfig.getUpgradeWebSocket) == null ? void 0 : _a.call(runConfig);
-  if (!upgradeWebSocket) {
-    return c.text(
-      "WebSockets are not enabled for this driver. Use SSE instead.",
-      400
-    );
-  }
-  let encoding;
-  try {
-    logger2().debug("websocket connection request received");
-    const protocols = c.req.header("sec-websocket-protocol");
-    const { queryRaw, encodingRaw, connParamsRaw } = parseWebSocketProtocols(protocols);
-    let queryUnvalidated;
-    try {
-      queryUnvalidated = JSON.parse(queryRaw);
-    } catch (error) {
-      logger2().error("invalid query json", { error });
-      throw new InvalidQueryJSON(error);
-    }
-    let connParamsUnvalidated = null;
-    try {
-      if (connParamsRaw) {
-        connParamsUnvalidated = JSON.parse(connParamsRaw);
-      }
-    } catch (error) {
-      logger2().error("invalid conn params", { error });
-      throw new InvalidParams(
-        `Invalid params JSON: ${stringifyError(error)}`
-      );
-    }
-    const params = ConnectWebSocketRequestSchema.safeParse({
-      query: queryUnvalidated,
-      encoding: encodingRaw,
-      connParams: connParamsUnvalidated
-    });
-    if (!params.success) {
-      logger2().error("invalid connection parameters", {
-        error: params.error
-      });
-      throw new InvalidRequest(params.error);
-    }
-    encoding = params.data.encoding;
-    const authData = await authenticateEndpoint(
-      c,
-      driver,
-      registryConfig,
-      params.data.query,
-      ["connect"],
-      connParamsRaw
-    );
-    const { actorId } = await queryActor2(c, params.data.query, driver);
-    logger2().debug("found actor for websocket connection", {
-      actorId
-    });
-    invariant7(actorId, "missing actor id");
-    return await driver.proxyWebSocket(
-      c,
-      PATH_CONNECT_WEBSOCKET,
-      actorId,
-      params.data.encoding,
-      params.data.connParams,
-      authData
-    );
-  } catch (error) {
-    const { code, message, metadata } = deconstructError(error, logger2(), {
-      wsEvent: "setup"
-    });
-    return await upgradeWebSocket(() => ({
-      onOpen: (_evt, ws) => {
-        if (encoding) {
-          try {
-            const errorMsg = {
-              body: {
-                tag: "Error",
-                val: {
-                  code,
-                  message,
-                  metadata: bufferToArrayBuffer(cbor5.encode(metadata)),
-                  actionId: null
-                }
-              }
-            };
-            const serialized = serializeWithEncoding(
-              encoding,
-              errorMsg,
-              TO_CLIENT_VERSIONED
-            );
-            ws.send(serialized);
-            ws.close(1011, code);
-          } catch (serializeError) {
-            logger2().error("failed to send error to websocket client", {
-              error: serializeError
-            });
-            ws.close(1011, "internal error during error handling");
-          }
-        } else {
-          ws.close(1011, code);
-        }
-      }
-    }))(c, noopNext());
-  }
-}
-async function handleMessageRequest(c, _registryConfig, _runConfig, driver) {
-  logger2().debug("connection message request received");
-  try {
-    const params = ConnMessageRequestSchema.safeParse({
-      actorId: c.req.header(HEADER_ACTOR_ID),
-      connId: c.req.header(HEADER_CONN_ID),
-      encoding: c.req.header(HEADER_ENCODING),
-      connToken: c.req.header(HEADER_CONN_TOKEN)
-    });
-    if (!params.success) {
-      logger2().error("invalid connection parameters", {
-        error: params.error
-      });
-      throw new InvalidRequest(params.error);
-    }
-    const { actorId, connId, encoding, connToken } = params.data;
-    const url = new URL("http://actor/connections/message");
-    const proxyRequestHeaders = new Headers();
-    proxyRequestHeaders.set(HEADER_ENCODING, encoding);
-    proxyRequestHeaders.set(HEADER_CONN_ID, connId);
-    proxyRequestHeaders.set(HEADER_CONN_TOKEN, connToken);
-    const proxyRequest = new Request(url, {
-      method: "POST",
-      body: c.req.raw.body,
-      duplex: "half",
-      headers: proxyRequestHeaders
-    });
-    return await driver.proxyRequest(c, proxyRequest, actorId);
-  } catch (error) {
-    logger2().error("error proxying connection message", { error });
-    if (!ActorError.isActorError(error)) {
-      throw new ProxyError("connection message", error);
-    } else {
-      throw error;
-    }
-  }
-}
-async function handleActionRequest(c, registryConfig, _runConfig, driver) {
-  try {
-    const actionName = c.req.param("action");
-    logger2().debug("action call received", { actionName });
-    const params = ConnectRequestSchema.safeParse({
-      query: getRequestQuery(c),
-      encoding: c.req.header(HEADER_ENCODING),
-      connParams: c.req.header(HEADER_CONN_PARAMS)
-    });
-    if (!params.success) {
-      logger2().error("invalid connection parameters", {
-        error: params.error
-      });
-      throw new InvalidRequest(params.error);
-    }
-    const connParams = params.data.connParams ? JSON.parse(params.data.connParams) : void 0;
-    const authData = await authenticateEndpoint(
-      c,
-      driver,
-      registryConfig,
-      params.data.query,
-      ["action"],
-      connParams
-    );
-    const { actorId } = await queryActor2(c, params.data.query, driver);
-    logger2().debug("found actor for action", { actorId });
-    invariant7(actorId, "Missing actor ID");
-    const url = new URL(
-      `http://actor/action/${encodeURIComponent(actionName)}`
-    );
-    const proxyRequestHeaders = new Headers();
-    proxyRequestHeaders.set(HEADER_ENCODING, params.data.encoding);
-    if (params.data.connParams) {
-      proxyRequestHeaders.set(HEADER_CONN_PARAMS, params.data.connParams);
-    }
-    if (authData) {
-      proxyRequestHeaders.set(HEADER_AUTH_DATA, JSON.stringify(authData));
-    }
-    const proxyRequest = new Request(url, {
-      method: "POST",
-      body: c.req.raw.body,
-      headers: proxyRequestHeaders
-    });
-    return await driver.proxyRequest(c, proxyRequest, actorId);
-  } catch (error) {
-    logger2().error("error in action handler", { error: stringifyError(error) });
-    if (!ActorError.isActorError(error)) {
-      throw new ProxyError("Action call", error);
-    } else {
-      throw error;
-    }
-  }
-}
-async function handleResolveRequest(c, registryConfig, driver) {
-  const encoding = getRequestEncoding(c.req);
-  logger2().debug("resolve request encoding", { encoding });
-  const params = ResolveRequestSchema.safeParse({
-    query: getRequestQuery(c),
-    connParams: c.req.header(HEADER_CONN_PARAMS)
-  });
-  if (!params.success) {
-    logger2().error("invalid connection parameters", {
-      error: params.error
-    });
-    throw new InvalidRequest(params.error);
-  }
-  const connParams = params.data.connParams ? JSON.parse(params.data.connParams) : void 0;
-  const query = params.data.query;
-  await authenticateEndpoint(c, driver, registryConfig, query, [], connParams);
-  const { actorId } = await queryActor2(c, query, driver);
-  logger2().debug("resolved actor", { actorId });
-  invariant7(actorId, "Missing actor ID");
-  const response = {
-    actorId
-  };
-  const serialized = serializeWithEncoding(
-    encoding,
-    response,
-    HTTP_RESOLVE_RESPONSE_VERSIONED
-  );
-  return c.body(serialized);
-}
-async function handleRawHttpRequest(c, registryConfig, _runConfig, driver) {
-  try {
-    const subpath = c.req.path.split("/raw/http/")[1] || "";
-    logger2().debug("raw http request received", { subpath });
-    const queryHeader = c.req.header(HEADER_ACTOR_QUERY);
-    if (!queryHeader) {
-      throw new InvalidRequest("Missing actor query header");
-    }
-    const query = JSON.parse(queryHeader);
-    const connParamsHeader = c.req.header(HEADER_CONN_PARAMS);
-    const connParams = connParamsHeader ? JSON.parse(connParamsHeader) : void 0;
-    const authData = await authenticateEndpoint(
-      c,
-      driver,
-      registryConfig,
-      query,
-      ["action"],
-      connParams
-    );
-    const { actorId } = await queryActor2(c, query, driver);
-    logger2().debug("found actor for raw http", { actorId });
-    invariant7(actorId, "Missing actor ID");
-    const originalUrl = new URL(c.req.url);
-    const url = new URL(
-      `http://actor/raw/http/${subpath}${originalUrl.search}`
-    );
-    logger2().debug("rewriting http url", {
-      from: c.req.url,
-      to: url
-    });
-    const proxyRequestHeaders = new Headers(c.req.raw.headers);
-    if (connParams) {
-      proxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(connParams));
-    }
-    if (authData) {
-      proxyRequestHeaders.set(HEADER_AUTH_DATA, JSON.stringify(authData));
-    }
-    const proxyRequest = new Request(url, {
-      method: c.req.method,
-      headers: proxyRequestHeaders,
-      body: c.req.raw.body
-    });
-    return await driver.proxyRequest(c, proxyRequest, actorId);
-  } catch (error) {
-    logger2().error("error in raw http handler", {
-      error: stringifyError(error)
-    });
-    if (!ActorError.isActorError(error)) {
-      throw new ProxyError("Raw HTTP request", error);
-    } else {
-      throw error;
-    }
-  }
-}
-async function handleRawWebSocketRequest(c, registryConfig, runConfig, driver) {
-  var _a;
-  const upgradeWebSocket = (_a = runConfig.getUpgradeWebSocket) == null ? void 0 : _a.call(runConfig);
-  if (!upgradeWebSocket) {
-    return c.text("WebSockets are not enabled for this driver.", 400);
-  }
-  try {
-    const subpath = c.req.path.split("/raw/websocket/")[1] || "";
-    logger2().debug("raw websocket request received", { subpath });
-    const protocols = c.req.header("sec-websocket-protocol");
-    const {
-      queryRaw: queryFromProtocol,
-      connParamsRaw: connParamsFromProtocol
-    } = parseWebSocketProtocols(protocols);
-    if (!queryFromProtocol) {
-      throw new InvalidRequest("Missing query in WebSocket protocol");
-    }
-    const query = JSON.parse(queryFromProtocol);
-    let connParams;
-    if (connParamsFromProtocol) {
-      connParams = JSON.parse(connParamsFromProtocol);
-    }
-    const authData = await authenticateEndpoint(
-      c,
-      driver,
-      registryConfig,
-      query,
-      ["action"],
-      connParams
-    );
-    const { actorId } = await queryActor2(c, query, driver);
-    logger2().debug("found actor for raw websocket", { actorId });
-    invariant7(actorId, "Missing actor ID");
-    logger2().debug("using custom proxy mode for raw websocket");
-    const originalUrl = new URL(c.req.url);
-    const proxyPath = `${PATH_RAW_WEBSOCKET_PREFIX}${subpath}${originalUrl.search}`;
-    logger2().debug("manager router proxyWebSocket", {
-      originalUrl: c.req.url,
-      subpath,
-      search: originalUrl.search,
-      proxyPath
-    });
-    return await driver.proxyWebSocket(
-      c,
-      proxyPath,
-      actorId,
-      "json",
-      // Default encoding for raw WebSocket
-      connParams,
-      authData
-    );
-  } catch (error) {
-    const { code } = deconstructError(error, logger2(), {
-      wsEvent: "setup"
-    });
-    return await upgradeWebSocket(() => ({
-      onOpen: (_evt, ws) => {
-        ws.close(1011, code);
-      }
-    }))(c, noopNext());
-  }
-}
-function universalActorProxy({
-  registryConfig,
-  runConfig,
-  driver
-}) {
-  return async (c, _next) => {
-    if (c.req.header("upgrade") === "websocket") {
-      return handleRawWebSocketRequest(c, registryConfig, runConfig, driver);
-    } else {
-      const queryHeader = c.req.header(HEADER_ACTOR_QUERY);
-      if (!queryHeader) {
-        throw new InvalidRequest("Missing actor query header");
-      }
-      const query = ActorQuerySchema.parse(JSON.parse(queryHeader));
-      const { actorId } = await queryActor2(c, query, driver);
-      const url = new URL(c.req.url);
-      url.hostname = "actor";
-      url.pathname = url.pathname.replace(new RegExp(`^${runConfig.basePath}`, ""), "").replace(/^\/?registry\/actors/, "").replace(/^\/?actors/, "");
-      const proxyRequest = new Request(url, {
-        method: c.req.method,
-        headers: c.req.raw.headers,
-        body: c.req.raw.body
-      });
-      return await driver.proxyRequest(c, proxyRequest, actorId);
-    }
-  };
-}
-
-// src/registry/config.ts
-import { z as z4 } from "zod";
-var ActorsSchema = z4.record(
-  z4.string(),
-  z4.custom()
-);
-var TestConfigSchema = z4.object({ enabled: z4.boolean() });
-var RegistryConfigSchema = z4.object({
-  use: z4.record(z4.string(), z4.custom()),
-  // TODO: Find a better way of passing around the test config
-  /**
-   * Test configuration.
-   *
-   * DO NOT MANUALLY ENABLE. THIS IS USED INTERNALLY.
-   * @internal
-   **/
-  test: TestConfigSchema.optional().default({ enabled: false })
-});
-
-// src/registry/log.ts
-var LOGGER_NAME5 = "registry";
-function logger8() {
-  return getLogger(LOGGER_NAME5);
-}
-
-// src/registry/serve.ts
-import { Hono as Hono4 } from "hono";
-async function crossPlatformServe(rivetKitRouter, userRouter) {
-  const app = userRouter ?? new Hono4();
-  let serve;
-  try {
-    const dep = await import("@hono/node-server");
-    serve = dep.serve;
-  } catch (err) {
-    logger8().error(
-      "failed to import @hono/node-server. please run 'npm install @hono/node-server @hono/node-ws'"
-    );
-    process.exit(1);
-  }
-  app.route("/registry", rivetKitRouter);
-  let createNodeWebSocket;
-  try {
-    const dep = await import("@hono/node-ws");
-    createNodeWebSocket = dep.createNodeWebSocket;
-  } catch (err) {
-    logger8().error(
-      "failed to import @hono/node-ws. please run 'npm install @hono/node-server @hono/node-ws'"
-    );
-    process.exit(1);
-  }
-  const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({
-    app
-  });
-  const port = Number.parseInt(
-    getEnvUniversal("PORT") ?? getEnvUniversal("PORT_HTTP") ?? "8080"
-  );
-  const server = serve(
-    { fetch: app.fetch, port },
-    () => logger8().info("server listening", { port })
-  );
-  injectWebSocket(server);
-  return { upgradeWebSocket };
-}
-
-// src/registry/mod.ts
-var Registry = class {
-  #config;
-  get config() {
-    return this.#config;
-  }
-  constructor(config2) {
-    this.#config = config2;
-  }
-  /**
-   * Runs the registry for a server.
-   */
-  createServer(inputConfig) {
-    var _a, _b;
-    const config2 = RunConfigSchema.parse(inputConfig);
-    const driver = chooseDefaultDriver(config2);
-    let upgradeWebSocket;
-    if (!config2.getUpgradeWebSocket) {
-      config2.getUpgradeWebSocket = () => upgradeWebSocket;
-    }
-    const managerDriver = driver.manager(this.#config, config2);
-    const clientDriver = createInlineClientDriver(managerDriver);
-    const { router: hono } = createManagerRouter(
-      this.#config,
-      config2,
-      clientDriver,
-      managerDriver,
-      false
-    );
-    const client = createClientWithDriver(clientDriver);
-    const driverLog = ((_a = managerDriver.extraStartupLog) == null ? void 0 : _a.call(managerDriver)) ?? {};
-    logger8().info("rivetkit ready", {
-      driver: driver.name,
-      definitions: Object.keys(this.#config.use).length,
-      ...driverLog
-    });
-    if ((_b = config2.inspector) == null ? void 0 : _b.enabled) {
-      logger8().info("inspector ready", {
-        url: getInspectorUrl(config2)
-      });
-    }
-    if (config2.role === "all" || config2.role === "runner") {
-      const inlineClient = createClientWithDriver(
-        createInlineClientDriver(managerDriver)
-      );
-      const _actorDriver = driver.actor(
-        this.#config,
-        config2,
-        managerDriver,
-        inlineClient
-      );
-    }
-    return {
-      client,
-      hono,
-      handler: async (req) => await hono.fetch(req),
-      serve: async (app) => {
-        const out = await crossPlatformServe(hono, app);
-        upgradeWebSocket = out.upgradeWebSocket;
-      }
-    };
-  }
-  /**
-   * Runs the registry as a standalone server.
-   */
-  async runServer(inputConfig) {
-    const { serve } = this.createServer(inputConfig);
-    serve();
-  }
-};
-function setup(input) {
-  const config2 = RegistryConfigSchema.parse(input);
-  return new Registry(config2);
-}
-
-export {
-  GenericConnGlobalState,
-  createGenericConnDrivers,
-  PATH_CONNECT_WEBSOCKET,
-  PATH_RAW_WEBSOCKET_PREFIX,
-  createActorRouter,
-  actor,
-  InlineWebSocketAdapter2,
-  createEngineDriver,
-  createInlineClientDriver,
-  createFileSystemOrMemoryDriver,
-  createFileSystemDriver,
-  createMemoryDriver,
-  createManagerRouter,
-  RegistryConfigSchema,
-  Registry,
-  setup
-};
-//! These configs configs hold anything that's not platform-specific about running actors.
-//# sourceMappingURL=chunk-OV6AYD4S.js.map