@rivetkit/core/dist/chunk-6DVAOXMS.js

import {
  RunConfigSchema,
  createFileSystemOrMemoryDriver,
  createInlineClientDriver,
  createManagerRouter
} from "./chunk-Q33XSJ6Q.js";
import {
  createClient
} from "./chunk-MDIBCJIZ.js";
import {
  getLogger
} from "./chunk-CLOGFICZ.js";

// src/test/mod.ts
import { createServer } from "net";
import { serve as honoServe } from "@hono/node-server";
import { createNodeWebSocket } from "@hono/node-ws";
import { vi } from "vitest";

// src/test/config.ts
import { z } from "zod";
var ConfigSchema = RunConfigSchema.removeDefault().extend({
  hostname: z.string().optional().default(process.env.HOSTNAME ?? "127.0.0.1"),
  port: z.number().optional().default(Number.parseInt(process.env.PORT ?? "8080"))
}).default({});

// src/test/log.ts
var LOGGER_NAME = "nodejs";
function logger() {
  return getLogger(LOGGER_NAME);
}

// src/test/mod.ts
function serve(registry, inputConfig) {
  inputConfig ??= {};
  if (!inputConfig.driver) {
    inputConfig.driver = createFileSystemOrMemoryDriver(false);
  }
  const config = ConfigSchema.parse(inputConfig);
  let upgradeWebSocket;
  if (!config.getUpgradeWebSocket) {
    config.getUpgradeWebSocket = () => upgradeWebSocket;
  }
  const runConfig = RunConfigSchema.parse(inputConfig);
  const managerDriver = config.driver.manager(registry.config, config);
  const inlineClientDriver = createInlineClientDriver(managerDriver);
  const { router } = createManagerRouter(
    registry.config,
    runConfig,
    inlineClientDriver,
    managerDriver,
    false
  );
  const nodeWebSocket = createNodeWebSocket({ app: router });
  upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
  const server = honoServe({
    fetch: router.fetch,
    hostname: config.hostname,
    port: config.port
  });
  nodeWebSocket.injectWebSocket(server);
  logger().info("rivetkit started", {
    hostname: config.hostname,
    port: config.port,
    definitions: Object.keys(registry.config.use).length
  });
  return server;
}
async function setupTest(c, registry) {
  vi.useFakeTimers();
  const mockDriverContext = {};
  const setDriverContextFn = (ctx) => {
    mockDriverContext.current = ctx;
  };
  const port = await getPort();
  const server = serve(registry, { port });
  c.onTestFinished(
    async () => await new Promise((resolve) => server.close(() => resolve()))
  );
  const client = createClient(`http://127.0.0.1:${port}`);
  c.onTestFinished(async () => await client.dispose());
  return {
    client,
    mockDriver: {
      actorDriver: {
        setCreateVarsContext: setDriverContextFn
      }
    }
  };
}
async function getPort() {
  const MIN_PORT = 1e4;
  const MAX_PORT = 65535;
  const getRandomPort = () => Math.floor(Math.random() * (MAX_PORT - MIN_PORT + 1)) + MIN_PORT;
  let port = getRandomPort();
  let maxAttempts = 10;
  while (maxAttempts > 0) {
    try {
      const server = await new Promise((resolve, reject) => {
        const server2 = createServer();
        server2.once("error", (err) => {
          if (err.code === "EADDRINUSE") {
            reject(new Error(`Port ${port} is in use`));
          } else {
            reject(err);
          }
        });
        server2.once("listening", () => {
          resolve(server2);
        });
        server2.listen(port);
      });
      await new Promise((resolve) => {
        server.close(() => resolve());
      });
      return port;
    } catch (err) {
      maxAttempts--;
      if (maxAttempts <= 0) {
        break;
      }
      port = getRandomPort();
    }
  }
  throw new Error("Could not find an available port after multiple attempts");
}

export {
  setupTest,
  getPort
};
//# sourceMappingURL=chunk-6DVAOXMS.js.map