playwright-checkpoint 0.1.0-beta.0

package/dist/cli/bin.cjs

@@ -0,0 +1,3972 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/report/story-utils.ts
+function groupByStory(runs) {
+  const stories = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    const existing = stories.get(run.title) ?? [];
+    existing.push(run);
+    stories.set(run.title, existing);
+  }
+  return stories;
+}
+function orderedCheckpointNames(runs) {
+  const names = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const run of runs) {
+    for (const checkpoint of run.checkpoints) {
+      if (seen.has(checkpoint.name)) {
+        continue;
+      }
+      seen.add(checkpoint.name);
+      names.push(checkpoint.name);
+    }
+  }
+  return names;
+}
+var init_story_utils = __esm({
+  "src/report/story-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/report/html-reporter.ts
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function slugify(value) {
+  return value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "story";
+}
+function formatDateTime(isoDate) {
+  const date = new Date(isoDate);
+  if (Number.isNaN(date.getTime())) {
+    return isoDate;
+  }
+  return new Intl.DateTimeFormat("en-US", {
+    dateStyle: "medium",
+    timeStyle: "short"
+  }).format(date);
+}
+function projectWeight(projectName, projectOrder) {
+  const index = projectOrder.indexOf(projectName);
+  return index === -1 ? Number.MAX_SAFE_INTEGER : index;
+}
+function formatProjectLabel(projectName) {
+  const [device, mode] = projectName.split("-");
+  if (!device || !mode) {
+    return projectName;
+  }
+  const deviceLabel = device === "desktop" ? "Desktop" : device === "mobile" ? "Mobile" : device;
+  const modeLabel = mode === "light" ? "Light" : mode === "dark" ? "Dark" : mode;
+  return `${deviceLabel} / ${modeLabel}`;
+}
+function sortByProjectAndTime(a, b, projectOrder) {
+  const byProject = projectWeight(a.project, projectOrder) - projectWeight(b.project, projectOrder);
+  if (byProject !== 0) {
+    return byProject;
+  }
+  const byProjectName = a.project.localeCompare(b.project);
+  if (byProjectName !== 0) {
+    return byProjectName;
+  }
+  return new Date(a.startedAt).getTime() - new Date(b.startedAt).getTime();
+}
+function getCollectorSummaryNumber(checkpoint, collectorName, key) {
+  const value = checkpoint.collectors[collectorName]?.summary[key];
+  return typeof value === "number" ? value : null;
+}
+function screenshotData(checkpoint) {
+  const data = checkpoint.collectors.screenshot?.data;
+  return data && typeof data === "object" ? data : null;
+}
+function highlightOverlayStyle(checkpoint) {
+  const data = screenshotData(checkpoint);
+  const bounds = data?.highlightBounds;
+  const imageSize = data?.imageSize;
+  if (!bounds || !imageSize || typeof bounds.x !== "number" || typeof bounds.y !== "number" || typeof bounds.width !== "number" || typeof bounds.height !== "number" || typeof imageSize.width !== "number" || typeof imageSize.height !== "number" || imageSize.width <= 0 || imageSize.height <= 0) {
+    return null;
+  }
+  const left = bounds.x / imageSize.width * 100;
+  const top = bounds.y / imageSize.height * 100;
+  const width = bounds.width / imageSize.width * 100;
+  const height = bounds.height / imageSize.height * 100;
+  return [
+    `left:${left.toFixed(4)}%`,
+    `top:${top.toFixed(4)}%`,
+    `width:${width.toFixed(4)}%`,
+    `height:${height.toFixed(4)}%`
+  ].join(";");
+}
+function highlightLabel(checkpoint) {
+  const selector = screenshotData(checkpoint)?.highlightSelector;
+  return typeof selector === "string" && selector.trim().length > 0 ? `Focus: ${selector.trim()}` : null;
+}
+function resolveArtifactPath(run, artifactPath) {
+  return import_node_path.default.isAbsolute(artifactPath) ? artifactPath : import_node_path.default.resolve(import_node_path.default.dirname(run.sourceManifestPath), artifactPath);
+}
+function toEncodedHref(outputDir, filePath) {
+  if (!filePath) {
+    return null;
+  }
+  const relativePath = import_node_path.default.relative(outputDir, filePath);
+  return relativePath.split(import_node_path.default.sep).map(encodeURIComponent).join("/");
+}
+function getArtifactHref(run, checkpoint, outputDir, collectorName, artifactName) {
+  const artifacts = checkpoint.collectors[collectorName]?.artifacts ?? [];
+  const artifact = artifactName ? artifacts.find((entry) => entry.name === artifactName) : artifacts[0];
+  if (!artifact?.path) {
+    return null;
+  }
+  return toEncodedHref(outputDir, resolveArtifactPath(run, artifact.path));
+}
+function renderArtifactLinks(run, checkpoint, outputDir) {
+  const links = [
+    { label: "DOM HTML", href: getArtifactHref(run, checkpoint, outputDir, "html", "html") },
+    { label: "Axe", href: getArtifactHref(run, checkpoint, outputDir, "axe", "axe") },
+    { label: "Web Vitals", href: getArtifactHref(run, checkpoint, outputDir, "web-vitals", "web-vitals") },
+    { label: "Console", href: getArtifactHref(run, checkpoint, outputDir, "console", "console-errors") },
+    { label: "Failed Requests", href: getArtifactHref(run, checkpoint, outputDir, "network", "failed-requests") }
+  ];
+  return links.map((link) => {
+    if (!link.href) {
+      return `<span class="artifact disabled">${escapeHtml(link.label)}</span>`;
+    }
+    return `<a class="artifact" href="${link.href}" target="_blank" rel="noreferrer">${escapeHtml(link.label)}</a>`;
+  }).join("");
+}
+function renderCheckpointCard(run, checkpointName, outputDir) {
+  const checkpoint = run.checkpoints.find((entry) => entry.name === checkpointName);
+  if (!checkpoint) {
+    return `
+      <article class="variant-card missing">
+        <header class="variant-card-header">
+          <div>
+            <h5>${escapeHtml(formatProjectLabel(run.project))}</h5>
+            <p>${escapeHtml(run.project)}</p>
+          </div>
+          <time>${escapeHtml(formatDateTime(run.startedAt))}</time>
+        </header>
+        <div class="empty-card">No checkpoint captured for this run.</div>
+      </article>
+    `;
+  }
+  const screenshotHref = getArtifactHref(run, checkpoint, outputDir, "screenshot", "screenshot");
+  const overlayStyle = highlightOverlayStyle(checkpoint);
+  const focus = highlightLabel(checkpoint);
+  const axeViolations = getCollectorSummaryNumber(checkpoint, "axe", "violations");
+  const consoleErrors = getCollectorSummaryNumber(checkpoint, "console", "consoleErrorCount") ?? 0;
+  const failedRequests = getCollectorSummaryNumber(checkpoint, "network", "failedRequestCount") ?? 0;
+  return `
+    <article class="variant-card">
+      <header class="variant-card-header">
+        <div>
+          <h5>${escapeHtml(formatProjectLabel(run.project))}</h5>
+          <p>${escapeHtml(run.project)}</p>
+        </div>
+        <time>${escapeHtml(formatDateTime(checkpoint.timestamp || run.startedAt))}</time>
+      </header>
+      <p class="page-meta">
+        <span>${escapeHtml(checkpoint.title || "Untitled page")}</span>
+        <span class="page-url">${escapeHtml(checkpoint.url)}</span>
+      </p>
+      ${screenshotHref ? `<a class="thumbnail-link" href="${screenshotHref}" target="_blank" rel="noreferrer">
+              <img src="${screenshotHref}" alt="${escapeHtml(`${run.project} \u2014 ${checkpoint.name}`)}" loading="lazy" />
+              ${overlayStyle ? `<span class="highlight-overlay" style="${overlayStyle}" aria-hidden="true"></span>` : ""}
+              ${focus ? `<span class="highlight-label">${escapeHtml(focus)}</span>` : ""}
+            </a>` : '<div class="empty-card">Screenshot unavailable.</div>'}
+      <div class="stats-grid">
+        <span><strong>${axeViolations ?? "n/a"}</strong><small>Axe violations</small></span>
+        <span><strong>${consoleErrors}</strong><small>Console errors</small></span>
+        <span><strong>${failedRequests}</strong><small>Failed requests</small></span>
+      </div>
+      <div class="artifact-list">${renderArtifactLinks(run, checkpoint, outputDir)}</div>
+    </article>
+  `;
+}
+function renderStorySection(title, runs, outputDir) {
+  const checkpointNames = orderedCheckpointNames(runs);
+  const environments = [...new Set(runs.map((run) => run.environment))].sort();
+  const tags = [...new Set(runs.flatMap((run) => run.tags))].sort();
+  const checkpointBlocks = checkpointNames.map(
+    (checkpointName) => `
+        <details class="accordion checkpoint-block">
+          <summary class="checkpoint-summary">
+            <span>${escapeHtml(checkpointName)}</span>
+            <span class="checkpoint-meta">${runs.length} variants</span>
+          </summary>
+          <div class="variant-grid">
+            ${runs.map((run) => renderCheckpointCard(run, checkpointName, outputDir)).join("")}
+          </div>
+        </details>
+      `
+  ).join("");
+  return `
+    <details class="accordion story-block" id="story-${slugify(title)}" open>
+      <summary class="story-summary">
+        <span class="story-title">${escapeHtml(title)}</span>
+        <span class="story-meta-chip">${runs.length} run${runs.length === 1 ? "" : "s"}</span>
+      </summary>
+      <div class="story-body">
+        <div class="story-meta-row">
+          <span><strong>Projects</strong> ${escapeHtml(runs.map((run) => run.project).join(", "))}</span>
+          <span><strong>Environments</strong> ${escapeHtml(environments.join(", ") || "n/a")}</span>
+          <span><strong>Tags</strong> ${escapeHtml(tags.join(", ") || "none")}</span>
+        </div>
+        ${checkpointBlocks || '<p class="empty-state">No checkpoints captured for this story.</p>'}
+      </div>
+    </details>
+  `;
+}
+function buildHtmlReport(runs, outputDir, config) {
+  const groupedRuns = groupByStory(runs);
+  const storyTitles = [...groupedRuns.keys()].sort((a, b) => a.localeCompare(b));
+  const projectOrder = Array.isArray(config.projectOrder) ? config.projectOrder.filter((value) => typeof value === "string") : DEFAULT_PROJECT_ORDER;
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const reportTitle = typeof config.title === "string" && config.title.trim() ? config.title.trim() : "Playwright Checkpoint Report";
+  for (const title of storyTitles) {
+    groupedRuns.get(title)?.sort((a, b) => sortByProjectAndTime(a, b, projectOrder));
+  }
+  const navLinks = storyTitles.map((title) => `<a href="#story-${slugify(title)}">${escapeHtml(title)}</a>`).join("");
+  const storySections = storyTitles.map((title) => renderStorySection(title, groupedRuns.get(title) ?? [], outputDir)).join("");
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml(reportTitle)}</title>
+  <style>
+    :root {
+      color-scheme: dark;
+      --bg: #0b1020;
+      --panel: rgba(15, 23, 42, 0.88);
+      --panel-2: rgba(17, 25, 40, 0.98);
+      --text: #e5eefb;
+      --muted: #9fb3c8;
+      --accent: #60a5fa;
+      --accent-2: #22d3ee;
+      --border: rgba(148, 163, 184, 0.18);
+      --success: #34d399;
+      --warning: #fbbf24;
+      --danger: #fb7185;
+      --shadow: 0 24px 64px rgba(2, 6, 23, 0.45);
+    }
+    * { box-sizing: border-box; }
+    html { scroll-behavior: smooth; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      background:
+        radial-gradient(circle at top, rgba(96, 165, 250, 0.14), transparent 30%),
+        linear-gradient(180deg, #07101f 0%, #0b1020 100%);
+      color: var(--text);
+    }
+    a { color: inherit; }
+    .page {
+      width: min(1600px, calc(100vw - 32px));
+      margin: 0 auto;
+      padding: 28px 0 56px;
+    }
+    .hero {
+      background: linear-gradient(180deg, rgba(15, 23, 42, 0.96), rgba(15, 23, 42, 0.84));
+      border: 1px solid var(--border);
+      border-radius: 24px;
+      padding: 24px;
+      box-shadow: var(--shadow);
+      backdrop-filter: blur(18px);
+    }
+    .hero h1 {
+      margin: 0;
+      font-size: clamp(1.9rem, 2.6vw, 3rem);
+      line-height: 1.1;
+    }
+    .hero p {
+      margin: 10px 0 0;
+      color: var(--muted);
+      max-width: 72ch;
+      line-height: 1.6;
+    }
+    .summary-bar {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 12px;
+      margin-top: 18px;
+    }
+    .summary-pill {
+      display: inline-flex;
+      gap: 8px;
+      align-items: center;
+      padding: 9px 12px;
+      border: 1px solid var(--border);
+      border-radius: 999px;
+      background: rgba(15, 23, 42, 0.72);
+      color: var(--muted);
+      font-size: 0.92rem;
+    }
+    .summary-pill strong { color: var(--text); }
+    .toolbar {
+      display: flex;
+      flex-wrap: wrap;
+      justify-content: space-between;
+      gap: 16px;
+      margin-top: 18px;
+      padding-top: 18px;
+      border-top: 1px solid var(--border);
+    }
+    .story-nav {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 10px;
+    }
+    .story-nav a,
+    .toolbar button,
+    .artifact {
+      border: 1px solid var(--border);
+      border-radius: 999px;
+      background: rgba(15, 23, 42, 0.7);
+      color: var(--text);
+      text-decoration: none;
+      padding: 8px 12px;
+      font: inherit;
+      font-size: 0.86rem;
+      transition: transform 140ms ease, border-color 140ms ease, background 140ms ease;
+    }
+    .toolbar button:hover,
+    .story-nav a:hover,
+    .artifact:hover {
+      transform: translateY(-1px);
+      border-color: rgba(96, 165, 250, 0.55);
+      background: rgba(30, 41, 59, 0.96);
+      cursor: pointer;
+    }
+    .content {
+      display: grid;
+      gap: 18px;
+      margin-top: 22px;
+    }
+    .accordion {
+      border: 1px solid var(--border);
+      border-radius: 22px;
+      background: var(--panel);
+      box-shadow: var(--shadow);
+      overflow: hidden;
+    }
+    .accordion summary {
+      list-style: none;
+      cursor: pointer;
+    }
+    .accordion summary::-webkit-details-marker { display: none; }
+    .story-summary,
+    .checkpoint-summary {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      gap: 12px;
+    }
+    .story-summary {
+      padding: 20px 22px;
+      background: linear-gradient(180deg, rgba(15, 23, 42, 0.92), rgba(15, 23, 42, 0.74));
+    }
+    .story-title {
+      font-size: 1.1rem;
+      font-weight: 700;
+    }
+    .story-meta-chip,
+    .checkpoint-meta {
+      color: var(--muted);
+      font-size: 0.84rem;
+      white-space: nowrap;
+    }
+    .story-body {
+      padding: 0 22px 22px;
+    }
+    .story-meta-row {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 16px;
+      color: var(--muted);
+      font-size: 0.92rem;
+      line-height: 1.5;
+      margin: 4px 0 18px;
+    }
+    .story-meta-row strong { color: var(--text); margin-right: 6px; }
+    .checkpoint-block {
+      margin-top: 14px;
+      border-radius: 18px;
+      background: var(--panel-2);
+      border: 1px solid rgba(148, 163, 184, 0.14);
+    }
+    .checkpoint-summary {
+      padding: 16px 18px;
+      font-weight: 600;
+      background: rgba(15, 23, 42, 0.68);
+    }
+    .variant-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+      gap: 14px;
+      padding: 0 18px 18px;
+    }
+    .variant-card {
+      display: grid;
+      gap: 12px;
+      border: 1px solid rgba(148, 163, 184, 0.14);
+      border-radius: 18px;
+      background: rgba(15, 23, 42, 0.72);
+      padding: 16px;
+      min-height: 100%;
+    }
+    .variant-card.missing {
+      opacity: 0.72;
+      border-style: dashed;
+    }
+    .variant-card-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: flex-start;
+      gap: 10px;
+    }
+    .variant-card-header h5 {
+      margin: 0;
+      font-size: 1rem;
+    }
+    .variant-card-header p,
+    .variant-card-header time {
+      margin: 4px 0 0;
+      color: var(--muted);
+      font-size: 0.83rem;
+    }
+    .page-meta {
+      display: grid;
+      gap: 4px;
+      margin: 0;
+      color: var(--muted);
+      font-size: 0.9rem;
+    }
+    .page-url {
+      overflow-wrap: anywhere;
+      font-size: 0.82rem;
+    }
+    .thumbnail-link {
+      position: relative;
+      display: block;
+      border-radius: 14px;
+      overflow: hidden;
+      border: 1px solid rgba(148, 163, 184, 0.18);
+      background: rgba(2, 6, 23, 0.65);
+    }
+    .thumbnail-link img {
+      display: block;
+      width: 100%;
+      aspect-ratio: 16 / 10;
+      object-fit: cover;
+    }
+    .highlight-overlay {
+      position: absolute;
+      border: 2px solid var(--danger);
+      border-radius: 12px;
+      background: rgba(251, 113, 133, 0.08);
+      box-shadow: 0 0 0 999px rgba(251, 113, 133, 0.02);
+      pointer-events: none;
+    }
+    .highlight-label {
+      position: absolute;
+      left: 12px;
+      bottom: 12px;
+      max-width: calc(100% - 24px);
+      padding: 6px 9px;
+      border-radius: 999px;
+      background: rgba(15, 23, 42, 0.9);
+      border: 1px solid rgba(251, 113, 133, 0.35);
+      color: #ffe4e6;
+      font-size: 0.74rem;
+      line-height: 1.3;
+      overflow-wrap: anywhere;
+    }
+    .stats-grid {
+      display: grid;
+      grid-template-columns: repeat(3, minmax(0, 1fr));
+      gap: 10px;
+    }
+    .stats-grid span {
+      display: grid;
+      gap: 6px;
+      padding: 10px 12px;
+      border-radius: 14px;
+      background: rgba(2, 6, 23, 0.42);
+      border: 1px solid rgba(148, 163, 184, 0.12);
+    }
+    .stats-grid strong {
+      font-size: 1.15rem;
+      line-height: 1;
+    }
+    .stats-grid small {
+      color: var(--muted);
+      font-size: 0.76rem;
+      text-transform: uppercase;
+      letter-spacing: 0.04em;
+    }
+    .artifact-list {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+    }
+    .artifact.disabled {
+      opacity: 0.45;
+      pointer-events: none;
+    }
+    .empty-state,
+    .empty-card {
+      margin: 0;
+      color: var(--muted);
+      padding: 12px;
+      border: 1px dashed rgba(148, 163, 184, 0.2);
+      border-radius: 14px;
+      background: rgba(2, 6, 23, 0.24);
+    }
+    @media (max-width: 720px) {
+      .page {
+        width: min(100vw - 20px, 1600px);
+        padding-top: 18px;
+      }
+      .hero,
+      .story-summary,
+      .story-body,
+      .checkpoint-summary,
+      .variant-grid {
+        padding-left: 16px;
+        padding-right: 16px;
+      }
+      .variant-card-header,
+      .story-summary,
+      .checkpoint-summary,
+      .toolbar {
+        flex-direction: column;
+        align-items: flex-start;
+      }
+      .stats-grid {
+        grid-template-columns: 1fr;
+      }
+    }
+  </style>
+</head>
+<body>
+  <main class="page">
+    <section class="hero">
+      <h1>${escapeHtml(reportTitle)}</h1>
+      <p>Explore checkpoint runs by story, inspect every project variant side-by-side, and jump directly to screenshots and generated artifacts.</p>
+      <div class="summary-bar">
+        <span class="summary-pill"><strong>Generated</strong> ${escapeHtml(formatDateTime(generatedAt))}</span>
+        <span class="summary-pill"><strong>Stories</strong> ${storyTitles.length}</span>
+        <span class="summary-pill"><strong>Runs</strong> ${runs.length}</span>
+        <span class="summary-pill"><strong>Output</strong> ${escapeHtml(outputDir)}</span>
+      </div>
+      <div class="toolbar">
+        <nav class="story-nav">${navLinks || '<span class="summary-pill">No stories found</span>'}</nav>
+        <div class="toolbar-actions">
+          <button type="button" data-action="expand-all">Expand all</button>
+          <button type="button" data-action="collapse-all">Collapse all</button>
+        </div>
+      </div>
+    </section>
+    <section class="content">
+      ${storySections || '<p class="empty-state">No checkpoint manifests found.</p>'}
+    </section>
+  </main>
+  <script>
+    (() => {
+      const details = Array.from(document.querySelectorAll('details.accordion'));
+      const setAll = (open) => {
+        details.forEach((entry) => {
+          entry.open = open;
+        });
+      };
+      document.querySelector('[data-action="expand-all"]')?.addEventListener('click', () => setAll(true));
+      document.querySelector('[data-action="collapse-all"]')?.addEventListener('click', () => setAll(false));
+      const revealHash = () => {
+        if (!window.location.hash) {
+          return;
+        }
+        const target = document.querySelector(window.location.hash);
+        if (!(target instanceof HTMLElement)) {
+          return;
+        }
+        const parentDetails = target.closest('details');
+        if (parentDetails instanceof HTMLDetailsElement) {
+          parentDetails.open = true;
+        }
+        target.scrollIntoView({ block: 'start', behavior: 'smooth' });
+      };
+      window.addEventListener('hashchange', revealHash);
+      revealHash();
+    })();
+  </script>
+</body>
+</html>
+`;
+}
+var import_promises, import_node_path, DEFAULT_PROJECT_ORDER, htmlReporter;
+var init_html_reporter = __esm({
+  "src/report/html-reporter.ts"() {
+    "use strict";
+    import_promises = __toESM(require("fs/promises"), 1);
+    import_node_path = __toESM(require("path"), 1);
+    init_story_utils();
+    DEFAULT_PROJECT_ORDER = ["desktop-light", "desktop-dark", "mobile-light", "mobile-dark"];
+    htmlReporter = {
+      name: "html",
+      description: "Responsive HTML report for checkpoint manifests.",
+      validateConfig(config) {
+        return config != null && typeof config === "object" && !Array.isArray(config);
+      },
+      async generate(context) {
+        const outputFile = import_node_path.default.join(context.outputDir, "index.html");
+        const html = buildHtmlReport(context.runs, context.outputDir, context.config);
+        await import_promises.default.mkdir(context.outputDir, { recursive: true });
+        await import_promises.default.writeFile(outputFile, html, "utf8");
+        const storyCount = new Set(context.runs.map((run) => run.title)).size;
+        return {
+          files: [outputFile],
+          summary: `Generated HTML report for ${storyCount} stor${storyCount === 1 ? "y" : "ies"} (${context.runs.length} run${context.runs.length === 1 ? "" : "s"}).`
+        };
+      }
+    };
+  }
+});
+
+// src/report/markdown-reporter.ts
+function slugify2(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "story";
+}
+function stripTags(value) {
+  const stripped = value.replace(/\s+@[a-z0-9-]+/gi, " ").replace(/\s+/g, " ").trim();
+  return stripped || value.trim() || "Untitled story";
+}
+function normalizeConfig(config) {
+  return {
+    storiesDir: typeof config.storiesDir === "string" ? config.storiesDir : ".",
+    screenshotsDir: typeof config.screenshotsDir === "string" ? config.screenshotsDir : "screenshots",
+    includeTags: Array.isArray(config.includeTags) ? config.includeTags.filter((value) => typeof value === "string") : void 0,
+    preferredProject: typeof config.preferredProject === "string" ? config.preferredProject : void 0,
+    header: typeof config.header === "string" ? config.header : void 0,
+    footer: typeof config.footer === "string" ? config.footer : void 0,
+    frontmatter: config.frontmatter === true || config.frontmatter === false || config.frontmatter != null && typeof config.frontmatter === "object" && !Array.isArray(config.frontmatter) ? config.frontmatter : false,
+    imagePathPrefix: typeof config.imagePathPrefix === "string" ? config.imagePathPrefix : void 0,
+    copyScreenshots: typeof config.copyScreenshots === "boolean" ? config.copyScreenshots : true
+  };
+}
+function normalizeTags(tags) {
+  return (tags ?? []).map((tag) => tag.trim().toLowerCase()).filter(Boolean);
+}
+function shouldIncludeRun(run, config) {
+  const includeTags = normalizeTags(config.includeTags);
+  if (includeTags.length > 0) {
+    const runTags = new Set(normalizeTags(run.tags));
+    return includeTags.some((tag) => runTags.has(tag));
+  }
+  return run.checkpoints.some((checkpoint) => {
+    const hasDescription = typeof checkpoint.description === "string" && checkpoint.description.trim().length > 0;
+    return hasDescription || typeof checkpoint.step === "number";
+  });
+}
+function choosePrimaryRun(runs, preferredProject) {
+  if (runs.length === 0) {
+    return null;
+  }
+  return [...runs].sort((left, right) => {
+    const leftPreferred = preferredProject && left.project === preferredProject ? 0 : 1;
+    const rightPreferred = preferredProject && right.project === preferredProject ? 0 : 1;
+    if (leftPreferred !== rightPreferred) {
+      return leftPreferred - rightPreferred;
+    }
+    const rightTime = new Date(right.startedAt).getTime();
+    const leftTime = new Date(left.startedAt).getTime();
+    if (rightTime !== leftTime) {
+      return rightTime - leftTime;
+    }
+    return left.project.localeCompare(right.project);
+  })[0] ?? null;
+}
+function resolveArtifactPath2(run, artifactPath) {
+  return import_node_path2.default.isAbsolute(artifactPath) ? artifactPath : import_node_path2.default.resolve(import_node_path2.default.dirname(run.sourceManifestPath), artifactPath);
+}
+function screenshotSourcePath(run, checkpoint) {
+  const artifacts = checkpoint.collectors.screenshot?.artifacts ?? [];
+  const artifact = artifacts.find((entry) => entry.name === "screenshot") ?? artifacts[0];
+  return artifact?.path ? resolveArtifactPath2(run, artifact.path) : null;
+}
+function screenshotData2(checkpoint) {
+  const data = checkpoint.collectors.screenshot?.data;
+  return data && typeof data === "object" ? data : null;
+}
+function focusNote(checkpoint) {
+  const data = screenshotData2(checkpoint);
+  const selector = typeof data?.highlightSelector === "string" ? data.highlightSelector.trim() : "";
+  if (selector) {
+    return `Focus: \`${selector}\``;
+  }
+  const bounds = data?.highlightBounds;
+  if (bounds && typeof bounds.x === "number" && typeof bounds.y === "number" && typeof bounds.width === "number" && typeof bounds.height === "number") {
+    return "Focus: highlighted UI element.";
+  }
+  return null;
+}
+function urlLabel(url) {
+  try {
+    const parsed = new URL(url);
+    const value = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+    return value || "/";
+  } catch {
+    return url || "/";
+  }
+}
+function breadcrumbLabel(url) {
+  const label = urlLabel(url);
+  if (!label.startsWith("/")) {
+    return null;
+  }
+  const [withoutQuery = label] = label.split("?");
+  const [withoutHash = withoutQuery] = withoutQuery.split("#");
+  const segments = withoutHash.split("/").map((segment) => segment.trim()).filter(Boolean).map((segment) => decodeURIComponent(segment).replace(/[-_]+/g, " "));
+  return segments.length > 0 ? segments.join(" \u203A ") : "home";
+}
+function autoDescription(checkpoint) {
+  const pageTitle = checkpoint.title.trim();
+  const location2 = urlLabel(checkpoint.url);
+  if (pageTitle) {
+    return `This step captures **${pageTitle}** at \`${location2}\`.`;
+  }
+  return `This step captures **${checkpoint.name}** at \`${location2}\`.`;
+}
+function markdownRelativePath(fromFile, toFile) {
+  const relativePath = import_node_path2.default.relative(import_node_path2.default.dirname(fromFile), toFile).split(import_node_path2.default.sep).join("/");
+  if (relativePath.startsWith(".")) {
+    return relativePath;
+  }
+  return `./${relativePath}`;
+}
+function rewriteImagePath(markdownFile, imageFile, outputDir, prefix) {
+  const relativePath = import_node_path2.default.relative(outputDir, imageFile).split(import_node_path2.default.sep).join("/");
+  if (prefix) {
+    return `${prefix.replace(/\/+$/g, "")}/${relativePath.replace(/^\/+/, "")}`;
+  }
+  return markdownRelativePath(markdownFile, imageFile);
+}
+function yamlScalar(value) {
+  return JSON.stringify(value);
+}
+function serializeFrontmatter(fields) {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      lines.push(`${key}:`);
+      if (value.length === 0) {
+        lines.push("  []");
+        continue;
+      }
+      for (const item of value) {
+        lines.push(`  - ${yamlScalar(item)}`);
+      }
+      continue;
+    }
+    lines.push(`${key}: ${yamlScalar(value)}`);
+  }
+  lines.push("---", "");
+  return lines.join("\n");
+}
+async function materializeScreenshot(args) {
+  const sourcePath = screenshotSourcePath(args.run, args.checkpoint);
+  if (!sourcePath) {
+    return null;
+  }
+  const extension = import_node_path2.default.extname(sourcePath) || ".png";
+  const targetPath = import_node_path2.default.join(
+    args.outputDir,
+    args.config.screenshotsDir ?? "screenshots",
+    args.storySlug,
+    `${String(args.stepOrder).padStart(2, "0")}-${slugify2(args.checkpoint.name)}${extension}`
+  );
+  try {
+    if (args.config.copyScreenshots !== false) {
+      await import_promises2.default.mkdir(import_node_path2.default.dirname(targetPath), { recursive: true });
+      await import_promises2.default.copyFile(sourcePath, targetPath);
+      args.writtenFiles.add(targetPath);
+      return rewriteImagePath(args.markdownFile, targetPath, args.outputDir, args.config.imagePathPrefix);
+    }
+    return rewriteImagePath(args.markdownFile, sourcePath, args.outputDir, args.config.imagePathPrefix);
+  } catch {
+    return null;
+  }
+}
+function orderedCheckpoints(checkpoints) {
+  return [...checkpoints].sort((left, right) => {
+    const leftOrder = typeof left.step === "number" ? left.step : Number.MAX_SAFE_INTEGER;
+    const rightOrder = typeof right.step === "number" ? right.step : Number.MAX_SAFE_INTEGER;
+    if (leftOrder !== rightOrder) {
+      return leftOrder - rightOrder;
+    }
+    return checkpoints.indexOf(left) - checkpoints.indexOf(right);
+  });
+}
+async function buildSteps(args) {
+  const checkpoints = orderedCheckpoints(args.run.checkpoints);
+  const steps = [];
+  for (const [index, checkpoint] of checkpoints.entries()) {
+    const order = typeof checkpoint.step === "number" ? checkpoint.step : index + 1;
+    steps.push({
+      checkpoint,
+      order,
+      heading: checkpoint.name,
+      description: typeof checkpoint.description === "string" && checkpoint.description.trim().length > 0 ? checkpoint.description.trim() : autoDescription(checkpoint),
+      imagePath: await materializeScreenshot({
+        run: args.run,
+        checkpoint,
+        storySlug: args.storySlug,
+        stepOrder: order,
+        outputDir: args.outputDir,
+        markdownFile: args.markdownFile,
+        config: args.config,
+        writtenFiles: args.writtenFiles
+      }),
+      urlLabel: urlLabel(checkpoint.url),
+      breadcrumbLabel: breadcrumbLabel(checkpoint.url),
+      focusNote: focusNote(checkpoint)
+    });
+  }
+  return steps;
+}
+function renderMarkdown(args) {
+  const frontmatterFields = args.config.frontmatter === true || typeof args.config.frontmatter === "object" ? {
+    title: args.title,
+    project: args.run.project,
+    testId: args.run.testId,
+    tags: args.run.tags,
+    startedAt: args.run.startedAt,
+    generatedAt: args.generatedAt,
+    ...args.config.frontmatter && typeof args.config.frontmatter === "object" ? args.config.frontmatter : {}
+  } : null;
+  const sections = args.steps.map((step) => {
+    const lines = [`## Step ${step.order}: ${step.heading}`, ""];
+    if (step.imagePath) {
+      lines.push(`![${step.checkpoint.title || step.heading}](${step.imagePath})`, "");
+    }
+    lines.push(`**URL:** \`${step.urlLabel}\``);
+    if (step.breadcrumbLabel) {
+      lines.push("", `**Breadcrumb:** ${step.breadcrumbLabel}`);
+    }
+    if (step.focusNote) {
+      lines.push("", `> ${step.focusNote}`);
+    }
+    lines.push("", step.description);
+    return lines.join("\n");
+  }).join("\n\n");
+  const parts = [
+    frontmatterFields ? serializeFrontmatter(frontmatterFields) : "",
+    `# ${args.title}`,
+    args.config.header ? args.config.header.trim() : "",
+    sections,
+    args.config.footer ? args.config.footer.trim() : ""
+  ].filter((value) => value.trim().length > 0);
+  return `${parts.join("\n\n")}
+`;
+}
+var import_promises2, import_node_path2, markdownReporter;
+var init_markdown_reporter = __esm({
+  "src/report/markdown-reporter.ts"() {
+    "use strict";
+    import_promises2 = __toESM(require("fs/promises"), 1);
+    import_node_path2 = __toESM(require("path"), 1);
+    init_story_utils();
+    markdownReporter = {
+      name: "markdown",
+      description: "Generates one Markdown help article per captured story.",
+      validateConfig(config) {
+        return config != null && typeof config === "object" && !Array.isArray(config);
+      },
+      async generate(context) {
+        const config = normalizeConfig(context.config);
+        const stories = groupByStory(context.runs);
+        const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const writtenFiles = /* @__PURE__ */ new Set();
+        let articleCount = 0;
+        for (const [storyTitle, runs] of stories) {
+          const primaryRun = choosePrimaryRun(runs, config.preferredProject);
+          if (!primaryRun || !shouldIncludeRun(primaryRun, config)) {
+            continue;
+          }
+          const title = stripTags(storyTitle);
+          const storySlug = slugify2(title);
+          const markdownFile = import_node_path2.default.join(context.outputDir, config.storiesDir ?? ".", `${storySlug}.md`);
+          const steps = await buildSteps({
+            run: primaryRun,
+            storySlug,
+            outputDir: context.outputDir,
+            markdownFile,
+            config,
+            writtenFiles
+          });
+          await import_promises2.default.mkdir(import_node_path2.default.dirname(markdownFile), { recursive: true });
+          await import_promises2.default.writeFile(
+            markdownFile,
+            renderMarkdown({
+              title,
+              steps,
+              run: primaryRun,
+              config,
+              generatedAt
+            }),
+            "utf8"
+          );
+          writtenFiles.add(markdownFile);
+          articleCount += 1;
+        }
+        return {
+          files: [...writtenFiles],
+          summary: `Generated ${articleCount} Markdown article${articleCount === 1 ? "" : "s"}.`
+        };
+      }
+    };
+  }
+});
+
+// src/report/mdx-reporter.ts
+function slugify3(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "story";
+}
+function stripTags2(value) {
+  const stripped = value.replace(/\s+@[a-z0-9-]+/gi, " ").replace(/\s+/g, " ").trim();
+  return stripped || value.trim() || "Untitled story";
+}
+function normalizeConfig2(config) {
+  return {
+    storiesDir: typeof config.storiesDir === "string" ? config.storiesDir : ".",
+    screenshotsDir: typeof config.screenshotsDir === "string" ? config.screenshotsDir : "screenshots",
+    includeTags: Array.isArray(config.includeTags) ? config.includeTags.filter((value) => typeof value === "string") : void 0,
+    preferredProject: typeof config.preferredProject === "string" ? config.preferredProject : void 0,
+    imagePathPrefix: typeof config.imagePathPrefix === "string" ? config.imagePathPrefix : void 0,
+    copyScreenshots: typeof config.copyScreenshots === "boolean" ? config.copyScreenshots : true,
+    componentImportPath: typeof config.componentImportPath === "string" ? config.componentImportPath : "playwright-checkpoint/components"
+  };
+}
+function normalizeTags2(tags) {
+  return (tags ?? []).map((tag) => tag.trim().toLowerCase()).filter(Boolean);
+}
+function frontmatterTags(tags) {
+  return normalizeTags2(tags).map((tag) => tag.replace(/^@+/, "")).filter(Boolean);
+}
+function shouldIncludeRun2(run, config) {
+  const includeTags = normalizeTags2(config.includeTags);
+  if (includeTags.length > 0) {
+    const runTags = new Set(normalizeTags2(run.tags));
+    return includeTags.some((tag) => runTags.has(tag));
+  }
+  return run.checkpoints.some((checkpoint) => {
+    const hasDescription = typeof checkpoint.description === "string" && checkpoint.description.trim().length > 0;
+    return hasDescription || typeof checkpoint.step === "number";
+  });
+}
+function choosePrimaryRun2(runs, preferredProject) {
+  if (runs.length === 0) {
+    return null;
+  }
+  return [...runs].sort((left, right) => {
+    const leftPreferred = preferredProject && left.project === preferredProject ? 0 : 1;
+    const rightPreferred = preferredProject && right.project === preferredProject ? 0 : 1;
+    if (leftPreferred !== rightPreferred) {
+      return leftPreferred - rightPreferred;
+    }
+    const rightTime = new Date(right.startedAt).getTime();
+    const leftTime = new Date(left.startedAt).getTime();
+    if (rightTime !== leftTime) {
+      return rightTime - leftTime;
+    }
+    return left.project.localeCompare(right.project);
+  })[0] ?? null;
+}
+function orderedCheckpoints2(checkpoints) {
+  return [...checkpoints].sort((left, right) => {
+    const leftOrder = typeof left.step === "number" ? left.step : Number.MAX_SAFE_INTEGER;
+    const rightOrder = typeof right.step === "number" ? right.step : Number.MAX_SAFE_INTEGER;
+    if (leftOrder !== rightOrder) {
+      return leftOrder - rightOrder;
+    }
+    return checkpoints.indexOf(left) - checkpoints.indexOf(right);
+  });
+}
+function resolveArtifactPath3(run, artifactPath) {
+  return import_node_path3.default.isAbsolute(artifactPath) ? artifactPath : import_node_path3.default.resolve(import_node_path3.default.dirname(run.sourceManifestPath), artifactPath);
+}
+function screenshotSourcePath2(run, checkpoint) {
+  const artifacts = checkpoint.collectors.screenshot?.artifacts ?? [];
+  const artifact = artifacts.find((entry) => entry.name === "screenshot") ?? artifacts[0];
+  return artifact?.path ? resolveArtifactPath3(run, artifact.path) : null;
+}
+function screenshotData3(checkpoint) {
+  const data = checkpoint.collectors.screenshot?.data;
+  return data && typeof data === "object" ? data : null;
+}
+function focusNote2(checkpoint) {
+  const data = screenshotData3(checkpoint);
+  const selector = typeof data?.highlightSelector === "string" ? data.highlightSelector.trim() : "";
+  if (selector) {
+    return `Focus: \`${selector}\``;
+  }
+  const bounds = data?.highlightBounds;
+  if (bounds && typeof bounds.x === "number" && typeof bounds.y === "number" && typeof bounds.width === "number" && typeof bounds.height === "number") {
+    return "Focus: highlighted UI element.";
+  }
+  return null;
+}
+function urlLabel2(url) {
+  try {
+    const parsed = new URL(url);
+    const value = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+    return value || "/";
+  } catch {
+    return url || "/";
+  }
+}
+function autoDescription2(checkpoint) {
+  const pageTitle = checkpoint.title.trim();
+  const location2 = urlLabel2(checkpoint.url);
+  if (pageTitle) {
+    return `This step captures **${pageTitle}** at \`${location2}\`.`;
+  }
+  return `This step captures **${checkpoint.name}** at \`${location2}\`.`;
+}
+function markdownRelativePath2(fromFile, toFile) {
+  const relativePath = import_node_path3.default.relative(import_node_path3.default.dirname(fromFile), toFile).split(import_node_path3.default.sep).join("/");
+  if (relativePath.startsWith(".")) {
+    return relativePath;
+  }
+  return `./${relativePath}`;
+}
+function rewriteImagePath2(mdxFile, imageFile, outputDir, prefix) {
+  const relativePath = import_node_path3.default.relative(outputDir, imageFile).split(import_node_path3.default.sep).join("/");
+  if (prefix) {
+    return `${prefix.replace(/\/+$/g, "")}/${relativePath.replace(/^\/+/, "")}`;
+  }
+  return markdownRelativePath2(mdxFile, imageFile);
+}
+function yamlScalar2(value) {
+  return JSON.stringify(value);
+}
+function serializeFrontmatter2(fields) {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      lines.push(`${key}:`);
+      if (value.length === 0) {
+        lines.push("  []");
+        continue;
+      }
+      for (const item of value) {
+        lines.push(`  - ${yamlScalar2(item)}`);
+      }
+      continue;
+    }
+    lines.push(`${key}: ${yamlScalar2(value)}`);
+  }
+  lines.push("---", "");
+  return lines.join("\n");
+}
+function quoteJsx(value) {
+  return JSON.stringify(value);
+}
+function projectWeight2(projectName) {
+  const index = DEFAULT_PROJECT_ORDER2.indexOf(projectName);
+  return index === -1 ? Number.MAX_SAFE_INTEGER : index;
+}
+function formatProjectLabel2(projectName) {
+  const [device, mode] = projectName.split("-");
+  if (!device || !mode) {
+    return projectName;
+  }
+  const deviceLabel = device === "desktop" ? "Desktop" : device === "mobile" ? "Mobile" : device;
+  const modeLabel = mode === "light" ? "Light" : mode === "dark" ? "Dark" : mode;
+  return `${deviceLabel} / ${modeLabel}`;
+}
+function sortRunsForVariants(runs) {
+  return [...runs].sort((left, right) => {
+    const byWeight = projectWeight2(left.project) - projectWeight2(right.project);
+    if (byWeight !== 0) {
+      return byWeight;
+    }
+    return left.project.localeCompare(right.project);
+  });
+}
+function findMatchingCheckpoint(run, baseCheckpoint, fallbackIndex) {
+  const checkpoints = orderedCheckpoints2(run.checkpoints);
+  if (typeof baseCheckpoint.step === "number") {
+    const byStep = checkpoints.find((entry) => entry.step === baseCheckpoint.step);
+    if (byStep) {
+      return byStep;
+    }
+  }
+  const byName = checkpoints.find((entry) => entry.name === baseCheckpoint.name);
+  if (byName) {
+    return byName;
+  }
+  return checkpoints[fallbackIndex] ?? null;
+}
+async function materializeScreenshot2(args) {
+  const sourcePath = screenshotSourcePath2(args.run, args.checkpoint);
+  if (!sourcePath) {
+    return null;
+  }
+  const extension = import_node_path3.default.extname(sourcePath) || ".png";
+  const targetPath = import_node_path3.default.join(
+    args.outputDir,
+    args.config.screenshotsDir ?? "screenshots",
+    args.storySlug,
+    `${String(args.stepOrder).padStart(2, "0")}-${slugify3(args.run.project)}-${slugify3(args.checkpoint.name)}${extension}`
+  );
+  try {
+    if (args.config.copyScreenshots !== false) {
+      await import_promises3.default.mkdir(import_node_path3.default.dirname(targetPath), { recursive: true });
+      await import_promises3.default.copyFile(sourcePath, targetPath);
+      args.writtenFiles.add(targetPath);
+      return rewriteImagePath2(args.mdxFile, targetPath, args.outputDir, args.config.imagePathPrefix);
+    }
+    return rewriteImagePath2(args.mdxFile, sourcePath, args.outputDir, args.config.imagePathPrefix);
+  } catch {
+    return null;
+  }
+}
+async function buildSteps2(args) {
+  const baseCheckpoints = orderedCheckpoints2(args.primaryRun.checkpoints);
+  const sortedRuns = sortRunsForVariants(args.runs);
+  const steps = [];
+  for (const [index, checkpoint] of baseCheckpoints.entries()) {
+    const order = typeof checkpoint.step === "number" ? checkpoint.step : index + 1;
+    const variants = [];
+    const matchedCheckpoints = [];
+    for (const run of sortedRuns) {
+      const variantCheckpoint = findMatchingCheckpoint(run, checkpoint, index);
+      if (!variantCheckpoint) {
+        continue;
+      }
+      matchedCheckpoints.push(variantCheckpoint);
+      variants.push({
+        project: run.project,
+        projectLabel: formatProjectLabel2(run.project),
+        imagePath: await materializeScreenshot2({
+          run,
+          checkpoint: variantCheckpoint,
+          storySlug: args.storySlug,
+          stepOrder: order,
+          outputDir: args.outputDir,
+          mdxFile: args.mdxFile,
+          config: args.config,
+          writtenFiles: args.writtenFiles
+        }),
+        imageAlt: variantCheckpoint.title || `${checkpoint.name} (${formatProjectLabel2(run.project)})`
+      });
+    }
+    const descriptionSource = matchedCheckpoints.find(
+      (entry) => typeof entry.description === "string" && entry.description.trim().length > 0
+    ) ?? checkpoint;
+    const stepFocus = matchedCheckpoints.map((entry) => focusNote2(entry)).find((value) => Boolean(value)) ?? null;
+    steps.push({
+      checkpoint,
+      order,
+      title: checkpoint.name,
+      description: typeof descriptionSource.description === "string" && descriptionSource.description.trim().length > 0 ? descriptionSource.description.trim() : autoDescription2(descriptionSource),
+      focusNote: stepFocus,
+      variants
+    });
+  }
+  return steps;
+}
+function renderVariantTabs(variants) {
+  if (variants.length === 0) {
+    return "";
+  }
+  if (variants.length === 1) {
+    const [variant] = variants;
+    if (!variant?.imagePath) {
+      return "";
+    }
+    return `<Screenshot src={${quoteJsx(variant.imagePath)}} alt={${quoteJsx(variant.imageAlt)}} />`;
+  }
+  const tabs = variants.map((variant) => {
+    const lines = [`  <DeviceTab label={${quoteJsx(variant.projectLabel)}}>`];
+    if (variant.imagePath) {
+      lines.push(`    <Screenshot src={${quoteJsx(variant.imagePath)}} alt={${quoteJsx(variant.imageAlt)}} />`);
+    } else {
+      lines.push(`    <p>No screenshot captured for ${variant.projectLabel}.</p>`);
+    }
+    lines.push("  </DeviceTab>");
+    return lines.join("\n");
+  }).join("\n");
+  return `<DeviceTabs>
+${tabs}
+</DeviceTabs>`;
+}
+function renderStep(step) {
+  const lines = [`  <Step number={${step.order}} title={${quoteJsx(step.title)}}>`];
+  const variantBlock = renderVariantTabs(step.variants);
+  if (variantBlock) {
+    lines.push(`    ${variantBlock.replace(/\n/g, "\n    ")}`, "");
+  }
+  if (step.focusNote) {
+    lines.push(`    ${step.focusNote}`, "");
+  }
+  lines.push(`    ${step.description}`, "  </Step>");
+  return lines.join("\n");
+}
+function renderMdx(args) {
+  const importNames = /* @__PURE__ */ new Set(["Screenshot", "StepList", "Step"]);
+  if (args.steps.some((step) => step.variants.length > 1)) {
+    importNames.add("DeviceTabs");
+    importNames.add("DeviceTab");
+  }
+  const frontmatter = serializeFrontmatter2({
+    title: args.title,
+    tags: frontmatterTags([...new Set(args.runs.flatMap((run) => run.tags))]),
+    generatedAt: args.generatedAt,
+    projects: [...new Set(args.runs.map((run) => run.project))]
+  });
+  const stepBlocks = args.steps.map(renderStep).join("\n\n");
+  return `${frontmatter}import { ${[...importNames].join(", ")} } from '${args.config.componentImportPath}';
+
+<StepList>
+${stepBlocks}
+</StepList>
+`;
+}
+var import_promises3, import_node_path3, DEFAULT_PROJECT_ORDER2, mdxReporter;
+var init_mdx_reporter = __esm({
+  "src/report/mdx-reporter.ts"() {
+    "use strict";
+    import_promises3 = __toESM(require("fs/promises"), 1);
+    import_node_path3 = __toESM(require("path"), 1);
+    init_story_utils();
+    DEFAULT_PROJECT_ORDER2 = ["desktop-light", "desktop-dark", "mobile-light", "mobile-dark"];
+    mdxReporter = {
+      name: "mdx",
+      description: "Generates one MDX help article per captured story.",
+      validateConfig(config) {
+        return config != null && typeof config === "object" && !Array.isArray(config);
+      },
+      async generate(context) {
+        const config = normalizeConfig2(context.config);
+        const stories = groupByStory(context.runs);
+        const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const writtenFiles = /* @__PURE__ */ new Set();
+        let articleCount = 0;
+        for (const [storyTitle, runs] of stories) {
+          const primaryRun = choosePrimaryRun2(runs, config.preferredProject);
+          if (!primaryRun || !shouldIncludeRun2(primaryRun, config)) {
+            continue;
+          }
+          const title = stripTags2(storyTitle);
+          const storySlug = slugify3(title);
+          const mdxFile = import_node_path3.default.join(context.outputDir, config.storiesDir ?? ".", `${storySlug}.mdx`);
+          const steps = await buildSteps2({
+            runs,
+            primaryRun,
+            storySlug,
+            outputDir: context.outputDir,
+            mdxFile,
+            config,
+            writtenFiles
+          });
+          await import_promises3.default.mkdir(import_node_path3.default.dirname(mdxFile), { recursive: true });
+          await import_promises3.default.writeFile(
+            mdxFile,
+            renderMdx({
+              title,
+              steps,
+              runs,
+              config,
+              generatedAt
+            }),
+            "utf8"
+          );
+          writtenFiles.add(mdxFile);
+          articleCount += 1;
+        }
+        return {
+          files: [...writtenFiles],
+          summary: `Generated ${articleCount} MDX article${articleCount === 1 ? "" : "s"}.`
+        };
+      }
+    };
+  }
+});
+
+// src/report/index.ts
+async function walkFiles(directory) {
+  const dirents = await import_promises4.default.readdir(directory, { withFileTypes: true });
+  const files = [];
+  for (const dirent of dirents) {
+    const absolutePath = import_node_path4.default.join(directory, dirent.name);
+    if (dirent.isDirectory()) {
+      files.push(...await walkFiles(absolutePath));
+      continue;
+    }
+    if (dirent.isFile()) {
+      files.push(absolutePath);
+    }
+  }
+  return files;
+}
+function isCheckpointManifestFile(filePath) {
+  const fileName = import_node_path4.default.basename(filePath);
+  return fileName === "checkpoint-manifest.json" || fileName.startsWith("checkpoint-manifest-") && fileName.endsWith(".json");
+}
+function isCheckpointManifest(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const manifest = value;
+  return typeof manifest.project === "string" && typeof manifest.testId === "string" && typeof manifest.title === "string" && typeof manifest.startedAt === "string" && Array.isArray(manifest.tags) && Array.isArray(manifest.checkpoints);
+}
+function toRunRecord(manifest, sourceManifestPath) {
+  return {
+    key: `${manifest.testId}|${manifest.project}|${manifest.startedAt}`,
+    sourceManifestPath,
+    environment: manifest.environment || "unknown",
+    project: manifest.project,
+    testId: manifest.testId,
+    title: manifest.title,
+    tags: manifest.tags,
+    startedAt: manifest.startedAt,
+    checkpoints: manifest.checkpoints
+  };
+}
+function toManifest(run) {
+  return {
+    environment: run.environment,
+    project: run.project,
+    testId: run.testId,
+    title: run.title,
+    tags: run.tags,
+    startedAt: run.startedAt,
+    checkpoints: run.checkpoints
+  };
+}
+function normalizeReporterConfig(config) {
+  if (config == null || config === false) {
+    return null;
+  }
+  if (config === true) {
+    return {};
+  }
+  return { ...config };
+}
+function registerBuiltinReporter(reporter) {
+  builtinReporters.set(reporter.name, reporter);
+}
+function dedupeRuns(runs) {
+  const map = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    const existing = map.get(run.key);
+    if (!existing) {
+      map.set(run.key, run);
+      continue;
+    }
+    const existingTime = new Date(existing.startedAt).getTime();
+    const currentTime = new Date(run.startedAt).getTime();
+    if (currentTime >= existingTime) {
+      map.set(run.key, run);
+    }
+  }
+  return [...map.values()];
+}
+async function loadRuns(testResultsDir) {
+  let manifestFiles;
+  try {
+    manifestFiles = (await walkFiles(testResultsDir)).filter(isCheckpointManifestFile);
+  } catch {
+    return [];
+  }
+  const runs = [];
+  for (const manifestPath of manifestFiles) {
+    let rawManifest;
+    try {
+      rawManifest = JSON.parse(await import_promises4.default.readFile(manifestPath, "utf8"));
+    } catch {
+      continue;
+    }
+    if (!isCheckpointManifest(rawManifest)) {
+      continue;
+    }
+    runs.push(toRunRecord(rawManifest, manifestPath));
+  }
+  return dedupeRuns(runs);
+}
+async function runReporters(config, testResultsDir, outputDir) {
+  const runs = await loadRuns(testResultsDir);
+  const manifests = runs.map(toManifest);
+  const results = {};
+  const reporterConfigMap = {
+    ...builtinReporterDefaults,
+    ...config.reporters ?? {}
+  };
+  for (const [name, value] of Object.entries(reporterConfigMap)) {
+    const reporterConfig2 = normalizeReporterConfig(value);
+    if (!reporterConfig2) {
+      continue;
+    }
+    const reporter = builtinReporters.get(name);
+    if (!reporter) {
+      throw new Error(`Reporter "${name}" is enabled but no implementation is registered.`);
+    }
+    if (reporter.validateConfig && !reporter.validateConfig(reporterConfig2)) {
+      throw new Error(`Reporter "${name}" received invalid configuration.`);
+    }
+    results[name] = await reporter.generate({
+      runs,
+      outputDir,
+      config: reporterConfig2,
+      manifests
+    });
+  }
+  return results;
+}
+var import_promises4, import_node_path4, builtinReporters, builtinReporterDefaults;
+var init_report = __esm({
+  "src/report/index.ts"() {
+    "use strict";
+    import_promises4 = __toESM(require("fs/promises"), 1);
+    import_node_path4 = __toESM(require("path"), 1);
+    init_html_reporter();
+    init_markdown_reporter();
+    init_mdx_reporter();
+    builtinReporters = /* @__PURE__ */ new Map();
+    builtinReporterDefaults = {
+      html: true,
+      markdown: false,
+      mdx: false
+    };
+    registerBuiltinReporter(htmlReporter);
+    registerBuiltinReporter(markdownReporter);
+    registerBuiltinReporter(mdxReporter);
+  }
+});
+
+// src/mcp/transport.ts
+function serializeMessage(message) {
+  return JSON.stringify(message) + "\n";
+}
+var ReadBuffer, StdioServerTransport;
+var init_transport = __esm({
+  "src/mcp/transport.ts"() {
+    "use strict";
+    ReadBuffer = class {
+      _buffer;
+      append(chunk) {
+        this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
+      }
+      readMessage() {
+        if (!this._buffer) return null;
+        const index = this._buffer.indexOf("\n");
+        if (index === -1) return null;
+        const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, "");
+        this._buffer = this._buffer.subarray(index + 1);
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }
+      clear() {
+        this._buffer = void 0;
+      }
+    };
+    StdioServerTransport = class {
+      _stdin;
+      _stdout;
+      _readBuffer = new ReadBuffer();
+      _started = false;
+      constructor(stdin, stdout) {
+        this._stdin = stdin ?? process.stdin;
+        this._stdout = stdout ?? process.stdout;
+      }
+      onclose;
+      onerror;
+      onmessage;
+      async start() {
+        if (this._started) {
+          throw new Error("StdioServerTransport already started!");
+        }
+        this._started = true;
+        this._stdin.on("data", (chunk) => {
+          this._readBuffer.append(chunk);
+          this.#processReadBuffer();
+        });
+        this._stdin.on("error", (error) => {
+          this.onerror?.(error);
+        });
+      }
+      #processReadBuffer() {
+        while (true) {
+          try {
+            const message = this._readBuffer.readMessage();
+            if (message === null) break;
+            this.onmessage?.(message);
+          } catch (error) {
+            this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+          }
+        }
+      }
+      async close() {
+        this._stdin.pause?.();
+        this._readBuffer.clear();
+        this.onclose?.();
+      }
+      async send(message) {
+        const json = serializeMessage(message);
+        if (this._stdout.write(json)) {
+          return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+          this._stdout.once("drain", resolve);
+        });
+      }
+    };
+  }
+});
+
+// src/mcp/upstream.ts
+function getNodeModuleCreateRequire() {
+  const { createRequire } = require("module");
+  return createRequire(process.cwd() + "/noop.js");
+}
+function resolvePackageJson(pkg) {
+  try {
+    const req = getNodeModuleCreateRequire();
+    return req.resolve(`${pkg}/package.json`);
+  } catch {
+    return null;
+  }
+}
+function resolveUpstream(options) {
+  if (options.upstream) {
+    return options.upstream;
+  }
+  if (resolvePackageJson("@playwright/mcp")) {
+    return "@playwright/mcp";
+  }
+  if (resolvePackageJson("playwright-mcp-advanced")) {
+    return "playwright-mcp-advanced";
+  }
+  return null;
+}
+function injectDebugPort(args) {
+  const hasDebugFlag = args.some(
+    (a) => a.startsWith("--remote-debugging-port") || a.startsWith("--cdp-endpoint")
+  );
+  if (hasDebugFlag) {
+    return args;
+  }
+  return ["--remote-debugging-port=9222", ...args];
+}
+function spawnUpstream(pkg, passthroughArgs) {
+  const npxBin = process.platform === "win32" ? "npx.cmd" : "npx";
+  const npxArgs = [pkg, ...passthroughArgs];
+  const child = (0, import_node_child_process.spawn)(npxBin, npxArgs, {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: {
+      ...process.env,
+      // Prevent npx from prompting or caching in CI
+      NPM_CONFIG_YES: "true",
+      NPM_CONFIG_INTERACTIVE: "false"
+    },
+    shell: false,
+    windowsHide: true
+  });
+  const transport = new ChildProcessTransport(
+    child.stdin,
+    child.stdout,
+    child.stderr,
+    (_msg) => {
+    },
+    () => {
+    }
+  );
+  transport.start();
+  const connection = {
+    process: child,
+    async listTools() {
+      const result = await transport.request("tools/list");
+      return result;
+    },
+    async callTool(name, args) {
+      const result = await transport.request("tools/call", { name, arguments: args ?? {} });
+      return result;
+    },
+    close() {
+      transport.close();
+    }
+  };
+  return connection;
+}
+var import_node_child_process, ChildProcessTransport;
+var init_upstream = __esm({
+  "src/mcp/upstream.ts"() {
+    "use strict";
+    import_node_child_process = require("child_process");
+    ChildProcessTransport = class {
+      constructor(stdin, stdout, stderr, onMessage, onClose) {
+        this.stdin = stdin;
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.onMessage = onMessage;
+        this.onClose = onClose;
+      }
+      stdin;
+      stdout;
+      stderr;
+      onMessage;
+      onClose;
+      pendingRequests = /* @__PURE__ */ new Map();
+      id = 0;
+      start() {
+        let buffer = "";
+        this.stdout.on("data", (chunk) => {
+          buffer += chunk.toString();
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            if (line.trim()) {
+              try {
+                const msg = JSON.parse(line);
+                this.handleMessage(msg);
+              } catch {
+              }
+            }
+          }
+        });
+        this.stdout.on("end", () => {
+          this.onClose?.();
+        });
+        this.stderr?.on("data", (chunk) => {
+          process.stderr.write(chunk);
+        });
+      }
+      handleMessage(msg) {
+        if (msg.id !== void 0) {
+          const pending = this.pendingRequests.get(String(msg.id));
+          if (pending) {
+            this.pendingRequests.delete(String(msg.id));
+            if (msg.error) {
+              pending.reject(new Error(String(msg.error)));
+            } else {
+              pending.resolve(msg.result);
+            }
+          }
+          return;
+        }
+        if (msg.method) {
+          this.onMessage(msg);
+        }
+      }
+      send(message) {
+        const json = JSON.stringify(message) + "\n";
+        this.stdin.write(json);
+      }
+      request(method, params) {
+        const id = String(++this.id);
+        const promise = new Promise((resolve, reject) => {
+          this.pendingRequests.set(id, { resolve, reject });
+        });
+        this.send({ method, params, id });
+        return promise;
+      }
+      close() {
+        this.stdin.end();
+      }
+    };
+  }
+});
+
+// src/mcp/browser-connect.ts
+function extractCdpUrlFromStderr(data) {
+  const match = CDP_WS_REGEX.exec(data);
+  return match ? match[1] ?? null : null;
+}
+async function getUpstreamPage(upstreamProcess, options) {
+  if (cachedConnection) {
+    return cachedConnection;
+  }
+  let cdpEndpoint = options.cdpEndpoint;
+  if (!cdpEndpoint) {
+    if (upstreamProcess?.stderr) {
+      const stderrLines = [];
+      upstreamProcess.stderr.on("data", (chunk) => {
+        stderrLines.push(chunk.toString());
+      });
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      for (const line of stderrLines) {
+        const url = extractCdpUrlFromStderr(line);
+        if (url) {
+          cdpEndpoint = url;
+          break;
+        }
+      }
+    }
+  }
+  if (!cdpEndpoint) {
+    const port = options.debugPort ?? 9222;
+    cdpEndpoint = `http://localhost:${port}`;
+  }
+  const browser = await chromiumConnect(cdpEndpoint);
+  const pages = await browser.contexts()[0]?.pages() ?? [];
+  const page = pages[0] ?? await browser.newPage();
+  cachedConnection = { browser, page };
+  return cachedConnection;
+}
+function getNodeModuleCreateRequire2() {
+  const { createRequire } = require("module");
+  return createRequire(import_meta.url);
+}
+async function chromiumConnect(endpoint) {
+  const req = getNodeModuleCreateRequire2();
+  const pw = req("playwright-core");
+  return pw.chromium.connectOverCDP(endpoint);
+}
+function resetCachedConnection() {
+  cachedConnection = null;
+}
+var import_meta, CDP_WS_REGEX, cachedConnection;
+var init_browser_connect = __esm({
+  "src/mcp/browser-connect.ts"() {
+    "use strict";
+    import_meta = {};
+    CDP_WS_REGEX = /DevTools listening on (ws:\/\/[^\s]+)/;
+    cachedConnection = null;
+  }
+});
+
+// src/collectors/aria-snapshot.ts
+function countSnapshotNodes(value) {
+  if (value == null) {
+    return 0;
+  }
+  if (Array.isArray(value)) {
+    return value.reduce((total, item) => total + countSnapshotNodes(item), 0);
+  }
+  if (typeof value !== "object") {
+    return 1;
+  }
+  const node = value;
+  const children = Array.isArray(node.children) ? node.children : [];
+  return 1 + children.reduce((total, child) => total + countSnapshotNodes(child), 0);
+}
+async function captureAriaSnapshot(page) {
+  try {
+    const root = page.locator(":root");
+    if (typeof root.ariaSnapshot === "function") {
+      const snapshot = await root.ariaSnapshot();
+      return snapshot ?? null;
+    }
+  } catch {
+  }
+  if (typeof page.accessibility?.snapshot === "function") {
+    try {
+      const snapshot = await page.accessibility.snapshot({ interestingOnly: false });
+      return snapshot ?? null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+var import_promises5, import_node_path6, ariaSnapshotCollector;
+var init_aria_snapshot = __esm({
+  "src/collectors/aria-snapshot.ts"() {
+    "use strict";
+    import_promises5 = __toESM(require("fs/promises"), 1);
+    import_node_path6 = __toESM(require("path"), 1);
+    ariaSnapshotCollector = {
+      name: "aria-snapshot",
+      defaultEnabled: false,
+      async collect(ctx) {
+        const snapshot = await captureAriaSnapshot(ctx.page);
+        const nodeCount = countSnapshotNodes(snapshot);
+        const outputPath = import_node_path6.default.join(ctx.checkpointDir, "aria-snapshot.json");
+        const data = {
+          snapshot,
+          nodeCount
+        };
+        await import_promises5.default.writeFile(outputPath, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+        return {
+          data,
+          artifacts: [
+            {
+              name: "aria-snapshot",
+              path: outputPath,
+              contentType: "application/json"
+            }
+          ],
+          summary: {
+            nodeCount
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/page-utils.ts
+async function settlePage(page) {
+  await page.waitForLoadState("domcontentloaded").catch(() => void 0);
+  await page.waitForLoadState("load", { timeout: 3e3 }).catch(() => void 0);
+}
+var init_page_utils = __esm({
+  "src/page-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/collectors/axe.ts
+function warnOnce(message, error) {
+  if (warnedAboutMissingAxe) {
+    return;
+  }
+  warnedAboutMissingAxe = true;
+  if (error instanceof Error) {
+    console.warn(`[playwright-checkpoint] ${message}`, error);
+    return;
+  }
+  if (error !== void 0) {
+    console.warn(`[playwright-checkpoint] ${message}`, String(error));
+    return;
+  }
+  console.warn(`[playwright-checkpoint] ${message}`);
+}
+function resolveAxeBuilder(module2) {
+  return module2.default ?? module2.AxeBuilder ?? null;
+}
+async function analyzeAccessibility(page, AxeBuilder) {
+  try {
+    await settlePage(page);
+    return await new AxeBuilder({ page }).analyze();
+  } catch {
+    await page.waitForTimeout(500);
+    await settlePage(page);
+    return await new AxeBuilder({ page }).analyze();
+  }
+}
+function skippedAxeResult(reason) {
+  return {
+    data: {
+      skipped: true,
+      reason,
+      violations: 0,
+      results: null
+    },
+    artifacts: [],
+    summary: {
+      violations: 0
+    }
+  };
+}
+var import_promises6, import_node_path7, axeLoader, warnedAboutMissingAxe, axeCollector;
+var init_axe = __esm({
+  "src/collectors/axe.ts"() {
+    "use strict";
+    import_promises6 = __toESM(require("fs/promises"), 1);
+    import_node_path7 = __toESM(require("path"), 1);
+    init_page_utils();
+    axeLoader = () => import("@axe-core/playwright");
+    warnedAboutMissingAxe = false;
+    axeCollector = {
+      name: "axe",
+      defaultEnabled: true,
+      async collect(ctx) {
+        const timeoutBudgetMs = typeof ctx.config.timeoutMs === "number" ? ctx.config.timeoutMs : 5e3;
+        if (timeoutBudgetMs > 0) {
+          if (typeof ctx.adjustTimeout === "function") {
+            ctx.adjustTimeout(timeoutBudgetMs);
+          } else if (ctx.testInfo && typeof ctx.testInfo.setTimeout === "function") {
+            ctx.testInfo.setTimeout(ctx.testInfo.timeout + timeoutBudgetMs);
+          }
+        }
+        let module2;
+        try {
+          module2 = await axeLoader();
+        } catch (error) {
+          warnOnce("Skipping axe collector because @axe-core/playwright is unavailable.", error);
+          return skippedAxeResult("@axe-core/playwright is unavailable");
+        }
+        const AxeBuilder = resolveAxeBuilder(module2);
+        if (!AxeBuilder) {
+          warnOnce("Skipping axe collector because @axe-core/playwright did not expose an AxeBuilder export.");
+          return skippedAxeResult("@axe-core/playwright did not expose AxeBuilder");
+        }
+        const results = await analyzeAccessibility(ctx.page, AxeBuilder);
+        const violations = results && typeof results === "object" && Array.isArray(results.violations) ? results.violations.length : 0;
+        const axePath = import_node_path7.default.join(ctx.checkpointDir, "axe.json");
+        await import_promises6.default.writeFile(axePath, `${JSON.stringify(results, null, 2)}
+`, "utf8");
+        return {
+          data: {
+            skipped: false,
+            reason: null,
+            violations,
+            results
+          },
+          artifacts: [
+            {
+              name: "axe",
+              path: axePath,
+              contentType: "application/json"
+            }
+          ],
+          summary: {
+            violations
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/collectors/console.ts
+function getLocation(message) {
+  const location2 = message.location();
+  if (!location2.url && location2.lineNumber == null && location2.columnNumber == null) {
+    return null;
+  }
+  return {
+    ...location2.url ? { url: location2.url } : {},
+    ...location2.lineNumber == null ? {} : { lineNumber: location2.lineNumber },
+    ...location2.columnNumber == null ? {} : { columnNumber: location2.columnNumber }
+  };
+}
+var import_promises7, import_node_path8, consoleStates, consoleCollector;
+var init_console = __esm({
+  "src/collectors/console.ts"() {
+    "use strict";
+    import_promises7 = __toESM(require("fs/promises"), 1);
+    import_node_path8 = __toESM(require("path"), 1);
+    consoleStates = /* @__PURE__ */ new WeakMap();
+    consoleCollector = {
+      name: "console",
+      defaultEnabled: true,
+      async setup({ page }) {
+        if (consoleStates.has(page)) {
+          return;
+        }
+        const entries = [];
+        const recordConsoleMessage = (message) => {
+          if (message.type() !== "error") {
+            return;
+          }
+          entries.push({
+            type: message.type(),
+            text: message.text(),
+            location: getLocation(message),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        };
+        const recordPageError = (error) => {
+          entries.push({
+            type: "pageerror",
+            text: error.message,
+            location: null,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        };
+        page.on("console", recordConsoleMessage);
+        page.on("pageerror", recordPageError);
+        consoleStates.set(page, {
+          entries,
+          offset: 0,
+          recordConsoleMessage,
+          recordPageError
+        });
+      },
+      async collect(ctx) {
+        const state = consoleStates.get(ctx.page);
+        const checkpointEntries = state ? state.entries.slice(state.offset) : [];
+        if (state) {
+          state.offset = state.entries.length;
+        }
+        const outputPath = import_node_path8.default.join(ctx.checkpointDir, "console-errors.json");
+        await import_promises7.default.writeFile(outputPath, `${JSON.stringify(checkpointEntries, null, 2)}
+`, "utf8");
+        return {
+          data: checkpointEntries,
+          artifacts: [
+            {
+              name: "console-errors",
+              path: outputPath,
+              contentType: "application/json"
+            }
+          ],
+          summary: {
+            consoleErrorCount: checkpointEntries.length
+          }
+        };
+      },
+      async teardown({ page }) {
+        const state = consoleStates.get(page);
+        if (!state) {
+          return;
+        }
+        page.off("console", state.recordConsoleMessage);
+        page.off("pageerror", state.recordPageError);
+        consoleStates.delete(page);
+      }
+    };
+  }
+});
+
+// src/collectors/dom-stats.ts
+var import_promises8, import_node_path9, domStatsCollector;
+var init_dom_stats = __esm({
+  "src/collectors/dom-stats.ts"() {
+    "use strict";
+    import_promises8 = __toESM(require("fs/promises"), 1);
+    import_node_path9 = __toESM(require("path"), 1);
+    domStatsCollector = {
+      name: "dom-stats",
+      defaultEnabled: false,
+      async collect(ctx) {
+        const stats = await ctx.page.evaluate(() => {
+          const allNodes = document.querySelectorAll("*");
+          const maxDepthFrom = (root) => {
+            if (!root) {
+              return 0;
+            }
+            let maxDepth = 1;
+            const queue = [{ node: root, depth: 1 }];
+            while (queue.length > 0) {
+              const current = queue.shift();
+              if (!current) {
+                continue;
+              }
+              maxDepth = Math.max(maxDepth, current.depth);
+              for (const child of Array.from(current.node.children)) {
+                queue.push({ node: child, depth: current.depth + 1 });
+              }
+            }
+            return maxDepth;
+          };
+          const maybeGetEventListeners = globalThis.getEventListeners;
+          let eventListenerCount = null;
+          if (typeof maybeGetEventListeners === "function") {
+            eventListenerCount = 0;
+            const targets = [window, document, ...Array.from(allNodes)];
+            for (const target of targets) {
+              try {
+                const listeners = maybeGetEventListeners(target) ?? {};
+                for (const entries of Object.values(listeners)) {
+                  eventListenerCount += Array.isArray(entries) ? entries.length : 0;
+                }
+              } catch {
+              }
+            }
+          }
+          return {
+            nodeCount: allNodes.length,
+            maxDepth: maxDepthFrom(document.documentElement),
+            formCount: document.querySelectorAll("form").length,
+            imageCount: document.querySelectorAll("img").length,
+            scriptCount: document.querySelectorAll("script").length,
+            stylesheetCount: document.styleSheets.length,
+            eventListenerCount
+          };
+        });
+        const data = {
+          nodeCount: stats.nodeCount,
+          maxDepth: stats.maxDepth,
+          formCount: stats.formCount,
+          imageCount: stats.imageCount,
+          scriptCount: stats.scriptCount,
+          stylesheetCount: stats.stylesheetCount,
+          eventListenerCount: stats.eventListenerCount
+        };
+        const outputPath = import_node_path9.default.join(ctx.checkpointDir, "dom-stats.json");
+        await import_promises8.default.writeFile(outputPath, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+        return {
+          data,
+          artifacts: [
+            {
+              name: "dom-stats",
+              path: outputPath,
+              contentType: "application/json"
+            }
+          ],
+          summary: {
+            nodeCount: data.nodeCount,
+            maxDepth: data.maxDepth,
+            formCount: data.formCount,
+            imageCount: data.imageCount
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/collectors/forms.ts
+function toRegex(pattern) {
+  const trimmed = pattern.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    return new RegExp(trimmed, "i");
+  } catch {
+    return null;
+  }
+}
+function redactionRegexes(ctx) {
+  const fromConfig = Array.isArray(ctx.config.redact) ? ctx.config.redact.filter((entry) => typeof entry === "string") : [];
+  return [...DEFAULT_REDACT_PATTERNS, ...ctx.redact, ...fromConfig].map((pattern) => toRegex(pattern)).filter((value) => value instanceof RegExp);
+}
+function shouldRedactText(value, regexes) {
+  if (EMAIL_LIKE_REGEX.test(value.trim())) {
+    return true;
+  }
+  return regexes.some((regex) => regex.test(value));
+}
+function fieldIdentifier(field) {
+  return [field.type, field.name, field.id, field.label, field.placeholder].filter((value) => !!value).join(" ");
+}
+function redactValue(value) {
+  if (value == null) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(() => REDACTED);
+  }
+  return REDACTED;
+}
+function fieldNeedsRedaction(field, regexes) {
+  if (shouldRedactText(fieldIdentifier(field), regexes)) {
+    return true;
+  }
+  if (field.value == null) {
+    return false;
+  }
+  if (Array.isArray(field.value)) {
+    return field.value.some((entry) => shouldRedactText(entry, regexes));
+  }
+  return shouldRedactText(field.value, regexes);
+}
+var import_promises9, import_node_path10, REDACTED, DEFAULT_REDACT_PATTERNS, EMAIL_LIKE_REGEX, formsCollector;
+var init_forms = __esm({
+  "src/collectors/forms.ts"() {
+    "use strict";
+    import_promises9 = __toESM(require("fs/promises"), 1);
+    import_node_path10 = __toESM(require("path"), 1);
+    REDACTED = "[REDACTED]";
+    DEFAULT_REDACT_PATTERNS = ["password", "token", "secret", "api[_-]?key", "authorization", "bearer"];
+    EMAIL_LIKE_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    formsCollector = {
+      name: "forms",
+      defaultEnabled: false,
+      async collect(ctx) {
+        const rawFields = await ctx.page.evaluate(() => {
+          const elements = Array.from(document.querySelectorAll("input, select, textarea"));
+          const isVisible = (element) => {
+            if (!(element instanceof HTMLElement)) {
+              return false;
+            }
+            const inputType = element instanceof HTMLInputElement ? element.type.toLowerCase() : null;
+            if (inputType === "hidden") {
+              return false;
+            }
+            if (element.hasAttribute("hidden") || element.getAttribute("aria-hidden") === "true") {
+              return false;
+            }
+            const style = window.getComputedStyle(element);
+            if (style.display === "none" || style.visibility === "hidden" || Number(style.opacity) === 0) {
+              return false;
+            }
+            const rect = element.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+          };
+          const readLabel = (element) => {
+            if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement) {
+              const fromLabels = element.labels && element.labels.length > 0 ? element.labels[0]?.textContent?.trim() : null;
+              if (fromLabels) {
+                return fromLabels;
+              }
+            }
+            return element.getAttribute("aria-label")?.trim() ?? null;
+          };
+          const readValue = (element) => {
+            if (element instanceof HTMLSelectElement) {
+              if (element.multiple) {
+                return {
+                  value: Array.from(element.selectedOptions).map((option) => option.value),
+                  checked: null,
+                  type: "select-multiple"
+                };
+              }
+              return {
+                value: element.value,
+                checked: null,
+                type: "select-one"
+              };
+            }
+            if (element instanceof HTMLTextAreaElement) {
+              return {
+                value: element.value,
+                checked: null,
+                type: "textarea"
+              };
+            }
+            if (element instanceof HTMLInputElement) {
+              const inputType = element.type.toLowerCase();
+              if (inputType === "checkbox" || inputType === "radio") {
+                return {
+                  value: element.checked ? element.value || "on" : null,
+                  checked: element.checked,
+                  type: inputType
+                };
+              }
+              if (inputType === "file") {
+                return {
+                  value: element.files ? Array.from(element.files).map((file) => file.name) : [],
+                  checked: null,
+                  type: inputType
+                };
+              }
+              return {
+                value: element.value,
+                checked: null,
+                type: inputType || null
+              };
+            }
+            return {
+              value: null,
+              checked: null,
+              type: null
+            };
+          };
+          return elements.filter((element) => isVisible(element)).map((element) => {
+            const { value, checked, type } = readValue(element);
+            return {
+              tagName: element.tagName.toLowerCase(),
+              type,
+              name: element.getAttribute("name"),
+              id: element.getAttribute("id"),
+              label: readLabel(element),
+              placeholder: element.getAttribute("placeholder"),
+              value,
+              checked,
+              disabled: element.disabled,
+              required: element.required
+            };
+          });
+        });
+        const regexes = redactionRegexes({ redact: ctx.redact, config: ctx.config });
+        let redactedCount = 0;
+        const fields = rawFields.map((field) => {
+          const redacted = fieldNeedsRedaction(field, regexes);
+          if (redacted) {
+            redactedCount += 1;
+          }
+          return {
+            ...field,
+            redacted,
+            value: redacted ? redactValue(field.value) : field.value
+          };
+        });
+        const data = {
+          fieldCount: fields.length,
+          redactedCount,
+          fields
+        };
+        const outputPath = import_node_path10.default.join(ctx.checkpointDir, "form-state.json");
+        await import_promises9.default.writeFile(outputPath, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+        return {
+          data,
+          artifacts: [
+            {
+              name: "form-state",
+              path: outputPath,
+              contentType: "application/json"
+            }
+          ],
+          summary: {
+            fieldCount: data.fieldCount,
+            redactedCount: data.redactedCount
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/collectors/html.ts
+async function readPageContent(page) {
+  try {
+    await settlePage(page);
+    return await page.content();
+  } catch {
+    await page.waitForTimeout(500);
+    await settlePage(page);
+    return await page.content();
+  }
+}
+var import_promises10, import_node_path11, htmlCollector;
+var init_html = __esm({
+  "src/collectors/html.ts"() {
+    "use strict";
+    import_promises10 = __toESM(require("fs/promises"), 1);
+    import_node_path11 = __toESM(require("path"), 1);
+    init_page_utils();
+    htmlCollector = {
+      name: "html",
+      defaultEnabled: true,
+      async collect(ctx) {
+        const htmlPath = import_node_path11.default.join(ctx.checkpointDir, "page.html");
+        const html = await readPageContent(ctx.page);
+        await import_promises10.default.writeFile(htmlPath, html, "utf8");
+        return {
+          data: {
+            contentLength: html.length
+          },
+          artifacts: [
+            {
+              name: "html",
+              path: htmlPath,
+              contentType: "text/html"
+            }
+          ],
+          summary: {
+            htmlPath: "page.html"
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/collectors/metadata.ts
+function normalizeStructuredData(scriptContents) {
+  const values = [];
+  for (const content of scriptContents) {
+    const value = content?.trim();
+    if (!value) {
+      continue;
+    }
+    try {
+      values.push(JSON.parse(value));
+    } catch {
+      values.push({
+        parseError: "Invalid JSON-LD",
+        raw: value
+      });
+    }
+  }
+  return values;
+}
+var import_promises11, import_node_path12, metadataCollector;
+var init_metadata = __esm({
+  "src/collectors/metadata.ts"() {
+    "use strict";
+    import_promises11 = __toESM(require("fs/promises"), 1);
+    import_node_path12 = __toESM(require("path"), 1);
+    metadataCollector = {
+      name: "metadata",
+      defaultEnabled: true,
+      async collect(ctx) {
+        const metadata = await ctx.page.evaluate(() => {
+          const meta = (selector) => document.querySelector(selector)?.getAttribute("content") ?? null;
+          const canonicalLink = document.querySelector('link[rel="canonical"]');
+          const html = document.documentElement;
+          const structuredDataScripts = Array.from(document.querySelectorAll('script[type="application/ld+json"]')).map((script) => script.textContent ?? null);
+          return {
+            url: location.href,
+            title: document.title,
+            description: meta('meta[name="description"]'),
+            openGraph: {
+              title: meta('meta[property="og:title"]'),
+              description: meta('meta[property="og:description"]'),
+              image: meta('meta[property="og:image"]')
+            },
+            canonicalUrl: canonicalLink?.getAttribute("href") ?? null,
+            lang: html.getAttribute("lang"),
+            viewport: meta('meta[name="viewport"]'),
+            structuredDataScripts
+          };
+        });
+        const normalizedMetadata = {
+          url: metadata.url,
+          title: metadata.title,
+          description: metadata.description,
+          openGraph: metadata.openGraph,
+          canonicalUrl: metadata.canonicalUrl,
+          lang: metadata.lang,
+          viewport: metadata.viewport,
+          structuredData: normalizeStructuredData(metadata.structuredDataScripts)
+        };
+        const outputPath = import_node_path12.default.join(ctx.checkpointDir, "metadata.json");
+        await import_promises11.default.writeFile(outputPath, `${JSON.stringify(normalizedMetadata, null, 2)}
+`, "utf8");
+        return {
+          data: normalizedMetadata,
+          artifacts: [
+            {
+              name: "metadata",
+              path: outputPath,
+              contentType: "application/json"
+            }
+          ],
+          summary: {
+            url: normalizedMetadata.url,
+            title: normalizedMetadata.title,
+            lang: normalizedMetadata.lang
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/collectors/network.ts
+var import_promises12, import_node_path13, networkStates, networkCollector;
+var init_network = __esm({
+  "src/collectors/network.ts"() {
+    "use strict";
+    import_promises12 = __toESM(require("fs/promises"), 1);
+    import_node_path13 = __toESM(require("path"), 1);
+    networkStates = /* @__PURE__ */ new WeakMap();
+    networkCollector = {
+      name: "network",
+      defaultEnabled: true,
+      async setup({ page }) {
+        if (networkStates.has(page)) {
+          return;
+        }
+        const entries = [];
+        const recordRequestFailure = (request) => {
+          entries.push({
+            kind: "requestfailed",
+            url: request.url(),
+            method: request.method(),
+            status: null,
+            statusText: null,
+            failureText: request.failure()?.errorText ?? null,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        };
+        const recordHttpError = (response) => {
+          if (response.status() < 400) {
+            return;
+          }
+          entries.push({
+            kind: "http-error",
+            url: response.url(),
+            method: response.request().method(),
+            status: response.status(),
+            statusText: response.statusText(),
+            failureText: null,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        };
+        page.on("requestfailed", recordRequestFailure);
+        page.on("response", recordHttpError);
+        networkStates.set(page, {
+          entries,
+          offset: 0,
+          recordRequestFailure,
+          recordHttpError
+        });
+      },
+      async collect(ctx) {
+        const state = networkStates.get(ctx.page);
+        const checkpointEntries = state ? state.entries.slice(state.offset) : [];
+        if (state) {
+          state.offset = state.entries.length;
+        }
+        const outputPath = import_node_path13.default.join(ctx.checkpointDir, "failed-requests.json");
+        await import_promises12.default.writeFile(outputPath, `${JSON.stringify(checkpointEntries, null, 2)}
+`, "utf8");
+        return {
+          data: checkpointEntries,
+          artifacts: [
+            {
+              name: "failed-requests",
+              path: outputPath,
+              contentType: "application/json"
+            }
+          ],
+          summary: {
+            failedRequestCount: checkpointEntries.length
+          }
+        };
+      },
+      async teardown({ page }) {
+        const state = networkStates.get(page);
+        if (!state) {
+          return;
+        }
+        page.off("requestfailed", state.recordRequestFailure);
+        page.off("response", state.recordHttpError);
+        networkStates.delete(page);
+      }
+    };
+  }
+});
+
+// src/collectors/network-timing.ts
+function maybeDuration(start, end) {
+  if (start <= 0 || end <= 0 || end < start) {
+    return null;
+  }
+  return end - start;
+}
+function toNetworkRecord(response, timing) {
+  return {
+    url: response.url,
+    status: response.status,
+    statusText: response.statusText,
+    resourceType: response.resourceType,
+    timestamp: response.timestamp,
+    durationMs: timing ? timing.duration : null,
+    transferSize: timing ? timing.transferSize : null,
+    encodedBodySize: timing ? timing.encodedBodySize : null,
+    decodedBodySize: timing ? timing.decodedBodySize : null,
+    nextHopProtocol: timing ? timing.nextHopProtocol || null : null,
+    timing: {
+      startTimeMs: timing ? timing.startTime : null,
+      redirectMs: timing ? maybeDuration(timing.redirectStart, timing.redirectEnd) : null,
+      dnsMs: timing ? maybeDuration(timing.domainLookupStart, timing.domainLookupEnd) : null,
+      connectMs: timing ? maybeDuration(timing.connectStart, timing.connectEnd) : null,
+      tlsMs: timing ? maybeDuration(timing.secureConnectionStart, timing.connectEnd) : null,
+      requestMs: timing ? maybeDuration(timing.requestStart, timing.responseStart) : null,
+      responseMs: timing ? maybeDuration(timing.responseStart, timing.responseEnd) : null
+    }
+  };
+}
+var import_promises13, import_node_path14, timingStates, networkTimingCollector;
+var init_network_timing = __esm({
+  "src/collectors/network-timing.ts"() {
+    "use strict";
+    import_promises13 = __toESM(require("fs/promises"), 1);
+    import_node_path14 = __toESM(require("path"), 1);
+    timingStates = /* @__PURE__ */ new WeakMap();
+    networkTimingCollector = {
+      name: "network-timing",
+      defaultEnabled: false,
+      async setup({ page }) {
+        if (timingStates.has(page)) {
+          return;
+        }
+        const responses = [];
+        const recordResponse = (response) => {
+          responses.push({
+            url: response.url(),
+            status: response.status(),
+            statusText: response.statusText(),
+            resourceType: response.request().resourceType(),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        };
+        page.on("response", recordResponse);
+        timingStates.set(page, {
+          responses,
+          responseOffset: 0,
+          resourceOffsetByUrl: /* @__PURE__ */ new Map(),
+          recordResponse
+        });
+      },
+      async collect(ctx) {
+        const state = timingStates.get(ctx.page);
+        const recentResponses = state ? state.responses.slice(state.responseOffset) : [];
+        if (state) {
+          state.responseOffset = state.responses.length;
+        }
+        const resourceTimings = await ctx.page.evaluate(() => {
+          const entries = performance.getEntriesByType("resource");
+          return entries.map((entry) => ({
+            name: entry.name,
+            duration: entry.duration,
+            transferSize: entry.transferSize,
+            encodedBodySize: entry.encodedBodySize,
+            decodedBodySize: entry.decodedBodySize,
+            nextHopProtocol: entry.nextHopProtocol,
+            startTime: entry.startTime,
+            redirectStart: entry.redirectStart,
+            redirectEnd: entry.redirectEnd,
+            domainLookupStart: entry.domainLookupStart,
+            domainLookupEnd: entry.domainLookupEnd,
+            connectStart: entry.connectStart,
+            connectEnd: entry.connectEnd,
+            secureConnectionStart: entry.secureConnectionStart,
+            requestStart: entry.requestStart,
+            responseStart: entry.responseStart,
+            responseEnd: entry.responseEnd
+          }));
+        });
+        const timingsByUrl = /* @__PURE__ */ new Map();
+        for (const timing of resourceTimings) {
+          const list = timingsByUrl.get(timing.name);
+          if (list) {
+            list.push(timing);
+          } else {
+            timingsByUrl.set(timing.name, [timing]);
+          }
+        }
+        const requests = recentResponses.map((response) => {
+          if (!state) {
+            return toNetworkRecord(response, null);
+          }
+          const list = timingsByUrl.get(response.url) ?? [];
+          const currentOffset = state.resourceOffsetByUrl.get(response.url) ?? 0;
+          const match = list[currentOffset] ?? null;
+          if (match) {
+            state.resourceOffsetByUrl.set(response.url, currentOffset + 1);
+          }
+          return toNetworkRecord(response, match);
+        });
+        const totalBytes = requests.reduce((total, request) => {
+          if (typeof request.transferSize !== "number" || request.transferSize < 0) {
+            return total;
+          }
+          return total + request.transferSize;
+        }, 0);
+        const slowestRequestMs = requests.reduce((slowest, request) => {
+          if (typeof request.durationMs !== "number") {
+            return slowest;
+          }
+          return Math.max(slowest, request.durationMs);
+        }, 0);
+        const data = {
+          requestCount: requests.length,
+          totalBytes,
+          slowestRequestMs,
+          requests
+        };
+        const outputPath = import_node_path14.default.join(ctx.checkpointDir, "network-timing.json");
+        await import_promises13.default.writeFile(outputPath, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+        return {
+          data,
+          artifacts: [
+            {
+              name: "network-timing",
+              path: outputPath,
+              contentType: "application/json"
+            }
+          ],
+          summary: {
+            requestCount: data.requestCount,
+            totalBytes: data.totalBytes,
+            slowestRequestMs: data.slowestRequestMs
+          }
+        };
+      },
+      async teardown({ page }) {
+        const state = timingStates.get(page);
+        if (!state) {
+          return;
+        }
+        page.off("response", state.recordResponse);
+        timingStates.delete(page);
+      }
+    };
+  }
+});
+
+// src/collectors/screenshot.ts
+function readPngSize(buffer) {
+  if (buffer.length < 24 || !buffer.subarray(0, 8).equals(PNG_SIGNATURE)) {
+    return null;
+  }
+  if (buffer.toString("ascii", 12, 16) !== "IHDR") {
+    return null;
+  }
+  return {
+    width: buffer.readUInt32BE(16),
+    height: buffer.readUInt32BE(20)
+  };
+}
+var import_node_path15, PNG_SIGNATURE, screenshotCollector;
+var init_screenshot = __esm({
+  "src/collectors/screenshot.ts"() {
+    "use strict";
+    import_node_path15 = __toESM(require("path"), 1);
+    PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+    screenshotCollector = {
+      name: "screenshot",
+      defaultEnabled: true,
+      async collect(ctx) {
+        const fullPage = ctx.options.fullPage ?? true;
+        const screenshotPath = import_node_path15.default.join(ctx.checkpointDir, "page.png");
+        const screenshotBuffer = await ctx.page.screenshot({ path: screenshotPath, fullPage });
+        let highlightBounds = null;
+        if (ctx.options.highlightSelector) {
+          highlightBounds = await ctx.page.locator(ctx.options.highlightSelector).boundingBox().catch(() => null);
+        }
+        return {
+          data: {
+            fullPage,
+            highlightBounds,
+            highlightSelector: ctx.options.highlightSelector ?? null,
+            imageSize: Buffer.isBuffer(screenshotBuffer) ? readPngSize(screenshotBuffer) : null
+          },
+          artifacts: [
+            {
+              name: "screenshot",
+              path: screenshotPath,
+              contentType: "image/png"
+            }
+          ],
+          summary: {
+            screenshotPath: "page.png"
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/collectors/storage.ts
+function toRegex2(pattern) {
+  const trimmed = pattern.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    return new RegExp(trimmed, "i");
+  } catch {
+    return null;
+  }
+}
+function buildRedactionRegexes(ctx) {
+  const fromConfig = Array.isArray(ctx.config.redact) ? ctx.config.redact.filter((entry) => typeof entry === "string") : [];
+  return [...DEFAULT_REDACT_PATTERNS2, ...ctx.redact, ...fromConfig].map((pattern) => toRegex2(pattern)).filter((value) => value instanceof RegExp);
+}
+function shouldRedact(identifier, value, regexes) {
+  if (regexes.some((regex) => regex.test(identifier))) {
+    return true;
+  }
+  if (!value) {
+    return false;
+  }
+  if (EMAIL_LIKE_REGEX2.test(value.trim())) {
+    return true;
+  }
+  return regexes.some((regex) => regex.test(value));
+}
+var import_promises14, import_node_path16, REDACTED2, DEFAULT_REDACT_PATTERNS2, EMAIL_LIKE_REGEX2, storageCollector;
+var init_storage = __esm({
+  "src/collectors/storage.ts"() {
+    "use strict";
+    import_promises14 = __toESM(require("fs/promises"), 1);
+    import_node_path16 = __toESM(require("path"), 1);
+    REDACTED2 = "[REDACTED]";
+    DEFAULT_REDACT_PATTERNS2 = ["password", "token", "secret", "api[_-]?key", "authorization", "session", "email"];
+    EMAIL_LIKE_REGEX2 = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    storageCollector = {
+      name: "storage",
+      defaultEnabled: false,
+      async collect(ctx) {
+        const includeCookieValues = ctx.config.includeCookieValues === true;
+        const includeLocalStorageValues = ctx.config.includeLocalStorageValues === true;
+        const redactValues = ctx.config.redactValues !== false;
+        const regexes = buildRedactionRegexes({ redact: ctx.redact, config: ctx.config });
+        const cookies = await ctx.page.context().cookies();
+        const localStorageEntries = await ctx.page.evaluate(
+          () => Object.keys(localStorage).map((key) => ({
+            key,
+            value: localStorage.getItem(key) ?? ""
+          }))
+        );
+        const normalizedCookies = cookies.map((cookie) => {
+          const rawValue = includeCookieValues ? cookie.value : null;
+          const redacted = redactValues && shouldRedact(cookie.name, rawValue, regexes);
+          return {
+            name: cookie.name,
+            domain: cookie.domain,
+            path: cookie.path,
+            value: rawValue == null ? null : redacted ? REDACTED2 : rawValue,
+            redacted,
+            expires: cookie.expires,
+            httpOnly: cookie.httpOnly,
+            secure: cookie.secure,
+            sameSite: cookie.sameSite
+          };
+        });
+        const normalizedLocalStorage = localStorageEntries.map((entry) => {
+          const rawValue = includeLocalStorageValues ? entry.value : null;
+          const redacted = redactValues && shouldRedact(entry.key, rawValue, regexes);
+          return {
+            key: entry.key,
+            value: rawValue == null ? null : redacted ? REDACTED2 : rawValue,
+            redacted
+          };
+        });
+        const data = {
+          cookieCount: normalizedCookies.length,
+          localStorageKeyCount: normalizedLocalStorage.length,
+          cookies: normalizedCookies,
+          localStorage: normalizedLocalStorage
+        };
+        const outputPath = import_node_path16.default.join(ctx.checkpointDir, "storage-state.json");
+        await import_promises14.default.writeFile(outputPath, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+        return {
+          data,
+          artifacts: [
+            {
+              name: "storage-state",
+              path: outputPath,
+              contentType: "application/json"
+            }
+          ],
+          summary: {
+            cookieCount: data.cookieCount,
+            localStorageKeyCount: data.localStorageKeyCount
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/collectors/web-vitals.ts
+function rateMetric(value, thresholds) {
+  if (value == null || Number.isNaN(value)) {
+    return "unknown";
+  }
+  if (value <= thresholds.good) {
+    return "good";
+  }
+  if (value <= thresholds.needsImprovement) {
+    return "needs-improvement";
+  }
+  return "poor";
+}
+function metric(value, thresholds) {
+  return {
+    value,
+    rating: rateMetric(value, thresholds)
+  };
+}
+async function captureWebVitals(page) {
+  const raw = await page.evaluate(() => {
+    const globalState = globalThis;
+    const state = globalState.__e2eWebVitals ?? {
+      cls: 0,
+      fcp: null,
+      lcp: null,
+      inp: null
+    };
+    const navigation = performance.getEntriesByType("navigation")[0];
+    return {
+      cls: state.cls,
+      fcp: state.fcp,
+      lcp: state.lcp,
+      inp: state.inp,
+      ttfb: navigation ? navigation.responseStart : null,
+      domContentLoaded: navigation ? navigation.domContentLoadedEventEnd : null,
+      loadEvent: navigation ? navigation.loadEventEnd : null,
+      url: location.href
+    };
+  });
+  return {
+    url: raw.url,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cls: metric(raw.cls, { good: 0.1, needsImprovement: 0.25 }),
+    fcpMs: metric(raw.fcp, { good: 1800, needsImprovement: 3e3 }),
+    lcpMs: metric(raw.lcp, { good: 2500, needsImprovement: 4e3 }),
+    inpMs: metric(raw.inp, { good: 200, needsImprovement: 500 }),
+    ttfbMs: metric(raw.ttfb, { good: 800, needsImprovement: 1800 }),
+    domContentLoadedMs: raw.domContentLoaded,
+    loadEventMs: raw.loadEvent
+  };
+}
+var import_promises15, import_node_path17, initializedPages, webVitalsCollector;
+var init_web_vitals = __esm({
+  "src/collectors/web-vitals.ts"() {
+    "use strict";
+    import_promises15 = __toESM(require("fs/promises"), 1);
+    import_node_path17 = __toESM(require("path"), 1);
+    initializedPages = /* @__PURE__ */ new WeakSet();
+    webVitalsCollector = {
+      name: "web-vitals",
+      defaultEnabled: true,
+      async setup({ page }) {
+        if (initializedPages.has(page)) {
+          return;
+        }
+        initializedPages.add(page);
+        await page.addInitScript(() => {
+          const globalState = globalThis;
+          if (!globalState.__e2eWebVitals) {
+            globalState.__e2eWebVitals = {
+              cls: 0,
+              fcp: null,
+              lcp: null,
+              inp: null
+            };
+          }
+          const state = globalState.__e2eWebVitals;
+          try {
+            const paintObserver = new PerformanceObserver((entryList) => {
+              for (const entry of entryList.getEntries()) {
+                if (entry.name === "first-contentful-paint") {
+                  state.fcp = entry.startTime;
+                }
+              }
+            });
+            paintObserver.observe({ type: "paint", buffered: true });
+          } catch {
+          }
+          try {
+            const lcpObserver = new PerformanceObserver((entryList) => {
+              const entries = entryList.getEntries();
+              const lastEntry = entries[entries.length - 1];
+              if (lastEntry) {
+                state.lcp = lastEntry.startTime;
+              }
+            });
+            lcpObserver.observe({ type: "largest-contentful-paint", buffered: true });
+            addEventListener("pagehide", () => lcpObserver.disconnect(), { once: true });
+          } catch {
+          }
+          try {
+            const clsObserver = new PerformanceObserver((entryList) => {
+              for (const entry of entryList.getEntries()) {
+                if (!entry.hadRecentInput) {
+                  state.cls += entry.value ?? 0;
+                }
+              }
+            });
+            clsObserver.observe({ type: "layout-shift", buffered: true });
+            addEventListener("pagehide", () => clsObserver.disconnect(), { once: true });
+          } catch {
+          }
+          try {
+            const inpObserver = new PerformanceObserver((entryList) => {
+              for (const entry of entryList.getEntries()) {
+                const duration = entry.duration ?? 0;
+                if (state.inp == null || duration > state.inp) {
+                  state.inp = duration;
+                }
+              }
+            });
+            inpObserver.observe({ type: "event", buffered: true, durationThreshold: 40 });
+            addEventListener("pagehide", () => inpObserver.disconnect(), { once: true });
+          } catch {
+          }
+        });
+      },
+      async collect(ctx) {
+        const snapshot = await captureWebVitals(ctx.page);
+        const outputPath = import_node_path17.default.join(ctx.checkpointDir, "web-vitals.json");
+        await import_promises15.default.writeFile(outputPath, `${JSON.stringify(snapshot, null, 2)}
+`, "utf8");
+        return {
+          data: snapshot,
+          artifacts: [
+            {
+              name: "web-vitals",
+              path: outputPath,
+              contentType: "application/json"
+            }
+          ],
+          summary: {
+            cls: snapshot.cls,
+            fcp: snapshot.fcpMs,
+            lcp: snapshot.lcpMs,
+            inp: snapshot.inpMs,
+            ttfb: snapshot.ttfbMs
+          }
+        };
+      },
+      async teardown({ page }) {
+        initializedPages.delete(page);
+      }
+    };
+  }
+});
+
+// src/collectors/builtin-collectors.ts
+var builtinCollectors;
+var init_builtin_collectors = __esm({
+  "src/collectors/builtin-collectors.ts"() {
+    "use strict";
+    init_aria_snapshot();
+    init_axe();
+    init_console();
+    init_dom_stats();
+    init_forms();
+    init_html();
+    init_metadata();
+    init_network();
+    init_network_timing();
+    init_screenshot();
+    init_storage();
+    init_web_vitals();
+    builtinCollectors = [
+      screenshotCollector,
+      htmlCollector,
+      axeCollector,
+      webVitalsCollector,
+      consoleCollector,
+      networkCollector,
+      metadataCollector,
+      ariaSnapshotCollector,
+      domStatsCollector,
+      formsCollector,
+      storageCollector,
+      networkTimingCollector
+    ];
+  }
+});
+
+// src/collectors/registry.ts
+function registerBuiltinCollector(collector) {
+  builtinCollectors2.set(collector.name, collector);
+}
+function registerBuiltinCollectors(collectors) {
+  if (builtinsRegistered) {
+    return;
+  }
+  for (const collector of collectors) {
+    registerBuiltinCollector(collector);
+  }
+  builtinsRegistered = true;
+}
+function getBuiltinCollectors() {
+  return new Map(builtinCollectors2);
+}
+var builtinCollectors2, builtinsRegistered;
+var init_registry = __esm({
+  "src/collectors/registry.ts"() {
+    "use strict";
+    builtinCollectors2 = /* @__PURE__ */ new Map();
+    builtinsRegistered = false;
+  }
+});
+
+// src/core.ts
+function cloneResolvedConfig(config) {
+  return { ...config };
+}
+function cloneCollectorState(state) {
+  return {
+    enabled: state?.enabled ?? false,
+    config: cloneResolvedConfig(state?.config ?? {})
+  };
+}
+function applyCollectorInput(state, input) {
+  const next = cloneCollectorState(state);
+  if (input === void 0) {
+    return next;
+  }
+  if (input === false) {
+    return {
+      enabled: false,
+      config: {}
+    };
+  }
+  if (input === true) {
+    return {
+      enabled: true,
+      config: next.config
+    };
+  }
+  return {
+    enabled: true,
+    config: {
+      ...next.config,
+      ...input
+    }
+  };
+}
+function collectorRegistryFor(config = {}) {
+  const registry = getBuiltinCollectors();
+  for (const collector of config.custom ?? []) {
+    registry.set(collector.name, collector);
+  }
+  return registry;
+}
+function cloneCheckpointOptions(options) {
+  return {
+    ...options,
+    ...options.collectors ? { collectors: { ...options.collectors } } : {}
+  };
+}
+function warn(message, error) {
+  if (error instanceof Error) {
+    console.warn(`[playwright-checkpoint] ${message}`, error);
+    return;
+  }
+  if (error !== void 0) {
+    console.warn(`[playwright-checkpoint] ${message}`, String(error));
+    return;
+  }
+  console.warn(`[playwright-checkpoint] ${message}`);
+}
+function sanitizeSegment(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "checkpoint";
+}
+function checkpointSlug(name, existing) {
+  const base = sanitizeSegment(name);
+  const existingSlugs = new Set(existing.map((record) => record.slug));
+  if (!existingSlugs.has(base)) {
+    return base;
+  }
+  let index = 2;
+  let candidate = `${base}-${index}`;
+  while (existingSlugs.has(candidate)) {
+    index += 1;
+    candidate = `${base}-${index}`;
+  }
+  return candidate;
+}
+async function attachArtifacts(testInfo, checkpointSlugValue, collectorName, artifacts) {
+  const attach = testInfo?.attach;
+  if (typeof attach !== "function") {
+    return;
+  }
+  for (const artifact of artifacts) {
+    try {
+      await attach.call(testInfo, `${checkpointSlugValue}/${collectorName}/${artifact.name}`, {
+        path: artifact.path,
+        contentType: artifact.contentType
+      });
+    } catch (error) {
+      warn(`Failed to attach artifact "${artifact.name}" from collector "${collectorName}".`, error);
+    }
+  }
+}
+async function collectPageTitle(page) {
+  try {
+    return await page.title();
+  } catch {
+    return "";
+  }
+}
+async function runCollectorSetup(collectors, page, testInfo) {
+  for (const collector of collectors) {
+    if (!collector.setup) {
+      continue;
+    }
+    try {
+      await collector.setup({ page, testInfo });
+    } catch (error) {
+      warn(`Collector "${collector.name}" setup failed.`, error);
+    }
+  }
+}
+async function runCollectorTeardown(collectors, page, testInfo) {
+  const collectorList = Array.from(collectors).reverse();
+  for (const collector of collectorList) {
+    if (!collector.teardown) {
+      continue;
+    }
+    try {
+      await collector.teardown({ page, testInfo });
+    } catch (error) {
+      warn(`Collector "${collector.name}" teardown failed.`, error);
+    }
+  }
+}
+function resolveCollectors(globalConfig = {}, testConfig = null, checkpointOptions = {}) {
+  const registry = collectorRegistryFor(globalConfig);
+  const states = /* @__PURE__ */ new Map();
+  for (const collector of registry.values()) {
+    states.set(collector.name, {
+      enabled: collector.defaultEnabled,
+      config: {}
+    });
+  }
+  const levels = [globalConfig.collectors, testConfig?.collectors, checkpointOptions.collectors];
+  for (const level of levels) {
+    for (const [name, input] of Object.entries(level ?? {})) {
+      states.set(name, applyCollectorInput(states.get(name), input));
+    }
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  for (const [name, state] of states) {
+    if (state.enabled) {
+      resolved.set(name, cloneResolvedConfig(state.config));
+    }
+  }
+  return resolved;
+}
+async function runCollectorPipeline(args) {
+  const options = cloneCheckpointOptions(args.options ?? {});
+  const slug = args.slug ?? checkpointSlug(args.name, args.manifest?.checkpoints ?? []);
+  const checkpointDir = import_node_path18.default.join(args.outputDir, slug);
+  const collectorResults = {};
+  await import_promises16.default.mkdir(checkpointDir, { recursive: true });
+  await settlePage(args.page);
+  for (const [collectorName, collectorConfig] of args.resolvedCollectors) {
+    const collector = args.registry.get(collectorName);
+    if (!collector) {
+      warn(`Collector "${collectorName}" is enabled but no implementation is registered.`);
+      continue;
+    }
+    try {
+      const result = await collector.collect({
+        page: args.page,
+        testInfo: args.testInfo,
+        checkpointDir,
+        checkpointName: args.name,
+        checkpointSlug: slug,
+        redact: [...args.redact ?? []],
+        config: cloneResolvedConfig(collectorConfig),
+        options,
+        adjustTimeout: args.adjustTimeout
+      });
+      collectorResults[collectorName] = result;
+      await attachArtifacts(args.testInfo, slug, collectorName, result.artifacts);
+    } catch (error) {
+      warn(`Collector "${collectorName}" failed during checkpoint "${args.name}".`, error);
+    }
+  }
+  const record = {
+    name: args.name,
+    slug,
+    url: args.page.url(),
+    title: await collectPageTitle(args.page),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...options.description ? { description: options.description } : {},
+    ...typeof options.step === "number" ? { step: options.step } : {},
+    collectors: collectorResults
+  };
+  args.manifest?.checkpoints.push(record);
+  return record;
+}
+async function captureCheckpoint(page, name, options) {
+  const sessionConfig = {
+    collectors: options.collectors,
+    custom: options.custom,
+    redact: options.redact
+  };
+  const registry = collectorRegistryFor(sessionConfig);
+  const resolvedCollectors = resolveCollectors(sessionConfig, null, options);
+  const enabledCollectors = Array.from(resolvedCollectors.keys()).map((collectorName) => registry.get(collectorName)).filter((collector) => Boolean(collector));
+  await import_promises16.default.mkdir(options.outputDir, { recursive: true });
+  await runCollectorSetup(enabledCollectors, page, options.testInfo);
+  try {
+    return await runCollectorPipeline({
+      page,
+      name,
+      outputDir: options.outputDir,
+      resolvedCollectors,
+      registry,
+      options,
+      redact: options.redact,
+      testInfo: options.testInfo,
+      adjustTimeout: options.adjustTimeout,
+      slug: checkpointSlug(name, [])
+    });
+  } finally {
+    await runCollectorTeardown(enabledCollectors, page, options.testInfo);
+  }
+}
+var import_promises16, import_node_path18;
+var init_core = __esm({
+  "src/core.ts"() {
+    "use strict";
+    import_promises16 = __toESM(require("fs/promises"), 1);
+    import_node_path18 = __toESM(require("path"), 1);
+    init_builtin_collectors();
+    init_registry();
+    init_page_utils();
+    registerBuiltinCollectors(builtinCollectors);
+  }
+});
+
+// src/mcp/tools.ts
+async function handleBrowserCheckpoint(args, ctx) {
+  const slug = sanitizeSegment(args.name);
+  const record = await captureCheckpoint(ctx.page, args.name, {
+    outputDir: ctx.outputDir,
+    highlightSelector: args.highlightSelector,
+    fullPage: args.fullPage ?? true,
+    description: args.description,
+    collectors: args.collectors
+  });
+  void slug;
+  return formatCheckpointSummary(record);
+}
+async function handleBrowserCheckpointReport(args, testResultsDir = "test-results") {
+  const outputDir = args.outputDir ?? "report";
+  const config = {
+    reporters: {
+      html: args.format === void 0 || args.format === "html",
+      markdown: args.format === "markdown",
+      mdx: args.format === "mdx"
+    }
+  };
+  const { resolve } = await import("path");
+  const results = await runReporters(
+    config,
+    resolve(process.cwd(), testResultsDir),
+    resolve(process.cwd(), outputDir)
+  );
+  const lines = Object.entries(results).map(([name, result]) => `- ${name}: ${result.summary}`);
+  if (lines.length === 0) {
+    return "No reports generated.";
+  }
+  return `Report generation complete:
+${lines.join("\n")}`;
+}
+function handleBrowserCheckpointCompare(_args) {
+  return "browser_checkpoint_compare is not yet implemented.";
+}
+function formatCheckpointSummary(record) {
+  const lines = [];
+  lines.push(`Checkpoint "${record.name}" captured.`);
+  lines.push(`URL: ${record.url}`);
+  lines.push(`Title: ${record.title}`);
+  lines.push("");
+  const axeData = record.collectors["axe"];
+  if (axeData?.data) {
+    const axe = axeData.data;
+    if (axe.skipped) {
+      lines.push(`Accessibility: skipped (${axe.reason ?? "unknown reason"})`);
+    } else {
+      const violations = axe.violations ?? 0;
+      lines.push(`Accessibility: ${violations} violation${violations !== 1 ? "s" : ""}`);
+    }
+  }
+  const wvData = record.collectors["web-vitals"];
+  if (wvData?.data) {
+    const wv = wvData.data;
+    lines.push("Web Vitals:");
+    const metricLines = [];
+    for (const [key, metric2] of Object.entries(wv)) {
+      if (!metric2 || typeof metric2 !== "object") continue;
+      const m = metric2;
+      if (m.value === null) continue;
+      const ratingIcon = m.rating === "good" ? "\u2705" : m.rating === "needs-improvement" ? "\u26A0\uFE0F" : m.rating === "poor" ? "\u274C" : "";
+      const label = key.replace(/Ms$/, "").toUpperCase();
+      const formatted = key.endsWith("Ms") ? `${Math.round(m.value)}ms` : m.value.toFixed ? m.value.toFixed(3) : String(m.value);
+      metricLines.push(`  ${label}: ${formatted} (${m.rating} ${ratingIcon})`.trim());
+    }
+    if (metricLines.length > 0) {
+      lines.push(metricLines.join("\n"));
+    }
+  }
+  const consoleData = record.collectors["console"];
+  if (consoleData?.data) {
+    const entries = consoleData.data;
+    const errors = entries.filter((e) => e.type === "error" || e.type === "pageerror");
+    if (errors.length > 0) {
+      lines.push(`Console: ${errors.length} error${errors.length !== 1 ? "s" : ""}`);
+      for (const err of errors.slice(0, 3)) {
+        lines.push(`  ${err.text}`);
+      }
+      if (errors.length > 3) {
+        lines.push(`  ... and ${errors.length - 3} more`);
+      }
+    } else {
+      lines.push("Console: no errors");
+    }
+  }
+  const netData = record.collectors["network"];
+  if (netData?.data) {
+    const requests = netData.data;
+    const failed = requests.filter((r) => r.status === null || r.status >= 400 || r.failureText);
+    if (failed.length > 0) {
+      lines.push(`Network: ${failed.length} failed request${failed.length !== 1 ? "s" : ""}`);
+      for (const req of failed.slice(0, 3)) {
+        const reason = req.failureText ?? `${req.status} ${req.url}`;
+        lines.push(`  ${req.url} \u2192 ${reason}`);
+      }
+      if (failed.length > 3) {
+        lines.push(`  ... and ${failed.length - 3} more`);
+      }
+    } else {
+      lines.push("Network: 0 failed requests");
+    }
+  }
+  const ssData = record.collectors["screenshot"];
+  if (ssData?.summary) {
+    const ss = ssData.summary;
+    if (ss.screenshotPath) {
+      lines.push(`Screenshot: ${ss.screenshotPath}`);
+    }
+  }
+  return lines.join("\n");
+}
+var browserCheckpointSchema, browserCheckpointReportSchema, browserCheckpointCompareSchema, CHECKPOINT_TOOL_NAME, REPORT_TOOL_NAME, COMPARE_TOOL_NAME, CHECKPOINT_TOOLS;
+var init_tools = __esm({
+  "src/mcp/tools.ts"() {
+    "use strict";
+    init_core();
+    init_report();
+    browserCheckpointSchema = {
+      type: "object",
+      properties: {
+        name: { type: "string", description: 'Unique name for this checkpoint (e.g. "homepage", "after-login").' },
+        description: {
+          type: "string",
+          description: "Long-form description of what this checkpoint captures."
+        },
+        highlightSelector: {
+          type: "string",
+          description: "CSS selector for a region to highlight in the annotated screenshot."
+        },
+        fullPage: {
+          type: "boolean",
+          description: "Capture the full page (default: true). Set false for viewport-only."
+        },
+        collectors: {
+          type: "object",
+          description: "Per-collector overrides. Set to false to disable, or an options object to configure.",
+          additionalProperties: true
+        }
+      },
+      required: ["name"]
+    };
+    browserCheckpointReportSchema = {
+      type: "object",
+      properties: {
+        outputDir: {
+          type: "string",
+          description: "Directory to write report files (default: ./report)."
+        },
+        format: {
+          type: "string",
+          enum: ["html", "markdown", "mdx"],
+          description: "Report format(s) to generate."
+        }
+      }
+    };
+    browserCheckpointCompareSchema = {
+      type: "object",
+      properties: {
+        baseline: { type: "string", description: "Path or name of the baseline checkpoint manifest." },
+        current: { type: "string", description: "Path or name of the current checkpoint manifest." }
+      },
+      required: ["baseline", "current"]
+    };
+    CHECKPOINT_TOOL_NAME = "browser_checkpoint";
+    REPORT_TOOL_NAME = "browser_checkpoint_report";
+    COMPARE_TOOL_NAME = "browser_checkpoint_compare";
+    CHECKPOINT_TOOLS = [
+      {
+        name: CHECKPOINT_TOOL_NAME,
+        description: "Capture a structured snapshot of the current browser page: screenshot, accessibility violations, Web Vitals, console errors, and network failures. Returns an LLM-friendly summary plus artifact paths.",
+        inputSchema: browserCheckpointSchema
+      },
+      {
+        name: REPORT_TOOL_NAME,
+        description: "Generate an HTML, Markdown, or MDX report from all checkpoint manifests in a directory.",
+        inputSchema: browserCheckpointReportSchema
+      },
+      {
+        name: COMPARE_TOOL_NAME,
+        description: "Compare two checkpoint runs to surface differences (not yet implemented).",
+        inputSchema: browserCheckpointCompareSchema
+      }
+    ];
+  }
+});
+
+// src/mcp/index.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  startMcpProxy: () => startMcpProxy
+});
+function ensureMcpSdk() {
+  try {
+    require("@modelcontextprotocol/sdk");
+  } catch {
+    throw new Error(
+      "playwright-checkpoint MCP mode requires @modelcontextprotocol/sdk.\nInstall it: npm install @modelcontextprotocol/sdk"
+    );
+  }
+}
+function getNodeModuleCreateRequire3() {
+  const { createRequire } = require("module");
+  return createRequire(import_meta2.url);
+}
+async function startMcpProxy(options = {}) {
+  ensureMcpSdk();
+  const req = getNodeModuleCreateRequire3();
+  const sdk = req("@modelcontextprotocol/sdk");
+  const sdkServer = req("@modelcontextprotocol/sdk/server");
+  const ListToolsRequestSchema = sdk.ListToolsRequestSchema;
+  const CallToolRequestSchema = sdk.CallToolRequestSchema;
+  const Server = sdkServer.Server;
+  const outputDir = options.outputDir ?? "./checkpoints";
+  let upstreamConnection = null;
+  const upstreamTools = [];
+  const upstreamPkg = options.standalone ? null : resolveUpstream({ upstream: options.upstream });
+  if (upstreamPkg) {
+    console.error(`[playwright-checkpoint MCP] Proxying upstream: ${upstreamPkg}`);
+    let passthroughArgs = options.passthrough ?? [];
+    if (!options.cdpEndpoint) {
+      passthroughArgs = injectDebugPort(passthroughArgs);
+    }
+    upstreamConnection = spawnUpstream(upstreamPkg, passthroughArgs);
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    try {
+      const result = await upstreamConnection.listTools();
+      for (const tool of result.tools) {
+        upstreamTools.push({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema
+        });
+      }
+    } catch (err) {
+      console.error("[playwright-checkpoint MCP] Warning: could not list upstream tools:", err);
+    }
+  } else {
+    console.error("[playwright-checkpoint MCP] Running in standalone mode (no upstream).");
+  }
+  const checkpointTools = CHECKPOINT_TOOLS.map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema
+  }));
+  const allTools = [...checkpointTools, ...upstreamTools];
+  const server = new Server({ name: "playwright-checkpoint", version: "0.1.0-beta.0" }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: allTools };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args = {} } = request.params;
+    if (name === CHECKPOINT_TOOL_NAME) {
+      const { page } = await getUpstreamPage(upstreamConnection?.process ?? null, {
+        cdpEndpoint: options.cdpEndpoint,
+        debugPort: 9222
+      });
+      const result = await handleBrowserCheckpoint(
+        args,
+        { page, outputDir }
+      );
+      return { content: [{ type: "text", text: result }] };
+    }
+    if (name === REPORT_TOOL_NAME) {
+      const result = await handleBrowserCheckpointReport(
+        args
+      );
+      return { content: [{ type: "text", text: result }] };
+    }
+    if (name === COMPARE_TOOL_NAME) {
+      const result = handleBrowserCheckpointCompare(
+        args
+      );
+      return { content: [{ type: "text", text: result }], isError: true };
+    }
+    if (upstreamConnection) {
+      try {
+        const result = await upstreamConnection.callTool(name, args);
+        return {
+          content: result.content,
+          isError: result.isError,
+          structuredContent: result.structuredContent
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Upstream tool "${name}" failed: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+    return { content: [{ type: "text", text: `Tool "${name}" is not available.` }], isError: true };
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  const cleanup = () => {
+    resetCachedConnection();
+    upstreamConnection?.close();
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+var import_meta2;
+var init_mcp = __esm({
+  "src/mcp/index.ts"() {
+    "use strict";
+    init_transport();
+    init_upstream();
+    init_browser_connect();
+    init_tools();
+    import_meta2 = {};
+  }
+});
+
+// src/cli/index.ts
+var import_node_path5 = __toESM(require("path"), 1);
+init_report();
+var DEFAULT_RESULTS_DIR = "test-results";
+var DEFAULT_REPORT_OUTPUT_DIR = "report";
+var DEFAULT_DOCS_OUTPUT_DIR = "docs";
+function printHelp(log) {
+  log(`playwright-checkpoint
+
+Usage:
+  playwright-checkpoint report [--results-dir ./test-results] [--output-dir ./report] [--reporter html,markdown]
+  playwright-checkpoint docs [--results-dir ./test-results] [--output-dir ./docs] [--format markdown|mdx] [--filter @user-journey]
+
+Commands:
+  report    Generate reports from checkpoint manifests
+  docs      Generate Markdown or MDX help articles from checkpoint manifests
+
+Options:
+  --results-dir <path>   Directory containing checkpoint manifests (default: ./${DEFAULT_RESULTS_DIR})
+  --output-dir <path>    Directory where generated output is written (defaults: ./${DEFAULT_REPORT_OUTPUT_DIR} for report, ./${DEFAULT_DOCS_OUTPUT_DIR} for docs)
+  --reporter <names>     Comma-separated reporters to run with the report command (default: html)
+  --format <name>        Docs output format: markdown or mdx (default: markdown)
+  --filter <tags>        Comma-separated tag filter for docs generation
+  -h, --help             Show this help text`);
+}
+function takeFlagValue(args, index, flag) {
+  const value = args[index + 1];
+  if (!value) {
+    throw new Error(`Missing value for ${flag}.`);
+  }
+  return {
+    value,
+    nextIndex: index + 1
+  };
+}
+function parseCommaSeparated(value) {
+  return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function parseCliArgs(argv2) {
+  if (argv2.length === 0 || argv2.includes("--help") || argv2.includes("-h")) {
+    return { command: "help" };
+  }
+  const [command, ...rest] = argv2;
+  if (command !== "report" && command !== "docs") {
+    throw new Error(`Unknown command "${command}".`);
+  }
+  let resultsDir = DEFAULT_RESULTS_DIR;
+  let outputDir = command === "docs" ? DEFAULT_DOCS_OUTPUT_DIR : DEFAULT_REPORT_OUTPUT_DIR;
+  let reporters = null;
+  let format = "markdown";
+  let filterTags = [];
+  for (let index = 0; index < rest.length; index += 1) {
+    const argument = rest[index];
+    if (!argument) {
+      continue;
+    }
+    if (argument === "--results-dir") {
+      const { value, nextIndex } = takeFlagValue(rest, index, argument);
+      resultsDir = value;
+      index = nextIndex;
+      continue;
+    }
+    if (argument.startsWith("--results-dir=")) {
+      resultsDir = argument.slice("--results-dir=".length);
+      continue;
+    }
+    if (argument === "--output-dir") {
+      const { value, nextIndex } = takeFlagValue(rest, index, argument);
+      outputDir = value;
+      index = nextIndex;
+      continue;
+    }
+    if (argument.startsWith("--output-dir=")) {
+      outputDir = argument.slice("--output-dir=".length);
+      continue;
+    }
+    if (command === "report") {
+      if (argument === "--reporter") {
+        const { value, nextIndex } = takeFlagValue(rest, index, argument);
+        reporters = parseCommaSeparated(value);
+        index = nextIndex;
+        continue;
+      }
+      if (argument.startsWith("--reporter=")) {
+        reporters = parseCommaSeparated(argument.slice("--reporter=".length));
+        continue;
+      }
+    }
+    if (command === "docs") {
+      if (argument === "--format") {
+        const { value, nextIndex } = takeFlagValue(rest, index, argument);
+        if (value !== "markdown" && value !== "mdx") {
+          throw new Error(`Unsupported docs format "${value}".`);
+        }
+        format = value;
+        index = nextIndex;
+        continue;
+      }
+      if (argument.startsWith("--format=")) {
+        const value = argument.slice("--format=".length);
+        if (value !== "markdown" && value !== "mdx") {
+          throw new Error(`Unsupported docs format "${value}".`);
+        }
+        format = value;
+        continue;
+      }
+      if (argument === "--filter") {
+        const { value, nextIndex } = takeFlagValue(rest, index, argument);
+        filterTags = parseCommaSeparated(value);
+        index = nextIndex;
+        continue;
+      }
+      if (argument.startsWith("--filter=")) {
+        filterTags = parseCommaSeparated(argument.slice("--filter=".length));
+        continue;
+      }
+    }
+    throw new Error(`Unknown argument "${argument}".`);
+  }
+  if (command === "docs") {
+    return {
+      command,
+      resultsDir,
+      outputDir,
+      format,
+      filterTags
+    };
+  }
+  return {
+    command,
+    resultsDir,
+    outputDir,
+    reporters
+  };
+}
+function reporterConfig(reporters) {
+  if (!reporters || reporters.length === 0) {
+    return {};
+  }
+  const selected = new Set(reporters);
+  return {
+    reporters: {
+      html: selected.has("html"),
+      markdown: selected.has("markdown"),
+      mdx: selected.has("mdx"),
+      ...Object.fromEntries(reporters.map((name) => [name, true]))
+    }
+  };
+}
+function docsConfig(format, filterTags) {
+  const reporterName = format === "mdx" ? "mdx" : "markdown";
+  return {
+    reporters: {
+      html: false,
+      markdown: false,
+      mdx: false,
+      [reporterName]: {
+        ...filterTags.length > 0 ? { includeTags: filterTags } : {}
+      }
+    }
+  };
+}
+async function runCli(argv2 = process.argv.slice(2), deps = {}) {
+  const cwd = deps.cwd ?? process.cwd;
+  const log = deps.log ?? console.log;
+  const error = deps.error ?? console.error;
+  const runReportersImpl = deps.runReportersImpl ?? runReporters;
+  let parsed;
+  try {
+    parsed = parseCliArgs(argv2);
+  } catch (caught) {
+    error(`[playwright-checkpoint] ${caught instanceof Error ? caught.message : String(caught)}`);
+    error("Run `playwright-checkpoint --help` for usage.");
+    return 1;
+  }
+  if (parsed.command === "help") {
+    printHelp(log);
+    return 0;
+  }
+  const resultsDir = import_node_path5.default.resolve(cwd(), parsed.resultsDir);
+  const outputDir = import_node_path5.default.resolve(cwd(), parsed.outputDir);
+  try {
+    const config = parsed.command === "docs" ? docsConfig(parsed.format, parsed.filterTags) : reporterConfig(parsed.reporters);
+    const results = await runReportersImpl(config, resultsDir, outputDir);
+    const summaryLines = Object.entries(results).map(([name, result]) => `- ${name}: ${result.summary}`);
+    log(
+      parsed.command === "docs" ? `[playwright-checkpoint] Generated ${parsed.format.toUpperCase()} docs from ${resultsDir} to ${outputDir}` : `[playwright-checkpoint] Generated reports from ${resultsDir} to ${outputDir}`
+    );
+    if (summaryLines.length > 0) {
+      for (const line of summaryLines) {
+        log(line);
+      }
+    } else {
+      log("- No reporters were enabled.");
+    }
+    return 0;
+  } catch (caught) {
+    error("[playwright-checkpoint] Failed to generate reports.");
+    error(caught instanceof Error ? caught.stack ?? caught.message : String(caught));
+    return 1;
+  }
+}
+
+// src/cli/mcp-args.ts
+function parseMcpCliArgs(argv2) {
+  const flags = {};
+  const passthroughArgs = [];
+  let doubleDashSeen = false;
+  for (let i = 0; i < argv2.length; i++) {
+    const arg = argv2[i] ?? "";
+    if (doubleDashSeen) {
+      passthroughArgs.push(arg);
+      continue;
+    }
+    if (arg === "--") {
+      doubleDashSeen = true;
+      continue;
+    }
+    if (arg === "--upstream") {
+      const value = argv2[i + 1];
+      if (!value || value.startsWith("-")) {
+        throw new Error("--upstream requires a package name argument.");
+      }
+      flags.upstream = value;
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--upstream=")) {
+      flags.upstream = arg.slice("--upstream=".length);
+      continue;
+    }
+    if (arg === "--standalone") {
+      flags.standalone = true;
+      continue;
+    }
+    if (arg === "--cdp-endpoint") {
+      const value = argv2[i + 1];
+      if (!value || value.startsWith("-")) {
+        throw new Error("--cdp-endpoint requires a URL argument.");
+      }
+      flags.cdpEndpoint = value;
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--cdp-endpoint=")) {
+      flags.cdpEndpoint = arg.slice("--cdp-endpoint=".length);
+      continue;
+    }
+    if (arg === "--output-dir") {
+      const value = argv2[i + 1];
+      if (!value || value.startsWith("-")) {
+        throw new Error("--output-dir requires a path argument.");
+      }
+      flags.outputDir = value;
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--output-dir=")) {
+      flags.outputDir = arg.slice("--output-dir=".length);
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      flags.upstream = "__help__";
+      return { flags, passthroughArgs: [] };
+    }
+    passthroughArgs.push(arg, ...argv2.slice(i + 1));
+    break;
+  }
+  return { flags, passthroughArgs };
+}
+function printMcpHelp(log) {
+  log(`playwright-checkpoint mcp
+
+Start the playwright-checkpoint MCP proxy server.
+
+Usage:
+  playwright-checkpoint mcp [options] [-- <upstream-args>...]
+
+Options:
+  --upstream <pkg>         Upstream MCP package to proxy (default: auto-detect)
+  --standalone             Run without an upstream MCP server
+  --cdp-endpoint <url>     Connect directly to a browser CDP endpoint
+  --output-dir <path>      Directory for checkpoint output (default: ./checkpoints)
+  -h, --help               Show this help text
+
+All arguments after -- are passed through to the upstream MCP server.
+
+Examples:
+  # Auto-detect @playwright/mcp from node_modules
+  playwright-checkpoint mcp
+
+  # Explicit upstream package
+  playwright-checkpoint mcp --upstream @playwright/mcp
+
+  # Pass headless args to upstream
+  playwright-checkpoint mcp -- --headless --browser chrome
+
+  # Standalone mode (no upstream, connect to existing browser)
+  playwright-checkpoint mcp --standalone --cdp-endpoint http://localhost:9222
+`);
+}
+
+// src/cli/bin.ts
+var argv = process.argv.slice(2);
+if (argv[0] === "mcp") {
+  const { passthroughArgs, flags } = parseMcpCliArgs(argv.slice(1));
+  if (flags.upstream === "__help__") {
+    printMcpHelp(console.log);
+    process.exit(0);
+  }
+  void (async () => {
+    try {
+      const { startMcpProxy: startMcpProxy2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+      await startMcpProxy2({
+        upstream: flags.upstream,
+        standalone: flags.standalone,
+        cdpEndpoint: flags.cdpEndpoint,
+        outputDir: flags.outputDir,
+        passthrough: passthroughArgs
+      });
+    } catch (err) {
+      console.error(
+        "[playwright-checkpoint MCP]",
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(1);
+    }
+  })();
+} else {
+  void runCli(argv).then((code) => {
+    process.exitCode = code;
+  });
+}
+//# sourceMappingURL=bin.cjs.map