rivetkit 2.0.2 → 2.0.4-rc.1

package/dist/tsup/chunk-Q4UD2GA4.cjs

@@ -0,0 +1,1810 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+
+
+
+
+var _chunkAUVH72REcjs = require('./chunk-AUVH72RE.cjs');
+
+
+
+
+
+
+
+
+
+
+var _chunkSAZZ4SB2cjs = require('./chunk-SAZZ4SB2.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk4JVIG3SScjs = require('./chunk-4JVIG3SS.cjs');
+
+
+
+
+
+
+var _chunkPVOE6BU7cjs = require('./chunk-PVOE6BU7.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkPQZHDKRWcjs = require('./chunk-PQZHDKRW.cjs');
+
+
+
+
+
+var _chunkL47L3ZWJcjs = require('./chunk-L47L3ZWJ.cjs');
+
+// src/actor/mod.ts
+function actor(input) {
+  const config = _chunkPVOE6BU7cjs.ActorConfigSchema.parse(input);
+  return new (0, _chunkAUVH72REcjs.ActorDefinition)(config);
+}
+var event2 = _chunkPVOE6BU7cjs.event;
+var queue2 = _chunkPVOE6BU7cjs.queue;
+
+// src/drivers/engine/actor-driver.ts
+var _enginerunner = require('@rivetkit/engine-runner');
+var _cborx = require('cbor-x'); var cbor = _interopRequireWildcard(_cborx);
+var _streaming = require('hono/streaming');
+var _ws = require('hono/ws');
+var _invariant = require('invariant'); var _invariant2 = _interopRequireDefault(_invariant);
+
+// src/drivers/engine/log.ts
+function logger2() {
+  return _chunkPQZHDKRWcjs.getLogger.call(void 0, "driver-engine");
+}
+
+// src/drivers/engine/actor-driver.ts
+var RUNNER_SSE_PING_INTERVAL = 1e3;
+var RUNNER_STOP_WAIT_MS = 15e3;
+var CONN_MESSAGE_ACK_DEADLINE = 5e3;
+var CONN_BUFFERED_MESSAGE_SIZE_THRESHOLD = 5e5;
+var EngineActorDriver = class {
+  #config;
+  #managerDriver;
+  #inlineClient;
+  #runner;
+  #actors = /* @__PURE__ */ new Map();
+  #actorRouter;
+  #runnerStarted = _chunkPQZHDKRWcjs.promiseWithResolvers.call(void 0, (reason) => logger2().warn({ msg: "unhandled runner started promise rejection", reason }));
+  #runnerStopped = _chunkPQZHDKRWcjs.promiseWithResolvers.call(void 0, (reason) => logger2().warn({ msg: "unhandled runner stopped promise rejection", reason }));
+  #isRunnerStopped = false;
+  // HACK: Track actor stop intent locally since the runner protocol doesn't
+  // pass the stop reason to onActorStop. This will be fixed when the runner
+  // protocol is updated to send the intent directly (see RVT-5284)
+  #actorStopIntent = /* @__PURE__ */ new Map();
+  // Map of conn IDs to message index waiting to be persisted before sending
+  // an ack
+  //
+  // serverMessageIndex is updated and pendingAck is flagged in needed in
+  // onBeforePersistConnect, then the HWS ack message is sent in
+  // onAfterPersistConn. This allows us to track what's about to be written
+  // to storage to prevent race conditions with the serverMessageIndex being
+  // updated while writing the existing state.
+  //
+  // bufferedMessageSize tracks the total bytes received since last persist
+  // to force a saveState when threshold is reached. This is the amount of
+  // data currently buffered on the gateway.
+  #hwsMessageIndex = /* @__PURE__ */ new Map();
+  constructor(config, managerDriver, inlineClient) {
+    this.#config = config;
+    this.#managerDriver = managerDriver;
+    this.#inlineClient = inlineClient;
+    const token = config.token;
+    this.#actorRouter = _chunkAUVH72REcjs.createActorRouter.call(void 0, 
+      config,
+      this,
+      void 0,
+      config.test.enabled
+    );
+    const engineRunnerConfig = {
+      version: config.runner.version,
+      endpoint: _chunkSAZZ4SB2cjs.getEndpoint.call(void 0, config),
+      token,
+      namespace: config.namespace,
+      totalSlots: config.runner.totalSlots,
+      runnerName: config.runner.runnerName,
+      runnerKey: _nullishCoalesce(config.runner.runnerKey, () => ( crypto.randomUUID())),
+      metadata: {
+        rivetkit: { version: _chunkPQZHDKRWcjs.VERSION }
+      },
+      prepopulateActorNames: _chunk4JVIG3SScjs.buildActorNames.call(void 0, config),
+      onConnected: () => {
+        this.#runnerStarted.resolve(void 0);
+      },
+      onDisconnected: (_code, _reason) => {
+      },
+      onShutdown: () => {
+        this.#runnerStopped.resolve(void 0);
+        this.#isRunnerStopped = true;
+      },
+      fetch: this.#runnerFetch.bind(this),
+      websocket: this.#runnerWebSocket.bind(this),
+      hibernatableWebSocket: {
+        canHibernate: this.#hwsCanHibernate.bind(this)
+      },
+      onActorStart: this.#runnerOnActorStart.bind(this),
+      onActorStop: this.#runnerOnActorStop.bind(this),
+      logger: _chunkPQZHDKRWcjs.getLogger.call(void 0, "engine-runner")
+    };
+    this.#runner = new (0, _enginerunner.Runner)(engineRunnerConfig);
+    this.#runner.start();
+    logger2().debug({
+      msg: "engine runner started",
+      endpoint: config.endpoint,
+      namespace: config.namespace,
+      runnerName: config.runner.runnerName
+    });
+  }
+  getExtraActorLogParams() {
+    return { runnerId: _nullishCoalesce(this.#runner.runnerId, () => ( "-")) };
+  }
+  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.actorStartError) throw handler.actorStartError;
+    if (!handler.actor) throw new Error("Actor should be loaded");
+    return handler;
+  }
+  getContext(actorId) {
+    return {};
+  }
+  async setAlarm(actor2, timestamp) {
+    const handler = this.#actors.get(actor2.id);
+    if (!handler) {
+      logger2().warn({
+        msg: "no handler for actor to set alarm"
+      });
+      return;
+    }
+    if (handler.alarmTimeout) {
+      handler.alarmTimeout.abort();
+      handler.alarmTimeout = void 0;
+    }
+    const delay = Math.max(0, timestamp - Date.now());
+    handler.alarmTimeout = _chunkPQZHDKRWcjs.setLongTimeout.call(void 0, () => {
+      actor2.onAlarm();
+      handler.alarmTimeout = void 0;
+    }, delay);
+    this.#runner.setAlarm(actor2.id, timestamp);
+  }
+  // No database overrides - will use KV-backed implementation from rivetkit/db
+  // MARK: - Batch KV operations
+  async kvBatchPut(actorId, entries) {
+    await this.#runner.kvPut(actorId, entries);
+  }
+  async kvBatchGet(actorId, keys) {
+    return await this.#runner.kvGet(actorId, keys);
+  }
+  async kvBatchDelete(actorId, keys) {
+    await this.#runner.kvDelete(actorId, keys);
+  }
+  async kvList(actorId) {
+    const entries = await this.#runner.kvListPrefix(
+      actorId,
+      new Uint8Array()
+    );
+    const keys = entries.map(([key]) => key);
+    logger2().info({
+      msg: "kvList called",
+      actorId,
+      keysCount: keys.length,
+      keys: keys.map((k) => new TextDecoder().decode(k))
+    });
+    return keys;
+  }
+  async kvListPrefix(actorId, prefix) {
+    const result = await this.#runner.kvListPrefix(actorId, prefix);
+    logger2().info({
+      msg: "kvListPrefix called",
+      actorId,
+      prefixStr: new TextDecoder().decode(prefix),
+      entriesCount: result.length,
+      keys: result.map(([key]) => new TextDecoder().decode(key))
+    });
+    return result;
+  }
+  /** Creates a SQLite VFS instance for creating KV-backed databases */
+  async createSqliteVfs() {
+    const specifier = "@rivetkit/sqlite-vfs";
+    const { SqliteVfs } = await Promise.resolve().then(() => _interopRequireWildcard(require(specifier)));
+    return new SqliteVfs();
+  }
+  // MARK: - Actor Lifecycle
+  async loadActor(actorId) {
+    const handler = await this.#loadActorHandler(actorId);
+    if (!handler.actor) throw new Error(`Actor ${actorId} failed to load`);
+    return handler.actor;
+  }
+  startSleep(actorId) {
+    this.#actorStopIntent.set(actorId, "sleep");
+    this.#runner.sleepActor(actorId);
+  }
+  startDestroy(actorId) {
+    this.#actorStopIntent.set(actorId, "destroy");
+    this.#runner.stopActor(actorId);
+  }
+  async shutdownRunner(immediate) {
+    logger2().info({ msg: "stopping engine actor driver", immediate });
+    logger2().debug({
+      msg: "stopping all actors before shutdown",
+      actorCount: this.#actors.size
+    });
+    const stopPromises = [];
+    for (const [_actorId, handler] of this.#actors.entries()) {
+      if (handler.actor) {
+        stopPromises.push(
+          handler.actor.onStop("sleep").catch((err) => {
+            var _a;
+            (_a = handler.actor) == null ? void 0 : _a.rLog.error({
+              msg: "onStop errored",
+              error: _chunkPQZHDKRWcjs.stringifyError.call(void 0, err)
+            });
+          })
+        );
+      }
+    }
+    await Promise.all(stopPromises);
+    logger2().debug({ msg: "all actors stopped" });
+    try {
+      await this.#runner.shutdown(immediate);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("WebSocket connection closed during shutdown")) {
+        logger2().debug({
+          msg: "ignoring shutdown websocket close race",
+          error: message
+        });
+      } else {
+        throw error;
+      }
+    }
+    const stopped = await Promise.race([
+      this.#runnerStopped.promise.then(() => true),
+      new Promise(
+        (resolve) => setTimeout(() => resolve(false), RUNNER_STOP_WAIT_MS)
+      )
+    ]);
+    if (!stopped) {
+      logger2().warn({
+        msg: "timed out waiting for runner shutdown",
+        waitMs: RUNNER_STOP_WAIT_MS
+      });
+    }
+  }
+  async serverlessHandleStart(c) {
+    return _streaming.streamSSE.call(void 0, c, async (stream) => {
+      stream.onAbort(() => {
+      });
+      c.req.raw.signal.addEventListener("abort", () => {
+        logger2().debug("SSE aborted, shutting down runner");
+        this.shutdownRunner(false);
+      });
+      await this.#runnerStarted.promise;
+      const payload = this.#runner.getServerlessInitPacket();
+      _invariant2.default.call(void 0, payload, "runnerId not set");
+      await stream.writeSSE({ data: payload });
+      while (true) {
+        if (this.#isRunnerStopped) {
+          logger2().debug({
+            msg: "runner is stopped"
+          });
+          break;
+        }
+        if (stream.closed || stream.aborted) {
+          logger2().debug({
+            msg: "runner sse stream closed",
+            closed: stream.closed,
+            aborted: stream.aborted
+          });
+          break;
+        }
+        await stream.writeSSE({ event: "ping", data: "" });
+        await stream.sleep(RUNNER_SSE_PING_INTERVAL);
+      }
+      await this.#runnerStopped.promise;
+    });
+  }
+  async #runnerOnActorStart(actorId, generation, actorConfig) {
+    var _a;
+    logger2().debug({
+      msg: "runner actor starting",
+      actorId,
+      name: actorConfig.name,
+      key: actorConfig.key,
+      generation
+    });
+    let input;
+    if (actorConfig.input) {
+      input = cbor.decode(actorConfig.input);
+    }
+    let handler = this.#actors.get(actorId);
+    if (!handler) {
+      handler = {
+        actorStartPromise: _chunkPQZHDKRWcjs.promiseWithResolvers.call(void 0, (reason) => logger2().warn({ msg: "unhandled actor start promise rejection", reason }))
+      };
+      this.#actors.set(actorId, handler);
+    }
+    handler.actorStartError = void 0;
+    const name = actorConfig.name;
+    _invariant2.default.call(void 0, actorConfig.key, "actor should have a key");
+    const key = _chunk4JVIG3SScjs.deserializeActorKey.call(void 0, actorConfig.key);
+    try {
+      const [persistDataBuffer] = await this.#runner.kvGet(actorId, [
+        _chunkPVOE6BU7cjs.KEYS.PERSIST_DATA
+      ]);
+      if (persistDataBuffer === null) {
+        const initialKvState = _chunk4JVIG3SScjs.getInitialActorKvState.call(void 0, input);
+        await this.#runner.kvPut(actorId, initialKvState);
+        logger2().debug({
+          msg: "initialized persist data for new actor",
+          actorId
+        });
+      } else {
+        logger2().debug({
+          msg: "found existing persist data for actor",
+          actorId,
+          dataSize: persistDataBuffer.byteLength
+        });
+      }
+      const definition = _chunkAUVH72REcjs.lookupInRegistry.call(void 0, this.#config, actorConfig.name);
+      handler.actor = await definition.instantiate();
+      await handler.actor.start(
+        this,
+        this.#inlineClient,
+        actorId,
+        name,
+        key,
+        "unknown"
+        // TODO: Add regions
+      );
+      logger2().debug({ msg: "runner actor started", actorId, name, key });
+    } catch (innerError) {
+      const error = innerError instanceof Error ? new Error(
+        `Failed to start actor ${actorId}: ${innerError.message}`,
+        { cause: innerError }
+      ) : new Error(`Failed to start actor ${actorId}: ${String(innerError)}`);
+      handler.actor = void 0;
+      handler.actorStartError = error;
+      (_a = handler.actorStartPromise) == null ? void 0 : _a.reject(error);
+      handler.actorStartPromise = void 0;
+      logger2().error({
+        msg: "runner actor failed to start",
+        actorId,
+        name,
+        key,
+        err: _chunkPQZHDKRWcjs.stringifyError.call(void 0, error)
+      });
+      try {
+        this.#runner.stopActor(actorId);
+      } catch (stopError) {
+        logger2().debug({
+          msg: "failed to stop actor after start failure",
+          actorId,
+          err: _chunkPQZHDKRWcjs.stringifyError.call(void 0, stopError)
+        });
+      }
+    }
+  }
+  async #runnerOnActorStop(actorId, generation) {
+    logger2().debug({ msg: "runner actor stopping", actorId, generation });
+    const reason = _nullishCoalesce(this.#actorStopIntent.get(actorId), () => ( "sleep"));
+    this.#actorStopIntent.delete(actorId);
+    const handler = this.#actors.get(actorId);
+    if (handler == null ? void 0 : handler.actorStartPromise) {
+      const startError = _nullishCoalesce(handler.actorStartError, () => ( new Error(`Actor ${actorId} stopped before start completed`)));
+      handler.actorStartError = startError;
+      handler.actorStartPromise.reject(startError);
+      handler.actorStartPromise = void 0;
+    }
+    if (handler == null ? void 0 : handler.actor) {
+      try {
+        await handler.actor.onStop(reason);
+      } catch (err) {
+        logger2().error({
+          msg: "error in onStop, proceeding with removing actor",
+          err: _chunkPQZHDKRWcjs.stringifyError.call(void 0, err)
+        });
+      }
+    }
+    if (handler) this.#actors.delete(actorId);
+    logger2().debug({ msg: "runner actor stopped", actorId, reason });
+  }
+  // MARK: - Runner Networking
+  async #runnerFetch(_runner, actorId, _gatewayIdBuf, _requestIdBuf, request) {
+    logger2().debug({
+      msg: "runner fetch",
+      actorId,
+      url: request.url,
+      method: request.method
+    });
+    return await this.#actorRouter.fetch(request, { actorId });
+  }
+  async #runnerWebSocket(_runner, actorId, websocketRaw, gatewayIdBuf, requestIdBuf, request, requestPath, requestHeaders, isHibernatable, isRestoringHibernatable) {
+    var _a, _b, _c, _d;
+    const websocket = websocketRaw;
+    const wsUniqueId = `ws_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    websocket.__rivet_ws_id = wsUniqueId;
+    logger2().debug({
+      msg: "runner websocket",
+      actorId,
+      url: request.url,
+      isRestoringHibernatable,
+      websocketObjectId: websocketRaw ? Object.prototype.toString.call(websocketRaw) : "null",
+      websocketType: (_a = websocketRaw == null ? void 0 : websocketRaw.constructor) == null ? void 0 : _a.name,
+      wsUniqueId,
+      websocketProps: websocketRaw ? Object.keys(websocketRaw).join(", ") : "null"
+    });
+    const protocols = request.headers.get("sec-websocket-protocol");
+    const { encoding, connParams } = _chunk4JVIG3SScjs.parseWebSocketProtocols.call(void 0, protocols);
+    let wsHandler;
+    try {
+      wsHandler = await _chunk4JVIG3SScjs.routeWebSocket.call(void 0, 
+        request,
+        requestPath,
+        requestHeaders,
+        this.#config,
+        this,
+        actorId,
+        encoding,
+        connParams,
+        gatewayIdBuf,
+        requestIdBuf,
+        isHibernatable,
+        isRestoringHibernatable
+      );
+    } catch (err) {
+      logger2().error({ msg: "building websocket handlers errored", err });
+      websocketRaw.close(1011, "ws.route_error");
+      return;
+    }
+    websocket.raw = websocket;
+    const wsContext = new (0, _ws.WSContext)(websocket);
+    const conn = wsHandler.conn;
+    const actor2 = wsHandler.actor;
+    const connStateManager = conn == null ? void 0 : conn[_chunk4JVIG3SScjs.CONN_STATE_MANAGER_SYMBOL];
+    logger2().debug({
+      msg: "attaching websocket event listeners",
+      actorId,
+      connId: conn == null ? void 0 : conn.id,
+      wsUniqueId: websocket.__rivet_ws_id,
+      isRestoringHibernatable,
+      websocketType: (_b = websocket == null ? void 0 : websocket.constructor) == null ? void 0 : _b.name
+    });
+    if (isRestoringHibernatable) {
+      (_c = wsHandler.onRestore) == null ? void 0 : _c.call(wsHandler, wsContext);
+    }
+    websocket.addEventListener("open", (event3) => {
+      wsHandler.onOpen(event3, wsContext);
+    });
+    websocket.addEventListener("message", (event3) => {
+      var _a2, _b2;
+      logger2().debug({
+        msg: "websocket message event listener triggered",
+        connId: conn == null ? void 0 : conn.id,
+        actorId: actor2 == null ? void 0 : actor2.id,
+        messageIndex: event3.rivetMessageIndex,
+        hasWsHandler: !!wsHandler,
+        hasOnMessage: !!(wsHandler == null ? void 0 : wsHandler.onMessage),
+        actorIsStopping: actor2 == null ? void 0 : actor2.isStopping,
+        websocketType: (_a2 = websocket == null ? void 0 : websocket.constructor) == null ? void 0 : _a2.name,
+        wsUniqueId: websocket.__rivet_ws_id,
+        eventTargetWsId: (_b2 = event3.target) == null ? void 0 : _b2.__rivet_ws_id
+      });
+      if (actor2 == null ? void 0 : actor2.isStopping) {
+        logger2().debug({
+          msg: "ignoring ws message, actor is stopping",
+          connId: conn == null ? void 0 : conn.id,
+          actorId: actor2 == null ? void 0 : actor2.id,
+          messageIndex: event3.rivetMessageIndex
+        });
+        return;
+      }
+      logger2().debug({
+        msg: "calling wsHandler.onMessage",
+        connId: conn == null ? void 0 : conn.id,
+        messageIndex: event3.rivetMessageIndex
+      });
+      wsHandler.onMessage(event3, wsContext);
+      const hibernate = connStateManager == null ? void 0 : connStateManager.hibernatableData;
+      if (hibernate && conn && actor2) {
+        _invariant2.default.call(void 0, 
+          typeof event3.rivetMessageIndex === "number",
+          "missing event.rivetMessageIndex"
+        );
+        const previousMsgIndex = hibernate.serverMessageIndex;
+        hibernate.serverMessageIndex = event3.rivetMessageIndex;
+        logger2().info({
+          msg: "persisting message index",
+          connId: conn.id,
+          previousMsgIndex,
+          newMsgIndex: event3.rivetMessageIndex
+        });
+        const entry = this.#hwsMessageIndex.get(conn.id);
+        if (entry) {
+          const messageLength = _chunk4JVIG3SScjs.getValueLength.call(void 0, event3.data);
+          entry.bufferedMessageSize += messageLength;
+          if (entry.bufferedMessageSize >= CONN_BUFFERED_MESSAGE_SIZE_THRESHOLD) {
+            entry.bufferedMessageSize = 0;
+            entry.pendingAckFromBufferSize = true;
+            actor2.stateManager.saveState({
+              immediate: true
+            });
+          } else {
+            actor2.stateManager.saveState({
+              maxWait: CONN_MESSAGE_ACK_DEADLINE
+            });
+          }
+        } else {
+          actor2.stateManager.saveState({
+            maxWait: CONN_MESSAGE_ACK_DEADLINE
+          });
+        }
+      }
+    });
+    websocket.addEventListener("close", (event3) => {
+      wsHandler.onClose(event3, wsContext);
+    });
+    websocket.addEventListener("error", (event3) => {
+      wsHandler.onError(event3, wsContext);
+    });
+    if (isRestoringHibernatable) {
+      logger2().info({
+        msg: "event listeners attached to restored websocket",
+        actorId,
+        connId: conn == null ? void 0 : conn.id,
+        gatewayId: _enginerunner.idToStr.call(void 0, gatewayIdBuf),
+        requestId: _enginerunner.idToStr.call(void 0, requestIdBuf),
+        websocketType: (_d = websocket == null ? void 0 : websocket.constructor) == null ? void 0 : _d.name,
+        hasMessageListener: !!websocket.addEventListener
+      });
+    }
+  }
+  // MARK: - Hibernating WebSockets
+  #hwsCanHibernate(actorId, gatewayId, requestId, request) {
+    var _a;
+    const url = new URL(request.url);
+    const path = url.pathname;
+    const actorInstance = this.#runner.getActor(actorId);
+    if (!actorInstance) {
+      logger2().warn({
+        msg: "actor not found in #hwsCanHibernate",
+        actorId
+      });
+      return false;
+    }
+    const handler = this.#actors.get(actorId);
+    if (!handler) {
+      logger2().warn({
+        msg: "actor handler not found in #hwsCanHibernate",
+        actorId
+      });
+      return false;
+    }
+    if (!handler.actor) {
+      logger2().warn({
+        msg: "actor not found in #hwsCanHibernate",
+        actorId
+      });
+      return false;
+    }
+    logger2().debug({
+      msg: "no existing hibernatable websocket found",
+      gatewayId: _enginerunner.idToStr.call(void 0, gatewayId),
+      requestId: _enginerunner.idToStr.call(void 0, requestId)
+    });
+    if (path === _chunk4JVIG3SScjs.PATH_CONNECT) {
+      return true;
+    } else if (path === _chunk4JVIG3SScjs.PATH_WEBSOCKET_BASE || path.startsWith(_chunk4JVIG3SScjs.PATH_WEBSOCKET_PREFIX)) {
+      const definition = _chunkAUVH72REcjs.lookupInRegistry.call(void 0, 
+        this.#config,
+        actorInstance.config.name
+      );
+      const canHibernateWebSocket = (_a = definition.config.options) == null ? void 0 : _a.canHibernateWebSocket;
+      if (canHibernateWebSocket === true) {
+        return true;
+      } else if (typeof canHibernateWebSocket === "function") {
+        try {
+          const newPath = _chunk4JVIG3SScjs.truncateRawWebSocketPathPrefix.call(void 0, 
+            url.pathname
+          );
+          const truncatedRequest = new Request(
+            `http://actor${newPath}`,
+            request
+          );
+          const canHibernate = canHibernateWebSocket(truncatedRequest);
+          return canHibernate;
+        } catch (error) {
+          logger2().error({
+            msg: "error calling canHibernateWebSocket",
+            error
+          });
+          return false;
+        }
+      } else {
+        return false;
+      }
+    } else if (path === _chunk4JVIG3SScjs.PATH_INSPECTOR_CONNECT) {
+      return false;
+    } else {
+      logger2().warn({
+        msg: "unexpected path for getActorHibernationConfig",
+        path
+      });
+      return false;
+    }
+  }
+  async #hwsLoadAll(actorId) {
+    const actor2 = await this.loadActor(actorId);
+    return actor2.conns.values().map((conn) => {
+      const connStateManager = conn[_chunk4JVIG3SScjs.CONN_STATE_MANAGER_SYMBOL];
+      const hibernatable = connStateManager.hibernatableData;
+      if (!hibernatable) return void 0;
+      return {
+        gatewayId: hibernatable.gatewayId,
+        requestId: hibernatable.requestId,
+        serverMessageIndex: hibernatable.serverMessageIndex,
+        clientMessageIndex: hibernatable.clientMessageIndex,
+        path: hibernatable.requestPath,
+        headers: hibernatable.requestHeaders
+      };
+    }).filter((x) => x !== void 0).toArray();
+  }
+  async onBeforeActorStart(actor2) {
+    var _a;
+    const handler = this.#actors.get(actor2.id);
+    _invariant2.default.call(void 0, handler, "missing actor handler in onBeforeActorReady");
+    handler.actorStartError = void 0;
+    (_a = handler.actorStartPromise) == null ? void 0 : _a.resolve();
+    handler.actorStartPromise = void 0;
+    const metaEntries = await this.#hwsLoadAll(actor2.id);
+    await this.#runner.restoreHibernatingRequests(actor2.id, metaEntries);
+  }
+  onCreateConn(conn) {
+    const hibernatable = conn[_chunk4JVIG3SScjs.CONN_STATE_MANAGER_SYMBOL].hibernatableData;
+    if (!hibernatable) return;
+    this.#hwsMessageIndex.set(conn.id, {
+      serverMessageIndex: hibernatable.serverMessageIndex,
+      bufferedMessageSize: 0,
+      pendingAckFromMessageIndex: false,
+      pendingAckFromBufferSize: false
+    });
+    logger2().debug({
+      msg: "created #hwsMessageIndex entry",
+      connId: conn.id,
+      serverMessageIndex: hibernatable.serverMessageIndex
+    });
+  }
+  onDestroyConn(conn) {
+    this.#hwsMessageIndex.delete(conn.id);
+    logger2().debug({
+      msg: "removed #hwsMessageIndex entry",
+      connId: conn.id
+    });
+  }
+  onBeforePersistConn(conn) {
+    const stateManager = conn[_chunk4JVIG3SScjs.CONN_STATE_MANAGER_SYMBOL];
+    const hibernatable = stateManager.hibernatableDataOrError();
+    const entry = this.#hwsMessageIndex.get(conn.id);
+    if (!entry) {
+      logger2().warn({
+        msg: "missing EngineActorDriver.#hwsMessageIndex entry for conn",
+        connId: conn.id
+      });
+      return;
+    }
+    entry.pendingAckFromMessageIndex = hibernatable.serverMessageIndex > entry.serverMessageIndex;
+    entry.serverMessageIndex = hibernatable.serverMessageIndex;
+  }
+  onAfterPersistConn(conn) {
+    const stateManager = conn[_chunk4JVIG3SScjs.CONN_STATE_MANAGER_SYMBOL];
+    const hibernatable = stateManager.hibernatableDataOrError();
+    const entry = this.#hwsMessageIndex.get(conn.id);
+    if (!entry) {
+      logger2().warn({
+        msg: "missing EngineActorDriver.#hwsMessageIndex entry for conn",
+        connId: conn.id
+      });
+      return;
+    }
+    if (entry.pendingAckFromMessageIndex || entry.pendingAckFromBufferSize) {
+      this.#runner.sendHibernatableWebSocketMessageAck(
+        hibernatable.gatewayId,
+        hibernatable.requestId,
+        entry.serverMessageIndex
+      );
+      entry.pendingAckFromMessageIndex = false;
+      entry.pendingAckFromBufferSize = false;
+      entry.bufferedMessageSize = 0;
+    }
+  }
+};
+
+// src/drivers/engine/config.ts
+var _v4 = require('zod/v4');
+var EngineConfigSchemaBase = _chunkSAZZ4SB2cjs.ClientConfigSchemaBase.extend({
+  /** Unique key for this runner. Runners connecting a given key will replace any other runner connected with the same key. */
+  runnerKey: _v4.z.string().optional().transform((val) => _nullishCoalesce(val, () => ( _chunkPQZHDKRWcjs.getRivetRunnerKey.call(void 0, )))),
+  /** How many actors this runner can run. */
+  totalSlots: _v4.z.number().default(1e5)
+});
+var EngineConfigSchemaTransformed = EngineConfigSchemaBase.transform(
+  (config, ctx) => transformEngineConfig(config, ctx)
+);
+var EngineConfigSchema = EngineConfigSchemaTransformed.default(
+  () => EngineConfigSchemaTransformed.parse({})
+);
+function transformEngineConfig(config, ctx) {
+  return {
+    ..._chunkSAZZ4SB2cjs.transformClientConfig.call(void 0, config, ctx),
+    runnerKey: config.runnerKey
+  };
+}
+
+// src/drivers/engine/mod.ts
+function createEngineDriver() {
+  return {
+    name: "engine",
+    displayName: "Engine",
+    manager: (config) => {
+      const clientConfig = _chunkSAZZ4SB2cjs.convertRegistryConfigToClientConfig.call(void 0, config);
+      return new (0, _chunkSAZZ4SB2cjs.RemoteManagerDriver)(clientConfig);
+    },
+    actor: (config, managerDriver, inlineClient) => {
+      return new EngineActorDriver(
+        config,
+        managerDriver,
+        inlineClient
+      );
+    },
+    autoStartActorDriver: true
+  };
+}
+
+// src/registry/config/legacy-runner.ts
+
+var LegacyDriverConfigSchema = _v4.z.object({
+  /** Machine-readable name to identify this driver by. */
+  name: _v4.z.string(),
+  manager: _v4.z.custom(),
+  actor: _v4.z.custom()
+});
+var LegacyRunnerConfigSchemaUnmerged = _v4.z.object({
+  driver: LegacyDriverConfigSchema.optional(),
+  /** @experimental */
+  maxIncomingMessageSize: _v4.z.number().optional().default(65536),
+  /** @experimental */
+  maxOutgoingMessageSize: _v4.z.number().optional().default(1048576),
+  /** @experimental */
+  inspector: _chunk4JVIG3SScjs.InspectorConfigSchema,
+  /** @experimental */
+  disableDefaultServer: _v4.z.boolean().optional().default(false),
+  /** @experimental */
+  defaultServerPort: _v4.z.number().default(6420),
+  /** @experimental */
+  runEngine: _v4.z.boolean().optional().default(() => _chunkPQZHDKRWcjs.getRivetRunEngine.call(void 0, )),
+  /** @experimental */
+  runEngineVersion: _v4.z.string().optional().default(() => _nullishCoalesce(_chunkPQZHDKRWcjs.getRivetRunEngineVersion.call(void 0, ), () => ( _chunkPQZHDKRWcjs.VERSION))),
+  /** @experimental */
+  overrideServerAddress: _v4.z.string().optional(),
+  /** @experimental */
+  disableActorDriver: _v4.z.boolean().optional().default(false),
+  /**
+   * @experimental
+   *
+   * Whether to run runners normally or have them managed
+   * serverlessly (by the Rivet Engine for example).
+   */
+  runnerKind: _v4.z.enum(["serverless", "normal"]).optional().default(
+    () => _chunkPQZHDKRWcjs.getRivetRunnerKind.call(void 0, ) === "serverless" ? "serverless" : "normal"
+  ),
+  totalSlots: _v4.z.number().optional(),
+  /**
+   * @experimental
+   *
+   * Base path for the router. This is used to prefix all routes.
+   * For example, if the base path is `/api`, then the route `/actors` will be
+   * available at `/api/actors`.
+   */
+  basePath: _v4.z.string().optional().default("/"),
+  /**
+   * @experimental
+   *
+   * Disable welcome message.
+   * */
+  noWelcome: _v4.z.boolean().optional().default(false),
+  /**
+   * @experimental
+   * */
+  logging: _v4.z.object({
+    baseLogger: _v4.z.custom().optional(),
+    level: _chunkPQZHDKRWcjs.LogLevelSchema.optional()
+  }).optional().default(() => ({})),
+  /**
+   * @experimental
+   *
+   * Automatically configure serverless runners in the engine.
+   * Can only be used when runnerKind is "serverless".
+   * If true, uses default configuration. Can also provide custom configuration.
+   */
+  autoConfigureServerless: _v4.z.union([
+    _v4.z.boolean(),
+    _v4.z.object({
+      url: _v4.z.string().optional(),
+      headers: _v4.z.record(_v4.z.string(), _v4.z.string()).optional(),
+      maxRunners: _v4.z.number().optional(),
+      minRunners: _v4.z.number().optional(),
+      requestLifespan: _v4.z.number().optional(),
+      runnersMargin: _v4.z.number().optional(),
+      slotsPerRunner: _v4.z.number().optional(),
+      metadata: _v4.z.record(_v4.z.string(), _v4.z.unknown()).optional()
+    })
+  ]).optional(),
+  // This is a function to allow for lazy configuration of upgradeWebSocket on the
+  // fly. This is required since the dependencies that upgradeWebSocket
+  // (specifically Node.js) can sometimes only be specified after the router is
+  // created or must be imported async using `await import(...)`
+  getUpgradeWebSocket: _v4.z.custom().optional(),
+  /** @experimental */
+  token: _v4.z.string().optional().transform((v) => v || _chunkPQZHDKRWcjs.getRivetToken.call(void 0, ))
+}).merge(EngineConfigSchemaBase);
+var LegacyRunnerConfigSchemaTransformed = LegacyRunnerConfigSchemaUnmerged.transform((config, ctx) => ({
+  ...config,
+  ...transformEngineConfig(config, ctx)
+}));
+var LegacyRunnerConfigSchema = LegacyRunnerConfigSchemaTransformed.default(
+  () => LegacyRunnerConfigSchemaTransformed.parse({})
+);
+
+// runtime/index.ts
+
+
+// src/drivers/default.ts
+function chooseDefaultDriver(config) {
+  if (config.endpoint && config.driver) {
+    throw new (0, _chunkL47L3ZWJcjs.UserError)(
+      "Cannot specify both 'endpoint' and 'driver' in configuration"
+    );
+  }
+  if (config.driver) {
+    return config.driver;
+  }
+  if (config.endpoint || config.token) {
+    _chunkPVOE6BU7cjs.loggerWithoutContext.call(void 0, ).debug({
+      msg: "using rivet engine driver",
+      endpoint: config.endpoint
+    });
+    return createEngineDriver();
+  }
+  _chunkPVOE6BU7cjs.loggerWithoutContext.call(void 0, ).debug({
+    msg: "using default file system driver",
+    storagePath: config.storagePath
+  });
+  return _chunkAUVH72REcjs.createFileSystemOrMemoryDriver.call(void 0, true, {
+    path: config.storagePath
+  });
+}
+
+// src/engine-process/log.ts
+function logger3() {
+  return _chunkPQZHDKRWcjs.getLogger.call(void 0, "engine-process");
+}
+
+// src/engine-process/mod.ts
+var ENGINE_BASE_URL = "https://releases.rivet.dev/rivet";
+var ENGINE_BINARY_NAME = "rivet-engine";
+async function ensureEngineProcess(options) {
+  _chunk4JVIG3SScjs.importNodeDependencies.call(void 0, );
+  logger3().debug({
+    msg: "ensuring engine process",
+    version: options.version
+  });
+  const path = _chunk4JVIG3SScjs.getNodePath.call(void 0, );
+  const storageRoot = _chunkAUVH72REcjs.getStoragePath.call(void 0, );
+  const binDir = path.join(storageRoot, "bin");
+  const varDir = path.join(storageRoot, "var");
+  const logsDir = path.join(varDir, "logs", "rivet-engine");
+  await _chunkAUVH72REcjs.ensureDirectoryExists.call(void 0, binDir);
+  await _chunkAUVH72REcjs.ensureDirectoryExists.call(void 0, varDir);
+  await _chunkAUVH72REcjs.ensureDirectoryExists.call(void 0, logsDir);
+  if (await isEngineRunning()) {
+    try {
+      const health = await waitForEngineHealth();
+      logger3().debug({
+        msg: "engine already running and healthy",
+        version: health.version
+      });
+      return;
+    } catch (error) {
+      logger3().warn({
+        msg: "existing engine process not healthy, cannot restart automatically",
+        error
+      });
+      throw new Error(
+        "Engine process exists but is not healthy. Please manually stop the process on port 6420 and retry."
+      );
+    }
+  }
+  const executableName = process.platform === "win32" ? `${ENGINE_BINARY_NAME}-${options.version}.exe` : `${ENGINE_BINARY_NAME}-${options.version}`;
+  const binaryPath = path.join(binDir, executableName);
+  await downloadEngineBinaryIfNeeded(binaryPath, options.version, varDir);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").replace(/\./g, "-");
+  const stdoutLogPath = path.join(logsDir, `engine-${timestamp}-stdout.log`);
+  const stderrLogPath = path.join(logsDir, `engine-${timestamp}-stderr.log`);
+  const fsSync = _chunk4JVIG3SScjs.getNodeFsSync.call(void 0, );
+  const stdoutStream = fsSync.createWriteStream(stdoutLogPath, {
+    flags: "a"
+  });
+  const stderrStream = fsSync.createWriteStream(stderrLogPath, {
+    flags: "a"
+  });
+  logger3().debug({
+    msg: "creating engine log files",
+    stdout: stdoutLogPath,
+    stderr: stderrLogPath
+  });
+  const childProcess = _chunk4JVIG3SScjs.getNodeChildProcess.call(void 0, );
+  const child = childProcess.spawn(binaryPath, ["start"], {
+    cwd: path.dirname(binaryPath),
+    stdio: ["inherit", "pipe", "pipe"],
+    env: {
+      ...process.env,
+      // Development environment overrides for Rivet Engine.
+      //
+      // NOTE: When modifying these env vars, also update scripts/run/dev-env.sh
+      // to keep them in sync for manual engine runs.
+      //
+      // In development, runners can be terminated without a graceful
+      // shutdown (i.e. SIGKILL instead of SIGTERM). This is treated as a
+      // crash by Rivet Engine in production and implements a backoff for
+      // rescheduling actors in case of a crash loop.
+      //
+      // This is problematic in development since this will cause actors
+      // to become unresponsive if frequently killing your dev server.
+      //
+      // We reduce the timeouts for resetting a runner as healthy in
+      // order to account for this.
+      RIVET__PEGBOARD__RETRY_RESET_DURATION: "100",
+      RIVET__PEGBOARD__BASE_RETRY_TIMEOUT: "100",
+      // Set max exponent to 1 to have a maximum of base_retry_timeout
+      RIVET__PEGBOARD__RESCHEDULE_BACKOFF_MAX_EXPONENT: "1",
+      // Reduce thresholds for faster development iteration
+      //
+      // Default ping interval is 3s, this gives a 2s & 4s grace
+      RIVET__PEGBOARD__RUNNER_ELIGIBLE_THRESHOLD: "5000",
+      RIVET__PEGBOARD__RUNNER_LOST_THRESHOLD: "7000",
+      // Allow faster metadata polling for hot-reload in development (in milliseconds)
+      RIVET__PEGBOARD__MIN_METADATA_POLL_INTERVAL: "1000",
+      // Reduce shutdown durations for faster development iteration (in seconds)
+      RIVET__RUNTIME__WORKER__SHUTDOWN_DURATION: "1",
+      RIVET__RUNTIME__GUARD_SHUTDOWN_DURATION: "1",
+      // Force exit after this duration (must be > worker and guard shutdown durations)
+      RIVET__RUNTIME__FORCE_SHUTDOWN_DURATION: "2"
+    }
+  });
+  if (!child.pid) {
+    throw new Error("failed to spawn rivet engine process");
+  }
+  if (child.stdout) {
+    child.stdout.pipe(stdoutStream);
+  }
+  const stderrChunks = [];
+  if (child.stderr) {
+    child.stderr.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    child.stderr.pipe(stderrStream);
+  }
+  logger3().debug({
+    msg: "spawned engine process",
+    pid: child.pid,
+    cwd: path.dirname(binaryPath)
+  });
+  child.once("exit", (code, signal) => {
+    const stderrOutput = Buffer.concat(stderrChunks).toString("utf-8");
+    if (stderrOutput.includes("LOCK: Resource temporarily unavailable")) {
+      logger3().error({
+        msg: "another instance of rivet engine is unexpectedly running, this is an internal error",
+        code,
+        signal,
+        stdoutLog: stdoutLogPath,
+        stderrLog: stderrLogPath,
+        issues: "https://github.com/rivet-dev/rivetkit/issues",
+        support: "https://rivet.dev/discord"
+      });
+    } else if (stderrOutput.includes("Rivet Engine has been rolled back to a previous version")) {
+      logger3().error({
+        msg: "rivet engine version downgrade detected",
+        hint: `You attempted to downgrade the RivetKit version in development. To fix this, nuke the database by running: '${binaryPath}' database nuke --yes`,
+        code,
+        signal,
+        stdoutLog: stdoutLogPath,
+        stderrLog: stderrLogPath
+      });
+    } else {
+      logger3().warn({
+        msg: "engine process exited, please report this error",
+        code,
+        signal,
+        stdoutLog: stdoutLogPath,
+        stderrLog: stderrLogPath,
+        issues: "https://github.com/rivet-dev/rivetkit/issues",
+        support: "https://rivet.dev/discord"
+      });
+    }
+    stdoutStream.end();
+    stderrStream.end();
+  });
+  child.once("error", (error) => {
+    logger3().error({
+      msg: "engine process failed",
+      error
+    });
+    stdoutStream.end();
+    stderrStream.end();
+  });
+  await waitForEngineHealth();
+  logger3().info({
+    msg: "engine process started",
+    pid: child.pid,
+    version: options.version,
+    logs: {
+      stdout: stdoutLogPath,
+      stderr: stderrLogPath
+    }
+  });
+}
+async function downloadEngineBinaryIfNeeded(binaryPath, version, varDir) {
+  const binaryExists = await fileExists(binaryPath);
+  if (binaryExists) {
+    logger3().debug({
+      msg: "engine binary already cached",
+      version,
+      path: binaryPath
+    });
+    return;
+  }
+  const { targetTriplet, extension } = resolveTargetTriplet();
+  const remoteFile = `${ENGINE_BINARY_NAME}-${targetTriplet}${extension}`;
+  const downloadUrl = `${ENGINE_BASE_URL}/${version}/engine/${remoteFile}`;
+  logger3().info({
+    msg: "downloading engine binary",
+    url: downloadUrl,
+    path: binaryPath,
+    version
+  });
+  const response = await fetch(downloadUrl);
+  if (!response.ok || !response.body) {
+    throw new Error(
+      `failed to download rivet engine binary from ${downloadUrl}: ${response.status} ${response.statusText}`
+    );
+  }
+  const crypto2 = _chunk4JVIG3SScjs.getNodeCrypto.call(void 0, );
+  const tempPath = `${binaryPath}.${crypto2.randomUUID()}.tmp`;
+  const startTime = Date.now();
+  logger3().debug({
+    msg: "starting binary download",
+    tempPath,
+    contentLength: response.headers.get("content-length")
+  });
+  const slowDownloadWarning = setTimeout(() => {
+    logger3().warn({
+      msg: "engine binary download is taking longer than expected, please be patient",
+      version
+    });
+  }, 5e3);
+  try {
+    const stream = _chunk4JVIG3SScjs.getNodeStream.call(void 0, );
+    const fsSync = _chunk4JVIG3SScjs.getNodeFsSync.call(void 0, );
+    await stream.pipeline(
+      response.body,
+      fsSync.createWriteStream(tempPath)
+    );
+    clearTimeout(slowDownloadWarning);
+    const fs = _chunk4JVIG3SScjs.getNodeFs.call(void 0, );
+    const stats = await fs.stat(tempPath);
+    const downloadDuration = Date.now() - startTime;
+    if (process.platform !== "win32") {
+      await fs.chmod(tempPath, 493);
+    }
+    await fs.rename(tempPath, binaryPath);
+    logger3().debug({
+      msg: "engine binary download complete",
+      version,
+      path: binaryPath,
+      size: stats.size,
+      durationMs: downloadDuration
+    });
+    logger3().info({
+      msg: "engine binary downloaded",
+      version,
+      path: binaryPath
+    });
+  } catch (error) {
+    clearTimeout(slowDownloadWarning);
+    logger3().warn({
+      msg: "engine download failed, please report this error",
+      tempPath,
+      error,
+      issues: "https://github.com/rivet-dev/rivetkit/issues",
+      support: "https://rivet.dev/discord"
+    });
+    try {
+      const fs = _chunk4JVIG3SScjs.getNodeFs.call(void 0, );
+      await fs.unlink(tempPath);
+    } catch (unlinkError) {
+    }
+    throw error;
+  }
+}
+function resolveTargetTriplet() {
+  return resolveTargetTripletFor(process.platform, process.arch);
+}
+function resolveTargetTripletFor(platform, arch) {
+  switch (platform) {
+    case "darwin":
+      if (arch === "arm64") {
+        return { targetTriplet: "aarch64-apple-darwin", extension: "" };
+      }
+      if (arch === "x64") {
+        return { targetTriplet: "x86_64-apple-darwin", extension: "" };
+      }
+      break;
+    case "linux":
+      if (arch === "x64") {
+        return {
+          targetTriplet: "x86_64-unknown-linux-musl",
+          extension: ""
+        };
+      }
+      break;
+    case "win32":
+      if (arch === "x64") {
+        return {
+          targetTriplet: "x86_64-pc-windows-gnu",
+          extension: ".exe"
+        };
+      }
+      break;
+  }
+  throw new Error(
+    `unsupported platform for rivet engine binary: ${platform}/${arch}`
+  );
+}
+async function isEngineRunning() {
+  return await checkIfEngineAlreadyRunningOnPort(_chunk4JVIG3SScjs.ENGINE_PORT);
+}
+async function checkIfEngineAlreadyRunningOnPort(port) {
+  let response;
+  try {
+    response = await fetch(`http://127.0.0.1:${port}/health`);
+  } catch (err) {
+    return false;
+  }
+  if (response.ok) {
+    const health = await response.json();
+    if (health.runtime === "engine") {
+      logger3().debug({
+        msg: "rivet engine already running on port",
+        port
+      });
+      return true;
+    } else if (health.runtime === "rivetkit") {
+      logger3().error({
+        msg: "another rivetkit process is already running on port",
+        port
+      });
+      throw new Error(
+        "RivetKit process already running on port 6420, stop that process and restart this."
+      );
+    } else {
+      throw new Error(
+        "Unknown process running on port 6420, cannot identify what it is."
+      );
+    }
+  }
+  return false;
+}
+async function fileExists(filePath) {
+  try {
+    const fs = _chunk4JVIG3SScjs.getNodeFs.call(void 0, );
+    await fs.access(filePath);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+var HEALTH_MAX_WAIT = 1e4;
+var HEALTH_INTERVAL = 100;
+async function waitForEngineHealth() {
+  const maxRetries = Math.ceil(HEALTH_MAX_WAIT / HEALTH_INTERVAL);
+  logger3().debug({ msg: "waiting for engine health check" });
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const response = await fetch(`${_chunk4JVIG3SScjs.ENGINE_ENDPOINT}/health`, {
+        signal: AbortSignal.timeout(1e3)
+      });
+      if (response.ok) {
+        const health = await response.json();
+        logger3().debug({ msg: "engine health check passed" });
+        return health;
+      }
+    } catch (error) {
+      logger3().debug({ msg: "engine health check failed", error });
+      if (i === maxRetries - 1) {
+        throw new Error(
+          `engine health check failed after ${maxRetries} retries: ${error}`
+        );
+      }
+    }
+    if (i < maxRetries - 1) {
+      logger3().trace({
+        msg: "engine not ready, retrying",
+        attempt: i + 1,
+        maxRetries
+      });
+      await new Promise(
+        (resolve) => setTimeout(resolve, HEALTH_INTERVAL)
+      );
+    }
+  }
+  throw new Error(`engine health check failed after ${maxRetries} retries`);
+}
+
+// src/inspector/utils.ts
+var _factory = require('hono/factory');
+function getInspectorUrl(config, managerPort) {
+  if (!config.inspector.enabled) return void 0;
+  const base = _nullishCoalesce(config.inspector.defaultEndpoint, () => ( `http://127.0.0.1:${managerPort}`));
+  return new URL("/ui/", base).href;
+}
+
+// src/serverless/log.ts
+function logger4() {
+  return _chunkPQZHDKRWcjs.getLogger.call(void 0, "serverless");
+}
+
+// src/serverless/configure.ts
+
+async function configureServerlessRunner(config) {
+  logger4().debug("configuring serverless runner");
+  try {
+    if (!config.namespace) {
+      throw new Error(
+        "namespace is required for serverless configuration"
+      );
+    }
+    if (!config.endpoint) {
+      throw new Error(
+        "endpoint is required for serverless configuration"
+      );
+    }
+    const customConfig = config.serverless.configureRunnerPool;
+    _invariant2.default.call(void 0, customConfig, "configureRunnerPool should exist");
+    const clientConfig = _chunkSAZZ4SB2cjs.convertRegistryConfigToClientConfig.call(void 0, config);
+    logger4().debug({
+      msg: "fetching datacenters",
+      endpoint: config.endpoint
+    });
+    const dcsRes = await _chunkSAZZ4SB2cjs.getDatacenters.call(void 0, clientConfig);
+    const runnerName = _nullishCoalesce(customConfig.name, () => ( "default"));
+    logger4().debug({
+      msg: "configuring serverless runner",
+      runnerName,
+      namespace: config.namespace
+    });
+    const serverlessConfig = {
+      serverless: {
+        url: customConfig.url,
+        headers: _nullishCoalesce(customConfig.headers, () => ( {})),
+        max_runners: _nullishCoalesce(customConfig.maxRunners, () => ( 1e3)),
+        min_runners: _nullishCoalesce(customConfig.minRunners, () => ( 0)),
+        request_lifespan: _nullishCoalesce(customConfig.requestLifespan, () => ( 15 * 60)),
+        runners_margin: _nullishCoalesce(customConfig.runnersMargin, () => ( 0)),
+        slots_per_runner: _nullishCoalesce(customConfig.slotsPerRunner, () => ( 1)),
+        metadata_poll_interval: _nullishCoalesce(customConfig.metadataPollInterval, () => ( 1e3))
+      },
+      metadata: _nullishCoalesce(customConfig.metadata, () => ( {})),
+      drain_on_version_upgrade: _nullishCoalesce(customConfig.drainOnVersionUpgrade, () => ( true)),
+      metadataPollInterval: _nullishCoalesce(customConfig.metadataPollInterval, () => ( 1e3))
+    };
+    await _chunkSAZZ4SB2cjs.updateRunnerConfig.call(void 0, clientConfig, runnerName, {
+      datacenters: Object.fromEntries(
+        dcsRes.datacenters.map((dc) => [dc.name, serverlessConfig])
+      )
+    });
+    logger4().info({
+      msg: "serverless runner configured successfully",
+      runnerName,
+      namespace: config.namespace
+    });
+  } catch (error) {
+    logger4().error({
+      msg: "failed to configure serverless runner, validate endpoint is configured correctly then restart this process",
+      error
+    });
+  }
+}
+
+// src/serverless/router.ts
+
+
+// src/manager/router-schema.ts
+
+var ServerlessStartHeadersSchema = _v4.z.object({
+  endpoint: _v4.z.string({
+    error: "x-rivet-endpoint header is required"
+  }),
+  token: _v4.z.string({ error: "x-rivet-token header must be a string" }).optional(),
+  totalSlots: _v4.z.coerce.number({
+    error: "x-rivet-total-slots header must be a number"
+  }).int({ error: "x-rivet-total-slots header must be an integer" }).gte(1, { error: "x-rivet-total-slots header must be positive" }),
+  runnerName: _v4.z.string({
+    error: "x-rivet-runner-name header is required"
+  }),
+  namespace: _v4.z.string({
+    error: "x-rivet-namespace-name header is required"
+  })
+});
+
+// src/serverless/router.ts
+function buildServerlessRouter(driverConfig, config) {
+  return _chunk4JVIG3SScjs.createRouter.call(void 0, config.serverless.basePath, (router) => {
+    router.get("/", (c) => {
+      return c.text(
+        "This is a RivetKit server.\n\nLearn more at https://rivetkit.org"
+      );
+    });
+    router.get("/start", async (c) => {
+      var _a;
+      const parseResult = ServerlessStartHeadersSchema.safeParse({
+        endpoint: c.req.header("x-rivet-endpoint"),
+        token: _nullishCoalesce(c.req.header("x-rivet-token"), () => ( void 0)),
+        totalSlots: c.req.header("x-rivet-total-slots"),
+        runnerName: c.req.header("x-rivet-runner-name"),
+        namespace: c.req.header("x-rivet-namespace-name")
+      });
+      if (!parseResult.success) {
+        throw new (0, _chunkL47L3ZWJcjs.InvalidRequest)(
+          _nullishCoalesce(((_a = parseResult.error.issues[0]) == null ? void 0 : _a.message), () => ( "invalid serverless start headers"))
+        );
+      }
+      const { endpoint, token, totalSlots, runnerName, namespace } = parseResult.data;
+      logger4().debug({
+        msg: "received serverless runner start request",
+        endpoint,
+        totalSlots,
+        runnerName,
+        namespace
+      });
+      if (config.endpoint) {
+        if (!endpointsMatch(endpoint, config.endpoint)) {
+          throw new (0, _chunkL47L3ZWJcjs.EndpointMismatch)(config.endpoint, endpoint);
+        }
+        if (namespace !== config.namespace) {
+          throw new (0, _chunkL47L3ZWJcjs.NamespaceMismatch)(config.namespace, namespace);
+        }
+      }
+      const newConfig = {
+        ...config,
+        endpoint,
+        namespace,
+        token,
+        runner: {
+          ...config.runner,
+          totalSlots,
+          runnerName,
+          // Not supported on serverless
+          runnerKey: void 0
+        }
+      };
+      const managerDriver = new (0, _chunkSAZZ4SB2cjs.RemoteManagerDriver)(
+        _chunkSAZZ4SB2cjs.convertRegistryConfigToClientConfig.call(void 0, newConfig)
+      );
+      const client = _chunkSAZZ4SB2cjs.createClientWithDriver.call(void 0, managerDriver);
+      const actorDriver = driverConfig.actor(
+        newConfig,
+        managerDriver,
+        client
+      );
+      _invariant2.default.call(void 0, 
+        actorDriver.serverlessHandleStart,
+        "missing serverlessHandleStart on ActorDriver"
+      );
+      return await actorDriver.serverlessHandleStart(c);
+    });
+    router.get("/health", (c) => _chunk4JVIG3SScjs.handleHealthRequest.call(void 0, c));
+    router.get(
+      "/metadata",
+      (c) => _chunk4JVIG3SScjs.handleMetadataRequest.call(void 0, 
+        c,
+        config,
+        { serverless: {} },
+        config.publicEndpoint,
+        config.publicNamespace,
+        config.publicToken
+      )
+    );
+  });
+}
+function normalizeEndpointUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const pathname = parsed.pathname === "/" ? "/" : parsed.pathname.replace(/\/+$/, "");
+    let hostname = isLoopbackAddress(parsed.hostname) ? "localhost" : parsed.hostname;
+    hostname = normalizeRegionalHostname(hostname);
+    const host = parsed.port ? `${hostname}:${parsed.port}` : hostname;
+    return `${parsed.protocol}//${host}${pathname}`;
+  } catch (e2) {
+    return null;
+  }
+}
+function normalizeRegionalHostname(hostname) {
+  if (!hostname.endsWith(".rivet.dev")) {
+    return hostname;
+  }
+  if (!hostname.startsWith("api-")) {
+    return hostname;
+  }
+  const withoutPrefix = hostname.slice(4);
+  const firstDotIndex = withoutPrefix.indexOf(".");
+  if (firstDotIndex === -1) {
+    return hostname;
+  }
+  const domain = withoutPrefix.slice(firstDotIndex + 1);
+  return `api.${domain}`;
+}
+function endpointsMatch(a, b) {
+  const normalizedA = normalizeEndpointUrl(a);
+  const normalizedB = normalizeEndpointUrl(b);
+  if (normalizedA === null || normalizedB === null) {
+    return a === b;
+  }
+  return normalizedA === normalizedB;
+}
+function isLoopbackAddress(hostname) {
+  return hostname === "127.0.0.1" || hostname === "0.0.0.0" || hostname === "::1" || hostname === "[::1]";
+}
+
+// runtime/index.ts
+function logLine(label, value) {
+  const padding = " ".repeat(Math.max(0, 13 - label.length));
+  console.log(`  - ${label}:${padding}${value}`);
+}
+var Runtime = class _Runtime {
+  #registry;
+  #config;
+  #driver;
+  #managerDriver;
+  #startKind;
+  
+  #serverlessRouter;
+  get config() {
+    return this.#config;
+  }
+  get driver() {
+    return this.#driver;
+  }
+  get managerDriver() {
+    return this.#managerDriver;
+  }
+  /** Use Runtime.create() instead */
+  constructor(registry, config, driver, managerDriver, managerPort) {
+    this.#registry = registry;
+    this.#config = config;
+    this.#driver = driver;
+    this.#managerDriver = managerDriver;
+    this.managerPort = managerPort;
+  }
+  static async create(registry) {
+    var _a, _b, _c;
+    _chunk4JVIG3SScjs.logger.call(void 0, ).info("rivetkit starting");
+    const config = registry.parseConfig();
+    if ((_a = config.logging) == null ? void 0 : _a.baseLogger) {
+      _chunkPQZHDKRWcjs.configureBaseLogger.call(void 0, config.logging.baseLogger);
+    } else {
+      _chunkPQZHDKRWcjs.configureDefaultLogger.call(void 0, (_b = config.logging) == null ? void 0 : _b.level);
+    }
+    _invariant2.default.call(void 0, 
+      !(config.serverless.spawnEngine && config.serveManager),
+      "cannot specify both spawnEngine and serveManager"
+    );
+    const driver = chooseDefaultDriver(config);
+    const managerDriver = driver.manager(config);
+    let managerPort;
+    if (config.serverless.spawnEngine) {
+      managerPort = _chunk4JVIG3SScjs.ENGINE_PORT;
+      _chunk4JVIG3SScjs.logger.call(void 0, ).debug({
+        msg: "spawning engine",
+        version: config.serverless.engineVersion
+      });
+      await ensureEngineProcess({
+        version: config.serverless.engineVersion
+      });
+    } else if (config.serveManager) {
+      const configuredManagerPort = config.managerPort;
+      const serveRuntime = _chunkPQZHDKRWcjs.detectRuntime.call(void 0, );
+      let upgradeWebSocket;
+      const getUpgradeWebSocket = () => upgradeWebSocket;
+      managerDriver.setGetUpgradeWebSocket(getUpgradeWebSocket);
+      const { router: managerRouter } = _chunk4JVIG3SScjs.buildManagerRouter.call(void 0, 
+        config,
+        managerDriver,
+        getUpgradeWebSocket,
+        serveRuntime
+      );
+      managerPort = await _chunk4JVIG3SScjs.findFreePort.call(void 0, config.managerPort);
+      _chunk4JVIG3SScjs.logger.call(void 0, ).debug({
+        msg: "serving manager",
+        port: managerPort
+      });
+      if (config.publicEndpoint === `http://127.0.0.1:${configuredManagerPort}`) {
+        config.publicEndpoint = `http://127.0.0.1:${managerPort}`;
+        config.serverless.publicEndpoint = config.publicEndpoint;
+      }
+      config.managerPort = managerPort;
+      const out = await _chunk4JVIG3SScjs.crossPlatformServe.call(void 0, 
+        config,
+        managerPort,
+        managerRouter,
+        serveRuntime
+      );
+      upgradeWebSocket = out.upgradeWebSocket;
+    }
+    const runtime = new _Runtime(
+      registry,
+      config,
+      driver,
+      managerDriver,
+      managerPort
+    );
+    const driverLog = _nullishCoalesce(((_c = managerDriver.extraStartupLog) == null ? void 0 : _c.call(managerDriver)), () => ( {}));
+    _chunk4JVIG3SScjs.logger.call(void 0, ).info({
+      msg: "rivetkit ready",
+      driver: driver.name,
+      definitions: Object.keys(config.use).length,
+      ...driverLog
+    });
+    return runtime;
+  }
+  startServerless() {
+    if (this.#startKind === "serverless") return;
+    _invariant2.default.call(void 0, !this.#startKind, "Runtime already started as runner");
+    this.#startKind = "serverless";
+    this.#serverlessRouter = buildServerlessRouter(
+      this.#driver,
+      this.#config
+    ).router;
+    this.#printWelcome();
+    if (this.#config.serverless.configureRunnerPool) {
+      configureServerlessRunner(this.#config);
+    }
+  }
+  startRunner() {
+    if (this.#startKind === "runner") return;
+    _invariant2.default.call(void 0, !this.#startKind, "Runtime already started as serverless");
+    this.#startKind = "runner";
+    if (this.#config.runner && this.#driver.autoStartActorDriver) {
+      _chunk4JVIG3SScjs.logger.call(void 0, ).debug("starting actor driver");
+      const inlineClient = _chunkSAZZ4SB2cjs.createClientWithDriver.call(void 0, 
+        this.#managerDriver
+      );
+      this.#driver.actor(this.#config, this.#managerDriver, inlineClient);
+    }
+    this.#printWelcome();
+  }
+  #printWelcome() {
+    if (this.#config.noWelcome) return;
+    const inspectorUrl = this.managerPort ? getInspectorUrl(this.#config, this.managerPort) : void 0;
+    console.log();
+    console.log(
+      `  RivetKit ${_chunkPQZHDKRWcjs.package_default.version} (${this.#driver.displayName} - ${this.#startKind === "serverless" ? "Serverless" : "Runner"})`
+    );
+    if (this.#config.namespace !== "default") {
+      logLine("Namespace", this.#config.namespace);
+    }
+    if (this.#config.endpoint) {
+      const endpointType = this.#config.serverless.spawnEngine ? "local native" : this.#config.serveManager ? "local manager" : "remote";
+      logLine("Endpoint", `${this.#config.endpoint} (${endpointType})`);
+    }
+    if (this.#startKind === "serverless" && this.#config.publicEndpoint) {
+      logLine("Client", this.#config.publicEndpoint);
+    }
+    if (inspectorUrl && this.#config.inspector.enabled) {
+      logLine("Inspector", inspectorUrl);
+    }
+    const actorCount = Object.keys(this.#config.use).length;
+    logLine("Actors", actorCount.toString());
+    const displayInfo = this.#managerDriver.displayInformation();
+    for (const [k, v] of Object.entries(displayInfo.properties)) {
+      logLine(k, v);
+    }
+    console.log();
+  }
+  /** Handle serverless request */
+  handleServerlessRequest(request) {
+    _invariant2.default.call(void 0, 
+      this.#startKind === "serverless",
+      "not started as serverless"
+    );
+    _invariant2.default.call(void 0, this.#serverlessRouter, "serverless router not initialized");
+    return this.#serverlessRouter.fetch(request);
+  }
+};
+
+// src/registry/index.ts
+var Registry = class {
+  #config;
+  get config() {
+    return this.#config;
+  }
+  parseConfig() {
+    return _chunk4JVIG3SScjs.RegistryConfigSchema.parse(this.#config);
+  }
+  // Shared runtime instance
+  #runtime;
+  #runtimePromise;
+  constructor(config) {
+    this.#config = config;
+    if (_chunkPQZHDKRWcjs.getNodeEnv.call(void 0, ) !== "test") {
+      setTimeout(() => {
+        this.#ensureRuntime();
+      }, 0);
+    }
+  }
+  /** Creates runtime if not already created. Idempotent. */
+  #ensureRuntime() {
+    if (!this.#runtimePromise) {
+      this.#runtimePromise = Runtime.create(this);
+      this.#runtimePromise.then((rt) => {
+        this.#runtime = rt;
+      });
+    }
+    return this.#runtimePromise;
+  }
+  /**
+   * Handle an incoming HTTP request for serverless deployments.
+   *
+   * @example
+   * ```ts
+   * const app = new Hono();
+   * app.all("/api/rivet/*", (c) => registry.handler(c.req.raw));
+   * export default app;
+   * ```
+   */
+  async handler(request) {
+    const runtime = await this.#ensureRuntime();
+    runtime.startServerless();
+    return await runtime.handleServerlessRequest(request);
+  }
+  /**
+   * Returns a fetch handler for serverless deployments.
+   *
+   * @example
+   * ```ts
+   * export default registry.serve();
+   * ```
+   */
+  serve() {
+    return { fetch: this.handler.bind(this) };
+  }
+  /**
+   * Starts an actor runner for standalone server deployments.
+   */
+  startRunner() {
+    this.#ensureRuntime().then((runtime) => runtime.startRunner());
+  }
+  // MARK: Legacy
+  /**
+   * Runs the registry for a server.
+   *
+   * @deprecated Use {@link Registry.startRunner} for long-running servers or {@link Registry.handler} for serverless deployments.
+   */
+  start(inputConfig) {
+    const config = LegacyRunnerConfigSchema.parse(inputConfig);
+    if (config.autoConfigureServerless && config.runnerKind !== "serverless") {
+      throw new Error(
+        "autoConfigureServerless can only be configured when runnerKind is 'serverless'"
+      );
+    }
+    const isDevEnv = _chunkPQZHDKRWcjs.isDev.call(void 0, );
+    if (isDevEnv && config.runnerKind === "serverless") {
+      if ((inputConfig == null ? void 0 : inputConfig.runEngine) === void 0) config.runEngine = true;
+      if ((inputConfig == null ? void 0 : inputConfig.autoConfigureServerless) === void 0)
+        config.autoConfigureServerless = true;
+    }
+    if (config.runnerKind === "serverless") {
+      return this.#legacyStartServerless(config, inputConfig);
+    } else {
+      return this.#legacyStartNormal(config);
+    }
+  }
+  #legacyStartServerless(config, _inputConfig) {
+    const client = _chunkSAZZ4SB2cjs.createClient.call(void 0, {
+      endpoint: config.endpoint,
+      token: config.token,
+      namespace: config.namespace,
+      headers: config.headers
+    });
+    return {
+      client,
+      fetch: this.handler.bind(this)
+    };
+  }
+  #legacyStartNormal(config) {
+    this.#ensureRuntime().then((runtime) => runtime.startRunner());
+    const client = _chunkSAZZ4SB2cjs.createClient.call(void 0, {
+      endpoint: config.endpoint,
+      token: config.token,
+      namespace: config.namespace,
+      headers: config.headers
+    });
+    return {
+      client,
+      fetch: this.handler.bind(this)
+    };
+  }
+};
+function setup(input) {
+  return new Registry(input);
+}
+
+
+
+
+
+
+
+
+exports.actor = actor; exports.event = event2; exports.queue = queue2; exports.createEngineDriver = createEngineDriver; exports.Registry = Registry; exports.setup = setup;
+//# sourceMappingURL=chunk-Q4UD2GA4.cjs.map