@detiq/crawler 0.1.3

package/src/network-observer.ts

@@ -0,0 +1,204 @@
+import type { BrowserContext } from 'playwright';
+import { redactJson } from './policies/crawl-safety.js';
+
+export interface ApiEndpointObservationInput {
+  method: string;
+  urlPattern: string;
+  statusCode?: number;
+  requestKind?: string;
+  responseShape?: unknown;
+  durationMs?: number;
+  errorBody?: string;
+}
+
+const API_PATTERN = /\/(api|graphql|gql|rest|v\d+)\//i;
+const ASSET_EXT = /\.(js|css|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|eot|map|json\.map)(\?|$)/i;
+
+function normalizeApiUrl(url: string): string {
+  const u = new URL(url);
+  return u.pathname
+    .replace(/\/[a-f0-9-]{8,}(?=\/|$)/gi, '/{id}')
+    .replace(/\/c[a-z0-9]{20,}(?=\/|$)/g, '/{id}')
+    .replace(/\/\d+(?=\/|$)/g, '/{id}');
+}
+
+function inferShape(value: unknown): unknown {
+  if (Array.isArray(value)) return value.length > 0 ? [inferShape(value[0])] : [];
+  if (value && typeof value === 'object') {
+    const out: Record<string, unknown> = {};
+    for (const [key, item] of Object.entries(value).slice(0, 40)) out[key] = inferShape(item);
+    return out;
+  }
+  return typeof value;
+}
+
+/** P4: Extract page-URL candidates from a JSON response body string. */
+function extractPageUrls(jsonStr: string): string[] {
+  const PAGE_URL = /"(?:url|href|path|link|route|to|src|redirect)"\s*:\s*"(\/[\w\-\/\.~@%]+)"/g;
+  const ASSET = /\.(png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|css|js|map|json)$/i;
+  const API_PATH = /^\/(api|v\d+|graphql|gql|rest|rpc|static|_next|assets)\//i;
+  const found = new Set<string>();
+  let m: RegExpExecArray | null;
+  PAGE_URL.lastIndex = 0;
+  while ((m = PAGE_URL.exec(jsonStr)) !== null) {
+    const u = m[1];
+    if (u && u.length > 1 && u.length < 120 && !ASSET.test(u) && !API_PATH.test(u)) found.add(u);
+  }
+  return [...found];
+}
+
+export function attachNetworkObserver(
+  context: BrowserContext,
+  sink: ApiEndpointObservationInput[],
+  onPageUrlDiscovered?: (relPath: string) => void,
+) {
+  const seen = new Map<string, ApiEndpointObservationInput>();
+  const requestTimes = new Map<string, number>();
+
+  context.on('request', (request) => {
+    try {
+      const url = request.url();
+      const rtype = request.resourceType();
+      if ((rtype !== 'xhr' && rtype !== 'fetch') || !API_PATTERN.test(url) || ASSET_EXT.test(url)) return;
+      const method = request.method();
+      const normalized = normalizeApiUrl(url);
+      const key = `${method}:${normalized}`;
+      requestTimes.set(url, Date.now());
+      if (!seen.has(key)) {
+        const row = { method, urlPattern: normalized, requestKind: rtype };
+        seen.set(key, row);
+        sink.push(row);
+      }
+    } catch {
+      // non-fatal
+    }
+  });
+
+  context.on('response', async (response) => {
+    try {
+      const request = response.request();
+      const url = request.url();
+      const rtype = request.resourceType();
+      if ((rtype !== 'xhr' && rtype !== 'fetch') || !API_PATTERN.test(url) || ASSET_EXT.test(url)) return;
+      const normalized = normalizeApiUrl(url);
+      const key = `${request.method()}:${normalized}`;
+      const durationMs = Date.now() - (requestTimes.get(url) ?? Date.now());
+      let row = seen.get(key);
+      if (!row) {
+        row = { method: request.method(), urlPattern: normalized, requestKind: rtype };
+        seen.set(key, row);
+        sink.push(row);
+      }
+      row.statusCode = response.status();
+      row.durationMs = durationMs;
+      const contentType = response.headers()['content-type'] ?? '';
+      if (contentType.includes('application/json')) {
+        const body = await response.json().catch(() => undefined);
+        if (body !== undefined) {
+          row.responseShape = redactJson(inferShape(body));
+          // P4: scan JSON body for page-URL candidates (non-API paths)
+          if (onPageUrlDiscovered) {
+            for (const u of extractPageUrls(JSON.stringify(body))) onPageUrlDiscovered(u);
+          }
+        }
+      }
+      if (response.status() >= 400) {
+        try {
+          const errText = await response.text();
+          row.errorBody = errText.slice(0, 300);
+        } catch { /* non-fatal */ }
+      }
+    } catch {
+      // non-fatal
+    }
+  });
+}
+
+// ── Full HAR capture ──────────────────────────────────────────────────────────
+
+export interface HarEntry {
+  startedAt: string;
+  method: string;
+  url: string;
+  status: number;
+  statusText: string;
+  requestHeaders: Record<string, string>;
+  responseHeaders: Record<string, string>;
+  contentType: string;
+  bodySize: number;
+  durationMs: number;
+  timings: { send: number; wait: number; receive: number };
+}
+
+export interface HarLog {
+  version: '1.2';
+  creator: { name: 'ZeTa-Crawler'; version: '1.0' };
+  pages: Array<{ id: string; title: string; startedAt: string }>;
+  entries: HarEntry[];
+}
+
+/**
+ * Full HAR capture via CDP — intercepts ALL network traffic, not just API endpoints.
+ * Returns a controller with getHar() and detach().
+ */
+export function attachHarCapture(cdpSession: any, pageTitle = 'Page'): { getHar(): HarLog; detach(): void } {
+  const entries: HarEntry[] = [];
+  const pending = new Map<string, { method: string; url: string; headers: Record<string, string>; startMs: number }>();
+  const pageId = `page_${String(Date.now())}`;
+  const pageStarted = new Date().toISOString();
+
+  const onRequest = (evt: any) => {
+    const { requestId, request } = evt ?? {};
+    if (!requestId || !request) return;
+    const headers: Record<string, string> = {};
+    for (const h of (request.headers ?? [])) if (h.name) headers[String(h.name).toLowerCase()] = String(h.value ?? '');
+    pending.set(requestId, { method: request.method ?? 'GET', url: request.url ?? '', headers, startMs: Date.now() });
+  };
+
+  const onResponse = (evt: any) => {
+    const { requestId, response } = evt ?? {};
+    if (!requestId || !response) return;
+    const req = pending.get(requestId);
+    if (!req) return;
+    pending.delete(requestId);
+    const durationMs = Date.now() - req.startMs;
+    const responseHeaders: Record<string, string> = {};
+    for (const h of (response.headers ?? [])) if (h.name) responseHeaders[String(h.name).toLowerCase()] = String(h.value ?? '');
+    entries.push({
+      startedAt: new Date(req.startMs).toISOString(),
+      method: req.method,
+      url: req.url,
+      status: response.status ?? 0,
+      statusText: response.statusText ?? '',
+      requestHeaders: req.headers,
+      responseHeaders,
+      contentType: responseHeaders['content-type'] ?? '',
+      bodySize: response.encodedDataLength ?? -1,
+      durationMs,
+      timings: { send: 0, wait: Math.round(durationMs * 0.9), receive: Math.round(durationMs * 0.1) },
+    });
+  };
+
+  if (cdpSession?.on) {
+    cdpSession.on('Network.requestWillBeSent', onRequest);
+    cdpSession.on('Network.responseReceived', onResponse);
+  }
+
+  return {
+    getHar(): HarLog {
+      return {
+        version: '1.2',
+        creator: { name: 'ZeTa-Crawler', version: '1.0' },
+        pages: [{ id: pageId, title: pageTitle, startedAt: pageStarted }],
+        entries: [...entries],
+      };
+    },
+    detach() {
+      if (cdpSession?.off) {
+        cdpSession.off('Network.requestWillBeSent', onRequest);
+        cdpSession.off('Network.responseReceived', onResponse);
+      }
+      pending.clear();
+    },
+  };
+}

