@crvy/rprtr 0.0.3

package/dist/chunk-BRFA7JCQ.js

@@ -0,0 +1,729 @@
+import {
+  ApproveRequestBodySchema,
+  LoadedReportDataSchema,
+  OfflineReportSchema,
+  TestBeginDataSchema,
+  TestEndDataSchema,
+  WebSocketMessageSchema,
+  applyTestBeginEvent,
+  applyTestEndEvent,
+  createMutableReportState,
+  finalizeRunEvent,
+  safeParse
+} from "./chunk-IEYNAB6M.js";
+
+// src/server/app.ts
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath } from "url";
+import pLimit from "p-limit";
+
+// src/offline-reports.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+var OFFLINE_REPORT_FILE_PATTERN = /^crvy-rprtr(?:-\d+)?\.json$/;
+async function findOfflineReportPaths(searchDir) {
+  try {
+    const entries = await readdir(searchDir);
+    return entries.filter((entry) => OFFLINE_REPORT_FILE_PATTERN.test(entry)).sort((left, right) => left.localeCompare(right)).map((entry) => join(searchDir, entry));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+function parseOfflineReport(value) {
+  const parsed = safeParse(OfflineReportSchema, value);
+  if (parsed === null || parsed.version !== 1 || !Array.isArray(parsed.events)) {
+    return null;
+  }
+  return parsed;
+}
+function mergeOfflineReportsIntoTests(existingTests, offlineReports, options = {}) {
+  const state = createMutableReportState(options.screenshotDir);
+  let shouldFinalize = false;
+  for (const report of offlineReports) {
+    for (const event of report.events) {
+      switch (event.type) {
+        case "test-begin": {
+          const parsed = safeParse(TestBeginDataSchema, event.data);
+          if (parsed !== null) {
+            applyTestBeginEvent(state, parsed);
+          }
+          break;
+        }
+        case "test-end": {
+          const parsed = safeParse(TestEndDataSchema, event.data);
+          if (parsed !== null) {
+            applyTestEndEvent(state, parsed, { screenshotsBaseUrl: options.screenshotsBaseUrl });
+          }
+          break;
+        }
+        case "run-end":
+          shouldFinalize = true;
+          break;
+      }
+    }
+  }
+  if (shouldFinalize) {
+    finalizeRunEvent(state);
+  }
+  return {
+    ...existingTests,
+    ...state.reportData.tests
+  };
+}
+
+// src/server/file-utils.ts
+import { access, copyFile, mkdir, readFile, stat, writeFile } from "fs/promises";
+import { dirname, extname } from "path";
+function isFileNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function isDirectory(filePath) {
+  try {
+    const stats = await stat(filePath);
+    return stats.isDirectory();
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function readJsonFile(filePath) {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    if (raw.trim() === "") {
+      return null;
+    }
+    return JSON.parse(raw);
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeJsonFile(filePath, value) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function copyFilePortable(sourcePath, destinationPath) {
+  await mkdir(dirname(destinationPath), { recursive: true });
+  await copyFile(sourcePath, destinationPath);
+}
+function inferContentType(filePath) {
+  switch (extname(filePath).toLowerCase()) {
+    case ".css":
+      return "text/css";
+    case ".gif":
+      return "image/gif";
+    case ".html":
+      return "text/html";
+    case ".jpeg":
+    case ".jpg":
+      return "image/jpeg";
+    case ".js":
+      return "application/javascript";
+    case ".json":
+      return "application/json";
+    case ".png":
+      return "image/png";
+    case ".svg":
+      return "image/svg+xml";
+    case ".txt":
+      return "text/plain";
+    case ".webp":
+      return "image/webp";
+    default:
+      return void 0;
+  }
+}
+async function respondWithFile(filePath, contentType) {
+  try {
+    const file = await readFile(filePath);
+    const resolvedContentType = contentType ?? inferContentType(filePath);
+    const headers = resolvedContentType === void 0 ? void 0 : { "Content-Type": resolvedContentType };
+    return new Response(file, { headers });
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+// src/server/utils.ts
+function broadcastToBrowsers(wsClients, msg) {
+  const payload = JSON.stringify(msg);
+  wsClients.forEach((ws) => {
+    ws.send(payload);
+  });
+}
+
+// src/server/handlers.ts
+function handleTestBegin(ctx, data) {
+  const test = applyTestBeginEvent(ctx, data);
+  console.log(`  \u25B6 [${test.browser ?? "?"}] ${test.title}`);
+}
+function handleTestEnd(ctx, data) {
+  const result = applyTestEndEvent(ctx, data);
+  if (result !== null) {
+    const { test, diffCount } = result;
+    const icon = data.status === "passed" ? "\u2713" : data.status === "skipped" ? "\u2013" : "\u2717";
+    const dur = data.duration === null || data.duration === void 0 ? "" : ` (${data.duration}ms)`;
+    const diffNote = diffCount > 0 ? ` [${diffCount} diff(s)]` : "";
+    const errNote = data.error !== null && data.error !== void 0 ? `
+    Error: ${data.error}` : "";
+    console.log(`  ${icon} [${test.browser}] ${test.title}${dur}${diffNote}${errNote}`);
+  }
+  broadcastToBrowsers(ctx.wsClients, { type: "test-update", data });
+}
+async function handleRunEnd(ctx, data) {
+  const { passed, failed, pending } = finalizeRunEvent(ctx);
+  await ctx.saveReport();
+  console.log(`
+Run complete \u2014 ${passed} passed, ${failed} failed, ${pending} skipped`);
+  broadcastToBrowsers(ctx.wsClients, { type: "run-end", data });
+}
+function handleApprove() {
+  console.log("[Server] Received approve message via WebSocket (handled via HTTP API)");
+}
+function handleSync(ctx) {
+  console.log("[Server] Received sync message");
+  broadcastToBrowsers(ctx.wsClients, { type: "sync", data: ctx.reportData });
+}
+
+// src/server/routes.ts
+import { join as join2 } from "path";
+var LIVE_UPDATES_WEBSOCKET_PATH = "/";
+function isWebSocketUpgradeRequest(req) {
+  return new URL(req.url).pathname === LIVE_UPDATES_WEBSOCKET_PATH && req.headers.get("upgrade")?.toLowerCase() === "websocket";
+}
+async function handleRoot(ctx) {
+  const html = await respondWithFile(join2(ctx.staticDir, "index.html"), "text/html");
+  return html ?? new Response("Not Found", { status: 404 });
+}
+async function handleAppCss() {
+  const css = await respondWithFile("./src/client/app.css", "text/css");
+  return css ?? new Response("Not Found", { status: 404 });
+}
+async function handleSrcFiles(req) {
+  const path = new URL(req.url).pathname.slice("/src/".length);
+  const filePath = `./src/${path}`;
+  const contentType = filePath.endsWith(".ts") || filePath.endsWith(".tsx") ? "application/javascript" : filePath.endsWith(".css") ? "text/css" : "text/plain";
+  const file = await respondWithFile(filePath, contentType);
+  return file ?? new Response("Not Found", { status: 404 });
+}
+function handleApiReport(ctx) {
+  return Response.json(ctx.reportData);
+}
+async function handleApiApprove(ctx, req) {
+  try {
+    const rawBody = await req.json();
+    const parsed = safeParse(ApproveRequestBodySchema, rawBody);
+    if (!parsed) {
+      console.error("Invalid approve request body", rawBody);
+      return Response.json({ success: false, error: "Invalid request body" }, { status: 400 });
+    }
+    const { id, retry, image } = parsed;
+    const test = ctx.reportData.tests[id];
+    if (test !== null && test !== void 0) {
+      test.approved ??= {};
+      test.approved[image] = retry;
+      await ctx.saveReport();
+      const actualUrl = test.results?.[retry]?.images?.[image]?.actual;
+      if (actualUrl !== null && actualUrl !== void 0 && test.location?.file !== null && test.location?.file !== void 0) {
+        const actualPath = actualUrl.replace("/screenshots/", `${ctx.reportData.screenshotDir}/`);
+        const snapshotPath = `${test.location.file}-snapshots/${image}-${test.browser}-${process.platform}.png`;
+        try {
+          await copyFilePortable(actualPath, snapshotPath);
+          console.log(`  \u2714 Updated baseline: ${snapshotPath}`);
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          console.error(`  \u2717 Failed to update baseline: ${errorMsg}`);
+        }
+      }
+      console.log(`  \u2714 Approved [${test.browser}] ${test.title} \u2014 ${image}`);
+    }
+    return Response.json({ success: true });
+  } catch {
+    return Response.json({ success: false, error: "Invalid request" }, { status: 400 });
+  }
+}
+async function handleApiApproveAll(ctx) {
+  let approvedCount = 0;
+  const baselineUpdates = [];
+  Object.values(ctx.reportData.tests).forEach((test) => {
+    if (!test?.results) return;
+    const approved = {};
+    const lastRetry = test.results.length - 1;
+    const lastResult = test.results[lastRetry];
+    if (!lastResult?.images) return;
+    Object.keys(lastResult.images).forEach((imageName) => {
+      approved[imageName] = lastRetry;
+      approvedCount++;
+      const actualUrl = lastResult.images?.[imageName]?.actual;
+      if (actualUrl !== null && actualUrl !== void 0 && test.location?.file !== null && test.location?.file !== void 0) {
+        const actualPath = actualUrl.replace("/screenshots/", `${ctx.reportData.screenshotDir}/`);
+        const snapshotPath = `${test.location.file}-snapshots/${imageName}-${test.browser}-${process.platform}.png`;
+        baselineUpdates.push(
+          copyFilePortable(actualPath, snapshotPath).then(() => {
+            console.log(`  \u2714 Updated baseline: ${snapshotPath}`);
+          }).catch((err) => {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            console.error(`  \u2717 Failed to update baseline: ${errorMsg}`);
+          })
+        );
+      }
+    });
+    test.approved = approved;
+  });
+  await ctx.saveReport();
+  await Promise.all(baselineUpdates);
+  console.log(`  \u2714 Approved all \u2014 ${approvedCount} image(s)`);
+  return Response.json({ success: true });
+}
+async function handleApiImages(req) {
+  const path = new URL(req.url).pathname.slice("/api/images/".length);
+  const imagePath = `./images/${path}`;
+  const file = await respondWithFile(imagePath);
+  return file ?? Response.json({ error: "Image not found" }, { status: 404 });
+}
+async function handleScreenshots(ctx, req) {
+  const path = new URL(req.url).pathname.slice("/screenshots/".length);
+  const screenshotPath = `${ctx.reportData.screenshotDir}/${path}`;
+  const file = await respondWithFile(screenshotPath);
+  return file ?? Response.json({ error: "Screenshot not found" }, { status: 404 });
+}
+async function handleDist(ctx, req) {
+  const path = new URL(req.url).pathname.slice("/dist/".length);
+  const filePath = join2(ctx.staticDir, path);
+  const contentType = filePath.endsWith(".css") ? "text/css" : filePath.endsWith(".js") ? "application/javascript" : filePath.endsWith(".svelte") ? "text/plain" : "application/octet-stream";
+  const file = await respondWithFile(filePath, contentType);
+  return file ?? new Response("Not Found", { status: 404 });
+}
+function handleHttpRequest(ctx, req) {
+  const pathname = new URL(req.url).pathname;
+  if (pathname === "/") {
+    return handleRoot(ctx);
+  }
+  if (pathname === "/src/client/app.css") {
+    return handleAppCss();
+  }
+  if (pathname.startsWith("/src/")) {
+    return handleSrcFiles(req);
+  }
+  if (pathname === "/api/report") {
+    return Promise.resolve(handleApiReport(ctx));
+  }
+  if (pathname === "/api/approve") {
+    return handleApiApprove(ctx, req);
+  }
+  if (pathname === "/api/approve-all") {
+    return handleApiApproveAll(ctx);
+  }
+  if (pathname.startsWith("/api/images/")) {
+    return handleApiImages(req);
+  }
+  if (pathname.startsWith("/screenshots/")) {
+    return handleScreenshots(ctx, req);
+  }
+  if (pathname.startsWith("/dist/")) {
+    return handleDist(ctx, req);
+  }
+  return Promise.resolve(new Response("Not Found", { status: 404 }));
+}
+
+// src/server/app.ts
+var MAX_CONCURRENT_FILE_OPS = 5;
+function createReportData(options) {
+  return {
+    isRunning: false,
+    tests: {},
+    browsers: ["chromium"],
+    isUpdateMode: false,
+    screenshotDir: options.screenshotDir ?? "./screenshots"
+  };
+}
+function createHandlerContext(reportData, wsClients, currentRunIds, saveReport) {
+  return {
+    reportData,
+    wsClients,
+    currentRunIds,
+    saveReport
+  };
+}
+async function loadReport(reportPath, reportData) {
+  try {
+    const raw = await readJsonFile(reportPath);
+    if (raw === null) {
+      console.log("No report.json found, using empty state");
+      return;
+    }
+    const parsed = safeParse(LoadedReportDataSchema, raw);
+    if (parsed !== null) {
+      reportData.tests = parsed.tests ?? {};
+      reportData.isUpdateMode = parsed.isUpdateMode ?? false;
+    }
+  } catch {
+    console.log("No report.json found, using empty state");
+  }
+}
+async function readOfflineReport(filePath) {
+  try {
+    const raw = await readJsonFile(filePath);
+    if (raw === null) {
+      return null;
+    }
+    const parsed = parseOfflineReport(raw);
+    if (parsed !== null) {
+      console.log(`[Server] Loading offline report: ${filePath}`);
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+async function loadOfflineReports(offlineReportDir, reportData) {
+  const offlineReportPaths = await findOfflineReportPaths(offlineReportDir);
+  if (offlineReportPaths.length === 0) {
+    return;
+  }
+  const limit = pLimit(MAX_CONCURRENT_FILE_OPS);
+  const reports = await Promise.all(offlineReportPaths.map((filePath) => limit(() => readOfflineReport(filePath))));
+  const validReports = reports.filter((report) => report !== null);
+  if (validReports.length === 0) {
+    return;
+  }
+  reportData.tests = mergeOfflineReportsIntoTests(reportData.tests, validReports, {
+    screenshotDir: reportData.screenshotDir,
+    screenshotsBaseUrl: "/screenshots/"
+  });
+}
+async function handleParsedWebSocketMessage(ctx, msg) {
+  switch (msg.type) {
+    case "test-begin": {
+      const parsed = safeParse(TestBeginDataSchema, msg.data);
+      if (parsed === null) {
+        console.error("Invalid test-begin message data", msg.data);
+        break;
+      }
+      handleTestBegin(ctx, parsed);
+      break;
+    }
+    case "test-end": {
+      const parsed = safeParse(TestEndDataSchema, msg.data);
+      if (parsed === null) {
+        console.error("Invalid test-end message data", msg.data);
+        break;
+      }
+      handleTestEnd(ctx, parsed);
+      break;
+    }
+    case "run-end":
+      await handleRunEnd(ctx, msg.data);
+      break;
+    case "approve":
+      handleApprove();
+      break;
+    case "sync":
+      handleSync(ctx);
+      break;
+  }
+}
+function createWebSocketMessageHandler(getHandlerContext) {
+  return async function handleWebSocketMessage(message) {
+    try {
+      const parsed = JSON.parse(message);
+      const wsMessage = safeParse(WebSocketMessageSchema, parsed);
+      if (wsMessage === null) {
+        console.error("Invalid WebSocket message: missing or invalid type", parsed);
+        return;
+      }
+      await handleParsedWebSocketMessage(getHandlerContext(), wsMessage);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error("Invalid WebSocket message:", errorMsg);
+    }
+  };
+}
+async function resolveStaticDir(staticDir) {
+  const currentDir = dirname2(fileURLToPath(import.meta.url));
+  const candidates = staticDir === void 0 ? [
+    currentDir,
+    join3(currentDir, "dist"),
+    join3(currentDir, "..", "dist"),
+    join3(currentDir, "..", "..", "dist"),
+    join3(currentDir, ".."),
+    join3(currentDir, "..", "..")
+  ] : [staticDir, join3(staticDir, "dist")];
+  const resolvedCandidates = await Promise.all(
+    candidates.map(async (candidate) => ({
+      candidate,
+      exists: await fileExists(join3(candidate, "index.html"))
+    }))
+  );
+  const resolved = resolvedCandidates.find(({ exists }) => exists);
+  if (resolved !== void 0) {
+    return resolved.candidate;
+  }
+  return candidates[0];
+}
+async function resolveReportPath(reportPath) {
+  if (await isDirectory(reportPath)) {
+    return { reportFile: join3(reportPath, "report.json"), offlineReportDir: reportPath };
+  }
+  return { reportFile: reportPath, offlineReportDir: dirname2(reportPath) };
+}
+async function createServerApp(options = {}) {
+  const port = options.port ?? 3e3;
+  const reportData = createReportData(options);
+  const reportPathOption = options.reportPath ?? "./report.json";
+  const { reportFile, offlineReportDir } = await resolveReportPath(reportPathOption);
+  const staticDir = await resolveStaticDir(options.staticDir);
+  const wsClients = /* @__PURE__ */ new Set();
+  const currentRunIds = /* @__PURE__ */ new Set();
+  async function saveReport() {
+    await writeJsonFile(reportFile, reportData);
+  }
+  const routesContext = {
+    reportData,
+    staticDir,
+    saveReport
+  };
+  const getHandlerContext = () => createHandlerContext(reportData, wsClients, currentRunIds, saveReport);
+  const handleRequest = (req) => handleHttpRequest(routesContext, req);
+  const handleWebSocketMessage = createWebSocketMessageHandler(getHandlerContext);
+  await loadReport(reportFile, reportData);
+  await loadOfflineReports(offlineReportDir, reportData);
+  return {
+    port,
+    wsClients,
+    handleRequest,
+    handleWebSocketMessage
+  };
+}
+
+// src/server/bun-adapter.ts
+function logWebSocketError(prefix, error) {
+  const errorMsg = error instanceof Error ? error.message : String(error);
+  console.error(`${prefix}:`, errorMsg);
+}
+function toMessageString(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (message instanceof ArrayBuffer) {
+    return Buffer.from(message).toString();
+  }
+  return Buffer.from(message.buffer, message.byteOffset, message.byteLength).toString();
+}
+function startBunServer(app) {
+  Bun.serve({
+    port: app.port,
+    fetch(req, server) {
+      if (isWebSocketUpgradeRequest(req)) {
+        if (server.upgrade(req)) {
+          return;
+        }
+        return new Response("WebSocket upgrade failed", { status: 400 });
+      }
+      return app.handleRequest(req);
+    },
+    websocket: {
+      open(ws) {
+        app.wsClients.add(ws);
+      },
+      message(_ws, message) {
+        app.handleWebSocketMessage(toMessageString(message)).catch((error) => {
+          logWebSocketError("Error handling WebSocket message", error);
+        });
+      },
+      close(ws) {
+        app.wsClients.delete(ws);
+      }
+    },
+    development: {
+      hmr: true,
+      console: true
+    }
+  });
+  console.log(`Crvy Rprtr started at http://localhost:${app.port}`);
+}
+
+// src/server/node-adapter.ts
+import { createServer } from "http";
+import { WebSocketServer } from "ws";
+function toHeaders(headersObject) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(headersObject)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((entry) => {
+        headers.append(key, entry);
+      });
+    } else {
+      headers.set(key, value);
+    }
+  }
+  return headers;
+}
+async function readRequestBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    const chunkValue = chunk;
+    if (typeof chunkValue === "string") {
+      chunks.push(Buffer.from(chunkValue));
+      continue;
+    }
+    if (chunkValue instanceof Uint8Array) {
+      chunks.push(chunkValue);
+      continue;
+    }
+    throw new TypeError("Unexpected request body chunk type");
+  }
+  return Buffer.concat(chunks);
+}
+async function toRequest(req) {
+  const headers = toHeaders(req.headers);
+  const protocol = headers.get("x-forwarded-proto") ?? "http";
+  const host = headers.get("host") ?? "localhost";
+  const url = new URL(req.url ?? "/", `${protocol}://${host}`);
+  const method = req.method ?? "GET";
+  if (method === "GET" || method === "HEAD") {
+    return new Request(url, { method, headers });
+  }
+  const body = await readRequestBody(req);
+  return new Request(url, {
+    method,
+    headers,
+    body: Buffer.from(body)
+  });
+}
+async function writeResponse(res, response) {
+  res.statusCode = response.status;
+  res.statusMessage = response.statusText;
+  response.headers.forEach((value, key) => {
+    res.setHeader(key, value);
+  });
+  if (response.body === null) {
+    res.end();
+    return;
+  }
+  const body = Buffer.from(await response.arrayBuffer());
+  res.end(body);
+}
+function logRequestError(error) {
+  const errorMsg = error instanceof Error ? error.message : String(error);
+  console.error("Error handling HTTP request:", errorMsg);
+}
+function logWebSocketError2(error) {
+  const errorMsg = error instanceof Error ? error.message : String(error);
+  console.error("Error handling WebSocket message:", errorMsg);
+}
+async function handleNodeRequest(app, req, res) {
+  try {
+    const request = await toRequest(req);
+    const response = await app.handleRequest(request);
+    await writeResponse(res, response);
+  } catch (error) {
+    logRequestError(error);
+    if (res.headersSent) {
+      res.end();
+      return;
+    }
+    res.statusCode = 500;
+    res.end("Internal Server Error");
+  }
+}
+function rawDataToString(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (message instanceof ArrayBuffer) {
+    return Buffer.from(message).toString();
+  }
+  if (Array.isArray(message)) {
+    return Buffer.concat(message.map((part) => Buffer.from(part))).toString();
+  }
+  return Buffer.from(message).toString();
+}
+function attachWebSocketServer(server, app) {
+  const wsServer = new WebSocketServer({ noServer: true });
+  wsServer.on("error", (error) => {
+    logWebSocketError2(error);
+  });
+  server.on("upgrade", (req, socket, head) => {
+    const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+    if (pathname !== LIVE_UPDATES_WEBSOCKET_PATH) {
+      socket.destroy();
+      return;
+    }
+    wsServer.handleUpgrade(req, socket, head, (ws) => {
+      app.wsClients.add(ws);
+      ws.on("message", (message) => {
+        app.handleWebSocketMessage(rawDataToString(message)).catch((error) => {
+          logWebSocketError2(error);
+        });
+      });
+      ws.on("error", (error) => {
+        app.wsClients.delete(ws);
+        logWebSocketError2(error);
+      });
+      ws.on("close", () => {
+        app.wsClients.delete(ws);
+      });
+    });
+  });
+}
+async function listen(server, port) {
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off("error", onError);
+      reject(error);
+    };
+    server.on("error", onError);
+    server.listen(port, () => {
+      server.off("error", onError);
+      resolve();
+    });
+  });
+}
+async function startNodeServer(app) {
+  const server = createServer((req, res) => {
+    void handleNodeRequest(app, req, res);
+  });
+  attachWebSocketServer(server, app);
+  await listen(server, app.port);
+  console.log(`Crvy Rprtr started at http://localhost:${app.port}`);
+}
+
+// src/server.ts
+async function startServer(options = {}) {
+  const app = await createServerApp(options);
+  if (typeof Bun !== "undefined" && typeof Bun.serve === "function") {
+    startBunServer(app);
+    return;
+  }
+  await startNodeServer(app);
+}
+
+export {
+  startServer
+};