@crvy/rprtr 0.1.4 → 0.2.2

package/dist/server.cjs

@@ -35,13 +35,13 @@ __export(server_exports, {
 module.exports = __toCommonJS(server_exports);
 
 // src/server/app.ts
-var import_path7 = 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_promises2 = require("fs/promises");
+var import_path2 = require("path");
+var import_p_limit = __toESM(require("p-limit"), 1);
 
 // src/path-utils.ts
 var posixAbsolutePattern = /^\//u;
@@ -186,7 +186,12 @@ function createMutableReportState(screenshotDir = "./screenshots") {
 function applyTestBeginEvent(state, data) {
   const { id, title, titlePath, browser, projectName, location } = data;
   state.currentRunIds.add(id);
-  state.reportData.tests[id] ??= {
+  const existing = state.reportData.tests[id];
+  if (existing !== void 0) {
+    existing.status = "running";
+    return existing;
+  }
+  const created = {
     id,
     titlePath: titlePath ?? [],
     browser: browser ?? "",
@@ -198,7 +203,8 @@ function applyTestBeginEvent(state, data) {
     location,
     status: "running"
   };
-  return state.reportData.tests[id];
+  state.reportData.tests[id] = created;
+  return created;
 }
 function applyTestEndEvent(state, data, options = {}) {
   const test = state.reportData.tests[data.id];
@@ -236,11 +242,13 @@ function applyTestEndEvent(state, data, options = {}) {
     diffCount
   };
 }
-function finalizeRunEvent(state) {
+function finalizeRunEvent(state, options = {}) {
   state.reportData.isRunning = false;
-  state.reportData.tests = Object.fromEntries(
-    Object.entries(state.reportData.tests).filter(([id]) => state.currentRunIds.has(id))
-  );
+  if (options.preserveNonCurrent !== true) {
+    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 {
@@ -251,169 +259,211 @@ function finalizeRunEvent(state) {
 }
 
 // src/schemas.ts
+var import_zod2 = require("zod");
+
+// src/schemas/http.ts
 var import_zod = require("zod");
-var LocationSchema = import_zod.z.object({
+var ApproveRequestBodySchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  retry: import_zod.z.number(),
+  image: import_zod.z.string()
+});
+var RunTestDescriptorSchema = import_zod.z.object({
   file: import_zod.z.string(),
-  line: import_zod.z.number()
+  line: import_zod.z.number(),
+  column: import_zod.z.number().optional(),
+  projectName: import_zod.z.string().optional(),
+  titlePath: import_zod.z.array(import_zod.z.string())
 });
-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 RunRequestBodySchema = import_zod.z.object({
+  tests: import_zod.z.array(RunTestDescriptorSchema).optional()
 });
-var ScreenshotDeclarationSchema = import_zod.z.discriminatedUnion("kind", [
+var RunResponseSchema = import_zod.z.discriminatedUnion("ok", [
+  import_zod.z.object({ ok: import_zod.z.literal(true) }),
   import_zod.z.object({
-    visualName: import_zod.z.string(),
-    kind: import_zod.z.literal("named"),
-    declaredName: import_zod.z.string(),
-    snapshotBaseName: import_zod.z.string(),
-    occurrenceIndex: import_zod.z.number()
-  }),
+    ok: import_zod.z.literal(false),
+    reason: import_zod.z.enum(["no-config", "already-running", "no-tests"])
+  })
+]);
+var StopResponseSchema = import_zod.z.discriminatedUnion("ok", [
+  import_zod.z.object({ ok: import_zod.z.literal(true) }),
   import_zod.z.object({
-    visualName: import_zod.z.string(),
-    kind: import_zod.z.literal("unnamed"),
-    occurrenceIndex: import_zod.z.number()
+    ok: import_zod.z.literal(false),
+    reason: import_zod.z.literal("not-running")
   })
 ]);
-var AttachmentSchema = import_zod.z.object({
-  name: import_zod.z.string(),
-  path: import_zod.z.string(),
-  contentType: import_zod.z.string()
+
+// src/schemas.ts
+var LocationSchema = import_zod2.z.object({
+  file: import_zod2.z.string(),
+  line: import_zod2.z.number(),
+  column: import_zod2.z.number().optional()
+});
+var VisualSourceSchema = import_zod2.z.enum(["comparison", "baseline-only", "declared-only"]);
+var ImagesSchema = import_zod2.z.object({
+  actual: import_zod2.z.string().optional(),
+  expect: import_zod2.z.string().optional(),
+  diff: import_zod2.z.string().optional(),
+  error: import_zod2.z.string().optional(),
+  source: VisualSourceSchema.optional()
 });
-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({
+var ScreenshotDeclarationSchema = import_zod2.z.discriminatedUnion("kind", [
+  import_zod2.z.object({
+    visualName: import_zod2.z.string(),
+    kind: import_zod2.z.literal("named"),
+    declaredName: import_zod2.z.string(),
+    snapshotBaseName: import_zod2.z.string(),
+    occurrenceIndex: import_zod2.z.number()
+  }),
+  import_zod2.z.object({
+    visualName: import_zod2.z.string(),
+    kind: import_zod2.z.literal("unnamed"),
+    occurrenceIndex: import_zod2.z.number()
+  })
+]);
+var AttachmentSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  path: import_zod2.z.string(),
+  contentType: import_zod2.z.string()
+});
+var TestStatusSchema = import_zod2.z.enum(["unknown", "pending", "running", "failed", "approved", "success", "retrying"]);
+var TestResultStatusSchema = import_zod2.z.enum(["failed", "success", "pending"]);
+var TestResultSchema = import_zod2.z.object({
   status: TestResultStatusSchema,
-  retries: import_zod.z.number(),
-  images: import_zod.z.record(import_zod.z.string(), ImagesSchema).optional(),
-  visualDeclarations: import_zod.z.array(ScreenshotDeclarationSchema).optional(),
-  error: import_zod.z.string().optional(),
-  duration: import_zod.z.number().optional()
+  retries: import_zod2.z.number(),
+  images: import_zod2.z.record(import_zod2.z.string(), ImagesSchema).optional(),
+  visualDeclarations: import_zod2.z.array(ScreenshotDeclarationSchema).optional(),
+  error: import_zod2.z.string().optional(),
+  duration: import_zod2.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(),
-  projectName: import_zod.z.string().optional(),
-  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(),
+var TestDataSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  titlePath: import_zod2.z.array(import_zod2.z.string()),
+  browser: import_zod2.z.string(),
+  projectName: import_zod2.z.string().optional(),
+  title: import_zod2.z.string(),
+  skip: import_zod2.z.union([import_zod2.z.boolean(), import_zod2.z.string()]).optional(),
+  retries: import_zod2.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(),
+  results: import_zod2.z.array(TestResultSchema).optional(),
+  approved: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.number()).nullable().optional(),
+  attachments: import_zod2.z.array(AttachmentSchema).optional(),
   location: LocationSchema.optional()
 });
 var CrvyRprtrTestSchema = TestDataSchema.extend({
-  checked: import_zod.z.boolean()
+  checked: import_zod2.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(),
+var CrvyRprtrSuiteSchema = import_zod2.z.lazy(
+  () => import_zod2.z.object({
+    path: import_zod2.z.array(import_zod2.z.string()),
+    skip: import_zod2.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()
+    opened: import_zod2.z.boolean(),
+    checked: import_zod2.z.boolean(),
+    indeterminate: import_zod2.z.boolean(),
+    children: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.union([CrvyRprtrSuiteSchema, CrvyRprtrTestSchema])).optional()
   })
 );
-var IncomingWebSocketMessageSchema = import_zod.z.object({
-  type: import_zod.z.enum(["test-begin", "test-end", "run-end", "approve", "sync", "register"]),
-  data: import_zod.z.unknown()
+var IncomingWebSocketMessageSchema = import_zod2.z.object({
+  type: import_zod2.z.enum(["test-begin", "test-end", "run-end", "approve", "sync", "register"]),
+  data: import_zod2.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())
+var WebSocketMessageSchema = import_zod2.z.discriminatedUnion("type", [
+  import_zod2.z.object({ type: import_zod2.z.literal("test-begin"), data: TestDataSchema }),
+  import_zod2.z.object({ type: import_zod2.z.literal("test-update"), data: TestDataSchema }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("run-end"),
+    data: import_zod2.z.object({
+      status: import_zod2.z.enum(["passed", "failed", "skipped"]),
+      removedTestIds: import_zod2.z.array(import_zod2.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_zod2.z.object({
+    type: import_zod2.z.literal("sync"),
+    data: import_zod2.z.object({
+      tests: import_zod2.z.record(import_zod2.z.string(), TestDataSchema),
+      isUpdateMode: import_zod2.z.boolean().optional()
     })
   }),
-  import_zod.z.object({ type: import_zod.z.literal("approve"), data: import_zod.z.unknown() })
+  import_zod2.z.object({ type: import_zod2.z.literal("approve"), data: import_zod2.z.unknown() }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("run-status"),
+    data: import_zod2.z.object({
+      running: import_zod2.z.boolean()
+    })
+  })
 ]);
-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(),
-  projectName: import_zod.z.string().optional(),
+var TestBeginDataSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  title: import_zod2.z.string(),
+  titlePath: import_zod2.z.array(import_zod2.z.string()),
+  browser: import_zod2.z.string(),
+  projectName: import_zod2.z.string().optional(),
   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([]),
-  visualDeclarations: import_zod.z.preprocess(
+var TestEndDataSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  status: import_zod2.z.enum(["passed", "failed", "skipped"]),
+  attachments: import_zod2.z.array(AttachmentSchema),
+  visualNames: import_zod2.z.array(import_zod2.z.string()).default([]),
+  visualDeclarations: import_zod2.z.preprocess(
     (value) => value === null ? void 0 : value,
-    import_zod.z.array(ScreenshotDeclarationSchema).optional()
+    import_zod2.z.array(ScreenshotDeclarationSchema).optional()
   ),
-  error: import_zod.z.string().optional(),
-  duration: import_zod.z.number().optional()
+  error: import_zod2.z.string().optional(),
+  duration: import_zod2.z.number().optional()
 });
-var RunEndDataSchema = import_zod.z.object({
-  status: import_zod.z.enum(["passed", "failed", "skipped"])
+var RunEndDataSchema = import_zod2.z.object({
+  status: import_zod2.z.enum(["passed", "failed", "skipped"])
 });
-var RegisterDataSchema = import_zod.z.object({
-  playwrightSnapshotDir: import_zod.z.string().optional(),
-  playwrightTestDir: import_zod.z.string().optional(),
-  playwrightSnapshotPathTemplate: import_zod.z.string().optional(),
-  playwrightToHaveScreenshotPathTemplate: import_zod.z.string().optional()
+var RegisterDataSchema = import_zod2.z.object({
+  playwrightSnapshotDir: import_zod2.z.string().optional(),
+  playwrightTestDir: import_zod2.z.string().optional(),
+  playwrightSnapshotPathTemplate: import_zod2.z.string().optional(),
+  playwrightToHaveScreenshotPathTemplate: import_zod2.z.string().optional(),
+  configFile: import_zod2.z.string().optional(),
+  cwd: import_zod2.z.string().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 ReportDataSchema = import_zod2.z.object({
+  isRunning: import_zod2.z.boolean(),
+  tests: import_zod2.z.record(import_zod2.z.string(), TestDataSchema),
+  browsers: import_zod2.z.array(import_zod2.z.string()),
+  isUpdateMode: import_zod2.z.boolean(),
+  screenshotDir: import_zod2.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 LoadedReportDataSchema = import_zod2.z.object({
+  tests: import_zod2.z.record(import_zod2.z.string(), TestDataSchema).optional(),
+  isUpdateMode: import_zod2.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 OfflineEventSchema = import_zod2.z.object({
+  type: import_zod2.z.enum(["test-begin", "test-end", "run-end"]),
+  data: import_zod2.z.unknown(),
+  timestamp: import_zod2.z.number(),
+  workerIndex: import_zod2.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 OfflineReportSchema = import_zod2.z.object({
+  version: import_zod2.z.number(),
+  generatedAt: import_zod2.z.string(),
+  workers: import_zod2.z.number(),
+  events: import_zod2.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_zod2.z.object({
+  tests: import_zod2.z.record(import_zod2.z.string(), TestDataSchema),
+  isUpdateMode: import_zod2.z.boolean().optional(),
+  isRunning: import_zod2.z.boolean().optional(),
+  runEnabled: import_zod2.z.boolean().optional()
 });
-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({
+var ClientBootstrapDataSchema = import_zod2.z.object({
   report: ReportApiResponseSchema.extend({
-    isUpdateMode: import_zod.z.boolean()
+    isUpdateMode: import_zod2.z.boolean()
   }),
-  liveUpdates: import_zod.z.boolean(),
-  approvalEnabled: import_zod.z.boolean(),
-  approvalMessage: import_zod.z.string().optional()
+  liveUpdates: import_zod2.z.boolean(),
+  approvalEnabled: import_zod2.z.boolean(),
+  approvalMessage: import_zod2.z.string().optional(),
+  runEnabled: import_zod2.z.boolean().optional(),
+  isRunning: import_zod2.z.boolean().optional()
 });
-var ImagesViewModeSchema = import_zod.z.enum(["side-by-side", "swap", "slide", "blend"]);
+var ImagesViewModeSchema = import_zod2.z.enum(["side-by-side", "swap", "slide", "blend"]);
 function safeParse(schema, data) {
   const result = schema.safeParse(data);
   if (result.success) {
@@ -422,70 +472,15 @@ function safeParse(schema, 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");
+var import_promises = require("fs/promises");
+var import_path = 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);
+    await (0, import_promises.access)(filePath);
     return true;
   } catch (error) {
     if (isFileNotFound(error)) {
@@ -496,7 +491,7 @@ async function fileExists(filePath) {
 }
 async function isDirectory(filePath) {
   try {
-    const stats = await (0, import_promises2.stat)(filePath);
+    const stats = await (0, import_promises.stat)(filePath);
     return stats.isDirectory();
   } catch (error) {
     if (isFileNotFound(error)) {
@@ -507,7 +502,7 @@ async function isDirectory(filePath) {
 }
 async function readJsonFile(filePath) {
   try {
-    const raw = await (0, import_promises2.readFile)(filePath, "utf8");
+    const raw = await (0, import_promises.readFile)(filePath, "utf8");
     if (raw.trim() === "") {
       return null;
     }
@@ -520,16 +515,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.writeFile)(filePath, `${JSON.stringify(value, null, 2)}
+  await (0, import_promises.mkdir)((0, import_path.dirname)(filePath), { recursive: true });
+  await (0, import_promises.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);
+  await (0, import_promises.mkdir)((0, import_path.dirname)(destinationPath), { recursive: true });
+  await (0, import_promises.copyFile)(sourcePath, destinationPath);
 }
 function inferContentType(filePath) {
-  switch ((0, import_path2.extname)(filePath).toLowerCase()) {
+  switch ((0, import_path.extname)(filePath).toLowerCase()) {
     case ".css":
       return "text/css";
     case ".gif":
@@ -557,7 +552,7 @@ function inferContentType(filePath) {
 }
 async function respondWithFile(filePath, contentType) {
   try {
-    const file = await (0, import_promises2.readFile)(filePath);
+    const file = await (0, import_promises.readFile)(filePath);
     const resolvedContentType = contentType ?? inferContentType(filePath);
     const headers = { "X-Content-Type-Options": "nosniff" };
     if (resolvedContentType !== void 0) {
@@ -572,6 +567,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 (0, import_promises2.readdir)(searchDir);
+    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 [];
+    }
+    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 = (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 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
 var import_fs2 = require("fs");
 
@@ -914,8 +996,8 @@ function handleTestEnd(ctx, data) {
   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`);
@@ -968,16 +1050,93 @@ 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
 var import_path6 = require("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 = (0, import_path6.join)(cwd, file);
+      return await fileExists(candidate) ? candidate : null;
+    })
+  );
+  return matches.find((path) => path !== null) ?? null;
+}
+
+// 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
+var import_path7 = require("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((0, import_path6.join)(ctx.staticDir, "index.html"), "text/html");
+  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() {
@@ -992,12 +1151,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 (0, import_path6.join)(ctx.reportData.screenshotDir, actualUrl.slice("/screenshots/".length));
+    return (0, import_path7.join)(ctx.reportData.screenshotDir, actualUrl.slice("/screenshots/".length));
   }
   if (actualUrl.startsWith("/file/")) {
     return decodeURIComponent(actualUrl.slice("/file/".length));
@@ -1119,12 +1281,12 @@ async function handleScreenshots(ctx, req) {
 }
 async function handleDist(ctx, req) {
   const path = new URL(req.url).pathname.slice("/dist/".length);
-  const filePath = (0, import_path6.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 });
 }
-function handleHttpRequest(ctx, req) {
+function handleHttpRequest(ctx, req, runController) {
   const pathname = new URL(req.url).pathname;
   if (pathname === "/") {
     return handleRoot(ctx);
@@ -1144,6 +1306,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);
   }
@@ -1160,9 +1326,222 @@ function handleHttpRequest(ctx, req) {
   return Promise.resolve(new Response("Not Found", { status: 404 }));
 }
 
-// src/server/app.ts
+// src/server/run-controller.ts
+var import_child_process = require("child_process");
+var import_node_fs = require("node:fs");
+var import_node_module = require("node:module");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_commands = require("package-manager-detector/commands");
+var import_detect = require("package-manager-detector/detect");
 var import_meta = { url: require("url").pathToFileURL(__filename).href };
-var MAX_CONCURRENT_FILE_OPS = 5;
+var STOP_GRACE_MS = 5e3;
+var KNOWN_SIGNALS = {
+  SIGTERM: "SIGTERM",
+  SIGKILL: "SIGKILL"
+};
+function resolvePlaywrightLaunch(cwd, playwrightArgs) {
+  const agent = (0, import_detect.getUserAgent)();
+  const resolved = agent === null ? null : (0, import_commands.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 = (0, import_node_module.createRequire)((0, import_node_path.join)(cwd, "package.json"));
+    const pkgPath = req.resolve("@playwright/test/package.json");
+    const pkg = JSON.parse((0, import_node_fs.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 = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `crvy-rprtr-test-list-${process.pid}-${Date.now()}.txt`);
+  (0, import_node_fs.writeFileSync)(path, content, "utf8");
+  return path;
+}
+function defaultDeleteTempFile(path) {
+  try {
+    (0, import_node_fs.unlinkSync)(path);
+  } catch {
+  }
+}
+function resolveReporterDefault(cwd) {
+  try {
+    return (0, import_node_module.createRequire)((0, import_node_path.join)(cwd, "package.json")).resolve("@crvy/rprtr");
+  } catch {
+  }
+  try {
+    return (0, import_node_module.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 } });
+  }
+};
+function createRealSpawn() {
+  return (cmd, args, opts) => {
+    const cp = (0, import_child_process.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 import_meta2 = {};
 function createReportData(options) {
   return {
     isRunning: false,
@@ -1188,37 +1567,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 = (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/"
-  });
-}
 async function handleParsedWebSocketMessage(ctx, msg) {
   switch (msg.type) {
     case "test-begin": {
@@ -1282,19 +1630,19 @@ function createWebSocketMessageHandler(getHandlerContext) {
   };
 }
 async function resolveStaticDir(staticDir) {
-  const currentDir = (0, import_path7.dirname)((0, import_url.fileURLToPath)(import_meta.url));
+  const currentDir = (0, import_path8.dirname)((0, import_url.fileURLToPath)(import_meta2.url));
   const candidates = staticDir === void 0 ? [
     currentDir,
-    (0, import_path7.join)(currentDir, "dist"),
-    (0, import_path7.join)(currentDir, "..", "dist"),
-    (0, import_path7.join)(currentDir, "..", "..", "dist"),
-    (0, import_path7.join)(currentDir, ".."),
-    (0, import_path7.join)(currentDir, "..", "..")
-  ] : [staticDir, (0, import_path7.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_path7.join)(candidate, "index.html"))
+      exists: await fileExists((0, import_path8.join)(candidate, "index.html"))
     }))
   );
   const resolved = resolvedCandidates.find(({ exists }) => exists);
@@ -1305,27 +1653,33 @@ async function resolveStaticDir(staticDir) {
 }
 async function resolveReportPath(reportPath) {
   if (await isDirectory(reportPath)) {
-    return { reportFile: (0, import_path7.join)(reportPath, "report.json"), offlineReportDir: reportPath };
+    return { reportFile: (0, import_path8.join)(reportPath, "report.json"), offlineReportDir: reportPath };
   }
-  return { reportFile: reportPath, offlineReportDir: (0, import_path7.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,
-      playwrightSnapshotDir: options.playwrightSnapshotDir,
-      playwrightSnapshotPathTemplate: options.playwrightSnapshotPathTemplate,
-      playwrightToHaveScreenshotPathTemplate: options.playwrightToHaveScreenshotPathTemplate
-    }
-  };
+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) {
+  return new RunController({
+    getRunContext: () => routesContext.runContext ?? null,
+    port,
+    broadcast: (message) => {
+      broadcastToBrowsers(wsClients, message);
+    },
+    setReportRunning: (running) => {
+      reportData.isRunning = running;
+    },
+    setRunFiltered,
+    spawn: createRealSpawn(),
+    timers: createRealTimers()
+  });
 }
 async function createServerApp(options = {}) {
   const port = options.port ?? 3e3;
@@ -1335,26 +1689,32 @@ 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 saveReport = () => writeJsonFile(reportFile, reportData);
   const routesContext = createRoutesContext(reportData, staticDir, saveReport, options);
+  await seedRunContext(routesContext, options);
+  let isFilteredRun = false;
+  const runController = createServerRunController(routesContext, wsClients, reportData, port, (filtered) => {
+    isFilteredRun = filtered;
+  });
   const getHandlerContext = () => ({
     reportData,
     wsClients,
     currentRunIds,
+    isFilteredRun,
     saveReport,
     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: () => {
+      runController.dispose();
     },
     handleRequest,
     handleWebSocketMessage