@crvy/rprtr 0.0.9 → 0.1.0

package/dist/server.cjs

@@ -35,15 +35,16 @@ __export(server_exports, {
 module.exports = __toCommonJS(server_exports);
 
 // src/server/app.ts
-var import_path5 = require("path");
+var import_path8 = 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");
+var import_path2 = require("path");
 
 // src/report-utils.ts
+var import_path = require("path");
 function normalizeScreenshotsBaseUrl(baseUrl) {
   return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 }
@@ -88,7 +89,7 @@ function attachmentsToImages(attachments, screenshotsBaseUrl = "/screenshots/")
     const role = match[2];
     if (baseName === null || baseName === void 0 || role === null || role === void 0) continue;
     images[baseName] ??= {};
-    const url = `${baseUrl}${attachment.path}`;
+    const url = (0, import_path.isAbsolute)(attachment.path) ? `/file/${encodeURIComponent(attachment.path)}` : `${baseUrl}${attachment.path}`;
     const img = images[baseName];
     if (img !== null && img !== void 0) {
       if (role === "actual") img.actual = url;
@@ -300,10 +301,29 @@ var CrvyRprtrSuiteSchema = import_zod.z.lazy(
     children: import_zod.z.record(import_zod.z.string(), import_zod.z.union([CrvyRprtrSuiteSchema, CrvyRprtrTestSchema])).optional()
   })
 );
-var WebSocketMessageSchema = import_zod.z.object({
+var IncomingWebSocketMessageSchema = import_zod.z.object({
   type: import_zod.z.enum(["test-begin", "test-end", "run-end", "approve", "sync"]),
   data: import_zod.z.unknown()
 });
+var WebSocketMessageSchema = import_zod.z.discriminatedUnion("type", [
+  import_zod.z.object({ type: import_zod.z.literal("test-begin"), data: TestDataSchema }),
+  import_zod.z.object({ type: import_zod.z.literal("test-update"), data: TestDataSchema }),
+  import_zod.z.object({
+    type: import_zod.z.literal("run-end"),
+    data: import_zod.z.object({
+      status: import_zod.z.enum(["passed", "failed", "skipped"]),
+      removedTestIds: import_zod.z.array(import_zod.z.string())
+    })
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("sync"),
+    data: import_zod.z.object({
+      tests: import_zod.z.record(import_zod.z.string(), TestDataSchema),
+      isUpdateMode: import_zod.z.boolean().optional()
+    })
+  }),
+  import_zod.z.object({ type: import_zod.z.literal("approve"), data: import_zod.z.unknown() })
+]);
 var TestBeginDataSchema = import_zod.z.object({
   id: import_zod.z.string(),
   title: import_zod.z.string(),
@@ -323,6 +343,9 @@ var TestEndDataSchema = import_zod.z.object({
   error: import_zod.z.string().optional(),
   duration: import_zod.z.number().optional()
 });
+var RunEndDataSchema = import_zod.z.object({
+  status: import_zod.z.enum(["passed", "failed", "skipped"])
+});
 var ReportDataSchema = import_zod.z.object({
   isRunning: import_zod.z.boolean(),
   tests: import_zod.z.record(import_zod.z.string(), TestDataSchema),
@@ -377,7 +400,7 @@ 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));
+    return entries.filter((entry) => OFFLINE_REPORT_FILE_PATTERN.test(entry)).sort((left, right) => left.localeCompare(right)).map((entry) => (0, import_path2.join)(searchDir, entry));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return [];
@@ -429,7 +452,7 @@ function mergeOfflineReportsIntoTests(existingTests, offlineReports, options = {
 
 // src/server/file-utils.ts
 var import_promises2 = require("fs/promises");
-var import_path2 = require("path");
+var import_path3 = require("path");
 function isFileNotFound(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
@@ -470,16 +493,16 @@ async function readJsonFile(filePath) {
   }
 }
 async function writeJsonFile(filePath, value) {
-  await (0, import_promises2.mkdir)((0, import_path2.dirname)(filePath), { recursive: true });
+  await (0, import_promises2.mkdir)((0, import_path3.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.mkdir)((0, import_path3.dirname)(destinationPath), { recursive: true });
   await (0, import_promises2.copyFile)(sourcePath, destinationPath);
 }
 function inferContentType(filePath) {
-  switch ((0, import_path2.extname)(filePath).toLowerCase()) {
+  switch ((0, import_path3.extname)(filePath).toLowerCase()) {
     case ".css":
       return "text/css";
     case ".gif":
@@ -509,7 +532,10 @@ 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 };
+    const headers = { "X-Content-Type-Options": "nosniff" };
+    if (resolvedContentType !== void 0) {
+      headers["Content-Type"] = resolvedContentType;
+    }
     return new Response(file, { headers });
   } catch (error) {
     if (isFileNotFound(error)) {
@@ -519,56 +545,17 @@ async function respondWithFile(filePath, contentType) {
   }
 }
 
-// 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);
-  ctx.reportData.isRunning = true;
-  console.log(`  \u25B6 [${test.browser ?? "?"}] ${test.title}`);
-  broadcastToBrowsers(ctx.wsClients, { type: "test-begin", data });
-}
-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 });
-}
+var import_fs2 = require("fs");
 
-// src/server/routes.ts
+// src/server/artifact-routes.ts
 var import_fs = require("fs");
-var import_path4 = require("path");
+var import_promises3 = require("fs/promises");
+var import_path6 = require("path");
 
 // src/snapshot-path-resolver.ts
 var import_crypto = require("crypto");
-var import_path3 = require("path");
+var import_path4 = require("path");
 var DEFAULT_SCREENSHOT_TEMPLATE = "{snapshotDir}/{testFileDir}/{testFileName}-snapshots/{arg}{-projectName}{-snapshotSuffix}{ext}";
 var WINDOWS_FILESYSTEM_FRIENDLY_LENGTH = 60;
 function isUnsafeFilePathCharacter(character) {
@@ -603,16 +590,16 @@ function trimLongString(value, length = WINDOWS_FILESYSTEM_FRIENDLY_LENGTH) {
   const end = length - middle.length - start;
   return value.slice(0, start) + middle + value.slice(-end);
 }
-function sanitizeFilePathBeforeExtension(filePath, extension = (0, import_path3.extname)(filePath)) {
+function sanitizeFilePathBeforeExtension(filePath, extension = (0, import_path4.extname)(filePath)) {
   const base = filePath.slice(0, filePath.length - extension.length);
   return sanitizeForFilePath(base) + extension;
 }
 function addSuffixToFilePath(filePath, suffix) {
-  const extension = (0, import_path3.extname)(filePath);
+  const extension = (0, import_path4.extname)(filePath);
   return filePath.slice(0, filePath.length - extension.length) + suffix + extension;
 }
 function normalizedSnapshotDir(config) {
-  return (0, import_path3.resolve)(config.configDir, config.snapshotDir);
+  return (0, import_path4.resolve)(config.configDir, config.snapshotDir);
 }
 function templateValue(template, token, value) {
   return template.replace(
@@ -622,8 +609,8 @@ function templateValue(template, token, value) {
 }
 function applyTemplate(input, nameArgument, extension) {
   const template = input.config.toHaveScreenshotPathTemplate ?? input.config.snapshotPathTemplate ?? DEFAULT_SCREENSHOT_TEMPLATE;
-  const relativeTestFilePath = (0, import_path3.relative)(input.config.testDir, input.testFile);
-  const parsed = (0, import_path3.parse)(relativeTestFilePath);
+  const relativeTestFilePath = (0, import_path4.relative)(input.config.testDir, input.testFile);
+  const parsed = (0, import_path4.parse)(relativeTestFilePath);
   const tokens = [
     ["testDir", input.config.testDir],
     ["snapshotDir", normalizedSnapshotDir(input.config)],
@@ -641,16 +628,16 @@ function applyTemplate(input, nameArgument, extension) {
     (currentTemplate, [token, value]) => templateValue(currentTemplate, token, value),
     template
   );
-  return (0, import_path3.resolve)(input.config.configDir, snapshotPath);
+  return (0, import_path4.resolve)(input.config.configDir, snapshotPath);
 }
-function removeExtension(filePath, extension = (0, import_path3.extname)(filePath)) {
+function removeExtension(filePath, extension = (0, import_path4.extname)(filePath)) {
   return filePath.slice(0, filePath.length - extension.length);
 }
 function snapshotNameParts(declaredName) {
-  const extension = (0, import_path3.extname)(declaredName) || ".png";
+  const extension = (0, import_path4.extname)(declaredName) || ".png";
   return {
     extension,
-    filePath: (0, import_path3.extname)(declaredName) === "" ? `${declaredName}${extension}` : declaredName
+    filePath: (0, import_path4.extname)(declaredName) === "" ? `${declaredName}${extension}` : declaredName
   };
 }
 function filePathForOccurrence(filePath, occurrenceIndex) {
@@ -674,7 +661,7 @@ function resolveStringCallTarget(input, declaration) {
 function resolveArrayCallTarget(input, declaration) {
   const { extension, filePath } = snapshotNameParts(declaration.declaredName);
   const occurrenceFilePath = filePathForOccurrence(filePath, declaration.occurrenceIndex);
-  const nameArgument = (0, import_path3.join)((0, import_path3.dirname)(occurrenceFilePath), (0, import_path3.basename)(occurrenceFilePath, extension));
+  const nameArgument = (0, import_path4.join)((0, import_path4.dirname)(occurrenceFilePath), (0, import_path4.basename)(occurrenceFilePath, extension));
   return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
 }
 function resolveNamedTarget(input, declaration) {
@@ -699,9 +686,11 @@ function resolveNamedTarget(input, declaration) {
 function reporterTitlesWithoutProjectAndFile(reporterTitlePath2) {
   return reporterTitlePath2.slice(3).filter((part) => part !== "");
 }
+function anonymousNameFromTitles(titles, occurrenceIndex) {
+  return sanitizeFilePathBeforeExtension(trimLongString(`${titles.join(" ")} ${occurrenceIndex}.png`), ".png");
+}
 function anonymousName(reporterTitlePath2, occurrenceIndex) {
-  const rawAnonymousName = `${reporterTitlesWithoutProjectAndFile(reporterTitlePath2).join(" ")} ${occurrenceIndex}.png`;
-  return sanitizeFilePathBeforeExtension(trimLongString(rawAnonymousName), ".png");
+  return anonymousNameFromTitles(reporterTitlesWithoutProjectAndFile(reporterTitlePath2), occurrenceIndex);
 }
 function resolveTarget(input, declaration) {
   switch (declaration.kind) {
@@ -710,7 +699,7 @@ function resolveTarget(input, declaration) {
     case "unnamed": {
       const anonymousFileName = anonymousName(input.reporterTitlePath, declaration.occurrenceIndex);
       const extension = ".png";
-      const nameArgument = (0, import_path3.join)((0, import_path3.dirname)(anonymousFileName), (0, import_path3.basename)(anonymousFileName, extension));
+      const nameArgument = (0, import_path4.join)((0, import_path4.dirname)(anonymousFileName), (0, import_path4.basename)(anonymousFileName, extension));
       return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
     }
   }
@@ -722,41 +711,67 @@ function resolveBaselineTargets(input) {
   });
 }
 
-// src/server/routes.ts
+// src/server/utils.ts
+var import_path5 = require("path");
 var LIVE_UPDATES_WEBSOCKET_PATH = "/";
+function broadcastToBrowsers(wsClients, msg) {
+  const payload = JSON.stringify(msg);
+  wsClients.forEach((ws) => {
+    ws.send(payload);
+  });
+}
 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 isPathWithinRoots(target, roots) {
+  const resolvedTarget = (0, import_path5.resolve)(target);
+  return roots.some((root) => {
+    const rel = (0, import_path5.relative)((0, import_path5.resolve)(root), resolvedTarget);
+    return rel === "" || !rel.startsWith(`..${import_path5.sep}`) && rel !== ".." && !(0, import_path5.isAbsolute)(rel);
+  });
 }
-function handleApiReport(ctx) {
-  return Response.json(ctx.reportData);
+
+// src/server/artifact-routes.ts
+async function realpathOrNull(path) {
+  try {
+    return await (0, import_promises3.realpath)(path);
+  } catch {
+    return null;
+  }
 }
-var APPROVAL_TARGET_ERROR = "Could not resolve approval target";
-function actualPathFromUrl(ctx, actualUrl) {
-  return actualUrl.startsWith("/screenshots/") ? (0, import_path4.join)(ctx.reportData.screenshotDir, actualUrl.slice("/screenshots/".length)) : actualUrl;
+async function handleFile(ctx, req) {
+  const notFound = () => new Response("Not Found", { status: 404 });
+  let decodedPath;
+  try {
+    decodedPath = (0, import_path6.resolve)(decodeURIComponent(new URL(req.url).pathname.slice("/file/".length)));
+  } catch {
+    return notFound();
+  }
+  const realTarget = await realpathOrNull(decodedPath);
+  if (realTarget === null) {
+    return notFound();
+  }
+  const realRoots = (await Promise.all((ctx.artifactRoots ?? []).map((root) => realpathOrNull((0, import_path6.resolve)(root))))).filter(
+    (root) => root !== null
+  );
+  if (!isPathWithinRoots(realTarget, realRoots)) {
+    return notFound();
+  }
+  try {
+    const file = await respondWithFile(realTarget);
+    return file ?? notFound();
+  } catch {
+    return notFound();
+  }
 }
 function reporterTitlePath(test) {
   const testFile = test.location?.file;
   return ["", test.browser, testFile ?? "", ...test.titlePath, test.title];
 }
-function resolveApprovalTarget(ctx, test, retry, imageName) {
+function resolveBaselineSnapshotPath(routing, test, retry, imageName) {
   const testFile = test.location?.file;
   const declaration = test.results?.[retry]?.visualDeclarations?.find((candidate) => candidate.visualName === imageName);
-  if (ctx.approvalRouting === void 0 || testFile === void 0 || declaration === void 0) {
+  if (routing === void 0 || testFile === void 0 || declaration === void 0) {
     return null;
   }
   const targets = resolveBaselineTargets({
@@ -764,18 +779,162 @@ function resolveApprovalTarget(ctx, test, retry, imageName) {
     reporterTitlePath: reporterTitlePath(test),
     declarations: [declaration],
     config: {
-      configDir: ctx.approvalRouting.configDir,
-      testDir: ctx.approvalRouting.playwrightTestDir ?? (0, import_path4.dirname)(testFile),
-      snapshotDir: ctx.approvalRouting.playwrightSnapshotDir ?? (0, import_path4.dirname)(testFile),
+      configDir: routing.configDir,
+      testDir: routing.playwrightTestDir ?? (0, import_path6.dirname)(testFile),
+      snapshotDir: routing.playwrightSnapshotDir ?? (0, import_path6.dirname)(testFile),
       projectName: test.browser,
       snapshotSuffix: process.platform,
-      snapshotPathTemplate: ctx.approvalRouting.playwrightSnapshotPathTemplate,
-      toHaveScreenshotPathTemplate: ctx.approvalRouting.playwrightToHaveScreenshotPathTemplate
+      snapshotPathTemplate: routing.playwrightSnapshotPathTemplate,
+      toHaveScreenshotPathTemplate: routing.playwrightToHaveScreenshotPathTemplate
     },
     snapshotPathExists: import_fs.existsSync
   });
   return targets.length === 1 ? targets[0]?.snapshotPath ?? null : null;
 }
+async function handleBaseline(ctx, req) {
+  const notFound = () => new Response("Not Found", { status: 404 });
+  let testId;
+  let retry;
+  let visualName;
+  try {
+    const segments = new URL(req.url).pathname.slice("/baseline/".length).split("/");
+    const [rawTestId, retryRaw, ...visualNameParts] = segments;
+    if (rawTestId === void 0 || retryRaw === void 0 || !/^\d+$/.test(retryRaw) || visualNameParts.length === 0) {
+      return notFound();
+    }
+    testId = decodeURIComponent(rawTestId);
+    retry = Number(retryRaw);
+    visualName = decodeURIComponent(visualNameParts.join("/"));
+  } catch {
+    return notFound();
+  }
+  const test = ctx.reportData.tests[testId];
+  if (test === void 0) {
+    return notFound();
+  }
+  const snapshotPath = resolveBaselineSnapshotPath(ctx.approvalRouting, test, retry, visualName);
+  if (snapshotPath === null) {
+    return notFound();
+  }
+  try {
+    const file = await respondWithFile(snapshotPath);
+    return file ?? notFound();
+  } catch {
+    return notFound();
+  }
+}
+function handleArtifactRoute(ctx, req, pathname) {
+  if (pathname.startsWith("/file/")) {
+    return handleFile(ctx, req);
+  }
+  if (pathname.startsWith("/baseline/")) {
+    return handleBaseline(ctx, req);
+  }
+  return null;
+}
+
+// src/server/handlers.ts
+function handleTestBegin(ctx, data) {
+  const test = applyTestBeginEvent(ctx, data);
+  ctx.reportData.isRunning = true;
+  console.log(`  \u25B6 [${test.browser ?? "?"}] ${test.title}`);
+  const message = { type: "test-begin", data: test };
+  broadcastToBrowsers(ctx.wsClients, message);
+}
+function enrichDeclaredBaselines(ctx, test) {
+  const retry = (test.results?.length ?? 0) - 1;
+  const images = test.results?.[retry]?.images;
+  if (retry < 0 || images === void 0) {
+    return;
+  }
+  for (const [visualName, image] of Object.entries(images)) {
+    if (image === void 0 || image.source !== "declared-only") {
+      continue;
+    }
+    const snapshotPath = resolveBaselineSnapshotPath(ctx.approvalRouting, test, retry, visualName);
+    if (snapshotPath === null || !(0, import_fs2.existsSync)(snapshotPath)) {
+      continue;
+    }
+    image.expect = `/baseline/${encodeURIComponent(test.id)}/${retry}/${encodeURIComponent(visualName)}`;
+    image.source = "baseline-only";
+  }
+}
+function handleTestEnd(ctx, data) {
+  const result = applyTestEndEvent(ctx, data);
+  if (result === null) {
+    console.error("[Server] test-end for unknown test id:", data.id);
+    return;
+  }
+  const { test, diffCount } = result;
+  if (data.status === "passed") {
+    enrichDeclaredBaselines(ctx, test);
+  }
+  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}`);
+  const message = { type: "test-update", data: test };
+  broadcastToBrowsers(ctx.wsClients, message);
+}
+async function handleRunEnd(ctx, data) {
+  const removedTestIds = Object.keys(ctx.reportData.tests).filter((id) => !ctx.currentRunIds.has(id));
+  const { passed, failed, pending } = finalizeRunEvent(ctx);
+  await ctx.saveReport();
+  console.log(`
+Run complete \u2014 ${passed} passed, ${failed} failed, ${pending} skipped`);
+  const message = {
+    type: "run-end",
+    data: { status: data.status, removedTestIds }
+  };
+  broadcastToBrowsers(ctx.wsClients, message);
+}
+function handleApprove() {
+  console.log("[Server] Received approve message via WebSocket (handled via HTTP API)");
+}
+function handleSync(ctx) {
+  console.log("[Server] Received sync message");
+  const message = {
+    type: "sync",
+    data: {
+      tests: ctx.reportData.tests,
+      isUpdateMode: ctx.reportData.isUpdateMode
+    }
+  };
+  broadcastToBrowsers(ctx.wsClients, message);
+}
+
+// src/server/routes.ts
+var import_path7 = require("path");
+async function handleRoot(ctx) {
+  const html = await respondWithFile((0, import_path7.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);
+}
+var APPROVAL_TARGET_ERROR = "Could not resolve approval target";
+function actualPathFromUrl(ctx, actualUrl) {
+  if (actualUrl.startsWith("/screenshots/")) {
+    return (0, import_path7.join)(ctx.reportData.screenshotDir, actualUrl.slice("/screenshots/".length));
+  }
+  if (actualUrl.startsWith("/file/")) {
+    return decodeURIComponent(actualUrl.slice("/file/".length));
+  }
+  return actualUrl;
+}
 async function handleApiApprove(ctx, req) {
   try {
     const rawBody = await req.json();
@@ -793,7 +952,7 @@ async function handleApiApprove(ctx, req) {
     if (actualUrl === void 0) {
       return Response.json({ success: false, error: "Actual image not found" }, { status: 409 });
     }
-    const snapshotPath = resolveApprovalTarget(ctx, test, retry, image);
+    const snapshotPath = resolveBaselineSnapshotPath(ctx.approvalRouting, test, retry, image);
     if (snapshotPath === null) {
       return Response.json({ success: false, error: APPROVAL_TARGET_ERROR }, { status: 409 });
     }
@@ -828,7 +987,7 @@ function createBulkApprovalUpdates(ctx) {
       if (actualUrl === void 0) {
         return [Promise.resolve({ kind: "unresolved" })];
       }
-      const snapshotPath = resolveApprovalTarget(ctx, test, lastRetry, imageName);
+      const snapshotPath = resolveBaselineSnapshotPath(ctx.approvalRouting, test, lastRetry, imageName);
       if (snapshotPath === null) {
         return [Promise.resolve({ kind: "unresolved" })];
       }
@@ -891,7 +1050,7 @@ async function handleScreenshots(ctx, req) {
 }
 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 filePath = (0, import_path7.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 });
@@ -919,6 +1078,10 @@ function handleHttpRequest(ctx, req) {
   if (pathname.startsWith("/api/images/")) {
     return handleApiImages(req);
   }
+  const artifactResponse = handleArtifactRoute(ctx, req, pathname);
+  if (artifactResponse !== null) {
+    return artifactResponse;
+  }
   if (pathname.startsWith("/screenshots/")) {
     return handleScreenshots(ctx, req);
   }
@@ -940,12 +1103,13 @@ function createReportData(options) {
     screenshotDir: options.screenshotDir ?? "./screenshots"
   };
 }
-function createHandlerContext(reportData, wsClients, currentRunIds, saveReport) {
+function createHandlerContext(reportData, wsClients, currentRunIds, saveReport, approvalRouting) {
   return {
     reportData,
     wsClients,
     currentRunIds,
-    saveReport
+    saveReport,
+    approvalRouting
   };
 }
 async function loadReport(reportPath, reportData) {
@@ -1015,9 +1179,15 @@ async function handleParsedWebSocketMessage(ctx, msg) {
       handleTestEnd(ctx, parsed);
       break;
     }
-    case "run-end":
-      await handleRunEnd(ctx, msg.data);
+    case "run-end": {
+      const parsed = safeParse(RunEndDataSchema, msg.data);
+      if (parsed === null) {
+        console.error("Invalid run-end message data", msg.data);
+        break;
+      }
+      await handleRunEnd(ctx, parsed);
       break;
+    }
     case "approve":
       handleApprove();
       break;
@@ -1030,7 +1200,7 @@ function createWebSocketMessageHandler(getHandlerContext) {
   return async function handleWebSocketMessage(message) {
     try {
       const parsed = JSON.parse(message);
-      const wsMessage = safeParse(WebSocketMessageSchema, parsed);
+      const wsMessage = safeParse(IncomingWebSocketMessageSchema, parsed);
       if (wsMessage === null) {
         console.error("Invalid WebSocket message: missing or invalid type", parsed);
         return;
@@ -1043,19 +1213,19 @@ function createWebSocketMessageHandler(getHandlerContext) {
   };
 }
 async function resolveStaticDir(staticDir) {
-  const currentDir = (0, import_path5.dirname)((0, import_url.fileURLToPath)(import_meta.url));
+  const currentDir = (0, import_path8.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")];
+    (0, import_path8.join)(currentDir, "dist"),
+    (0, import_path8.join)(currentDir, "..", "dist"),
+    (0, import_path8.join)(currentDir, "..", "..", "dist"),
+    (0, import_path8.join)(currentDir, ".."),
+    (0, import_path8.join)(currentDir, "..", "..")
+  ] : [staticDir, (0, import_path8.join)(staticDir, "dist")];
   const resolvedCandidates = await Promise.all(
     candidates.map(async (candidate) => ({
       candidate,
-      exists: await fileExists((0, import_path5.join)(candidate, "index.html"))
+      exists: await fileExists((0, import_path8.join)(candidate, "index.html"))
     }))
   );
   const resolved = resolvedCandidates.find(({ exists }) => exists);
@@ -1066,15 +1236,19 @@ async function resolveStaticDir(staticDir) {
 }
 async function resolveReportPath(reportPath) {
   if (await isDirectory(reportPath)) {
-    return { reportFile: (0, import_path5.join)(reportPath, "report.json"), offlineReportDir: reportPath };
+    return { reportFile: (0, import_path8.join)(reportPath, "report.json"), offlineReportDir: reportPath };
   }
-  return { reportFile: reportPath, offlineReportDir: (0, import_path5.dirname)(reportPath) };
+  return { reportFile: reportPath, offlineReportDir: (0, import_path8.dirname)(reportPath) };
 }
 function createRoutesContext(reportData, staticDir, saveReport, options) {
+  const artifactRoots = [reportData.screenshotDir, options.outputDir, options.playwrightSnapshotDir].filter(
+    (root) => root !== void 0 && root !== ""
+  );
   return {
     reportData,
     staticDir,
     saveReport,
+    artifactRoots,
     approvalRouting: {
       configDir: options.configDir ?? process.cwd(),
       playwrightTestDir: options.playwrightTestDir,
@@ -1096,7 +1270,7 @@ async function createServerApp(options = {}) {
     await writeJsonFile(reportFile, reportData);
   }
   const routesContext = createRoutesContext(reportData, staticDir, saveReport, options);
-  const getHandlerContext = () => createHandlerContext(reportData, wsClients, currentRunIds, saveReport);
+  const getHandlerContext = () => createHandlerContext(reportData, wsClients, currentRunIds, saveReport, routesContext.approvalRouting);
   const handleRequest = (req) => handleHttpRequest(routesContext, req);
   const handleWebSocketMessage = createWebSocketMessageHandler(getHandlerContext);
   await loadReport(reportFile, reportData);
@@ -1286,7 +1460,7 @@ function attachWebSocketServer(server, app) {
   });
 }
 async function listen(server, port) {
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve4, reject) => {
     const onError = (error) => {
       server.off("error", onError);
       reject(error);
@@ -1294,7 +1468,7 @@ async function listen(server, port) {
     server.on("error", onError);
     server.listen(port, () => {
       server.off("error", onError);
-      resolve2();
+      resolve4();
     });
   });
 }