rivetkit 2.0.42 → 2.1.0-rc.1

package/dist/tsup/{chunk-JDAD2YFA.js → chunk-5ESWDTHJ.js}

@@ -1,18 +1,12 @@
 import {
+  ActorDefinition,
   createActorRouter,
   createFileSystemOrMemoryDriver,
   ensureDirectoryExists,
-  getNodeChildProcess,
-  getNodeCrypto,
-  getNodeFs,
-  getNodeFsSync,
-  getNodePath,
-  getNodeStream,
   getStoragePath,
-  importNodeDependencies
-} from "./chunk-KCOVZOPS.js";
+  lookupInRegistry
+} from "./chunk-MZ37VV3P.js";
 import {
-  ActorDefinition,
   ClientConfigSchemaBase,
   RemoteManagerDriver,
   convertRegistryConfigToClientConfig,
@@ -20,16 +14,14 @@ import {
   createClientWithDriver,
   getDatacenters,
   getEndpoint,
-  lookupInRegistry,
   transformClientConfig,
   updateRunnerConfig
-} from "./chunk-Q6W7RJJP.js";
+} from "./chunk-DIGBC2VI.js";
 import {
   CONN_STATE_MANAGER_SYMBOL,
   ENGINE_ENDPOINT,
   ENGINE_PORT,
   InspectorConfigSchema,
-  KEYS,
   PATH_CONNECT,
   PATH_INSPECTOR_CONNECT,
   PATH_WEBSOCKET_BASE,
@@ -40,14 +32,27 @@ import {
   createRouter,
   deserializeActorKey,
   getInitialActorKvState,
+  getNodeChildProcess,
+  getNodeCrypto,
+  getNodeFs,
+  getNodeFsSync,
+  getNodePath,
+  getNodeStream,
   getValueLength,
   handleHealthRequest,
   handleMetadataRequest,
-  loggerWithoutContext,
+  importNodeDependencies,
   parseWebSocketProtocols,
   routeWebSocket,
   truncateRawWebSocketPathPrefix
-} from "./chunk-GMAVRZSF.js";
+} from "./chunk-M2T62AZQ.js";
+import {
+  ActorConfigSchema,
+  KEYS,
+  event,
+  loggerWithoutContext,
+  queue
+} from "./chunk-T5YCUGVS.js";
 import {
   LogLevelSchema,
   VERSION,
@@ -55,6 +60,7 @@ import {
   configureDefaultLogger,
   detectRuntime,
   getLogger,
+  getNodeEnv,
   getRivetRunEngine,
   getRivetRunEngineVersion,
   getRivetRunnerKey,
@@ -65,172 +71,21 @@ import {
   promiseWithResolvers,
   setLongTimeout,
   stringifyError
-} from "./chunk-FJ3KTN4V.js";
+} from "./chunk-6LIBPELE.js";
 import {
   EndpointMismatch,
   InvalidRequest,
   NamespaceMismatch,
   UserError
-} from "./chunk-LFVF5SCU.js";
-
-// src/actor/config.ts
-import { z } from "zod";
-var zFunction = () => z.custom((val) => typeof val === "function");
-var ActorConfigSchema = z.object({
-  onCreate: zFunction().optional(),
-  onDestroy: zFunction().optional(),
-  onWake: zFunction().optional(),
-  onSleep: zFunction().optional(),
-  onStateChange: zFunction().optional(),
-  onBeforeConnect: zFunction().optional(),
-  onConnect: zFunction().optional(),
-  onDisconnect: zFunction().optional(),
-  onBeforeActionResponse: zFunction().optional(),
-  onRequest: zFunction().optional(),
-  onWebSocket: zFunction().optional(),
-  actions: z.record(z.string(), zFunction()).default(() => ({})),
-  state: z.any().optional(),
-  createState: zFunction().optional(),
-  connState: z.any().optional(),
-  createConnState: zFunction().optional(),
-  vars: z.any().optional(),
-  db: z.any().optional(),
-  createVars: zFunction().optional(),
-  options: z.object({
-    createVarsTimeout: z.number().positive().default(5e3),
-    createConnStateTimeout: z.number().positive().default(5e3),
-    onConnectTimeout: z.number().positive().default(5e3),
-    // This must be less than ACTOR_STOP_THRESHOLD_MS
-    onSleepTimeout: z.number().positive().default(5e3),
-    onDestroyTimeout: z.number().positive().default(5e3),
-    stateSaveInterval: z.number().positive().default(1e4),
-    actionTimeout: z.number().positive().default(6e4),
-    // Max time to wait for waitUntil background promises during shutdown
-    waitUntilTimeout: z.number().positive().default(15e3),
-    connectionLivenessTimeout: z.number().positive().default(2500),
-    connectionLivenessInterval: z.number().positive().default(5e3),
-    noSleep: z.boolean().default(false),
-    sleepTimeout: z.number().positive().default(3e4),
-    /**
-     * Can hibernate WebSockets for onWebSocket.
-     *
-     * WebSockets using actions/events are hibernatable by default.
-     *
-     * @experimental
-     **/
-    canHibernateWebSocket: z.union([
-      z.boolean(),
-      zFunction()
-    ]).default(false)
-  }).strict().prefault(() => ({}))
-}).strict().refine(
-  (data) => !(data.state !== void 0 && data.createState !== void 0),
-  {
-    message: "Cannot define both 'state' and 'createState'",
-    path: ["state"]
-  }
-).refine(
-  (data) => !(data.connState !== void 0 && data.createConnState !== void 0),
-  {
-    message: "Cannot define both 'connState' and 'createConnState'",
-    path: ["connState"]
-  }
-).refine(
-  (data) => !(data.vars !== void 0 && data.createVars !== void 0),
-  {
-    message: "Cannot define both 'vars' and 'createVars'",
-    path: ["vars"]
-  }
-);
-var DocActorOptionsSchema = z.object({
-  createVarsTimeout: z.number().optional().describe("Timeout in ms for createVars handler. Default: 5000"),
-  createConnStateTimeout: z.number().optional().describe(
-    "Timeout in ms for createConnState handler. Default: 5000"
-  ),
-  onConnectTimeout: z.number().optional().describe("Timeout in ms for onConnect handler. Default: 5000"),
-  onSleepTimeout: z.number().optional().describe(
-    "Timeout in ms for onSleep handler. Must be less than ACTOR_STOP_THRESHOLD_MS. Default: 5000"
-  ),
-  onDestroyTimeout: z.number().optional().describe("Timeout in ms for onDestroy handler. Default: 5000"),
-  stateSaveInterval: z.number().optional().describe(
-    "Interval in ms between automatic state saves. Default: 10000"
-  ),
-  actionTimeout: z.number().optional().describe("Timeout in ms for action handlers. Default: 60000"),
-  waitUntilTimeout: z.number().optional().describe(
-    "Max time in ms to wait for waitUntil background promises during shutdown. Default: 15000"
-  ),
-  connectionLivenessTimeout: z.number().optional().describe(
-    "Timeout in ms for connection liveness checks. Default: 2500"
-  ),
-  connectionLivenessInterval: z.number().optional().describe(
-    "Interval in ms between connection liveness checks. Default: 5000"
-  ),
-  noSleep: z.boolean().optional().describe("If true, the actor will never sleep. Default: false"),
-  sleepTimeout: z.number().optional().describe(
-    "Time in ms of inactivity before the actor sleeps. Default: 30000"
-  ),
-  canHibernateWebSocket: z.boolean().optional().describe(
-    "Whether WebSockets using onWebSocket can be hibernated. WebSockets using actions/events are hibernatable by default. Default: false"
-  )
-}).describe("Actor options for timeouts and behavior configuration.");
-var DocActorConfigSchema = z.object({
-  state: z.unknown().optional().describe(
-    "Initial state value for the actor. Cannot be used with createState."
-  ),
-  createState: z.unknown().optional().describe(
-    "Function to create initial state. Receives context and input. Cannot be used with state."
-  ),
-  connState: z.unknown().optional().describe(
-    "Initial connection state value. Cannot be used with createConnState."
-  ),
-  createConnState: z.unknown().optional().describe(
-    "Function to create connection state. Receives context and connection params. Cannot be used with connState."
-  ),
-  vars: z.unknown().optional().describe(
-    "Initial ephemeral variables value. Cannot be used with createVars."
-  ),
-  createVars: z.unknown().optional().describe(
-    "Function to create ephemeral variables. Receives context and driver context. Cannot be used with vars."
-  ),
-  db: z.unknown().optional().describe("Database provider instance for the actor."),
-  onCreate: z.unknown().optional().describe(
-    "Called when the actor is first initialized. Use to initialize state."
-  ),
-  onDestroy: z.unknown().optional().describe("Called when the actor is destroyed."),
-  onWake: z.unknown().optional().describe(
-    "Called when the actor wakes up and is ready to receive connections and actions."
-  ),
-  onSleep: z.unknown().optional().describe(
-    "Called when the actor is stopping or sleeping. Use to clean up resources."
-  ),
-  onStateChange: z.unknown().optional().describe(
-    "Called when the actor's state changes. State changes within this hook won't trigger recursion."
-  ),
-  onBeforeConnect: z.unknown().optional().describe(
-    "Called before a client connects. Throw an error to reject the connection."
-  ),
-  onConnect: z.unknown().optional().describe("Called when a client successfully connects."),
-  onDisconnect: z.unknown().optional().describe("Called when a client disconnects."),
-  onBeforeActionResponse: z.unknown().optional().describe(
-    "Called before sending an action response. Use to transform output."
-  ),
-  onRequest: z.unknown().optional().describe(
-    "Called for raw HTTP requests to /actors/{name}/http/* endpoints."
-  ),
-  onWebSocket: z.unknown().optional().describe(
-    "Called for raw WebSocket connections to /actors/{name}/websocket/* endpoints."
-  ),
-  actions: z.record(z.string(), z.unknown()).optional().describe(
-    "Map of action name to handler function. Defaults to an empty object."
-  ),
-  options: DocActorOptionsSchema.optional()
-}).describe("Actor configuration passed to the actor() function.");
+} 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;
 
 // src/drivers/engine/actor-driver.ts
 import { idToStr, Runner } from "@rivetkit/engine-runner";
