Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

54.6 KB
Raw Blame
import { describe, expect, test, vi } from "vitest";
import type { ProjectSessionScreenshotInput } from "./mcp";
import {
  __testing__,
  augmentAuditWithRenderedChecks,
  getRenderedAuditOverallTimeout,
  getRenderedAuditViewports,
  getRenderedContrastIssues,
  getRenderedGeometryIssues,
  getRenderedImageIssues,
  getRenderedResourceIssues,
} from "./mcp-rendered-audit";

const { addCrossBreakpointGeometryIssues, mergeRenderedAudit } = __testing__;
const previewUrl = "http://127.0.0.1:5177";
const createStartPreview = () => vi.fn(async () => ({ url: previewUrl }));

const layout = {
  documentType: "text/html",
  viewportWidth: 375,
  viewportHeight: 812,
  contentWidth: 375,
  contentHeight: 1600,
  horizontalOverflow: false,
  images: [],
  resources: [],
  contrasts: [],
};

const getNavigation = (path: string) => ({
  requestedUrl: `http://127.0.0.1:5177${path}`,
  finalUrl: `http://127.0.0.1:5177${path}`,
  status: 200,
  statusText: "OK",
  mimeType: "text/html",
  redirects: [],
  documentReadyState: "complete",
  generatedSiteRootPresent: true,
  layoutStable: true,
});

