@crvy/rprtr 0.1.3 → 0.2.2

package/dist/server.cjs

@@ -37,14 +37,32 @@ module.exports = __toCommonJS(server_exports);
 // src/server/app.ts
 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_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;
+var windowsDrivePattern = /^[A-Za-z]:[\\/]/u;
+var windowsUncPattern = /^[\\/][\\/]/u;
+function isPosixAbsolutePath(p) {
+  return posixAbsolutePattern.test(p);
+}
+function isWindowsAbsolutePath(p) {
+  return windowsDrivePattern.test(p) || windowsUncPattern.test(p);
+}
+function isAnyAbsolutePath(p) {
+  return isPosixAbsolutePath(p) || isWindowsAbsolutePath(p);
+}
+function isForeignAbsolutePath(p, hostPlatform) {
+  if (!isAnyAbsolutePath(p)) return false;
+  if (hostPlatform === "win32") return !isWindowsAbsolutePath(p);
+  return !isPosixAbsolutePath(p);
+}
 
 // src/report-utils.ts
-var import_path = require("path");
 function normalizeScreenshotsBaseUrl(baseUrl) {
   return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 }
@@ -89,7 +107,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 = (0, import_path.isAbsolute)(attachment.path) ? `/file/${encodeURIComponent(attachment.path)}` : `${baseUrl}${attachment.path}`;
+    const url = isAnyAbsolutePath(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;
@@ -124,9 +142,6 @@ function isCurrentArtifact(image) {
 }
 function isReusablePassingImage(image) {
   const source = image.source ?? classifyImage(image);
-  if (source === "comparison") {
-    return image.actual !== void 0 && image.diff === void 0;
-  }
   return source === "baseline-only";
 }
 function hasReusablePassingImages(images) {
@@ -147,8 +162,8 @@ function preservePreviousPassingImages(test, status, images) {
     return {
       ...currentImages,
       [name]: {
-        ...previousImage,
-        source: previousImage.source ?? classifyImage(previousImage)
+        expect: previousImage.expect,
+        source: "baseline-only"
       }
     };
   }, images);
@@ -171,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 ?? "",
@@ -183,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];
@@ -221,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 {
@@ -236,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")
+  })
+]);
+
+// 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 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_zod.z.object({
-  name: import_zod.z.string(),
-  path: import_zod.z.string(),
-  contentType: import_zod.z.string()
+var AttachmentSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  path: import_zod2.z.string(),
+  contentType: import_zod2.z.string()
 });
-var TestStatusSchema = import_zod.z.enum(["unknown", "pending", "running", "failed", "approved", "success", "retrying"]);
-var TestResultStatusSchema = import_zod.z.enum(["failed", "success", "pending"]);
-var TestResultSchema = import_zod.z.object({
+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()
-});
-var RunEndDataSchema = import_zod.z.object({
-  status: import_zod.z.enum(["passed", "failed", "skipped"])
+  error: import_zod2.z.string().optional(),
+  duration: import_zod2.z.number().optional()
 });
