rivetkit 2.1.4 → 2.1.6-rc.1

package/dist/tsup/{chunk-M6H4XIF4.js → chunk-JJSPHLJN.js}

@@ -1,37 +1,25 @@
 import {
-  ActorDefinition,
-  createActorRouter,
   createFileSystemOrMemoryDriver,
   ensureDirectoryExists,
-  getStoragePath,
+  getStoragePath
+} from "./chunk-EGWXXBZV.js";
+import {
+  createActorRouter,
   lookupInRegistry
-} from "./chunk-KTWY3K6Z.js";
+} from "./chunk-YGYGANCA.js";
 import {
-  ClientConfigSchemaBase,
   RemoteManagerDriver,
   convertRegistryConfigToClientConfig,
-  createClient,
   createClientWithDriver,
   getDatacenters,
   getEndpoint,
-  transformClientConfig,
   updateRunnerConfig
-} from "./chunk-I6PL6QIY.js";
+} from "./chunk-WW27B6DM.js";
 import {
-  CONN_STATE_MANAGER_SYMBOL,
-  ENGINE_ENDPOINT,
-  ENGINE_PORT,
-  InspectorConfigSchema,
-  PATH_CONNECT,
-  PATH_INSPECTOR_CONNECT,
-  PATH_WEBSOCKET_BASE,
-  PATH_WEBSOCKET_PREFIX,
-  RegistryConfigSchema,
-  buildActorNames,
+  SqliteVfsPoolManager,
   buildManagerRouter,
   createRouter,
   crossPlatformServe,
-  deserializeActorKey,
   findFreePort,
   getInitialActorKvState,
   getNodeChildProcess,
@@ -40,55 +28,49 @@ import {
   getNodeFsSync,
   getNodePath,
   getNodeStream,
+  importNodeDependencies,
+  loadRuntimeServeStatic,
+  logger
+} from "./chunk-C4EB42ET.js";
+import {
+  CONN_STATE_MANAGER_SYMBOL,
+  ENGINE_ENDPOINT,
+  ENGINE_PORT,
+  PATH_CONNECT,
+  PATH_INSPECTOR_CONNECT,
+  PATH_WEBSOCKET_BASE,
+  PATH_WEBSOCKET_PREFIX,
+  RegistryConfigSchema,
+  buildActorNames,
+  deserializeActorKey,
   getValueLength,
   handleHealthRequest,
   handleMetadataRequest,
-  importNodeDependencies,
-  logger,
   parseWebSocketProtocols,
   routeWebSocket,
   truncateRawWebSocketPathPrefix
-} from "./chunk-UDMRZR6A.js";
+} from "./chunk-PQWI44WD.js";
 import {
-  ActorConfigSchema,
   KEYS,
-  event,
-  loggerWithoutContext,
-  queue
-} from "./chunk-ANKZ2FS6.js";
+  loggerWithoutContext
+} from "./chunk-C22JYHVT.js";
 import {
-  LogLevelSchema,
   VERSION,
   configureBaseLogger,
   configureDefaultLogger,
   detectRuntime,
   getLogger,
-  getNodeEnv,
-  getRivetRunEngine,
-  getRivetRunEngineVersion,
-  getRivetRunnerKey,
-  getRivetRunnerKind,
-  getRivetToken,
-  isDev,
   package_default,
   promiseWithResolvers,
   setLongTimeout,
   stringifyError
-} from "./chunk-DZXDUGLL.js";
+} from "./chunk-VWYO36X4.js";
 import {
   EndpointMismatch,
   InvalidRequest,
   NamespaceMismatch,
   UserError
-} from "./chunk-7HTNH26M.js";
-
-// src/actor/mod.ts
-function actor(input) {
-  const config = ActorConfigSchema.parse(input);
-  return new ActorDefinition(config);
-}
-var event2 = event;
-var queue2 = queue;
+} from "./chunk-AKUJ5OTO.js";
 
 // src/drivers/engine/actor-driver.ts
 import { idToStr, Runner } from "@rivetkit/engine-runner";
