rivetkit 2.0.5 → 2.0.7-rc.1

package/dist/tsup/chunk-HPT3I7UU.js

@@ -0,0 +1,3726 @@
+import {
+  configureInspectorAccessToken,
+  getInspectorUrl,
+  inspectorLogger,
+  isInspectorEnabled,
+  secureInspector
+} from "./chunk-4GP7BZSR.js";
+import {
+  ActorDefinition,
+  RemoteManagerDriver,
+  createActorInspectorRouter,
+  createClientWithDriver,
+  deserializeActorKey,
+  generateConnSocketId,
+  lookupInRegistry,
+  serializeActorKey
+} from "./chunk-BW5DPM6Z.js";
+import {
+  CreateActorSchema
+} from "./chunk-GZVBFXBI.js";
+import {
+  ActionContext,
+  HTTP_ACTION_REQUEST_VERSIONED,
+  HTTP_ACTION_RESPONSE_VERSIONED,
+  HTTP_RESPONSE_ERROR_VERSIONED,
+  RunConfigSchema,
+  TO_SERVER_VERSIONED,
+  createVersionedDataHandler,
+  parseMessage,
+  serializeEmptyPersistData
+} from "./chunk-JD54PXWP.js";
+import {
+  EncodingSchema,
+  HEADER_ACTOR_ID,
+  HEADER_CONN_ID,
+  HEADER_CONN_PARAMS,
+  HEADER_CONN_TOKEN,
+  HEADER_ENCODING,
+  HEADER_RIVET_ACTOR,
+  HEADER_RIVET_TARGET,
+  PATH_CONNECT_WEBSOCKET,
+  PATH_RAW_WEBSOCKET_PREFIX,
+  WS_PROTOCOL_ACTOR,
+  WS_PROTOCOL_CONN_ID,
+  WS_PROTOCOL_CONN_PARAMS,
+  WS_PROTOCOL_CONN_TOKEN,
+  WS_PROTOCOL_ENCODING,
+  WS_PROTOCOL_PATH,
+  WS_PROTOCOL_TARGET,
+  WS_PROTOCOL_TRANSPORT,
+  contentTypeForEncoding,
+  deserializeWithEncoding,
+  encodingIsBinary,
+  generateRandomString,
+  loggerWithoutContext,
+  serializeWithEncoding
+} from "./chunk-YQ4XQYPM.js";
+import {
+  configureBaseLogger,
+  configureDefaultLogger,
+  getLogger
+} from "./chunk-PUSQNDJG.js";
+import {
+  bufferToArrayBuffer,
+  deconstructError,
+  getEnvUniversal,
+  noopNext,
+  package_default,
+  promiseWithResolvers,
+  setLongTimeout,
+  stringifyError
+} from "./chunk-RVP5RUSC.js";
+import {
+  ActorAlreadyExists,
+  ConnNotFound,
+  IncorrectConnToken,
+  InternalError,
+  InvalidEncoding,
+  InvalidParams,
+  MissingActorHeader,
+  Unsupported,
+  UserError,
+  WebSocketsNotEnabled
+} from "./chunk-YPZFLUO6.js";
+
+// src/actor/config.ts
+import { z } from "zod";
+var ActorConfigSchema = z.object({
+  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/router.ts
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import invariant2 from "invariant";
+
+// src/actor/router-endpoints.ts
+import * as cbor from "cbor-x";
+import { streamSSE } from "hono/streaming";
+import invariant from "invariant";
+
+// src/manager/log.ts
+function logger() {
+  return getLogger("actor-manager");
+}
+
+// src/manager/hono-websocket-adapter.ts
+var HonoWebSocketAdapter = class {
+  // WebSocket readyState values
+  CONNECTING = 0;
+  OPEN = 1;
+  CLOSING = 2;
+  CLOSED = 3;
+  #ws;
+  #readyState = 1;
+  // Start as OPEN since WSContext is already connected
+  #eventListeners = /* @__PURE__ */ new Map();
+  #closeCode;
+  #closeReason;
+  constructor(ws) {
+    this.#ws = ws;
+    this.#readyState = this.OPEN;
+    setTimeout(() => {
+      this.#fireEvent("open", { type: "open", target: this });
+    }, 0);
+  }
+  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) {
+    if (this.readyState !== this.OPEN) {
+      throw new Error("WebSocket is not open");
+    }
+    try {
+      logger().debug({
+        msg: "bridge sending data",
+        dataType: typeof data,
+        isString: typeof data === "string",
+        isArrayBuffer: data instanceof ArrayBuffer,
+        dataStr: typeof data === "string" ? data.substring(0, 100) : "<non-string>"
+      });
+      if (typeof data === "string") {
+        this.#ws.send(data);
+      } else if (data instanceof ArrayBuffer) {
+        this.#ws.send(data);
+      } else if (ArrayBuffer.isView(data)) {
+        const buffer = data.buffer.slice(
+          data.byteOffset,
+          data.byteOffset + data.byteLength
+        );
+        if (buffer instanceof SharedArrayBuffer) {
+          const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+          new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));
+          this.#ws.send(arrayBuffer);
+        } else {
+          this.#ws.send(buffer);
+        }
+      } else if (data instanceof Blob) {
+        data.arrayBuffer().then((buffer) => {
+          this.#ws.send(buffer);
+        }).catch((error) => {
+          logger().error({
+            msg: "failed to convert blob to arraybuffer",
+            error
+          });
+          this.#fireEvent("error", { type: "error", target: this, error });
+        });
+      } else {
+        logger().warn({
+          msg: "unsupported data type, converting to string",
+          dataType: typeof data,
+          data
+        });
+        this.#ws.send(String(data));
+      }
+    } catch (error) {
+      logger().error({ msg: "error sending websocket data", error });
+      this.#fireEvent("error", { type: "error", target: this, error });
+      throw error;
+    }
+  }
+  close(code = 1e3, reason = "") {
+    if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
+      return;
+    }
+    this.#readyState = this.CLOSING;
+    this.#closeCode = code;
+    this.#closeReason = reason;
+    try {
+      this.#ws.close(code, reason);
+      this.#readyState = this.CLOSED;
+      this.#fireEvent("close", {
+        type: "close",
+        target: this,
+        code,
+        reason,
+        wasClean: code === 1e3
+      });
+    } catch (error) {
+      logger().error({ msg: "error closing websocket", error });
+      this.#readyState = this.CLOSED;
+      this.#fireEvent("close", {
+        type: "close",
+        target: this,
+        code: 1006,
+        reason: "Abnormal closure",
+        wasClean: false
+      });
+    }
+  }
+  addEventListener(type, listener) {
+    if (!this.#eventListeners.has(type)) {
+      this.#eventListeners.set(type, /* @__PURE__ */ new Set());
+    }
+    this.#eventListeners.get(type).add(listener);
+  }
+  removeEventListener(type, listener) {
+    const listeners = this.#eventListeners.get(type);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+  }
+  dispatchEvent(event) {
+    const listeners = this.#eventListeners.get(event.type);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(event);
+        } catch (error) {
+          logger().error({
+            msg: `error in ${event.type} event listener`,
+            error
+          });
+        }
+      }
+    }
+    return true;
+  }
+  // Internal method to handle incoming messages from WSContext
+  _handleMessage(data) {
+    let messageData;
+    if (typeof data === "string") {
+      messageData = data;
+    } else if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+      messageData = data;
+    } else if (data && typeof data === "object" && "data" in data) {
+      messageData = data.data;
+    } else {
+      messageData = String(data);
+    }
+    logger().debug({
+      msg: "bridge handling message",
+      dataType: typeof messageData,
+      isArrayBuffer: messageData instanceof ArrayBuffer,
+      dataStr: typeof messageData === "string" ? messageData : "<binary>"
+    });
+    this.#fireEvent("message", {
+      type: "message",
+      target: this,
+      data: messageData
+    });
+  }
+  // Internal method to handle close from WSContext
+  _handleClose(code, reason) {
+    this.#ws.close(1e3, "hack_force_close");
+    if (this.readyState === this.CLOSED) return;
+    this.#readyState = this.CLOSED;
+    this.#closeCode = code;
+    this.#closeReason = reason;
+    this.#fireEvent("close", {
+      type: "close",
+      target: this,
+      code,
+      reason,
+      wasClean: code === 1e3
+    });
+  }
+  // Internal method to handle errors from WSContext
+  _handleError(error) {
+    this.#fireEvent("error", {
+      type: "error",
+      target: this,
+      error
+    });
+  }
+  #fireEvent(type, event) {
+    const listeners = this.#eventListeners.get(type);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(event);
+        } catch (error) {
+          logger().error({ msg: `error in ${type} event listener`, error });
+        }
+      }
+    }
+    switch (type) {
+      case "open":
+        if (this.#onopen) {
+          try {
+            this.#onopen(event);
+          } catch (error) {
+            logger().error({ msg: "error in onopen handler", error });
+          }
+        }
+        break;
+      case "close":
+        if (this.#onclose) {
+          try {
+            this.#onclose(event);
+          } catch (error) {
+            logger().error({ msg: "error in onclose handler", error });
+          }
+        }
+        break;
+      case "error":
+        if (this.#onerror) {
+          try {
+            this.#onerror(event);
+          } catch (error) {
+            logger().error({ msg: "error in onerror handler", error });
+          }
+        }
+        break;
+      case "message":
+        if (this.#onmessage) {
+          try {
+            this.#onmessage(event);
+          } catch (error) {
+            logger().error({ msg: "error in onmessage handler", error });
+          }
+        }
+        break;
+    }
+  }
+  // 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/actor/router-endpoints.ts
+var SSE_PING_INTERVAL = 1e3;
+async function handleWebSocketConnect(req, runConfig, actorDriver, actorId, encoding, parameters, connId, connToken) {
+  const exposeInternalError = req ? getRequestExposeInternalError(req) : false;
+  const {
+    promise: handlersPromise,
+    resolve: handlersResolve,
+    reject: handlersReject
+  } = promiseWithResolvers();
+  let actor2;
+  try {
+    actor2 = await actorDriver.loadActor(actorId);
+  } catch (error) {
+    return {
+      onOpen: (_evt, ws) => {
+        const { code } = deconstructError(
+          error,
+          actor2.rLog,
+          {
+            wsEvent: "open"
+          },
+          exposeInternalError
+        );
+        ws.close(1011, code);
+      },
+      onMessage: (_evt, ws) => {
+        ws.close(1011, "Actor not loaded");
+      },
+      onClose: (_event, _ws) => {
+      },
+      onError: (_error) => {
+      }
+    };
+  }
+  const closePromise = promiseWithResolvers();
+  const socketId = generateConnSocketId();
+  return {
+    onOpen: (_evt, ws) => {
+      actor2.rLog.debug("actor websocket open");
+      (async () => {
+        try {
+          let conn;
+          actor2.rLog.debug({
+            msg: connId ? "websocket reconnection attempt" : "new websocket connection",
+            connId,
+            actorId
+          });
+          conn = await actor2.createConn(
+            {
+              socketId,
+              driverState: {
+                [0 /* WEBSOCKET */]: {
+                  encoding,
+                  websocket: ws,
+                  closePromise
+                }
+              }
+            },
+            parameters,
+            req,
+            connId,
+            connToken
+          );
+          handlersResolve({ conn, actor: actor2, connId: conn.id });
+        } catch (error) {
+          handlersReject(error);
+          const { code } = deconstructError(
+            error,
+            actor2.rLog,
+            {
+              wsEvent: "open"
+            },
+            exposeInternalError
+          );
+          ws.close(1011, code);
+        }
+      })();
+    },
+    onMessage: (evt, ws) => {
+      handlersPromise.then(({ conn, actor: actor3 }) => {
+        actor3.rLog.debug({ msg: "received message" });
+        const value = evt.data.valueOf();
+        parseMessage(value, {
+          encoding,
+          maxIncomingMessageSize: runConfig.maxIncomingMessageSize
+        }).then((message) => {
+          actor3.processMessage(message, conn).catch((error) => {
+            const { code } = deconstructError(
+              error,
+              actor3.rLog,
+              {
+                wsEvent: "message"
+              },
+              exposeInternalError
+            );
+            ws.close(1011, code);
+          });
+        }).catch((error) => {
+          const { code } = deconstructError(
+            error,
+            actor3.rLog,
+            {
+              wsEvent: "message"
+            },
+            exposeInternalError
+          );
+          ws.close(1011, code);
+        });
+      }).catch((error) => {
+        const { code } = deconstructError(
+          error,
+          actor2.rLog,
+          {
+            wsEvent: "message"
+          },
+          exposeInternalError
+        );
+        ws.close(1011, code);
+      });
+    },
+    onClose: (event, ws) => {
+      handlersReject(`WebSocket closed (${event.code}): ${event.reason}`);
+      closePromise.resolve();
+      if (event.wasClean) {
+        actor2.rLog.info({
+          msg: "websocket closed",
+          code: event.code,
+          reason: event.reason,
+          wasClean: event.wasClean
+        });
+      } else {
+        actor2.rLog.warn({
+          msg: "websocket closed",
+          code: event.code,
+          reason: event.reason,
+          wasClean: event.wasClean
+        });
+      }
+      ws.close(1e3, "hack_force_close");
+      handlersPromise.then(({ conn, actor: actor3 }) => {
+        actor3.__connDisconnected(conn, event.wasClean, socketId);
+      }).catch((error) => {
+        deconstructError(
+          error,
+          actor2.rLog,
+          { wsEvent: "close" },
+          exposeInternalError
+        );
+      });
+    },
+    onError: (_error) => {
+      try {
+        actor2.rLog.warn({ msg: "websocket error" });
+      } catch (error) {
+        deconstructError(
+          error,
+          actor2.rLog,
+          { wsEvent: "error" },
+          exposeInternalError
+        );
+      }
+    }
+  };
+}
+async function handleSseConnect(c, _runConfig, actorDriver, actorId) {
+  c.header("Content-Encoding", "Identity");
+  const encoding = getRequestEncoding(c.req);
+  const parameters = getRequestConnParams(c.req);
+  const socketId = generateConnSocketId();
+  const connId = c.req.header(HEADER_CONN_ID);
+  const connToken = c.req.header(HEADER_CONN_TOKEN);
+  return streamSSE(c, async (stream) => {
+    let actor2;
+    let conn;
+    try {
+      actor2 = await actorDriver.loadActor(actorId);
+      actor2.rLog.debug({
+        msg: connId ? "sse reconnection attempt" : "sse open",
+        connId
+      });
+      conn = await actor2.createConn(
+        {
+          socketId,
+          driverState: {
+            [1 /* SSE */]: {
+              encoding,
+              stream
+            }
+          }
+        },
+        parameters,
+        c.req.raw,
+        connId,
+        connToken
+      );
+      const abortResolver = promiseWithResolvers();
+      stream.onAbort(() => {
+      });
+      c.req.raw.signal.addEventListener("abort", async () => {
+        invariant(actor2, "actor should exist");
+        const rLog = actor2.rLog ?? loggerWithoutContext();
+        try {
+          rLog.debug("sse stream aborted");
+          if (conn) {
+            actor2.__connDisconnected(conn, false, socketId);
+          }
+          abortResolver.resolve(void 0);
+        } catch (error) {
+          rLog.error({ msg: "error closing sse connection", error });
+          abortResolver.resolve(void 0);
+        }
+      });
+      while (true) {
+        if (stream.closed || stream.aborted) {
+          actor2 == null ? void 0 : actor2.rLog.debug({
+            msg: "sse stream closed",
+            closed: stream.closed,
+            aborted: stream.aborted
+          });
+          break;
+        }
+        await stream.writeSSE({ event: "ping", data: "" });
+        await stream.sleep(SSE_PING_INTERVAL);
+      }
+    } catch (error) {
+      loggerWithoutContext().error({ msg: "error in sse connection", error });
+      if (conn && actor2 !== void 0) {
+        actor2.__connDisconnected(conn, false, socketId);
+      }
+      stream.close();
+    }
+  });
+}
+async function handleAction(c, _runConfig, actorDriver, actionName, actorId) {
+  const encoding = getRequestEncoding(c.req);
+  const parameters = getRequestConnParams(c.req);
+  const arrayBuffer = await c.req.arrayBuffer();
+  const request = deserializeWithEncoding(
+    encoding,
+    new Uint8Array(arrayBuffer),
+    HTTP_ACTION_REQUEST_VERSIONED
+  );
+  const actionArgs = cbor.decode(new Uint8Array(request.args));
+  const socketId = generateConnSocketId();
+  let actor2;
+  let conn;
+  let output;
+  try {
+    actor2 = await actorDriver.loadActor(actorId);
+    actor2.rLog.debug({ msg: "handling action", actionName, encoding });
+    conn = await actor2.createConn(
+      {
+        socketId,
+        driverState: { [2 /* HTTP */]: {} }
+      },
+      parameters,
+      c.req.raw
+    );
+    const ctx = new ActionContext(actor2.actorContext, conn);
+    output = await actor2.executeAction(ctx, actionName, actionArgs);
+  } finally {
+    if (conn) {
+      actor2 == null ? void 0 : actor2.__connDisconnected(conn, true, socketId);
+    }
+  }
+  const responseData = {
+    output: bufferToArrayBuffer(cbor.encode(output))
+  };
+  const serialized = serializeWithEncoding(
+    encoding,
+    responseData,
+    HTTP_ACTION_RESPONSE_VERSIONED
+  );
+  return c.body(serialized, 200, {
+    "Content-Type": contentTypeForEncoding(encoding)
+  });
+}
+async function handleConnectionMessage(c, _runConfig, actorDriver, connId, connToken, actorId) {
+  const encoding = getRequestEncoding(c.req);
+  const arrayBuffer = await c.req.arrayBuffer();
+  const message = deserializeWithEncoding(
+    encoding,
+    new Uint8Array(arrayBuffer),
+    TO_SERVER_VERSIONED
+  );
+  const actor2 = await actorDriver.loadActor(actorId);
+  const conn = actor2.conns.get(connId);
+  if (!conn) {
+    throw new ConnNotFound(connId);
+  }
+  if (conn._token !== connToken) {
+    throw new IncorrectConnToken();
+  }
+  await actor2.processMessage(message, conn);
+  return c.json({});
+}
+async function handleConnectionClose(c, _runConfig, actorDriver, connId, connToken, actorId) {
+  var _a;
+  const actor2 = await actorDriver.loadActor(actorId);
+  const conn = actor2.conns.get(connId);
+  if (!conn) {
+    throw new ConnNotFound(connId);
+  }
+  if (conn._token !== connToken) {
+    throw new IncorrectConnToken();
+  }
+  if (!((_a = conn.__socket) == null ? void 0 : _a.driverState) || !(1 /* SSE */ in conn.__socket.driverState)) {
+    throw new UserError(
+      "Connection close is only supported for SSE connections"
+    );
+  }
+  await conn.disconnect("Connection closed by client request");
+  return c.json({});
+}
+async function handleRawWebSocketHandler(req, path3, actorDriver, actorId) {
+  const actor2 = await actorDriver.loadActor(actorId);
+  return {
+    onOpen: (_evt, ws) => {
+      const adapter = new HonoWebSocketAdapter(ws);
+      ws.__adapter = adapter;
+      const url = new URL(path3, "http://actor");
+      const pathname = url.pathname.replace(/^\/raw\/websocket\/?/, "") || "/";
+      const normalizedPath = (pathname.startsWith("/") ? pathname : "/" + pathname) + url.search;
+      let newRequest;
+      if (req) {
+        newRequest = new Request(`http://actor${normalizedPath}`, req);
+      } else {
+        newRequest = new Request(`http://actor${normalizedPath}`, {
+          method: "GET"
+        });
+      }
+      actor2.rLog.debug({
+        msg: "rewriting websocket url",
+        from: path3,
+        to: newRequest.url,
+        pathname: url.pathname,
+        search: url.search,
+        normalizedPath
+      });
+      actor2.handleWebSocket(adapter, {
+        request: newRequest
+      });
+    },
+    onMessage: (event, ws) => {
+      const adapter = ws.__adapter;
+      if (adapter) {
+        adapter._handleMessage(event);
+      }
+    },
+    onClose: (evt, ws) => {
+      const adapter = ws.__adapter;
+      if (adapter) {
+        adapter._handleClose((evt == null ? void 0 : evt.code) || 1006, (evt == null ? void 0 : evt.reason) || "");
+      }
+    },
+    onError: (error, ws) => {
+      const adapter = ws.__adapter;
+      if (adapter) {
+        adapter._handleError(error);
+      }
+    }
+  };
+}
+function getRequestEncoding(req) {
+  const encodingParam = req.header(HEADER_ENCODING);
+  if (!encodingParam) {
+    throw new InvalidEncoding("undefined");
+  }
+  const result = EncodingSchema.safeParse(encodingParam);
+  if (!result.success) {
+    throw new InvalidEncoding(encodingParam);
+  }
+  return result.data;
+}
+function getRequestExposeInternalError(_req) {
+  return false;
+}
+function getRequestConnParams(req) {
+  const paramsParam = req.header(HEADER_CONN_PARAMS);
+  if (!paramsParam) {
+    return null;
+  }
+  try {
+    return JSON.parse(paramsParam);
+  } catch (err) {
+    throw new InvalidParams(
+      `Invalid params JSON: ${stringifyError(err)}`
+    );
+  }
+}
+
+// src/common/router.ts
+import * as cbor2 from "cbor-x";
+function logger2() {
+  return getLogger("router");
+}
+function loggerMiddleware(logger7) {
+  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;
+    logger7.debug({
+      msg: "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(error, c) {
+  const exposeInternalError = getRequestExposeInternalError(c.req.raw);
+  const { statusCode, group, code, message, metadata } = deconstructError(
+    error,
+    logger2(),
+    {
+      method: c.req.method,
+      path: c.req.path
+    },
+    exposeInternalError
+  );
+  let encoding;
+  try {
+    encoding = getRequestEncoding(c.req);
+  } catch (_) {
+    encoding = "json";
+  }
+  const output = serializeWithEncoding(
+    encoding,
+    {
+      group,
+      code,
+      message,
+      // TODO: Cannot serialize non-binary meta since it requires ArrayBuffer atm
+      metadata: encodingIsBinary(encoding) ? bufferToArrayBuffer(cbor2.encode(metadata)) : null
+    },
+    HTTP_RESPONSE_ERROR_VERSIONED
+  );
+  return c.body(output, { status: statusCode });
+}
+
+// src/actor/router.ts
+function createActorRouter(runConfig, actorDriver) {
+  const router = new Hono({ strict: false });
+  router.use("*", loggerMiddleware(loggerWithoutContext()));
+  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.post("/.test/force-disconnect", async (c) => {
+    const connId = c.req.query("conn");
+    if (!connId) {
+      return c.text("Missing conn query parameter", 400);
+    }
+    const actor2 = await actorDriver.loadActor(c.env.actorId);
+    const conn = actor2.__getConnForId(connId);
+    if (!conn) {
+      return c.text(`Connection not found: ${connId}`, 404);
+    }
+    const driverState = conn.__driverState;
+    if (driverState && 0 /* WEBSOCKET */ in driverState) {
+      const ws = driverState[0 /* WEBSOCKET */].websocket;
+      ws.raw.terminate();
+    } else if (driverState && 1 /* SSE */ in driverState) {
+      const stream = driverState[1 /* SSE */].stream;
+      stream.abort();
+    }
+    return c.json({ success: true });
+  });
+  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 protocols = c2.req.header("sec-websocket-protocol");
+        let encodingRaw;
+        let connParamsRaw;
+        let connIdRaw;
+        let connTokenRaw;
+        if (protocols) {
+          const protocolList = protocols.split(",").map((p) => p.trim());
+          for (const protocol of protocolList) {
+            if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
+              encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
+            } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
+              connParamsRaw = decodeURIComponent(
+                protocol.substring(WS_PROTOCOL_CONN_PARAMS.length)
+              );
+            } else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
+              connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
+            } else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
+              connTokenRaw = protocol.substring(WS_PROTOCOL_CONN_TOKEN.length);
+            }
+          }
+        }
+        const encoding = EncodingSchema.parse(encodingRaw);
+        const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
+        return await handleWebSocketConnect(
+          c2.req.raw,
+          runConfig,
+          actorDriver,
+          c2.env.actorId,
+          encoding,
+          connParams,
+          connIdRaw,
+          connTokenRaw
+        );
+      })(c, noopNext());
+    } else {
+      return c.text(
+        "WebSockets are not enabled for this driver. Use SSE instead.",
+        400
+      );
+    }
+  });
+  router.get("/connect/sse", async (c) => {
+    return handleSseConnect(c, runConfig, actorDriver, c.env.actorId);
+  });
+  router.post("/action/:action", async (c) => {
+    const actionName = c.req.param("action");
+    return handleAction(c, runConfig, actorDriver, actionName, c.env.actorId);
+  });
+  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.post("/connections/close", 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 handleConnectionClose(
+      c,
+      runConfig,
+      actorDriver,
+      connId,
+      connToken,
+      c.env.actorId
+    );
+  });
+  router.all("/raw/http/*", async (c) => {
+    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,
+      duplex: "half"
+    });
+    loggerWithoutContext().debug({
+      msg: "rewriting http url",
+      from: c.req.url,
+      to: correctedRequest.url
+    });
+    const response = await actor2.handleFetch(correctedRequest, {});
+    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 url = new URL(c2.req.url);
+        const pathWithQuery = c2.req.path + url.search;
+        loggerWithoutContext().debug({
+          msg: "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
+        );
+      })(c, noopNext());
+    } else {
+      return c.text(
+        "WebSockets are not enabled for this driver. Use SSE instead.",
+        400
+      );
+    }
+  });
+  if (isInspectorEnabled(runConfig, "actor")) {
+    router.route(
+      "/inspect",
+      new Hono().use(
+        cors(runConfig.inspector.cors),
+        secureInspector(runConfig),
+        async (c, next) => {
+          const inspector = (await actorDriver.loadActor(c.env.actorId)).inspector;
+          invariant2(inspector, "inspector not supported on this platform");
+          c.set("inspector", inspector);
+          return next();
+        }
+      ).route("/", createActorInspectorRouter())
+    );
+  }
+  router.notFound(handleRouteNotFound);
+  router.onError(handleRouteError);
+  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";
+function logger3() {
+  return getLogger("fake-event-source2");
+}
+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) => {
+        logger3().debug({ msg: "WSContext.send called" });
+        this.#handleMessage(data);
+      },
+      close: (code, reason) => {
+        logger3().debug({ msg: "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) {
+    logger3().debug({ msg: "send called", readyState: this.readyState });
+    if (this.readyState !== this.OPEN) {
+      const error = new Error("WebSocket is not open");
+      logger3().warn({
+        msg: "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;
+    }
+    logger3().debug({ msg: "closing fake websocket", code, reason });
+    this.#readyState = this.CLOSING;
+    try {
+      this.#handler.onClose({ code, reason, wasClean: true }, this.#wsContext);
+    } catch (err) {
+      logger3().error({ msg: "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 {
+      logger3().debug({ msg: "fake websocket initializing" });
+      logger3().debug({ msg: "calling handler.onOpen with WSContext" });
+      this.#handler.onOpen(void 0, this.#wsContext);
+      this.#readyState = this.OPEN;
+      logger3().debug({ msg: "fake websocket initialized and now OPEN" });
+      this.#fireOpen();
+      if (this.#queuedMessages.length > 0) {
+        if (this.readyState !== this.OPEN) {
+          logger3().warn({
+            msg: "socket no longer open, dropping queued messages"
+          });
+          return;
+        }
+        logger3().debug({
+          msg: `now processing ${this.#queuedMessages.length} queued messages`
+        });
+        const messagesToProcess = [...this.#queuedMessages];
+        this.#queuedMessages = [];
+        for (const message of messagesToProcess) {
+          logger3().debug({ msg: "processing queued message" });
+          this.#handleMessage(message);
+        }
+      }
+    } catch (err) {
+      logger3().error({
+        msg: "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) {
+      logger3().debug({
+        msg: "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;
+    }
+    logger3().debug({
+      msg: "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) {
+      logger3().debug(
+        `dispatching ${type} event to ${listeners.length} listeners`
+      );
+      for (const listener of listeners) {
+        try {
+          listener(event);
+        } catch (err) {
+          logger3().error({
+            msg: `error in ${type} event listener`,
+            error: err
+          });
+        }
+      }
+    } else {
+      logger3().debug({
+        msg: `no ${type} listeners registered, buffering event`
+      });
+      this.#bufferedEvents.push({ type, event });
+    }
+    switch (type) {
+      case "open":
+        if (this.#onopen) {
+          try {
+            this.#onopen(event);
+          } catch (error) {
+            logger3().error({ msg: "error in onopen handler", error });
+          }
+        }
+        break;
+      case "close":
+        if (this.#onclose) {
+          try {
+            this.#onclose(event);
+          } catch (error) {
+            logger3().error({ msg: "error in onclose handler", error });
+          }
+        }
+        break;
+      case "error":
+        if (this.#onerror) {
+          try {
+            this.#onerror(event);
+          } catch (error) {
+            logger3().error({ msg: "error in onerror handler", error });
+          }
+        }
+        break;
+      case "message":
+        if (this.#onmessage) {
+          try {
+            this.#onmessage(event);
+          } catch (error) {
+            logger3().error({ msg: "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) {
+      logger3().error({ msg: "error in open event", error: err });
+    }
+  }
+  #fireClose(event) {
+    try {
+      this.#dispatchEvent("close", event);
+    } catch (err) {
+      logger3().error({ msg: "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) {
+      logger3().error({ msg: "error in error event", error: err });
+    }
+    logger3().error({ msg: "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 cbor3 from "cbor-x";
+import { streamSSE as streamSSE2 } from "hono/streaming";
+import { WSContext as WSContext2 } from "hono/ws";
+import invariant3 from "invariant";
+
+// src/drivers/engine/kv.ts
+var KEYS = {
+  PERSIST_DATA: Uint8Array.from([1])
+};
+
+// src/drivers/engine/log.ts
+function logger4() {
+  return getLogger("driver-engine");
+}
+
+// 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
+  #runnerStarted = Promise.withResolvers();
+  #runnerStopped = Promise.withResolvers();
+  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,
+      token: config2.token,
+      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) {
+          logger4().info({
+            msg: "runner reconnected",
+            namespace: this.#config.namespace,
+            runnerName: this.#config.runnerName
+          });
+        } else {
+          logger4().debug({
+            msg: "runner connected",
+            namespace: this.#config.namespace,
+            runnerName: this.#config.runnerName
+          });
+        }
+        this.#runnerStarted.resolve(void 0);
+      },
+      onDisconnected: () => {
+        logger4().warn({
+          msg: "runner disconnected",
+          namespace: this.#config.namespace,
+          runnerName: this.#config.runnerName
+        });
+        hasDisconnected = true;
+      },
+      onShutdown: () => {
+        this.#runnerStopped.resolve(void 0);
+      },
+      fetch: this.#runnerFetch.bind(this),
+      websocket: this.#runnerWebSocket.bind(this),
+      onActorStart: this.#runnerOnActorStart.bind(this),
+      onActorStop: this.#runnerOnActorStop.bind(this),
+      logger: getLogger("engine-runner")
+    };
+    this.#runner = new Runner(runnerConfig);
+    this.#runner.start();
+    logger4().debug({
+      msg: "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;
+  }
+  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;
+    logger4().debug({
+      msg: "runner actor starting",
+      actorId,
+      name: config2.name,
+      key: config2.key,
+      generation
+    });
+    let input;
+    if (config2.input) {
+      input = cbor3.decode(config2.input);
+    }
+    let handler = this.#actors.get(actorId);
+    if (!handler) {
+      handler = {
+        actorStartPromise: promiseWithResolvers(),
+        persistedData: serializeEmptyPersistData(input)
+      };
+      this.#actors.set(actorId, handler);
+    }
+    const name = config2.name;
+    invariant3(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();
+    await handler.actor.start(
+      this,
+      this.#inlineClient,
+      actorId,
+      name,
+      key,
+      "unknown"
+      // TODO: Add regions
+    );
+    (_a = handler.actorStartPromise) == null ? void 0 : _a.resolve();
+    handler.actorStartPromise = void 0;
+    logger4().debug({ msg: "runner actor started", actorId, name, key });
+  }
+  async #runnerOnActorStop(actorId, generation) {
+    logger4().debug({ msg: "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);
+    }
+    logger4().debug({ msg: "runner actor stopped", actorId });
+  }
+  async #runnerFetch(actorId, request) {
+    logger4().debug({
+      msg: "runner fetch",
+      actorId,
+      url: request.url,
+      method: request.method
+    });
+    return await this.#actorRouter.fetch(request, { actorId });
+  }
+  async #runnerWebSocket(actorId, websocketRaw, request) {
+    const websocket = websocketRaw;
+    logger4().debug({ msg: "runner websocket", actorId, url: request.url });
+    const url = new URL(request.url);
+    const protocols = request.headers.get("sec-websocket-protocol");
+    if (protocols === null)
+      throw new Error(`Missing sec-websocket-protocol header`);
+    let encodingRaw;
+    let connParamsRaw;
+    if (protocols) {
+      const protocolList = protocols.split(",").map((p) => p.trim());
+      for (const protocol of protocolList) {
+        if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
+          encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
+        } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
+          connParamsRaw = decodeURIComponent(
+            protocol.substring(WS_PROTOCOL_CONN_PARAMS.length)
+          );
+        }
+      }
+    }
+    const encoding = EncodingSchema.parse(encodingRaw);
+    const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
+    let wsHandlerPromise;
+    if (url.pathname === PATH_CONNECT_WEBSOCKET) {
+      wsHandlerPromise = handleWebSocketConnect(
+        request,
+        this.#runConfig,
+        this,
+        actorId,
+        encoding,
+        connParams,
+        // Extract connId and connToken from protocols if needed
+        void 0,
+        void 0
+      );
+    } else if (url.pathname.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {
+      wsHandlerPromise = handleRawWebSocketHandler(
+        request,
+        url.pathname + url.search,
+        this,
+        actorId
+      );
+    } else {
+      throw new Error(`Unreachable path: ${url.pathname}`);
+    }
+    const wsContext = new WSContext2(websocket);
+    wsHandlerPromise.catch((err) => {
+      logger4().error({ msg: "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) {
+    logger4().info({ msg: "stopping engine actor driver" });
+    await this.#runner.shutdown(immediate);
+  }
+  async serverlessHandleStart(c) {
+    await this.#runnerStarted.promise;
+    return streamSSE2(c, async (stream) => {
+      const runnerId = this.#runner.runnerId;
+      invariant3(runnerId, "runnerId not set");
+      stream.writeSSE({ data: runnerId });
+      return this.#runnerStopped.promise;
+    });
+  }
+};
+
+// 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:6420"
+  ),
+  token: z2.string().optional().transform((val) => val ?? getEnvUniversal("RIVET_TOKEN")),
+  pegboardEndpoint: z2.string().optional(),
+  namespace: z2.string().default(() => getEnvUniversal("RIVET_NAMESPACE") ?? "default"),
+  runnerName: z2.string().default(() => getEnvUniversal("RIVET_RUNNER") ?? "rivetkit"),
+  // TODO: Automatically attempt to 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)
+}).default({});
+
+// src/drivers/engine/mod.ts
+function createEngineDriver(inputConfig) {
+  const config2 = ConfigSchema.parse(inputConfig);
+  return {
+    name: "engine",
+    manager: (_registryConfig, runConfig) => {
+      return new RemoteManagerDriver(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
+    );
+  }
+  /**
+   * 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 crypto3 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
+function logger5() {
+  return getLogger("driver-fs");
+}
+
+// src/drivers/file-system/utils.ts
+import * as crypto2 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 = crypto2.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 = crypto2.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 persist() {
+    return this.#persist;
+  }
+  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) {
+        logger5().error({ msg: "failed to count actors", error });
+      }
+      logger5().debug({
+        msg: "file system driver ready",
+        dir: this.#storagePath,
+        actorCount: this.#actorCountOnStartup
+      });
+      try {
+        this.#cleanupTempFilesSync();
+      } catch (err) {
+        logger5().error({ msg: "failed to cleanup temp files", error: err });
+      }
+    } else {
+      logger5().debug({ msg: "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) {
+        logger5().error({ msg: "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,
+      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.${crypto3.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 {
+        }
+        logger5().error({ msg: "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.${crypto3.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 {
+      }
+      logger5().error({ msg: "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) {
+      return;
+    }
+    this.#runnerParams = {
+      registryConfig,
+      runConfig,
+      inlineClient,
+      actorDriver
+    };
+    try {
+      this.#loadAlarmsSync();
+    } catch (err) {
+      logger5().error({ msg: "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 not 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 = promiseWithResolvers();
+    try {
+      const definition = lookupInRegistry(registryConfig, entry.state.name);
+      entry.actor = definition.instantiate();
+      await entry.actor.start(
+        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 {
+            logger5().debug({ msg: "invalid alarm file contents", file });
+          }
+        } catch (err) {
+          logger5().error({
+            msg: "failed to read alarm file",
+            file,
+            error: stringifyError(err)
+          });
+        }
+      }
+    } catch (err) {
+      logger5().error({ msg: "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) {
+      logger5().debug({
+        msg: "skipping alarm schedule (later than existing)",
+        actorId,
+        timestamp,
+        current: entry.alarmTimestamp
+      });
+      return;
+    }
+    logger5().debug({ msg: "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") {
+            logger5().debug({
+              msg: "failed to remove alarm file",
+              actorId,
+              error: stringifyError(err)
+            });
+          }
+        }
+      }
+      try {
+        logger5().debug({ msg: "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) {
+        logger5().error({
+          msg: "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);
+            logger5().info({
+              msg: "cleaned up stale temp file",
+              file: tempFile
+            });
+          }
+        } catch (err) {
+          logger5().debug({
+            msg: "failed to cleanup temp file",
+            file: tempFile,
+            error: err
+          });
+        }
+      }
+    } catch (err) {
+      logger5().error({
+        msg: "failed to read actors directory for cleanup",
+        error: err
+      });
+    }
+  }
+};
+
+// src/drivers/file-system/manager.ts
+import invariant5 from "invariant";
+
+// 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({ msg: "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({ msg: "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;
+      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(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, connId, connToken) {
+    const pathOnly = path3.split("?")[0];
+    const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
+    if (normalizedPath === PATH_CONNECT_WEBSOCKET) {
+      const wsHandler = await handleWebSocketConnect(
+        void 0,
+        this.#runConfig,
+        this.#actorDriver,
+        actorId,
+        encoding,
+        params,
+        connId,
+        connToken
+      );
+      return new InlineWebSocketAdapter2(wsHandler);
+    } else if (normalizedPath.startsWith(PATH_RAW_WEBSOCKET_PREFIX) || normalizedPath === "/raw/websocket") {
+      const wsHandler = await handleRawWebSocketHandler(
+        void 0,
+        path3,
+        this.#actorDriver,
+        actorId
+      );
+      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, connId, connToken) {
+    var _a, _b;
+    const upgradeWebSocket = (_b = (_a = this.#runConfig).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
+    invariant5(upgradeWebSocket, "missing getUpgradeWebSocket");
+    const pathOnly = path3.split("?")[0];
+    const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
+    if (normalizedPath === PATH_CONNECT_WEBSOCKET) {
+      const wsHandler = await handleWebSocketConnect(
+        c.req.raw,
+        this.#runConfig,
+        this.#actorDriver,
+        actorId,
+        encoding,
+        connParams,
+        connId,
+        connToken
+      );
+      return upgradeWebSocket(() => wsHandler)(c, noopNext());
+    } else if (normalizedPath.startsWith(PATH_RAW_WEBSOCKET_PREFIX) || normalizedPath === "/raw/websocket") {
+      const wsHandler = await handleRawWebSocketHandler(
+        c.req.raw,
+        path3,
+        this.#actorDriver,
+        actorId
+      );
+      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) {
+      logger5().error({ msg: "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
+    );
+    invariant5(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
+    };
+  }
+  displayInformation() {
+    return {
+      name: this.#state.persist ? "File System" : "Memory",
+      properties: {
+        ...this.#state.persist ? { Data: this.#state.storagePath } : {},
+        Instances: this.#state.actorCountOnStartup.toString()
+      }
+    };
+  }
+  extraStartupLog() {
+    return {
+      instances: this.#state.actorCountOnStartup,
+      data: this.#state.storagePath
+    };
+  }
+  getOrCreateInspectorAccessToken() {
+    return this.#state.getOrCreateInspectorAccessToken();
+  }
+};
+
+// 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) {
+  if (runConfig.endpoint && runConfig.driver) {
+    throw new UserError(
+      "Cannot specify both 'engine' and 'driver' in configuration"
+    );
+  }
+  if (runConfig.driver) {
+    return runConfig.driver;
+  }
+  if (runConfig.endpoint) {
+    loggerWithoutContext().debug({
+      msg: "using rivet engine driver",
+      endpoint: runConfig.endpoint
+    });
+    return createEngineDriver({
+      endpoint: runConfig.endpoint,
+      token: runConfig.token
+    });
+  }
+  loggerWithoutContext().debug({ msg: "using default file system driver" });
+  return createFileSystemOrMemoryDriver(true);
+}
+
+// src/manager/router.ts
+import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import * as cbor4 from "cbor-x";
+import {
+  Hono as Hono3
+} from "hono";
+import { cors as corsMiddleware } from "hono/cors";
+import { createMiddleware } from "hono/factory";
+import invariant6 from "invariant";
+import { z as z5 } from "zod";
+
+// src/manager-api/actors.ts
+import { z as z4 } from "zod";
+
+// src/manager-api/common.ts
+import { z as z3 } from "zod";
+var RivetIdSchema = z3.string();
+
+// src/manager-api/actors.ts
+var ActorSchema = z4.object({
+  actor_id: RivetIdSchema,
+  name: z4.string(),
+  key: z4.string(),
+  namespace_id: RivetIdSchema,
+  runner_name_selector: z4.string(),
+  create_ts: z4.number(),
+  connectable_ts: z4.number().nullable().optional(),
+  destroy_ts: z4.number().nullable().optional(),
+  sleep_ts: z4.number().nullable().optional(),
+  start_ts: z4.number().nullable().optional()
+});
+var ActorsListResponseSchema = z4.object({
+  actors: z4.array(ActorSchema)
+});
+var ActorsCreateRequestSchema = z4.object({
+  name: z4.string(),
+  runner_name_selector: z4.string(),
+  crash_policy: z4.string(),
+  key: z4.string().nullable().optional(),
+  input: z4.string().nullable().optional()
+});
+var ActorsCreateResponseSchema = z4.object({
+  actor: ActorSchema
+});
+var ActorsGetOrCreateRequestSchema = z4.object({
+  name: z4.string(),
+  key: z4.string(),
+  runner_name_selector: z4.string(),
+  crash_policy: z4.string(),
+  input: z4.string().nullable().optional()
+});
+var ActorsGetOrCreateResponseSchema = z4.object({
+  actor: ActorSchema,
+  created: z4.boolean()
+});
+var ActorsDeleteResponseSchema = z4.object({});
+
+// src/manager/gateway.ts
+async function actorGateway(runConfig, managerDriver, c, next) {
+  if (c.req.path.startsWith("/.test/")) {
+    return next();
+  }
+  if (c.req.header("upgrade") === "websocket") {
+    return await handleWebSocketGateway(runConfig, managerDriver, c);
+  }
+  return await handleHttpGateway(managerDriver, c, next);
+}
+async function handleWebSocketGateway(runConfig, managerDriver, c) {
+  var _a;
+  const upgradeWebSocket = (_a = runConfig.getUpgradeWebSocket) == null ? void 0 : _a.call(runConfig);
+  if (!upgradeWebSocket) {
+    throw new WebSocketsNotEnabled();
+  }
+  const protocols = c.req.header("sec-websocket-protocol");
+  let target;
+  let actorId;
+  let encodingRaw;
+  let connParamsRaw;
+  let connIdRaw;
+  let connTokenRaw;
+  if (protocols) {
+    const protocolList = protocols.split(",").map((p) => p.trim());
+    for (const protocol of protocolList) {
+      if (protocol.startsWith(WS_PROTOCOL_TARGET)) {
+        target = protocol.substring(WS_PROTOCOL_TARGET.length);
+      } else if (protocol.startsWith(WS_PROTOCOL_ACTOR)) {
+        actorId = protocol.substring(WS_PROTOCOL_ACTOR.length);
+      } else if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
+        encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
+      } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
+        connParamsRaw = decodeURIComponent(
+          protocol.substring(WS_PROTOCOL_CONN_PARAMS.length)
+        );
+      } else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
+        connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
+      } else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
+        connTokenRaw = protocol.substring(WS_PROTOCOL_CONN_TOKEN.length);
+      }
+    }
+  }
+  if (target !== "actor") {
+    return c.text("WebSocket upgrade requires target.actor protocol", 400);
+  }
+  if (!actorId) {
+    throw new MissingActorHeader();
+  }
+  logger().debug({
+    msg: "proxying websocket to actor",
+    actorId,
+    path: c.req.path,
+    encoding: encodingRaw
+  });
+  const encoding = encodingRaw || "json";
+  const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
+  const pathWithQuery = c.req.url.includes("?") ? c.req.path + c.req.url.substring(c.req.url.indexOf("?")) : c.req.path;
+  return await managerDriver.proxyWebSocket(
+    c,
+    pathWithQuery,
+    actorId,
+    encoding,
+    // Will be validated by driver
+    connParams,
+    connIdRaw,
+    connTokenRaw
+  );
+}
+async function handleHttpGateway(managerDriver, c, next) {
+  const target = c.req.header(HEADER_RIVET_TARGET);
+  const actorId = c.req.header(HEADER_RIVET_ACTOR);
+  if (target !== "actor") {
+    return next();
+  }
+  if (!actorId) {
+    throw new MissingActorHeader();
+  }
+  logger().debug({
+    msg: "proxying request to actor",
+    actorId,
+    path: c.req.path,
+    method: c.req.method
+  });
+  const proxyHeaders = new Headers(c.req.raw.headers);
+  proxyHeaders.delete(HEADER_RIVET_TARGET);
+  proxyHeaders.delete(HEADER_RIVET_ACTOR);
+  const url = new URL(c.req.url);
+  const proxyUrl = new URL(`http://actor${url.pathname}${url.search}`);
+  const proxyRequest = new Request(proxyUrl, {
+    method: c.req.raw.method,
+    headers: proxyHeaders,
+    body: c.req.raw.body,
+    signal: c.req.raw.signal
+  });
+  return await managerDriver.proxyRequest(c, proxyRequest, actorId);
+}
+async function createTestWebSocketProxy(clientWsPromise) {
+  let clientWs = null;
+  const {
+    promise: serverWsPromise,
+    resolve: serverWsResolve,
+    reject: serverWsReject
+  } = promiseWithResolvers();
+  try {
+    logger().debug({ msg: "awaiting client websocket promise" });
+    const ws = await clientWsPromise;
+    clientWs = ws;
+    logger().debug({
+      msg: "client websocket promise resolved",
+      constructor: ws == null ? void 0 : ws.constructor.name
+    });
+    await new Promise((resolve, reject) => {
+      const onOpen = () => {
+        logger().debug({ msg: "test websocket connection to actor opened" });
+        resolve();
+      };
+      const onError = (error) => {
+        logger().error({ msg: "test websocket connection failed", error });
+        reject(
+          new Error(`Failed to open WebSocket: ${error.message || error}`)
+        );
+        serverWsReject();
+      };
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onError);
+      ws.addEventListener("message", async (clientEvt) => {
+        var _a, _b;
+        const serverWs = await serverWsPromise;
+        logger().debug({
+          msg: `test 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) => {
+              logger().debug({
+                msg: "converted client blob to arraybuffer, sending to server",
+                bufferSize: buffer.byteLength
+              });
+              serverWs.send(buffer);
+            }).catch((error) => {
+              logger().error({
+                msg: "failed to convert blob to arraybuffer",
+                error
+              });
+            });
+          } else {
+            logger().debug({
+              msg: "sending client data directly to server",
+              dataType: typeof clientEvt.data,
+              dataLength: typeof clientEvt.data === "string" ? clientEvt.data.length : void 0
+            });
+            serverWs.send(clientEvt.data);
+          }
+        }
+      });
+      ws.addEventListener("close", async (clientEvt) => {
+        const serverWs = await serverWsPromise;
+        logger().debug({
+          msg: `test websocket connection closed`
+        });
+        if (serverWs.readyState !== 3) {
+          serverWs.close(clientEvt.code, clientEvt.reason);
+        }
+      });
+      ws.addEventListener("error", async () => {
+        const serverWs = await serverWsPromise;
+        logger().debug({
+          msg: `test websocket connection error`
+        });
+        if (serverWs.readyState !== 3) {
+          serverWs.close(1011, "Error in client websocket");
+        }
+      });
+    });
+  } catch (error) {
+    logger().error({
+      msg: `failed to establish client websocket connection`,
+      error
+    });
+    return {
+      onOpen: (_evt, serverWs) => {
+        serverWs.close(1011, "Failed to establish connection");
+      },
+      onMessage: () => {
+      },
+      onError: () => {
+      },
+      onClose: () => {
+      }
+    };
+  }
+  return {
+    onOpen: (_evt, serverWs) => {
+      logger().debug({
+        msg: `test websocket connection from client opened`
+      });
+      logger().debug({
+        msg: "clientWs info",
+        constructor: clientWs.constructor.name,
+        hasAddEventListener: typeof clientWs.addEventListener === "function",
+        readyState: clientWs.readyState
+      });
+      serverWsResolve(serverWs);
+    },
+    onMessage: (evt) => {
+      var _a, _b;
+      logger().debug({
+        msg: "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) => {
+            logger().debug({
+              msg: "converted blob to arraybuffer, sending",
+              bufferSize: buffer.byteLength
+            });
+            clientWs.send(buffer);
+          }).catch((error) => {
+            logger().error({
+              msg: "failed to convert blob to arraybuffer",
+              error
+            });
+          });
+        } else {
+          logger().debug({
+            msg: "sending data directly",
+            dataType: typeof evt.data,
+            dataLength: typeof evt.data === "string" ? evt.data.length : void 0
+          });
+          clientWs.send(evt.data);
+        }
+      }
+    },
+    onClose: (event, serverWs) => {
+      logger().debug({
+        msg: `server 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) => {
+      logger().error({
+        msg: `error in server websocket`,
+        error
+      });
+      if (clientWs && clientWs.readyState !== clientWs.CLOSED && clientWs.readyState !== clientWs.CLOSING) {
+        clientWs.close(1011, "Error in server websocket");
+      }
+      serverWsReject();
+    }
+  };
+}
+
+// src/manager/router.ts
+function buildOpenApiResponses(schema) {
+  return {
+    200: {
+      description: "Success",
+      content: {
+        "application/json": {
+          schema
+        }
+      }
+    },
+    400: {
+      description: "User error"
+    },
+    500: {
+      description: "Internal error"
+    }
+  };
+}
+function createManagerRouter(registryConfig, runConfig, managerDriver, serverlessActorDriverBuilder) {
+  const router = new OpenAPIHono({ strict: false }).basePath(
+    runConfig.basePath
+  );
+  router.use("*", loggerMiddleware(logger()));
+  const cors2 = runConfig.cors ? corsMiddleware(runConfig.cors) : createMiddleware((_c, next) => next());
+  if (serverlessActorDriverBuilder) {
+    addServerlessRoutes(serverlessActorDriverBuilder, router, cors2);
+  } else {
+    addManagerRoutes(registryConfig, runConfig, managerDriver, router, cors2);
+  }
+  router.notFound(handleRouteNotFound);
+  router.onError(handleRouteError);
+  return { router, openapi: router, cors: cors2 };
+}
+function addServerlessRoutes(serverlessActorDriverBuilder, router, cors2) {
+  router.get("/", cors2, (c) => {
+    return c.text(
+      "This is a RivetKit server.\n\nLearn more at https://rivetkit.org"
+    );
+  });
+  router.get("/start", cors2, async (c) => {
+    const actorDriver = serverlessActorDriverBuilder();
+    invariant6(
+      actorDriver.serverlessHandleStart,
+      "missing serverlessHandleStart on ActorDriver"
+    );
+    return await actorDriver.serverlessHandleStart(c);
+  });
+  router.get("/health", cors2, (c) => {
+    return c.text("ok");
+  });
+}
+function addManagerRoutes(registryConfig, runConfig, managerDriver, router, cors2) {
+  var _a;
+  router.use("*", cors2, actorGateway.bind(void 0, runConfig, managerDriver));
+  router.get("/", cors2, (c) => {
+    return c.text(
+      "This is a RivetKit server.\n\nLearn more at https://rivetkit.org"
+    );
+  });
+  {
+    const route = createRoute({
+      middleware: [cors2],
+      method: "get",
+      path: "/actors",
+      request: {
+        query: z5.object({
+          name: z5.string(),
+          actor_ids: z5.string().optional(),
+          key: z5.string().optional()
+        })
+      },
+      responses: buildOpenApiResponses(ActorsListResponseSchema)
+    });
+    router.openapi(route, async (c) => {
+      const { name, actor_ids, key } = c.req.valid("query");
+      const actorIdsParsed = actor_ids ? actor_ids.split(",").map((id) => id.trim()).filter((id) => id.length > 0) : void 0;
+      const actors = [];
+      if (actorIdsParsed) {
+        if (actorIdsParsed.length > 32) {
+          return c.json(
+            {
+              error: `Too many actor IDs. Maximum is 32, got ${actorIdsParsed.length}.`
+            },
+            400
+          );
+        }
+        if (actorIdsParsed.length === 0) {
+          return c.json({
+            actors: []
+          });
+        }
+        for (const actorId of actorIdsParsed) {
+          if (name) {
+            const actorOutput = await managerDriver.getForId({
+              c,
+              name,
+              actorId
+            });
+            if (actorOutput) {
+              actors.push(actorOutput);
+            }
+          }
+        }
+      } else if (key) {
+        const actorOutput = await managerDriver.getWithKey({
+          c,
+          name,
+          key: [key]
+          // Convert string to ActorKey array
+        });
+        if (actorOutput) {
+          actors.push(actorOutput);
+        }
+      }
+      return c.json({
+        actors: actors.map(createApiActor)
+      });
+    });
+  }
+  {
+    const route = createRoute({
+      middleware: [cors2],
+      method: "put",
+      path: "/actors",
+      request: {
+        body: {
+          content: {
+            "application/json": {
+              schema: ActorsGetOrCreateRequestSchema
+            }
+          }
+        }
+      },
+      responses: buildOpenApiResponses(ActorsGetOrCreateResponseSchema)
+    });
+    router.openapi(route, async (c) => {
+      const body = c.req.valid("json");
+      const existingActor = await managerDriver.getWithKey({
+        c,
+        name: body.name,
+        key: [body.key]
+        // Convert string to ActorKey array
+      });
+      if (existingActor) {
+        return c.json({
+          actor: createApiActor(existingActor),
+          created: false
+        });
+      }
+      const newActor = await managerDriver.getOrCreateWithKey({
+        c,
+        name: body.name,
+        key: [body.key],
+        // Convert string to ActorKey array
+        input: body.input ? cbor4.decode(Buffer.from(body.input, "base64")) : void 0,
+        region: void 0
+        // Not provided in the request schema
+      });
+      return c.json({
+        actor: createApiActor(newActor),
+        created: true
+      });
+    });
+  }
+  {
+    const route = createRoute({
+      middleware: [cors2],
+      method: "post",
+      path: "/actors",
+      request: {
+        body: {
+          content: {
+            "application/json": {
+              schema: ActorsCreateRequestSchema
+            }
+          }
+        }
+      },
+      responses: buildOpenApiResponses(ActorsCreateResponseSchema)
+    });
+    router.openapi(route, async (c) => {
+      const body = c.req.valid("json");
+      const actorOutput = await managerDriver.createActor({
+        c,
+        name: body.name,
+        key: [body.key || crypto.randomUUID()],
+        // Generate key if not provided, convert to ActorKey array
+        input: body.input ? cbor4.decode(Buffer.from(body.input, "base64")) : void 0,
+        region: void 0
+        // Not provided in the request schema
+      });
+      const actor2 = createApiActor(actorOutput);
+      return c.json({ actor: actor2 });
+    });
+  }
+  if (registryConfig.test.enabled) {
+    router.post(".test/inline-driver/call", async (c) => {
+      const buffer = await c.req.arrayBuffer();
+      const { encoding, transport, method, args } = cbor4.decode(new Uint8Array(buffer));
+      logger().debug({
+        msg: "received inline request",
+        encoding,
+        transport,
+        method,
+        args
+      });
+      let response;
+      try {
+        const output = await managerDriver[method](...args);
+        response = { ok: output };
+      } catch (rawErr) {
+        const err = deconstructError(rawErr, logger(), {}, true);
+        response = { err };
+      }
+      return c.body(cbor4.encode(response));
+    });
+    router.get(".test/inline-driver/connect-websocket/*", async (c) => {
+      var _a2;
+      const upgradeWebSocket = (_a2 = runConfig.getUpgradeWebSocket) == null ? void 0 : _a2.call(runConfig);
+      invariant6(upgradeWebSocket, "websockets not supported on this platform");
+      return upgradeWebSocket(async (c2) => {
+        const protocolHeader = c2.req.header("sec-websocket-protocol") || "";
+        const protocols = protocolHeader.split(/,\s*/);
+        let actorId = "";
+        let encoding = "bare";
+        let transport = "websocket";
+        let path3 = "";
+        let params;
+        let connId;
+        let connToken;
+        for (const protocol of protocols) {
+          if (protocol.startsWith(WS_PROTOCOL_ACTOR)) {
+            actorId = protocol.substring(WS_PROTOCOL_ACTOR.length);
+          } else if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
+            encoding = protocol.substring(
+              WS_PROTOCOL_ENCODING.length
+            );
+          } else if (protocol.startsWith(WS_PROTOCOL_TRANSPORT)) {
+            transport = protocol.substring(
+              WS_PROTOCOL_TRANSPORT.length
+            );
+          } else if (protocol.startsWith(WS_PROTOCOL_PATH)) {
+            path3 = decodeURIComponent(
+              protocol.substring(WS_PROTOCOL_PATH.length)
+            );
+          } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
+            const paramsRaw = decodeURIComponent(
+              protocol.substring(WS_PROTOCOL_CONN_PARAMS.length)
+            );
+            params = JSON.parse(paramsRaw);
+          } else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
+            connId = protocol.substring(WS_PROTOCOL_CONN_ID.length);
+          } else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
+            connToken = protocol.substring(WS_PROTOCOL_CONN_TOKEN.length);
+          }
+        }
+        logger().debug({
+          msg: "received test inline driver websocket",
+          actorId,
+          params,
+          encodingKind: encoding,
+          transport,
+          path: path3
+        });
+        const clientWsPromise = managerDriver.openWebSocket(
+          path3,
+          actorId,
+          encoding,
+          params,
+          connId,
+          connToken
+        );
+        return await createTestWebSocketProxy(clientWsPromise);
+      })(c, noopNext());
+    });
+    router.all(".test/inline-driver/send-request/*", async (c) => {
+      const actorId = c.req.header(HEADER_ACTOR_ID);
+      if (!actorId) {
+        return c.text("Missing required headers", 400);
+      }
+      const pathOnly = c.req.path.split("/.test/inline-driver/send-request/")[1] || "";
+      const url = new URL(c.req.url);
+      const pathWithQuery = pathOnly + url.search;
+      logger().debug({
+        msg: "received test inline driver raw http",
+        actorId,
+        path: pathWithQuery,
+        method: c.req.method
+      });
+      try {
+        const response = await managerDriver.sendRequest(
+          actorId,
+          new Request(`http://actor/${pathWithQuery}`, {
+            method: c.req.method,
+            headers: c.req.raw.headers,
+            body: c.req.raw.body,
+            duplex: "half"
+          })
+        );
+        return response;
+      } catch (error) {
+        logger().error({
+          msg: "error in test inline raw http",
+          error: stringifyError(error)
+        });
+        const err = deconstructError(error, logger(), {}, true);
+        return c.json(
+          {
+            error: {
+              code: err.code,
+              message: err.message,
+              metadata: err.metadata
+            }
+          },
+          err.statusCode
+        );
+      }
+    });
+    router.post("/.test/force-disconnect", async (c) => {
+      const actorId = c.req.query("actor");
+      const connId = c.req.query("conn");
+      if (!actorId || !connId) {
+        return c.text("Missing actor or conn query parameters", 400);
+      }
+      logger().debug({
+        msg: "forcing unclean disconnect",
+        actorId,
+        connId
+      });
+      try {
+        const response = await managerDriver.sendRequest(
+          actorId,
+          new Request(`http://actor/.test/force-disconnect?conn=${connId}`, {
+            method: "POST"
+          })
+        );
+        if (!response.ok) {
+          const text = await response.text();
+          return c.text(
+            `Failed to force disconnect: ${text}`,
+            response.status
+          );
+        }
+        return c.json({ success: true });
+      } catch (error) {
+        logger().error({
+          msg: "error forcing disconnect",
+          error: stringifyError(error)
+        });
+        return c.text(`Error: ${error}`, 500);
+      }
+    });
+  }
+  router.get("/health", cors2, (c) => {
+    return c.text("ok");
+  });
+  (_a = managerDriver.modifyManagerRouter) == null ? void 0 : _a.call(
+    managerDriver,
+    registryConfig,
+    router
+  );
+  if (isInspectorEnabled(runConfig, "manager")) {
+    if (!managerDriver.inspector) {
+      throw new Unsupported("inspector");
+    }
+    router.route(
+      "/inspect",
+      new Hono3().use(corsMiddleware(runConfig.inspector.cors)).use(secureInspector(runConfig)).use((c, next) => {
+        c.set("inspector", managerDriver.inspector);
+        return next();
+      }).route("/", createManagerInspectorRouter())
+    );
+  }
+}
+function createApiActor(actor2) {
+  return {
+    actor_id: actor2.actorId,
+    name: actor2.name,
+    key: serializeActorKey(actor2.key),
+    namespace_id: "default",
+    // Assert default namespace
+    runner_name_selector: "rivetkit",
+    // Assert rivetkit runner
+    create_ts: Date.now(),
+    connectable_ts: null,
+    destroy_ts: null,
+    sleep_ts: null,
+    start_ts: null
+  };
+}
+
+// src/registry/config.ts
+import { z as z6 } from "zod";
+var ActorsSchema = z6.record(
+  z6.string(),
+  z6.custom()
+);
+var TestConfigSchema = z6.object({ enabled: z6.boolean() });
+var RegistryConfigSchema = z6.object({
+  use: z6.record(z6.string(), z6.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
+function logger6() {
+  return getLogger("registry");
+}
+
+// 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(
+      /* webpackIgnore: true */
+      "@hono/node-server"
+    );
+    serve = dep.serve;
+  } catch (err) {
+    logger6().error(
+      "failed to import @hono/node-server. please run 'npm install @hono/node-server @hono/node-ws'"
+    );
+    process.exit(1);
+  }
+  app.route("/", rivetKitRouter);
+  let createNodeWebSocket;
+  try {
+    const dep = await import(
+      /* webpackIgnore: true */
+      "@hono/node-ws"
+    );
+    createNodeWebSocket = dep.createNodeWebSocket;
+  } catch (err) {
+    logger6().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 = 6420;
+  const server = serve(
+    { fetch: app.fetch, port },
+    () => logger6().info({ msg: "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.
+   */
+  start(inputConfig) {
+    var _a, _b, _c;
+    const config2 = RunConfigSchema.parse(inputConfig);
+    if ((_a = config2.logging) == null ? void 0 : _a.baseLogger) {
+      configureBaseLogger(config2.logging.baseLogger);
+    } else {
+      configureDefaultLogger((_b = config2.logging) == null ? void 0 : _b.level);
+    }
+    const driver = chooseDefaultDriver(config2);
+    if (driver.name === "engine") {
+      config2.inspector.enabled = { manager: false, actor: true };
+      config2.disableServer = true;
+    }
+    if (driver.name === "cloudflare-workers") {
+      config2.inspector.enabled = { manager: false, actor: true };
+      config2.disableServer = true;
+      config2.disableActorDriver = true;
+      config2.noWelcome = true;
+    }
+    let upgradeWebSocket;
+    if (!config2.getUpgradeWebSocket) {
+      config2.getUpgradeWebSocket = () => upgradeWebSocket;
+    }
+    const managerDriver = driver.manager(this.#config, config2);
+    configureInspectorAccessToken(config2, managerDriver);
+    const client = createClientWithDriver(managerDriver, config2);
+    const driverLog = ((_c = managerDriver.extraStartupLog) == null ? void 0 : _c.call(managerDriver)) ?? {};
+    logger6().info({
+      msg: "rivetkit ready",
+      driver: driver.name,
+      definitions: Object.keys(this.#config.use).length,
+      ...driverLog
+    });
+    if (isInspectorEnabled(config2, "manager") && managerDriver.inspector) {
+      logger6().info({ msg: "inspector ready", url: getInspectorUrl(config2) });
+    }
+    if (!config2.noWelcome) {
+      const displayInfo = managerDriver.displayInformation();
+      console.log();
+      console.log(`  RivetKit ${package_default.version} (${displayInfo.name})`);
+      console.log(`  - Endpoint:     http://127.0.0.1:6420`);
+      for (const [k, v] of Object.entries(displayInfo.properties)) {
+        const padding = " ".repeat(Math.max(0, 13 - k.length));
+        console.log(`  - ${k}:${padding}${v}`);
+      }
+      if (isInspectorEnabled(config2, "manager") && managerDriver.inspector) {
+        console.log(`  - Inspector:     ${getInspectorUrl(config2)}`);
+      }
+      console.log();
+    }
+    if (!config2.disableActorDriver) {
+      const _actorDriver = driver.actor(
+        this.#config,
+        config2,
+        managerDriver,
+        client
+      );
+    }
+    const { router: hono } = createManagerRouter(
+      this.#config,
+      config2,
+      managerDriver,
+      void 0
+    );
+    if (!config2.disableServer) {
+      (async () => {
+        const out = await crossPlatformServe(hono, void 0);
+        upgradeWebSocket = out.upgradeWebSocket;
+      })();
+    }
+    return {
+      client,
+      fetch: hono.fetch.bind(hono)
+    };
+  }
+  startServerless(inputConfig) {
+    var _a, _b, _c, _d, _e;
+    const config2 = RunConfigSchema.parse(inputConfig);
+    if ((_a = config2.logging) == null ? void 0 : _a.baseLogger) {
+      configureBaseLogger(config2.logging.baseLogger);
+    } else {
+      configureDefaultLogger((_b = config2.logging) == null ? void 0 : _b.level);
+    }
+    const driver = chooseDefaultDriver(config2);
+    if (driver.name === "engine") {
+      config2.inspector.enabled = false;
+      config2.disableServer = true;
+      config2.disableActorDriver = true;
+    }
+    if (driver.name === "cloudflare-workers") {
+      config2.inspector.enabled = false;
+      config2.disableServer = true;
+      config2.disableActorDriver = true;
+      config2.noWelcome = true;
+    }
+    let upgradeWebSocket;
+    if (!config2.getUpgradeWebSocket) {
+      config2.getUpgradeWebSocket = () => upgradeWebSocket;
+    }
+    const managerDriver = driver.manager(this.#config, config2);
+    const client = createClientWithDriver(managerDriver, config2);
+    const driverLog = ((_c = managerDriver.extraStartupLog) == null ? void 0 : _c.call(managerDriver)) ?? {};
+    logger6().info({
+      msg: "rivetkit ready",
+      driver: driver.name,
+      definitions: Object.keys(this.#config.use).length,
+      ...driverLog
+    });
+    if (((_d = config2.inspector) == null ? void 0 : _d.enabled) && managerDriver.inspector) {
+      logger6().info({ msg: "inspector ready", url: getInspectorUrl(config2) });
+    }
+    if (!config2.noWelcome) {
+      const displayInfo = managerDriver.displayInformation();
+      console.log();
+      console.log(`  RivetKit ${package_default.version} (${displayInfo.name})`);
+      console.log(`  - Endpoint:     http://127.0.0.1:6420`);
+      for (const [k, v] of Object.entries(displayInfo.properties)) {
+        const padding = " ".repeat(Math.max(0, 13 - k.length));
+        console.log(`  - ${k}:${padding}${v}`);
+      }
+      if (((_e = config2.inspector) == null ? void 0 : _e.enabled) && managerDriver.inspector) {
+        console.log(`  - Inspector:    ${getInspectorUrl(config2)}`);
+      }
+      console.log();
+    }
+    let serverlessActorDriverBuilder = () => {
+      return driver.actor(this.#config, config2, managerDriver, client);
+    };
+    if (!config2.disableActorDriver) {
+      const _actorDriver = serverlessActorDriverBuilder();
+      serverlessActorDriverBuilder = void 0;
+    }
+    const { router: hono } = createManagerRouter(
+      this.#config,
+      config2,
+      managerDriver,
+      serverlessActorDriverBuilder
+    );
+    if (!config2.disableServer) {
+      (async () => {
+        const out = await crossPlatformServe(hono, void 0);
+        upgradeWebSocket = out.upgradeWebSocket;
+      })();
+    }
+    return {
+      client,
+      fetch: hono.fetch.bind(hono)
+    };
+  }
+};
+function setup(input) {
+  const config2 = RegistryConfigSchema.parse(input);
+  return new Registry(config2);
+}
+
+export {
+  handleWebSocketConnect,
+  handleRawWebSocketHandler,
+  createActorRouter,
+  actor,
+  InlineWebSocketAdapter2,
+  createEngineDriver,
+  createFileSystemOrMemoryDriver,
+  createFileSystemDriver,
+  createMemoryDriver,
+  createManagerRouter,
+  RegistryConfigSchema,
+  Registry,
+  setup
+};
+//! These configs configs hold anything that's not platform-specific about running actors.
+//# sourceMappingURL=chunk-HPT3I7UU.js.map