rivetkit 2.0.20 → 2.0.22-rc.1

package/dist/tsup/{chunk-L3YPHXPE.js → chunk-4B25D5OW.js}

@@ -4,7 +4,7 @@ import {
   inspectorLogger,
   isInspectorEnabled,
   secureInspector
-} from "./chunk-RI4YHZZW.js";
+} from "./chunk-NDLOG2JH.js";
 import {
   ActorDefinition,
   RemoteManagerDriver,
@@ -17,10 +17,10 @@ import {
   lookupInRegistry,
   serializeActorKey,
   updateRunnerConfig
-} from "./chunk-GQ5WTE64.js";
+} from "./chunk-FETQGZN4.js";
 import {
   CreateActorSchema
-} from "./chunk-QRUGCDA5.js";
+} from "./chunk-RPI45FGS.js";
 import {
   ActionContext,
   ClientConfigSchema,
@@ -32,7 +32,7 @@ import {
   createVersionedDataHandler,
   parseMessage,
   serializeEmptyPersistData
-} from "./chunk-7ACKZS3T.js";
+} from "./chunk-I7EJWHYV.js";
 import {
   EncodingSchema,
   HEADER_ACTOR_ID,
@@ -58,12 +58,12 @@ import {
   generateRandomString,
   loggerWithoutContext,
   serializeWithEncoding
-} from "./chunk-YFFCPYHY.js";
+} from "./chunk-ZVEDMBFT.js";
 import {
   configureBaseLogger,
   configureDefaultLogger,
   getLogger
-} from "./chunk-ER5OT3SQ.js";
+} from "./chunk-GJPOIJHZ.js";
 import {
   VERSION,
   assertUnreachable,
@@ -75,7 +75,7 @@ import {
   promiseWithResolvers,
   setLongTimeout,
   stringifyError
-} from "./chunk-QMVCFQ37.js";
+} from "./chunk-JKNDUKFI.js";
 import {
   ActorAlreadyExists,
   ConnNotFound,
@@ -237,7 +237,11 @@ var HonoWebSocketAdapter = class {
             msg: "failed to convert blob to arraybuffer",
             error
           });
