@crvy/rprtr 0.1.4 → 0.2.3

package/dist/{chunk-KLGJSEKV.js → chunk-473CWZ4V.js}

@@ -5,6 +5,7 @@ import {
   OfflineReportSchema,
   RegisterDataSchema,
   RunEndDataSchema,
+  RunRequestBodySchema,
   TestBeginDataSchema,
   TestEndDataSchema,
   applyTestBeginEvent,
@@ -14,69 +15,16 @@ import {
   isForeignAbsolutePath,
   resolveBaselineTargets,
   safeParse
-} from "./chunk-WRMHUY5A.js";
+} from "./chunk-HAFWYUNO.js";
 
 // src/server/app.ts
-import { dirname as dirname3, join as join3 } from "path";
+import { dirname as dirname3, join as join5 } 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
-  };
-}
+import pLimit from "p-limit";
 
 // src/server/file-utils.ts
 import { access, copyFile, mkdir, readFile, stat, writeFile } from "fs/promises";
@@ -173,6 +121,93 @@ async function respondWithFile(filePath, contentType) {
   }
 }
 
+// src/offline-reports.ts
+var MAX_CONCURRENT_FILE_OPS = 5;
+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;
+}
+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(reportData, offlineReportDir) {
+  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/"
+  });
+}
+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/handlers.ts
 import { existsSync as existsSync2 } from "fs";
 
@@ -315,6 +350,7 @@ function handleArtifactRoute(ctx, req, pathname) {
 function handleTestBegin(ctx, data) {
   const test = applyTestBeginEvent(ctx, data);
   ctx.reportData.isRunning = true;
+  ctx.scheduleReportSave();
   console.log(`  \u25B6 [${test.browser ?? "?"}] ${test.title}`);
   const message = { type: "test-begin", data: test };
   broadcastToBrowsers(ctx.wsClients, message);
@@ -353,12 +389,13 @@ function handleTestEnd(ctx, data) {
   const errNote = data.error !== null && data.error !== void 0 ? `
     Error: ${data.error}` : "";
   console.log(`  ${icon} [${test.browser}] ${test.title}${dur}${diffNote}${errNote}`);
+  ctx.scheduleReportSave();
   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);
+  const removedTestIds = ctx.isFilteredRun ? [] : Object.keys(ctx.reportData.tests).filter((id) => !ctx.currentRunIds.has(id));
+  const { passed, failed, pending } = finalizeRunEvent(ctx, { preserveNonCurrent: ctx.isFilteredRun });
   await ctx.saveReport();
   console.log(`
 Run complete \u2014 ${passed} passed, ${failed} failed, ${pending} skipped`);
@@ -411,16 +448,148 @@ function handleRegister(ctx, data) {
       ctx.routesContext.approvalRouting.playwrightToHaveScreenshotPathTemplate = data.playwrightToHaveScreenshotPathTemplate;
     }
   }
+  if (data.configFile !== void 0 && data.cwd !== void 0) {
+    ctx.routesContext.runContext = { configFile: data.configFile, cwd: data.cwd };
+  }
   console.log("[Server] Reporter registered with config:", {
     playwrightSnapshotDir: data.playwrightSnapshotDir,
     playwrightTestDir: data.playwrightTestDir
   });
 }
 
-// src/server/routes.ts
+// src/server/playwright-config.ts
 import { join as join2 } from "path";
