rivetkit 2.0.35 → 2.0.36

package/dist/tsup/{chunk-ESNM74WZ.js → chunk-KJLJLNHR.js}

@@ -15,6 +15,8 @@ import {
   getRivetEndpoint,
   getRivetEngine,
   getRivetNamespace,
+  getRivetPublicEndpoint,
+  getRivetPublicToken,
   getRivetRunEngine,
   getRivetRunEngineVersion,
   getRivetRunner,
@@ -29,7 +31,7 @@ import {
   noopNext,
   promiseWithResolvers,
   stringifyError
-} from "./chunk-UCUYH474.js";
+} from "./chunk-UDKWYSU3.js";
 import {
   ConnStateNotEnabled,
   Forbidden,
@@ -45,7 +47,7 @@ import {
   Unreachable,
   Unsupported,
   WebSocketsNotEnabled
-} from "./chunk-6KPMUCTX.js";
+} from "./chunk-2YHR67M4.js";
 
 // src/common/actor-router-consts.ts
 var PATH_CONNECT = "/connect";
@@ -83,8 +85,8 @@ var ALLOWED_PUBLIC_HEADERS = [
 // src/manager/router.ts
 import { createRoute } from "@hono/zod-openapi";
 import * as cbor6 from "cbor-x";
-import invariant6 from "invariant";
-import { z as z12 } from "zod";
+import invariant5 from "invariant";
+import { z as z10 } from "zod";
 
 // src/actor/keys.ts
 var EMPTY_KEY = "/";
@@ -1626,153 +1628,14 @@ function getRequestConnParams(req) {
 }
 
 // src/registry/config/index.ts
-import invariant2 from "invariant";
-import { z as z9 } from "zod";
-
-// src/client/config.ts
-import z4 from "zod";
-
-// src/utils/endpoint-parser.ts
-import { z as z3 } from "zod";
-function zodParseEndpoint(endpoint) {
-  const url = new URL(endpoint);
-  if (url.search) {
-    throw new z3.ZodError([
-      {
-        code: "custom",
-        message: "endpoint cannot contain a query string",
-        path: ["endpoint"]
-      }
-    ]);
-  }
-  if (url.hash) {
-    throw new z3.ZodError([
-      {
-        code: "custom",
-        message: "endpoint cannot contain a fragment",
-        path: ["endpoint"]
-      }
-    ]);
-  }
-  const namespace = url.username ? decodeURIComponent(url.username) : void 0;
-  const token = url.password ? decodeURIComponent(url.password) : void 0;
-  if (token && !namespace) {
-    throw new z3.ZodError([
-      {
-        code: "custom",
-        message: "endpoint cannot have a token without a namespace",
-        path: ["endpoint"]
-      }
-    ]);
-  }
-  url.username = "";
-  url.password = "";
-  const cleanedEndpoint = url.toString();
-  return {
-    endpoint: cleanedEndpoint,
-    namespace,
-    token
-  };
-}
-var EndpointSchema = z3.string().transform((endpoint) => {
-  return zodParseEndpoint(endpoint);
-});
-function zodCheckDuplicateCredentials(resolvedEndpoint, config6, ctx) {
-  if (resolvedEndpoint.namespace && config6.namespace) {
-    ctx.addIssue({
-      code: "custom",
-      message: "cannot specify namespace both in endpoint URL and as a separate config option",
-      path: ["namespace"]
-    });
-  }
-  if (resolvedEndpoint.token && config6.token) {
-    ctx.addIssue({
-      code: "custom",
-      message: "cannot specify token both in endpoint URL and as a separate config option",
-      path: ["token"]
-    });
-  }
-}
-
-// src/client/config.ts
-var ClientConfigSchemaBase = z4.object({
-  /** Endpoint to connect to for Rivet Engine or RivetKit manager API. */
-  endpoint: EndpointSchema.optional(),
-  /** Token to use to authenticate with the API. */
-  token: z4.string().optional(),
-  /** Namespace to connect to. */
-  namespace: z4.string().optional(),
-  /** Name of the runner. This is used to group together runners in to different pools. */
-  runnerName: z4.string().default(() => getRivetRunner() ?? "default"),
-  encoding: EncodingSchema.default("bare"),
-  headers: z4.record(z4.string(), z4.string()).optional().default(() => ({})),
-  // See RunConfig.getUpgradeWebSocket
-  //
-  // This is required in the client config in order to support
-  // `proxyWebSocket`
-  getUpgradeWebSocket: z4.custom().optional(),
-  /** Whether to automatically perform health checks when the client is created. */
-  disableMetadataLookup: z4.boolean().optional().default(false),
-  /** Whether to enable RivetKit Devtools integration. */
-  devtools: z4.boolean().default(
-    () => {
-      var _a;
-      return typeof window !== "undefined" && ((_a = window == null ? void 0 : window.location) == null ? void 0 : _a.hostname) === "localhost";
-    }
-  )
-});
-var ClientConfigSchema = ClientConfigSchemaBase.transform(
-  (config6, ctx) => transformClientConfig(config6, ctx)
-);
-function resolveEndpoint(parsedEndpoint) {
-  if (parsedEndpoint) {
-    return parsedEndpoint;
-  }
-  const envEndpoint = getRivetEngine() ?? getRivetEndpoint();
-  if (envEndpoint) {
-    return EndpointSchema.parse(envEndpoint);
-  }
-  return void 0;
-}
-function validateClientConfig(resolvedEndpoint, config6, ctx) {
-  if (resolvedEndpoint) {
-    zodCheckDuplicateCredentials(resolvedEndpoint, config6, ctx);
-  }
-}
-function transformClientConfig(config6, ctx) {
-  const resolvedEndpoint = resolveEndpoint(config6.endpoint);
-  if (ctx) {
-    validateClientConfig(resolvedEndpoint, config6, ctx);
-  }
-  return {
-    ...config6,
-    endpoint: resolvedEndpoint == null ? void 0 : resolvedEndpoint.endpoint,
-    namespace: (resolvedEndpoint == null ? void 0 : resolvedEndpoint.namespace) ?? config6.namespace ?? getRivetNamespace() ?? "default",
-    token: (resolvedEndpoint == null ? void 0 : resolvedEndpoint.token) ?? config6.token ?? getRivetToken()
-  };
-}
-function convertRegistryConfigToClientConfig(config6) {
-  var _a;
-  return {
-    endpoint: config6.endpoint,
-    token: config6.token,
-    namespace: config6.namespace,
-    runnerName: config6.runner.runnerName,
-    headers: config6.headers,
-    encoding: "bare",
-    getUpgradeWebSocket: void 0,
-    // We don't need health checks for internal clients
-    disableMetadataLookup: true,
-    devtools: typeof window !== "undefined" && ((_a = window == null ? void 0 : window.location) == null ? void 0 : _a.hostname) === "localhost"
-  };
-}
+import { z as z7 } from "zod";
 
 // src/engine-process/constants.ts
 var ENGINE_PORT = 6420;
 var ENGINE_ENDPOINT = `http://localhost:${ENGINE_PORT}`;
 
 // src/inspector/config.ts
-import { z as z5 } from "zod";
+import { z as z3 } from "zod";
 var defaultTokenFn = () => {
   const envToken = getRivetkitInspectorToken();
   if (envToken) {
@@ -1783,31 +1646,95 @@ var defaultTokenFn = () => {
 var defaultEnabled = () => {
   return isDev() || !getRivetkitInspectorDisable();
 };
-var InspectorConfigSchema = z5.object({
-  enabled: z5.boolean().default(defaultEnabled),
+var InspectorConfigSchema = z3.object({
+  enabled: z3.boolean().default(defaultEnabled),
   /**
    * Token used to access the Inspector.
    */
-  token: z5.custom().optional().default(() => defaultTokenFn),
+  token: z3.custom().optional().default(() => defaultTokenFn),
   /**
    * Default RivetKit server endpoint for Rivet Inspector to connect to. This should be the same endpoint as what you use for your Rivet client to connect to RivetKit.
    *
    * This is a convenience property just for printing out the inspector URL.
    */
-  defaultEndpoint: z5.string().optional()
+  defaultEndpoint: z3.string().optional()
 }).optional().default(() => ({
   enabled: defaultEnabled(),
   token: defaultTokenFn
 }));
 
+// src/utils/endpoint-parser.ts
+function tryParseEndpoint(ctx, options) {
+  const { endpoint, path = ["endpoint"], namespace: configNamespace, token: configToken } = options;
+  let url;
+  try {
+    url = new URL(endpoint);
+  } catch {
+    ctx.addIssue({
+      code: "custom",
+      message: `invalid URL: ${endpoint}`,
+      path
+    });
+    return void 0;
+  }
+  if (url.search) {
+    ctx.addIssue({
+      code: "custom",
+      message: "endpoint cannot contain a query string",
+      path
+    });
+    return void 0;
+  }
+  if (url.hash) {
+    ctx.addIssue({
+      code: "custom",
+      message: "endpoint cannot contain a fragment",
+      path
+    });
+    return void 0;
+  }
+  const namespace = url.username ? decodeURIComponent(url.username) : void 0;
+  const token = url.password ? decodeURIComponent(url.password) : void 0;
+  if (token && !namespace) {
+    ctx.addIssue({
+      code: "custom",
+      message: "endpoint cannot have a token without a namespace",
+      path
+    });
+    return void 0;
+  }
+  if (namespace && configNamespace) {
+    ctx.addIssue({
+      code: "custom",
+      message: "cannot specify namespace both in endpoint URL and as a separate config option",
+      path: ["namespace"]
+    });
+  }
+  if (token && configToken) {
+    ctx.addIssue({
+      code: "custom",
+      message: "cannot specify token both in endpoint URL and as a separate config option",
+      path: ["token"]
+    });
+  }
+  url.username = "";
+  url.password = "";
+  const cleanedEndpoint = url.toString();
+  return {
+    endpoint: cleanedEndpoint,
+    namespace,
+    token
+  };
+}
+
 // src/registry/config/driver.ts
-import { z as z6 } from "zod";
-var DriverConfigSchema = z6.object({
+import { z as z4 } from "zod";
+var DriverConfigSchema = z4.object({
   /** Machine-readable name to identify this driver by. */
-  name: z6.string(),
-  displayName: z6.string(),
-  manager: z6.custom(),
-  actor: z6.custom(),
+  name: z4.string(),
+  displayName: z4.string(),
+  manager: z4.custom(),
+  actor: z4.custom(),
   /**
    * Start actor driver immediately or if this is started separately.
    *
@@ -1815,33 +1742,33 @@ var DriverConfigSchema = z6.object({
    * - Engine driver needs this to start immediately since this starts the Runner that connects to the engine
    * - Cloudflare Workers should not start it automatically, since the actor only runs in the DO
    * */
-  autoStartActorDriver: z6.boolean()
+  autoStartActorDriver: z4.boolean()
 });
 
 // src/registry/config/runner.ts
-import { z as z7 } from "zod";
-var RunnerConfigSchema = z7.object({
+import { z as z5 } from "zod";
+var RunnerConfigSchema = z5.object({
   // MARK: Runner
-  totalSlots: z7.number().default(() => getRivetTotalSlots() ?? 1e5),
-  runnerName: z7.string().default(() => getRivetRunner() ?? "default"),
-  runnerKey: z7.string().optional().transform((x) => x ?? getRivetRunnerKey()),
-  version: z7.number().default(() => getRivetRunnerVersion() ?? 1)
+  totalSlots: z5.number().default(() => getRivetTotalSlots() ?? 1e5),
+  runnerName: z5.string().default(() => getRivetRunner() ?? "default"),
+  runnerKey: z5.string().optional().transform((x) => x ?? getRivetRunnerKey()),
+  version: z5.number().default(() => getRivetRunnerVersion() ?? 1)
 });
 
 // src/registry/config/serverless.ts
-import { z as z8 } from "zod";
-var ConfigureRunnerPoolSchema = z8.object({
-  name: z8.string().optional(),
-  url: z8.string(),
-  headers: z8.record(z8.string(), z8.string()).optional(),
-  maxRunners: z8.number().optional(),
-  minRunners: z8.number().optional(),
-  requestLifespan: z8.number().optional(),
-  runnersMargin: z8.number().optional(),
-  slotsPerRunner: z8.number().optional(),
-  metadata: z8.record(z8.string(), z8.unknown()).optional()
+import { z as z6 } from "zod";
+var ConfigureRunnerPoolSchema = z6.object({
+  name: z6.string().optional(),
+  url: z6.string(),
+  headers: z6.record(z6.string(), z6.string()).optional(),
+  maxRunners: z6.number().optional(),
+  minRunners: z6.number().optional(),
+  requestLifespan: z6.number().optional(),
+  runnersMargin: z6.number().optional(),
+  slotsPerRunner: z6.number().optional(),
+  metadata: z6.record(z6.string(), z6.unknown()).optional()
 }).optional();
-var ServerlessConfigSchema = z8.object({
+var ServerlessConfigSchema = z6.object({
   // MARK: Run Engine
   /**
    * @experimental
@@ -1849,9 +1776,9 @@ var ServerlessConfigSchema = z8.object({
    * Downloads and starts the full Rust engine process.
    * Auto-enabled in development mode when no endpoint is provided.
    */
-  spawnEngine: z8.boolean().default(() => getRivetRunEngine()),
+  spawnEngine: z6.boolean().default(() => getRivetRunEngine()),
   /** @experimental */
-  engineVersion: z8.string().optional().default(() => getRivetRunEngineVersion() ?? VERSION),
+  engineVersion: z6.string().optional().default(() => getRivetRunEngineVersion() ?? VERSION),
   /**
    * @experimental
    *
@@ -1862,29 +1789,47 @@ var ServerlessConfigSchema = z8.object({
   configureRunnerPool: ConfigureRunnerPoolSchema.optional(),
   // MARK: Routing
   // TODO: serverlessBasePath? better naming?
-  basePath: z8.string().optional().default("/api/rivet"),
+  basePath: z6.string().optional().default("/api/rivet"),
+  // MARK: Public Endpoint Configuration
   /**
    * The endpoint that clients should connect to.
    *
    * This is useful if clients connect to serverless directly
    * (e.g. `http://localhost:3000/api/rivet`), they will fetch
    * `http://localhost:3000/api/rivet/metadata` and be redirected to
-   * the advertised endpoint.
+   * the public endpoint.
+   *
+   * Supports URL auth syntax for namespace and token:
+   * - `https://namespace:token@api.rivet.dev`
+   * - `https://namespace@api.rivet.dev`
    *
    * Auto-determined based on endpoint and NODE_ENV if not specified.
+   *
+   * Can also be set via RIVET_PUBLIC_ENDPOINT environment variable.
    */
-  advertiseEndpoint: z8.string().optional()
+  publicEndpoint: z6.string().optional().transform((val) => val ?? getRivetPublicEndpoint()),
+  /**
+   * Token that clients should use when connecting via the public endpoint.
+   *
+   * Can also be set via RIVET_PUBLIC_TOKEN environment variable.
+   *
+   * Can also be specified in the publicEndpoint URL as `https://namespace:token@host`.
+   */
+  publicToken: z6.string().optional().transform((val) => val ?? getRivetPublicToken())
+  // There is no publicNamespace config option because the frontend and backend
+  // cannot use different namespaces. The namespace is extracted from the
+  // publicEndpoint URL auth syntax if provided.
 });
 
 // src/registry/config/index.ts
-var ActorsSchema = z9.record(
-  z9.string(),
-  z9.custom()
+var ActorsSchema = z7.record(
+  z7.string(),
+  z7.custom()
 );
-var TestConfigSchema = z9.object({ enabled: z9.boolean() });
-var RegistryConfigSchema = z9.object({
+var TestConfigSchema = z7.object({ enabled: z7.boolean() });
+var RegistryConfigSchema = z7.object({
   // MARK: Actors
-  use: z9.record(z9.string(), z9.custom()),
+  use: z7.record(z7.string(), z7.custom()),
   // TODO: Find a better way of passing around the test config
   /**
    * Test configuration.
@@ -1897,21 +1842,21 @@ var RegistryConfigSchema = z9.object({
   driver: DriverConfigSchema.optional(),
   // MARK: Networking
   /** @experimental */
-  maxIncomingMessageSize: z9.number().optional().default(65536),
+  maxIncomingMessageSize: z7.number().optional().default(65536),
   /** @experimental */
-  maxOutgoingMessageSize: z9.number().optional().default(1048576),
+  maxOutgoingMessageSize: z7.number().optional().default(1048576),
   // MARK: Runtime
   /**
    * @experimental
    *
    * Disable welcome message.
    * */
-  noWelcome: z9.boolean().optional().default(false),
+  noWelcome: z7.boolean().optional().default(false),
   /**
    * @experimental
    * */
-  logging: z9.object({
-    baseLogger: z9.custom().optional(),
+  logging: z7.object({
+    baseLogger: z7.custom().optional(),
     level: LogLevelSchema.optional()
   }).optional().default(() => ({})),
   // MARK: Routing
@@ -1921,10 +1866,19 @@ var RegistryConfigSchema = z9.object({
   // // created or must be imported async using `await import(...)`
   // getUpgradeWebSocket: z.custom<GetUpgradeWebSocket>().optional(),
   // MARK: Runner Configuration
-  endpoint: EndpointSchema.optional(),
-  token: z9.string().optional(),
-  namespace: z9.string().optional(),
-  headers: z9.record(z9.string(), z9.string()).optional().default({}),
+  /**
+   * Endpoint to connect to for Rivet Engine.
+   *
+   * Supports URL auth syntax for namespace and token:
+   * - `https://namespace:token@api.rivet.dev`
+   * - `https://namespace@api.rivet.dev`
+   *
+   * Can also be set via RIVET_ENDPOINT environment variables.
+   */
+  endpoint: z7.string().optional().transform((val) => val ?? getRivetEngine() ?? getRivetEndpoint()),
+  token: z7.string().optional().transform((val) => val ?? getRivetToken()),
+  namespace: z7.string().optional().transform((val) => val ?? getRivetNamespace()),
+  headers: z7.record(z7.string(), z7.string()).optional().default({}),
   // MARK: Client
   // TODO:
   // client: ClientConfigSchema.optional(),
@@ -1933,7 +1887,7 @@ var RegistryConfigSchema = z9.object({
    * Whether to start the local manager server.
    * Auto-determined based on endpoint and NODE_ENV if not specified.
    */
-  serveManager: z9.boolean().optional(),
+  serveManager: z7.boolean().optional(),
   /**
    * @experimental
    *
@@ -1941,13 +1895,13 @@ var RegistryConfigSchema = z9.object({
    * For example, if the base path is `/foo`, then the route `/actors`
    * will be available at `/foo/actors`.
    */
-  managerBasePath: z9.string().optional().default("/"),
+  managerBasePath: z7.string().optional().default("/"),
   /**
    * @experimental
    *
    * What port to run the manager on.
    */
-  managerPort: z9.number().optional().default(6420),
+  managerPort: z7.number().optional().default(6420),
   /** @experimental */
   inspector: InspectorConfigSchema,
   // MARK: Runtime-specific
@@ -1958,58 +1912,49 @@ var RegistryConfigSchema = z9.object({
     () => RunnerConfigSchema.parse({})
   )
 }).transform((config6, ctx) => {
-  var _a;
   const isDevEnv = isDev();
-  const resolvedEndpoint = resolveEndpoint(config6.endpoint);
-  if (resolvedEndpoint) {
-    zodCheckDuplicateCredentials(resolvedEndpoint, config6, ctx);
-  }
-  if (resolvedEndpoint && config6.serveManager) {
+  const parsedEndpoint = config6.endpoint ? tryParseEndpoint(ctx, {
+    endpoint: config6.endpoint,
+    path: ["endpoint"],
+    namespace: config6.namespace,
+    token: config6.token
+  }) : void 0;
+  if (parsedEndpoint && config6.serveManager) {
     ctx.addIssue({
       code: "custom",
       message: "cannot specify both endpoint and serveManager"
     });
   }
-  if (config6.serverless) {
-    if (config6.serverless.spawnEngine && resolvedEndpoint) {
-      ctx.addIssue({
-        code: "custom",
-        message: "cannot specify both spawnEngine and endpoint"
-      });
-    }
-    if (config6.serverless.configureRunnerPool && !resolvedEndpoint && !config6.serverless.spawnEngine) {
-      ctx.addIssue({
-        code: "custom",
-        message: "configureRunnerPool requires either endpoint or spawnEngine"
-      });
-    }
-    if (!isDevEnv && !resolvedEndpoint && !config6.serverless.advertiseEndpoint) {
-      ctx.addIssue({
-        code: "custom",
-        message: "must specify either endpoint or advertiseEndpoint when in production mode",
-        path: ["advertiseEndpoint"]
-      });
-    }
+  if (config6.serverless.spawnEngine && parsedEndpoint) {
+    ctx.addIssue({
+      code: "custom",
+      message: "cannot specify both spawnEngine and endpoint"
+    });
   }
-  const endpoint = ((_a = config6.serverless) == null ? void 0 : _a.spawnEngine) ? ENGINE_ENDPOINT : resolvedEndpoint == null ? void 0 : resolvedEndpoint.endpoint;
-  const namespace = (resolvedEndpoint == null ? void 0 : resolvedEndpoint.namespace) ?? config6.namespace ?? getRivetNamespace() ?? "default";
-  const token = (resolvedEndpoint == null ? void 0 : resolvedEndpoint.token) ?? config6.token ?? getRivetToken();
-  let serveManager;
-  let advertiseEndpoint;
-  if (endpoint) {
-    serveManager = config6.serveManager ?? false;
-    advertiseEndpoint = config6.serverless.advertiseEndpoint ?? endpoint;
-  } else if (isDevEnv) {
-    serveManager = config6.serveManager ?? true;
-    advertiseEndpoint = config6.serverless.advertiseEndpoint ?? (serveManager ? `http://localhost:${config6.managerPort}` : void 0);
-  } else {
-    serveManager = config6.serveManager ?? false;
-    invariant2(
-      config6.serverless.advertiseEndpoint,
-      "advertiseEndpoint not specified in production mode"
-    );
-    advertiseEndpoint = config6.serverless.advertiseEndpoint;
+  if (config6.serverless.configureRunnerPool && !parsedEndpoint && !config6.serverless.spawnEngine) {
+    ctx.addIssue({
+      code: "custom",
+      message: "configureRunnerPool requires either endpoint or spawnEngine"
+    });
   }
+  const endpoint = config6.serverless.spawnEngine ? ENGINE_ENDPOINT : parsedEndpoint == null ? void 0 : parsedEndpoint.endpoint;
+  const namespace = (parsedEndpoint == null ? void 0 : parsedEndpoint.namespace) ?? config6.namespace ?? "default";
+  const token = (parsedEndpoint == null ? void 0 : parsedEndpoint.token) ?? config6.token;
+  const parsedPublicEndpoint = config6.serverless.publicEndpoint ? tryParseEndpoint(ctx, {
+    endpoint: config6.serverless.publicEndpoint,
+    path: ["serverless", "publicEndpoint"]
+  }) : void 0;
+  if ((parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.namespace) && parsedPublicEndpoint.namespace !== namespace) {
+    ctx.addIssue({
+      code: "custom",
+      message: `publicEndpoint namespace "${parsedPublicEndpoint.namespace}" must match backend namespace "${namespace}"`,
+      path: ["serverless", "publicEndpoint"]
+    });
+  }
+  const serveManager = config6.serveManager ?? (isDevEnv && !endpoint);
+  const publicEndpoint = (parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.endpoint) ?? (isDevEnv && serveManager ? `http://localhost:${config6.managerPort}` : void 0);
+  const publicNamespace = parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.namespace;
+  const publicToken = (parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.token) ?? config6.serverless.publicToken;
   const willUseEngine = !!endpoint || config6.serverless.spawnEngine;
   const inspector = willUseEngine ? {
     ...config6.inspector,
@@ -2021,11 +1966,13 @@ var RegistryConfigSchema = z9.object({
     namespace,
     token,
     serveManager,
-    advertiseEndpoint,
+    publicEndpoint,
+    publicNamespace,
+    publicToken,
     inspector,
     serverless: {
       ...config6.serverless,
-      advertiseEndpoint
+      publicEndpoint
     }
   };
 });
@@ -2103,7 +2050,7 @@ function handleRouteError(error, c) {
   );
   return c.body(output, { status: statusCode });
 }
-function handleMetadataRequest(c, config6, runnerKind, clientEndpoint) {
+function handleMetadataRequest(c, config6, runnerKind, clientEndpoint, clientNamespace, clientToken) {
   const response = {
     runtime: "rivetkit",
     version: VERSION,
@@ -2111,7 +2058,9 @@ function handleMetadataRequest(c, config6, runnerKind, clientEndpoint) {
       kind: runnerKind
     },
     actorNames: buildActorNames(config6),
-    clientEndpoint
+    clientEndpoint,
+    clientNamespace,
+    clientToken
   };
   return c.json(response);
 }
@@ -2124,76 +2073,76 @@ function handleHealthRequest(c) {
 }
 
 // src/manager-api/actors.ts
-import { z as z11 } from "zod";
+import { z as z9 } from "zod";
 
 // src/manager-api/common.ts
-import { z as z10 } from "zod";
-var RivetIdSchema = z10.string();
+import { z as z8 } from "zod";
+var RivetIdSchema = z8.string();
 
 // src/manager-api/actors.ts
-var ServerlessConnectionErrorSchema = z11.union([
-  z11.object({ http_error: z11.object({ status_code: z11.number(), body: z11.string() }) }),
-  z11.literal("stream_ended_early"),
-  z11.object({ connection_error: z11.object({ message: z11.string() }) }),
-  z11.literal("invalid_base64"),
-  z11.object({ invalid_payload: z11.object({ message: z11.string() }) }),
-  z11.literal("runner_config_not_found"),
-  z11.literal("runner_config_not_serverless"),
-  z11.literal("namespace_not_found")
+var ServerlessConnectionErrorSchema = z9.union([
+  z9.object({ http_error: z9.object({ status_code: z9.number(), body: z9.string() }) }),
+  z9.literal("stream_ended_early"),
+  z9.object({ connection_error: z9.object({ message: z9.string() }) }),
+  z9.literal("invalid_base64"),
+  z9.object({ invalid_payload: z9.object({ message: z9.string() }) }),
+  z9.literal("runner_config_not_found"),
+  z9.literal("runner_config_not_serverless"),
+  z9.literal("namespace_not_found")
 ]);
-var ActorErrorDetailsSchema = z11.union([
-  z11.object({ serverless_error: ServerlessConnectionErrorSchema }),
-  z11.object({ no_capacity: z11.object({ runner_name: z11.string() }) }),
-  z11.object({ runner_no_response: z11.object({ runner_id: z11.string() }) })
+var ActorErrorDetailsSchema = z9.union([
+  z9.object({ serverless_error: ServerlessConnectionErrorSchema }),
+  z9.object({ no_capacity: z9.object({ runner_name: z9.string() }) }),
+  z9.object({ runner_no_response: z9.object({ runner_id: z9.string() }) })
 ]);
-var ActorSchema = z11.object({
+var ActorSchema = z9.object({
   actor_id: RivetIdSchema,
-  name: z11.string(),
-  key: z11.string(),
+  name: z9.string(),
+  key: z9.string(),
   namespace_id: RivetIdSchema,
-  runner_name_selector: z11.string(),
-  create_ts: z11.number(),
-  connectable_ts: z11.number().nullable().optional(),
-  destroy_ts: z11.number().nullable().optional(),
-  sleep_ts: z11.number().nullable().optional(),
-  start_ts: z11.number().nullable().optional(),
+  runner_name_selector: z9.string(),
+  create_ts: z9.number(),
+  connectable_ts: z9.number().nullable().optional(),
+  destroy_ts: z9.number().nullable().optional(),
+  sleep_ts: z9.number().nullable().optional(),
+  start_ts: z9.number().nullable().optional(),
   error: ActorErrorDetailsSchema.nullable().optional()
 });
-var ActorNameSchema = z11.object({
-  metadata: z11.record(z11.string(), z11.unknown())
+var ActorNameSchema = z9.object({
+  metadata: z9.record(z9.string(), z9.unknown())
 });
-var ActorsListResponseSchema = z11.object({
-  actors: z11.array(ActorSchema)
+var ActorsListResponseSchema = z9.object({
+  actors: z9.array(ActorSchema)
 });
-var ActorsCreateRequestSchema = z11.object({
-  datacenter: z11.string().optional(),
-  name: z11.string(),
-  runner_name_selector: z11.string(),
-  crash_policy: z11.string(),
-  key: z11.string().nullable().optional(),
-  input: z11.string().nullable().optional()
+var ActorsCreateRequestSchema = z9.object({
+  datacenter: z9.string().optional(),
+  name: z9.string(),
+  runner_name_selector: z9.string(),
+  crash_policy: z9.string(),
+  key: z9.string().nullable().optional(),
+  input: z9.string().nullable().optional()
 });
-var ActorsCreateResponseSchema = z11.object({
+var ActorsCreateResponseSchema = z9.object({
   actor: ActorSchema
 });
-var ActorsGetOrCreateRequestSchema = z11.object({
-  datacenter: z11.string().optional(),
-  name: z11.string(),
-  key: z11.string(),
-  runner_name_selector: z11.string(),
-  crash_policy: z11.string(),
-  input: z11.string().nullable().optional()
+var ActorsGetOrCreateRequestSchema = z9.object({
+  datacenter: z9.string().optional(),
+  name: z9.string(),
+  key: z9.string(),
+  runner_name_selector: z9.string(),
+  crash_policy: z9.string(),
+  input: z9.string().nullable().optional()
 });
-var ActorsGetOrCreateResponseSchema = z11.object({
+var ActorsGetOrCreateResponseSchema = z9.object({
   actor: ActorSchema,
-  created: z11.boolean()
+  created: z9.boolean()
 });
-var ActorsDeleteResponseSchema = z11.object({});
-var ActorsListNamesResponseSchema = z11.object({
-  names: z11.record(z11.string(), ActorNameSchema)
+var ActorsDeleteResponseSchema = z9.object({});
+var ActorsListNamesResponseSchema = z9.object({
+  names: z9.record(z9.string(), ActorNameSchema)
 });
-var ActorsKvGetResponseSchema = z11.object({
-  value: z11.string().nullable()
+var ActorsKvGetResponseSchema = z9.object({
+  value: z9.string().nullable()
 });
 
 // src/utils/crypto.ts
@@ -2301,10 +2250,10 @@ function buildOpenApiRequestBody(schema) {
 }
 
 // src/manager/gateway.ts
-import invariant5 from "invariant";
+import invariant4 from "invariant";
 
 // src/actor/router-websocket-endpoints.ts
-import invariant4 from "invariant";
+import invariant3 from "invariant";
 
 // src/inspector/log.ts
 function inspectorLogger() {
@@ -2615,7 +2564,7 @@ import * as cbor4 from "cbor-x";
 
 // src/actor/conn/state-manager.ts
 import onChange from "@rivetkit/on-change";
-import invariant3 from "invariant";
+import invariant2 from "invariant";
 var StateManager = class {
   #conn;
   /**
@@ -2669,7 +2618,7 @@ var StateManager = class {
   }
   hibernatableDataOrError() {
     const hibernatable = this.hibernatableData;
-    invariant3(hibernatable, "missing hibernatable data");
+    invariant2(hibernatable, "missing hibernatable data");
     return hibernatable;
   }
   get hibernatableDataRaw() {
@@ -3315,7 +3264,7 @@ async function handleRawWebSocket(setWebSocket, { request, actor, closePromiseRe
     actor,
     onRestore: (wsContext) => {
       const ws = wsContext.raw;
-      invariant4(ws, "missing wsContext.raw");
+      invariant3(ws, "missing wsContext.raw");
       setWebSocket(ws);
     },
     // NOTE: onOpen cannot be async since this will cause the client's open
@@ -3323,7 +3272,7 @@ async function handleRawWebSocket(setWebSocket, { request, actor, closePromiseRe
     // handleRawWebSocket root.
     onOpen: (_evt, wsContext) => {
       const ws = wsContext.raw;
-      invariant4(ws, "missing wsContext.raw");
+      invariant3(ws, "missing wsContext.raw");
       setWebSocket(ws);
       actor.connectionManager.connectConn(conn);
       actor.handleRawWebSocket(conn, ws, request);
@@ -3613,7 +3562,7 @@ async function createTestWebSocketProxy(proxyToActorWsPromise) {
       constructor: proxyToActorWs == null ? void 0 : proxyToActorWs.constructor.name
     });
     await new Promise((resolve, reject) => {
-      invariant5(proxyToActorWs, "missing proxyToActorWs");
+      invariant4(proxyToActorWs, "missing proxyToActorWs");
       const onOpen = () => {
         logger3().debug({
           msg: "test websocket connection to actor opened"
@@ -3803,10 +3752,10 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
         method: "get",
         path: "/actors",
         request: {
-          query: z12.object({
-            name: z12.string().optional(),
-            actor_ids: z12.string().optional(),
-            key: z12.string().optional()
+          query: z10.object({
+            name: z10.string().optional(),
+            actor_ids: z10.string().optional(),
+            key: z10.string().optional()
           })
         },
         responses: buildOpenApiResponses(ActorsListResponseSchema)
@@ -3906,8 +3855,8 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
         method: "get",
         path: "/actors/names",
         request: {
-          query: z12.object({
-            namespace: z12.string()
+          query: z10.object({
+            namespace: z10.string()
           })
         },
         responses: buildOpenApiResponses(ActorsListNamesResponseSchema)
@@ -3990,9 +3939,9 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
         method: "get",
         path: "/actors/{actor_id}/kv/keys/{key}",
         request: {
-          params: z12.object({
-            actor_id: z12.string(),
-            key: z12.string()
+          params: z10.object({
+            actor_id: z10.string(),
+            key: z10.string()
           })
         },
         responses: buildOpenApiResponses(ActorsKvGetResponseSchema)
@@ -4046,7 +3995,7 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
       });
       router.get(".test/inline-driver/connect-websocket/*", async (c) => {
         const upgradeWebSocket = getUpgradeWebSocket == null ? void 0 : getUpgradeWebSocket();
-        invariant6(
+        invariant5(
           upgradeWebSocket,
           "websockets not supported on this platform"
         );
@@ -4186,7 +4135,14 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
     router.get("/health", (c) => handleHealthRequest(c));
     router.get(
       "/metadata",
-      (c) => handleMetadataRequest(c, config6, { normal: {} }, void 0)
+      (c) => handleMetadataRequest(
+        c,
+        config6,
+        { normal: {} },
+        config6.publicEndpoint,
+        config6.publicNamespace,
+        config6.publicToken
+      )
     );
     (_a = managerDriver.modifyManagerRouter) == null ? void 0 : _a.call(managerDriver, config6, router);
   });
@@ -4937,6 +4893,7 @@ export {
   generateSecureToken,
   isStatePath,
   isConnStatePath,
+  EncodingSchema,
   CachedSerializer,
   jsonStringifyCompat,
   CONN_CONNECTED_SYMBOL,
@@ -4982,13 +4939,10 @@ export {
   ALLOWED_PUBLIC_HEADERS,
   handleAction,
   handleRawRequest,
-  ClientConfigSchemaBase,
-  ClientConfigSchema,
-  transformClientConfig,
-  convertRegistryConfigToClientConfig,
   ENGINE_PORT,
   ENGINE_ENDPOINT,
   InspectorConfigSchema,
+  tryParseEndpoint,
   DriverConfigSchema,
   ActorsSchema,
   TestConfigSchema,
@@ -5006,4 +4960,4 @@ export {
   buildManagerRouter,
   getInitialActorKvState
 };
-//# sourceMappingURL=chunk-ESNM74WZ.js.map
+//# sourceMappingURL=chunk-KJLJLNHR.js.map