rivetkit 2.1.4 → 2.1.6-rc.1

package/dist/tsup/chunk-C4EB42ET.js

@@ -0,0 +1,1459 @@
+import {
+  ACTOR_VERSIONED,
+  CURRENT_VERSION2 as CURRENT_VERSION,
+  HEADER_ACTOR_ID,
+  HEADER_RIVET_ACTOR,
+  HEADER_RIVET_TARGET,
+  HEADER_RIVET_TOKEN,
+  WS_PROTOCOL_ACTOR,
+  WS_PROTOCOL_CONN_PARAMS,
+  WS_PROTOCOL_ENCODING,
+  WS_TEST_PROTOCOL_PATH,
+  buildActorNames,
+  deserializeActorKey,
+  handleHealthRequest,
+  handleMetadataRequest,
+  handleRouteError,
+  handleRouteNotFound,
+  loggerMiddleware,
+  parseWebSocketProtocols,
+  serializeActorKey,
+  timingSafeEqual
+} from "./chunk-PQWI44WD.js";
+import {
+  KEYS
+} from "./chunk-C22JYHVT.js";
+import {
+  bufferToArrayBuffer,
+  deconstructError,
+  detectRuntime,
+  getLogger,
+  isDev,
+  noopNext,
+  promiseWithResolvers,
+  stringifyError
+} from "./chunk-VWYO36X4.js";
+import {
+  Forbidden,
+  MissingActorHeader,
+  RestrictedFeature,
+  WebSocketsNotEnabled
+} from "./chunk-AKUJ5OTO.js";
+
+// src/manager/router.ts
+import { createRoute } from "@hono/zod-openapi";
+import * as cbor from "cbor-x";
+import invariant2 from "invariant";
+import { z as z3 } from "zod/v4";
+
+// src/inspector/serve-ui.ts
+import { extract } from "tar";
+
+// src/utils/node.ts
+import { createRequire } from "module";
+var nodeCrypto;
+var nodeFsSync;
+var nodeFs;
+var nodePath;
+var nodeOs;
+var nodeChildProcess;
+var nodeStream;
+var nodeUrl;
+var hasImportedDependencies = false;
+function getRequireFn() {
+  return createRequire(import.meta.url);
+}
+function importNodeDependencies() {
+  if (hasImportedDependencies) return;
+  try {
+    const requireFn = getRequireFn();
+    nodeCrypto = requireFn(
+      /* webpackIgnore: true */
+      "node:crypto"
+    );
+    nodeFsSync = requireFn(
+      /* webpackIgnore: true */
+      "node:fs"
+    );
+    nodeFs = requireFn(
+      /* webpackIgnore: true */
+      "node:fs/promises"
+    );
+    nodePath = requireFn(
+      /* webpackIgnore: true */
+      "node:path"
+    );
+    nodeOs = requireFn(
+      /* webpackIgnore: true */
+      "node:os"
+    );
+    nodeChildProcess = requireFn(
+      /* webpackIgnore: true */
+      "node:child_process"
+    );
+    nodeStream = requireFn(
+      /* webpackIgnore: true */
+      "node:stream/promises"
+    );
+    nodeUrl = requireFn(
+      /* webpackIgnore: true */
+      "node:url"
+    );
+    hasImportedDependencies = true;
+  } catch (err) {
+    console.warn(
+      "Node.js modules not available, file system driver will not work",
+      err
+    );
+    throw err;
+  }
+}
+function getNodeCrypto() {
+  if (!nodeCrypto) {
+    throw new Error(
+      "Node crypto module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeCrypto;
+}
+function getNodeFsSync() {
+  if (!nodeFsSync) {
+    throw new Error(
+      "Node fs module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeFsSync;
+}
+function getNodeFs() {
+  if (!nodeFs) {
+    throw new Error(
+      "Node fs/promises module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeFs;
+}
+function getNodePath() {
+  if (!nodePath) {
+    throw new Error(
+      "Node path module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodePath;
+}
+function getNodeOs() {
+  if (!nodeOs) {
+    throw new Error(
+      "Node os module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeOs;
+}
+function getNodeChildProcess() {
+  if (!nodeChildProcess) {
+    throw new Error(
+      "Node child_process module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeChildProcess;
+}
+function getNodeStream() {
+  if (!nodeStream) {
+    throw new Error(
+      "Node stream/promises module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeStream;
+}
+function getNodeUrl() {
+  if (!nodeUrl) {
+    throw new Error(
+      "Node url module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeUrl;
+}
+
+// src/inspector/serve-ui.ts
+var extractedDir;
+var extractionPromise;
+async function getInspectorDir() {
+  if (extractedDir !== void 0) return extractedDir;
+  if (extractionPromise !== void 0) return extractionPromise;
+  const nodeFs2 = getNodeFs();
+  const os = getNodeOs();
+  const url = getNodeUrl();
+  const path = getNodePath();
+  extractionPromise = (async () => {
+    const tarball = path.join(
+      path.dirname(url.fileURLToPath(import.meta.url)),
+      "../../dist/inspector.tar.gz"
+    );
+    try {
+      await nodeFs2.access(tarball);
+    } catch {
+      throw new Error(
+        `Inspector tarball not found at ${tarball}. Run 'pnpm build:pack-inspector' first.`
+      );
+    }
+    const dest = path.join(os.tmpdir(), "rivetkit-inspector");
+    await nodeFs2.mkdir(dest, { recursive: true });
+    await extract({ file: tarball, cwd: dest });
+    extractedDir = dest;
+    return dest;
+  })();
+  return extractionPromise;
+}
+
+// src/manager-api/actors.ts
+import { z as z2 } from "zod/v4";
+
+// src/manager-api/common.ts
+import { z } from "zod/v4";
+var RivetIdSchema = z.string();
+
+// src/manager-api/actors.ts
+var ActorSchema = z2.object({
+  actor_id: RivetIdSchema,
+  name: z2.string(),
+  key: z2.string(),
+  namespace_id: RivetIdSchema,
+  runner_name_selector: z2.string(),
+  create_ts: z2.number(),
+  connectable_ts: z2.number().nullable().optional(),
+  destroy_ts: z2.number().nullable().optional(),
+  sleep_ts: z2.number().nullable().optional(),
+  start_ts: z2.number().nullable().optional(),
+  error: z2.unknown().nullable().optional()
+});
+var ActorNameSchema = z2.object({
+  metadata: z2.record(z2.string(), z2.unknown())
+});
+var ActorsListResponseSchema = z2.object({
+  actors: z2.array(ActorSchema)
+});
+var ActorsCreateRequestSchema = z2.object({
+  datacenter: z2.string().optional(),
+  name: z2.string(),
+  runner_name_selector: z2.string(),
+  crash_policy: z2.string(),
+  key: z2.string().nullable().optional(),
+  input: z2.string().nullable().optional()
+});
+var ActorsCreateResponseSchema = z2.object({
+  actor: ActorSchema
+});
+var ActorsGetOrCreateRequestSchema = z2.object({
+  datacenter: z2.string().optional(),
+  name: z2.string(),
+  key: z2.string(),
+  runner_name_selector: z2.string(),
+  crash_policy: z2.string(),
+  input: z2.string().nullable().optional()
+});
+var ActorsGetOrCreateResponseSchema = z2.object({
+  actor: ActorSchema,
+  created: z2.boolean()
+});
+var ActorsDeleteResponseSchema = z2.object({});
+var ActorsListNamesResponseSchema = z2.object({
+  names: z2.record(z2.string(), ActorNameSchema)
+});
+var ActorsKvGetResponseSchema = z2.object({
+  value: z2.string().nullable()
+});
+
+// src/registry/log.ts
+function logger() {
+  return getLogger("registry");
+}
+
+// src/utils/serve.ts
+import getPort from "get-port";
+var DEFAULT_PORT = 6420;
+var serveStaticLoaderPromises = {};
+async function findFreePort(startPort = DEFAULT_PORT) {
+  function* portRange(start, count = 100) {
+    for (let i = 0; i < count; i++) {
+      yield start + i;
+    }
+  }
+  return getPort({ port: portRange(startPort) });
+}
+async function crossPlatformServe(config, managerPort, app, runtime = detectRuntime()) {
+  logger().debug({ msg: "detected runtime for serve", runtime });
+  switch (runtime) {
+    case "deno":
+      return serveDeno(config, managerPort, app);
+    case "bun":
+      return serveBun(config, managerPort, app);
+    case "node":
+      return serveNode(config, managerPort, app);
+    default:
+      return serveNode(config, managerPort, app);
+  }
+}
+async function loadRuntimeServeStatic(runtime) {
+  if (!serveStaticLoaderPromises[runtime]) {
+    if (runtime === "node") {
+      const nodeServeStaticModule = "@hono/node-server/serve-static";
+      serveStaticLoaderPromises[runtime] = import(
+        /* webpackIgnore: true */
+        nodeServeStaticModule
+      ).then((x) => x.serveStatic);
+    } else if (runtime === "bun") {
+      const bunModule = "hono/bun";
+      serveStaticLoaderPromises[runtime] = import(
+        /* webpackIgnore: true */
+        bunModule
+      ).then((x) => x.serveStatic);
+    } else if (runtime === "deno") {
+      const denoModule = "hono/deno";
+      serveStaticLoaderPromises[runtime] = import(
+        /* webpackIgnore: true */
+        denoModule
+      ).then((x) => x.serveStatic);
+    } else {
+      throw new Error(`unsupported runtime: ${runtime}`);
+    }
+  }
+  return await serveStaticLoaderPromises[runtime];
+}
+async function serveNode(config, managerPort, app) {
+  const nodeServerModule = "@hono/node-server";
+  let serve;
+  try {
+    const dep = await import(
+      /* webpackIgnore: true */
+      nodeServerModule
+    );
+    serve = dep.serve;
+  } catch (err) {
+    logger().error({
+      msg: "failed to import @hono/node-server. please run 'npm install @hono/node-server @hono/node-ws'",
+      error: stringifyError(err)
+    });
+    process.exit(1);
+  }
+  const nodeWsModule = "@hono/node-ws";
+  let createNodeWebSocket;
+  try {
+    const dep = await import(
+      /* webpackIgnore: true */
+      nodeWsModule
+    );
+    createNodeWebSocket = dep.createNodeWebSocket;
+  } catch (err) {
+    logger().error({
+      msg: "failed to import @hono/node-ws. please run 'npm install @hono/node-server @hono/node-ws'",
+      error: stringifyError(err)
+    });
+    process.exit(1);
+  }
+  const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({
+    app
+  });
+  const port = managerPort;
+  const hostname = config.managerHost;
+  const server = serve(
+    { fetch: app.fetch, port, hostname },
+    () => logger().info({ msg: "server listening", port, hostname })
+  );
+  injectWebSocket(server);
+  const closeServer = () => {
+    server.close();
+  };
+  return { upgradeWebSocket, closeServer };
+}
+async function serveDeno(config, managerPort, app) {
+  const honoDenoModule = "hono/deno";
+  let upgradeWebSocket;
+  try {
+    const dep = await import(
+      /* webpackIgnore: true */
+      honoDenoModule
+    );
+    upgradeWebSocket = dep.upgradeWebSocket;
+  } catch (err) {
+    logger().error({
+      msg: "failed to import hono/deno",
+      error: stringifyError(err)
+    });
+    process.exit(1);
+  }
+  const port = config.managerPort;
+  const hostname = config.managerHost;
+  Deno.serve({ port, hostname }, app.fetch);
+  logger().info({ msg: "server listening", port, hostname });
+  return { upgradeWebSocket };
+}
+async function serveBun(config, managerPort, app) {
+  const honoBunModule = "hono/bun";
+  let createBunWebSocket;
+  try {
+    const dep = await import(
+      /* webpackIgnore: true */
+      honoBunModule
+    );
+    createBunWebSocket = dep.createBunWebSocket;
+  } catch (err) {
+    logger().error({
+      msg: "failed to import hono/bun",
+      error: stringifyError(err)
+    });
+    process.exit(1);
+  }
+  const { websocket, upgradeWebSocket } = createBunWebSocket();
+  const port = config.managerPort;
+  const hostname = config.managerHost;
+  Bun.serve({
+    fetch: app.fetch,
+    port,
+    hostname,
+    websocket
+  });
+  logger().info({ msg: "server listening", port, hostname });
+  return { upgradeWebSocket };
+}
+
+// src/utils/router.ts
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { createMiddleware } from "hono/factory";
+
+// src/common/cors.ts
+var cors = () => {
+  return async (c, next) => {
+    const origin = c.req.header("origin") || "*";
+    if (c.req.method === "OPTIONS") {
+      const requestHeaders = c.req.header("access-control-request-headers") || "*";
+      c.header("access-control-allow-origin", origin);
+      c.header("access-control-allow-credentials", "true");
+      c.header(
+        "access-control-allow-methods",
+        "GET, POST, PUT, DELETE, OPTIONS, PATCH"
+      );
+      c.header("access-control-allow-headers", requestHeaders);
+      c.header("access-control-expose-headers", "*");
+      c.header("access-control-max-age", "86400");
+      if (origin !== "*") {
+        c.header("vary", "Origin");
+      }
+      c.res.headers.delete("content-length");
+      c.res.headers.delete("content-type");
+      return c.body(null, 204);
+    }
+    await next();
+    c.header("access-control-allow-origin", origin);
+    c.header("access-control-allow-credentials", "true");
+    c.header("access-control-expose-headers", "*");
+    if (origin !== "*") {
+      c.header("vary", "Origin");
+    }
+  };
+};
+
+// src/utils/router.ts
+function logger2() {
+  return getLogger("router");
+}
+function createRouter(basePath, builder) {
+  const router = new OpenAPIHono({ strict: false }).basePath(basePath);
+  router.use("*", loggerMiddleware(logger2()), cors());
+  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();
+    })
+  );
+  builder(router);
+  router.notFound(handleRouteNotFound);
+  router.onError(handleRouteError);
+  return { router, openapi: router };
+}
+function buildOpenApiResponses(schema) {
+  return {
+    200: {
+      description: "Success",
+      content: {
+        "application/json": {
+          schema
+        }
+      }
+    },
+    400: {
+      description: "User error"
+    },
+    500: {
+      description: "Internal error"
+    }
+  };
+}
+function buildOpenApiRequestBody(schema) {
+  return {
+    required: true,
+    content: {
+      "application/json": {
+        schema
+      }
+    }
+  };
+}
+
+// src/manager/gateway.ts
+import invariant from "invariant";
+
+// src/manager/log.ts
+function logger3() {
+  return getLogger("actor-manager");
+}
+
+// src/manager/gateway.ts
+async function handleWebSocketGatewayPathBased(config, managerDriver, c, actorPathInfo, getUpgradeWebSocket) {
+  const upgradeWebSocket = getUpgradeWebSocket == null ? void 0 : getUpgradeWebSocket();
+  if (!upgradeWebSocket) {
+    throw new WebSocketsNotEnabled();
+  }
+  const { encoding, connParams } = parseWebSocketProtocols(
+    c.req.header("sec-websocket-protocol")
+  );
+  logger3().debug({
+    msg: "proxying websocket to actor via path-based routing",
+    actorId: actorPathInfo.actorId,
+    path: actorPathInfo.remainingPath,
+    encoding
+  });
+  return await managerDriver.proxyWebSocket(
+    c,
+    actorPathInfo.remainingPath,
+    actorPathInfo.actorId,
+    encoding,
+    // Will be validated by driver
+    connParams
+  );
+}
+async function handleHttpGatewayPathBased(managerDriver, c, actorPathInfo) {
+  logger3().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(config, managerDriver, getUpgradeWebSocket, c, next) {
+  if (c.req.path.startsWith("/.test/")) {
+    return next();
+  }
+  let strippedPath = c.req.path;
+  if (config.managerBasePath && strippedPath.startsWith(config.managerBasePath)) {
+    strippedPath = strippedPath.slice(config.managerBasePath.length);
+    if (!strippedPath.startsWith("/")) {
+      strippedPath = "/" + strippedPath;
+    }
+  }
+  const pathWithQuery = c.req.url.includes("?") ? strippedPath + c.req.url.substring(c.req.url.indexOf("?")) : strippedPath;
+  const actorPathInfo = parseActorPath(pathWithQuery);
+  if (actorPathInfo) {
+    logger3().debug({
+      msg: "routing using path-based actor routing",
+      actorPathInfo
+    });
+    const isWebSocket = c.req.header("upgrade") === "websocket";
+    if (isWebSocket) {
+      return await handleWebSocketGatewayPathBased(
+        config,
+        managerDriver,
+        c,
+        actorPathInfo,
+        getUpgradeWebSocket
+      );
+    }
+    return await handleHttpGatewayPathBased(
+      managerDriver,
+      c,
+      actorPathInfo
+    );
+  }
+  if (c.req.header("upgrade") === "websocket") {
+    return await handleWebSocketGateway(
+      config,
+      managerDriver,
+      getUpgradeWebSocket,
+      c,
+      strippedPath
+    );
+  }
+  return await handleHttpGateway(managerDriver, c, next, strippedPath);
+}
+async function handleWebSocketGateway(config, managerDriver, getUpgradeWebSocket, c, strippedPath) {
+  const upgradeWebSocket = getUpgradeWebSocket == null ? void 0 : getUpgradeWebSocket();
+  if (!upgradeWebSocket) {
+    throw new WebSocketsNotEnabled();
+  }
+  let target;
+  let actorId;
+  const { encoding, connParams } = parseWebSocketProtocols(
+    c.req.header("sec-websocket-protocol")
+  );
+  if (target !== "actor") {
+    return c.text("WebSocket upgrade requires target.actor protocol", 400);
+  }
+  if (!actorId) {
+    throw new MissingActorHeader();
+  }
+  logger3().debug({
+    msg: "proxying websocket to actor",
+    actorId,
+    path: strippedPath,
+    encoding
+  });
+  const pathWithQuery = c.req.url.includes("?") ? strippedPath + c.req.url.substring(c.req.url.indexOf("?")) : strippedPath;
+  return await managerDriver.proxyWebSocket(
+    c,
+    pathWithQuery,
+    actorId,
+    encoding,
+    connParams
+  );
+}
+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") {
+    return next();
+  }
+  if (!actorId) {
+    throw new MissingActorHeader();
+  }
+  logger3().debug({
+    msg: "proxying request to actor",
+    actorId,
+    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${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,
+    duplex: "half"
+  });
+  return await managerDriver.proxyRequest(c, proxyRequest, actorId);
+}
+function parseActorPath(path) {
+  const queryPos = path.indexOf("?");
+  const fragmentPos = path.indexOf("#");
+  let queryString = "";
+  if (queryPos !== -1) {
+    if (fragmentPos !== -1 && queryPos < fragmentPos) {
+      queryString = path.slice(queryPos, fragmentPos);
+    } else {
+      queryString = path.slice(queryPos);
+    }
+  }
+  let basePath = path;
+  if (queryPos !== -1) {
+    basePath = path.slice(0, queryPos);
+  } else if (fragmentPos !== -1) {
+    basePath = path.slice(0, fragmentPos);
+  }
+  if (basePath.includes("//")) {
+    return null;
+  }
+  const segments = basePath.split("/").filter((s) => s.length > 0);
+  if (segments.length < 2) {
+    return null;
+  }
+  if (segments[0] !== "gateway") {
+    return null;
+  }
+  const actorSegment = segments[1];
+  if (actorSegment.length === 0) {
+    return null;
+  }
+  let actorId;
+  let token;
+  const atPos = actorSegment.indexOf("@");
+  if (atPos !== -1) {
+    const rawActorId = actorSegment.slice(0, atPos);
+    const rawToken = actorSegment.slice(atPos + 1);
+    if (rawActorId.length === 0 || rawToken.length === 0) {
+      return null;
+    }
+    try {
+      actorId = decodeURIComponent(rawActorId);
+      token = decodeURIComponent(rawToken);
+    } catch (e) {
+      return null;
+    }
+  } else {
+    try {
+      actorId = decodeURIComponent(actorSegment);
+    } catch (e) {
+      return null;
+    }
+    token = void 0;
+  }
+  let prefixLen = 0;
+  for (let i = 0; i < 2; 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(proxyToActorWsPromise) {
+  let proxyToActorWs = null;
+  const {
+    promise: clientToProxyWsPromise,
+    resolve: clientToProxyWsResolve,
+    reject: clientToProxyWsReject
+  } = promiseWithResolvers(
+    (reason) => logger3().warn({
+      msg: "unhandled client websocket promise rejection",
+      reason
+    })
+  );
+  try {
+    logger3().debug({ msg: "awaiting client websocket promise" });
+    proxyToActorWs = await proxyToActorWsPromise;
+    logger3().debug({
+      msg: "client websocket promise resolved",
+      constructor: proxyToActorWs == null ? void 0 : proxyToActorWs.constructor.name
+    });
+    await new Promise((resolve, reject) => {
+      invariant(proxyToActorWs, "missing proxyToActorWs");
+      const onOpen = () => {
+        logger3().debug({
+          msg: "test websocket connection to actor opened"
+        });
+        resolve();
+      };
+      const onError = (error) => {
+        logger3().error({
+          msg: "test websocket connection failed",
+          error
+        });
+        reject(
+          new Error(
+            `Failed to open WebSocket: ${error.message || error}`
+          )
+        );
+        clientToProxyWsReject();
+      };
+      proxyToActorWs.addEventListener("open", onOpen);
+      proxyToActorWs.addEventListener("error", onError);
+      proxyToActorWs.addEventListener(
+        "message",
+        async (clientEvt) => {
+          var _a, _b;
+          const clientToProxyWs = await clientToProxyWsPromise;
+          logger3().debug({
+            msg: `test websocket connection message from client`,
+            dataType: typeof clientEvt.data,
+            isBlob: clientEvt.data instanceof Blob,
+            isArrayBuffer: clientEvt.data instanceof ArrayBuffer,
+            dataConstructor: (_b = (_a = clientEvt.data) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name,
+            dataStr: typeof clientEvt.data === "string" ? clientEvt.data.substring(0, 100) : void 0
+          });
+          if (clientToProxyWs.readyState === 1) {
+            if (clientEvt.data instanceof Blob) {
+              clientEvt.data.arrayBuffer().then((buffer) => {
+                logger3().debug({
+                  msg: "converted client blob to arraybuffer, sending to server",
+                  bufferSize: buffer.byteLength
+                });
+                clientToProxyWs.send(buffer);
+              }).catch((error) => {
+                logger3().error({
+                  msg: "failed to convert blob to arraybuffer",
+                  error
+                });
+              });
+            } else {
+              logger3().debug({
+                msg: "sending client data directly to server",
+                dataType: typeof clientEvt.data,
+                dataLength: typeof clientEvt.data === "string" ? clientEvt.data.length : void 0
+              });
+              clientToProxyWs.send(clientEvt.data);
+            }
+          }
+        }
+      );
+      proxyToActorWs.addEventListener("close", async (clientEvt) => {
+        const clientToProxyWs = await clientToProxyWsPromise;
+        logger3().debug({
+          msg: `test websocket connection closed`
+        });
+        if (clientToProxyWs.readyState !== 3) {
+          clientToProxyWs.close(clientEvt.code, clientEvt.reason);
+        }
+      });
+      proxyToActorWs.addEventListener("error", async () => {
+        const clientToProxyWs = await clientToProxyWsPromise;
+        logger3().debug({
+          msg: `test websocket connection error`
+        });
+        if (clientToProxyWs.readyState !== 3) {
+          clientToProxyWs.close(1011, "Error in client websocket");
+        }
+      });
+    });
+  } catch (error) {
+    logger3().error({
+      msg: `failed to establish client websocket connection`,
+      error
+    });
+    return {
+      onOpen: (_evt, clientToProxyWs) => {
+        clientToProxyWs.close(1011, "Failed to establish connection");
+      },
+      onMessage: () => {
+      },
+      onError: () => {
+      },
+      onClose: () => {
+      }
+    };
+  }
+  return {
+    onOpen: (_evt, clientToProxyWs) => {
+      logger3().debug({
+        msg: `test websocket connection from client opened`
+      });
+      logger3().debug({
+        msg: "proxyToActorWs info",
+        constructor: proxyToActorWs.constructor.name,
+        hasAddEventListener: typeof proxyToActorWs.addEventListener === "function",
+        readyState: proxyToActorWs.readyState
+      });
+      clientToProxyWsResolve(clientToProxyWs);
+    },
+    onMessage: (evt) => {
+      var _a, _b;
+      logger3().debug({
+        msg: "received message from server",
+        dataType: typeof evt.data,
+        isBlob: evt.data instanceof Blob,
+        isArrayBuffer: evt.data instanceof ArrayBuffer,
+        dataConstructor: (_b = (_a = evt.data) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name,
+        dataStr: typeof evt.data === "string" ? evt.data.substring(0, 100) : void 0
+      });
+      if (proxyToActorWs.readyState === 1) {
+        if (evt.data instanceof Blob) {
+          evt.data.arrayBuffer().then((buffer) => {
+            logger3().debug({
+              msg: "converted blob to arraybuffer, sending",
+              bufferSize: buffer.byteLength
+            });
+            proxyToActorWs.send(buffer);
+          }).catch((error) => {
+            logger3().error({
+              msg: "failed to convert blob to arraybuffer",
+              error
+            });
+          });
+        } else {
+          logger3().debug({
+            msg: "sending data directly",
+            dataType: typeof evt.data,
+            dataLength: typeof evt.data === "string" ? evt.data.length : void 0
+          });
+          proxyToActorWs.send(evt.data);
+        }
+      }
+    },
+    onClose: (event, clientToProxyWs) => {
+      logger3().debug({
+        msg: `server websocket closed`,
+        wasClean: event.wasClean,
+        code: event.code,
+        reason: event.reason
+      });
+      clientToProxyWs.close(1e3, "hack_force_close");
+      if (proxyToActorWs && proxyToActorWs.readyState !== proxyToActorWs.CLOSED && proxyToActorWs.readyState !== proxyToActorWs.CLOSING) {
+        proxyToActorWs.close(1e3, event.reason);
+      }
+    },
+    onError: (error) => {
+      logger3().error({
+        msg: `error in server websocket`,
+        error
+      });
+      if (proxyToActorWs && proxyToActorWs.readyState !== proxyToActorWs.CLOSED && proxyToActorWs.readyState !== proxyToActorWs.CLOSING) {
+        proxyToActorWs.close(1011, "Error in server websocket");
+      }
+      clientToProxyWsReject();
+    }
+  };
+}
+
+// src/manager/router.ts
+function buildManagerRouter(config, managerDriver, getUpgradeWebSocket, runtime = "node") {
+  return createRouter(config.managerBasePath, (router) => {
+    var _a;
+    router.use(
+      "*",
+      actorGateway.bind(
+        void 0,
+        config,
+        managerDriver,
+        getUpgradeWebSocket
+      )
+    );
+    router.get("/", (c) => {
+      return c.text(
+        "This is a RivetKit server.\n\nLearn more at https://rivet.dev"
+      );
+    });
+    {
+      const route = createRoute({
+        method: "get",
+        path: "/actors",
+        request: {
+          query: z3.object({
+            name: z3.string().optional(),
+            actor_ids: z3.string().optional(),
+            key: z3.string().optional()
+          })
+        },
+        responses: buildOpenApiResponses(ActorsListResponseSchema)
+      });
+      router.openapi(route, async (c) => {
+        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: "Name is required when key is provided."
+            },
+            400
+          );
+        }
+        if (actorIdsParsed) {
+          if (actorIdsParsed.length > 32) {
+            return c.json(
+              {
+                error: `Too many actor IDs. Maximum is 32, got ${actorIdsParsed.length}.`
+              },
+              400
+            );
+          }
+          if (actorIdsParsed.length === 0) {
+            return c.json({
+              actors: []
+            });
+          }
+          for (const actorId of actorIdsParsed) {
+            if (name) {
+              const actorOutput = await managerDriver.getForId({
+                c,
+                name,
+                actorId
+              });
+              if (actorOutput) {
+                actors.push(actorOutput);
+              }
+            } else {
+              for (const actorName of Object.keys(config.use)) {
+                const actorOutput = await managerDriver.getForId({
+                  c,
+                  name: actorName,
+                  actorId
+                });
+                if (actorOutput) {
+                  actors.push(actorOutput);
+                  break;
+                }
+              }
+            }
+          }
+        } else if (key && name) {
+          const actorOutput = await managerDriver.getWithKey({
+            c,
+            name,
+            key: deserializeActorKey(key)
+          });
+          if (actorOutput) {
+            actors.push(actorOutput);
+          }
+        } else {
+          if (!name) {
+            return c.json(
+              {
+                error: "Name is required when not using actor_ids."
+              },
+              400
+            );
+          }
+          const actorOutputs = await managerDriver.listActors({
+            c,
+            name,
+            key,
+            includeDestroyed: false
+          });
+          actors.push(...actorOutputs);
+        }
+        return c.json({
+          actors: actors.map((actor) => createApiActor(actor))
+        });
+      });
+    }
+    {
+      const route = createRoute({
+        method: "get",
+        path: "/actors/names",
+        request: {
+          query: z3.object({
+            namespace: z3.string()
+          })
+        },
+        responses: buildOpenApiResponses(ActorsListNamesResponseSchema)
+      });
+      router.openapi(route, async (c) => {
+        const names = buildActorNames(config);
+        return c.json({
+          names
+        });
+      });
+    }
+    {
+      const route = createRoute({
+        method: "put",
+        path: "/actors",
+        request: {
+          body: buildOpenApiRequestBody(
+            ActorsGetOrCreateRequestSchema
+          )
+        },
+        responses: buildOpenApiResponses(
+          ActorsGetOrCreateResponseSchema
+        )
+      });
+      router.openapi(route, async (c) => {
+        const body = c.req.valid("json");
+        const existingActor = await managerDriver.getWithKey({
+          c,
+          name: body.name,
+          key: deserializeActorKey(body.key)
+        });
+        if (existingActor) {
+          return c.json({
+            actor: createApiActor(existingActor),
+            created: false
+          });
+        }
+        const newActor = await managerDriver.getOrCreateWithKey({
+          c,
+          name: body.name,
+          key: deserializeActorKey(body.key),
+          input: body.input ? cbor.decode(Buffer.from(body.input, "base64")) : void 0,
+          region: void 0
+          // Not provided in the request schema
+        });
+        return c.json({
+          actor: createApiActor(newActor),
+          created: true
+        });
+      });
+    }
+    {
+      const route = createRoute({
+        method: "post",
+        path: "/actors",
+        request: {
+          body: buildOpenApiRequestBody(ActorsCreateRequestSchema)
+        },
+        responses: buildOpenApiResponses(ActorsCreateResponseSchema)
+      });
+      router.openapi(route, async (c) => {
+        const body = c.req.valid("json");
+        const actorOutput = await managerDriver.createActor({
+          c,
+          name: body.name,
+          key: deserializeActorKey(body.key || crypto.randomUUID()),
+          input: body.input ? cbor.decode(Buffer.from(body.input, "base64")) : void 0,
+          region: void 0
+          // Not provided in the request schema
+        });
+        const actor = createApiActor(actorOutput);
+        return c.json({ actor });
+      });
+    }
+    {
+      const route = createRoute({
+        method: "get",
+        path: "/actors/{actor_id}/kv/keys/{key}",
+        request: {
+          params: z3.object({
+            actor_id: z3.string(),
+            key: z3.string()
+          })
+        },
+        responses: buildOpenApiResponses(ActorsKvGetResponseSchema)
+      });
+      router.openapi(route, async (c) => {
+        if (isDev() && !config.token) {
+          logger3().warn({
+            msg: "RIVET_TOKEN is not set, skipping KV store access checks in development mode. This endpoint will be disabled in production, unless you set the token."
+          });
+        }
+        if (!isDev()) {
+          if (!config.token) {
+            throw new RestrictedFeature("KV store access");
+          }
+          if (timingSafeEqual(
+            config.token,
+            c.req.header(HEADER_RIVET_TOKEN) || ""
+          ) === false) {
+            throw new Forbidden();
+          }
+        }
+        const { actor_id: actorId, key } = c.req.valid("param");
+        const response = await managerDriver.kvGet(
+          actorId,
+          Buffer.from(key, "base64")
+        );
+        return c.json({
+          value: response ? Buffer.from(response).toString("base64") : null
+        });
+      });
+    }
+    if (config.test.enabled) {
+      router.post(".test/inline-driver/call", async (c) => {
+        const buffer = await c.req.arrayBuffer();
+        const { encoding, method, args } = cbor.decode(new Uint8Array(buffer));
+        logger3().debug({
+          msg: "received inline request",
+          encoding,
+          method,
+          args
+        });
+        let response;
+        try {
+          const output = await managerDriver[method](...args);
+          response = { ok: output };
+        } catch (rawErr) {
+          const err = deconstructError(rawErr, logger3(), {}, true);
+          response = { err };
+        }
+        return c.body(cbor.encode(response));
+      });
+      router.get(".test/inline-driver/connect-websocket/*", async (c) => {
+        const upgradeWebSocket = getUpgradeWebSocket == null ? void 0 : getUpgradeWebSocket();
+        invariant2(
+          upgradeWebSocket,
+          "websockets not supported on this platform"
+        );
+        return upgradeWebSocket(async (c2) => {
+          const protocolHeader = c2.req.header("sec-websocket-protocol") || "";
+          const protocols = protocolHeader.split(/,\s*/);
+          let actorId = "";
+          let encoding = "bare";
+          let path = "";
+          let params;
+          for (const protocol of protocols) {
+            if (protocol.startsWith(WS_PROTOCOL_ACTOR)) {
+              actorId = decodeURIComponent(
+                protocol.substring(WS_PROTOCOL_ACTOR.length)
+              );
+            } else if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
+              encoding = protocol.substring(
+                WS_PROTOCOL_ENCODING.length
+              );
+            } else if (protocol.startsWith(WS_TEST_PROTOCOL_PATH)) {
+              path = decodeURIComponent(
+                protocol.substring(
+                  WS_TEST_PROTOCOL_PATH.length
+                )
+              );
+            } else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
+              const paramsRaw = decodeURIComponent(
+                protocol.substring(
+                  WS_PROTOCOL_CONN_PARAMS.length
+                )
+              );
+              params = JSON.parse(paramsRaw);
+            }
+          }
+          logger3().debug({
+            msg: "received test inline driver websocket",
+            actorId,
+            params,
+            encodingKind: encoding,
+            path
+          });
+          const clientToProxyWsPromise = managerDriver.openWebSocket(
+            path,
+            actorId,
+            encoding,
+            params
+          );
+          return await createTestWebSocketProxy(
+            clientToProxyWsPromise
+          );
+        })(c, noopNext());
+      });
+      router.all(".test/inline-driver/send-request/*", async (c) => {
+        const actorId = c.req.header(HEADER_ACTOR_ID);
+        if (!actorId) {
+          return c.text("Missing required headers", 400);
+        }
+        const pathOnly = c.req.path.split("/.test/inline-driver/send-request/")[1] || "";
+        const url = new URL(c.req.url);
+        const pathWithQuery = pathOnly + url.search;
+        logger3().debug({
+          msg: "received test inline driver raw http",
+          actorId,
+          path: pathWithQuery,
+          method: c.req.method
+        });
+        try {
+          const response = await managerDriver.sendRequest(
+            actorId,
+            new Request(`http://actor/${pathWithQuery}`, {
+              method: c.req.method,
+              headers: c.req.raw.headers,
+              body: c.req.raw.body,
+              duplex: "half"
+            })
+          );
+          return response;
+        } catch (error) {
+          logger3().error({
+            msg: "error in test inline raw http",
+            error: stringifyError(error)
+          });
+          const err = deconstructError(error, logger3(), {}, true);
+          return c.json(
+            {
+              error: {
+                code: err.code,
+                message: err.message,
+                metadata: err.metadata
+              }
+            },
+            err.statusCode
+          );
+        }
+      });
+      router.post("/.test/force-disconnect", async (c) => {
+        const actorId = c.req.query("actor");
+        const connId = c.req.query("conn");
+        if (!actorId || !connId) {
+          return c.text(
+            "Missing actor or conn query parameters",
+            400
+          );
+        }
+        logger3().debug({
+          msg: "forcing unclean disconnect",
+          actorId,
+          connId
+        });
+        try {
+          const response = await managerDriver.sendRequest(
+            actorId,
+            new Request(
+              `http://actor/.test/force-disconnect?conn=${connId}`,
+              {
+                method: "POST"
+              }
+            )
+          );
+          if (!response.ok) {
+            const text = await response.text();
+            return c.text(
+              `Failed to force disconnect: ${text}`,
+              response.status
+            );
+          }
+          return c.json({ success: true });
+        } catch (error) {
+          logger3().error({
+            msg: "error forcing disconnect",
+            error: stringifyError(error)
+          });
+          return c.text(`Error: ${error}`, 500);
+        }
+      });
+    }
+    if (config.inspector.enabled) {
+      let inspectorRoot;
+      router.get("/ui/*", async (c, next) => {
+        let serveStatic;
+        try {
+          serveStatic = await loadRuntimeServeStatic(runtime);
+        } catch (error) {
+          logger3().error({
+            msg: "failed to load inspector static file handler",
+            error: stringifyError(error)
+          });
+          return c.text(
+            `Failed to load static file handler for runtime '${runtime}'.`,
+            500
+          );
+        }
+        if (!inspectorRoot) {
+          inspectorRoot = await getInspectorDir();
+        }
+        const root = inspectorRoot;
+        const rewrite = (path) => path.replace(/^\/ui/, "") || "/";
+        return serveStatic({
+          root,
+          rewriteRequestPath: rewrite,
+          onNotFound: async (_path, c2) => {
+            await serveStatic({ root, path: "index.html" })(
+              c2,
+              next
+            );
+          }
+        })(c, next);
+      });
+      router.get("/ui", (c) => c.redirect("/ui/"));
+    }
+    router.get("/health", (c) => handleHealthRequest(c));
+    router.get(
+      "/metadata",
+      (c) => handleMetadataRequest(
+        c,
+        config,
+        { normal: {} },
+        config.publicEndpoint,
+        config.publicNamespace,
+        config.publicToken
+      )
+    );
+    (_a = managerDriver.modifyManagerRouter) == null ? void 0 : _a.call(managerDriver, config, router);
+  });
+}
+function createApiActor(actor) {
+  return {
+    actor_id: actor.actorId,
+    name: actor.name,
+    key: serializeActorKey(actor.key),
+    namespace_id: "default",
+    // Assert default namespace
+    runner_name_selector: "default",
+    create_ts: actor.createTs ?? Date.now(),
+    connectable_ts: actor.connectableTs ?? null,
+    destroy_ts: actor.destroyTs ?? null,
+    sleep_ts: actor.sleepTs ?? null,
+    start_ts: actor.startTs ?? null
+  };
+}
+
+// src/driver-helpers/utils.ts
+import * as cbor2 from "cbor-x";
+function serializeEmptyPersistData(input) {
+  const persistData = {
+    input: input !== void 0 ? bufferToArrayBuffer(cbor2.encode(input)) : null,
+    hasInitialized: false,
+    state: bufferToArrayBuffer(cbor2.encode(void 0)),
+    scheduledEvents: []
+  };
+  return ACTOR_VERSIONED.serializeWithEmbeddedVersion(
+    persistData,
+    CURRENT_VERSION
+  );
+}
+function getInitialActorKvState(input) {
+  const persistData = serializeEmptyPersistData(input);
+  return [[KEYS.PERSIST_DATA, persistData]];
+}
+
+// src/driver-helpers/sqlite-pool.ts
+var SqliteVfsPoolManager = class {
+  #poolPromise;
+  #config;
+  constructor(config) {
+    this.#config = config;
+  }
+  async acquire(actorId) {
+    if (!this.#poolPromise) {
+      const poolConfig = this.#config.sqlitePool;
+      this.#poolPromise = import("@rivetkit/sqlite-vfs").then(
+        ({ SqliteVfsPool }) => new SqliteVfsPool({
+          actorsPerInstance: poolConfig.actorsPerInstance,
+          idleDestroyMs: poolConfig.idleDestroyMs
+        })
+      );
+    }
+    const pool = await this.#poolPromise;
+    return await pool.acquire(actorId);
+  }
+  async shutdown() {
+    if (this.#poolPromise) {
+      const pool = await this.#poolPromise;
+      await pool.shutdown();
+    }
+  }
+};
+
+export {
+  getRequireFn,
+  importNodeDependencies,
+  getNodeCrypto,
+  getNodeFsSync,
+  getNodeFs,
+  getNodePath,
+  getNodeOs,
+  getNodeChildProcess,
+  getNodeStream,
+  logger,
+  findFreePort,
+  crossPlatformServe,
+  loadRuntimeServeStatic,
+  createRouter,
+  buildManagerRouter,
+  getInitialActorKvState,
+  SqliteVfsPoolManager
+};
+//# sourceMappingURL=chunk-C4EB42ET.js.map