@@ -114,8 +96,19 @@ var EngineActorDriver = class {
   #runner;
   #actors = /* @__PURE__ */ new Map();
   #actorRouter;
-  #runnerStarted = promiseWithResolvers((reason) => logger2().warn({ msg: "unhandled runner started promise rejection", reason }));
-  #runnerStopped = promiseWithResolvers((reason) => logger2().warn({ msg: "unhandled runner stopped promise rejection", reason }));
+  #sqlitePool;
+  #runnerStarted = promiseWithResolvers(
+    (reason) => logger2().warn({
+      msg: "unhandled runner started promise rejection",
+      reason
+    })
+  );
+  #runnerStopped = promiseWithResolvers(
+    (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
@@ -138,6 +131,7 @@ var EngineActorDriver = class {
     this.#config = config;
     this.#managerDriver = managerDriver;
     this.#inlineClient = inlineClient;
+    this.#sqlitePool = new SqliteVfsPoolManager(config);
     const token = config.token;
     this.#actorRouter = createActorRouter(
       config,
@@ -152,7 +146,6 @@ var EngineActorDriver = class {
       namespace: config.namespace,
       totalSlots: config.runner.totalSlots,
       runnerName: config.runner.runnerName,
-      runnerKey: config.runner.runnerKey ?? crypto.randomUUID(),
       metadata: {
         rivetkit: { version: VERSION }
       },
@@ -173,7 +166,8 @@ var EngineActorDriver = class {
       },
       onActorStart: this.#runnerOnActorStart.bind(this),
       onActorStop: this.#runnerOnActorStop.bind(this),
-      logger: getLogger("engine-runner")
+      logger: getLogger("engine-runner"),
+      debugLatencyMs: process.env._RIVET_DEBUG_LATENCY_MS ? Number.parseInt(process.env._RIVET_DEBUG_LATENCY_MS, 10) : void 0
     };
     this.#runner = new Runner(engineRunnerConfig);
     this.#runner.start();
@@ -199,8 +193,8 @@ var EngineActorDriver = class {
   getContext(actorId) {
     return {};
   }
-  async setAlarm(actor2, timestamp) {
-    const handler = this.#actors.get(actor2.id);
+  async setAlarm(actor, timestamp) {
+    const handler = this.#actors.get(actor.id);
     if (!handler) {
       logger2().warn({
         msg: "no handler for actor to set alarm"
@@ -213,10 +207,10 @@ var EngineActorDriver = class {
     }
     const delay = Math.max(0, timestamp - Date.now());
     handler.alarmTimeout = setLongTimeout(() => {
-      actor2.onAlarm();
+      actor.onAlarm();
       handler.alarmTimeout = void 0;
     }, delay);
-    this.#runner.setAlarm(actor2.id, timestamp);
+    this.#runner.setAlarm(actor.id, timestamp);
   }
   // No database overrides - will use KV-backed implementation from rivetkit/db
   // MARK: - Batch KV operations
@@ -229,6 +223,9 @@ var EngineActorDriver = class {
   async kvBatchDelete(actorId, keys) {
     await this.#runner.kvDelete(actorId, keys);
   }
+  async kvDeleteRange(actorId, start, end) {
+    await this.#runner.kvDeleteRange(actorId, start, end);
+  }
   async kvList(actorId) {
     const entries = await this.#runner.kvListPrefix(
       actorId,
@@ -243,8 +240,12 @@ var EngineActorDriver = class {
     });
     return keys;
   }
-  async kvListPrefix(actorId, prefix) {
-    const result = await this.#runner.kvListPrefix(actorId, prefix);
+  async kvListPrefix(actorId, prefix, options) {
+    const result = await this.#runner.kvListPrefix(
+      actorId,
+      prefix,
+      options
+    );
     logger2().info({
       msg: "kvListPrefix called",
       actorId,
@@ -254,11 +255,18 @@ var EngineActorDriver = class {
     });
     return result;
   }
+  async kvListRange(actorId, start, end, options) {
+    return await this.#runner.kvListRange(
+      actorId,
+      start,
+      end,
+      true,
+      options
+    );
+  }
   /** Creates a SQLite VFS instance for creating KV-backed databases */
-  async createSqliteVfs() {
-    const specifier = "@rivetkit/sqlite-vfs";
-    const { SqliteVfs } = await import(specifier);
-    return new SqliteVfs();
+  async createSqliteVfs(actorId) {
+    return await this.#sqlitePool.acquire(actorId);
   }
   // MARK: - Actor Lifecycle
   async loadActor(actorId) {
@@ -296,6 +304,7 @@ var EngineActorDriver = class {
     }
     await Promise.all(stopPromises);
     logger2().debug({ msg: "all actors stopped" });
+    await this.#sqlitePool.shutdown();
     try {
       await this.#runner.shutdown(immediate);
     } catch (error) {
@@ -371,7 +380,12 @@ var EngineActorDriver = class {
     let handler = this.#actors.get(actorId);
     if (!handler) {
       handler = {
-        actorStartPromise: promiseWithResolvers((reason) => logger2().warn({ msg: "unhandled actor start promise rejection", reason }))
+        actorStartPromise: promiseWithResolvers(
+          (reason) => logger2().warn({
+            msg: "unhandled actor start promise rejection",
+            reason
+          })
+        )
       };
       this.#actors.set(actorId, handler);
     }
@@ -405,11 +419,17 @@ var EngineActorDriver = class {
           msg: "applying config limits from protocol",
           protocolMetadata
         });
-        const stopThresholdMax = Math.max(Number(protocolMetadata.actorStopThreshold) - 1e3, 0);
+        const stopThresholdMax = Math.max(
+          Number(protocolMetadata.actorStopThreshold) - 1e3,
+          0
+        );
         handler.actor.overrides.onSleepTimeout = stopThresholdMax;
         handler.actor.overrides.onDestroyTimeout = stopThresholdMax;
         if (protocolMetadata.serverlessDrainGracePeriod) {
-          const drainMax = Math.max(Number(protocolMetadata.serverlessDrainGracePeriod) - 1e3, 0);
+          const drainMax = Math.max(
+            Number(protocolMetadata.serverlessDrainGracePeriod) - 1e3,
+            0
+          );
           handler.actor.overrides.runStopTimeout = drainMax;
           handler.actor.overrides.waitUntilTimeout = drainMax;
         }
@@ -428,7 +448,9 @@ var EngineActorDriver = class {
       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)}`);
+      ) : 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);
@@ -457,12 +479,20 @@ var EngineActorDriver = class {
     this.#actorStopIntent.delete(actorId);
     const handler = this.#actors.get(actorId);
     if (!handler) {
-      logger2().debug({ msg: "no runner actor handler to stop", actorId, reason });
+      logger2().debug({
+        msg: "no runner actor handler to stop",
+        actorId,
+        reason
+      });
       return;
     }
     if (handler.actorStartPromise) {
       try {
-        logger2().debug({ msg: "runner actor stopping before it started, waiting", actorId, generation });
+        logger2().debug({
+          msg: "runner actor stopping before it started, waiting",
+          actorId,
+          generation
+        });
         await handler.actorStartPromise.promise;
       } catch (err) {
         logger2().debug({
@@ -536,7 +566,7 @@ var EngineActorDriver = class {
     websocket.raw = websocket;
     const wsContext = new WSContext(websocket);
     const conn = wsHandler.conn;
-    const actor2 = wsHandler.actor;
+    const actor = wsHandler.actor;
     const connStateManager = conn == null ? void 0 : conn[CONN_STATE_MANAGER_SYMBOL];
     logger2().debug({
       msg: "attaching websocket event listeners",
@@ -549,79 +579,79 @@ var EngineActorDriver = class {
     if (isRestoringHibernatable) {
       (_c = wsHandler.onRestore) == null ? void 0 : _c.call(wsHandler, wsContext);
     }
-    websocket.addEventListener("open", (event3) => {
-      wsHandler.onOpen(event3, wsContext);
+    websocket.addEventListener("open", (event) => {
+      wsHandler.onOpen(event, wsContext);
     });
-    websocket.addEventListener("message", (event3) => {
+    websocket.addEventListener("message", (event) => {
       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,
+        actorId: actor == null ? void 0 : actor.id,
+        messageIndex: event.rivetMessageIndex,
         hasWsHandler: !!wsHandler,
         hasOnMessage: !!(wsHandler == null ? void 0 : wsHandler.onMessage),
-        actorIsStopping: actor2 == null ? void 0 : actor2.isStopping,
+        actorIsStopping: actor == null ? void 0 : actor.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
+        eventTargetWsId: (_b2 = event.target) == null ? void 0 : _b2.__rivet_ws_id
       });
-      if (actor2 == null ? void 0 : actor2.isStopping) {
+      if (actor == null ? void 0 : actor.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
+          actorId: actor == null ? void 0 : actor.id,
+          messageIndex: event.rivetMessageIndex
         });
         return;
       }
       logger2().debug({
         msg: "calling wsHandler.onMessage",
         connId: conn == null ? void 0 : conn.id,
-        messageIndex: event3.rivetMessageIndex
+        messageIndex: event.rivetMessageIndex
       });
-      wsHandler.onMessage(event3, wsContext);
+      wsHandler.onMessage(event, wsContext);
       const hibernate = connStateManager == null ? void 0 : connStateManager.hibernatableData;
-      if (hibernate && conn && actor2) {
+      if (hibernate && conn && actor) {
         invariant(
-          typeof event3.rivetMessageIndex === "number",
+          typeof event.rivetMessageIndex === "number",
           "missing event.rivetMessageIndex"
         );
         const previousMsgIndex = hibernate.serverMessageIndex;
-        hibernate.serverMessageIndex = event3.rivetMessageIndex;
+        hibernate.serverMessageIndex = event.rivetMessageIndex;
         logger2().info({
           msg: "persisting message index",
           connId: conn.id,
           previousMsgIndex,
-          newMsgIndex: event3.rivetMessageIndex
+          newMsgIndex: event.rivetMessageIndex
         });
         const entry = this.#hwsMessageIndex.get(conn.id);
         if (entry) {
-          const messageLength = getValueLength(event3.data);
+          const messageLength = getValueLength(event.data);
           entry.bufferedMessageSize += messageLength;
           if (entry.bufferedMessageSize >= CONN_BUFFERED_MESSAGE_SIZE_THRESHOLD) {
             entry.bufferedMessageSize = 0;
             entry.pendingAckFromBufferSize = true;
-            actor2.stateManager.saveState({
+            actor.stateManager.saveState({
               immediate: true
             });
           } else {
-            actor2.stateManager.saveState({
+            actor.stateManager.saveState({
               maxWait: CONN_MESSAGE_ACK_DEADLINE
             });
           }
         } else {
-          actor2.stateManager.saveState({
+          actor.stateManager.saveState({
             maxWait: CONN_MESSAGE_ACK_DEADLINE
           });
         }
       }
     });
-    websocket.addEventListener("close", (event3) => {
-      wsHandler.onClose(event3, wsContext);
+    websocket.addEventListener("close", (event) => {
+      wsHandler.onClose(event, wsContext);
     });
-    websocket.addEventListener("error", (event3) => {
-      wsHandler.onError(event3, wsContext);
+    websocket.addEventListener("error", (event) => {
+      wsHandler.onError(event, wsContext);
     });
     if (isRestoringHibernatable) {
       logger2().info({
@@ -710,8 +740,8 @@ var EngineActorDriver = class {
     }
   }
   async #hwsLoadAll(actorId) {
-    const actor2 = await this.loadActor(actorId);
-    return actor2.conns.values().map((conn) => {
+    const actor = await this.loadActor(actorId);
+    return actor.conns.values().map((conn) => {
       const connStateManager = conn[CONN_STATE_MANAGER_SYMBOL];
       const hibernatable = connStateManager.hibernatableData;
       if (!hibernatable) return void 0;
@@ -725,15 +755,15 @@ var EngineActorDriver = class {
       };
     }).filter((x) => x !== void 0).toArray();
   }
-  async onBeforeActorStart(actor2) {
+  async onBeforeActorStart(actor) {
     var _a;
-    const handler = this.#actors.get(actor2.id);
+    const handler = this.#actors.get(actor.id);
     invariant(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);
+    const metaEntries = await this.#hwsLoadAll(actor.id);
+    await this.#runner.restoreHibernatingRequests(actor.id, metaEntries);
   }
   onCreateConn(conn) {
     const hibernatable = conn[CONN_STATE_MANAGER_SYMBOL].hibernatableData;
@@ -795,27 +825,6 @@ var EngineActorDriver = class {
   }
 };
 
-// src/drivers/engine/config.ts
-import { z } from "zod/v4";
-var EngineConfigSchemaBase = ClientConfigSchemaBase.extend({
-  /** Unique key for this runner. Runners connecting a given key will replace any other runner connected with the same key. */
-  runnerKey: z.string().optional().transform((val) => val ?? getRivetRunnerKey()),
-  /** How many actors this runner can run. */
-  totalSlots: z.number().default(1e5)
-});
-var EngineConfigSchemaTransformed = EngineConfigSchemaBase.transform(
-  (config, ctx) => transformEngineConfig(config, ctx)
-);
-var EngineConfigSchema = EngineConfigSchemaTransformed.default(
-  () => EngineConfigSchemaTransformed.parse({})
-);
-function transformEngineConfig(config, ctx) {
-  return {
-    ...transformClientConfig(config, ctx),
-    runnerKey: config.runnerKey
-  };
-}
-
 // src/drivers/engine/mod.ts
 function createEngineDriver() {
   return {
@@ -826,111 +835,12 @@ function createEngineDriver() {
       return new RemoteManagerDriver(clientConfig);
     },
     actor: (config, managerDriver, inlineClient) => {
-      return new EngineActorDriver(
-        config,
-        managerDriver,
-        inlineClient
-      );
+      return new EngineActorDriver(config, managerDriver, inlineClient);
     },
     autoStartActorDriver: true
   };
 }
 
-// src/registry/config/legacy-runner.ts
-import { z as z2 } from "zod/v4";
-var LegacyDriverConfigSchema = z2.object({
-  /** Machine-readable name to identify this driver by. */
-  name: z2.string(),
-  manager: z2.custom(),
-  actor: z2.custom()
-});
-var LegacyRunnerConfigSchemaUnmerged = z2.object({
-  driver: LegacyDriverConfigSchema.optional(),
-  /** @experimental */
-  maxIncomingMessageSize: z2.number().optional().default(65536),
-  /** @experimental */
-  maxOutgoingMessageSize: z2.number().optional().default(1048576),
-  /** @experimental */
-  inspector: InspectorConfigSchema,
-  /** @experimental */
-  disableDefaultServer: z2.boolean().optional().default(false),
-  /** @experimental */
-  defaultServerPort: z2.number().default(6420),
-  /** @experimental */
-  runEngine: z2.boolean().optional().default(() => getRivetRunEngine()),
-  /** @experimental */
-  runEngineVersion: z2.string().optional().default(() => getRivetRunEngineVersion() ?? VERSION),
-  /** @experimental */
-  overrideServerAddress: z2.string().optional(),
-  /** @experimental */
-  disableActorDriver: z2.boolean().optional().default(false),
-  /**
-   * @experimental
-   *
-   * Whether to run runners normally or have them managed
-   * serverlessly (by the Rivet Engine for example).
-   */
-  runnerKind: z2.enum(["serverless", "normal"]).optional().default(
-    () => getRivetRunnerKind() === "serverless" ? "serverless" : "normal"
-  ),
-  totalSlots: z2.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: z2.string().optional().default("/"),
-  /**
-   * @experimental
-   *
-   * Disable welcome message.
-   * */
-  noWelcome: z2.boolean().optional().default(false),
-  /**
-   * @experimental
-   * */
-  logging: z2.object({
-    baseLogger: z2.custom().optional(),
-    level: 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: z2.union([
-    z2.boolean(),
-    z2.object({
-      url: z2.string().optional(),
-      headers: z2.record(z2.string(), z2.string()).optional(),
-      maxRunners: z2.number().optional(),
-      minRunners: z2.number().optional(),
-      requestLifespan: z2.number().optional(),
-      runnersMargin: z2.number().optional(),
-      slotsPerRunner: z2.number().optional(),
-      metadata: z2.record(z2.string(), z2.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: z2.custom().optional(),
-  /** @experimental */
-  token: z2.string().optional().transform((v) => v || getRivetToken())
-}).merge(EngineConfigSchemaBase);
-var LegacyRunnerConfigSchemaTransformed = LegacyRunnerConfigSchemaUnmerged.transform((config, ctx) => ({
-  ...config,
-  ...transformEngineConfig(config, ctx)
-}));
-var LegacyRunnerConfigSchema = LegacyRunnerConfigSchemaTransformed.default(
-  () => LegacyRunnerConfigSchemaTransformed.parse({})
-);
-
 // runtime/index.ts
 import invariant4 from "invariant";
 
@@ -1087,7 +997,9 @@ async function ensureEngineProcess(options) {
         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")) {
+    } 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`,
@@ -1154,8 +1066,8 @@ async function downloadEngineBinaryIfNeeded(binaryPath, version, varDir) {
       `failed to download rivet engine binary from ${downloadUrl}: ${response.status} ${response.statusText}`
     );
   }
-  const crypto2 = getNodeCrypto();
-  const tempPath = `${binaryPath}.${crypto2.randomUUID()}.tmp`;
+  const crypto = getNodeCrypto();
+  const tempPath = `${binaryPath}.${crypto.randomUUID()}.tmp`;
   const startTime = Date.now();
   logger3().debug({
     msg: "starting binary download",
@@ -1372,7 +1284,7 @@ async function configureServerlessRunner(config) {
       serverless: {
         url: customConfig.url,
         headers: customConfig.headers ?? {},
-        max_runners: customConfig.maxRunners ?? 1e3,
+        max_runners: customConfig.maxRunners ?? 1e5,
         min_runners: customConfig.minRunners ?? 0,
         request_lifespan: customConfig.requestLifespan ?? 15 * 60,
         runners_margin: customConfig.runnersMargin ?? 0,
@@ -1405,19 +1317,19 @@ async function configureServerlessRunner(config) {
 import invariant3 from "invariant";
 
 // src/manager/router-schema.ts
-import { z as z3 } from "zod/v4";
-var ServerlessStartHeadersSchema = z3.object({
-  endpoint: z3.string({
+import { z } from "zod/v4";
+var ServerlessStartHeadersSchema = z.object({
+  endpoint: z.string({
     error: "x-rivet-endpoint header is required"
   }),
-  token: z3.string({ error: "x-rivet-token header must be a string" }).optional(),
-  totalSlots: z3.coerce.number({
+  token: z.string({ error: "x-rivet-token header must be a string" }).optional(),
+  totalSlots: 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: z3.string({
+  runnerName: z.string({
     error: "x-rivet-runner-name header is required"
   }),
-  namespace: z3.string({
+  namespace: z.string({
     error: "x-rivet-namespace-name header is required"
   })
 });
@@ -1460,25 +1372,33 @@ function buildServerlessRouter(driverConfig, config) {
           throw new NamespaceMismatch(config.namespace, namespace);
         }
       }
-      const newConfig = {
+      const sharedConfig = {
         ...config,
         endpoint,
         namespace,
-        token,
         runner: {
           ...config.runner,
           totalSlots,
-          runnerName,
-          // Not supported on serverless
-          runnerKey: void 0
+          runnerName
         }
       };
+      const runnerConfig = {
+        ...sharedConfig,
+        token
+      };
+      const clientConfig = {
+        ...sharedConfig,
+        // Preserve the configured application token for actor-to-actor
+        // calls. The start token is only needed for the runner
+        // connection and may not have gateway permissions.
+        token: config.token ?? token
+      };
       const managerDriver = new RemoteManagerDriver(
-        convertRegistryConfigToClientConfig(newConfig)
+        convertRegistryConfigToClientConfig(clientConfig)
       );
       const client = createClientWithDriver(managerDriver);
       const actorDriver = driverConfig.actor(
-        newConfig,
+        runnerConfig,
         managerDriver,
         client
       );
@@ -1618,13 +1538,40 @@ var Runtime = class _Runtime {
         config.serverless.publicEndpoint = config.publicEndpoint;
       }
       config.managerPort = managerPort;
+      let serverApp = managerRouter;
+      if (config.publicDir) {
+        let dirExists = false;
+        try {
+          const fsSync = getNodeFsSync();
+          dirExists = fsSync.existsSync(config.publicDir);
+        } catch {
+        }
+        if (dirExists) {
+          const { Hono } = await import("hono");
+          const serveStaticFn = await loadRuntimeServeStatic(serveRuntime);
+          const wrapper = new Hono();
+          wrapper.use(
+            "*",
+            serveStaticFn({ root: `./${config.publicDir}` })
+          );
+          wrapper.route("/", managerRouter);
+          serverApp = wrapper;
+        }
+      }
       const out = await crossPlatformServe(
         config,
         managerPort,
-        managerRouter,
+        serverApp,
         serveRuntime
       );
       upgradeWebSocket = out.upgradeWebSocket;
+      if (out.closeServer && process.env.NODE_ENV !== "production") {
+        const shutdown = () => {
+          out.closeServer();
+        };
+        process.on("SIGTERM", shutdown);
+        process.on("SIGINT", shutdown);
+      }
     }
     const runtime = new _Runtime(
       registry,
@@ -1685,6 +1632,15 @@ var Runtime = class _Runtime {
     if (this.#startKind === "serverless" && this.#config.publicEndpoint) {
       logLine("Client", this.#config.publicEndpoint);
     }
+    if (this.#config.publicDir) {
+      try {
+        const fsSync = getNodeFsSync();
+        if (fsSync.existsSync(this.#config.publicDir)) {
+          logLine("Static", `./${this.#config.publicDir}`);
+        }
+      } catch {
+      }
+    }
     if (inspectorUrl && this.#config.inspector.enabled) {
       logLine("Inspector", inspectorUrl);
     }
@@ -1721,11 +1677,12 @@ var Registry = class {
   #runtimePromise;
   constructor(config) {
     this.#config = config;
-    if (getNodeEnv() !== "test") {
-      setTimeout(() => {
+    setTimeout(() => {
+      const parsedConfig = this.parseConfig();
+      if (parsedConfig.serverless.spawnEngine || parsedConfig.serveManager) {
         this.#ensureRuntime();
-      }, 0);
-    }
+      }
+    }, 0);
   }
   /** Creates runtime if not already created. Idempotent. */
   #ensureRuntime() {
@@ -1769,55 +1726,33 @@ var Registry = class {
   startRunner() {
     this.#ensureRuntime().then((runtime) => runtime.startRunner());
   }
-  // MARK: Legacy
   /**
-   * Runs the registry for a server.
+   * Starts the server, serving both the actor API and static files.
    *
-   * @deprecated Use {@link Registry.startRunner} for long-running servers or {@link Registry.handler} for serverless deployments.
+   * This is the simplest way to run RivetKit. It starts a local manager
+   * server, serves static files from the configured `publicDir` (default
+   * `"public"`), and starts the actor runner.
+   *
+   * When an endpoint is configured (via config or RIVET_ENDPOINT env var),
+   * operates in serverless mode connected to the remote engine instead.
+   *
+   * @example
+   * ```ts
+   * const registry = setup({ use: { counter } });
+   * registry.start();
+   * ```
    */
-  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'"
-      );
+  start() {
+    if (this.#config.publicDir === void 0) {
+      this.#config.publicDir = "public";
     }
-    const isDevEnv = isDev();
-    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);
+    if (this.#config.serveManager === void 0) {
+      const hasEndpoint = !!(this.#config.endpoint || typeof process !== "undefined" && (process.env.RIVET_ENGINE || process.env.RIVET_ENDPOINT));
+      if (!hasEndpoint) {
+        this.#config.serveManager = true;
+      }
     }
-  }
-  #legacyStartServerless(config, _inputConfig) {
-    const client = createClient({
-      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 = createClient({
-      endpoint: config.endpoint,
-      token: config.token,
-      namespace: config.namespace,
-      headers: config.headers
-    });
-    return {
-      client,
-      fetch: this.handler.bind(this)
-    };
   }
 };
 function setup(input) {
@@ -1825,11 +1760,8 @@ function setup(input) {
 }
 
 export {
-  actor,
-  event2 as event,
-  queue2 as queue,
   createEngineDriver,
   Registry,
   setup
 };
-//# sourceMappingURL=chunk-M6H4XIF4.js.map
+//# sourceMappingURL=chunk-JJSPHLJN.js.map