@crvy/rprtr 0.0.3 → 0.0.5

package/dist/server.cjs

@@ -0,0 +1,1176 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startServer: () => startServer
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/server/app.ts
+var import_path5 = require("path");
+var import_url = require("url");
+var import_p_limit = __toESM(require("p-limit"), 1);
+
+// src/offline-reports.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+
+// src/report-utils.ts
+function normalizeScreenshotsBaseUrl(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+function classifyImage(image) {
+  if (image.actual !== void 0 || image.diff !== void 0) {
+    return "comparison";
+  }
+  if (image.expect !== void 0) {
+    return "baseline-only";
+  }
+  return "declared-only";
+}
+function withImageSource(image) {
+  return {
+    ...image,
+    source: classifyImage(image)
+  };
+}
+function mergeDeclaredImages(images, visualNames) {
+  const names = /* @__PURE__ */ new Set([...Object.keys(images), ...visualNames]);
+  return Object.fromEntries(
+    Array.from(names, (name) => {
+      const current = images[name] ?? {};
+      return [name, withImageSource(current)];
+    })
+  );
+}
+function attachmentsToImages(attachments, screenshotsBaseUrl = "/screenshots/") {
+  const images = {};
+  const baseUrl = normalizeScreenshotsBaseUrl(screenshotsBaseUrl);
+  for (const attachment of attachments) {
+    if (attachment.contentType !== "image/png") continue;
+    const match = attachment.name.match(/^(.+?)-(actual|expected|diff)(?:\.png)?$/);
+    if (match === null) continue;
+    const baseName = match[1];
+    const role = match[2];
+    if (baseName === null || baseName === void 0 || role === null || role === void 0) continue;
+    images[baseName] ??= {};
+    const url = `${baseUrl}${attachment.path}`;
+    const img = images[baseName];
+    if (img !== null && img !== void 0) {
+      if (role === "actual") img.actual = url;
+      else if (role === "expected") img.expect = url;
+      else if (role === "diff") img.diff = url;
+    }
+  }
+  for (const key of Object.keys(images)) {
+    const img = images[key];
+    if (img?.actual !== void 0 && img?.expect !== void 0 && img?.diff === void 0) {
+      delete img.expect;
+    }
+  }
+  return mergeDeclaredImages(images, []);
+}
+function mapStatus(status) {
+  switch (status) {
+    case "passed":
+      return "success";
+    case "failed":
+      return "failed";
+    case "skipped":
+      return "pending";
+    default:
+      return "unknown";
+  }
+}
+
+// src/report-state.ts
+function isCurrentArtifact(image) {
+  return image?.actual !== void 0 || image?.expect !== void 0 || image?.diff !== void 0;
+}
+function isReusablePassingImage(image) {
+  const source = image.source ?? classifyImage(image);
+  if (source === "comparison") {
+    return image.actual !== void 0 && image.diff === void 0;
+  }
+  return source === "baseline-only";
+}
+function hasReusablePassingImages(images) {
+  return Object.values(images).some((img) => img !== null && img !== void 0 && isReusablePassingImage(img));
+}
+function preservePreviousPassingImages(test, status, images) {
+  if (status !== "passed") {
+    return images;
+  }
+  const previousImages = test.results?.[0]?.images ?? {};
+  if (!hasReusablePassingImages(previousImages)) {
+    return images;
+  }
+  return Object.entries(previousImages).reduce((currentImages, [name, previousImage]) => {
+    if (!Object.hasOwn(currentImages, name) || previousImage === void 0 || !isReusablePassingImage(previousImage) || isCurrentArtifact(currentImages[name])) {
+      return currentImages;
+    }
+    return {
+      ...currentImages,
+      [name]: {
+        ...previousImage,
+        source: previousImage.source ?? classifyImage(previousImage)
+      }
+    };
+  }, images);
+}
+function countDiffImages(images) {
+  return Object.values(images).filter((img) => img?.diff !== null && img?.diff !== void 0).length;
+}
+function createMutableReportState(screenshotDir = "./screenshots") {
+  return {
+    reportData: {
+      isRunning: false,
+      tests: {},
+      browsers: ["chromium"],
+      isUpdateMode: false,
+      screenshotDir
+    },
+    currentRunIds: /* @__PURE__ */ new Set()
+  };
+}
+function applyTestBeginEvent(state, data) {
+  const { id, title, titlePath, browser, location } = data;
+  state.currentRunIds.add(id);
+  state.reportData.tests[id] ??= {
+    id,
+    titlePath: titlePath ?? [],
+    browser: browser ?? "",
+    title: title ?? "",
+    location,
+    status: "running"
+  };
+  return state.reportData.tests[id];
+}
+function applyTestEndEvent(state, data, options = {}) {
+  const test = state.reportData.tests[data.id];
+  if (test === void 0) {
+    return null;
+  }
+  test.status = mapStatus(data.status);
+  const resultStatus = data.status === "passed" ? "success" : data.status === "failed" ? "failed" : "pending";
+  const images = preservePreviousPassingImages(
+    test,
+    data.status,
+    mergeDeclaredImages(attachmentsToImages(data.attachments, options.screenshotsBaseUrl), data.visualNames)
+  );
+  const diffCount = countDiffImages(images);
+  const hasDiffs = diffCount > 0;
+  if (hasDiffs) {
+    test.approved = null;
+  }
+  test.results = [
+    {
+      status: resultStatus,
+      retries: 0,
+      images,
+      error: data.error,
+      duration: data.duration
+    }
+  ];
+  return {
+    test,
+    diffCount
+  };
+}
+function finalizeRunEvent(state) {
+  state.reportData.isRunning = false;
+  state.reportData.tests = Object.fromEntries(
+    Object.entries(state.reportData.tests).filter(([id]) => state.currentRunIds.has(id))
+  );
+  state.currentRunIds.clear();
+  const runTests = Object.values(state.reportData.tests).filter((test) => test !== void 0);
+  return {
+    passed: runTests.filter((test) => test.status === "success").length,
+    failed: runTests.filter((test) => test.status === "failed").length,
+    pending: runTests.filter((test) => test.status === "pending").length
+  };
+}
+
+// src/schemas.ts
+var import_zod = require("zod");
+var LocationSchema = import_zod.z.object({
+  file: import_zod.z.string(),
+  line: import_zod.z.number()
+});
+var VisualSourceSchema = import_zod.z.enum(["comparison", "baseline-only", "declared-only"]);
+var ImagesSchema = import_zod.z.object({
+  actual: import_zod.z.string().optional(),
+  expect: import_zod.z.string().optional(),
+  diff: import_zod.z.string().optional(),
+  error: import_zod.z.string().optional(),
+  source: VisualSourceSchema.optional()
+});
+var AttachmentSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  path: import_zod.z.string(),
+  contentType: import_zod.z.string()
+});
+var TestStatusSchema = import_zod.z.enum(["unknown", "pending", "running", "failed", "approved", "success", "retrying"]);
+var TestResultStatusSchema = import_zod.z.enum(["failed", "success", "pending"]);
+var TestResultSchema = import_zod.z.object({
+  status: TestResultStatusSchema,
+  retries: import_zod.z.number(),
+  images: import_zod.z.record(import_zod.z.string(), ImagesSchema).optional(),
+  error: import_zod.z.string().optional(),
+  duration: import_zod.z.number().optional()
+});
+var TestDataSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  titlePath: import_zod.z.array(import_zod.z.string()),
+  browser: import_zod.z.string(),
+  title: import_zod.z.string(),
+  skip: import_zod.z.union([import_zod.z.boolean(), import_zod.z.string()]).optional(),
+  retries: import_zod.z.number().optional(),
+  status: TestStatusSchema.optional(),
+  results: import_zod.z.array(TestResultSchema).optional(),
+  approved: import_zod.z.record(import_zod.z.string(), import_zod.z.number()).nullable().optional(),
+  attachments: import_zod.z.array(AttachmentSchema).optional(),
+  location: LocationSchema.optional()
+});
+var CrvyRprtrTestSchema = TestDataSchema.extend({
+  checked: import_zod.z.boolean()
+});
+var CrvyRprtrSuiteSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    path: import_zod.z.array(import_zod.z.string()),
+    skip: import_zod.z.boolean(),
+    status: TestStatusSchema.optional(),
+    opened: import_zod.z.boolean(),
+    checked: import_zod.z.boolean(),
+    indeterminate: import_zod.z.boolean(),
+    children: import_zod.z.record(import_zod.z.string(), import_zod.z.union([CrvyRprtrSuiteSchema, CrvyRprtrTestSchema])).optional()
+  })
+);
+var WebSocketMessageSchema = import_zod.z.object({
+  type: import_zod.z.enum(["test-begin", "test-end", "run-end", "approve", "sync"]),
+  data: import_zod.z.unknown()
+});
+var TestBeginDataSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  title: import_zod.z.string(),
+  titlePath: import_zod.z.array(import_zod.z.string()),
+  browser: import_zod.z.string(),
+  location: LocationSchema
+});
+var TestEndDataSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  status: import_zod.z.enum(["passed", "failed", "skipped"]),
+  attachments: import_zod.z.array(AttachmentSchema),
+  visualNames: import_zod.z.array(import_zod.z.string()).default([]),
+  error: import_zod.z.string().optional(),
+  duration: import_zod.z.number().optional()
+});
+var ReportDataSchema = import_zod.z.object({
+  isRunning: import_zod.z.boolean(),
+  tests: import_zod.z.record(import_zod.z.string(), TestDataSchema),
+  browsers: import_zod.z.array(import_zod.z.string()),
+  isUpdateMode: import_zod.z.boolean(),
+  screenshotDir: import_zod.z.string()
+});
+var LoadedReportDataSchema = import_zod.z.object({
+  tests: import_zod.z.record(import_zod.z.string(), TestDataSchema).optional(),
+  isUpdateMode: import_zod.z.boolean().optional()
+});
+var OfflineEventSchema = import_zod.z.object({
+  type: import_zod.z.enum(["test-begin", "test-end", "run-end"]),
+  data: import_zod.z.unknown(),
+  timestamp: import_zod.z.number(),
+  workerIndex: import_zod.z.number()
+});
+var OfflineReportSchema = import_zod.z.object({
+  version: import_zod.z.number(),
+  generatedAt: import_zod.z.string(),
+  workers: import_zod.z.number(),
+  events: import_zod.z.array(OfflineEventSchema)
+});
+var ApproveRequestBodySchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  retry: import_zod.z.number(),
+  image: import_zod.z.string()
+});
+var ReportApiResponseSchema = import_zod.z.object({
+  tests: import_zod.z.record(import_zod.z.string(), TestDataSchema),
+  isUpdateMode: import_zod.z.boolean().optional()
+});
+var ClientBootstrapDataSchema = import_zod.z.object({
+  report: ReportApiResponseSchema.extend({
+    isUpdateMode: import_zod.z.boolean()
+  }),
+  liveUpdates: import_zod.z.boolean(),
+  approvalEnabled: import_zod.z.boolean(),
+  approvalMessage: import_zod.z.string().optional()
+});
+var ImagesViewModeSchema = import_zod.z.enum(["side-by-side", "swap", "slide", "blend"]);
+function safeParse(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return result.data;
+  }
+  return null;
+}
+
+// src/offline-reports.ts
+var OFFLINE_REPORT_FILE_PATTERN = /^crvy-rprtr(?:-\d+)?\.json$/;
+async function findOfflineReportPaths(searchDir) {
+  try {
+    const entries = await (0, import_promises.readdir)(searchDir);
+    return entries.filter((entry) => OFFLINE_REPORT_FILE_PATTERN.test(entry)).sort((left, right) => left.localeCompare(right)).map((entry) => (0, import_path.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
+var import_promises2 = require("fs/promises");
+var import_path2 = require("path");
+function isFileNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function fileExists(filePath) {
+  try {
+    await (0, import_promises2.access)(filePath);
+    return true;
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function isDirectory(filePath) {
+  try {
+    const stats = await (0, import_promises2.stat)(filePath);
+    return stats.isDirectory();
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function readJsonFile(filePath) {
+  try {
+    const raw = await (0, import_promises2.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 (0, import_promises2.mkdir)((0, import_path2.dirname)(filePath), { recursive: true });
+  await (0, import_promises2.writeFile)(filePath, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function copyFilePortable(sourcePath, destinationPath) {
+  await (0, import_promises2.mkdir)((0, import_path2.dirname)(destinationPath), { recursive: true });
+  await (0, import_promises2.copyFile)(sourcePath, destinationPath);
+}
+function inferContentType(filePath) {
+  switch ((0, import_path2.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 (0, import_promises2.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/report-watch.ts
+var import_promises3 = require("fs/promises");
+var import_path3 = require("path");
+var OFFLINE_REPORT_FILE_PATTERN2 = /^crvy-rprtr(?:-\d+)?\.json$/;
+function createDebouncedRefresh(reload, delayMs = 50) {
+  let timer = null;
+  return () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      void reload();
+    }, delayMs);
+  };
+}
+function isFileNotFound2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function describeFile(filePath, label) {
+  try {
+    const fileStats = await (0, import_promises3.stat)(filePath);
+    return `${label}:${fileStats.size}:${fileStats.mtimeMs}`;
+  } catch (error) {
+    if (isFileNotFound2(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function createOfflineFingerprint(offlineReportDir) {
+  if (!await isDirectory(offlineReportDir)) {
+    return "offline:missing";
+  }
+  try {
+    const entries = await (0, import_promises3.readdir)(offlineReportDir, { withFileTypes: true });
+    const relevantEntries = entries.filter(
+      (entry) => entry.isFile() && (entry.name === "report.json" || OFFLINE_REPORT_FILE_PATTERN2.test(entry.name))
+    ).sort((left, right) => left.name.localeCompare(right.name));
+    const parts = await Promise.all(
+      relevantEntries.map((entry) => describeFile((0, import_path3.join)(offlineReportDir, entry.name), entry.name))
+    );
+    return `offline:${parts.filter((part) => part !== null).join("|")}`;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.warn(`[Server] Unable to scan ${offlineReportDir}: ${errorMsg}`);
+    return "offline:error";
+  }
+}
+async function createScreenshotFingerprint(screenshotDir, relativePath = "") {
+  const directoryPath = relativePath === "" ? screenshotDir : (0, import_path3.join)(screenshotDir, relativePath);
+  if (!await isDirectory(directoryPath)) {
+    return relativePath === "" ? ["screenshots:missing"] : [];
+  }
+  try {
+    const entries = await (0, import_promises3.readdir)(directoryPath, { withFileTypes: true });
+    const parts = await Promise.all(
+      entries.sort((left, right) => left.name.localeCompare(right.name)).map((entry) => {
+        const entryRelativePath = relativePath === "" ? entry.name : (0, import_path3.join)(relativePath, entry.name);
+        if (entry.isDirectory()) {
+          return createScreenshotFingerprint(screenshotDir, entryRelativePath);
+        }
+        return describeFile((0, import_path3.join)(screenshotDir, entryRelativePath), entryRelativePath);
+      })
+    );
+    return parts.flat().filter((part) => part !== null);
+  } catch (error) {
+    if (isFileNotFound2(error)) {
+      return relativePath === "" ? ["screenshots:missing"] : [];
+    }
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.warn(`[Server] Unable to scan ${directoryPath}: ${errorMsg}`);
+    return relativePath === "" ? ["screenshots:error"] : [];
+  }
+}
+async function createArtifactsFingerprint(options) {
+  const [offlineFingerprint, screenshotFingerprint] = await Promise.all([
+    createOfflineFingerprint(options.offlineReportDir),
+    createScreenshotFingerprint(options.screenshotDir)
+  ]);
+  return `${offlineFingerprint}::${screenshotFingerprint.join("|")}`;
+}
+async function watchReportArtifacts(options) {
+  let fingerprint = await createArtifactsFingerprint(options);
+  let isPolling = false;
+  const interval = setInterval(() => {
+    if (isPolling) {
+      return;
+    }
+    isPolling = true;
+    void createArtifactsFingerprint(options).then((nextFingerprint) => {
+      if (nextFingerprint === fingerprint) {
+        return;
+      }
+      fingerprint = nextFingerprint;
+      options.scheduleRefresh();
+    }).catch((error) => {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.warn(`[Server] Artifact refresh poll failed: ${errorMsg}`);
+    }).finally(() => {
+      isPolling = false;
+    });
+  }, 100);
+  return () => {
+    clearInterval(interval);
+  };
+}
+
+// src/server/routes.ts
+var import_path4 = require("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((0, import_path4.join)(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 = (0, import_path4.join)(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 import_meta = { url: require("url").pathToFileURL(__filename).href };
+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 = (0, import_p_limit.default)(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/"
+  });
+}
+function resetReloadableReportData(reportData) {
+  reportData.tests = {};
+  reportData.isUpdateMode = false;
+}
+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 = (0, import_path5.dirname)((0, import_url.fileURLToPath)(import_meta.url));
+  const candidates = staticDir === void 0 ? [
+    currentDir,
+    (0, import_path5.join)(currentDir, "dist"),
+    (0, import_path5.join)(currentDir, "..", "dist"),
+    (0, import_path5.join)(currentDir, "..", "..", "dist"),
+    (0, import_path5.join)(currentDir, ".."),
+    (0, import_path5.join)(currentDir, "..", "..")
+  ] : [staticDir, (0, import_path5.join)(staticDir, "dist")];
+  const resolvedCandidates = await Promise.all(
+    candidates.map(async (candidate) => ({
+      candidate,
+      exists: await fileExists((0, import_path5.join)(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: (0, import_path5.join)(reportPath, "report.json"), offlineReportDir: reportPath };
+  }
+  return { reportFile: reportPath, offlineReportDir: (0, import_path5.dirname)(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);
+  const reloadFromDisk = async () => {
+    resetReloadableReportData(reportData);
+    await loadReport(reportFile, reportData);
+    await loadOfflineReports(offlineReportDir, reportData);
+    broadcastToBrowsers(wsClients, { type: "sync", data: reportData });
+  };
+  await reloadFromDisk();
+  const close = await watchReportArtifacts({
+    offlineReportDir,
+    screenshotDir: reportData.screenshotDir,
+    scheduleRefresh: createDebouncedRefresh(reloadFromDisk)
+  });
+  return {
+    port,
+    wsClients,
+    close,
+    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
+var import_http = require("http");
+var import_ws = require("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 import_ws.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 = (0, import_http.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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startServer
+});