-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 RunEndDataSchema = import_zod2.z.object({
+  status: import_zod2.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),
-  browsers: import_zod.z.array(import_zod.z.string()),
-  isUpdateMode: import_zod.z.boolean(),
-  screenshotDir: import_zod.z.string()
+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 LoadedReportDataSchema = import_zod.z.object({
-  tests: import_zod.z.record(import_zod.z.string(), TestDataSchema).optional(),
-  isUpdateMode: import_zod.z.boolean().optional()
+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 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 LoadedReportDataSchema = import_zod2.z.object({
+  tests: import_zod2.z.record(import_zod2.z.string(), TestDataSchema).optional(),
+  isUpdateMode: import_zod2.z.boolean().optional()
 });
-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 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 ApproveRequestBodySchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  retry: import_zod.z.number(),
-  image: import_zod.z.string()
+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 ReportApiResponseSchema = import_zod.z.object({
-  tests: import_zod.z.record(import_zod.z.string(), TestDataSchema),
-  isUpdateMode: import_zod.z.boolean().optional()
+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 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) {
@@ -407,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_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;
-}
-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_path3 = 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)) {
@@ -481,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)) {
@@ -492,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;
     }
@@ -505,16 +515,16 @@ async function readJsonFile(filePath) {
   }
 }
 async function writeJsonFile(filePath, value) {
-  await (0, import_promises2.mkdir)((0, import_path3.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_path3.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_path3.extname)(filePath).toLowerCase()) {
+  switch ((0, import_path.extname)(filePath).toLowerCase()) {
     case ".css":
       return "text/css";
     case ".gif":
@@ -542,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) {
@@ -557,17 +567,104 @@ 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");
 
 // src/server/artifact-routes.ts
 var import_fs = require("fs");
 var import_promises3 = require("fs/promises");
-var import_path6 = require("path");
+var import_path5 = require("path");
 
 // src/snapshot-path-resolver.ts
 var import_crypto = require("crypto");
-var import_path4 = require("path");
+var import_path3 = require("path");
 var DEFAULT_SCREENSHOT_TEMPLATE = "{snapshotDir}/{testFileDir}/{testFileName}-snapshots/{arg}{-projectName}{-snapshotSuffix}{ext}";
 var WINDOWS_FILESYSTEM_FRIENDLY_LENGTH = 60;
 function isUnsafeFilePathCharacter(character) {
@@ -602,16 +699,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_path4.extname)(filePath)) {
+function sanitizeFilePathBeforeExtension(filePath, extension = (0, import_path3.extname)(filePath)) {
   const base = filePath.slice(0, filePath.length - extension.length);
   return sanitizeForFilePath(base) + extension;
 }
 function addSuffixToFilePath(filePath, suffix) {
-  const extension = (0, import_path4.extname)(filePath);
+  const extension = (0, import_path3.extname)(filePath);
   return filePath.slice(0, filePath.length - extension.length) + suffix + extension;
 }
 function normalizedSnapshotDir(config) {
-  return (0, import_path4.resolve)(config.configDir, config.snapshotDir);
+  return (0, import_path3.resolve)(config.configDir, config.snapshotDir);
 }
 function templateValue(template, token, value) {
   return template.replace(
@@ -621,8 +718,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_path4.relative)(input.config.testDir, input.testFile);
-  const parsed = (0, import_path4.parse)(relativeTestFilePath);
+  const relativeTestFilePath = (0, import_path3.relative)(input.config.testDir, input.testFile);
+  const parsed = (0, import_path3.parse)(relativeTestFilePath);
   const tokens = [
     ["testDir", input.config.testDir],
     ["snapshotDir", normalizedSnapshotDir(input.config)],
@@ -640,16 +737,16 @@ function applyTemplate(input, nameArgument, extension) {
     (currentTemplate, [token, value]) => templateValue(currentTemplate, token, value),
     template
   );
-  return (0, import_path4.resolve)(input.config.configDir, snapshotPath);
+  return (0, import_path3.resolve)(input.config.configDir, snapshotPath);
 }
-function removeExtension(filePath, extension = (0, import_path4.extname)(filePath)) {
+function removeExtension(filePath, extension = (0, import_path3.extname)(filePath)) {
   return filePath.slice(0, filePath.length - extension.length);
 }
 function snapshotNameParts(declaredName) {
-  const extension = (0, import_path4.extname)(declaredName) || ".png";
+  const extension = (0, import_path3.extname)(declaredName) || ".png";
   return {
     extension,
-    filePath: (0, import_path4.extname)(declaredName) === "" ? `${declaredName}${extension}` : declaredName
+    filePath: (0, import_path3.extname)(declaredName) === "" ? `${declaredName}${extension}` : declaredName
   };
 }
 function filePathForOccurrence(filePath, occurrenceIndex) {
@@ -673,7 +770,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_path4.join)((0, import_path4.dirname)(occurrenceFilePath), (0, import_path4.basename)(occurrenceFilePath, extension));
+  const nameArgument = (0, import_path3.join)((0, import_path3.dirname)(occurrenceFilePath), (0, import_path3.basename)(occurrenceFilePath, extension));
   return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
 }
 function resolveNamedTarget(input, declaration) {
@@ -711,7 +808,7 @@ function resolveTarget(input, declaration) {
     case "unnamed": {
       const anonymousFileName = anonymousName(input.reporterTitlePath, declaration.occurrenceIndex);
       const extension = ".png";
-      const nameArgument = (0, import_path4.join)((0, import_path4.dirname)(anonymousFileName), (0, import_path4.basename)(anonymousFileName, extension));
+      const nameArgument = (0, import_path3.join)((0, import_path3.dirname)(anonymousFileName), (0, import_path3.basename)(anonymousFileName, extension));
       return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
     }
   }
@@ -724,7 +821,7 @@ function resolveBaselineTargets(input) {
 }
 
 // src/server/utils.ts
-var import_path5 = require("path");
+var import_path4 = require("path");
 var LIVE_UPDATES_WEBSOCKET_PATH = "/";
 function broadcastToBrowsers(wsClients, msg) {
   const payload = JSON.stringify(msg);
@@ -736,10 +833,10 @@ function isWebSocketUpgradeRequest(req) {
   return new URL(req.url).pathname === LIVE_UPDATES_WEBSOCKET_PATH && req.headers.get("upgrade")?.toLowerCase() === "websocket";
 }
 function isPathWithinRoots(target, roots) {
-  const resolvedTarget = (0, import_path5.resolve)(target);
+  const resolvedTarget = (0, import_path4.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);
+    const rel = (0, import_path4.relative)((0, import_path4.resolve)(root), resolvedTarget);
+    return rel === "" || !rel.startsWith(`..${import_path4.sep}`) && rel !== ".." && !(0, import_path4.isAbsolute)(rel);
   });
 }
 
@@ -753,17 +850,24 @@ async function realpathOrNull(path) {
 }
 async function handleFile(ctx, req) {
   const notFound = () => new Response("Not Found", { status: 404 });
+  let rawDecoded;
   let decodedPath;
   try {
-    decodedPath = (0, import_path6.resolve)(decodeURIComponent(new URL(req.url).pathname.slice("/file/".length)));
+    rawDecoded = decodeURIComponent(new URL(req.url).pathname.slice("/file/".length));
+    decodedPath = (0, import_path5.resolve)(rawDecoded);
   } catch {
     return notFound();
   }
   const realTarget = await realpathOrNull(decodedPath);
   if (realTarget === null) {
+    if (isForeignAbsolutePath(rawDecoded, process.platform)) {
+      console.warn(
+        `[Crvy Rprtr] /file request resolved to a foreign-OS absolute path that cannot be served on ${process.platform}: ${rawDecoded}`
+      );
+    }
     return notFound();
   }
-  const realRoots = (await Promise.all((ctx.artifactRoots ?? []).map((root) => realpathOrNull((0, import_path6.resolve)(root))))).filter(
+  const realRoots = (await Promise.all((ctx.artifactRoots ?? []).map((root) => realpathOrNull((0, import_path5.resolve)(root))))).filter(
     (root) => root !== null
   );
   if (!isPathWithinRoots(realTarget, realRoots)) {
@@ -793,8 +897,8 @@ function resolveBaselineSnapshotPath(routing, test, retry, imageName) {
     declarations: [declaration],
     config: {
       configDir: routing.configDir,
-      testDir: routing.playwrightTestDir ?? (0, import_path6.dirname)(testFile),
-      snapshotDir: routing.playwrightSnapshotDir ?? (0, import_path6.dirname)(testFile),
+      testDir: routing.playwrightTestDir ?? (0, import_path5.dirname)(testFile),
+      snapshotDir: routing.playwrightSnapshotDir ?? (0, import_path5.dirname)(testFile),
       projectName: test.projectName ?? test.browser,
       snapshotSuffix: process.platform,
       snapshotPathTemplate: routing.playwrightSnapshotPathTemplate,
@@ -892,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`);
@@ -946,14 +1050,91 @@ 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/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_path7.join)(ctx.staticDir, "index.html"), "text/html");
   return html ?? new Response("Not Found", { status: 404 });
@@ -970,7 +1151,10 @@ 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) {
@@ -1102,7 +1286,7 @@ async function handleDist(ctx, req) {
   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);
@@ -1122,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);
   }
@@ -1138,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,
@@ -1166,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": {
@@ -1260,7 +1630,7 @@ function createWebSocketMessageHandler(getHandlerContext) {
   };
 }
 async function resolveStaticDir(staticDir) {
-  const currentDir = (0, import_path8.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_path8.join)(currentDir, "dist"),
@@ -1287,23 +1657,29 @@ async function resolveReportPath(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;
@@ -1313,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