package/src/network-throttle.ts

@@ -0,0 +1,69 @@
+/**
+ * Network throttle simulation via CDP.
+ *
+ * Simulates different network conditions during crawl to test how the app
+ * behaves under slow connections. Useful for detecting loading states, error
+ * handling, and performance degradation on poor networks.
+ *
+ * Conditions mirror Chrome DevTools presets:
+ * - slow3g: ~500kbps download, high latency
+ * - fast3g: ~1.6Mbps download, medium latency
+ * - 4g: ~9Mbps download, low latency
+ * - offline: no connectivity
+ * - none: no throttle (default)
+ */
+
+export type NetworkConditionPreset = 'none' | 'slow3g' | 'fast3g' | '4g' | 'offline';
+
+interface NetworkCondition {
+  offline: boolean;
+  downloadThroughput: number; // bytes/s
+  uploadThroughput: number;   // bytes/s
+  latency: number;            // ms
+}
+
+const PRESETS: Record<NetworkConditionPreset, NetworkCondition> = {
+  none:    { offline: false, downloadThroughput: -1, uploadThroughput: -1, latency: 0 },
+  slow3g:  { offline: false, downloadThroughput: 500 * 1024 / 8, uploadThroughput: 500 * 1024 / 8, latency: 2_000 },
+  fast3g:  { offline: false, downloadThroughput: 1.6 * 1024 * 1024 / 8, uploadThroughput: 750 * 1024 / 8, latency: 562.5 },
+  '4g':    { offline: false, downloadThroughput: 9 * 1024 * 1024 / 8, uploadThroughput: 2.67 * 1024 * 1024 / 8, latency: 85 },
+  offline: { offline: true, downloadThroughput: 0, uploadThroughput: 0, latency: 0 },
+};
+
+export async function applyNetworkThrottle(
+  cdpSession: any,
+  preset: NetworkConditionPreset,
+): Promise<void> {
+  if (!cdpSession?.send) return;
+  const condition = PRESETS[preset];
+  try {
+    await cdpSession.send('Network.enable');
+    await cdpSession.send('Network.emulateNetworkConditions', condition);
+  } catch { /* non-fatal — CDP may not be available */ }
+}
+
+export async function clearNetworkThrottle(cdpSession: any): Promise<void> {
+  await applyNetworkThrottle(cdpSession, 'none');
+}
+
+export interface ThrottledCrawlOpts {
+  /** Network preset to apply during this URL's crawl */
+  preset: NetworkConditionPreset;
+  /** Restore to 'none' after navigation (default: true) */
+  restoreAfter?: boolean;
+}
+
+/** Apply throttle, run fn, restore. Returns fn's result. */
+export async function withNetworkThrottle<T>(
+  cdpSession: any,
+  preset: NetworkConditionPreset,
+  fn: () => Promise<T>,
+  restoreAfter = true,
+): Promise<T> {
+  await applyNetworkThrottle(cdpSession, preset);
+  try {
+    return await fn();
+  } finally {
+    if (restoreAfter) await clearNetworkThrottle(cdpSession).catch(() => {});
+  }
+}

