rivetkit 2.0.9 → 2.0.11

package/dist/tsup/{chunk-FZP2IBIX.js → chunk-NOXYAPM2.js}

@@ -4,7 +4,7 @@ import {
   inspectorLogger,
   isInspectorEnabled,
   secureInspector
-} from "./chunk-YR2VY4XS.js";
+} from "./chunk-MIP4PYTD.js";
 import {
   ActorDefinition,
   RemoteManagerDriver,
@@ -12,23 +12,24 @@ import {
   createClientWithDriver,
   deserializeActorKey,
   generateConnSocketId,
+  getEndpoint,
   lookupInRegistry,
   serializeActorKey
-} from "./chunk-KHZ2QSQ4.js";
+} from "./chunk-MT5ES4XD.js";
 import {
   CreateActorSchema
-} from "./chunk-WBSPHV5V.js";
+} from "./chunk-JTWD6ZT2.js";
 import {
   ActionContext,
   HTTP_ACTION_REQUEST_VERSIONED,
   HTTP_ACTION_RESPONSE_VERSIONED,
   HTTP_RESPONSE_ERROR_VERSIONED,
-  RunConfigSchema,
+  RunnerConfigSchema,
   TO_SERVER_VERSIONED,
   createVersionedDataHandler,
   parseMessage,
   serializeEmptyPersistData
-} from "./chunk-VVCL5DXN.js";
+} from "./chunk-OHSP4BUE.js";
 import {
   EncodingSchema,
   HEADER_ACTOR_ID,
@@ -54,22 +55,23 @@ import {
   generateRandomString,
   loggerWithoutContext,
   serializeWithEncoding
-} from "./chunk-R7OP5N25.js";
+} from "./chunk-AZI2T6UF.js";
 import {
   configureBaseLogger,
   configureDefaultLogger,
   getLogger
-} from "./chunk-DLPIL3VC.js";
+} from "./chunk-7DCESQ4O.js";
 import {
+  VERSION,
+  assertUnreachable,
   bufferToArrayBuffer,
   deconstructError,
-  getEnvUniversal,
   noopNext,
   package_default,
   promiseWithResolvers,
   setLongTimeout,
   stringifyError
-} from "./chunk-E63WU5PL.js";
+} from "./chunk-NQFIZSTR.js";
 import {
   ActorAlreadyExists,
   ConnNotFound,
@@ -77,6 +79,7 @@ import {
   InternalError,
   InvalidEncoding,
   InvalidParams,
+  InvalidRequest,
   MissingActorHeader,
   Unsupported,
   UserError,
@@ -746,13 +749,13 @@ async function handleConnectionClose(c, _runConfig, actorDriver, connId, connTok
   await conn.disconnect("Connection closed by client request");
   return c.json({});
 }
-async function handleRawWebSocketHandler(req, path3, actorDriver, actorId) {
+async function handleRawWebSocketHandler(req, path4, actorDriver, actorId) {
   const actor2 = await actorDriver.loadActor(actorId);
   return {
     onOpen: (_evt, ws) => {
       const adapter = new HonoWebSocketAdapter(ws);
       ws.__adapter = adapter;
-      const url = new URL(path3, "http://actor");
+      const url = new URL(path4, "http://actor");
       const pathname = url.pathname.replace(/^\/raw\/websocket\/?/, "") || "/";
       const normalizedPath = (pathname.startsWith("/") ? pathname : "/" + pathname) + url.search;
       let newRequest;
@@ -765,7 +768,7 @@ async function handleRawWebSocketHandler(req, path3, actorDriver, actorId) {
       }
       actor2.rLog.debug({
         msg: "rewriting websocket url",
-        from: path3,
+        from: path4,
         to: newRequest.url,
         pathname: url.pathname,
         search: url.search,
@@ -828,17 +831,17 @@ import * as cbor2 from "cbor-x";
 function logger2() {
   return getLogger("router");
 }
-function loggerMiddleware(logger7) {
+function loggerMiddleware(logger8) {
   return async (c, next) => {
     const method = c.req.method;
-    const path3 = c.req.path;
+    const path4 = c.req.path;
     const startTime = Date.now();
     await next();
     const duration = Date.now() - startTime;
-    logger7.debug({
+    logger8.debug({
       msg: "http request",
       method,
-      path: path3,
+      path: path4,
       status: c.res.status,
       dt: `${duration}ms`,
       reqSize: c.req.header("content-length"),
@@ -1434,7 +1437,6 @@ var EngineActorDriver = class {
   #runConfig;
   #managerDriver;
   #inlineClient;
-  #config;
   #runner;
   #actors = /* @__PURE__ */ new Map();
   #actorRouter;
@@ -1443,27 +1445,29 @@ var EngineActorDriver = class {
   #alarmTimeout;
   #runnerStarted = Promise.withResolvers();
   #runnerStopped = Promise.withResolvers();
-  constructor(registryConfig, runConfig, managerDriver, inlineClient, config2) {
+  constructor(registryConfig, runConfig, managerDriver, inlineClient) {
     this.#registryConfig = registryConfig;
     this.#runConfig = runConfig;
     this.#managerDriver = managerDriver;
     this.#inlineClient = inlineClient;
-    this.#config = config2;
+    const token = runConfig.token ?? runConfig.token;
+    if (token && runConfig.inspector && runConfig.inspector.enabled) {
+      runConfig.inspector.token = () => token;
+    }
     this.#actorRouter = createActorRouter(
       runConfig,
       this,
       registryConfig.test.enabled
     );
     let hasDisconnected = false;
-    const runnerConfig = {
+    const engineRunnerConfig = {
       version: this.#version,
-      endpoint: config2.endpoint,
-      token: runConfig.token ?? config2.token,
-      pegboardEndpoint: config2.pegboardEndpoint,
-      namespace: config2.namespace,
-      totalSlots: runConfig.totalSlots ?? config2.totalSlots,
-      runnerName: config2.runnerName,
-      runnerKey: config2.runnerKey,
+      endpoint: getEndpoint(runConfig),
+      token,
+      namespace: runConfig.namespace ?? runConfig.namespace,
+      totalSlots: runConfig.totalSlots ?? runConfig.totalSlots,
+      runnerName: runConfig.runnerName ?? runConfig.runnerName,
+      runnerKey: runConfig.runnerKey,
       metadata: {
         inspectorToken: this.#runConfig.inspector.token()
       },
@@ -1477,14 +1481,14 @@ var EngineActorDriver = class {
         if (hasDisconnected) {
           logger4().info({
             msg: "runner reconnected",
-            namespace: this.#config.namespace,
-            runnerName: this.#config.runnerName
+            namespace: this.#runConfig.namespace,
+            runnerName: this.#runConfig.runnerName
           });
         } else {
           logger4().debug({
             msg: "runner connected",
-            namespace: this.#config.namespace,
-            runnerName: this.#config.runnerName
+            namespace: this.#runConfig.namespace,
+            runnerName: this.#runConfig.runnerName
           });
         }
         this.#runnerStarted.resolve(void 0);
@@ -1492,8 +1496,8 @@ var EngineActorDriver = class {
       onDisconnected: () => {
         logger4().warn({
           msg: "runner disconnected",
-          namespace: this.#config.namespace,
-          runnerName: this.#config.runnerName
+          namespace: this.#runConfig.namespace,
+          runnerName: this.#runConfig.runnerName
         });
         hasDisconnected = true;
       },
@@ -1506,13 +1510,13 @@ var EngineActorDriver = class {
       onActorStop: this.#runnerOnActorStop.bind(this),
       logger: getLogger("engine-runner")
     };
-    this.#runner = new Runner(runnerConfig);
+    this.#runner = new Runner(engineRunnerConfig);
     this.#runner.start();
     logger4().debug({
       msg: "engine runner started",
-      endpoint: config2.endpoint,
-      namespace: config2.namespace,
-      runnerName: config2.runnerName
+      endpoint: runConfig.endpoint,
+      namespace: runConfig.namespace,
+      runnerName: runConfig.runnerName
     });
   }
   async #loadActorHandler(actorId) {
@@ -1564,18 +1568,18 @@ var EngineActorDriver = class {
     return void 0;
   }
   // Runner lifecycle callbacks
-  async #runnerOnActorStart(actorId, generation, config2) {
+  async #runnerOnActorStart(actorId, generation, runConfig) {
     var _a;
     logger4().debug({
       msg: "runner actor starting",
       actorId,
-      name: config2.name,
-      key: config2.key,
+      name: runConfig.name,
+      key: runConfig.key,
       generation
     });
     let input;
-    if (config2.input) {
-      input = cbor3.decode(config2.input);
+    if (runConfig.input) {
+      input = cbor3.decode(runConfig.input);
     }
     let handler = this.#actors.get(actorId);
     if (!handler) {
@@ -1585,14 +1589,10 @@ var EngineActorDriver = class {
       };
       this.#actors.set(actorId, handler);
     }
-    const name = config2.name;
-    invariant3(config2.key, "actor should have a key");
-    const key = deserializeActorKey(config2.key);
-    const definition = lookupInRegistry(
-      this.#registryConfig,
-      config2.name
-      // TODO: Remove cast
-    );
+    const name = runConfig.name;
+    invariant3(runConfig.key, "actor should have a key");
+    const key = deserializeActorKey(runConfig.key);
+    const definition = lookupInRegistry(this.#registryConfig, runConfig.name);
     handler.actor = definition.instantiate();
     await handler.actor.start(
       this,
@@ -1718,35 +1718,17 @@ var EngineActorDriver = class {
   async serverlessHandleStart(c) {
     await this.#runnerStarted.promise;
     return streamSSE2(c, async (stream) => {
+      stream.onAbort(() => this.shutdown(true));
       const payload = this.#runner.getServerlessInitPacket();
       invariant3(payload, "runnerId not set");
-      stream.writeSSE({ data: payload });
+      await stream.writeSSE({ data: payload });
       return this.#runnerStopped.promise;
     });
   }
 };
 
-// src/drivers/engine/config.ts
-import { z as z2 } from "zod";
-var ConfigSchema = z2.object({
-  app: z2.custom().optional(),
-  endpoint: z2.string().default(
-    () => getEnvUniversal("RIVET_ENGINE") ?? "http://localhost:6420"
-  ),
-  token: z2.string().optional().transform((val) => val ?? getEnvUniversal("RIVET_TOKEN")),
-  pegboardEndpoint: z2.string().optional(),
-  namespace: z2.string().default(() => getEnvUniversal("RIVET_NAMESPACE") ?? "default"),
-  runnerName: z2.string().default(() => getEnvUniversal("RIVET_RUNNER") ?? "rivetkit"),
-  // TODO: Automatically attempt to determine key by common env vars (e.g. k8s pod name)
-  runnerKey: z2.string().default(
-    () => getEnvUniversal("RIVET_RUNNER_KEY") ?? crypto.randomUUID()
-  ),
-  totalSlots: z2.number().default(1e5)
-}).default({});
-
 // src/drivers/engine/mod.ts
-function createEngineDriver(inputConfig) {
-  const config2 = ConfigSchema.parse(inputConfig);
+function createEngineDriver() {
   return {
     name: "engine",
     manager: (_registryConfig, runConfig) => {
@@ -1757,8 +1739,7 @@ function createEngineDriver(inputConfig) {
         registryConfig,
         runConfig,
         managerDriver,
-        inlineClient,
-        config2
+        inlineClient
       );
     }
   };
@@ -1949,9 +1930,9 @@ function getStoragePath(customPath) {
   const dirHash = createHashForPath(pathToHash);
   return path.join(dataPath, dirHash);
 }
-async function pathExists(path3) {
+async function pathExists(path4) {
   try {
-    await fs.access(path3);
+    await fs.access(path4);
     return true;
   } catch {
     return false;
@@ -2584,8 +2565,8 @@ var FileSystemManagerDriver = class {
       actorId
     });
   }
-  async openWebSocket(path3, actorId, encoding, params, connId, connToken) {
-    const pathOnly = path3.split("?")[0];
+  async openWebSocket(path4, actorId, encoding, params, connId, connToken) {
+    const pathOnly = path4.split("?")[0];
     const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
     if (normalizedPath === PATH_CONNECT_WEBSOCKET) {
       const wsHandler = await handleWebSocketConnect(
@@ -2602,13 +2583,13 @@ var FileSystemManagerDriver = class {
     } else if (normalizedPath.startsWith(PATH_RAW_WEBSOCKET_PREFIX) || normalizedPath === "/raw/websocket") {
       const wsHandler = await handleRawWebSocketHandler(
         void 0,
-        path3,
+        path4,
         this.#actorDriver,
         actorId
       );
       return new InlineWebSocketAdapter2(wsHandler);
     } else {
-      throw new Error(`Unreachable path: ${path3}`);
+      throw new Error(`Unreachable path: ${path4}`);
     }
   }
   async proxyRequest(c, actorRequest, actorId) {
@@ -2616,11 +2597,11 @@ var FileSystemManagerDriver = class {
       actorId
     });
   }
-  async proxyWebSocket(c, path3, actorId, encoding, connParams, connId, connToken) {
+  async proxyWebSocket(c, path4, actorId, encoding, connParams, connId, connToken) {
     var _a, _b;
     const upgradeWebSocket = (_b = (_a = this.#runConfig).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
     invariant5(upgradeWebSocket, "missing getUpgradeWebSocket");
-    const pathOnly = path3.split("?")[0];
+    const pathOnly = path4.split("?")[0];
     const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
     if (normalizedPath === PATH_CONNECT_WEBSOCKET) {
       const wsHandler = await handleWebSocketConnect(
@@ -2637,13 +2618,13 @@ var FileSystemManagerDriver = class {
     } else if (normalizedPath.startsWith(PATH_RAW_WEBSOCKET_PREFIX) || normalizedPath === "/raw/websocket") {
       const wsHandler = await handleRawWebSocketHandler(
         c.req.raw,
-        path3,
+        path4,
         this.#actorDriver,
         actorId
       );
       return upgradeWebSocket(() => wsHandler)(c, noopNext());
     } else {
-      throw new Error(`Unreachable path: ${path3}`);
+      throw new Error(`Unreachable path: ${path4}`);
     }
   }
   async getForId({ actorId }) {
@@ -2753,30 +2734,284 @@ function createMemoryDriver() {
   return createFileSystemOrMemoryDriver(false);
 }
 
+// src/registry/mod.ts
+import invariant7 from "invariant";
+
 // src/drivers/default.ts
 function chooseDefaultDriver(runConfig) {
   if (runConfig.endpoint && runConfig.driver) {
     throw new UserError(
-      "Cannot specify both 'engine' and 'driver' in configuration"
+      "Cannot specify both 'endpoint' and 'driver' in configuration"
+    );
+  }
+  if (runConfig.runnerKind === "serverless" && !runConfig.endpoint) {
+    throw new UserError(
+      "Cannot use 'serverless' runnerKind without the 'endpoint' config set."
     );
   }
   if (runConfig.driver) {
     return runConfig.driver;
   }
-  if (runConfig.endpoint) {
+  if (runConfig.endpoint || runConfig.token) {
     loggerWithoutContext().debug({
       msg: "using rivet engine driver",
       endpoint: runConfig.endpoint
     });
-    return createEngineDriver({
-      endpoint: runConfig.endpoint,
-      token: runConfig.token
-    });
+    return createEngineDriver();
   }
   loggerWithoutContext().debug({ msg: "using default file system driver" });
   return createFileSystemOrMemoryDriver(true);
 }
 
+// src/engine-process/mod.ts
+import { spawn } from "child_process";
+import { createWriteStream } from "fs";
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+import { pipeline } from "stream/promises";
+
+// src/engine-process/log.ts
+function logger6() {
+  return getLogger("engine-process");
+}
+
+// src/engine-process/mod.ts
+var ENGINE_PORT = 6420;
+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 });
+  const storageRoot = getStoragePath();
+  const binDir = path3.join(storageRoot, "bin");
+  const varDir = path3.join(storageRoot, "var");
+  const logsDir = path3.join(varDir, "logs", "rivet-engine");
+  await ensureDirectoryExists(binDir);
+  await ensureDirectoryExists(varDir);
+  await ensureDirectoryExists(logsDir);
+  const executableName = process.platform === "win32" ? `${ENGINE_BINARY_NAME}-${options.version}.exe` : `${ENGINE_BINARY_NAME}-${options.version}`;
+  const binaryPath = path3.join(binDir, executableName);
+  await downloadEngineBinaryIfNeeded(binaryPath, options.version, varDir);
+  if (await isEngineRunning()) {
+    try {
+      await waitForEngineHealth();
+      logger6().debug({
+        msg: "engine already running and healthy",
+        version: options.version
+      });
+      return;
+    } catch (error) {
+      logger6().warn({
+        msg: "existing engine process not healthy, cannot restart automatically",
+        error
+      });
+      throw new Error(
+        "Engine process exists but is not healthy. Please manually stop the process on port 6420 and retry."
+      );
+    }
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").replace(/\./g, "-");
+  const stdoutLogPath = path3.join(logsDir, `engine-${timestamp}-stdout.log`);
+  const stderrLogPath = path3.join(logsDir, `engine-${timestamp}-stderr.log`);
+  const stdoutStream = createWriteStream(stdoutLogPath, { flags: "a" });
+  const stderrStream = createWriteStream(stderrLogPath, { flags: "a" });
+  logger6().debug({
+    msg: "creating engine log files",
+    stdout: stdoutLogPath,
+    stderr: stderrLogPath
+  });
+  const child = spawn(binaryPath, ["start"], {
+    cwd: path3.dirname(binaryPath),
+    stdio: ["inherit", "pipe", "pipe"],
+    env: {
+      ...process.env
+    }
+  });
+  if (!child.pid) {
+    throw new Error("failed to spawn rivet engine process");
+  }
+  if (child.stdout) {
+    child.stdout.pipe(stdoutStream);
+  }
+  if (child.stderr) {
+    child.stderr.pipe(stderrStream);
+  }
+  logger6().debug({
+    msg: "spawned engine process",
+    pid: child.pid,
+    cwd: path3.dirname(binaryPath)
+  });
+  child.once("exit", (code, signal) => {
+    logger6().warn({
+      msg: "engine process exited",
+      code,
+      signal
+    });
+    stdoutStream.end();
+    stderrStream.end();
+  });
+  child.once("error", (error) => {
+    logger6().error({
+      msg: "engine process failed",
+      error
+    });
+    stdoutStream.end();
+    stderrStream.end();
+  });
+  await waitForEngineHealth();
+  logger6().info({
+    msg: "engine process started",
+    pid: child.pid,
+    version: options.version,
+    logs: {
+      stdout: stdoutLogPath,
+      stderr: stderrLogPath
+    }
+  });
+}
+async function downloadEngineBinaryIfNeeded(binaryPath, version, varDir) {
+  const binaryExists = await fileExists(binaryPath);
+  if (binaryExists) {
+    logger6().debug({
+      msg: "engine binary already cached",
+      version,
+      path: binaryPath
+    });
+    return;
+  }
+  const { targetTriplet, extension } = resolveTargetTriplet();
+  const remoteFile = `${ENGINE_BINARY_NAME}-${targetTriplet}${extension}`;
+  const downloadUrl = `${ENGINE_BASE_URL}/${version}/${remoteFile}`;
+  logger6().info({
+    msg: "downloading engine binary",
+    url: downloadUrl,
+    path: binaryPath,
+    version
+  });
+  const response = await fetch(downloadUrl);
+  if (!response.ok || !response.body) {
+    throw new Error(
+      `failed to download rivet engine binary from ${downloadUrl}: ${response.status} ${response.statusText}`
+    );
+  }
+  const tempPath = `${binaryPath}.${process.pid}.tmp`;
+  await pipeline(response.body, createWriteStream(tempPath));
+  if (process.platform !== "win32") {
+    await fs3.chmod(tempPath, 493);
+  }
+  await fs3.rename(tempPath, binaryPath);
+  logger6().debug({
+    msg: "engine binary download complete",
+    version,
+    path: binaryPath
+  });
+  logger6().info({
+    msg: "engine binary downloaded",
+    version,
+    path: binaryPath
+  });
+}
+function resolveTargetTriplet() {
+  return resolveTargetTripletFor(process.platform, process.arch);
+}
+function resolveTargetTripletFor(platform, arch) {
+  switch (platform) {
+    case "darwin":
+      if (arch === "arm64") {
+        return { targetTriplet: "aarch64-apple-darwin", extension: "" };
+      }
+      if (arch === "x64") {
+        return { targetTriplet: "x86_64-apple-darwin", extension: "" };
+      }
+      break;
+    case "linux":
+      if (arch === "x64") {
+        return { targetTriplet: "x86_64-unknown-linux-musl", extension: "" };
+      }
+      break;
+    case "win32":
+      if (arch === "x64") {
+        return { targetTriplet: "x86_64-pc-windows-gnu", extension: ".exe" };
+      }
+      break;
+  }
+  throw new Error(
+    `unsupported platform for rivet engine binary: ${platform}/${arch}`
+  );
+}
+async function isEngineRunning() {
+  return await checkIfEngineAlreadyRunningOnPort(ENGINE_PORT);
+}
+async function checkIfEngineAlreadyRunningOnPort(port) {
+  let response;
+  try {
+    response = await fetch(`http://localhost:${port}/health`);
+  } catch (err) {
+    return false;
+  }
+  if (response.ok) {
+    const health = await response.json();
+    if (health.runtime === "engine") {
+      logger6().debug({
+        msg: "rivet engine already running on port",
+        port
+      });
+      return true;
+    } else if (health.runtime === "rivetkit") {
+      logger6().error({
+        msg: "another rivetkit process is already running on port",
+        port
+      });
+      throw new Error(
+        "RivetKit process already running on port 6420, stop that process and restart this."
+      );
+    } else {
+      throw new Error(
+        "Unknown process running on port 6420, cannot identify what it is."
+      );
+    }
+  }
+  return false;
+}
+async function fileExists(filePath) {
+  try {
+    await fs3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var HEALTH_MAX_WAIT = 1e4;
+var HEALTH_INTERVAL = 100;
+async function waitForEngineHealth() {
+  const maxRetries = Math.ceil(HEALTH_MAX_WAIT / HEALTH_INTERVAL);
+  logger6().debug({ msg: "waiting for engine health check" });
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const response = await fetch(`${ENGINE_ENDPOINT}/health`);
+      if (response.ok) {
+        logger6().debug({ msg: "engine health check passed" });
+        return;
+      }
+    } catch (error) {
+      if (i === maxRetries - 1) {
+        throw new Error(
+          `engine health check failed after ${maxRetries} retries: ${error}`
+        );
+      }
+    }
+    if (i < maxRetries - 1) {
+      logger6().trace({
+        msg: "engine not ready, retrying",
+        attempt: i + 1,
+        maxRetries
+      });
+      await new Promise((resolve) => setTimeout(resolve, HEALTH_INTERVAL));
+    }
+  }
+  throw new Error(`engine health check failed after ${maxRetries} retries`);
+}
+
 // src/manager/router.ts
 import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
 import * as cbor4 from "cbor-x";
@@ -2784,66 +3019,79 @@ import {
   Hono as Hono3
 } from "hono";
 import { cors as corsMiddleware } from "hono/cors";
+import { createMiddleware } from "hono/factory";
 import invariant6 from "invariant";
 import { z as z5 } from "zod";
 
 // src/manager-api/actors.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 
 // src/manager-api/common.ts
-import { z as z3 } from "zod";
-var RivetIdSchema = z3.string();
+import { z as z2 } from "zod";
+var RivetIdSchema = z2.string();
 
 // src/manager-api/actors.ts
-var ActorSchema = z4.object({
+var ActorSchema = z3.object({
   actor_id: RivetIdSchema,
-  name: z4.string(),
-  key: z4.string(),
+  name: z3.string(),
+  key: z3.string(),
   namespace_id: RivetIdSchema,
-  runner_name_selector: z4.string(),
-  create_ts: z4.number(),
-  connectable_ts: z4.number().nullable().optional(),
-  destroy_ts: z4.number().nullable().optional(),
-  sleep_ts: z4.number().nullable().optional(),
-  start_ts: z4.number().nullable().optional()
+  runner_name_selector: z3.string(),
+  create_ts: z3.number(),
+  connectable_ts: z3.number().nullable().optional(),
+  destroy_ts: z3.number().nullable().optional(),
+  sleep_ts: z3.number().nullable().optional(),
+  start_ts: z3.number().nullable().optional()
 });
-var ActorsListResponseSchema = z4.object({
-  actors: z4.array(ActorSchema)
+var ActorsListResponseSchema = z3.object({
+  actors: z3.array(ActorSchema)
 });
-var ActorsCreateRequestSchema = z4.object({
-  name: z4.string(),
-  runner_name_selector: z4.string(),
-  crash_policy: z4.string(),
-  key: z4.string().nullable().optional(),
-  input: z4.string().nullable().optional()
+var ActorsCreateRequestSchema = z3.object({
+  name: z3.string(),
+  runner_name_selector: z3.string(),
+  crash_policy: z3.string(),
+  key: z3.string().nullable().optional(),
+  input: z3.string().nullable().optional()
 });
-var ActorsCreateResponseSchema = z4.object({
+var ActorsCreateResponseSchema = z3.object({
   actor: ActorSchema
 });
-var ActorsGetOrCreateRequestSchema = z4.object({
-  name: z4.string(),
-  key: z4.string(),
-  runner_name_selector: z4.string(),
-  crash_policy: z4.string(),
-  input: z4.string().nullable().optional()
+var ActorsGetOrCreateRequestSchema = z3.object({
+  name: z3.string(),
+  key: z3.string(),
+  runner_name_selector: z3.string(),
+  crash_policy: z3.string(),
+  input: z3.string().nullable().optional()
 });
-var ActorsGetOrCreateResponseSchema = z4.object({
+var ActorsGetOrCreateResponseSchema = z3.object({
   actor: ActorSchema,
-  created: z4.boolean()
+  created: z3.boolean()
 });
-var ActorsDeleteResponseSchema = z4.object({});
+var ActorsDeleteResponseSchema = z3.object({});
 
 // src/manager/gateway.ts
 async function actorGateway(runConfig, managerDriver, c, next) {
   if (c.req.path.startsWith("/.test/")) {
     return next();
   }
+  let strippedPath = c.req.path;
+  if (runConfig.basePath && strippedPath.startsWith(runConfig.basePath)) {
+    strippedPath = strippedPath.slice(runConfig.basePath.length);
+    if (!strippedPath.startsWith("/")) {
+      strippedPath = "/" + strippedPath;
+    }
+  }
   if (c.req.header("upgrade") === "websocket") {
-    return await handleWebSocketGateway(runConfig, managerDriver, c);
+    return await handleWebSocketGateway(
+      runConfig,
+      managerDriver,
+      c,
+      strippedPath
+    );
   }
-  return await handleHttpGateway(managerDriver, c, next);
+  return await handleHttpGateway(managerDriver, c, next, strippedPath);
 }
-async function handleWebSocketGateway(runConfig, managerDriver, c) {
+async function handleWebSocketGateway(runConfig, managerDriver, c, strippedPath) {
   var _a;
   const upgradeWebSocket = (_a = runConfig.getUpgradeWebSocket) == null ? void 0 : _a.call(runConfig);
   if (!upgradeWebSocket) {
@@ -2885,12 +3133,12 @@ async function handleWebSocketGateway(runConfig, managerDriver, c) {
   logger().debug({
     msg: "proxying websocket to actor",
     actorId,
-    path: c.req.path,
+    path: strippedPath,
     encoding: encodingRaw
   });
   const encoding = encodingRaw || "json";
   const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
-  const pathWithQuery = c.req.url.includes("?") ? c.req.path + c.req.url.substring(c.req.url.indexOf("?")) : c.req.path;
+  const pathWithQuery = c.req.url.includes("?") ? strippedPath + c.req.url.substring(c.req.url.indexOf("?")) : strippedPath;
   return await managerDriver.proxyWebSocket(
     c,
     pathWithQuery,
@@ -2902,7 +3150,7 @@ async function handleWebSocketGateway(runConfig, managerDriver, c) {
     connTokenRaw
   );
 }
-async function handleHttpGateway(managerDriver, c, next) {
+async function handleHttpGateway(managerDriver, c, next, strippedPath) {
   const target = c.req.header(HEADER_RIVET_TARGET);
   const actorId = c.req.header(HEADER_RIVET_ACTOR);
   if (target !== "actor") {
@@ -2914,19 +3162,20 @@ async function handleHttpGateway(managerDriver, c, next) {
   logger().debug({
     msg: "proxying request to actor",
     actorId,
-    path: c.req.path,
+    path: strippedPath,
     method: c.req.method
   });
   const proxyHeaders = new Headers(c.req.raw.headers);
   proxyHeaders.delete(HEADER_RIVET_TARGET);
   proxyHeaders.delete(HEADER_RIVET_ACTOR);
   const url = new URL(c.req.url);
-  const proxyUrl = new URL(`http://actor${url.pathname}${url.search}`);
+  const proxyUrl = new URL(`http://actor${strippedPath}${url.search}`);
   const proxyRequest = new Request(proxyUrl, {
     method: c.req.raw.method,
     headers: proxyHeaders,
     body: c.req.raw.body,
-    signal: c.req.raw.signal
+    signal: c.req.raw.signal,
+    duplex: "half"
   });
   return await managerDriver.proxyRequest(c, proxyRequest, actorId);
 }
@@ -3102,6 +3351,22 @@ async function createTestWebSocketProxy(clientWsPromise) {
   };
 }
 
+// src/manager/router-schema.ts
+import { z as z4 } from "zod";
+var ServerlessStartHeadersSchema = z4.object({
+  endpoint: z4.string({ required_error: "x-rivet-endpoint header is required" }),
+  token: z4.string({ invalid_type_error: "x-rivet-token header must be a string" }).optional(),
+  totalSlots: z4.coerce.number({
+    invalid_type_error: "x-rivet-total-slots header must be a number"
+  }).int("x-rivet-total-slots header must be an integer").gte(1, "x-rivet-total-slots header must be positive"),
+  runnerName: z4.string({
+    required_error: "x-rivet-runner-name header is required"
+  }),
+  namespace: z4.string({
+    required_error: "x-rivet-namespace-id header is required"
+  })
+});
+
 // src/manager/router.ts
 function buildOpenApiResponses(schema) {
   return {
@@ -3121,21 +3386,42 @@ function buildOpenApiResponses(schema) {
     }
   };
 }
-function createManagerRouter(registryConfig, runConfig, managerDriver, serverlessActorDriverBuilder) {
+function createManagerRouter(registryConfig, runConfig, managerDriver, driverConfig, client) {
   const router = new OpenAPIHono({ strict: false }).basePath(
     runConfig.basePath
   );
   router.use("*", loggerMiddleware(logger()));
-  if (serverlessActorDriverBuilder) {
-    addServerlessRoutes(runConfig, serverlessActorDriverBuilder, router);
-  } else {
+  router.use(
+    "*",
+    createMiddleware(async (c, next) => {
+      const upgrade = c.req.header("upgrade");
+      const isWebSocket = (upgrade == null ? void 0 : upgrade.toLowerCase()) === "websocket";
+      const isGet = c.req.method === "GET";
+      if (isGet && isWebSocket) {
+        c.header("Sec-WebSocket-Protocol", "rivet");
+      }
+      await next();
+    })
+  );
+  if (runConfig.runnerKind === "serverless") {
+    addServerlessRoutes(
+      driverConfig,
+      registryConfig,
+      runConfig,
+      managerDriver,
+      client,
+      router
+    );
+  } else if (runConfig.runnerKind === "normal") {
     addManagerRoutes(registryConfig, runConfig, managerDriver, router);
+  } else {
+    assertUnreachable(runConfig.runnerKind);
   }
   router.notFound(handleRouteNotFound);
   router.onError(handleRouteError);
   return { router, openapi: router };
 }
-function addServerlessRoutes(runConfig, serverlessActorDriverBuilder, router) {
+function addServerlessRoutes(driverConfig, registryConfig, runConfig, managerDriver, client, router) {
   if (runConfig.cors) router.use("*", corsMiddleware(runConfig.cors));
   router.get("/", (c) => {
     return c.text(
@@ -3143,12 +3429,39 @@ function addServerlessRoutes(runConfig, serverlessActorDriverBuilder, router) {
     );
   });
   router.get("/start", async (c) => {
-    const token = c.req.header("x-rivet-token");
-    let totalSlots = parseInt(
-      c.req.header("x-rivetkit-total-slots")
+    var _a;
+    const parseResult = ServerlessStartHeadersSchema.safeParse({
+      endpoint: c.req.header("x-rivet-endpoint"),
+      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")
+    });
+    if (!parseResult.success) {
+      throw new InvalidRequest(
+        ((_a = parseResult.error.issues[0]) == null ? void 0 : _a.message) ?? "invalid serverless start headers"
+      );
+    }
+    const { endpoint, token, totalSlots, runnerName, namespace } = parseResult.data;
+    logger().debug({
+      msg: "received serverless runner start request",
+      endpoint,
+      totalSlots,
+      runnerName,
+      namespace
+    });
+    const newRunConfig = Object.assign({}, runConfig);
+    newRunConfig.endpoint = endpoint;
+    newRunConfig.token = token;
+    newRunConfig.totalSlots = totalSlots;
+    newRunConfig.runnerName = runnerName;
+    newRunConfig.namespace = namespace;
+    const actorDriver = driverConfig.actor(
+      registryConfig,
+      newRunConfig,
+      managerDriver,
+      client
     );
-    if (isNaN(totalSlots)) totalSlots = void 0;
-    const actorDriver = serverlessActorDriverBuilder(token, totalSlots);
     invariant6(
       actorDriver.serverlessHandleStart,
       "missing serverlessHandleStart on ActorDriver"
@@ -3156,7 +3469,11 @@ function addServerlessRoutes(runConfig, serverlessActorDriverBuilder, router) {
     return await actorDriver.serverlessHandleStart(c);
   });
   router.get("/health", (c) => {
-    return c.text("ok");
+    return c.json({
+      status: "ok",
+      runtime: "rivetkit",
+      version: VERSION
+    });
   });
 }
 function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
@@ -3235,7 +3552,9 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
         }
       }
       return c.json({
-        actors: actors.map(createApiActor)
+        actors: actors.map(
+          (actor2) => createApiActor(actor2, runConfig.runnerName)
+        )
       });
     });
   }
@@ -3264,7 +3583,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
       });
       if (existingActor) {
         return c.json({
-          actor: createApiActor(existingActor),
+          actor: createApiActor(existingActor, runConfig.runnerName),
           created: false
         });
       }
@@ -3278,7 +3597,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
         // Not provided in the request schema
       });
       return c.json({
-        actor: createApiActor(newActor),
+        actor: createApiActor(newActor, runConfig.runnerName),
         created: true
       });
     });
@@ -3309,7 +3628,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
         region: void 0
         // Not provided in the request schema
       });
-      const actor2 = createApiActor(actorOutput);
+      const actor2 = createApiActor(actorOutput, runConfig.runnerName);
       return c.json({ actor: actor2 });
     });
   }
@@ -3344,7 +3663,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
         let actorId = "";
         let encoding = "bare";
         let transport = "websocket";
-        let path3 = "";
+        let path4 = "";
         let params;
         let connId;
         let connToken;
@@ -3360,7 +3679,7 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
               WS_PROTOCOL_TRANSPORT.length
             );
           } else if (protocol.startsWith(WS_PROTOCOL_PATH)) {
-            path3 = decodeURIComponent(
+            path4 = decodeURIComponent(
               protocol.substring(WS_PROTOCOL_PATH.length)
             );
           } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
@@ -3380,10 +3699,10 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
           params,
           encodingKind: encoding,
           transport,
-          path: path3
+          path: path4
         });
         const clientWsPromise = managerDriver.openWebSocket(
-          path3,
+          path4,
           actorId,
           encoding,
           params,
@@ -3472,7 +3791,12 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
     });
   }
   router.get("/health", (c) => {
-    return c.text("ok");
+    return c.json({
+      status: "ok",
+      rivetkit: {
+        version: VERSION
+      }
+    });
   });
   (_a = managerDriver.modifyManagerRouter) == null ? void 0 : _a.call(
     managerDriver,
@@ -3480,15 +3804,14 @@ function addManagerRoutes(registryConfig, runConfig, managerDriver, router) {
     router
   );
 }
-function createApiActor(actor2) {
+function createApiActor(actor2, runnerName = "default") {
   return {
     actor_id: actor2.actorId,
     name: actor2.name,
     key: serializeActorKey(actor2.key),
     namespace_id: "default",
     // Assert default namespace
-    runner_name_selector: "rivetkit",
-    // Assert rivetkit runner
+    runner_name_selector: runnerName,
     create_ts: Date.now(),
     connectable_ts: null,
     destroy_ts: null,
@@ -3517,13 +3840,13 @@ var RegistryConfigSchema = z6.object({
 });
 
 // src/registry/log.ts
-function logger6() {
+function logger7() {
   return getLogger("registry");
 }
 
 // src/registry/serve.ts
 import { Hono as Hono4 } from "hono";
-async function crossPlatformServe(rivetKitRouter, userRouter) {
+async function crossPlatformServe(runConfig, rivetKitRouter, userRouter) {
   const app = userRouter ?? new Hono4();
   let serve;
   try {
@@ -3533,7 +3856,7 @@ async function crossPlatformServe(rivetKitRouter, userRouter) {
     );
     serve = dep.serve;
   } catch (err) {
-    logger6().error(
+    logger7().error(
       "failed to import @hono/node-server. please run 'npm install @hono/node-server @hono/node-ws'"
     );
     process.exit(1);
@@ -3547,7 +3870,7 @@ async function crossPlatformServe(rivetKitRouter, userRouter) {
     );
     createNodeWebSocket = dep.createNodeWebSocket;
   } catch (err) {
-    logger6().error(
+    logger7().error(
       "failed to import @hono/node-ws. please run 'npm install @hono/node-server @hono/node-ws'"
     );
     process.exit(1);
@@ -3555,10 +3878,10 @@ async function crossPlatformServe(rivetKitRouter, userRouter) {
   const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({
     app
   });
-  const port = 6420;
+  const port = runConfig.defaultServerPort;
   const server = serve(
     { fetch: app.fetch, port },
-    () => logger6().info({ msg: "server listening", port })
+    () => logger7().info({ msg: "server listening", port })
   );
   injectWebSocket(server);
   return { upgradeWebSocket };
@@ -3578,7 +3901,34 @@ var Registry = class {
    */
   start(inputConfig) {
     var _a, _b, _c;
-    const config2 = RunConfigSchema.parse(inputConfig);
+    const config2 = RunnerConfigSchema.parse(inputConfig);
+    if (config2.autoConfigureServerless && config2.runnerKind !== "serverless") {
+      throw new Error(
+        "autoConfigureServerless can only be configured when runnerKind is 'serverless'"
+      );
+    }
+    const readyPromises = [];
+    if (config2.runEngine) {
+      logger7().debug({
+        msg: "run engine requested",
+        version: config2.runEngineVersion
+      });
+      invariant7(
+        config2.endpoint === void 0,
+        "cannot specify 'endpoint' with 'runEngine'"
+      );
+      config2.endpoint = ENGINE_ENDPOINT;
+      config2.disableActorDriver = true;
+      const engineProcessPromise = ensureEngineProcess({
+        version: config2.runEngineVersion
+      });
+      readyPromises.push(engineProcessPromise);
+    }
+    if (config2.runnerKind === "serverless") {
+      config2.defaultServerPort = 8080;
+      config2.overrideServerAddress = config2.endpoint;
+      config2.disableActorDriver = true;
+    }
     if ((_a = config2.logging) == null ? void 0 : _a.baseLogger) {
       configureBaseLogger(config2.logging.baseLogger);
     } else {
@@ -3587,11 +3937,13 @@ var Registry = class {
     const driver = chooseDefaultDriver(config2);
     if (driver.name === "engine") {
       config2.inspector.enabled = { manager: false, actor: true };
-      config2.disableServer = true;
+      if (config2.runnerKind !== "serverless") {
+        config2.disableDefaultServer = true;
+      }
     }
     if (driver.name === "cloudflare-workers") {
       config2.inspector.enabled = { manager: false, actor: true };
-      config2.disableServer = true;
+      config2.disableDefaultServer = true;
       config2.disableActorDriver = true;
       config2.noWelcome = true;
     }
@@ -3603,20 +3955,28 @@ var Registry = class {
     configureInspectorAccessToken(config2, managerDriver);
     const client = createClientWithDriver(managerDriver, config2);
     const driverLog = ((_c = managerDriver.extraStartupLog) == null ? void 0 : _c.call(managerDriver)) ?? {};
-    logger6().info({
+    logger7().info({
       msg: "rivetkit ready",
       driver: driver.name,
       definitions: Object.keys(this.#config.use).length,
       ...driverLog
     });
     if (isInspectorEnabled(config2, "manager") && managerDriver.inspector) {
-      logger6().info({ msg: "inspector ready", url: getInspectorUrl(config2) });
+      logger7().info({ msg: "inspector ready", url: getInspectorUrl(config2) });
     }
     if (!config2.noWelcome) {
       const displayInfo = managerDriver.displayInformation();
       console.log();
       console.log(`  RivetKit ${package_default.version} (${displayInfo.name})`);
-      console.log(`  - Endpoint:     http://127.0.0.1:6420`);
+      if (!config2.disableDefaultServer) {
+        console.log(`  - Endpoint:     ${config2.endpoint}`);
+      } else if (config2.overrideServerAddress) {
+        console.log(`  - Endpoint:     ${config2.overrideServerAddress}`);
+      }
+      if (config2.runEngine) {
+        const padding = " ".repeat(Math.max(0, 13 - "Engine".length));
+        console.log(`  - Engine:${padding}v${config2.runEngineVersion}`);
+      }
       for (const [k, v] of Object.entries(displayInfo.properties)) {
         const padding = " ".repeat(Math.max(0, 13 - k.length));
         console.log(`  - ${k}:${padding}${v}`);
@@ -3627,22 +3987,25 @@ var Registry = class {
       console.log();
     }
     if (!config2.disableActorDriver) {
-      const _actorDriver = driver.actor(
-        this.#config,
-        config2,
-        managerDriver,
-        client
-      );
+      Promise.all(readyPromises).then(async () => {
+        driver.actor(this.#config, config2, managerDriver, client);
+      });
+    }
+    if (config2.runnerKind === "serverless" && config2.autoConfigureServerless) {
+      Promise.all(readyPromises).then(async () => {
+        await configureServerlessRunner(config2);
+      });
     }
     const { router: hono } = createManagerRouter(
       this.#config,
       config2,
       managerDriver,
-      void 0
+      driver,
+      client
     );
-    if (!config2.disableServer) {
+    if (!config2.disableDefaultServer) {
       (async () => {
-        const out = await crossPlatformServe(hono, void 0);
+        const out = await crossPlatformServe(config2, hono, void 0);
         upgradeWebSocket = out.upgradeWebSocket;
       })();
     }
@@ -3651,83 +4014,83 @@ var Registry = class {
       fetch: hono.fetch.bind(hono)
     };
   }
-  startServerless(inputConfig) {
-    var _a, _b, _c, _d, _e;
-    const config2 = RunConfigSchema.parse(inputConfig);
-    if ((_a = config2.logging) == null ? void 0 : _a.baseLogger) {
-      configureBaseLogger(config2.logging.baseLogger);
-    } else {
-      configureDefaultLogger((_b = config2.logging) == null ? void 0 : _b.level);
-    }
-    const driver = chooseDefaultDriver(config2);
-    if (driver.name === "engine") {
-      config2.inspector.enabled = false;
-      config2.disableServer = true;
-      config2.disableActorDriver = true;
+};
+async function configureServerlessRunner(config2) {
+  try {
+    if (!config2.runnerName) {
+      throw new Error("runnerName is required for serverless configuration");
     }
-    if (driver.name === "cloudflare-workers") {
-      config2.inspector.enabled = false;
-      config2.disableServer = true;
-      config2.disableActorDriver = true;
-      config2.noWelcome = true;
+    if (!config2.namespace) {
+      throw new Error("namespace is required for serverless configuration");
     }
-    let upgradeWebSocket;
-    if (!config2.getUpgradeWebSocket) {
-      config2.getUpgradeWebSocket = () => upgradeWebSocket;
+    if (!config2.endpoint) {
+      throw new Error("endpoint is required for serverless configuration");
     }
-    const managerDriver = driver.manager(this.#config, config2);
-    const client = createClientWithDriver(managerDriver, config2);
-    const driverLog = ((_c = managerDriver.extraStartupLog) == null ? void 0 : _c.call(managerDriver)) ?? {};
-    logger6().info({
-      msg: "rivetkit ready",
-      driver: driver.name,
-      definitions: Object.keys(this.#config.use).length,
-      ...driverLog
+    const customConfig = typeof config2.autoConfigureServerless === "object" ? config2.autoConfigureServerless : {};
+    const dcsUrl = `${config2.endpoint}/datacenters`;
+    logger7().debug({
+      msg: "fetching datacenters",
+      url: dcsUrl
     });
-    if (((_d = config2.inspector) == null ? void 0 : _d.enabled) && managerDriver.inspector) {
-      logger6().info({ msg: "inspector ready", url: getInspectorUrl(config2) });
-    }
-    if (!config2.noWelcome) {
-      const displayInfo = managerDriver.displayInformation();
-      console.log();
-      console.log(`  RivetKit ${package_default.version} (${displayInfo.name})`);
-      console.log(`  - Endpoint:     http://127.0.0.1:6420`);
-      for (const [k, v] of Object.entries(displayInfo.properties)) {
-        const padding = " ".repeat(Math.max(0, 13 - k.length));
-        console.log(`  - ${k}:${padding}${v}`);
-      }
-      if (((_e = config2.inspector) == null ? void 0 : _e.enabled) && managerDriver.inspector) {
-        console.log(`  - Inspector:    ${getInspectorUrl(config2)}`);
+    const dcsResponse = await fetch(dcsUrl, {
+      headers: {
+        ...config2.token ? { Authorization: `Bearer ${config2.token}` } : {}
       }
-      console.log();
+    });
+    if (!dcsResponse.ok) {
+      const errorText = await dcsResponse.text();
+      throw new Error(
+        `failed to configure serverless runner: ${dcsResponse.status} ${dcsResponse.statusText} - ${errorText}`
+      );
     }
-    let serverlessActorDriverBuilder = (token, totalSlots) => {
-      if (token) config2.token = token;
-      if (totalSlots) config2.totalSlots = totalSlots;
-      return driver.actor(this.#config, config2, managerDriver, client);
+    const dcsRes = await dcsResponse.json();
+    const serverlessConfig = {
+      serverless: {
+        url: customConfig.url || `http://localhost:${config2.defaultServerPort}/start`,
+        headers: customConfig.headers || {},
+        max_runners: customConfig.maxRunners ?? 100,
+        min_runners: customConfig.minRunners ?? 0,
+        request_lifespan: customConfig.requestLifespan ?? 15 * 60,
+        runners_margin: customConfig.runnersMargin ?? 0,
+        slots_per_runner: customConfig.slotsPerRunner ?? config2.totalSlots ?? 1e3
+      }
     };
-    if (!config2.disableActorDriver) {
-      const _actorDriver = serverlessActorDriverBuilder();
-      serverlessActorDriverBuilder = void 0;
-    }
-    const { router: hono } = createManagerRouter(
-      this.#config,
-      config2,
-      managerDriver,
-      serverlessActorDriverBuilder
+    const requestBody = Object.fromEntries(
+      dcsRes.datacenters.map((dc) => [dc.name, serverlessConfig])
     );
-    if (!config2.disableServer) {
-      (async () => {
-        const out = await crossPlatformServe(hono, void 0);
-        upgradeWebSocket = out.upgradeWebSocket;
-      })();
+    const configUrl = `${config2.endpoint}/runner-configs/${config2.runnerName}?namespace=${config2.namespace}`;
+    logger7().debug({
+      msg: "configuring serverless runner",
+      url: configUrl,
+      config: serverlessConfig.serverless
+    });
+    const response = await fetch(configUrl, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        ...config2.token ? { Authorization: `Bearer ${config2.token}` } : {}
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `failed to configure serverless runner: ${response.status} ${response.statusText} - ${errorText}`
+      );
     }
-    return {
-      client,
-      fetch: hono.fetch.bind(hono)
-    };
+    logger7().info({
+      msg: "serverless runner configured successfully",
+      runnerName: config2.runnerName,
+      namespace: config2.namespace
+    });
+  } catch (error) {
+    logger7().error({
+      msg: "failed to configure serverless runner",
+      error
+    });
+    throw error;
   }
-};
+}
 function setup(input) {
   const config2 = RegistryConfigSchema.parse(input);
   return new Registry(config2);
@@ -3749,4 +4112,4 @@ export {
   setup
 };
 //! These configs configs hold anything that's not platform-specific about running actors.
-//# sourceMappingURL=chunk-FZP2IBIX.js.map
+//# sourceMappingURL=chunk-NOXYAPM2.js.map