-          this.#fireEvent("error", { type: "error", target: this, error });
+          this.#fireEvent("error", {
+            type: "error",
+            target: this,
+            error
+          });
         });
       } else {
         logger().warn({
@@ -364,7 +368,10 @@ var HonoWebSocketAdapter = class {
         try {
           listener(event);
         } catch (error) {
-          logger().error({ msg: `error in ${type} event listener`, error });
+          logger().error({
+            msg: `error in ${type} event listener`,
+            error
+          });
         }
       }
     }
@@ -374,7 +381,10 @@ var HonoWebSocketAdapter = class {
           try {
             this.#onopen(event);
           } catch (error) {
-            logger().error({ msg: "error in onopen handler", error });
+            logger().error({
+              msg: "error in onopen handler",
+              error
+            });
           }
         }
         break;
@@ -383,7 +393,10 @@ var HonoWebSocketAdapter = class {
           try {
             this.#onclose(event);
           } catch (error) {
-            logger().error({ msg: "error in onclose handler", error });
+            logger().error({
+              msg: "error in onclose handler",
+              error
+            });
           }
         }
         break;
@@ -392,7 +405,10 @@ var HonoWebSocketAdapter = class {
           try {
             this.#onerror(event);
           } catch (error) {
-            logger().error({ msg: "error in onerror handler", error });
+            logger().error({
+              msg: "error in onerror handler",
+              error
+            });
           }
         }
         break;
@@ -401,7 +417,10 @@ var HonoWebSocketAdapter = class {
           try {
             this.#onmessage(event);
           } catch (error) {
-            logger().error({ msg: "error in onmessage handler", error });
+            logger().error({
+              msg: "error in onmessage handler",
+              error
+            });
           }
         }
         break;
@@ -664,7 +683,10 @@ async function handleSseConnect(c, _runConfig, actorDriver, actorId) {
         await stream.sleep(SSE_PING_INTERVAL);
       }
     } catch (error) {
-      loggerWithoutContext().error({ msg: "error in sse connection", error });
+      loggerWithoutContext().error({
+        msg: "error in sse connection",
+        error
+      });
       if (conn && actor2 !== void 0) {
         actor2.__connDisconnected(conn, false, socketId);
       }
@@ -937,7 +959,9 @@ function handleHealthRequest(c) {
 
 // src/actor/router.ts
 function createActorRouter(runConfig, actorDriver, isTest) {
-  const router = new Hono({ strict: false });
+  const router = new Hono({
+    strict: false
+  });
   router.use("*", loggerMiddleware(loggerWithoutContext()));
   router.get("/", (c) => {
     return c.text(
@@ -983,15 +1007,23 @@ function createActorRouter(runConfig, actorDriver, isTest) {
           const protocolList = protocols.split(",").map((p) => p.trim());
           for (const protocol of protocolList) {
             if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
-              encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
+              encodingRaw = protocol.substring(
+                WS_PROTOCOL_ENCODING.length
+              );
             } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
               connParamsRaw = decodeURIComponent(
-                protocol.substring(WS_PROTOCOL_CONN_PARAMS.length)
+                protocol.substring(
+                  WS_PROTOCOL_CONN_PARAMS.length
+                )
               );
             } else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
-              connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
+              connIdRaw = protocol.substring(
+                WS_PROTOCOL_CONN_ID.length
+              );
             } else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
-              connTokenRaw = protocol.substring(WS_PROTOCOL_CONN_TOKEN.length);
+              connTokenRaw = protocol.substring(
+                WS_PROTOCOL_CONN_TOKEN.length
+              );
             }
           }
         }
@@ -1020,7 +1052,13 @@ function createActorRouter(runConfig, actorDriver, isTest) {
   });
   router.post("/action/:action", async (c) => {
     const actionName = c.req.param("action");
-    return handleAction(c, runConfig, actorDriver, actionName, c.env.actorId);
+    return handleAction(
+      c,
+      runConfig,
+      actorDriver,
+      actionName,
+      c.env.actorId
+    );
   });
   router.post("/connections/message", async (c) => {
     const connId = c.req.header(HEADER_CONN_ID);
@@ -1110,7 +1148,10 @@ function createActorRouter(runConfig, actorDriver, isTest) {
         secureInspector(runConfig),
         async (c, next) => {
           const inspector = (await actorDriver.loadActor(c.env.actorId)).inspector;
-          invariant2(inspector, "inspector not supported on this platform");
+          invariant2(
+            inspector,
+            "inspector not supported on this platform"
+          );
           c.set("inspector", inspector);
           return next();
         }
@@ -1213,7 +1254,10 @@ var InlineWebSocketAdapter2 = class {
     logger3().debug({ msg: "closing fake websocket", code, reason });
     this.#readyState = this.CLOSING;
     try {
-      this.#handler.onClose({ code, reason, wasClean: true }, this.#wsContext);
+      this.#handler.onClose(
+        { code, reason, wasClean: true },
+        this.#wsContext
+      );
     } catch (err) {
       logger3().error({ msg: "error closing websocket", error: err });
     } finally {
@@ -1352,7 +1396,10 @@ var InlineWebSocketAdapter2 = class {
           try {
             this.#onopen(event);
           } catch (error) {
-            logger3().error({ msg: "error in onopen handler", error });
+            logger3().error({
+              msg: "error in onopen handler",
+              error
+            });
           }
         }
         break;
@@ -1361,7 +1408,10 @@ var InlineWebSocketAdapter2 = class {
           try {
             this.#onclose(event);
           } catch (error) {
-            logger3().error({ msg: "error in onclose handler", error });
+            logger3().error({
+              msg: "error in onclose handler",
+              error
+            });
           }
         }
         break;
@@ -1370,7 +1420,10 @@ var InlineWebSocketAdapter2 = class {
           try {
             this.#onerror(event);
           } catch (error) {
-            logger3().error({ msg: "error in onerror handler", error });
+            logger3().error({
+              msg: "error in onerror handler",
+              error
+            });
           }
         }
         break;
@@ -1379,7 +1432,10 @@ var InlineWebSocketAdapter2 = class {
           try {
             this.#onmessage(event);
           } catch (error) {
-            logger3().error({ msg: "error in onmessage handler", error });
+            logger3().error({
+              msg: "error in onmessage handler",
+              error
+            });
           }
         }
         break;
@@ -1494,8 +1550,8 @@ var EngineActorDriver = class {
   #version = 1;
   // Version for the runner protocol
   #alarmTimeout;
-  #runnerStarted = Promise.withResolvers();
-  #runnerStopped = Promise.withResolvers();
+  #runnerStarted = promiseWithResolvers();
+  #runnerStopped = promiseWithResolvers();
   constructor(registryConfig, runConfig, managerDriver, inlineClient) {
     this.#registryConfig = registryConfig;
     this.#runConfig = runConfig;
@@ -1567,7 +1623,8 @@ var EngineActorDriver = class {
   }
   async #loadActorHandler(actorId) {
     const handler = this.#actors.get(actorId);
-    if (!handler) throw new Error(`Actor handler does not exist ${actorId}`);
+    if (!handler)
+      throw new Error(`Actor handler does not exist ${actorId}`);
     if (handler.actorStartPromise) await handler.actorStartPromise.promise;
     if (!handler.actor) throw new Error("Actor should be loaded");
     return handler;
@@ -1607,18 +1664,18 @@ var EngineActorDriver = class {
     return void 0;
   }
   // Runner lifecycle callbacks
-  async #runnerOnActorStart(actorId, generation, runConfig) {
+  async #runnerOnActorStart(actorId, generation, actorConfig) {
     var _a;
     logger4().debug({
       msg: "runner actor starting",
       actorId,
-      name: runConfig.name,
-      key: runConfig.key,
+      name: actorConfig.name,
+      key: actorConfig.key,
       generation
     });
     let input;
-    if (runConfig.input) {
-      input = cbor3.decode(runConfig.input);
+    if (actorConfig.input) {
+      input = cbor3.decode(actorConfig.input);
     }
     let handler = this.#actors.get(actorId);
     if (!handler) {
@@ -1632,10 +1689,13 @@ var EngineActorDriver = class {
       ]);
       handler.persistedData = persistedValue !== null ? persistedValue : serializeEmptyPersistData(input);
     }
-    const name = runConfig.name;
-    invariant3(runConfig.key, "actor should have a key");
-    const key = deserializeActorKey(runConfig.key);
-    const definition = lookupInRegistry(this.#registryConfig, runConfig.name);
+    const name = actorConfig.name;
+    invariant3(actorConfig.key, "actor should have a key");
+    const key = deserializeActorKey(actorConfig.key);
+    const definition = lookupInRegistry(
+      this.#registryConfig,
+      actorConfig.name
+    );
     handler.actor = definition.instantiate();
     await handler.actor.start(
       this,
@@ -1659,7 +1719,7 @@ var EngineActorDriver = class {
     }
     logger4().debug({ msg: "runner actor stopped", actorId });
   }
-  async #runnerFetch(actorId, request) {
+  async #runnerFetch(runner, actorId, request) {
     logger4().debug({
       msg: "runner fetch",
       actorId,
@@ -1668,20 +1728,20 @@ var EngineActorDriver = class {
     });
     return await this.#actorRouter.fetch(request, { actorId });
   }
-  async #runnerWebSocket(actorId, websocketRaw, request) {
+  async #runnerWebSocket(runner, actorId, websocketRaw, request) {
     const websocket = websocketRaw;
     logger4().debug({ msg: "runner websocket", actorId, url: request.url });
     const url = new URL(request.url);
     const protocols = request.headers.get("sec-websocket-protocol");
-    if (protocols === null)
-      throw new Error(`Missing sec-websocket-protocol header`);
     let encodingRaw;
     let connParamsRaw;
     if (protocols) {
       const protocolList = protocols.split(",").map((p) => p.trim());
       for (const protocol of protocolList) {
         if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
-          encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
+          encodingRaw = protocol.substring(
+            WS_PROTOCOL_ENCODING.length
+          );
         } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
           connParamsRaw = decodeURIComponent(
             protocol.substring(WS_PROTOCOL_CONN_PARAMS.length)
@@ -1720,10 +1780,12 @@ var EngineActorDriver = class {
       wsContext.close(1011, `${err}`);
     });
     if (websocket.readyState === 1) {
-      wsHandlerPromise.then((x) => {
-        var _a;
-        return (_a = x.onOpen) == null ? void 0 : _a.call(x, new Event("open"), wsContext);
-      });
+      wsHandlerPromise.then(
+        (x) => {
+          var _a;
+          return (_a = x.onOpen) == null ? void 0 : _a.call(x, new Event("open"), wsContext);
+        }
+      );
     } else {
       websocket.addEventListener("open", (event) => {
         wsHandlerPromise.then((x) => {
@@ -1759,13 +1821,18 @@ var EngineActorDriver = class {
     await this.#runner.shutdown(immediate);
   }
   async serverlessHandleStart(c) {
-    await this.#runnerStarted.promise;
     return streamSSE2(c, async (stream) => {
-      stream.onAbort(() => this.shutdown(true));
+      stream.onAbort(() => {
+      });
+      c.req.raw.signal.addEventListener("abort", () => {
+        logger4().debug("SSE aborted, shutting down runner");
+        this.shutdown(true);
+      });
+      await this.#runnerStarted.promise;
       const payload = this.#runner.getServerlessInitPacket();
       invariant3(payload, "runnerId not set");
       await stream.writeSSE({ data: payload });
-      return this.#runnerStopped.promise;
+      await this.#runnerStopped.promise;
     });
   }
 };
@@ -2001,7 +2068,12 @@ function getDataPath(appName) {
         appName
       );
     case "darwin":
-      return path.join(homeDir, "Library", "Application Support", appName);
+      return path.join(
+        homeDir,
+        "Library",
+        "Application Support",
+        appName
+      );
     default:
       return path.join(
         process.env.XDG_DATA_HOME || path.join(homeDir, ".local", "share"),
@@ -2053,7 +2125,10 @@ var FileSystemGlobalState = class {
       try {
         this.#cleanupTempFilesSync();
       } catch (err) {
-        logger5().error({ msg: "failed to cleanup temp files", error: err });
+        logger5().error({
+          msg: "failed to cleanup temp files",
+          error: err
+        });
       }
     } else {
       logger5().debug({ msg: "memory driver ready" });
@@ -2083,7 +2158,11 @@ var FileSystemGlobalState = class {
         const state = await this.loadActorStateOrError(actorId);
         yield state;
       } catch (error) {
-        logger5().error({ msg: "failed to load actor state", actorId, error });
+        logger5().error({
+          msg: "failed to load actor state",
+          actorId,
+          error
+        });
       }
     }
   }
@@ -2117,7 +2196,9 @@ var FileSystemGlobalState = class {
       name,
       key,
       createdAt: BigInt(Date.now()),
-      persistedData: bufferToArrayBuffer(serializeEmptyPersistData(input))
+      persistedData: bufferToArrayBuffer(
+        serializeEmptyPersistData(input)
+      )
     };
     await this.writeActor(actorId, entry.state);
     return entry;
@@ -2153,7 +2234,9 @@ var FileSystemGlobalState = class {
         entry.loadPromise = void 0;
         return entry;
       }
-      const error = new Error(`Failed to load actor state: ${innerError}`);
+      const error = new Error(
+        `Failed to load actor state: ${innerError}`
+      );
       throw error;
     }
   }
@@ -2165,7 +2248,9 @@ var FileSystemGlobalState = class {
         name,
         key,
         createdAt: BigInt(Date.now()),
-        persistedData: bufferToArrayBuffer(serializeEmptyPersistData(input))
+        persistedData: bufferToArrayBuffer(
+          serializeEmptyPersistData(input)
+        )
       };
       await this.writeActor(actorId, entry.state);
     }
@@ -2180,7 +2265,8 @@ var FileSystemGlobalState = class {
     const actor2 = this.#actors.get(actorId);
     invariant4(actor2, `tried to sleep ${actorId}, does not exist`);
     if (actor2.loadPromise) await actor2.loadPromise.catch();
-    if ((_a = actor2.startPromise) == null ? void 0 : _a.promise) await actor2.startPromise.promise.catch();
+    if ((_a = actor2.startPromise) == null ? void 0 : _a.promise)
+      await actor2.startPromise.promise.catch();
     actor2.removed = true;
     invariant4(actor2.actor, "actor should be loaded");
     await actor2.actor._stop();
@@ -2209,7 +2295,9 @@ var FileSystemGlobalState = class {
           actorId,
           timestamp: BigInt(timestamp)
         };
-        const data = ACTOR_ALARM_VERSIONED.serializeWithEmbeddedVersion(alarmData);
+        const data = ACTOR_ALARM_VERSIONED.serializeWithEmbeddedVersion(
+          alarmData
+        );
         await fs2.writeFile(tempPath, data);
         await fs2.rename(tempPath, alarmPath);
       } catch (error) {
@@ -2217,7 +2305,11 @@ var FileSystemGlobalState = class {
           await fs2.unlink(tempPath);
         } catch {
         }
-        logger5().error({ msg: "failed to write alarm", actorId, error });
+        logger5().error({
+          msg: "failed to write alarm",
+          actorId,
+          error
+        });
         throw new Error(`Failed to write alarm: ${error}`);
       }
     }
@@ -2246,7 +2338,11 @@ var FileSystemGlobalState = class {
         await fs2.unlink(tempPath);
       } catch {
       }
-      logger5().error({ msg: "failed to save actor state", actorId, error });
+      logger5().error({
+        msg: "failed to save actor state",
+        actorId,
+        error
+      });
       throw new Error(`Failed to save actor state: ${error}`);
     }
   }
@@ -2270,7 +2366,10 @@ var FileSystemGlobalState = class {
     try {
       this.#loadAlarmsSync();
     } catch (err) {
-      logger5().error({ msg: "failed to load alarms on startup", error: err });
+      logger5().error({
+        msg: "failed to load alarms on startup",
+        error: err
+      });
     }
   }
   async startActor(registryConfig, runConfig, inlineClient, actorDriver, actorId) {
@@ -2291,7 +2390,10 @@ var FileSystemGlobalState = class {
     }
     entry.startPromise = promiseWithResolvers();
     try {
-      const definition = lookupInRegistry(registryConfig, entry.state.name);
+      const definition = lookupInRegistry(
+        registryConfig,
+        entry.state.name
+      );
       entry.actor = definition.instantiate();
       await entry.actor.start(
         actorDriver,
@@ -2343,9 +2445,15 @@ var FileSystemGlobalState = class {
           );
           const timestamp = Number(alarmData.timestamp);
           if (Number.isFinite(timestamp)) {
-            this.#scheduleAlarmTimeout(alarmData.actorId, timestamp);
+            this.#scheduleAlarmTimeout(
+              alarmData.actorId,
+              timestamp
+            );
           } else {
-            logger5().debug({ msg: "invalid alarm file contents", file });
+            logger5().debug({
+              msg: "invalid alarm file contents",
+              file
+            });
           }
         } catch (err) {
           logger5().error({
@@ -2356,7 +2464,10 @@ var FileSystemGlobalState = class {
         }
       }
     } catch (err) {
-      logger5().error({ msg: "failed to list alarms directory", error: err });
+      logger5().error({
+        msg: "failed to list alarms directory",
+        error: err
+      });
     }
   }
   /**
@@ -2396,7 +2507,8 @@ var FileSystemGlobalState = class {
       try {
         logger5().debug({ msg: "triggering alarm", actorId, timestamp });
         const loaded = await this.loadActor(actorId);
-        if (!loaded.state) throw new Error(`Actor does not exist: ${actorId}`);
+        if (!loaded.state)
+          throw new Error(`Actor does not exist: ${actorId}`);
         const runnerParams = this.#runnerParams;
         invariant4(runnerParams, "missing runner params");
         if (!loaded.actor) {
@@ -2486,7 +2598,10 @@ function createManagerInspectorRouter() {
       });
       return c.json(actors, 200);
     } catch (error) {
-      inspectorLogger().error({ msg: "Failed to fetch actors", error });
+      inspectorLogger().error({
+        msg: "Failed to fetch actors",
+        error
+      });
       return c.json("Failed to fetch actors", 500);
     }
   }).post("/actors", sValidator("json", CreateActorSchema), async (c) => {
@@ -2540,7 +2655,9 @@ var FileSystemManagerDriver = class {
           name: actorState.name,
           key: actorState.key,
           startedAt,
-          createdAt: new Date(Number(actorState.createdAt)).toISOString(),
+          createdAt: new Date(
+            Number(actorState.createdAt)
+          ).toISOString(),
           features: [
             "state" /* State */,
             "connections" /* Connections */,
@@ -2574,14 +2691,18 @@ var FileSystemManagerDriver = class {
             }
           },
           getBuilds: async () => {
-            return Object.keys(this.#registryConfig.use).map((name) => ({
-              name
-            }));
+            return Object.keys(this.#registryConfig.use).map(
+              (name) => ({
+                name
+              })
+            );
           },
           createActor: async (input) => {
             const { actorId } = await this.createActor(input);
             try {
-              const result = await this.#state.loadActorStateOrError(actorId);
+              const result = await this.#state.loadActorStateOrError(
+                actorId
+              );
               return transformActor2(result);
             } catch {
               return null;
@@ -2673,7 +2794,9 @@ var FileSystemManagerDriver = class {
       throw new Error(`Unreachable path: ${path4}`);
     }
   }
-  async getForId({ actorId }) {
+  async getForId({
+    actorId
+  }) {
     const actor2 = await this.#state.loadActor(actorId);
     if (!actor2.state) {
       return void 0;
@@ -2685,7 +2808,11 @@ var FileSystemManagerDriver = class {
         key: actor2.state.key
       };
     } catch (error) {
-      logger5().error({ msg: "failed to read actor state", actorId, error });
+      logger5().error({
+        msg: "failed to read actor state",
+        actorId,
+        error
+      });
       return void 0;
     }
   }
@@ -2767,7 +2894,12 @@ function createFileSystemOrMemoryDriver(persist = true, customPath) {
         inlineClient,
         state
       );
-      state.onRunnerStart(registryConfig, runConfig, inlineClient, actorDriver);
+      state.onRunnerStart(
+        registryConfig,
+        runConfig,
+        inlineClient,
+        actorDriver
+      );
       return actorDriver;
     }
   };
@@ -2823,7 +2955,10 @@ var ENGINE_ENDPOINT = `http://localhost:${ENGINE_PORT}`;
 var ENGINE_BASE_URL = "https://releases.rivet.gg/engine";
 var ENGINE_BINARY_NAME = "rivet-engine";
 async function ensureEngineProcess(options) {
-  logger6().debug({ msg: "ensuring engine process", version: options.version });
+  logger6().debug({
+    msg: "ensuring engine process",
+    version: options.version
+  });
   const storageRoot = getStoragePath();
   const binDir = path3.join(storageRoot, "bin");
   const varDir = path3.join(storageRoot, "var");
@@ -3003,12 +3138,18 @@ function resolveTargetTripletFor(platform, arch) {
       break;
     case "linux":
       if (arch === "x64") {
-        return { targetTriplet: "x86_64-unknown-linux-musl", extension: "" };
+        return {
+          targetTriplet: "x86_64-unknown-linux-musl",
+          extension: ""
+        };
       }
       break;
     case "win32":
       if (arch === "x64") {
-        return { targetTriplet: "x86_64-pc-windows-gnu", extension: ".exe" };
+        return {
+          targetTriplet: "x86_64-pc-windows-gnu",
+          extension: ".exe"
+        };
       }
       break;
   }
@@ -3083,7 +3224,9 @@ async function waitForEngineHealth() {
         attempt: i + 1,
         maxRetries
       });
-      await new Promise((resolve) => setTimeout(resolve, HEALTH_INTERVAL));
+      await new Promise(
+        (resolve) => setTimeout(resolve, HEALTH_INTERVAL)
+      );
     }
   }
   throw new Error(`engine health check failed after ${maxRetries} retries`);
@@ -3124,6 +3267,7 @@ var ActorsListResponseSchema = z4.object({
   actors: z4.array(ActorSchema)
 });
 var ActorsCreateRequestSchema = z4.object({
+  datacenter: z4.string().optional(),
   name: z4.string(),
   runner_name_selector: z4.string(),
   crash_policy: z4.string(),
@@ -3134,6 +3278,7 @@ var ActorsCreateResponseSchema = z4.object({
   actor: ActorSchema
 });
 var ActorsGetOrCreateRequestSchema = z4.object({
+  datacenter: z4.string().optional(),
   name: z4.string(),
   key: z4.string(),
   runner_name_selector: z4.string(),
@@ -3147,6 +3292,76 @@ var ActorsGetOrCreateResponseSchema = z4.object({
 var ActorsDeleteResponseSchema = z4.object({});
 
 // src/manager/gateway.ts
+async function handleWebSocketGatewayPathBased(runConfig, managerDriver, c, actorPathInfo) {
+  var _a;
+  const upgradeWebSocket = (_a = runConfig.getUpgradeWebSocket) == null ? void 0 : _a.call(runConfig);
+  if (!upgradeWebSocket) {
+    throw new WebSocketsNotEnabled();
+  }
+  const protocols = c.req.header("sec-websocket-protocol");
+  let encodingRaw;
+  let connParamsRaw;
+  let connIdRaw;
+  let connTokenRaw;
+  if (protocols) {
+    const protocolList = protocols.split(",").map((p) => p.trim());
+    for (const protocol of protocolList) {
+      if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
+        encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
+      } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
+        connParamsRaw = decodeURIComponent(
+          protocol.substring(WS_PROTOCOL_CONN_PARAMS.length)
+        );
+      } else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
+        connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
+      } else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
+        connTokenRaw = protocol.substring(
+          WS_PROTOCOL_CONN_TOKEN.length
+        );
+      }
+    }
+  }
+  logger().debug({
+    msg: "proxying websocket to actor via path-based routing",
+    actorId: actorPathInfo.actorId,
+    path: actorPathInfo.remainingPath,
+    encoding: encodingRaw
+  });
+  const encoding = encodingRaw || "json";
+  const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
+  return await managerDriver.proxyWebSocket(
+    c,
+    actorPathInfo.remainingPath,
+    actorPathInfo.actorId,
+    encoding,
+    // Will be validated by driver
+    connParams,
+    connIdRaw,
+    connTokenRaw
+  );
+}
+async function handleHttpGatewayPathBased(managerDriver, c, actorPathInfo) {
+  logger().debug({
+    msg: "proxying request to actor via path-based routing",
+    actorId: actorPathInfo.actorId,
+    path: actorPathInfo.remainingPath,
+    method: c.req.method
+  });
+  const proxyHeaders = new Headers(c.req.raw.headers);
+  const proxyUrl = new URL(`http://actor${actorPathInfo.remainingPath}`);
+  const proxyRequest = new Request(proxyUrl, {
+    method: c.req.raw.method,
+    headers: proxyHeaders,
+    body: c.req.raw.body,
+    signal: c.req.raw.signal,
+    duplex: "half"
+  });
+  return await managerDriver.proxyRequest(
+    c,
+    proxyRequest,
+    actorPathInfo.actorId
+  );
+}
 async function actorGateway(runConfig, managerDriver, c, next) {
   if (c.req.path.startsWith("/.test/")) {
     return next();
@@ -3158,6 +3373,28 @@ async function actorGateway(runConfig, managerDriver, c, next) {
       strippedPath = "/" + strippedPath;
     }
   }
+  const pathWithQuery = c.req.url.includes("?") ? strippedPath + c.req.url.substring(c.req.url.indexOf("?")) : strippedPath;
+  const actorPathInfo = parseActorPath(pathWithQuery);
+  if (actorPathInfo) {
+    logger().debug({
+      msg: "routing using path-based actor routing",
+      actorPathInfo
+    });
+    const isWebSocket = c.req.header("upgrade") === "websocket";
+    if (isWebSocket) {
+      return await handleWebSocketGatewayPathBased(
+        runConfig,
+        managerDriver,
+        c,
+        actorPathInfo
+      );
+    }
+    return await handleHttpGatewayPathBased(
+      managerDriver,
+      c,
+      actorPathInfo
+    );
+  }
   if (c.req.header("upgrade") === "websocket") {
     return await handleWebSocketGateway(
       runConfig,
@@ -3197,7 +3434,9 @@ async function handleWebSocketGateway(runConfig, managerDriver, c, strippedPath)
       } else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
         connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
       } else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
-        connTokenRaw = protocol.substring(WS_PROTOCOL_CONN_TOKEN.length);
+        connTokenRaw = protocol.substring(
+          WS_PROTOCOL_CONN_TOKEN.length
+        );
       }
     }
   }
@@ -3256,6 +3495,73 @@ async function handleHttpGateway(managerDriver, c, next, strippedPath) {
   });
   return await managerDriver.proxyRequest(c, proxyRequest, actorId);
 }
+function parseActorPath(path4) {
+  const queryPos = path4.indexOf("?");
+  const fragmentPos = path4.indexOf("#");
+  let queryString = "";
+  if (queryPos !== -1) {
+    if (fragmentPos !== -1 && queryPos < fragmentPos) {
+      queryString = path4.slice(queryPos, fragmentPos);
+    } else {
+      queryString = path4.slice(queryPos);
+    }
+  }
+  let basePath = path4;
+  if (queryPos !== -1) {
+    basePath = path4.slice(0, queryPos);
+  } else if (fragmentPos !== -1) {
+    basePath = path4.slice(0, fragmentPos);
+  }
+  if (basePath.includes("//")) {
+    return null;
+  }
+  const segments = basePath.split("/").filter((s) => s.length > 0);
+  if (segments.length < 4) {
+    return null;
+  }
+  if (segments[0] !== "gateway" || segments[1] !== "actors") {
+    return null;
+  }
+  if (segments[2].length === 0) {
+    return null;
+  }
+  const actorId = segments[2];
+  let token;
+  let remainingPathStartIdx;
+  if (segments.length >= 6 && segments[3] === "tokens" && segments[5] === "route") {
+    if (segments[4].length === 0) {
+      return null;
+    }
+    token = segments[4];
+    remainingPathStartIdx = 6;
+  } else if (segments.length >= 4 && segments[3] === "route") {
+    token = void 0;
+    remainingPathStartIdx = 4;
+  } else {
+    return null;
+  }
+  let prefixLen = 0;
+  for (let i = 0; i < remainingPathStartIdx; i++) {
+    prefixLen += 1 + segments[i].length;
+  }
+  let remainingBase;
+  if (prefixLen < basePath.length) {
+    remainingBase = basePath.slice(prefixLen);
+  } else {
+    remainingBase = "/";
+  }
+  let remainingPath;
+  if (remainingBase.length === 0 || !remainingBase.startsWith("/")) {
+    remainingPath = `/${remainingBase}${queryString}`;
+  } else {
+    remainingPath = `${remainingBase}${queryString}`;
+  }
+  return {
+    actorId,
+    token,
+    remainingPath
+  };
+}
 async function createTestWebSocketProxy(clientWsPromise) {
   let clientWs = null;
   const {
@@ -3273,13 +3579,20 @@ async function createTestWebSocketProxy(clientWsPromise) {
     });
     await new Promise((resolve, reject) => {
       const onOpen = () => {
-        logger().debug({ msg: "test websocket connection to actor opened" });
+        logger().debug({
+          msg: "test websocket connection to actor opened"
+        });
         resolve();
       };
       const onError = (error) => {
-        logger().error({ msg: "test websocket connection failed", error });
+        logger().error({
+          msg: "test websocket connection failed",
+          error
+        });
         reject(
-          new Error(`Failed to open WebSocket: ${error.message || error}`)
+          new Error(
+            `Failed to open WebSocket: ${error.message || error}`
+          )
         );
         serverWsReject();
       };
@@ -3431,7 +3744,9 @@ async function createTestWebSocketProxy(clientWsPromise) {
 // src/manager/router-schema.ts
 import { z as z5 } from "zod";
 var ServerlessStartHeadersSchema = z5.object({
-  endpoint: z5.string({ required_error: "x-rivet-endpoint header is required" }),
+  endpoint: z5.string({
+    required_error: "x-rivet-endpoint header is required"
+  }),
   token: z5.string({ invalid_type_error: "x-rivet-token header must be a string" }).optional(),
   totalSlots: z5.coerce.number({
     invalid_type_error: "x-rivet-total-slots header must be a number"
@@ -3440,7 +3755,7 @@ var ServerlessStartHeadersSchema = z5.object({
     required_error: "x-rivet-runner-name header is required"
   }),
   namespace: z5.string({
-    required_error: "x-rivet-namespace-id header is required"
+    required_error: "x-rivet-namespace-name header is required"
   })
 });
 
@@ -3512,7 +3827,7 @@ function addServerlessRoutes(driverConfig, registryConfig, runConfig, managerDri
       token: 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-id")
+      namespace: c.req.header("x-rivet-namespace-name")
     });
     if (!parseResult.success) {
       throw new InvalidRequest(
@@ -3578,7 +3893,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
       path: "/actors",
       request: {
         query: z6.object({
-          name: z6.string(),
+          name: z6.string().optional(),
           actor_ids: z6.string().optional(),
           key: z6.string().optional()
         })
@@ -3589,6 +3904,30 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
       const { name, actor_ids, key } = c.req.valid("query");
       const actorIdsParsed = actor_ids ? actor_ids.split(",").map((id) => id.trim()).filter((id) => id.length > 0) : void 0;
       const actors = [];
+      if (actorIdsParsed && (name || key)) {
+        return c.json(
+          {
+            error: "Cannot provide both actor_ids and (name + key). Use either actor_ids or (name + key)."
+          },
+          400
+        );
+      }
+      if (key && !name) {
+        return c.json(
+          {
+            error: "When providing 'key', 'name' must also be provided."
+          },
+          400
+        );
+      }
+      if (!actorIdsParsed && !key) {
+        return c.json(
+          {
+            error: "Must provide either 'actor_ids' or both 'name' and 'key'."
+          },
+          400
+        );
+      }
       if (actorIdsParsed) {
         if (actorIdsParsed.length > 32) {
           return c.json(
@@ -3613,6 +3952,20 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
             if (actorOutput) {
               actors.push(actorOutput);
             }
+          } else {
+            for (const actorName of Object.keys(
+              registryConfig.use
+            )) {
+              const actorOutput = await managerDriver.getForId({
+                c,
+                name: actorName,
+                actorId
+              });
+              if (actorOutput) {
+                actors.push(actorOutput);
+                break;
+              }
+            }
           }
         }
       } else if (key) {
@@ -3710,7 +4063,14 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
   if (registryConfig.test.enabled) {
     router.post(".test/inline-driver/call", async (c) => {
       const buffer = await c.req.arrayBuffer();
-      const { encoding, transport, method, args } = cbor4.decode(new Uint8Array(buffer));
+      const {
+        encoding,
+        transport,
+        method,
+        args
+      } = cbor4.decode(
+        new Uint8Array(buffer)
+      );
       logger().debug({
         msg: "received inline request",
         encoding,
@@ -3720,7 +4080,9 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
       });
       let response;
       try {
-        const output = await managerDriver[method](...args);
+        const output = await managerDriver[method](
+          ...args
+        );
         response = { ok: output };
       } catch (rawErr) {
         const err = deconstructError(rawErr, logger(), {}, true);
@@ -3731,7 +4093,10 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
     router.get(".test/inline-driver/connect-websocket/*", async (c) => {
       var _a2;
       const upgradeWebSocket = (_a2 = runConfig.getUpgradeWebSocket) == null ? void 0 : _a2.call(runConfig);
-      invariant6(upgradeWebSocket, "websockets not supported on this platform");
+      invariant6(
+        upgradeWebSocket,
+        "websockets not supported on this platform"
+      );
       return upgradeWebSocket(async (c2) => {
         const protocolHeader = c2.req.header("sec-websocket-protocol") || "";
         const protocols = protocolHeader.split(/,\s*/);
@@ -3765,7 +4130,9 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
           } else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
             connId = protocol.substring(WS_PROTOCOL_CONN_ID.length);
           } else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
-            connToken = protocol.substring(WS_PROTOCOL_CONN_TOKEN.length);
+            connToken = protocol.substring(
+              WS_PROTOCOL_CONN_TOKEN.length
+            );
           }
         }
         logger().debug({
@@ -3844,9 +4211,12 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
       try {
         const response = await managerDriver.sendRequest(
           actorId,
-          new Request(`http://actor/.test/force-disconnect?conn=${connId}`, {
-            method: "POST"
-          })
+          new Request(
+            `http://actor/.test/force-disconnect?conn=${connId}`,
+            {
+              method: "POST"
+            }
+          )
         );
         if (!response.ok) {
           const text = await response.text();
@@ -4024,7 +4394,10 @@ var Registry = class {
       ...driverLog
     });
     if (isInspectorEnabled(config2, "manager") && managerDriver.inspector) {
-      logger7().info({ msg: "inspector ready", url: getInspectorUrl(config2) });
+      logger7().info({
+        msg: "inspector ready",
+        url: getInspectorUrl(config2)
+      });
     }
     if (!config2.noWelcome) {
       const displayInfo = managerDriver.displayInformation();
@@ -4033,7 +4406,9 @@ var Registry = class {
       if (!config2.disableDefaultServer) {
         console.log(`  - Endpoint:     ${getEndpoint(config2)}`);
       } else if (config2.overrideServerAddress) {
-        console.log(`  - Endpoint:     ${config2.overrideServerAddress}`);
+        console.log(
+          `  - Endpoint:     ${config2.overrideServerAddress}`
+        );
       }
       if (config2.runEngine) {
         const padding = " ".repeat(Math.max(0, 13 - "Engine".length));
@@ -4082,13 +4457,19 @@ async function configureServerlessRunner(config2) {
   logger7().debug("configuring serverless runner");
   try {
     if (!config2.runnerName) {
-      throw new Error("runnerName is required for serverless configuration");
+      throw new Error(
+        "runnerName is required for serverless configuration"
+      );
     }
     if (!config2.namespace) {
-      throw new Error("namespace is required for serverless configuration");
+      throw new Error(
+        "namespace is required for serverless configuration"
+      );
     }
     if (!config2.endpoint) {
-      throw new Error("endpoint is required for serverless configuration");
+      throw new Error(
+        "endpoint is required for serverless configuration"
+      );
     }
     const customConfig = typeof config2.autoConfigureServerless === "object" ? config2.autoConfigureServerless : {};
     const clientConfig = {
@@ -4163,4 +4544,4 @@ export {
   setup
 };
 //! These configs configs hold anything that's not platform-specific about running actors.
-//# sourceMappingURL=chunk-L3YPHXPE.js.map
+//# sourceMappingURL=chunk-4B25D5OW.js.map