playwright-checkpoint 0.1.0-beta.0

package/dist/chunk-KG37WSYS.js

@@ -0,0 +1,1549 @@
+// src/core.ts
+import fs12 from "fs/promises";
+import path13 from "path";
+
+// src/collectors/aria-snapshot.ts
+import fs from "fs/promises";
+import path from "path";
+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 ariaSnapshotCollector = {
+  name: "aria-snapshot",
+  defaultEnabled: false,
+  async collect(ctx) {
+    const snapshot = await captureAriaSnapshot(ctx.page);
+    const nodeCount = countSnapshotNodes(snapshot);
+    const outputPath = path.join(ctx.checkpointDir, "aria-snapshot.json");
+    const data = {
+      snapshot,
+      nodeCount
+    };
+    await fs.writeFile(outputPath, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+    return {
+      data,
+      artifacts: [
+        {
+          name: "aria-snapshot",
+          path: outputPath,
+          contentType: "application/json"
+        }
+      ],
+      summary: {
+        nodeCount
+      }
+    };
+  }
+};
+
+// src/collectors/axe.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/page-utils.ts
+async function settlePage(page) {
+  await page.waitForLoadState("domcontentloaded").catch(() => void 0);
+  await page.waitForLoadState("load", { timeout: 3e3 }).catch(() => void 0);
+}
+
+// src/collectors/axe.ts
+var axeLoader = () => import("@axe-core/playwright");
+var warnedAboutMissingAxe = false;
+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(module) {
+  return module.default ?? module.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
+    }
+  };
+}
+function setAxeLoaderForTests(loader) {
+  axeLoader = loader ?? (() => import("@axe-core/playwright"));
+  warnedAboutMissingAxe = false;
+}
+var 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 module;
+    try {
+      module = 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(module);
+    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 = path2.join(ctx.checkpointDir, "axe.json");
+    await fs2.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
+import fs3 from "fs/promises";
+import path3 from "path";
+var consoleStates = /* @__PURE__ */ new WeakMap();
+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 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 = path3.join(ctx.checkpointDir, "console-errors.json");
+    await fs3.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
+import fs4 from "fs/promises";
+import path4 from "path";
+var 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 = path4.join(ctx.checkpointDir, "dom-stats.json");
+    await fs4.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
+import fs5 from "fs/promises";
+import path5 from "path";
+var REDACTED = "[REDACTED]";
+var DEFAULT_REDACT_PATTERNS = ["password", "token", "secret", "api[_-]?key", "authorization", "bearer"];
+var EMAIL_LIKE_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+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 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 = path5.join(ctx.checkpointDir, "form-state.json");
+    await fs5.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
+import fs6 from "fs/promises";
+import path6 from "path";
+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 htmlCollector = {
+  name: "html",
+  defaultEnabled: true,
+  async collect(ctx) {
+    const htmlPath = path6.join(ctx.checkpointDir, "page.html");
+    const html = await readPageContent(ctx.page);
+    await fs6.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
+import fs7 from "fs/promises";
+import path7 from "path";
+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 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 = path7.join(ctx.checkpointDir, "metadata.json");
+    await fs7.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
+import fs8 from "fs/promises";
+import path8 from "path";
+var networkStates = /* @__PURE__ */ new WeakMap();
+var 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 = path8.join(ctx.checkpointDir, "failed-requests.json");
+    await fs8.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
+import fs9 from "fs/promises";
+import path9 from "path";
+var timingStates = /* @__PURE__ */ new WeakMap();
+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 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 = path9.join(ctx.checkpointDir, "network-timing.json");
+    await fs9.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
+import path10 from "path";
+var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+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 screenshotCollector = {
+  name: "screenshot",
+  defaultEnabled: true,
+  async collect(ctx) {
+    const fullPage = ctx.options.fullPage ?? true;
+    const screenshotPath = path10.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
+import fs10 from "fs/promises";
+import path11 from "path";
+var REDACTED2 = "[REDACTED]";
+var DEFAULT_REDACT_PATTERNS2 = ["password", "token", "secret", "api[_-]?key", "authorization", "session", "email"];
+var EMAIL_LIKE_REGEX2 = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+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 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 = path11.join(ctx.checkpointDir, "storage-state.json");
+    await fs10.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
+import fs11 from "fs/promises";
+import path12 from "path";
+var initializedPages = /* @__PURE__ */ new WeakSet();
+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 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 = path12.join(ctx.checkpointDir, "web-vitals.json");
+    await fs11.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 = [
+  screenshotCollector,
+  htmlCollector,
+  axeCollector,
+  webVitalsCollector,
+  consoleCollector,
+  networkCollector,
+  metadataCollector,
+  ariaSnapshotCollector,
+  domStatsCollector,
+  formsCollector,
+  storageCollector,
+  networkTimingCollector
+];
+
+// src/collectors/registry.ts
+var builtinCollectors2 = /* @__PURE__ */ new Map();
+var builtinsRegistered = false;
+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);
+}
+
+// src/core.ts
+registerBuiltinCollectors(builtinCollectors);
+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 defaultManifestEnvironment() {
+  return process.env.PLAYWRIGHT_CHECKPOINT_ENV || process.env.NODE_ENV || "test";
+}
+function createManifest(sessionMetadata) {
+  return {
+    environment: sessionMetadata?.environment ?? defaultManifestEnvironment(),
+    project: sessionMetadata?.project ?? "",
+    testId: sessionMetadata?.testId ?? "",
+    title: sessionMetadata?.title ?? "",
+    tags: [...sessionMetadata?.tags ?? []],
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checkpoints: []
+  };
+}
+async function writeManifestFile(manifestPath, manifest) {
+  await fs12.mkdir(path13.dirname(manifestPath), { recursive: true });
+  await fs12.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  return manifestPath;
+}
+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 = path13.join(args.outputDir, slug);
+  const collectorResults = {};
+  await fs12.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 fs12.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);
+  }
+}
+async function createCheckpointSession(page, options) {
+  const sessionConfig = {
+    collectors: options.collectors,
+    custom: options.custom,
+    redact: options.redact
+  };
+  const outputDir = options.outputDir;
+  const registry = collectorRegistryFor(sessionConfig);
+  const manifest = options.manifest ?? createManifest(options.sessionMetadata);
+  const setupCollectorNames = /* @__PURE__ */ new Set();
+  const setupCollectors = [];
+  let finalizePromise = null;
+  async function ensureCollectorsSetup(resolvedCollectors) {
+    for (const collectorName of resolvedCollectors.keys()) {
+      if (setupCollectorNames.has(collectorName)) {
+        continue;
+      }
+      const collector = registry.get(collectorName);
+      if (!collector) {
+        warn(`Collector "${collectorName}" is enabled but no implementation is registered.`);
+        continue;
+      }
+      setupCollectorNames.add(collectorName);
+      setupCollectors.push(collector);
+      await runCollectorSetup([collector], page, options.testInfo);
+    }
+  }
+  await fs12.mkdir(outputDir, { recursive: true });
+  await ensureCollectorsSetup(resolveCollectors(sessionConfig));
+  return {
+    outputDir,
+    manifest,
+    async checkpoint(name, checkpointOptions = {}) {
+      if (finalizePromise) {
+        throw new Error("Checkpoint session has already been finalized.");
+      }
+      const resolvedCollectors = resolveCollectors(sessionConfig, null, checkpointOptions);
+      await ensureCollectorsSetup(resolvedCollectors);
+      return runCollectorPipeline({
+        page,
+        name,
+        outputDir,
+        resolvedCollectors,
+        registry,
+        options: checkpointOptions,
+        manifest,
+        redact: options.redact,
+        testInfo: options.testInfo,
+        adjustTimeout: options.adjustTimeout
+      });
+    },
+    finalize() {
+      if (!finalizePromise) {
+        finalizePromise = (async () => {
+          await runCollectorTeardown(setupCollectors, page, options.testInfo);
+          await writeManifestFile(options.manifestPath ?? path13.join(outputDir, "checkpoint-manifest.json"), manifest);
+          return manifest;
+        })();
+      }
+      return finalizePromise;
+    }
+  };
+}
+
+export {
+  ariaSnapshotCollector,
+  settlePage,
+  setAxeLoaderForTests,
+  axeCollector,
+  consoleCollector,
+  domStatsCollector,
+  formsCollector,
+  htmlCollector,
+  metadataCollector,
+  networkCollector,
+  networkTimingCollector,
+  screenshotCollector,
+  storageCollector,
+  webVitalsCollector,
+  builtinCollectors,
+  registerBuiltinCollector,
+  registerBuiltinCollectors,
+  getBuiltinCollectors,
+  warn,
+  sanitizeSegment,
+  checkpointSlug,
+  collectPageTitle,
+  runCollectorSetup,
+  runCollectorTeardown,
+  resolveCollectors,
+  runCollectorPipeline,
+  captureCheckpoint,
+  createCheckpointSession
+};
+//# sourceMappingURL=chunk-KG37WSYS.js.map