@crvy/rprtr 0.0.4 → 0.0.7

package/CHANGELOG.md

@@ -5,6 +5,87 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.7] - 2026-06-05
+
+### Ci
+
+- Upgrade actions and node version for npm trusted publishing
+## [0.0.6] - 2026-06-05
+
+### Added
+
+- Add named screenshot baseline resolver
+- Resolve unnamed and duplicate screenshot baselines
+- Resolve passed screenshot baselines through Playwright rules
+- Persist approval resolver metadata in report state
+- Emit approval resolver metadata from reporter
+- Reuse resolver for approval routing
+- Report mixed approval routing outcomes
+
+### Changed
+
+- Separate resolver attachment and artifact names
+- Tighten screenshot declaration typing
+
+### Documentation
+
+- Add passed screenshot baseline resolution design
+- Add passed screenshot baseline resolution plan
+- Document passed screenshot baseline resolution options
+- Narrow approval path claims
+- Add template-aware approval routing design
+- Add template-aware approval routing plan
+- Align approval routing docs with resolver behavior
+- Clarify approval routing configuration scope
+
+### Fixed
+
+- Sanitize named screenshot resolver inputs
+- Preserve visual names in named baseline targets
+- Disambiguate named screenshot baseline resolution
+- Restore reporter declaration compatibility
+- Use safe artifact names for copied baselines
+- Encode copied baseline artifact paths safely
+- Neutralize traversal segments in baseline artifact paths
+- Encode saved attachment artifact paths safely
+- Use stable traversal-safe artifact path encoding
+- Preserve approval metadata through schemas
+- Preserve visual name fallback for older payloads
+- Use configured testDir for approval resolution
+- Use configured configDir for approval resolution
+- Require POST for approve-all routing
+- Require POST for approve routing
+- Report no-actual bulk approval outcomes
+- Honor approval api results in client state
+
+### Testing
+
+- Cover exact approval routing cases
+
+### Ci
+
+- Switch npm publish to OIDC trusted publishing
+## [0.0.5] - 2026-05-14
+
+### Added
+
+- Classify passed visual assertions in report state
+- Emit declared visual names for screenshot steps
+- Refresh report state from disk changes
+- Label passed visual fallback states in ui
+
+### Documentation
+
+- Describe passed screenshot fallback modes
+
+### Fixed
+
+- **ci:** Checkout hooks submodule
+
+### Miscellaneous
+
+- Add you-lint-not-pass hook integration
+- Exclude hooks repo from root checks
 ## [0.0.4] - 2026-04-23
 
 ### Added

package/README.md

@@ -50,12 +50,15 @@ npx crvy-rprtr ./artifacts
 
 ## Reporter Options
 
-| Option              | Type     | Default                        | Description                                        |
-| ------------------- | -------- | ------------------------------ | -------------------------------------------------- |
-| `serverUrl`         | `string` | `"ws://localhost:3000"`        | WebSocket URL of the Crvy Rprtr server             |
-| `screenshotDir`     | `string` | `"./screenshots"`              | Directory for saving screenshot artifacts          |
-| `offlineReportPath` | `string` | `"./crvy-rprtr-{worker}.json"` | Path for offline report when server is unavailable |
-| `reportHtmlPath`    | `string` | `"./crvy-rprtr.html"`          | Path for the browser-openable static report HTML   |
+| Option                                   | Type     | Default                        | Description                                                                                            |
+| ---------------------------------------- | -------- | ------------------------------ | ------------------------------------------------------------------------------------------------------ |
+| `serverUrl`                              | `string` | `"ws://localhost:3000"`        | WebSocket URL of the Crvy Rprtr server                                                                 |
+| `screenshotDir`                          | `string` | `"./screenshots"`              | Directory for saving screenshot artifacts                                                              |
+| `offlineReportPath`                      | `string` | `"./crvy-rprtr-{worker}.json"` | Path for offline report when server is unavailable                                                     |
+| `reportHtmlPath`                         | `string` | `"./crvy-rprtr.html"`          | Path for the browser-openable static report HTML                                                       |
+| `playwrightSnapshotDir`                  | `string` | `undefined`                    | Override the Playwright snapshot directory used for passed-baseline display lookup                     |
+| `playwrightSnapshotPathTemplate`         | `string` | `undefined`                    | Mirror Playwright `snapshotPathTemplate` for passed-baseline display resolution                        |
+| `playwrightToHaveScreenshotPathTemplate` | `string` | `undefined`                    | Mirror Playwright `expect.toHaveScreenshot.pathTemplate` for passed-baseline display; takes precedence |
 
 ## Server CLI Options
 