+var CONFIG_FILES = [
+  "playwright.config.ts",
+  "playwright.config.mts",
+  "playwright.config.cts",
+  "playwright.config.js",
+  "playwright.config.mjs",
+  "playwright.config.cjs"
+];
+async function resolvePlaywrightConfig(cwd) {
+  const matches = await Promise.all(
+    CONFIG_FILES.map(async (file) => {
+      const candidate = join2(cwd, file);
+      return await fileExists(candidate) ? candidate : null;
+    })
+  );
+  return matches.find((path) => path !== null) ?? null;
+}
+
+// src/server/report-persistence.ts
+function createDebouncedSaver(save, delayMs, setTimeoutFn = (fn, ms) => setTimeout(fn, ms), clearTimeoutFn = (handle) => {
+  if (handle !== null) clearTimeout(handle);
+}) {
+  let timer = null;
+  let dirty = false;
+  let inFlight = null;
+  const runSave = () => {
+    dirty = false;
+    inFlight = save();
+    return inFlight.finally(() => {
+      inFlight = null;
+    });
+  };
+  return {
+    schedule() {
+      dirty = true;
+      if (timer !== null) clearTimeoutFn(timer);
+      timer = setTimeoutFn(() => {
+        timer = null;
+        void runSave();
+      }, delayMs);
+    },
+    async flush() {
+      if (timer !== null) {
+        clearTimeoutFn(timer);
+        timer = null;
+      }
+      if (inFlight !== null) {
+        await inFlight;
+      }
+      if (dirty) {
+        await runSave();
+      }
+    },
+    cancel() {
+      if (timer !== null) {
+        clearTimeoutFn(timer);
+        timer = null;
+      }
+      dirty = false;
+    }
+  };
+}
+function createReportPersistence(reportFile, reportData) {
+  const reportSaver = createDebouncedSaver(() => writeJsonFile(reportFile, reportData), 250);
+  return {
+    saveReport: () => reportSaver.flush(),
+    scheduleReportSave: () => {
+      reportSaver.schedule();
+    },
+    dispose: () => reportSaver.flush()
+  };
+}
+
+// src/server/routes-context.ts
+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,
+      playwrightSnapshotDir: options.playwrightSnapshotDir,
+      playwrightSnapshotPathTemplate: options.playwrightSnapshotPathTemplate,
+      playwrightToHaveScreenshotPathTemplate: options.playwrightToHaveScreenshotPathTemplate
+    },
+    runContext: void 0
+  };
+}
+
+// src/server/routes.ts
+import { join as join3 } from "path";
+
+// src/server/run-routes.ts
+function handleRunRoutes(pathname, method, runController, req) {
+  if (pathname === "/api/run" && method === "POST") {
+    return handleApiRun(runController, req);
+  }
+  if (pathname === "/api/stop" && method === "POST") {
+    return Promise.resolve(handleApiStop(runController));
+  }
+  return null;
+}
+async function handleApiRun(runController, req) {
+  let body = {};
+  try {
+    body = await req.json();
+  } catch {
+  }
+  const parsed = safeParse(RunRequestBodySchema, body);
+  if (parsed === null) {
+    return Response.json({ ok: false, error: "Invalid request body" }, { status: 400 });
+  }
+  const result = runController.start(parsed);
+  if (result.ok) return Response.json(result);
+  const status = result.reason === "no-tests" ? 400 : 409;
+  return Response.json(result, { status });
+}
+function handleApiStop(runController) {
+  const result = runController.stop();
+  if (result.ok) return Response.json(result);
+  return Response.json(result, { status: 409 });
+}
+
+// src/server/routes.ts
 async function handleRoot(ctx) {
-  const html = await respondWithFile(join2(ctx.staticDir, "index.html"), "text/html");
+  const html = await respondWithFile(join3(ctx.staticDir, "index.html"), "text/html");
   return html ?? new Response("Not Found", { status: 404 });
 }
 async function handleAppCss() {
@@ -435,12 +604,15 @@ async function handleSrcFiles(req) {
   return file ?? new Response("Not Found", { status: 404 });
 }
 function handleApiReport(ctx) {
-  return Response.json(ctx.reportData);
+  return Response.json({
+    ...ctx.reportData,
+    runEnabled: ctx.runContext !== void 0
+  });
 }
 var APPROVAL_TARGET_ERROR = "Could not resolve approval target";
 function actualPathFromUrl(ctx, actualUrl) {
   if (actualUrl.startsWith("/screenshots/")) {
-    return join2(ctx.reportData.screenshotDir, actualUrl.slice("/screenshots/".length));
+    return join3(ctx.reportData.screenshotDir, actualUrl.slice("/screenshots/".length));
   }
   if (actualUrl.startsWith("/file/")) {
     return decodeURIComponent(actualUrl.slice("/file/".length));
@@ -562,12 +734,12 @@ async function handleScreenshots(ctx, req) {
 }
 async function handleDist(ctx, req) {
   const path = new URL(req.url).pathname.slice("/dist/".length);
-  const filePath = join2(ctx.staticDir, path);
+  const filePath = join3(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) {
+function handleHttpRequest(ctx, req, runController) {
   const pathname = new URL(req.url).pathname;
   if (pathname === "/") {
     return handleRoot(ctx);
@@ -587,6 +759,10 @@ function handleHttpRequest(ctx, req) {
   if (pathname === "/api/approve-all" && req.method === "POST") {
     return handleApiApproveAll(ctx);
   }
+  const runResponse = handleRunRoutes(pathname, req.method, runController, req);
+  if (runResponse !== null) {
+    return runResponse;
+  }
   if (pathname.startsWith("/api/images/")) {
     return handleApiImages(req);
   }
@@ -603,8 +779,219 @@ function handleHttpRequest(ctx, req) {
   return Promise.resolve(new Response("Not Found", { status: 404 }));
 }
 
+// src/server/run-controller.ts
+import { spawn } from "child_process";
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join as join4 } from "node:path";
+import { resolveCommand } from "package-manager-detector/commands";
+import { getUserAgent } from "package-manager-detector/detect";
+var STOP_GRACE_MS = 5e3;
+var KNOWN_SIGNALS = {
+  SIGTERM: "SIGTERM",
+  SIGKILL: "SIGKILL"
+};
+function resolvePlaywrightLaunch(cwd, playwrightArgs) {
+  const agent = getUserAgent();
+  const resolved = agent === null ? null : resolveCommand(agent, "execute-local", ["playwright", ...playwrightArgs]);
+  if (resolved !== null) return { cmd: resolved.command, args: resolved.args };
+  return { cmd: "npx", args: ["playwright", ...playwrightArgs] };
+}
+function descriptorLocation(d) {
+  return d.column === void 0 ? `${d.file}:${d.line}` : `${d.file}:${d.line}:${d.column}`;
+}
+function sharedProject(tests) {
+  const names = new Set(tests.map((t) => t.projectName ?? ""));
+  if (names.size === 1) {
+    const name = [...names][0];
+    return name === "" ? void 0 : name;
+  }
+  return void 0;
+}
+function gteMinor(version, major, minor) {
+  const match = /^(\d+)\.(\d+)/.exec(version.trim());
+  if (match === null) return false;
+  const maj = parseInt(match[1], 10);
+  const min = parseInt(match[2], 10);
+  if (maj !== major) return maj > major;
+  return min >= minor;
+}
+function resolvePlaywrightVersion(cwd) {
+  try {
+    const req = createRequire(join4(cwd, "package.json"));
+    const pkgPath = req.resolve("@playwright/test/package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return typeof pkg === "object" && pkg !== null && "version" in pkg && typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+function buildTestListEntries(tests) {
+  return tests.map((d) => {
+    const loc = descriptorLocation(d);
+    const title = d.titlePath.join(" \u203A ");
+    const prefix = d.projectName !== void 0 && d.projectName !== "" ? `[${d.projectName}] \u203A ` : "";
+    return `${prefix}${loc} \u203A ${title}`;
+  });
+}
+function defaultWriteTempFile(content) {
+  const path = join4(tmpdir(), `crvy-rprtr-test-list-${process.pid}-${Date.now()}.txt`);
+  writeFileSync(path, content, "utf8");
+  return path;
+}
+function defaultDeleteTempFile(path) {
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+}
+function resolveReporterDefault(cwd) {
+  try {
+    return createRequire(join4(cwd, "package.json")).resolve("@crvy/rprtr");
+  } catch {
+  }
+  try {
+    return createRequire(import.meta.url).resolve("@crvy/rprtr");
+  } catch {
+    return null;
+  }
+}
+function buildSpawnEnv(port) {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key === "CI") continue;
+    env[key] = value;
+  }
+  env.CRVY_RPRTR_SERVER_URL = `ws://localhost:${port}`;
+  env.PLAYWRIGHT_HTML_OPEN = "never";
+  return env;
+}
+var RunController = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  child = null;
+  sigkillTimer = null;
+  testListPath = null;
+  get isRunning() {
+    return this.child !== null;
+  }
+  supportsTestList(cwd) {
+    const getVersion = this.deps.getPlaywrightVersion ?? resolvePlaywrightVersion;
+    const version = getVersion(cwd);
+    return version !== null && gteMinor(version, 1, 56);
+  }
+  cleanupTempFile() {
+    if (this.testListPath !== null) {
+      const del = this.deps.deleteTempFile ?? defaultDeleteTempFile;
+      del(this.testListPath);
+      this.testListPath = null;
+    }
+  }
+  start(filters) {
+    const ctx = this.deps.getRunContext();
+    if (ctx === null) return { ok: false, reason: "no-config" };
+    if (this.child !== null) return { ok: false, reason: "already-running" };
+    if (filters.tests !== void 0 && filters.tests.length === 0) {
+      return { ok: false, reason: "no-tests" };
+    }
+    const resolveReporter = this.deps.resolveReporter ?? resolveReporterDefault;
+    const reporterModule = resolveReporter(ctx.cwd);
+    const tests = filters.tests;
+    const useTestList = tests !== void 0 && tests.length > 1 && this.supportsTestList(ctx.cwd);
+    const args = ["test", "--config", ctx.configFile];
+    if (reporterModule !== null) args.push("--reporter", reporterModule);
+    if (useTestList && tests !== void 0) {
+      const content = buildTestListEntries(tests).join("\n");
+      const writeTemp = this.deps.writeTempFile ?? defaultWriteTempFile;
+      this.testListPath = writeTemp(content);
+      args.push("--test-list", this.testListPath);
+    } else if (tests !== void 0 && tests.length > 0) {
+      const project = sharedProject(tests);
+      if (project !== void 0) args.push("--project", project);
+      for (const d of tests) args.push(descriptorLocation(d));
+    }
+    const resolveLaunch = this.deps.resolveLaunch ?? resolvePlaywrightLaunch;
+    const { cmd, args: launchArgs } = resolveLaunch(ctx.cwd, args);
+    let child;
+    try {
+      child = this.deps.spawn(cmd, launchArgs, { cwd: ctx.cwd, env: buildSpawnEnv(this.deps.port), stdio: "inherit" });
+    } catch (err) {
+      this.cleanupTempFile();
+      throw err;
+    }
+    this.child = child;
+    child.on("exit", (code) => {
+      this.handleChildExit(code);
+    });
+    child.on("error", () => {
+      this.handleChildExit(null);
+    });
+    this.deps.setReportRunning(true);
+    this.deps.setRunFiltered?.(filters.tests !== void 0);
+    this.deps.broadcast({ type: "run-status", data: { running: true } });
+    return { ok: true };
+  }
+  stop() {
+    if (this.child === null) return { ok: false, reason: "not-running" };
+    if (this.sigkillTimer !== null) this.deps.timers.clearTimeout(this.sigkillTimer);
+    this.child.kill("SIGTERM");
+    this.sigkillTimer = this.deps.timers.setTimeout(() => {
+      if (this.child !== null) this.child.kill("SIGKILL");
+    }, STOP_GRACE_MS);
+    return { ok: true };
+  }
+  dispose() {
+    if (this.child === null) return;
+    if (this.sigkillTimer !== null) this.deps.timers.clearTimeout(this.sigkillTimer);
+    this.sigkillTimer = null;
+    this.child.kill("SIGKILL");
+    this.cleanupTempFile();
+  }
+  handleChildExit(code) {
+    if (this.child === null) return;
+    if (this.sigkillTimer !== null) {
+      this.deps.timers.clearTimeout(this.sigkillTimer);
+      this.sigkillTimer = null;
+    }
+    this.child = null;
+    this.cleanupTempFile();
+    if (code !== null && code !== 0) {
+      console.warn(`[RunController] playwright test exited with code ${code}`);
+    }
+    this.deps.setReportRunning(false);
+    this.deps.broadcast({ type: "run-status", data: { running: false } });
+    void this.deps.saveReport?.();
+  }
+};
+function createRealSpawn() {
+  return (cmd, args, opts) => {
+    const cp = spawn(cmd, args, opts);
+    return {
+      on: (event, cb) => cp.on(event, cb),
+      kill: (signal) => {
+        const sig = KNOWN_SIGNALS[signal];
+        if (sig !== void 0) cp.kill(sig);
+      }
+    };
+  };
+}
+function createRealTimers() {
+  const pending = [];
+  return {
+    setTimeout: (fn, ms) => {
+      const id = setTimeout(fn, ms);
+      pending.push(id);
+      return id;
+    },
+    clearTimeout: () => {
+      for (const h of pending.splice(0)) clearTimeout(h);
+    }
+  };
+}
+
 // src/server/app.ts
-var MAX_CONCURRENT_FILE_OPS = 5;
 function createReportData(options) {
   return {
     isRunning: false,
@@ -630,37 +1017,6 @@ async function loadReport(reportPath, reportData) {
     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": {
@@ -727,16 +1083,16 @@ async function resolveStaticDir(staticDir) {
   const currentDir = dirname3(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")];
+    join5(currentDir, "dist"),
+    join5(currentDir, "..", "dist"),
+    join5(currentDir, "..", "..", "dist"),
+    join5(currentDir, ".."),
+    join5(currentDir, "..", "..")
+  ] : [staticDir, join5(staticDir, "dist")];
   const resolvedCandidates = await Promise.all(
     candidates.map(async (candidate) => ({
       candidate,
-      exists: await fileExists(join3(candidate, "index.html"))
+      exists: await fileExists(join5(candidate, "index.html"))
     }))
   );
   const resolved = resolvedCandidates.find(({ exists }) => exists);
@@ -747,27 +1103,34 @@ async function resolveStaticDir(staticDir) {
 }
 async function resolveReportPath(reportPath) {
   if (await isDirectory(reportPath)) {
-    return { reportFile: join3(reportPath, "report.json"), offlineReportDir: reportPath };
+    return { reportFile: join5(reportPath, "report.json"), offlineReportDir: reportPath };
   }
   return { reportFile: reportPath, offlineReportDir: dirname3(reportPath) };
 }
-function createRoutesContext(reportData, staticDir, saveReport, options) {
-  const artifactRoots = [reportData.screenshotDir, options.outputDir, options.playwrightSnapshotDir].filter(
-    (root) => root !== void 0 && root !== ""
-  );
-  return {
-    reportData,
-    staticDir,
+async function seedRunContext(routesContext, options) {
+  if (routesContext.runContext !== void 0) {
+    return;
+  }
+  const configFile = options.playwrightConfig ?? await resolvePlaywrightConfig(process.cwd());
+  if (configFile !== null) {
+    routesContext.runContext = { configFile, cwd: process.cwd() };
+  }
+}
+function createServerRunController(routesContext, wsClients, reportData, port, setRunFiltered, saveReport) {
+  return new RunController({
+    getRunContext: () => routesContext.runContext ?? null,
+    port,
+    broadcast: (message) => {
+      broadcastToBrowsers(wsClients, message);
+    },
+    setReportRunning: (running) => {
+      reportData.isRunning = running;
+    },
+    setRunFiltered,
     saveReport,
-    artifactRoots,
-    approvalRouting: {
-      configDir: options.configDir ?? process.cwd(),
-      playwrightTestDir: options.playwrightTestDir,
-      playwrightSnapshotDir: options.playwrightSnapshotDir,
-      playwrightSnapshotPathTemplate: options.playwrightSnapshotPathTemplate,
-      playwrightToHaveScreenshotPathTemplate: options.playwrightToHaveScreenshotPathTemplate
-    }
-  };
+    spawn: createRealSpawn(),
+    timers: createRealTimers()
+  });
 }
 async function createServerApp(options = {}) {
   const port = options.port ?? 3e3;
@@ -777,31 +1140,49 @@ async function createServerApp(options = {}) {
   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 = createRoutesContext(reportData, staticDir, saveReport, options);
+  const persistence = createReportPersistence(reportFile, reportData);
+  const routesContext = createRoutesContext(reportData, staticDir, persistence.saveReport, options);
+  await seedRunContext(routesContext, options);
+  let isFilteredRun = false;
+  const runController = createServerRunController(
+    routesContext,
+    wsClients,
+    reportData,
+    port,
+    (filtered) => {
+      isFilteredRun = filtered;
+    },
+    persistence.saveReport
+  );
   const getHandlerContext = () => ({
     reportData,
     wsClients,
     currentRunIds,
-    saveReport,
+    isFilteredRun,
+    saveReport: persistence.saveReport,
+    scheduleReportSave: persistence.scheduleReportSave,
     approvalRouting: routesContext.approvalRouting,
-    routesContext
+    routesContext,
+    runController
   });
-  const handleRequest = (req) => handleHttpRequest(routesContext, req);
+  const handleRequest = (req) => handleHttpRequest(routesContext, req, runController);
   const handleWebSocketMessage = createWebSocketMessageHandler(getHandlerContext);
   await loadReport(reportFile, reportData);
-  await loadOfflineReports(offlineReportDir, reportData);
+  await loadOfflineReports(reportData, offlineReportDir);
   return {
     port,
     wsClients,
-    close: () => {
-    },
+    close: createCloseHandler(persistence, runController),
     handleRequest,
     handleWebSocketMessage
   };
 }
+function createCloseHandler(persistence, runController) {
+  return async () => {
+    await persistence.dispose();
+    runController.dispose();
+  };
+}
 
 // src/server/bun-adapter.ts
 function logWebSocketError(prefix, error) {
@@ -999,9 +1380,37 @@ async function startNodeServer(app) {
   console.log(`Crvy Rprtr started at http://localhost:${app.port}`);
 }
 
+// src/server/shutdown.ts
+var EXIT_CODES = {
+  SIGINT: 130,
+  SIGTERM: 143,
+  SIGHUP: 129
+};
+function createSignalShutdown(deps) {
+  let shuttingDown = false;
+  return async function shutdown(signal) {
+    if (shuttingDown) {
+      deps.exit(EXIT_CODES[signal] ?? 1);
+      return;
+    }
+    shuttingDown = true;
+    try {
+      await deps.close();
+    } catch {
+    }
+    deps.exit(EXIT_CODES[signal] ?? 1);
+  };
+}
+
 // src/server.ts
 async function startServer(options = {}) {
   const app = await createServerApp(options);
+  const shutdown = createSignalShutdown({ close: () => app.close(), exit: (code) => process.exit(code) });
+  const onSignal = (signal) => {
+    void shutdown(signal);
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
   if (typeof Bun !== "undefined" && typeof Bun.serve === "function") {
     startBunServer(app);
     return;