package/src/openapi-generator.ts

@@ -0,0 +1,135 @@
+/**
+ * OpenAPI 3.0 spec generator from observed network traffic.
+ *
+ * Takes the ApiEndpointObservationInput[] collected by the network observer
+ * during crawl and generates a minimal but valid OpenAPI 3.0 spec.
+ *
+ * The spec captures: endpoints, methods, observed response shapes, status codes.
+ * It does NOT capture request bodies (we'd need to intercept requests too) — that's
+ * marked as a TODO. But it's enough for generating smoke-test suites.
+ */
+
+import type { ApiEndpointObservationInput } from './network-observer.js';
+
+export interface OpenApiSpec {
+  openapi: '3.0.3';
+  info: { title: string; version: string; description?: string };
+  servers: Array<{ url: string }>;
+  paths: Record<string, Record<string, OpenApiOperation>>;
+}
+
+interface OpenApiOperation {
+  summary: string;
+  parameters?: OpenApiParam[];
+  responses: Record<string, { description: string; content?: Record<string, { schema: unknown }> }>;
+  tags?: string[];
+}
+
+interface OpenApiParam {
+  name: string;
+  in: 'path' | 'query';
+  required: boolean;
+  schema: { type: string };
+}
+
+function extractPathParams(urlPattern: string): OpenApiParam[] {
+  const params: OpenApiParam[] = [];
+  const matches = urlPattern.matchAll(/\{(\w+)\}/g);
+  for (const m of matches) {
+    params.push({ name: m[1], in: 'path', required: true, schema: { type: 'string' } });
+  }
+  return params;
+}
+
+function methodSummary(method: string, path: string): string {
+  const resource = path.split('/').filter(s => !s.startsWith('{') && s.length > 0).pop() ?? 'resource';
+  const summaries: Record<string, string> = {
+    GET: `Get ${resource}`,
+    POST: `Create ${resource}`,
+    PUT: `Update ${resource}`,
+    PATCH: `Partially update ${resource}`,
+    DELETE: `Delete ${resource}`,
+  };
+  return summaries[method.toUpperCase()] ?? `${method} ${resource}`;
+}
+
+function inferTag(path: string): string {
+  const parts = path.split('/').filter(s => s.length > 0 && !s.startsWith('{'));
+  return parts[0] ?? 'default';
+}
+
+export function generateOpenApiSpec(
+  observations: ApiEndpointObservationInput[],
+  opts: { title?: string; baseUrl?: string; version?: string } = {},
+): OpenApiSpec {
+  const { title = 'ZeTa Discovered API', baseUrl = '/', version = '1.0.0' } = opts;
+
+  const spec: OpenApiSpec = {
+    openapi: '3.0.3',
+    info: { title, version, description: 'Auto-generated by ZeTa crawler from observed network traffic.' },
+    servers: [{ url: baseUrl }],
+    paths: {},
+  };
+
+  for (const obs of observations) {
+    const path = obs.urlPattern;
+    const method = obs.method.toLowerCase();
+
+    if (!spec.paths[path]) spec.paths[path] = {};
+
+    const params = extractPathParams(path);
+    const statusCode = obs.statusCode ?? 200;
+    const responses: OpenApiOperation['responses'] = {
+      [String(statusCode)]: {
+        description: statusCode < 400 ? 'Successful response' : 'Error response',
+        content: obs.responseShape
+          ? { 'application/json': { schema: shapeToJsonSchema(obs.responseShape) } }
+          : undefined,
+      },
+    };
+
+    const op: OpenApiOperation = {
+      summary: methodSummary(obs.method, path),
+      parameters: params.length > 0 ? params : undefined,
+      responses,
+      tags: [inferTag(path)],
+    };
+
+    spec.paths[path][method] = op;
+  }
+
+  return spec;
+}
+
+function shapeToJsonSchema(shape: unknown): unknown {
+  if (Array.isArray(shape)) return { type: 'array', items: shape.length > 0 ? shapeToJsonSchema(shape[0]) : {} };
+  if (shape && typeof shape === 'object') {
+    const props: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(shape as object)) props[k] = shapeToJsonSchema(v);
+    return { type: 'object', properties: props };
+  }
+  return { type: String(shape) };
+}
+
+export function specToYaml(spec: OpenApiSpec): string {
+  // Minimal YAML serializer — avoids yaml dep
+  function toYaml(val: unknown, indent = 0): string {
+    const pad = '  '.repeat(indent);
+    if (val === null || val === undefined) return 'null';
+    if (typeof val === 'string') return val.includes('\n') || val.includes(':') ? `"${val.replace(/"/g, '\\"')}"` : val;
+    if (typeof val === 'number' || typeof val === 'boolean') return String(val);
+    if (Array.isArray(val)) return val.map(v => `\n${pad}- ${toYaml(v, indent + 1).trimStart()}`).join('') || '[]';
+    if (typeof val === 'object') {
+      const entries = Object.entries(val as object);
+      if (entries.length === 0) return '{}';
+      return entries.map(([k, v]) => {
+        const vStr = toYaml(v, indent + 1);
+        return typeof v === 'object' && v !== null && !Array.isArray(v)
+          ? `\n${pad}${k}:${vStr}`
+          : `\n${pad}${k}: ${vStr.trimStart()}`;
+      }).join('');
+    }
+    return String(val);
+  }
+  return `openapi: "${spec.openapi}"${toYaml(spec, 0)}`;
+}