@@ -77,12 +80,14 @@ Explicit flags override the paths derived from `artifact-dir`.
 | `--screenshot-dir` | `-s`  | `./screenshots` | Screenshot directory path                                                                 |
 | `--report-path`    | `-r`  | `./report.json` | Report JSON file path or directory containing `report.json` and `crvy-rprtr-*.json` files |
 
+The CLI currently exposes only these flags. Approval-routing resolver overrides are available through the programmatic server API, not additional CLI flags.
+
 ## How It Works
 
 1. **During test runs:** The Playwright reporter sends test results to the server via WebSocket in real-time and records the same run for artifact export.
 2. **After tests complete:** A static `crvy-rprtr.html` artifact is written for direct browser viewing, and offline report JSON is also written if the server was unavailable.
 3. **In the browser:** The UI shows all screenshot tests with side-by-side, swap, slide, and blend diff views.
-4. **Approving changes:** Start the UI server and click "Approve" to accept a new screenshot as the baseline. The server copies the actual image to the expected snapshot location.
+4. **Approving changes:** Start the UI server and click "Approve" or "Approve All" to accept a new screenshot as the baseline. Approval uses the same exact Playwright-aware resolver as passed-baseline display, including default layouts, unnamed screenshots, duplicate names, and custom templates when the running server was started with matching resolver options. Those approval-routing options are read from the server startup path, not from reporter options. If the server starts without explicit resolver overrides, approval falls back to the server defaults instead. If Crvy Rprtr cannot determine exactly one target path, it leaves the image unresolved instead of guessing.
 
 ## Offline Mode
 
@@ -93,6 +98,21 @@ When the server isn't running during tests, the reporter automatically falls bac
 - On test completion, a self-contained `crvy-rprtr.html` is written for direct browser review
 - When the server starts, it loads and merges all `crvy-rprtr-*.json` files from the offline report directory
 
+## Passed Screenshot Modes
+
+Crvy Rprtr keeps passed Playwright screenshot assertions visible in two fallback modes when Playwright does not emit a full passing comparison payload:
+
+- `baseline-only`: Crvy Rprtr resolved the exact expected snapshot path and copied that baseline into the screenshot directory, so the UI can show the stored baseline.
+- `declared-only`: the screenshot assertion was detected, but Crvy Rprtr could not resolve one exact snapshot file and therefore keeps the honest text-only fallback.
+
+Exact resolution mirrors Playwright's screenshot naming and template rules for default layouts, unnamed screenshots, and explicitly configured custom templates. For slash-containing named screenshot titles, Crvy Rprtr may check both Playwright-equivalent variants and only uses a baseline when exactly one candidate wins.
+
+Crvy Rprtr does not auto-read Playwright config for snapshot template discovery. If your suite uses a custom snapshot layout, pass the matching `playwrightSnapshotDir`, `playwrightSnapshotPathTemplate`, or `playwrightToHaveScreenshotPathTemplate` reporter options explicitly for passed-baseline display.
+
+Approval routing uses the same resolver, but it reads its resolver settings from the server startup path today. The current user-facing place to pass those overrides is `startServer({...})`, via options such as `configDir`, `playwrightTestDir`, `playwrightSnapshotDir`, `playwrightSnapshotPathTemplate`, and `playwrightToHaveScreenshotPathTemplate`. The CLI does not expose flags for those overrides, so `npx crvy-rprtr` uses the server defaults when they are omitted. For slash-containing named screenshot titles, Crvy Rprtr only updates the baseline when one exact Playwright-equivalent target can be determined.
+
+When the server is running, Crvy Rprtr also refreshes the UI after report JSON or screenshot artifacts change on disk.
+
 ## Programmatic API
 
 ```ts
@@ -113,6 +133,20 @@ await startServer({
 })
 ```
 
