everyscreen 0.0.0-stage → 0.1.0

package/dist/playwright-logic-QFlBFspE.d.mts

@@ -0,0 +1,138 @@
+import { z } from "zod";
+import "playwright";
+import { PlaywrightTestOptions, PlaywrightWorkerOptions, Project } from "@playwright/test";
+import { TestStatus } from "@playwright/test/reporter";
+declare const hubFileSchema: z.ZodObject<{
+  pid: z.ZodNumber;
+  port: z.ZodNumber;
+  devices: z.ZodRecord<z.ZodString, z.ZodObject<{
+    wsEndpoint: z.ZodString;
+    cdpUrl: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type HubFile = z.infer<typeof hubFileSchema>;
+declare const liveTestStatusSchema: z.ZodEnum<{
+  failed: "failed";
+  ok: "ok";
+  running: "running";
+}>;
+declare const testEventSchema: z.ZodObject<{
+  deviceId: z.ZodString;
+  testId: z.ZodString;
+  title: z.ZodString;
+  specFile: z.ZodString;
+  status: z.ZodEnum<{
+    failed: "failed";
+    ok: "ok";
+    running: "running";
+  }>;
+  errorLine: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const stepEventSchema: z.ZodObject<{
+  deviceId: z.ZodString;
+  testId: z.ZodString;
+  stepIndex: z.ZodNumber;
+  stepTitle: z.ZodString;
+  status: z.ZodEnum<{
+    failed: "failed";
+    ok: "ok";
+    running: "running";
+  }>;
+  errorLine: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const runTotalsSchema: z.ZodObject<{
+  phase: z.ZodEnum<{
+    start: "start";
+    update: "update";
+  }>;
+  totalTests: z.ZodNumber;
+  startedAt: z.ZodNumber;
+  endedAt: z.ZodNullable<z.ZodNumber>;
+  okCount: z.ZodNumber;
+  failedCount: z.ZodNumber;
+  outcome: z.ZodNullable<z.ZodEnum<{
+    failed: "failed";
+    ok: "ok";
+  }>>;
+  endReason: z.ZodNullable<z.ZodEnum<{
+    reported: "reported";
+    stopped: "stopped";
+  }>>;
+}, z.core.$strip>;
+declare const testsClearSchema: z.ZodObject<{
+  deviceIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const runSavedSchema: z.ZodObject<{
+  runId: z.ZodString;
+}, z.core.$strip>;
+type LiveTestStatus = z.infer<typeof liveTestStatusSchema>;
+type TestEvent = z.infer<typeof testEventSchema>;
+type StepEvent = z.infer<typeof stepEventSchema>;
+type RunTotals = z.infer<typeof runTotalsSchema>;
+type TestsClear = z.infer<typeof testsClearSchema>;
+type RunSaved = z.infer<typeof runSavedSchema>;
+type FindingKind = "overflow" | "clipped-text" | "safe-area" | "tap-target" | "console-error" | "failed-request";
+declare const SEVERITIES: readonly ["failed", "warn"];
+type Severity = (typeof SEVERITIES)[number];
+interface Finding {
+  kind: FindingKind;
+  severity: Severity;
+  deviceId: string;
+  selector: string | null;
+  message: string;
+}
+interface DeviceOk {
+  status: "ok";
+  deviceId: string;
+  durationMs: number;
+  shotPath: string | null;
+}
+interface DeviceFailure {
+  status: "failed";
+  deviceId: string;
+  durationMs: number;
+  message: string;
+  shotPath: string | null;
+}
+type DeviceAnswer = DeviceOk | DeviceFailure;
+type RunStatus = "running" | "ok" | "failed";
+type RunOrigin = "cli" | "flow" | "playwright";
+type RunKind = "steps" | "sweep";
+interface StepProof {
+  shotPath: string | null;
+  errorMessage: string;
+  codeSnippet: string | null;
+  codeLocation: string | null;
+}
+interface RunStep {
+  stepId: string;
+  title: string;
+  startedAt: number;
+  deviceAnswers: DeviceAnswer[];
+  findings: Finding[];
+  proof: StepProof | null;
+}
+interface Run {
+  runId: string;
+  origin: RunOrigin;
+  runKind: RunKind;
+  status: RunStatus;
+  startedAt: number;
+  steps: RunStep[];
+}
+interface DeviceProjectOptions {
+  everyscreenDeviceId: string | null;
+}
+type DeviceProject = Project<PlaywrightTestOptions & DeviceProjectOptions, PlaywrightWorkerOptions>;
+interface FinishedTest {
+  deviceId: string;
+  titlePath: string[];
+  status: TestStatus;
+  startedAt: number;
+  durationMs: number;
+  errorMessage: string | null;
+  codeSnippet: string | null;
+  codeLocation: string | null;
+  shotPath: string | null;
+}
+export { RunStep as a, RunTotals as c, TestsClear as d, HubFile as f, Run as i, StepEvent as l, DeviceProjectOptions as n, LiveTestStatus as o, FinishedTest as r, RunSaved as s, DeviceProject as t, TestEvent as u };

package/dist/playwright.d.mts

@@ -0,0 +1,2 @@
+import { t as DeviceProject } from "./playwright-logic-QFlBFspE.mjs";
+export declare const listDevices: (deviceIds?: string[] | null) => DeviceProject[];

package/dist/playwright.mjs

@@ -0,0 +1,18 @@
+import { f as pickGridDevices, g as devicesFileSchema, t as parseDevicesYaml } from "./devices-store-edScJDie.mjs";
+import { _ as DEVICES_FILE_PATH } from "./commands-logic-DVWfSe3O.mjs";
+import { h as pickProjectDevices, i as createDeviceProject, r as readOptionalFile, t as readHubFile } from "./read-hub-file-N4rZ-6Wr.mjs";
+// src/playwright/playwright-devices.ts
+const readGridDevices = () => {
+	const devicesYaml = readOptionalFile(DEVICES_FILE_PATH);
+	const devicesFile = devicesYaml === null ? devicesFileSchema.parse({}) : parseDevicesYaml(devicesYaml);
+	return pickGridDevices(devicesFile);
+};
+const listDevices = (deviceIds = null) => {
+	const gridDevices = readGridDevices();
+	const hubDevices = readHubFile()?.devices ?? null;
+	return pickProjectDevices(gridDevices, deviceIds).map((projectDevice) => {
+		const hubDevice = hubDevices?.[projectDevice.id] ?? null;
+		return createDeviceProject(projectDevice, hubDevice);
+	});
+};
+export { listDevices };

package/dist/read-hub-file-N4rZ-6Wr.mjs

@@ -0,0 +1,180 @@
+import { h as hubFileSchema, m as countDeviceStatuses, r as createReplyLine, v as HUB_FILE_PATH, y as HUB_HOST } from "./commands-logic-DVWfSe3O.mjs";
+import { stripVTControlCharacters } from "node:util";
+import { basename, sep } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+// src/playwright/playwright-logic.ts
+const STEP_TITLE_SEPARATOR = " › ";
+const KEY_SEPARATOR = "\0";
+const pickScreenshotMode = (browserName) => {
+	return browserName === "chromium" ? "only-on-failure" : "on";
+};
+const createDeviceProject = (devicePreset, hubDevice) => {
+	const { viewport, screen, deviceScaleFactor, isMobile, hasTouch, userAgent } = devicePreset.use;
+	const connectOptions = hubDevice !== null ? { wsEndpoint: hubDevice.wsEndpoint } : void 0;
+	return {
+		name: devicePreset.id,
+		use: {
+			everyscreenDeviceId: devicePreset.id,
+			browserName: devicePreset.browserName,
+			viewport,
+			screen,
+			deviceScaleFactor,
+			isMobile,
+			hasTouch,
+			userAgent,
+			screenshot: pickScreenshotMode(devicePreset.browserName),
+			connectOptions
+		}
+	};
+};
+const pickProjectDevices = (gridDevices, deviceIds) => {
+	if (deviceIds === null) return gridDevices;
+	return deviceIds.map((deviceId) => {
+		const gridDevice = gridDevices.find(({ id }) => id === deviceId);
+		if (gridDevice === void 0) {
+			const knownIds = gridDevices.map(({ id }) => id).join(", ");
+			throw new Error(`Unknown device ${deviceId}. Known devices: ${knownIds}`);
+		}
+		return gridDevice;
+	});
+};
+const isLastAttempt = (attemptSummary) => {
+	const { status, retry, retries } = attemptSummary;
+	return status === "passed" || status === "skipped" || retry >= retries;
+};
+const pickTestKey = (titlePath) => titlePath.join(KEY_SEPARATOR);
+const isStepComplete = (finishedTests, expectedCount) => finishedTests.length >= expectedCount;
+const isAnswered = (finishedTest) => finishedTest.status !== "skipped";
+const isFailed = (finishedTest) => finishedTest.status !== "passed";
+const pickFirstLine = (message) => {
+	const [firstLine] = stripVTControlCharacters(message).split("\n");
+	return firstLine;
+};
+const createDeviceAnswer = (finishedTest) => {
+	const { deviceId, durationMs, errorMessage, status, shotPath } = finishedTest;
+	if (status === "passed") return {
+		status: "ok",
+		deviceId,
+		durationMs,
+		shotPath: null
+	};
+	return {
+		status: "failed",
+		deviceId,
+		durationMs,
+		message: errorMessage !== null ? pickFirstLine(errorMessage) : `Test ${status}`,
+		shotPath
+	};
+};
+const createStepProof = (failedTest) => {
+	const { errorMessage, status, shotPath, codeSnippet, codeLocation } = failedTest;
+	return {
+		shotPath,
+		errorMessage: errorMessage !== null ? stripVTControlCharacters(errorMessage) : `Test ${status}`,
+		codeSnippet: codeSnippet !== null ? stripVTControlCharacters(codeSnippet) : null,
+		codeLocation
+	};
+};
+const createRunStep = (stepNumber, finishedTests) => {
+	const answeredTests = finishedTests.filter(isAnswered);
+	if (answeredTests.length === 0) return null;
+	const failedTest = answeredTests.find(isFailed);
+	const isAnyTestFailed = failedTest !== void 0;
+	const startTimes = answeredTests.map(({ startedAt }) => startedAt);
+	return {
+		stepId: `step-${stepNumber}`,
+		title: answeredTests[0].titlePath.join(STEP_TITLE_SEPARATOR),
+		startedAt: Math.min(...startTimes),
+		deviceAnswers: answeredTests.map(createDeviceAnswer),
+		findings: [],
+		proof: isAnyTestFailed ? createStepProof(failedTest) : null
+	};
+};
+const pickRunEndStatus = (suiteStatus) => {
+	return suiteStatus === "passed" ? "ok" : "failed";
+};
+const createSuiteReplyLine = (runSteps, runId) => {
+	const { okCount, warnCount, failedCount } = countDeviceStatuses(runSteps);
+	return createReplyLine({
+		unit: "device",
+		okCount,
+		warnCount,
+		failedCount,
+		runId
+	});
+};
+const pickLiveTestStatus = (testStatus) => {
+	return testStatus === "passed" || testStatus === "skipped" ? "ok" : "failed";
+};
+const pickFirstErrorLine = (errorMessage) => {
+	if (errorMessage === null || errorMessage === void 0) return null;
+	return stripVTControlCharacters(errorMessage).split("\n").map((messageLine) => messageLine.trim()).find((messageLine) => messageLine !== "") ?? null;
+};
+const createTestEvent = (testAttempt) => {
+	const { deviceId, testId, titlePath, status, errorMessage } = testAttempt;
+	const [specPath, ...titleParts] = titlePath;
+	const isTestFailed = status === "failed";
+	return {
+		deviceId,
+		testId,
+		title: titleParts.join(STEP_TITLE_SEPARATOR),
+		specFile: basename(specPath ?? ""),
+		status,
+		errorLine: isTestFailed ? pickFirstErrorLine(errorMessage) : null
+	};
+};
+const USER_STEP_CATEGORIES = ["pw:api", "test.step"];
+const HIDDEN_PARENT_CATEGORIES = ["hook", "fixture"];
+const isCountedStep = (category, ancestorCategories) => {
+	const isUserStep = USER_STEP_CATEGORIES.includes(category);
+	const hasHiddenAncestor = ancestorCategories.some((ancestorCategory) => HIDDEN_PARENT_CATEGORIES.includes(ancestorCategory) || USER_STEP_CATEGORIES.includes(ancestorCategory));
+	return isUserStep && !hasHiddenAncestor;
+};
+const isStepFromFolder = (stepFile, folderPath) => {
+	if (stepFile === void 0) return false;
+	return stepFile.startsWith(`${folderPath}${sep}`);
+};
+const createStepEvent = (stepReport) => {
+	const { deviceId, testId, stepIndex, stepTitle, errorMessage, isEnded } = stepReport;
+	const errorLine = pickFirstErrorLine(errorMessage);
+	return {
+		deviceId,
+		testId,
+		stepIndex,
+		stepTitle,
+		status: isEnded ? errorLine !== null ? "failed" : "ok" : "running",
+		errorLine
+	};
+};
+const pickRunOutcome = (suiteStatus) => {
+	return suiteStatus === "passed" ? "ok" : "failed";
+};
+const createHubUrl = (hubFile) => `http://${HUB_HOST}:${hubFile.port}`;
+const pickScreenHubUrl = (hubFile, deviceId) => {
+	if (deviceId === null || hubFile === null) return null;
+	const hubDevice = hubFile.devices[deviceId];
+	if (hubDevice === void 0) return null;
+	if (hubDevice.cdpUrl !== null) return null;
+	return createHubUrl(hubFile);
+};
+// src/playwright/read-optional-file.ts
+const readOptionalFile = (filePath) => {
+	if (!existsSync(filePath)) return null;
+	return readFileSync(filePath, "utf8");
+};
+// src/playwright/read-hub-file.ts
+const readHubFile = () => {
+	const serializedHubFile = readOptionalFile(HUB_FILE_PATH);
+	if (serializedHubFile === null) return null;
+	const hubFileDocument = JSON.parse(serializedHubFile);
+	return hubFileSchema.parse(hubFileDocument);
+};
+const readHubFileSafely = (reportTrouble) => {
+	try {
+		return readHubFile();
+	} catch (error) {
+		reportTrouble(error);
+		return null;
+	}
+};
+export { pickRunOutcome as _, createHubUrl as a, createSuiteReplyLine as c, isLastAttempt as d, isStepComplete as f, pickRunEndStatus as g, pickProjectDevices as h, createDeviceProject as i, createTestEvent as l, pickLiveTestStatus as m, readHubFileSafely as n, createRunStep as o, isStepFromFolder as p, readOptionalFile as r, createStepEvent as s, readHubFile as t, isCountedStep as u, pickScreenHubUrl as v, pickTestKey as y };

package/dist/report-hub-trouble-BjbcuK21.d.mts

@@ -0,0 +1,2 @@
+type ReportHubTrouble = (error: unknown) => void;
+export { ReportHubTrouble as t };

package/dist/report-hub-trouble-CaUiyteI.mjs

@@ -0,0 +1,41 @@
+import { S as LIVE_TESTS_PATH } from "./commands-logic-DVWfSe3O.mjs";
+// src/playwright/post-to-hub.ts
+const POST_TIMEOUT_MS = 2e3;
+const END_WAIT_TIMEOUT_MS = 5e3;
+const JSON_CONTENT_TYPE = "application/json";
+const postToHub = async (hubTarget, routePath, message) => {
+	const { hubUrl, reportTrouble } = hubTarget;
+	try {
+		const hubReply = await fetch(`${hubUrl}${LIVE_TESTS_PATH}${routePath}`, {
+			method: "POST",
+			headers: { "Content-Type": JSON_CONTENT_TYPE },
+			body: JSON.stringify(message),
+			signal: AbortSignal.timeout(POST_TIMEOUT_MS)
+		});
+		if (!hubReply.ok) throw new Error(`The hub answered ${hubReply.status}`);
+		return true;
+	} catch (error) {
+		reportTrouble(error);
+		return false;
+	}
+};
+const waitForHubPosts = async (hubPosts) => {
+	const endSignal = AbortSignal.timeout(END_WAIT_TIMEOUT_MS);
+	const endTimeout = new Promise((finish) => {
+		endSignal.addEventListener("abort", () => finish(), { once: true });
+	});
+	await Promise.race([Promise.all(hubPosts), endTimeout]);
+};
+// src/playwright/report-hub-trouble.ts
+const createHubTroubleReporter = () => {
+	const reporting = { isReported: false };
+	return (error) => {
+		if (reporting.isReported) return;
+		reporting.isReported = true;
+		console.error({
+			message: "Everyscreen could not reach the hub, so the tests run on without live updates",
+			error
+		});
+	};
+};
+export { postToHub as n, waitForHubPosts as r, createHubTroubleReporter as t };

package/dist/reporter.d.mts

@@ -0,0 +1,47 @@
+import { a as RunStep, c as RunTotals, d as TestsClear, i as Run, l as StepEvent, o as LiveTestStatus, r as FinishedTest, s as RunSaved, u as TestEvent } from "./playwright-logic-QFlBFspE.mjs";
+import { t as ReportHubTrouble } from "./report-hub-trouble-BjbcuK21.mjs";
+import { FullConfig, FullResult, Reporter, Suite, TestCase, TestResult, TestStep } from "@playwright/test/reporter";
+interface HubTarget {
+  hubUrl: string;
+  reportTrouble: ReportHubTrouble;
+}
+interface RunEnd {
+  endedAt: number;
+  outcome: "ok" | "failed";
+}
+export default class EveryscreenReporter implements Reporter {
+  rootFolder: string;
+  runCreation: Promise<Run> | null;
+  expectedCounts: Map<string, number>;
+  finishedTests: FinishedTest[];
+  savedKeys: Set<string>;
+  savedSteps: RunStep[];
+  pendingTasks: Promise<void>[];
+  pendingHubPosts: Promise<boolean>[];
+  isHubGivenUp: boolean;
+  heartbeatTimer: ReturnType<typeof setInterval> | null;
+  hubTarget: HubTarget | null;
+  deviceIds: string[];
+  totalTests: number;
+  startedAt: number;
+  okCount: number;
+  failedCount: number;
+  stepIndexes: Map<TestStep, number>;
+  stepCounts: Map<TestResult, number>;
+  runTask: (task: () => Promise<void>) => void;
+  readRun: () => Promise<Run>;
+  postToLiveTests: (routePath: string, message: TestEvent | StepEvent | RunTotals | TestsClear | RunSaved) => void;
+  sendTestEvent: (testCase: TestCase, status: LiveTestStatus, testResult: TestResult) => void;
+  sendRunTotals: (phase: RunTotals["phase"], runEnd: RunEnd | null) => void;
+  sendStepEvent: (testCase: TestCase, testStep: TestStep, stepIndex: number, isEnded: boolean) => void;
+  createHubTarget: () => HubTarget | null;
+  copyShot: (runId: string, testCase: TestCase, testResult: TestResult) => Promise<string | null>;
+  saveStep: (testKey: string) => Promise<void>;
+  onBegin: (config: FullConfig, suite: Suite) => void;
+  onTestBegin: (testCase: TestCase, testResult: TestResult) => void;
+  onStepBegin: (testCase: TestCase, testResult: TestResult, testStep: TestStep) => void;
+  onStepEnd: (testCase: TestCase, _testResult: TestResult, testStep: TestStep) => void;
+  onTestEnd: (testCase: TestCase, testResult: TestResult) => void;
+  onEnd: (fullResult: FullResult) => Promise<void>;
+}
+export {};

package/dist/reporter.mjs

@@ -0,0 +1,250 @@
+import { w as STORE_FOLDER } from "./commands-logic-DVWfSe3O.mjs";
+import { t as runOneAtATime } from "./run-one-at-a-time-BeV_a3Fm.mjs";
+import { o as saveRunEvent, r as createRun } from "./runs-store-Bd_ITPFj.mjs";
+import { _ as pickRunOutcome, a as createHubUrl, c as createSuiteReplyLine, d as isLastAttempt, f as isStepComplete, g as pickRunEndStatus, l as createTestEvent, m as pickLiveTestStatus, n as readHubFileSafely, o as createRunStep, p as isStepFromFolder, s as createStepEvent, u as isCountedStep, y as pickTestKey } from "./read-hub-file-N4rZ-6Wr.mjs";
+import { n as postToHub, r as waitForHubPosts, t as createHubTroubleReporter } from "./report-hub-trouble-CaUiyteI.mjs";
+import { dirname, join, relative } from "node:path";
+import { copyFile, mkdir } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+// src/playwright/playwright-reporter.ts
+const OWN_FOLDER = dirname(fileURLToPath(import.meta.url));
+const SHOTS_SUBFOLDER = "shots";
+const SCREENSHOT_ATTACHMENT_NAME = "screenshot";
+const TEST_EVENTS_QUEUE_KEY = "test-events";
+const HEARTBEAT_INTERVAL_MS = 5e3;
+const RUN_SAVED_PATH = "/run-saved";
+const TITLE_PATH_PROJECT_PARTS = 2;
+const pickTitlePath = (testCase) => testCase.titlePath().slice(TITLE_PATH_PROJECT_PARTS);
+const listAncestorCategories = (testStep) => {
+	const { parent } = testStep;
+	if (parent === void 0) return [];
+	return [parent.category, ...listAncestorCategories(parent)];
+};
+const pickDeviceId = (testCase) => {
+	const project = testCase.parent.project();
+	if (project === void 0) throw new Error(`Test ${testCase.title} belongs to no project`);
+	return project.name;
+};
+var EveryscreenReporter = class {
+	rootFolder = process.cwd();
+	runCreation = null;
+	expectedCounts = /* @__PURE__ */ new Map();
+	finishedTests = [];
+	savedKeys = /* @__PURE__ */ new Set();
+	savedSteps = [];
+	pendingTasks = [];
+	pendingHubPosts = [];
+	isHubGivenUp = false;
+	heartbeatTimer = null;
+	hubTarget = null;
+	deviceIds = [];
+	totalTests = 0;
+	startedAt = 0;
+	okCount = 0;
+	failedCount = 0;
+	stepIndexes = /* @__PURE__ */ new Map();
+	stepCounts = /* @__PURE__ */ new Map();
+	runTask = (task) => {
+		const trackedTask = task().catch((error) => {
+			console.error({
+				message: "Everyscreen could not save the run",
+				error
+			});
+		});
+		this.pendingTasks.push(trackedTask);
+	};
+	readRun = async () => {
+		const { runCreation } = this;
+		if (runCreation === null) throw new Error("The run was never created");
+		return runCreation;
+	};
+	postToLiveTests = (routePath, message) => {
+		const { hubTarget, isHubGivenUp } = this;
+		if (hubTarget === null || isHubGivenUp) return;
+		const hubPost = runOneAtATime(TEST_EVENTS_QUEUE_KEY, async () => {
+			if (this.isHubGivenUp) return false;
+			const isPosted = await postToHub(hubTarget, routePath, message);
+			this.isHubGivenUp = !isPosted;
+			return isPosted;
+		});
+		this.pendingHubPosts.push(hubPost);
+	};
+	sendTestEvent = (testCase, status, testResult) => {
+		const deviceId = pickDeviceId(testCase);
+		const titlePath = pickTitlePath(testCase);
+		const errorMessage = testResult.error?.message;
+		const testEvent = createTestEvent({
+			deviceId,
+			testId: testCase.id,
+			titlePath,
+			status,
+			errorMessage
+		});
+		this.postToLiveTests("/events", testEvent);
+	};
+	sendRunTotals = (phase, runEnd) => {
+		const isRunEnded = runEnd !== null;
+		this.postToLiveTests("/run", {
+			phase,
+			totalTests: this.totalTests,
+			startedAt: this.startedAt,
+			endedAt: isRunEnded ? runEnd.endedAt : null,
+			okCount: this.okCount,
+			failedCount: this.failedCount,
+			outcome: isRunEnded ? runEnd.outcome : null,
+			endReason: isRunEnded ? "reported" : null
+		});
+	};
+	sendStepEvent = (testCase, testStep, stepIndex, isEnded) => {
+		const stepEvent = createStepEvent({
+			deviceId: pickDeviceId(testCase),
+			testId: testCase.id,
+			stepIndex,
+			stepTitle: testStep.title,
+			errorMessage: testStep.error?.message,
+			isEnded
+		});
+		this.postToLiveTests("/steps", stepEvent);
+	};
+	createHubTarget = () => {
+		const reportTrouble = createHubTroubleReporter();
+		const hubFile = readHubFileSafely(reportTrouble);
+		if (hubFile === null) {
+			reportTrouble(/* @__PURE__ */ new Error("There is no hub file, is the hub running?"));
+			return null;
+		}
+		return {
+			hubUrl: createHubUrl(hubFile),
+			reportTrouble
+		};
+	};
+	copyShot = async (runId, testCase, testResult) => {
+		const attachmentPath = testResult.attachments.find(({ name }) => name === SCREENSHOT_ATTACHMENT_NAME)?.path;
+		if (attachmentPath === void 0) return null;
+		const shotPath = join(STORE_FOLDER, SHOTS_SUBFOLDER, `${runId}-${testCase.id}.png`);
+		await mkdir(join(this.rootFolder, STORE_FOLDER, SHOTS_SUBFOLDER), { recursive: true });
+		await copyFile(attachmentPath, join(this.rootFolder, shotPath));
+		return shotPath;
+	};
+	saveStep = async (testKey) => {
+		const keyTests = this.finishedTests.filter(({ titlePath }) => pickTestKey(titlePath) === testKey);
+		const runStep = createRunStep(this.savedSteps.length + 1, keyTests);
+		if (runStep === null) return;
+		this.savedSteps.push(runStep);
+		const { runId } = await this.readRun();
+		await saveRunEvent(this.rootFolder, runId, {
+			kind: "step-end",
+			step: runStep
+		});
+		this.postToLiveTests(RUN_SAVED_PATH, { runId });
+	};
+	onBegin = (config, suite) => {
+		this.hubTarget = this.createHubTarget();
+		this.deviceIds = config.projects.map(({ name }) => name);
+		const allTests = suite.allTests();
+		this.totalTests = allTests.length;
+		this.startedAt = Date.now();
+		this.sendRunTotals("start", null);
+		this.heartbeatTimer = setInterval(() => this.sendRunTotals("update", null), HEARTBEAT_INTERVAL_MS);
+		for (const testCase of allTests) {
+			const testTitlePath = pickTitlePath(testCase);
+			const testKey = pickTestKey(testTitlePath);
+			this.expectedCounts.set(testKey, (this.expectedCounts.get(testKey) ?? 0) + 1);
+		}
+		this.runCreation = createRun(this.rootFolder, "playwright", "steps");
+		this.runCreation.catch((error) => {
+			console.error({
+				message: "Everyscreen could not create the run",
+				error
+			});
+		});
+	};
+	onTestBegin = (testCase, testResult) => {
+		this.sendTestEvent(testCase, "running", testResult);
+	};
+	onStepBegin = (testCase, testResult, testStep) => {
+		const ancestorCategories = listAncestorCategories(testStep);
+		const isUserStep = isCountedStep(testStep.category, ancestorCategories);
+		const isFixtureStep = isStepFromFolder(testStep.location?.file, OWN_FOLDER);
+		if (!isUserStep || isFixtureStep) return;
+		const stepIndex = (this.stepCounts.get(testResult) ?? 0) + 1;
+		this.stepCounts.set(testResult, stepIndex);
+		this.stepIndexes.set(testStep, stepIndex);
+		this.sendStepEvent(testCase, testStep, stepIndex, false);
+	};
+	onStepEnd = (testCase, _testResult, testStep) => {
+		const stepIndex = this.stepIndexes.get(testStep);
+		if (stepIndex === void 0) return;
+		this.stepIndexes.delete(testStep);
+		this.sendStepEvent(testCase, testStep, stepIndex, true);
+	};
+	onTestEnd = (testCase, testResult) => {
+		const liveStatus = pickLiveTestStatus(testResult.status);
+		this.sendTestEvent(testCase, liveStatus, testResult);
+		if (!isLastAttempt({
+			status: testResult.status,
+			retry: testResult.retry,
+			retries: testCase.retries
+		})) return;
+		const isTestFailed = liveStatus === "failed";
+		const isTestGood = liveStatus === "ok";
+		if (isTestFailed) this.failedCount += 1;
+		if (isTestGood) this.okCount += 1;
+		this.sendRunTotals("update", null);
+		this.runTask(async () => {
+			const { runId } = await this.readRun();
+			const shotPath = await this.copyShot(runId, testCase, testResult);
+			const { error, startTime, duration, status } = testResult;
+			const titlePath = pickTitlePath(testCase);
+			const errorLocation = error?.location;
+			const codeLocation = errorLocation !== void 0 ? `${relative(this.rootFolder, errorLocation.file)}:${errorLocation.line}:${errorLocation.column}` : null;
+			this.finishedTests.push({
+				deviceId: pickDeviceId(testCase),
+				titlePath,
+				status,
+				startedAt: startTime.getTime(),
+				durationMs: duration,
+				errorMessage: error?.message ?? null,
+				codeSnippet: error?.snippet ?? null,
+				codeLocation,
+				shotPath
+			});
+			const testKey = pickTestKey(titlePath);
+			const keyTests = this.finishedTests.filter((finishedTest) => pickTestKey(finishedTest.titlePath) === testKey);
+			const expectedCount = this.expectedCounts.get(testKey);
+			if (expectedCount === void 0) throw new Error(`Test ${testCase.title} was not counted at the start`);
+			const isStepSaved = this.savedKeys.has(testKey);
+			if (!isStepComplete(keyTests, expectedCount) || isStepSaved) return;
+			this.savedKeys.add(testKey);
+			await this.saveStep(testKey);
+		});
+	};
+	onEnd = async (fullResult) => {
+		const { heartbeatTimer } = this;
+		if (heartbeatTimer !== null) clearInterval(heartbeatTimer);
+		this.heartbeatTimer = null;
+		this.sendRunTotals("update", {
+			endedAt: Date.now(),
+			outcome: pickRunOutcome(fullResult.status)
+		});
+		this.postToLiveTests("/clear", { deviceIds: this.deviceIds });
+		await waitForHubPosts(this.pendingHubPosts);
+		await Promise.all(this.pendingTasks);
+		const unsavedKeys = [...this.expectedCounts.keys()].filter((testKey) => !this.savedKeys.has(testKey));
+		for (const testKey of unsavedKeys) {
+			this.savedKeys.add(testKey);
+			await this.saveStep(testKey);
+		}
+		const { runId } = await this.readRun();
+		const runEndStatus = pickRunEndStatus(fullResult.status);
+		await saveRunEvent(this.rootFolder, runId, {
+			kind: "run-end",
+			status: runEndStatus
+		});
+		this.postToLiveTests(RUN_SAVED_PATH, { runId });
+		await waitForHubPosts(this.pendingHubPosts);
+		const replyLine = createSuiteReplyLine(this.savedSteps, runId);
+		console.log(replyLine);
+	};
+};
+export { EveryscreenReporter as default };