@crvy/rprtr 0.1.3 → 0.2.2

package/dist/reporter.cjs

@@ -36,7 +36,7 @@ __export(reporter_exports, {
 module.exports = __toCommonJS(reporter_exports);
 var import_fs = require("fs");
 var import_promises3 = require("fs/promises");
-var import_path5 = require("path");
+var import_path4 = require("path");
 var import_p_limit2 = __toESM(require("p-limit"), 1);
 
 // src/ci.ts
@@ -56,16 +56,29 @@ var logError = (...args) => {
 
 // src/reporter-artifact-ops.ts
 var import_promises2 = require("fs/promises");
-var import_path3 = require("path");
+var import_path2 = require("path");
 var import_p_limit = __toESM(require("p-limit"), 1);
 
 // src/report-artifact.ts
 var import_promises = require("fs/promises");
-var import_path2 = require("path");
+var import_path = require("path");
 var import_url = require("url");
 
+// 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);
+}
+
 // src/report-utils.ts
-var import_path = require("path");
 function normalizeScreenshotsBaseUrl(baseUrl) {
   return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 }
@@ -110,7 +123,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;
@@ -145,9 +158,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) {
@@ -168,8 +178,8 @@ function preservePreviousPassingImages(test, status, images) {
     return {
       ...currentImages,
       [name]: {
-        ...previousImage,
-        source: previousImage.source ?? classifyImage(previousImage)
+        expect: previousImage.expect,
+        source: "baseline-only"
       }
     };
   }, images);
@@ -192,7 +202,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 ?? "",
@@ -204,7 +219,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];
@@ -242,11 +258,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 {
@@ -257,169 +275,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 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 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_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()
-});
-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) {
@@ -433,7 +493,7 @@ var import_meta = { url: require("url").pathToFileURL(__filename).href };
 var DEFAULT_REPORT_HTML_PATH = "./crvy-rprtr.html";
 var STATIC_ARTIFACT_APPROVAL_MESSAGE = "This artifact is read-only. Open it with the Crvy Rprtr server to approve screenshots.";
 function toBrowserPath(pathValue) {
-  const normalized = pathValue.split(import_path2.sep).join("/");
+  const normalized = pathValue.split(import_path.sep).join("/");
   if (normalized === "") return ".";
   if (normalized.startsWith(".")) return normalized;
   return `./${normalized}`;
@@ -469,11 +529,11 @@ function renderArtifactHtml(template, bootstrapData, stylesheet, script) {
   );
 }
 async function getPackagedAssetPath(fileName) {
-  const currentDir = (0, import_path2.dirname)((0, import_url.fileURLToPath)(import_meta.url));
-  const candidates = [currentDir, (0, import_path2.resolve)(currentDir, "../dist")];
+  const currentDir = (0, import_path.dirname)((0, import_url.fileURLToPath)(import_meta.url));
+  const candidates = [currentDir, (0, import_path.resolve)(currentDir, "../dist")];
   const resolvedCandidates = await Promise.all(
     candidates.map(async (candidate) => {
-      const assetPath = (0, import_path2.resolve)(candidate, fileName);
+      const assetPath = (0, import_path.resolve)(candidate, fileName);
       try {
         await (0, import_promises.access)(assetPath);
         return assetPath;
@@ -491,7 +551,7 @@ async function getPackagedAssetPath(fileName) {
   );
 }
 function buildStaticBootstrapData(events, screenshotDir, htmlPath) {
-  const screenshotBaseUrl = toBrowserDirPath((0, import_path2.relative)((0, import_path2.dirname)(htmlPath), (0, import_path2.resolve)(screenshotDir)));
+  const screenshotBaseUrl = toBrowserDirPath((0, import_path.relative)((0, import_path.dirname)(htmlPath), (0, import_path.resolve)(screenshotDir)));
   const state = createMutableReportState(screenshotDir);
   for (const event of events) {
     switch (event.type) {
@@ -530,13 +590,13 @@ function buildStaticBootstrapData(events, screenshotDir, htmlPath) {
   return parsedBootstrapData;
 }
 async function writeReportArtifact(options) {
-  const reportHtmlPath = (0, import_path2.resolve)(options.reportHtmlPath ?? DEFAULT_REPORT_HTML_PATH);
+  const reportHtmlPath = (0, import_path.resolve)(options.reportHtmlPath ?? DEFAULT_REPORT_HTML_PATH);
   const [indexHtmlPath, indexJsPath, indexCssPath] = await Promise.all([
     getPackagedAssetPath("index.html"),
     getPackagedAssetPath("index.js"),
     getPackagedAssetPath("index.css")
   ]);
-  await (0, import_promises.mkdir)((0, import_path2.dirname)(reportHtmlPath), { recursive: true });
+  await (0, import_promises.mkdir)((0, import_path.dirname)(reportHtmlPath), { recursive: true });
   const [template, script, stylesheet] = await Promise.all([
     (0, import_promises.readFile)(indexHtmlPath, "utf8"),
     (0, import_promises.readFile)(indexJsPath, "utf8"),
@@ -569,9 +629,9 @@ function sanitizeId(id) {
 async function copyResolvedBaseline(safeTestId, testScreenshotDir, target, savedAttachments) {
   const attachmentName = `${target.attachmentBaseName}-expected.png`;
   const artifactPath = safeArtifactPath(attachmentName);
-  const destPath = (0, import_path3.join)(testScreenshotDir, artifactPath);
+  const destPath = (0, import_path2.join)(testScreenshotDir, artifactPath);
   try {
-    await (0, import_promises2.mkdir)((0, import_path3.dirname)(destPath), { recursive: true });
+    await (0, import_promises2.mkdir)((0, import_path2.dirname)(destPath), { recursive: true });
     await (0, import_promises2.copyFile)(target.snapshotPath, destPath);
     savedAttachments.push({ name: attachmentName, path: `${safeTestId}/${artifactPath}`, contentType: "image/png" });
     log(`[CrvyRprtr] Attached baseline: ${target.snapshotPath}`);
@@ -581,7 +641,7 @@ async function copyResolvedBaseline(safeTestId, testScreenshotDir, target, saved
 async function saveAttachments(screenshotDir, testId, result) {
   const savedAttachments = [];
   const safeTestId = sanitizeId(testId);
-  const testScreenshotDir = (0, import_path3.join)(screenshotDir, safeTestId);
+  const testScreenshotDir = (0, import_path2.join)(screenshotDir, safeTestId);
   const limit = (0, import_p_limit.default)(MAX_CONCURRENT_FILE_OPS);
   await Promise.all(
     result.attachments.filter(
@@ -590,8 +650,8 @@ async function saveAttachments(screenshotDir, testId, result) {
       (attachment) => limit(async () => {
         try {
           const artifactPath = safeArtifactPath(attachment.name);
-          const destPath = (0, import_path3.join)(testScreenshotDir, artifactPath);
-          await (0, import_promises2.mkdir)((0, import_path3.dirname)(destPath), { recursive: true });
+          const destPath = (0, import_path2.join)(testScreenshotDir, artifactPath);
+          await (0, import_promises2.mkdir)((0, import_path2.dirname)(destPath), { recursive: true });
           await (0, import_promises2.copyFile)(attachment.path, destPath);
           savedAttachments.push({
             name: attachment.name,
@@ -721,7 +781,7 @@ function extractScreenshotDeclarations(steps) {
 
 // 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) {
@@ -756,16 +816,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(
@@ -775,8 +835,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)],
@@ -794,16 +854,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) {
@@ -827,7 +887,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) {
@@ -869,7 +929,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);
     }
   }
@@ -909,7 +969,7 @@ var CrvyRprtr = class {
   ci;
   pendingArtifacts = [];
   constructor(options = {}) {
-    this.serverUrl = options.serverUrl ?? "ws://localhost:3000";
+    this.serverUrl = options.serverUrl ?? process.env.CRVY_RPRTR_SERVER_URL ?? "ws://localhost:3000";
     this.screenshotDir = options.screenshotDir ?? "./screenshots";
     this.workerIndex = parseInt(process.env.TEST_WORKER_INDEX ?? "0", 10) || 0;
     this.offlineReportPath = options.offlineReportPath ?? `./crvy-rprtr-${this.workerIndex}.json`;
@@ -920,10 +980,9 @@ var CrvyRprtr = class {
     this.ci = options.ci ?? isCI();
     if (this.ci) this.isOfflineMode = true;
   }
-  async onBegin(config, suite) {
-    this.configDir = config.configFile === void 0 ? config.rootDir : (0, import_path5.dirname)(config.configFile);
+  onBegin(config, suite) {
+    this.configDir = config.configFile === void 0 ? config.rootDir : (0, import_path4.dirname)(config.configFile);
     log(`[CrvyRprtr] Starting run with ${suite.allTests().length} tests`);
-    await (0, import_promises3.mkdir)(this.screenshotDir, { recursive: true });
     if (!this.ci) {
       this.connect();
       this.sendRegister(config);
@@ -971,7 +1030,9 @@ var CrvyRprtr = class {
         playwrightSnapshotDir: typeof snapshotDir === "string" ? snapshotDir : void 0,
         playwrightTestDir: typeof testDir === "string" ? testDir : void 0,
         playwrightSnapshotPathTemplate: this.playwrightSnapshotPathTemplate,
-        playwrightToHaveScreenshotPathTemplate: this.playwrightToHaveScreenshotPathTemplate
+        playwrightToHaveScreenshotPathTemplate: this.playwrightToHaveScreenshotPathTemplate,
+        configFile: config.configFile,
+        cwd: config.rootDir ?? process.cwd()
       }
     });
   }
@@ -1009,7 +1070,7 @@ var CrvyRprtr = class {
         titlePath: this.describeTitlePath(test),
         browser: this.resolveBrowserLabel(project),
         projectName: project?.name ?? "",
-        location: { file: test.location.file, line: test.location.line }
+        location: { file: test.location.file, line: test.location.line, column: test.location.column }
       }
     });
   }
@@ -1070,7 +1131,7 @@ var CrvyRprtr = class {
   async copyBaselinesForTargets(testId, status, resolvedTargets, savedAttachments) {
     if (status !== "passed" || resolvedTargets.length === 0) return;
     const safeTestId = sanitizeId(testId);
-    const testScreenshotDir = (0, import_path5.join)(this.screenshotDir, safeTestId);
+    const testScreenshotDir = (0, import_path4.join)(this.screenshotDir, safeTestId);
     const limit = (0, import_p_limit2.default)(5);
     await Promise.all(
       resolvedTargets.map(
@@ -1081,6 +1142,7 @@ var CrvyRprtr = class {
   async onEnd(result) {
     this.send({ type: "run-end", data: { status: result.status } });
     if (this.ci) {
+      await (0, import_promises3.mkdir)(this.screenshotDir, { recursive: true });
       const limit = (0, import_p_limit2.default)(10);
       await Promise.all(
         this.pendingArtifacts.map(