+If you need approval routing to follow a custom Playwright snapshot layout, pass the resolver options when starting the server programmatically:
+
+```ts
+await startServer({
+  port: 3000,
+  screenshotDir: './screenshots',
+  reportPath: './artifacts',
+  configDir: process.cwd(),
+  playwrightTestDir: './tests',
+  playwrightSnapshotDir: './tests/__screenshots__',
+  playwrightToHaveScreenshotPathTemplate: '{snapshotDir}/{testFilePath}/{arg}{ext}',
+})
+```
+
 The programmatic server API works in both Node 22+ and Bun.
 
 ## Development

package/dist/chunk-JGS2VWQP.js

@@ -0,0 +1,500 @@
+// src/snapshot-path-resolver.ts
+import { createHash } from "crypto";
+import { basename, dirname, extname, join, parse, relative, resolve } from "path";
+var DEFAULT_SCREENSHOT_TEMPLATE = "{snapshotDir}/{testFileDir}/{testFileName}-snapshots/{arg}{-projectName}{-snapshotSuffix}{ext}";
+var WINDOWS_FILESYSTEM_FRIENDLY_LENGTH = 60;
+function isUnsafeFilePathCharacter(character) {
+  const codePoint = character.codePointAt(0);
+  return codePoint !== void 0 && (codePoint <= 44 || codePoint >= 46 && codePoint <= 47 || codePoint >= 58 && codePoint <= 64 || codePoint >= 91 && codePoint <= 96 || codePoint >= 123 && codePoint <= 127);
+}
+function sanitizeForFilePath(value) {
+  return Array.from(value).reduce(
+    (state, character) => {
+      const unsafeCharacter = isUnsafeFilePathCharacter(character);
+      return unsafeCharacter ? state.previousCharacterWasUnsafe ? state : {
+        value: `${state.value}-`,
+        previousCharacterWasUnsafe: true
+      } : {
+        value: `${state.value}${character}`,
+        previousCharacterWasUnsafe: false
+      };
+    },
+    {
+      value: "",
+      previousCharacterWasUnsafe: false
+    }
+  ).value;
+}
+function trimLongString(value, length = WINDOWS_FILESYSTEM_FRIENDLY_LENGTH) {
+  if (value.length <= length) {
+    return value;
+  }
+  const hash = createHash("sha1").update(value).digest("hex");
+  const middle = `-${hash.slice(0, 5)}-`;
+  const start = Math.floor((length - middle.length) / 2);
+  const end = length - middle.length - start;
+  return value.slice(0, start) + middle + value.slice(-end);
+}
+function sanitizeFilePathBeforeExtension(filePath, extension = extname(filePath)) {
+  const base = filePath.slice(0, filePath.length - extension.length);
+  return sanitizeForFilePath(base) + extension;
+}
+function addSuffixToFilePath(filePath, suffix) {
+  const extension = extname(filePath);
+  return filePath.slice(0, filePath.length - extension.length) + suffix + extension;
+}
+function normalizedSnapshotDir(config) {
+  return resolve(config.configDir, config.snapshotDir);
+}
+function templateValue(template, token, value) {
+  return template.replace(
+    new RegExp(`\\{(.)?${token}\\}`, "g"),
+    (_, prefix) => value === "" ? "" : `${prefix ?? ""}${value}`
+  );
+}
+function applyTemplate(input, nameArgument, extension) {
+  const template = input.config.toHaveScreenshotPathTemplate ?? input.config.snapshotPathTemplate ?? DEFAULT_SCREENSHOT_TEMPLATE;
+  const relativeTestFilePath = relative(input.config.testDir, input.testFile);
+  const parsed = parse(relativeTestFilePath);
+  const tokens = [
+    ["testDir", input.config.testDir],
+    ["snapshotDir", normalizedSnapshotDir(input.config)],
+    ["snapshotSuffix", input.config.snapshotSuffix],
+    ["testFileDir", parsed.dir],
+    ["platform", process.platform],
+    ["projectName", sanitizeForFilePath(input.config.projectName)],
+    ["testName", ""],
+    ["testFileName", parsed.base],
+    ["testFilePath", relativeTestFilePath],
+    ["arg", nameArgument],
+    ["ext", extension]
+  ];
+  const snapshotPath = tokens.reduce(
+    (currentTemplate, [token, value]) => templateValue(currentTemplate, token, value),
+    template
+  );
+  return resolve(input.config.configDir, snapshotPath);
+}
+function removeExtension(filePath, extension = extname(filePath)) {
+  return filePath.slice(0, filePath.length - extension.length);
+}
+function snapshotNameParts(declaredName) {
+  const extension = extname(declaredName) || ".png";
+  return {
+    extension,
+    filePath: extname(declaredName) === "" ? `${declaredName}${extension}` : declaredName
+  };
+}
+function filePathForOccurrence(filePath, occurrenceIndex) {
+  return occurrenceIndex === 1 ? filePath : addSuffixToFilePath(filePath, `-${occurrenceIndex - 1}`);
+}
+function createResolvedBaselineTarget(input, declaration, nameArgument, extension) {
+  return {
+    visualName: declaration.visualName,
+    attachmentBaseName: declaration.visualName,
+    artifactBaseName: sanitizeForFilePath(declaration.visualName),
+    snapshotPath: applyTemplate(input, nameArgument, extension)
+  };
+}
+function resolveStringCallTarget(input, declaration) {
+  const { extension, filePath } = snapshotNameParts(declaration.declaredName);
+  const occurrenceFilePath = filePathForOccurrence(filePath, declaration.occurrenceIndex);
+  const sanitizedNameWithExtension = sanitizeFilePathBeforeExtension(occurrenceFilePath, extension);
+  const nameArgument = removeExtension(sanitizedNameWithExtension, extension);
+  return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
+}
+function resolveArrayCallTarget(input, declaration) {
+  const { extension, filePath } = snapshotNameParts(declaration.declaredName);
+  const occurrenceFilePath = filePathForOccurrence(filePath, declaration.occurrenceIndex);
+  const nameArgument = join(dirname(occurrenceFilePath), basename(occurrenceFilePath, extension));
+  return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
+}
+function resolveNamedTarget(input, declaration) {
+  if (!declaration.declaredName.includes("/")) {
+    return resolveStringCallTarget(input, declaration);
+  }
+  const stringCallTarget = resolveStringCallTarget(input, declaration);
+  const arrayCallTarget = resolveArrayCallTarget(input, declaration);
+  if (stringCallTarget.snapshotPath === arrayCallTarget.snapshotPath) {
+    return stringCallTarget;
+  }
+  if (input.snapshotPathExists === void 0) {
+    return void 0;
+  }
+  const stringCallTargetExists = input.snapshotPathExists(stringCallTarget.snapshotPath);
+  const arrayCallTargetExists = input.snapshotPathExists(arrayCallTarget.snapshotPath);
+  if (stringCallTargetExists === arrayCallTargetExists) {
+    return void 0;
+  }
+  return stringCallTargetExists ? stringCallTarget : arrayCallTarget;
+}
+function reporterTitlesWithoutProjectAndFile(reporterTitlePath) {
+  return reporterTitlePath.slice(3).filter((part) => part !== "");
+}
+function anonymousName(reporterTitlePath, occurrenceIndex) {
+  const rawAnonymousName = `${reporterTitlesWithoutProjectAndFile(reporterTitlePath).join(" ")} ${occurrenceIndex}.png`;
+  return sanitizeFilePathBeforeExtension(trimLongString(rawAnonymousName), ".png");
+}
+function resolveTarget(input, declaration) {
+  switch (declaration.kind) {
+    case "named":
+      return typeof declaration.declaredName === "string" && declaration.declaredName !== "" ? resolveNamedTarget(input, declaration) : void 0;
+    case "unnamed": {
+      const anonymousFileName = anonymousName(input.reporterTitlePath, declaration.occurrenceIndex);
+      const extension = ".png";
+      const nameArgument = join(dirname(anonymousFileName), basename(anonymousFileName, extension));
+      return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
+    }
+  }
+}
+function resolveBaselineTargets(input) {
+  return input.declarations.flatMap((declaration) => {
+    const resolvedTarget = resolveTarget(input, declaration);
+    return resolvedTarget === void 0 ? [] : [resolvedTarget];
+  });
+}
+
+// src/report-utils.ts
+function normalizeScreenshotsBaseUrl(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+function classifyImage(image) {
+  if (image.actual !== void 0 || image.diff !== void 0) {
+    return "comparison";
+  }
+  if (image.expect !== void 0) {
+    return "baseline-only";
+  }
+  return "declared-only";
+}
+function withImageSource(image) {
+  return {
+    ...image,
+    source: classifyImage(image)
+  };
+}
+function getDeclaredVisualNames(visualNames, visualDeclarations) {
+  return visualDeclarations?.map(({ visualName }) => visualName) ?? visualNames;
+}
+function copyVisualDeclarations(visualDeclarations) {
+  return visualDeclarations?.map((visualDeclaration) => ({ ...visualDeclaration }));
+}
+function mergeDeclaredImages(images, visualNames) {
+  const names = /* @__PURE__ */ new Set([...Object.keys(images), ...visualNames]);
+  return Object.fromEntries(
+    Array.from(names, (name) => {
+      const current = images[name] ?? {};
+      return [name, withImageSource(current)];
+    })
+  );
+}
+function attachmentsToImages(attachments, screenshotsBaseUrl = "/screenshots/") {
+  const images = {};
+  const baseUrl = normalizeScreenshotsBaseUrl(screenshotsBaseUrl);
+  for (const attachment of attachments) {
+    if (attachment.contentType !== "image/png") continue;
+    const match = attachment.name.match(/^(.+?)-(actual|expected|diff)(?:\.png)?$/);
+    if (match === null) continue;
+    const baseName = match[1];
+    const role = match[2];
+    if (baseName === null || baseName === void 0 || role === null || role === void 0) continue;
+    images[baseName] ??= {};
+    const url = `${baseUrl}${attachment.path}`;
+    const img = images[baseName];
+    if (img !== null && img !== void 0) {
+      if (role === "actual") img.actual = url;
+      else if (role === "expected") img.expect = url;
+      else if (role === "diff") img.diff = url;
+    }
+  }
+  for (const key of Object.keys(images)) {
+    const img = images[key];
+    if (img?.actual !== void 0 && img?.expect !== void 0 && img?.diff === void 0) {
+      delete img.expect;
+    }
+  }
+  return mergeDeclaredImages(images, []);
+}
+function mapStatus(status) {
+  switch (status) {
+    case "passed":
+      return "success";
+    case "failed":
+      return "failed";
+    case "skipped":
+      return "pending";
+    default:
+      return "unknown";
+  }
+}
+
+// src/report-state.ts
+function isCurrentArtifact(image) {
+  return image?.actual !== void 0 || image?.expect !== void 0 || image?.diff !== void 0;
+}
+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) {
+  return Object.values(images).some((img) => img !== null && img !== void 0 && isReusablePassingImage(img));
+}
+function preservePreviousPassingImages(test, status, images) {
+  if (status !== "passed") {
+    return images;
+  }
+  const previousImages = test.results?.[0]?.images ?? {};
+  if (!hasReusablePassingImages(previousImages)) {
+    return images;
+  }
+  return Object.entries(previousImages).reduce((currentImages, [name, previousImage]) => {
+    if (!Object.hasOwn(currentImages, name) || previousImage === void 0 || !isReusablePassingImage(previousImage) || isCurrentArtifact(currentImages[name])) {
+      return currentImages;
+    }
+    return {
+      ...currentImages,
+      [name]: {
+        ...previousImage,
+        source: previousImage.source ?? classifyImage(previousImage)
+      }
+    };
+  }, images);
+}
+function countDiffImages(images) {
+  return Object.values(images).filter((img) => img?.diff !== null && img?.diff !== void 0).length;
+}
+function createMutableReportState(screenshotDir = "./screenshots") {
+  return {
+    reportData: {
+      isRunning: false,
+      tests: {},
+      browsers: ["chromium"],
+      isUpdateMode: false,
+      screenshotDir
+    },
+    currentRunIds: /* @__PURE__ */ new Set()
+  };
+}
+function applyTestBeginEvent(state, data) {
+  const { id, title, titlePath, browser, location } = data;
+  state.currentRunIds.add(id);
+  state.reportData.tests[id] ??= {
+    id,
+    titlePath: titlePath ?? [],
+    browser: browser ?? "",
+    title: title ?? "",
+    location,
+    status: "running"
+  };
+  return state.reportData.tests[id];
+}
+function applyTestEndEvent(state, data, options = {}) {
+  const test = state.reportData.tests[data.id];
+  if (test === void 0) {
+    return null;
+  }
+  test.status = mapStatus(data.status);
+  const resultStatus = data.status === "passed" ? "success" : data.status === "failed" ? "failed" : "pending";
+  const visualDeclarations = copyVisualDeclarations(data.visualDeclarations);
+  const images = preservePreviousPassingImages(
+    test,
+    data.status,
+    mergeDeclaredImages(
+      attachmentsToImages(data.attachments, options.screenshotsBaseUrl),
+      getDeclaredVisualNames(data.visualNames, visualDeclarations)
+    )
+  );
+  const diffCount = countDiffImages(images);
+  const hasDiffs = diffCount > 0;
+  if (hasDiffs) {
+    test.approved = null;
+  }
+  test.results = [
+    {
+      status: resultStatus,
+      retries: 0,
+      images,
+      visualDeclarations,
+      error: data.error,
+      duration: data.duration
+    }
+  ];
+  return {
+    test,
+    diffCount
+  };
+}
+function finalizeRunEvent(state) {
+  state.reportData.isRunning = false;
+  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 {
+    passed: runTests.filter((test) => test.status === "success").length,
+    failed: runTests.filter((test) => test.status === "failed").length,
+    pending: runTests.filter((test) => test.status === "pending").length
+  };
+}
+
+// src/schemas.ts
+import { z } from "zod";
+var LocationSchema = z.object({
+  file: z.string(),
+  line: z.number()
+});
+var VisualSourceSchema = z.enum(["comparison", "baseline-only", "declared-only"]);
+var ImagesSchema = z.object({
+  actual: z.string().optional(),
+  expect: z.string().optional(),
+  diff: z.string().optional(),
+  error: z.string().optional(),
+  source: VisualSourceSchema.optional()
+});
+var ScreenshotDeclarationSchema = z.discriminatedUnion("kind", [
+  z.object({
+    visualName: z.string(),
+    kind: z.literal("named"),
+    declaredName: z.string(),
+    snapshotBaseName: z.string(),
+    occurrenceIndex: z.number()
+  }),
+  z.object({
+    visualName: z.string(),
+    kind: z.literal("unnamed"),
+    occurrenceIndex: z.number()
+  })
+]);
+var AttachmentSchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  contentType: z.string()
+});
+var TestStatusSchema = z.enum(["unknown", "pending", "running", "failed", "approved", "success", "retrying"]);
+var TestResultStatusSchema = z.enum(["failed", "success", "pending"]);
+var TestResultSchema = z.object({
+  status: TestResultStatusSchema,
+  retries: z.number(),
+  images: z.record(z.string(), ImagesSchema).optional(),
+  visualDeclarations: z.array(ScreenshotDeclarationSchema).optional(),
+  error: z.string().optional(),
+  duration: z.number().optional()
+});
+var TestDataSchema = z.object({
+  id: z.string(),
+  titlePath: z.array(z.string()),
+  browser: z.string(),
+  title: z.string(),
+  skip: z.union([z.boolean(), z.string()]).optional(),
+  retries: z.number().optional(),
+  status: TestStatusSchema.optional(),
+  results: z.array(TestResultSchema).optional(),
+  approved: z.record(z.string(), z.number()).nullable().optional(),
+  attachments: z.array(AttachmentSchema).optional(),
+  location: LocationSchema.optional()
+});
+var CrvyRprtrTestSchema = TestDataSchema.extend({
+  checked: z.boolean()
+});
+var CrvyRprtrSuiteSchema = z.lazy(
+  () => z.object({
+    path: z.array(z.string()),
+    skip: z.boolean(),
+    status: TestStatusSchema.optional(),
+    opened: z.boolean(),
+    checked: z.boolean(),
+    indeterminate: z.boolean(),
+    children: z.record(z.string(), z.union([CrvyRprtrSuiteSchema, CrvyRprtrTestSchema])).optional()
+  })
+);
+var WebSocketMessageSchema = z.object({
+  type: z.enum(["test-begin", "test-end", "run-end", "approve", "sync"]),
+  data: z.unknown()
+});
+var TestBeginDataSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  titlePath: z.array(z.string()),
+  browser: z.string(),
+  location: LocationSchema
+});
+var TestEndDataSchema = z.object({
+  id: z.string(),
+  status: z.enum(["passed", "failed", "skipped"]),
+  attachments: z.array(AttachmentSchema),
+  visualNames: z.array(z.string()).default([]),
+  visualDeclarations: z.preprocess(
+    (value) => value === null ? void 0 : value,
+    z.array(ScreenshotDeclarationSchema).optional()
+  ),
+  error: z.string().optional(),
+  duration: z.number().optional()
+});
+var ReportDataSchema = z.object({
+  isRunning: z.boolean(),
+  tests: z.record(z.string(), TestDataSchema),
+  browsers: z.array(z.string()),
+  isUpdateMode: z.boolean(),
+  screenshotDir: z.string()
+});
+var LoadedReportDataSchema = z.object({
+  tests: z.record(z.string(), TestDataSchema).optional(),
+  isUpdateMode: z.boolean().optional()
+});
+var OfflineEventSchema = z.object({
+  type: z.enum(["test-begin", "test-end", "run-end"]),
+  data: z.unknown(),
+  timestamp: z.number(),
+  workerIndex: z.number()
+});
+var OfflineReportSchema = z.object({
+  version: z.number(),
+  generatedAt: z.string(),
+  workers: z.number(),
+  events: z.array(OfflineEventSchema)
+});
+var ApproveRequestBodySchema = z.object({
+  id: z.string(),
+  retry: z.number(),
+  image: z.string()
+});
+var ReportApiResponseSchema = z.object({
+  tests: z.record(z.string(), TestDataSchema),
+  isUpdateMode: z.boolean().optional()
+});
+var ClientBootstrapDataSchema = z.object({
+  report: ReportApiResponseSchema.extend({
+    isUpdateMode: z.boolean()
+  }),
+  liveUpdates: z.boolean(),
+  approvalEnabled: z.boolean(),
+  approvalMessage: z.string().optional()
+});
+var ImagesViewModeSchema = z.enum(["side-by-side", "swap", "slide", "blend"]);
+function safeParse(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return result.data;
+  }
+  return null;
+}
+
+export {
+  createMutableReportState,
+  applyTestBeginEvent,
+  applyTestEndEvent,
+  finalizeRunEvent,
+  WebSocketMessageSchema,
+  TestBeginDataSchema,
+  TestEndDataSchema,
+  LoadedReportDataSchema,
+  OfflineReportSchema,
+  ApproveRequestBodySchema,
+  ClientBootstrapDataSchema,
+  safeParse,
+  resolveBaselineTargets
+};