package/src/pdf-extractor.ts

@@ -0,0 +1,123 @@
+/**
+ * PDF extraction — discovers and extracts text from PDF URLs found during crawl.
+ *
+ * When the HTTP engine or browser engine discovers a link to a .pdf file,
+ * this module fetches the PDF, extracts its text content, and returns it
+ * as a screen-compatible markdown string for test generation.
+ *
+ * Uses pdf-parse (already installed in API package, accessible via dynamic import).
+ */
+
+const PDF_EXT = /\.pdf(\?.*)?$/i;
+const PDF_MIME = 'application/pdf';
+
+export interface PdfScreen {
+  url: string;
+  title: string;
+  markdown: string;
+  pageCount: number;
+  info: Record<string, string>;
+  sizeBytes: number;
+}
+
+export function isPdfUrl(url: string, contentType?: string): boolean {
+  return PDF_EXT.test(url) || (contentType?.includes(PDF_MIME) ?? false);
+}
+
+export async function extractPdfFromUrl(url: string, opts: {
+  userAgent?: string;
+  timeoutMs?: number;
+  maxSizeBytes?: number;
+} = {}): Promise<PdfScreen | null> {
+  const { userAgent = 'ZeTa-Crawler/1.0', timeoutMs = 30_000, maxSizeBytes = 50 * 1024 * 1024 } = opts;
+
+  let buffer: Buffer;
+  let sizeBytes: number;
+
+  try {
+    const response = await fetch(url, {
+      headers: { 'User-Agent': userAgent, 'Accept': 'application/pdf,*/*' },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!response.ok) return null;
+
+    const contentType = response.headers.get('content-type') ?? '';
+    if (!contentType.includes('pdf') && !PDF_EXT.test(url)) return null;
+
+    const arrayBuffer = await response.arrayBuffer();
+    sizeBytes = arrayBuffer.byteLength;
+    if (sizeBytes > maxSizeBytes) {
+      console.warn(`[pdf-extractor] PDF too large (${sizeBytes} bytes), skipping: ${url}`);
+      return null;
+    }
+    buffer = Buffer.from(arrayBuffer);
+  } catch (e: any) {
+    console.error(`[pdf-extractor] Failed to fetch PDF ${url}: ${e.message}`);
+    return null;
+  }
+
+  try {
+    // pdf-parse is installed in the API package — use dynamic import
+    // so this file compiles without adding pdf-parse to crawler's package.json
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore – no types for pdf-parse/lib/pdf-parse.js
+    const pdfParse = await import('pdf-parse/lib/pdf-parse.js').catch(
+      () => import('pdf-parse' as any)
+    ) as any;
+    const parse = pdfParse.default ?? pdfParse;
+    const data = await parse(buffer, { max: 0 }); // max: 0 = all pages
+
+    const title = (data.info?.Title as string) || extractTitleFromUrl(url);
+    const markdown = pdfTextToMarkdown(data.text ?? '', title);
+
+    return {
+      url,
+      title,
+      markdown,
+      pageCount: data.numpages ?? 0,
+      info: {
+        author: data.info?.Author ?? '',
+        subject: data.info?.Subject ?? '',
+        keywords: data.info?.Keywords ?? '',
+        creator: data.info?.Creator ?? '',
+      },
+      sizeBytes,
+    };
+  } catch (e: any) {
+    console.error(`[pdf-extractor] Failed to parse PDF ${url}: ${e.message}`);
+    return null;
+  }
+}
+
+function extractTitleFromUrl(url: string): string {
+  try {
+    const { pathname } = new URL(url);
+    const filename = pathname.split('/').pop() ?? 'document';
+    return filename.replace(/\.pdf$/i, '').replace(/[-_]/g, ' ').trim();
+  } catch {
+    return 'PDF Document';
+  }
+}
+
+function pdfTextToMarkdown(text: string, title: string): string {
+  if (!text.trim()) return `# ${title}\n\n*No extractable text content.*`;
+
+  // Clean up common PDF extraction artifacts
+  const cleaned = text
+    .replace(/\f/g, '\n\n---\n\n') // form feed = page break
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .replace(/[ \t]{2,}/g, ' ')
+    .trim();
+
+  return `# ${title}\n\n${cleaned}`;
+}
+
+/**
+ * Filter a list of discovered URLs to find PDF links.
+ * Used by http-engine and browser crawler to decide which links to pass to extractPdfFromUrl.
+ */
+export function filterPdfUrls(urls: string[]): string[] {
+  return urls.filter(u => PDF_EXT.test(u));
+}

package/src/performance-metrics.ts

@@ -0,0 +1,134 @@
+/**
+ * Performance metrics collection via CDP + Playwright page.evaluate().
+ *
+ * Collects Core Web Vitals and resource timing after page navigation.
+ * Stored alongside screen data for test generation context and regression detection.
+ *
+ * Metrics:
+ * - LCP (Largest Contentful Paint) — via PerformanceObserver in page
+ * - CLS (Cumulative Layout Shift) — via PerformanceObserver in page
+ * - TTFB (Time to First Byte) — from navigation timing
+ * - DOMContentLoaded — from navigation timing
+ * - Resource count and size by type
+ */
+
+import type { Page } from 'playwright';
+
+export interface CoreWebVitals {
+  lcp?: number;   // ms
+  cls?: number;   // unitless score
+  ttfb?: number;  // ms
+  fcp?: number;   // First Contentful Paint ms
+  domContentLoaded?: number; // ms
+  loadEventEnd?: number;     // ms
+}
+
+export interface ResourceSummary {
+  scripts: { count: number; totalBytes: number };
+  styles: { count: number; totalBytes: number };
+  images: { count: number; totalBytes: number };
+  fonts: { count: number; totalBytes: number };
+  other: { count: number; totalBytes: number };
+}
+
+export interface PagePerfMetrics {
+  url: string;
+  vitals: CoreWebVitals;
+  resources: ResourceSummary;
+  totalTransferBytes: number;
+  requestCount: number;
+  measuredAt: string;
+}
+
+export async function collectPerfMetrics(page: Page, url: string): Promise<PagePerfMetrics> {
+  const measuredAt = new Date().toISOString();
+
+  // Inject PerformanceObserver for LCP + CLS, wait up to 3s
+  let vitals: CoreWebVitals = {};
+  try {
+    vitals = await page.evaluate(() => {
+      return new Promise<any>((resolve) => {
+        const result: any = {};
+
+        // Navigation timing
+        const nav = performance.getEntriesByType('navigation')[0] as any;
+        if (nav) {
+          result.ttfb = Math.round(nav.responseStart - nav.requestStart);
+          result.domContentLoaded = Math.round(nav.domContentLoadedEventEnd);
+          result.loadEventEnd = Math.round(nav.loadEventEnd);
+        }
+
+        let lcpDone = false;
+        let clsDone = false;
+        const tryResolve = () => { if (lcpDone && clsDone) resolve(result); };
+
+        // LCP
+        try {
+          new PerformanceObserver((list) => {
+            const entries = list.getEntries();
+            if (entries.length > 0) result.lcp = Math.round((entries[entries.length - 1] as any).startTime);
+            lcpDone = true;
+            tryResolve();
+          }).observe({ type: 'largest-contentful-paint', buffered: true });
+        } catch { lcpDone = true; }
+
+        // CLS
+        try {
+          let cls = 0;
+          new PerformanceObserver((list) => {
+            for (const e of list.getEntries() as any[]) {
+              if (!e.hadRecentInput) cls += e.value;
+            }
+            result.cls = Math.round(cls * 1000) / 1000;
+            clsDone = true;
+            tryResolve();
+          }).observe({ type: 'layout-shift', buffered: true });
+        } catch { clsDone = true; }
+
+        // FCP
+        try {
+          const fcp = performance.getEntriesByName('first-contentful-paint')[0] as any;
+          if (fcp) result.fcp = Math.round(fcp.startTime);
+        } catch {}
+
+        // Fallback resolve after 3s
+        setTimeout(() => resolve(result), 3_000);
+      });
+    }).catch(() => ({}));
+  } catch { /* page closed or navigate already */ }
+
+  // Resource timing
+  let resources: ResourceSummary = {
+    scripts: { count: 0, totalBytes: 0 },
+    styles: { count: 0, totalBytes: 0 },
+    images: { count: 0, totalBytes: 0 },
+    fonts: { count: 0, totalBytes: 0 },
+    other: { count: 0, totalBytes: 0 },
+  };
+  let totalTransferBytes = 0;
+  let requestCount = 0;
+
+  try {
+    const entries = await page.evaluate(() =>
+      performance.getEntriesByType('resource').map((e: any) => ({
+        name: e.name,
+        initiatorType: e.initiatorType,
+        transferSize: e.transferSize ?? 0,
+      }))
+    ).catch(() => [] as any[]);
+
+    for (const e of entries) {
+      requestCount++;
+      totalTransferBytes += e.transferSize;
+      const cat = e.initiatorType === 'script' ? 'scripts'
+        : e.initiatorType === 'css' || e.name?.endsWith('.css') ? 'styles'
+        : e.initiatorType === 'img' ? 'images'
+        : e.name?.match(/\.(woff|woff2|ttf|otf|eot)/) ? 'fonts'
+        : 'other';
+      resources[cat as keyof ResourceSummary].count++;
+      resources[cat as keyof ResourceSummary].totalBytes += e.transferSize;
+    }
+  } catch {}
+
+  return { url, vitals, resources, totalTransferBytes, requestCount, measuredAt };
+}