@@ -255,8 +110,8 @@ var EngineActorDriver = class {
   #runner;
   #actors = /* @__PURE__ */ new Map();
   #actorRouter;
-  #runnerStarted = promiseWithResolvers();
-  #runnerStopped = promiseWithResolvers();
+  #runnerStarted = promiseWithResolvers((reason) => logger().warn({ msg: "unhandled runner started promise rejection", reason }));
+  #runnerStopped = promiseWithResolvers((reason) => logger().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
@@ -358,9 +213,7 @@ var EngineActorDriver = class {
     }, delay);
     this.#runner.setAlarm(actor2.id, timestamp);
   }
-  async getDatabase(_actorId) {
-    return void 0;
-  }
+  // 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);
@@ -468,6 +321,7 @@ var EngineActorDriver = class {
     });
   }
   async #runnerOnActorStart(actorId, generation, actorConfig) {
+    var _a;
     logger().debug({
       msg: "runner actor starting",
       actorId,
@@ -482,42 +336,52 @@ var EngineActorDriver = class {
     let handler = this.#actors.get(actorId);
     if (!handler) {
       handler = {
-        actorStartPromise: promiseWithResolvers()
+        actorStartPromise: promiseWithResolvers((reason) => logger().warn({ msg: "unhandled actor start promise rejection", reason }))
       };
       this.#actors.set(actorId, handler);
     }
     const name = actorConfig.name;
     invariant(actorConfig.key, "actor should have a key");
     const key = deserializeActorKey(actorConfig.key);
-    const [persistDataBuffer] = await this.#runner.kvGet(actorId, [
-      KEYS.PERSIST_DATA
-    ]);
-    if (persistDataBuffer === null) {
-      const initialKvState = getInitialActorKvState(input);
-      await this.#runner.kvPut(actorId, initialKvState);
-      logger().debug({
-        msg: "initialized persist data for new actor",
-        actorId
-      });
-    } else {
-      logger().debug({
-        msg: "found existing persist data for actor",
+    try {
+      const [persistDataBuffer] = await this.#runner.kvGet(actorId, [
+        KEYS.PERSIST_DATA
+      ]);
+      if (persistDataBuffer === null) {
+        const initialKvState = getInitialActorKvState(input);
+        await this.#runner.kvPut(actorId, initialKvState);
+        logger().debug({
+          msg: "initialized persist data for new actor",
+          actorId
+        });
+      } else {
+        logger().debug({
+          msg: "found existing persist data for actor",
+          actorId,
+          dataSize: persistDataBuffer.byteLength
+        });
+      }
+      const definition = lookupInRegistry(this.#config, actorConfig.name);
+      handler.actor = await definition.instantiate();
+      await handler.actor.start(
+        this,
+        this.#inlineClient,
         actorId,
-        dataSize: persistDataBuffer.byteLength
-      });
+        name,
+        key,
+        "unknown"
+        // TODO: Add regions
+      );
+      logger().debug({ msg: "runner actor started", actorId, name, key });
+    } catch (innerError) {
+      const error = new Error(
+        `Failed to start actor ${actorId}: ${innerError}`,
+        { cause: innerError }
+      );
+      (_a = handler.actorStartPromise) == null ? void 0 : _a.reject(error);
+      handler.actorStartPromise = void 0;
+      throw error;
     }
-    const definition = lookupInRegistry(this.#config, actorConfig.name);
-    handler.actor = definition.instantiate();
-    await handler.actor.start(
-      this,
-      this.#inlineClient,
-      actorId,
-      name,
-      key,
-      "unknown"
-      // TODO: Add regions
-    );
-    logger().debug({ msg: "runner actor started", actorId, name, key });
   }
   async #runnerOnActorStop(actorId, generation) {
     logger().debug({ msg: "runner actor stopping", actorId, generation });
@@ -601,55 +465,55 @@ var EngineActorDriver = class {
     if (isRestoringHibernatable) {
       (_c = wsHandler.onRestore) == null ? void 0 : _c.call(wsHandler, wsContext);
     }
-    websocket.addEventListener("open", (event) => {
-      wsHandler.onOpen(event, wsContext);
+    websocket.addEventListener("open", (event3) => {
+      wsHandler.onOpen(event3, wsContext);
     });
-    websocket.addEventListener("message", (event) => {
+    websocket.addEventListener("message", (event3) => {
       var _a2, _b2;
       logger().debug({
         msg: "websocket message event listener triggered",
         connId: conn == null ? void 0 : conn.id,
         actorId: actor2 == null ? void 0 : actor2.id,
-        messageIndex: event.rivetMessageIndex,
+        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 = event.target) == null ? void 0 : _b2.__rivet_ws_id
+        eventTargetWsId: (_b2 = event3.target) == null ? void 0 : _b2.__rivet_ws_id
       });
       if (actor2 == null ? void 0 : actor2.isStopping) {
         logger().debug({
           msg: "ignoring ws message, actor is stopping",
           connId: conn == null ? void 0 : conn.id,
           actorId: actor2 == null ? void 0 : actor2.id,
-          messageIndex: event.rivetMessageIndex
+          messageIndex: event3.rivetMessageIndex
         });
         return;
       }
       logger().debug({
         msg: "calling wsHandler.onMessage",
         connId: conn == null ? void 0 : conn.id,
-        messageIndex: event.rivetMessageIndex
+        messageIndex: event3.rivetMessageIndex
       });
-      wsHandler.onMessage(event, wsContext);
+      wsHandler.onMessage(event3, wsContext);
       const hibernate = connStateManager == null ? void 0 : connStateManager.hibernatableData;
       if (hibernate && conn && actor2) {
         invariant(
-          typeof event.rivetMessageIndex === "number",
+          typeof event3.rivetMessageIndex === "number",
           "missing event.rivetMessageIndex"
         );
         const previousMsgIndex = hibernate.serverMessageIndex;
-        hibernate.serverMessageIndex = event.rivetMessageIndex;
+        hibernate.serverMessageIndex = event3.rivetMessageIndex;
         logger().info({
           msg: "persisting message index",
           connId: conn.id,
           previousMsgIndex,
-          newMsgIndex: event.rivetMessageIndex
+          newMsgIndex: event3.rivetMessageIndex
         });
         const entry = this.#hwsMessageIndex.get(conn.id);
         if (entry) {
-          const messageLength = getValueLength(event.data);
+          const messageLength = getValueLength(event3.data);
           entry.bufferedMessageSize += messageLength;
           if (entry.bufferedMessageSize >= CONN_BUFFERED_MESSAGE_SIZE_THRESHOLD) {
             entry.bufferedMessageSize = 0;
@@ -669,11 +533,11 @@ var EngineActorDriver = class {
         }
       }
     });
-    websocket.addEventListener("close", (event) => {
-      wsHandler.onClose(event, wsContext);
+    websocket.addEventListener("close", (event3) => {
+      wsHandler.onClose(event3, wsContext);
     });
-    websocket.addEventListener("error", (event) => {
-      wsHandler.onError(event, wsContext);
+    websocket.addEventListener("error", (event3) => {
+      wsHandler.onError(event3, wsContext);
     });
     if (isRestoringHibernatable) {
       logger().info({
@@ -847,12 +711,12 @@ var EngineActorDriver = class {
 };
 
 // src/drivers/engine/config.ts
-import { z as z2 } from "zod";
+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: z2.string().optional().transform((val) => val ?? getRivetRunnerKey()),
+  runnerKey: z.string().optional().transform((val) => val ?? getRivetRunnerKey()),
   /** How many actors this runner can run. */
-  totalSlots: z2.number().default(1e5)
+  totalSlots: z.number().default(1e5)
 });
 var EngineConfigSchemaTransformed = EngineConfigSchemaBase.transform(
   (config, ctx) => transformEngineConfig(config, ctx)
@@ -888,43 +752,43 @@ function createEngineDriver() {
 }
 
 // src/registry/config/legacy-runner.ts
-import { z as z3 } from "zod";
-var LegacyDriverConfigSchema = z3.object({
+import { z as z2 } from "zod/v4";
+var LegacyDriverConfigSchema = z2.object({
   /** Machine-readable name to identify this driver by. */
-  name: z3.string(),
-  manager: z3.custom(),
-  actor: z3.custom()
+  name: z2.string(),
+  manager: z2.custom(),
+  actor: z2.custom()
 });
-var LegacyRunnerConfigSchemaUnmerged = z3.object({
+var LegacyRunnerConfigSchemaUnmerged = z2.object({
   driver: LegacyDriverConfigSchema.optional(),
   /** @experimental */
-  maxIncomingMessageSize: z3.number().optional().default(65536),
+  maxIncomingMessageSize: z2.number().optional().default(65536),
   /** @experimental */
-  maxOutgoingMessageSize: z3.number().optional().default(1048576),
+  maxOutgoingMessageSize: z2.number().optional().default(1048576),
   /** @experimental */
   inspector: InspectorConfigSchema,
   /** @experimental */
-  disableDefaultServer: z3.boolean().optional().default(false),
+  disableDefaultServer: z2.boolean().optional().default(false),
   /** @experimental */
-  defaultServerPort: z3.number().default(6420),
+  defaultServerPort: z2.number().default(6420),
   /** @experimental */
-  runEngine: z3.boolean().optional().default(() => getRivetRunEngine()),
+  runEngine: z2.boolean().optional().default(() => getRivetRunEngine()),
   /** @experimental */
-  runEngineVersion: z3.string().optional().default(() => getRivetRunEngineVersion() ?? VERSION),
+  runEngineVersion: z2.string().optional().default(() => getRivetRunEngineVersion() ?? VERSION),
   /** @experimental */
-  overrideServerAddress: z3.string().optional(),
+  overrideServerAddress: z2.string().optional(),
   /** @experimental */
-  disableActorDriver: z3.boolean().optional().default(false),
+  disableActorDriver: z2.boolean().optional().default(false),
   /**
    * @experimental
    *
    * Whether to run runners normally or have them managed
    * serverlessly (by the Rivet Engine for example).
    */
-  runnerKind: z3.enum(["serverless", "normal"]).optional().default(
+  runnerKind: z2.enum(["serverless", "normal"]).optional().default(
     () => getRivetRunnerKind() === "serverless" ? "serverless" : "normal"
   ),
-  totalSlots: z3.number().optional(),
+  totalSlots: z2.number().optional(),
   /**
    * @experimental
    *
@@ -932,18 +796,18 @@ var LegacyRunnerConfigSchemaUnmerged = z3.object({
    * For example, if the base path is `/api`, then the route `/actors` will be
    * available at `/api/actors`.
    */
-  basePath: z3.string().optional().default("/"),
+  basePath: z2.string().optional().default("/"),
   /**
    * @experimental
    *
    * Disable welcome message.
    * */
-  noWelcome: z3.boolean().optional().default(false),
+  noWelcome: z2.boolean().optional().default(false),
   /**
    * @experimental
    * */
-  logging: z3.object({
-    baseLogger: z3.custom().optional(),
+  logging: z2.object({
+    baseLogger: z2.custom().optional(),
     level: LogLevelSchema.optional()
   }).optional().default(() => ({})),
   /**
@@ -953,26 +817,26 @@ var LegacyRunnerConfigSchemaUnmerged = z3.object({
    * Can only be used when runnerKind is "serverless".
    * If true, uses default configuration. Can also provide custom configuration.
    */
-  autoConfigureServerless: z3.union([
-    z3.boolean(),
-    z3.object({
-      url: z3.string().optional(),
-      headers: z3.record(z3.string(), z3.string()).optional(),
-      maxRunners: z3.number().optional(),
-      minRunners: z3.number().optional(),
-      requestLifespan: z3.number().optional(),
-      runnersMargin: z3.number().optional(),
-      slotsPerRunner: z3.number().optional(),
-      metadata: z3.record(z3.string(), z3.unknown()).optional()
+  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: z3.custom().optional(),
+  getUpgradeWebSocket: z2.custom().optional(),
   /** @experimental */
-  token: z3.string().optional().transform((v) => v || getRivetToken())
+  token: z2.string().optional().transform((v) => v || getRivetToken())
 }).merge(EngineConfigSchemaBase);
 var LegacyRunnerConfigSchemaTransformed = LegacyRunnerConfigSchemaUnmerged.transform((config, ctx) => ({
   ...config,
@@ -1002,8 +866,13 @@ function chooseDefaultDriver(config) {
     });
     return createEngineDriver();
   }
-  loggerWithoutContext().debug({ msg: "using default file system driver" });
-  return createFileSystemOrMemoryDriver(true);
+  loggerWithoutContext().debug({
+    msg: "using default file system driver",
+    storagePath: config.storagePath
+  });
+  return createFileSystemOrMemoryDriver(true, {
+    path: config.storagePath
+  });
 }
 
 // src/engine-process/log.ts
@@ -1376,12 +1245,8 @@ async function waitForEngineHealth() {
 import { createMiddleware } from "hono/factory";
 function getInspectorUrl(config, managerPort) {
   if (!config.inspector.enabled) return void 0;
-  const url = new URL("https://inspect.rivet.dev");
-  const endpoint = config.inspector.defaultEndpoint ?? (config.managerPort !== 6420 ? `http://127.0.0.1:${managerPort}` : void 0);
-  if (endpoint) {
-    url.searchParams.set("u", endpoint);
-  }
-  return url.href;
+  const base = config.inspector.defaultEndpoint ?? `http://127.0.0.1:${managerPort}`;
+  return new URL("/ui/", base).href;
 }
 
 // src/serverless/log.ts
@@ -1579,19 +1444,19 @@ async function serveBun(config, managerPort, app) {
 import invariant3 from "invariant";
 
 // src/manager/router-schema.ts
-import { z as z4 } from "zod";
-var ServerlessStartHeadersSchema = z4.object({
-  endpoint: z4.string({
+import { z as z3 } from "zod/v4";
+var ServerlessStartHeadersSchema = z3.object({
+  endpoint: z3.string({
     error: "x-rivet-endpoint header is required"
   }),
-  token: z4.string({ error: "x-rivet-token header must be a string" }).optional(),
-  totalSlots: z4.coerce.number({
+  token: z3.string({ error: "x-rivet-token header must be a string" }).optional(),
+  totalSlots: z3.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: z4.string({
+  runnerName: z3.string({
     error: "x-rivet-runner-name header is required"
   }),
-  namespace: z4.string({
+  namespace: z3.string({
     error: "x-rivet-namespace-name header is required"
   })
 });
@@ -1771,6 +1636,7 @@ var Runtime = class _Runtime {
         version: config.serverless.engineVersion
       });
     } else if (config.serveManager) {
+      const configuredManagerPort = config.managerPort;
       let upgradeWebSocket;
       const getUpgradeWebSocket = () => upgradeWebSocket;
       managerDriver.setGetUpgradeWebSocket(getUpgradeWebSocket);
@@ -1784,6 +1650,11 @@ var Runtime = class _Runtime {
         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 crossPlatformServe(
         config,
         managerPort,
@@ -1886,9 +1757,11 @@ var Registry = class {
   #runtimePromise;
   constructor(config) {
     this.#config = config;
-    setTimeout(() => {
-      this.#ensureRuntime();
-    }, 0);
+    if (getNodeEnv() !== "test") {
+      setTimeout(() => {
+        this.#ensureRuntime();
+      }, 0);
+    }
   }
   /** Creates runtime if not already created. Idempotent. */
   #ensureRuntime() {
@@ -1989,8 +1862,10 @@ function setup(input) {
 
 export {
   actor,
+  event2 as event,
+  queue2 as queue,
   createEngineDriver,
   Registry,
   setup
 };
-//# sourceMappingURL=chunk-JDAD2YFA.js.map
+//# sourceMappingURL=chunk-5ESWDTHJ.js.map