describe("rendered audit evidence", () => {
  test("reports only measured contrast ratios below their exact threshold", () => {
    expect(
      getRenderedContrastIssues({
        ...layout,
        contrasts: [
          {
            instanceId: "muted-copy",
            tagName: "p",
            foreground: "rgb(120, 120, 120)",
            background: "rgb(255, 255, 255)",
            ratio: 4.2,
            requiredRatio: 4.5,
            fontSize: 16,
            fontWeight: 400,
          },
          {
            instanceId: "heading",
            tagName: "h1",
            foreground: "rgb(0, 0, 0)",
            background: "rgb(255, 255, 255)",
            ratio: 21,
            requiredRatio: 3,
            fontSize: 32,
            fontWeight: 700,
          },
        ],
      })
    ).toEqual([
      {
        kind: "low-text-contrast",
        confidence: "exact",
        instanceId: "muted-copy",
        tagName: "p",
        foreground: "rgb(120, 120, 120)",
        background: "rgb(255, 255, 255)",
        ratio: 4.2,
        requiredRatio: 4.5,
        fontSize: 16,
        fontWeight: 400,
      },
    ]);
  });

  test("reports exact clipping and advisory overlap from bounded geometry", () => {
    expect(
      getRenderedGeometryIssues({
        ...layout,
        elementGeometry: {
          total: 2,
          sampled: 2,
          truncated: false,
          elements: [
            {
              instanceId: "card",
              tagName: "article",
              x: 0,
              y: 0,
              width: 300,
              height: 200,
              visible: true,
              clippedX: true,
              clippedY: false,
              overlapsWith: ["badge"],
            },
            {
              instanceId: "badge",
              tagName: "div",
              x: 250,
              y: 0,
              width: 100,
              height: 40,
              visible: true,
              clippedX: false,
              clippedY: false,
              overlapsWith: ["card"],
            },
          ],
        },
      })
    ).toEqual([
      {
        kind: "clipped-content",
        confidence: "exact",
        instanceId: "card",
        message: "Rendered content exceeds a clipping boundary.",
        evidence: { clippedX: true, clippedY: false },
      },
      {
        kind: "overlapping-elements",
        confidence: "advisory",
        instanceId: "badge",
        relatedInstanceId: "card",
        message:
          "Rendered element bounds overlap; inspect the screenshot to determine whether this is intentional.",
        evidence: {},
      },
    ]);
  });

  test("reports persistent hidden content and advisory breakpoint changes once", () => {
    const makeCheck = (
      width: number,
      elements: Array<{
        instanceId: string;
        visible: boolean;
        x: number;
        width: number;
        hiddenReason?: "display";
      }>
    ) => ({
      pageId: "home",
      pagePath: "/",
      viewport: { width, height: 800 },
      screenshotPath: `/tmp/${width}.webp`,
      layout: {
        ...layout,
        viewportWidth: width,
        elementGeometry: {
          total: elements.length,
          sampled: elements.length,
          truncated: false,
          elements: elements.map((element) => ({
            ...element,
            tagName: "div",
            y: 0,
            height: 100,
            clippedX: false,
            clippedY: false,
            overlapsWith: [],
          })),
        },
      },
      issues: [],
      geometryIssues: [],
      imageIssues: [],
      resourceIssues: [],
    });
    const [mobile, desktop] = addCrossBreakpointGeometryIssues([
      makeCheck(375, [
        {
          instanceId: "always-hidden",
          visible: false,
          hiddenReason: "display",
          x: 0,
          width: 0,
        },
        {
          instanceId: "responsive-nav",
          visible: false,
          hiddenReason: "display",
          x: 0,
          width: 0,
        },
      ]),
      makeCheck(1440, [
        {
          instanceId: "always-hidden",
          visible: false,
          hiddenReason: "display",
          x: 0,
          width: 0,
        },
        {
          instanceId: "responsive-nav",
          visible: true,
          x: 900,
          width: 400,
        },
      ]),
    ] as never);

    expect(mobile?.geometryIssues).toMatchObject([
      {
        kind: "hidden-content",
        confidence: "advisory",
        instanceId: "always-hidden",
      },
    ]);
    expect(desktop?.geometryIssues).toMatchObject([
      {
        kind: "cross-breakpoint-layout-change",
        confidence: "advisory",
        instanceId: "responsive-nav",
        evidence: {
          sourceViewportWidth: 375,
          targetViewportWidth: 1440,
          sourceVisible: false,
          targetVisible: true,
        },
      },
    ]);
    expect(desktop?.issues).toEqual(["cross-breakpoint-layout-change"]);
  });

  test("budgets five minutes for each confirmed capture batch", () => {
    expect(getRenderedAuditOverallTimeout(1)).toBe(5 * 60_000);
    expect(getRenderedAuditOverallTimeout(120)).toBe(5 * 60_000);
    expect(getRenderedAuditOverallTimeout(121)).toBe(10 * 60_000);
    expect(getRenderedAuditOverallTimeout(396)).toBe(20 * 60_000);
    expect(getRenderedAuditOverallTimeout(396, 1234)).toBe(1234);
  });

  test("matches the public root path to the stored empty home path", async () => {
    const storeRenderedAuditArtifacts = vi.fn(async () => "/manifest.json");
    const captureScreenshot = vi.fn(async (input) => ({
      output: `/tmp/home-${input.viewport.width}.png`,
      browserPath: "/usr/bin/chromium",
      browser: "chromium" as const,
      viewport: input.viewport,
      fullPage: true,
      elapsedMs: 10,
      warnings: [],
      navigation: getNavigation("/"),
      layout,
    }));
    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["accessibility"],
          manualCheckCount: 0,
          verbose: true,
        },
      } as never,
      input: { rendered: true, pagePath: "/", verbose: true },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? { pages: [{ id: "home", path: "" }] }
              : { breakpoints: [] },
        }) as never,
      startPreview: vi.fn(async () => ({
        url: previewUrl,
        generatedBuildMetrics: {
          version: 1,
          fileCount: 3,
          bytes: 4_000,
          gzipBytes: 1_200,
          client: { fileCount: 2, bytes: 3_000, gzipBytes: 900 },
          server: { fileCount: 1, bytes: 1_000, gzipBytes: 300 },
          largestFiles: [
            {
              path: "client/assets/index.js",
              bytes: 2_000,
              gzipBytes: 600,
              kind: "script",
            },
          ],
        },
      })),
      stopPreview: vi.fn(),
      captureScreenshot,
      storeRenderedAuditArtifacts,
    });

    expect(captureScreenshot).toHaveBeenCalledOnce();
    expect(result.result).toMatchObject({
      renderedPlan: {
        pages: [{ pageId: "home", pagePath: "/" }],
        captureCount: 1,
      },
      renderedFailureCount: 0,
      generatedBuildSummary: {
        version: 1,
        fileCount: 3,
        bytes: 4_000,
        gzipBytes: 1_200,
      },
      generatedBuildMetrics: {
        largestFiles: [
          expect.objectContaining({ path: "client/assets/index.js" }),
        ],
      },
    });
    expect(storeRenderedAuditArtifacts).toHaveBeenCalledWith(
      expect.objectContaining({
        performance: expect.objectContaining({ captureCount: 1 }),
      })
    );
  });

  test("loads pages and breakpoints concurrently", async () => {
    let activeReads = 0;
    let maximumActiveReads = 0;
    const executeRead = vi.fn(async (command: string) => {
      activeReads += 1;
      maximumActiveReads = Math.max(maximumActiveReads, activeReads);
      await new Promise((resolve) => setTimeout(resolve, 10));
      activeReads -= 1;
      return {
        result:
          command === "list-pages"
            ? { pages: [{ id: "home", path: "" }] }
            : { breakpoints: [] },
      } as never;
    });

    await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["accessibility"],
          manualCheckCount: 0,
          verbose: true,
        },
      } as never,
      input: { rendered: true },
      executeRead,
      startPreview: createStartPreview(),
      stopPreview: vi.fn(),
      captureScreenshot: vi.fn(async (input) => ({
        output: "/tmp/home.png",
        browserPath: "/usr/bin/chromium",
        browser: "chromium" as const,
        viewport: input.viewport,
        fullPage: true,
        elapsedMs: 10,
        warnings: [],
        navigation: getNavigation("/"),
        layout,
      })),
    });

    expect(maximumActiveReads).toBe(2);
  });

  test("reports sparse structured capture progress for larger audits", async () => {
    const progress: string[] = [];
    const pages = Array.from({ length: 12 }, (_, index) => ({
      id: `page-${index}`,
      path: `/page-${index}`,
    }));

    await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: { scopes: ["accessibility"], manualCheckCount: 0 },
      } as never,
      input: { rendered: true, verbose: true },
      executeRead: async (command) =>
        ({
          result: command === "list-pages" ? { pages } : { breakpoints: [] },
        }) as never,
      startPreview: createStartPreview(),
      stopPreview: vi.fn(),
      captureScreenshot: vi.fn(async (input) => ({
        output: `/tmp${input.path}.webp`,
        browserPath: "/usr/bin/chromium",
        browser: "chromium" as const,
        viewport: input.viewport,
        fullPage: true,
        elapsedMs: 10,
        warnings: [],
        navigation: getNavigation(input.path ?? "/"),
        layout,
      })),
      reportProgress: (message) => progress.push(message),
    });

    const structured = progress.filter((message) =>
      message.startsWith("tool audit progress ")
    );
    expect(structured.length).toBeLessThanOrEqual(12);
    expect(
      structured.map((message) =>
        JSON.parse(message.slice("tool audit progress ".length))
      )
    ).toEqual(
      expect.arrayContaining([
        { phase: "planned", pages: 12, viewports: 1, captures: 12 },
        { phase: "capture", completed: 12, total: 12 },
      ])
    );
    expect(progress.some((message) => message.includes("capturing /"))).toBe(
      false
    );
  });

  test("captures each page once and resizes through its viewport plan", async () => {
    const captureScreenshot = vi.fn();
    const capturePageScreenshots = vi.fn(
      async (inputs: readonly ProjectSessionScreenshotInput[]) =>
        inputs.map((input) => ({
          output: `/tmp/page-${input.viewport.width}.png`,
          browserPath: "/usr/bin/chromium",
          browser: "chromium" as const,
          viewport: input.viewport,
          fullPage: true,
          elapsedMs: 10,
          warnings: [],
          timings: {
            wallMs: 25,
            targetSetupMs: 5,
            navigationMs: 20,
            readinessMs: 4,
            imageInspectionMs: 3,
            resourceInspectionMs: 1,
            screenshotMs: 8,
            artifactWriteMs: 2,
            targetCleanupMs: input.viewport.width === 1440 ? 1 : 0,
          },
          navigation: getNavigation("/page"),
          layout: {
            ...layout,
            viewportWidth: input.viewport.width,
            viewportHeight: input.viewport.height,
          },
        }))
    );
    const storeRenderedAuditArtifacts = vi.fn(async () => "/manifest.json");
    const startPreview = createStartPreview();

    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["performance"],
          manualCheckCount: 0,
          verbose: true,
        },
      } as never,
      input: { rendered: true, pagePath: "/page", verbose: true },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? { pages: [{ id: "page", path: "/page" }] }
              : { breakpoints: [] },
        }) as never,
      startPreview,
      stopPreview: vi.fn(),
      captureScreenshot,
      capturePageScreenshots,
      storeRenderedAuditArtifacts,
    });

    expect(startPreview).toHaveBeenCalledWith(
      expect.objectContaining({
        port: 0,
        source: "session",
        mode: "production",
      }),
      expect.any(Object)
    );
    expect(capturePageScreenshots).toHaveBeenCalledOnce();
    expect(capturePageScreenshots).toHaveBeenCalledWith([
      expect.objectContaining({
        path: "/page",
        mode: "production",
        output: ".webstudio/audits/screenshots/page-1440x900.webp",
        viewport: { width: 1440, height: 900 },
        waitForTimeout: 0,
      }),
    ]);
    expect(captureScreenshot).not.toHaveBeenCalled();
    expect(result.result).toMatchObject({
      renderedCheckCount: 1,
      renderedFailureCount: 0,
    });
    expect(storeRenderedAuditArtifacts).toHaveBeenCalledWith(
      expect.objectContaining({
        screenshot: {
          format: "webp",
          quality: 82,
          scale: 0.5,
        },
        performance: {
          captureCount: 1,
          previewStartMs: expect.any(Number),
          captureWallMs: expect.any(Number),
          previewStopMs: expect.any(Number),
          targetSetupMs: 5,
          navigationMs: 20,
          readinessMs: 4,
          imageInspectionMs: 3,
          resourceInspectionMs: 1,
          screenshotMs: 8,
          artifactWriteMs: 2,
          targetCleanupMs: 1,
        },
      })
    );
  });

  test("falls back to isolated captures when resized page capture fails", async () => {
    const capturePageScreenshots = vi.fn(async () => {
      throw new Error("responsive script failed during resize");
    });
    const captureScreenshot = vi.fn(async (input) => ({
      output: `/tmp/fallback-${input.viewport.width}.png`,
      browserPath: "/usr/bin/chromium",
      browser: "chromium" as const,
      viewport: input.viewport,
      fullPage: true,
      elapsedMs: 10,
      warnings: [],
      navigation: getNavigation("/page"),
      layout,
    }));

    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["accessibility"],
          manualCheckCount: 0,
          verbose: true,
        },
      } as never,
      input: { rendered: true, pagePath: "/page", verbose: true },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? { pages: [{ id: "page", path: "/page" }] }
              : { breakpoints: [] },
        }) as never,
      startPreview: createStartPreview(),
      stopPreview: vi.fn(),
      captureScreenshot,
      capturePageScreenshots,
    });

    expect(capturePageScreenshots).toHaveBeenCalledOnce();
    expect(captureScreenshot).toHaveBeenCalledOnce();
    expect(result.result).toMatchObject({
      renderedCheckCount: 1,
      renderedFailureCount: 0,
    });
  });

  test("isolates a failed page without falling back healthy concurrent pages", async () => {
    const pages = Array.from({ length: 7 }, (_, index) => ({
      id: `page-${index}`,
      path: index === 0 ? "/bad" : `/page-${index}`,
    }));
    const capturePageScreenshots = vi.fn(
      async (inputs: readonly ProjectSessionScreenshotInput[]) => {
        if (inputs.some((input) => input.path === "/bad")) {
          throw new Error("bad page did not become ready");
        }
        return inputs.map((input) => {
          const path = input.path ?? "/";
          return {
            output: `/tmp/${path.slice(1)}-${input.viewport.width}.webp`,
            browserPath: "/usr/bin/chromium",
            browser: "chromium" as const,
            viewport: input.viewport,
            fullPage: true,
            elapsedMs: 1,
            warnings: [],
            navigation: getNavigation(path),
            layout,
          };
        });
      }
    );
    const captureScreenshot = vi.fn(async (input) => ({
      output: `/tmp/bad-${input.viewport.width}.webp`,
      browserPath: "/usr/bin/chromium",
      browser: "chromium" as const,
      viewport: input.viewport,
      fullPage: true,
      elapsedMs: 1,
      warnings: [],
      navigation: getNavigation("/bad"),
      layout,
    }));

    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["accessibility"],
          manualCheckCount: 0,
          verbose: true,
        },
      } as never,
      input: { rendered: true, verbose: true },
      executeRead: async (command) =>
        ({
          result: command === "list-pages" ? { pages } : { breakpoints: [] },
        }) as never,
      startPreview: createStartPreview(),
      stopPreview: vi.fn(),
      captureScreenshot,
      capturePageScreenshots,
    });

    expect(capturePageScreenshots).toHaveBeenCalledTimes(7);
    expect(captureScreenshot).toHaveBeenCalledOnce();
    expect(captureScreenshot.mock.calls.map(([input]) => input.path)).toEqual([
      "/bad",
    ]);
    expect(result.result).toMatchObject({
      renderedCheckCount: 7,
      renderedFailureCount: 0,
    });
  });

  test("captures a common device viewport in each breakpoint range", () => {
    expect(
      getRenderedAuditViewports({
        breakpoints: [
          { label: "Base" },
          { label: "Tablet", maxWidth: 991 },
          { label: "Mobile landscape", maxWidth: 767 },
          { label: "Mobile portrait", maxWidth: 479 },
          { label: "Large", minWidth: 1280 },
          { label: "Wide", minWidth: 1440 },
        ],
      })
    ).toEqual([
      {
        width: 390,
        height: 844,
        purposes: ["Mobile portrait: representative"],
      },
      {
        width: 667,
        height: 375,
        purposes: ["Mobile landscape: representative"],
      },
      {
        width: 820,
        height: 1180,
        purposes: ["Tablet: representative"],
      },
      {
        width: 1024,
        height: 768,
        purposes: ["base breakpoint: representative"],
      },
      {
        width: 1366,
        height: 768,
        purposes: ["Large: representative"],
      },
      {
        width: 1440,
        height: 900,
        purposes: ["Wide: representative"],
      },
    ]);
  });

  test("uses a desktop viewport when the project only has a base breakpoint", () => {
    expect(
      getRenderedAuditViewports({
        breakpoints: [{ id: "base", label: "Base" }],
      })
    ).toEqual([
      {
        width: 1440,
        height: 900,
        purposes: ["base breakpoint: desktop"],
      },
    ]);
  });

  test("does not assign one capture failure to unrelated captures", () => {
    const result = mergeRenderedAudit({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["accessibility"],
          manualCheckCount: 0,
          verbose: true,
        },
      } as never,
      input: { rendered: true, verbose: true },
      checks: [],
      failures: [
        {
          code: "RENDERED_AUDIT_SCREENSHOT_FAILED",
          phase: "capture",
          retryable: true,
          remediation: "Retry this capture.",
          pageId: "one",
          pagePath: "/one",
          viewport: { width: 1440, height: 900 },
          message: "Capture failed.",
        },
      ],
      plan: {
        version: 1,
        pages: [
          { pageId: "one", pagePath: "/one" },
          { pageId: "two", pagePath: "/two" },
        ],
        excludedPages: [],
        viewports: [
          {
            width: 1440,
            height: 900,
            purposes: ["base breakpoint: desktop"],
          },
        ],
        checks: ["horizontal-overflow", "low-text-contrast"],
        captureCount: 2,
      },
    });

    expect(result.result).toMatchObject({
      renderedCaptureStatuses: [
        {
          pageId: "one",
          status: "failed",
          failureCode: "RENDERED_AUDIT_SCREENSHOT_FAILED",
        },
        { pageId: "two", status: "skipped" },
      ],
    });
    expect(
      (result.result as { renderedCaptureStatuses: Array<unknown> })
        .renderedCaptureStatuses[1]
    ).not.toHaveProperty("failureCode");
  });

  test("does not hide real failures behind a confirmation state", () => {
    const result = mergeRenderedAudit({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: { scopes: ["performance"], manualCheckCount: 0 },
      } as never,
      input: { rendered: true },
      checks: [],
      failures: [
        {
          code: "RENDERED_AUDIT_CONFIRMATION_REQUIRED",
          phase: "planning",
          retryable: false,
          remediation: "Confirm the planned run.",
          message: "Confirmation required.",
        },
        {
          code: "RENDERED_AUDIT_SCREENSHOT_FAILED",
          phase: "capture",
          retryable: true,
          remediation: "Retry the capture.",
          message: "Capture failed.",
        },
      ],
    });

    expect(result.result).toMatchObject({ renderedState: "failed" });
  });

  test("summarizes rendered issue kinds in compact results", () => {
    const result = mergeRenderedAudit({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["performance"],
          manualCheckCount: 0,
          verbose: false,
        },
      } as never,
      input: { rendered: true },
      checks: [
        {
          pageId: "home",
          pagePath: "/",
          viewport: { width: 390, height: 844 },
          issues: ["oversized-image", "oversized-image", "broken-image"],
        },
        {
          pageId: "home",
          pagePath: "/",
          viewport: { width: 1440, height: 900 },
          issues: ["oversized-image"],
        },
      ] as never,
      failures: [],
    });

    expect(result.result).toMatchObject({
      renderedIssueCount: 4,
      renderedIssueSummaries: [
        {
          kind: "oversized-image",
          confidence: "advisory",
          count: 3,
          captureCount: 2,
          pagePaths: ["/"],
        },
        {
          kind: "broken-image",
          confidence: "exact",
          count: 1,
          captureCount: 1,
          pagePaths: ["/"],
        },
      ],
    });
  });

  test("classifies broken, eager below-fold, and oversized images once", () => {
    expect(
      getRenderedImageIssues({
        ...layout,
        images: [
          {
            loading: "eager",
            complete: true,
            naturalWidth: 0,
            naturalHeight: 0,
            renderedWidth: 100,
            renderedHeight: 50,
            top: 900,
          },
          {
            loading: "eager",
            complete: true,
            naturalWidth: 100,
            naturalHeight: 100,
            renderedWidth: 100,
            renderedHeight: 100,
            top: 900,
          },
          {
            loading: "lazy",
            complete: true,
            naturalWidth: 1000,
            naturalHeight: 800,
            renderedWidth: 200,
            renderedHeight: 150,
            top: 0,
          },
        ],
      }).map(({ kind }) => kind)
    ).toEqual(["broken-image", "eager-below-fold-image", "oversized-image"]);
  });

  test("uses the selected response bitmap dimensions for oversized images", () => {
    const issues = getRenderedImageIssues({
      ...layout,
      images: [
        {
          loading: "lazy",
          complete: true,
          naturalWidth: 2000,
          naturalHeight: 1200,
          selectedSourceWidth: 400,
          selectedSourceHeight: 240,
          renderedWidth: 300,
          renderedHeight: 180,
          top: 0,
        },
        {
          loading: "lazy",
          complete: true,
          naturalWidth: 300,
          naturalHeight: 180,
          selectedSourceWidth: 1600,
          selectedSourceHeight: 960,
          renderedWidth: 300,
          renderedHeight: 180,
          top: 0,
        },
      ],
    });

    expect(issues).toHaveLength(1);
    expect(issues[0]).toMatchObject({
      kind: "oversized-image",
      selectedSourceWidth: 1600,
      selectedSourceHeight: 960,
    });
  });

  test("reports blocking resources and legacy font formats independently", () => {
    expect(
      getRenderedResourceIssues({
        ...layout,
        resources: [
          {
            pathname: "/fonts/brand.woff",
            initiatorType: "link",
            transferSize: 10,
            encodedBodySize: 8,
            decodedBodySize: 12,
            duration: 5,
            renderBlockingStatus: "blocking",
          },
        ],
      }).map(({ kind }) => kind)
    ).toEqual(["render-blocking-resource", "legacy-font-format"]);
  });

  test("does not report vector sizing or an eager source already used above the fold", () => {
    expect(
      getRenderedImageIssues({
        ...layout,
        images: [
          {
            sourcePathname: "/assets/mark.svg",
            loading: "eager",
            complete: true,
            naturalWidth: 280,
            naturalHeight: 280,
            renderedWidth: 30,
            renderedHeight: 30,
            top: 10,
          },
          {
            sourcePathname: "/assets/mark.svg",
            loading: "eager",
            complete: true,
            naturalWidth: 280,
            naturalHeight: 280,
            renderedWidth: 30,
            renderedHeight: 30,
            top: 900,
          },
        ],
      })
    ).toEqual([]);
  });

  test("does not report the generated application stylesheet", () => {
    expect(
      getRenderedResourceIssues({
        ...layout,
        resources: [
          {
            pathname: "/assets/index-DIEIbGZp.css",
            initiatorType: "link",
            transferSize: 10,
            encodedBodySize: 8,
            decodedBodySize: 12,
            duration: 5,
            renderBlockingStatus: "blocking",
          },
        ],
      })
    ).toEqual([]);
  });

  test("classifies an HTTP error capture as failed rendered evidence", async () => {
    const storeRenderedAuditArtifacts = vi.fn(async () => "/manifest.json");
    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["performance"],
          manualCheckCount: 0,
          verbose: true,
        },
      } as never,
      input: { rendered: true, pagePath: "/missing", verbose: true },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? { pages: [{ id: "missing", path: "/missing" }] }
              : { breakpoints: [] },
        }) as never,
      startPreview: createStartPreview(),
      stopPreview: vi.fn(),
      captureScreenshot: vi.fn(async () => ({
        output: "/tmp/missing.png",
        browserPath: "/usr/bin/chromium",
        browser: "chromium" as const,
        viewport: { width: 375, height: 812 },
        fullPage: true,
        elapsedMs: 10,
        warnings: [],
        navigation: {
          requestedUrl: "http://127.0.0.1:5177/missing",
          finalUrl: "http://127.0.0.1:5177/missing",
          status: 404,
          statusText: "Not Found",
          mimeType: "text/html",
          redirects: [],
          documentReadyState: "complete",
          generatedSiteRootPresent: true,
          layoutStable: true,
        },
        layout,
      })),
      storeRenderedAuditArtifacts,
    });

    expect(result.result).toMatchObject({
      renderedState: "failed",
      renderedCheckCount: 0,
      renderedFailureCount: 1,
      renderedCaptureSummary: {
        planned: 1,
        passed: 0,
        issues: 0,
        skipped: 0,
        failed: 1,
      },
      renderedCaptureStatuses: [
        expect.objectContaining({
          pagePath: "/missing",
          status: "failed",
          screenshotPath: "/tmp/missing.png",
          failureCode: "RENDERED_AUDIT_HTTP_ERROR",
        }),
      ],
      renderedFailures: [
        expect.objectContaining({
          code: "RENDERED_AUDIT_HTTP_ERROR",
          pagePath: "/missing",
          message: expect.stringContaining("HTTP 404"),
        }),
      ],
      renderedArtifactManifest: {
        version: 1,
        path: "/manifest.json",
        screenshotCount: 1,
      },
    });
    expect(storeRenderedAuditArtifacts).toHaveBeenCalledWith(
      expect.objectContaining({
        failures: [
          expect.objectContaining({ screenshotPath: "/tmp/missing.png" }),
        ],
      })
    );
  });

  test("accepts an intentional generated redirect", async () => {
    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["accessibility"],
          manualCheckCount: 0,
          verbose: true,
        },
      } as never,
      input: { rendered: true, pagePath: "/old", verbose: true },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? { pages: [{ id: "old", path: "/old" }] }
              : { breakpoints: [] },
        }) as never,
      startPreview: createStartPreview(),
      stopPreview: vi.fn(),
      captureScreenshot: vi.fn(async (input) => ({
        output: `/tmp/redirect-${input.viewport.width}.png`,
        browserPath: "/usr/bin/chromium",
        browser: "chromium" as const,
        viewport: input.viewport,
        fullPage: true,
        elapsedMs: 10,
        warnings: [],
        navigation: {
          ...getNavigation("/new"),
          requestedUrl: "http://127.0.0.1:5177/old",
          redirects: ["http://127.0.0.1:5177/old"],
        },
        layout,
      })),
    });

    expect(result.result).toMatchObject({
      renderedState: "complete",
      renderedCheckCount: 1,
      renderedFailureCount: 0,
      renderedCaptureSummary: {
        planned: 1,
        passed: 1,
        issues: 0,
        skipped: 0,
        failed: 0,
      },
    });
  });

  test("returns partial evidence when one capture succeeds and one fails", async () => {
    const stopPreview = vi.fn();
    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["performance"],
          manualCheckCount: 0,
          verbose: true,
        },
      } as never,
      input: { rendered: true, verbose: true },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? {
                  pages: [
                    { id: "good", path: "/good" },
                    { id: "bad", path: "/bad" },
                  ],
                }
              : { breakpoints: [] },
        }) as never,
      startPreview: createStartPreview(),
      stopPreview,
      captureScreenshot: vi.fn(async (input) => {
        if (input.path === "/bad") {
          throw new Error("browser page closed");
        }
        return {
          output: "/tmp/good.png",
          browserPath: "/usr/bin/chromium",
          browser: "chromium" as const,
          viewport: input.viewport,
          fullPage: true,
          elapsedMs: 1,
          warnings: [],
          navigation: getNavigation("/good"),
          layout,
        };
      }),
    });

    expect(result.result).toMatchObject({
      renderedState: "partial",
      renderedCheckCount: 1,
      renderedFailureCount: 1,
      renderedCaptureSummary: {
        planned: 2,
        passed: 1,
        failed: 1,
      },
      renderedFailures: [
        expect.objectContaining({
          code: "RENDERED_AUDIT_SCREENSHOT_FAILED",
          retryable: true,
        }),
      ],
    });
    expect(stopPreview).toHaveBeenCalledOnce();
  });

  test("stops a preview that resolves to an unowned origin", async () => {
    const stopPreview = vi.fn();
    const captureScreenshot = vi.fn();
    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: { scopes: ["accessibility"], manualCheckCount: 0 },
      } as never,
      input: { rendered: true, verbose: true },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? { pages: [{ id: "home", path: "/" }] }
              : { breakpoints: [] },
        }) as never,
      startPreview: vi.fn(async () => ({ url: "http://localhost:5177" })),
      stopPreview,
      captureScreenshot,
    });

    expect(result.result).toMatchObject({
      renderedState: "failed",
      renderedFailures: [
        expect.objectContaining({
          code: "RENDERED_AUDIT_PREVIEW_START_FAILED",
        }),
      ],
    });
    expect(captureScreenshot).not.toHaveBeenCalled();
    expect(stopPreview).toHaveBeenCalledOnce();
  });

  test("accepts a generated non-HTML document without an HTML marker", async () => {
    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["accessibility"],
          manualCheckCount: 0,
          verbose: true,
        },
      } as never,
      input: { rendered: true, pagePath: "/sitemap.xml", verbose: true },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? { pages: [{ id: "sitemap", path: "/sitemap.xml" }] }
              : { breakpoints: [] },
        }) as never,
      startPreview: createStartPreview(),
      stopPreview: vi.fn(),
      captureScreenshot: vi.fn(async (input) => ({
        output: `/tmp/sitemap-${input.viewport.width}.png`,
        browserPath: "/usr/bin/chromium",
        browser: "chromium" as const,
        viewport: input.viewport,
        fullPage: true,
        elapsedMs: 10,
        warnings: [],
        navigation: {
          ...getNavigation("/sitemap.xml"),
          mimeType: "application/xml",
          generatedSiteRootPresent: false,
        },
        layout: { ...layout, documentType: "application/xml" },
      })),
    });

    expect(result.result).toMatchObject({
      renderedState: "complete",
      renderedCheckCount: 1,
      renderedFailureCount: 0,
      renderedCaptureSummary: {
        planned: 1,
        passed: 1,
        issues: 0,
        skipped: 0,
        failed: 0,
      },
    });
  });

  test("classifies bounded capture timeouts and preserves reconciliation", async () => {
    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["accessibility"],
          manualCheckCount: 1,
          verbose: true,
        },
      } as never,
      input: { rendered: true, pagePath: "/slow", verbose: true },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? { pages: [{ id: "slow", path: "/slow" }] }
              : { breakpoints: [] },
        }) as never,
      startPreview: createStartPreview(),
      stopPreview: vi.fn(),
      captureScreenshot: vi.fn(
        async (): Promise<never> => await new Promise<never>(() => {})
      ),
      timeouts: { capture: 5 },
    });

    expect(result.result).toMatchObject({
      renderedState: "failed",
      renderedCheckCount: 0,
      renderedFailureCount: 1,
      renderedCaptureSummary: {
        planned: 1,
        passed: 0,
        issues: 0,
        skipped: 0,
        failed: 1,
      },
      renderedFailures: [
        expect.objectContaining({ code: "RENDERED_AUDIT_CAPTURE_TIMEOUT" }),
      ],
    });
  });

  test("does not retry an unresolved resized capture after its timeout", async () => {
    const captureScreenshot = vi.fn();
    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: { scopes: ["performance"], manualCheckCount: 0, verbose: true },
      } as never,
      input: { rendered: true, pagePath: "/slow", verbose: true },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? { pages: [{ id: "slow", path: "/slow" }] }
              : { breakpoints: [] },
        }) as never,
      startPreview: createStartPreview(),
      stopPreview: vi.fn(),
      captureScreenshot,
      capturePageScreenshots: vi.fn(
        async (): Promise<never> => await new Promise<never>(() => {})
      ),
      timeouts: { page: 5 },
    });

    expect(captureScreenshot).not.toHaveBeenCalled();
    expect(result.result).toMatchObject({
      renderedState: "failed",
      renderedFailureCount: 1,
      renderedCaptureSummary: { planned: 1, failed: 1 },
      renderedFailures: [
        expect.objectContaining({ code: "RENDERED_AUDIT_CAPTURE_TIMEOUT" }),
      ],
    });
  });

  test("reads every page of paginated audit planning data", async () => {
    const pages = Array.from({ length: 205 }, (_, index) => ({
      id: `page-${index}`,
      path: `/page-${index}`,
    }));
    const executeRead = vi.fn(
      async (command: "list-pages" | "list-breakpoints", input: unknown) => {
        if (command === "list-breakpoints") {
          return { result: { breakpoints: [], nextCursor: null } } as never;
        }
        const { cursor, limit } = input as {
          cursor?: string;
          limit: number;
        };
        const offset = Number(cursor ?? 0);
        const items = pages.slice(offset, offset + limit);
        return {
          result: {
            pages: items,
            nextCursor:
              offset + items.length < pages.length
                ? String(offset + items.length)
                : null,
          },
        } as never;
      }
    );

    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: { scopes: ["accessibility"], manualCheckCount: 1 },
      } as never,
      input: { rendered: true },
      executeRead,
      startPreview: createStartPreview(),
      stopPreview: vi.fn(),
      captureScreenshot: vi.fn(),
    });

    expect(executeRead).toHaveBeenCalledWith("list-pages", {
      cursor: undefined,
      limit: 200,
    });
    expect(executeRead).toHaveBeenCalledWith("list-pages", {
      cursor: "200",
      limit: 200,
    });
    expect(result.result).toMatchObject({
      renderedState: "confirmation-required",
      renderedPlan: { captureCount: 205 },
    });
  });

  test("requires and consumes confirmation for a large unchanged plan", async () => {
    const startPreview = createStartPreview();
    const stopPreview = vi.fn();
    const captureScreenshot = vi.fn(async (input) => ({
      output: `/tmp/${input.path}-${input.viewport.width}.png`,
      browserPath: "/browser",
      browser: "chromium" as const,
      viewport: input.viewport,
      fullPage: true,
      elapsedMs: 1,
      warnings: [],
      navigation: getNavigation(input.path ?? "/"),
      layout: {
        ...layout,
        viewportWidth: input.viewport.width,
        viewportHeight: input.viewport.height,
      },
    }));
    const envelope = {
      operationId: "project.audit",
      source: "remote",
      projectId: "project",
      buildId: "build",
      version: 1,
      committed: false,
      result: {
        scopes: ["accessibility"],
        manualCheckCount: 1,
      },
    } as never;
    const executeRead = async (command: "list-pages" | "list-breakpoints") =>
      ({
        operationId:
          command === "list-pages" ? "pages.list" : "breakpoints.list",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result:
          command === "list-pages"
            ? {
                pages: Array.from({ length: 122 }, (_, index) => ({
                  id: `page-${index}`,
                  path: `/page-${index}`,
                })),
              }
            : { breakpoints: [] },
      }) as never;
    const result = await augmentAuditWithRenderedChecks({
      envelope,
      input: { rendered: true, verbose: true },
      executeRead,
      startPreview,
      stopPreview,
      captureScreenshot,
    });

    expect(result.result).toMatchObject({
      renderedState: "confirmation-required",
      renderedPlan: {
        version: 1,
        pages: expect.arrayContaining([
          { pageId: "page-0", pagePath: "/page-0" },
        ]),
        excludedPages: [],
        viewports: [
          expect.objectContaining({
            width: 1440,
            purposes: ["base breakpoint: desktop"],
          }),
        ],
        checks: ["horizontal-overflow", "low-text-contrast"],
        captureCount: 122,
        confirmationToken: expect.any(String),
        confirmationExpiresAt: expect.any(String),
      },
      renderedCheckCount: 0,
      renderedFailureCount: 1,
      renderedCaptureSummary: {
        planned: 122,
        passed: 0,
        issues: 0,
        skipped: 122,
        failed: 0,
      },
      renderedFailures: [
        {
          code: "RENDERED_AUDIT_CONFIRMATION_REQUIRED",
          phase: "planning",
          retryable: false,
          remediation: expect.stringContaining("confirmLargeRun"),
          message: expect.stringContaining(
            "122 screenshots, exceeding the 120-screenshot unconfirmed threshold"
          ),
        },
      ],
    });
    expect(startPreview).not.toHaveBeenCalled();
    expect(stopPreview).not.toHaveBeenCalled();
    expect(captureScreenshot).not.toHaveBeenCalled();

    const plan = (result.result as Record<string, unknown>)
      .renderedPlan as Record<string, unknown>;
    const confirmed = await augmentAuditWithRenderedChecks({
      envelope,
      input: {
        rendered: true,
        verbose: true,
        confirmLargeRun: true,
        confirmationToken: plan.confirmationToken,
      },
      executeRead,
      startPreview,
      stopPreview,
      captureScreenshot,
    });

    expect(confirmed.result).toMatchObject({
      renderedState: "complete",
      renderedCheckCount: 122,
      renderedFailureCount: 0,
      renderedCaptureSummary: {
        planned: 122,
        passed: 122,
        issues: 0,
        skipped: 0,
        failed: 0,
      },
    });
    expect(startPreview).toHaveBeenCalledOnce();
    expect(stopPreview).toHaveBeenCalledOnce();
    expect(captureScreenshot).toHaveBeenCalledTimes(122);

    const secondPlan = await augmentAuditWithRenderedChecks({
      envelope,
      input: { rendered: true, verbose: true },
      executeRead,
      startPreview,
      stopPreview,
      captureScreenshot,
    });
    const secondToken = (
      (secondPlan.result as Record<string, unknown>).renderedPlan as Record<
        string,
        unknown
      >
    ).confirmationToken;
    const stale = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 2,
        committed: false,
        result: {
          scopes: ["accessibility"],
          manualCheckCount: 1,
        },
      } as never,
      input: {
        rendered: true,
        verbose: true,
        confirmLargeRun: true,
        confirmationToken: secondToken,
      },
      executeRead,
      startPreview,
      stopPreview,
      captureScreenshot,
    });
    expect(stale.result).toMatchObject({
      renderedState: "confirmation-required",
      renderedCheckCount: 0,
      renderedFailures: [
        expect.objectContaining({
          code: "RENDERED_AUDIT_CONFIRMATION_INVALID",
        }),
      ],
    });
    expect(startPreview).toHaveBeenCalledOnce();
  });

  test("explains excluded dynamic routes without starting preview", async () => {
    const startPreview = createStartPreview();
    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["performance"],
          manualCheckCount: 1,
          verbose: false,
        },
      } as never,
      input: { rendered: true, pagePath: "/blog/:slug" },
      executeRead: async (command) =>
        ({
          operationId:
            command === "list-pages" ? "pages.list" : "breakpoints.list",
          source: "remote",
          projectId: "project",
          buildId: "build",
          version: 1,
          committed: false,
          result:
            command === "list-pages"
              ? { pages: [{ id: "post", path: "/blog/:slug" }] }
              : { breakpoints: [{ id: "tablet", maxWidth: 991 }] },
        }) as never,
      startPreview,
      stopPreview: vi.fn(),
      captureScreenshot: vi.fn(),
    });

    expect(result.result).toMatchObject({
      renderedState: "failed",
      renderedPlan: {
        pages: [],
        excludedPages: [
          {
            pageId: "post",
            pagePath: "/blog/:slug",
            reason: "dynamic-route-needs-example",
          },
        ],
        viewports: expect.arrayContaining([
          expect.objectContaining({
            width: 390,
            purposes: ["tablet: representative"],
          }),
        ]),
        checks: [
          "horizontal-overflow",
          "broken-image",
          "eager-below-fold-image",
          "oversized-image",
          "render-blocking-resource",
          "legacy-font-format",
        ],
        captureCount: 0,
      },
      renderedFailureCount: 1,
      renderedFailureSummaries: [
        expect.objectContaining({ code: "RENDERED_AUDIT_NO_STATIC_PAGES" }),
      ],
    });
    expect(startPreview).not.toHaveBeenCalled();
  });

  test("stops scheduling captures and cleans up when the caller cancels", async () => {
    const controller = new AbortController();
    const startPreview = createStartPreview();
    const stopPreview = vi.fn();
    const captureScreenshot = vi.fn(() => {
      controller.abort();
      return new Promise<never>(() => undefined);
    });
    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["performance"],
          manualCheckCount: 0,
          verbose: true,
        },
      } as never,
      input: { rendered: true, verbose: true },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? { pages: [{ id: "home", path: "/" }] }
              : { breakpoints: [] },
        }) as never,
      startPreview,
      stopPreview,
      captureScreenshot,
      signal: controller.signal,
    });

    expect(result.result).toMatchObject({
      renderedState: "failed",
      renderedCheckCount: 0,
      renderedCaptureSummary: {
        planned: 1,
        skipped: 1,
        failed: 0,
      },
      renderedFailures: [
        expect.objectContaining({ code: "RENDERED_AUDIT_CANCELLED" }),
      ],
    });
    expect(startPreview).toHaveBeenCalledOnce();
    expect(captureScreenshot).toHaveBeenCalledOnce();
    expect(stopPreview).toHaveBeenCalledOnce();
  });

  test("captures a caller-supplied concrete example for a dynamic route", async () => {
    const storeRenderedAuditArtifacts = vi.fn(
      async () => "/project/.webstudio/audits/rendered-project-1.json"
    );
    const captureScreenshot = vi.fn(async (input) => ({
      output: `/tmp/post-${input.viewport.width}.png`,
      browserPath: "/browser",
      browser: "chromium" as const,
      viewport: input.viewport,
      fullPage: true,
      elapsedMs: 1,
      warnings: [],
      navigation: getNavigation(input.path ?? "/"),
      layout: {
        ...layout,
        viewportWidth: input.viewport.width,
        viewportHeight: input.viewport.height,
      },
    }));
    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: {
          scopes: ["accessibility"],
          manualCheckCount: 1,
          verbose: true,
        },
      } as never,
      input: {
        rendered: true,
        verbose: true,
        pageId: "post",
        routeExamples: [{ pageId: "post", path: "/blog/hello?draft=1" }],
      },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? { pages: [{ id: "post", path: "/blog/:slug" }] }
              : { breakpoints: [] },
        }) as never,
      startPreview: createStartPreview(),
      stopPreview: vi.fn(),
      captureScreenshot,
      storeRenderedAuditArtifacts,
    });

    expect(captureScreenshot).toHaveBeenCalledOnce();
    expect(captureScreenshot).toHaveBeenCalledWith(
      expect.objectContaining({ path: "/blog/hello?draft=1" })
    );
    expect(result.result).toMatchObject({
      renderedPlan: {
        pages: [{ pageId: "post", pagePath: "/blog/hello?draft=1" }],
        excludedPages: [],
        captureCount: 1,
      },
      renderedCaptureSummary: {
        planned: 1,
        passed: 1,
        issues: 0,
        skipped: 0,
        failed: 0,
      },
      renderedArtifactManifest: {
        version: 1,
        path: "/project/.webstudio/audits/rendered-project-1.json",
        screenshotCount: 1,
      },
    });
    expect(storeRenderedAuditArtifacts).toHaveBeenCalledWith(
      expect.objectContaining({
        version: 1,
        auditContractVersion: 2,
        projectId: "project",
        projectVersion: 1,
        captureStatuses: [
          expect.objectContaining({
            pagePath: "/blog/hello?draft=1",
            screenshotPath: "/tmp/post-1440.png",
          }),
        ],
        checks: [
          expect.objectContaining({
            screenshotPath: "/tmp/post-1440.png",
            layout: expect.objectContaining({
              navigation: expect.objectContaining({
                finalUrl: "http://127.0.0.1:5177/blog/hello?draft=1",
                status: 200,
                generatedSiteRootPresent: true,
              }),
            }),
          }),
        ],
        failures: [],
      })
    );
  });

  test("treats empty and slash home paths as the same rendered page", async () => {
    const captureScreenshot = vi.fn(async (input) => ({
      output: "/tmp/home.webp",
      browserPath: "/browser",
      browser: "chromium" as const,
      viewport: input.viewport,
      fullPage: true,
      elapsedMs: 1,
      warnings: [],
      navigation: getNavigation(input.path ?? "/"),
      layout,
    }));

    const result = await augmentAuditWithRenderedChecks({
      envelope: {
        operationId: "project.audit",
        source: "remote",
        projectId: "project",
        buildId: "build",
        version: 1,
        committed: false,
        result: { scopes: ["accessibility"], manualCheckCount: 1 },
      } as never,
      input: { rendered: true, pagePath: "" },
      executeRead: async (command) =>
        ({
          result:
            command === "list-pages"
              ? { pages: [{ id: "home", path: "" }] }
              : { breakpoints: [] },
        }) as never,
      startPreview: createStartPreview(),
      stopPreview: vi.fn(),
      captureScreenshot,
    });

    expect(captureScreenshot).toHaveBeenCalledWith(
      expect.objectContaining({ path: "/" })
    );
    expect(result.result).toMatchObject({
      renderedPlan: {
        pages: [{ pageId: "home", pagePath: "/" }],
        captureCount: 1,
      },
      renderedCaptureSummary: { passed: 1, failed: 0 },
    });
  });
});