@taodigital/crawler 0.0.0-stage → 1.2.0

package/src/responsive-detector.ts

@@ -0,0 +1,92 @@
+/**
+ * Responsive design detector — captures page at multiple breakpoints
+ * and detects layout differences between desktop and mobile viewports.
+ *
+ * Breakpoints: mobile(375), tablet(768), desktop(1280), wide(1920)
+ * Detects: viewport-specific content visibility, menu collapse state,
+ * font size changes, hidden/shown elements.
+ */
+
+import type { Page } from 'playwright';
+
+export interface ViewportCapture {
+  width: number;
+  height: number;
+  label: 'mobile' | 'tablet' | 'desktop' | 'wide';
+  screenshotBuffer?: Buffer;
+  visibleTextLength: number;
+  hasHamburgerMenu: boolean;
+  hiddenElements: number; // display:none element count
+  scrollHeight: number;
+}
+
+export interface ResponsiveReport {
+  url: string;
+  captures: ViewportCapture[];
+  isResponsive: boolean; // true if layout changes between viewports
+  hasMobileMenu: boolean;
+  issues: string[];
+}
+
+const BREAKPOINTS: Array<{ width: number; height: number; label: ViewportCapture['label'] }> = [
+  { width: 375, height: 812, label: 'mobile' },
+  { width: 768, height: 1024, label: 'tablet' },
+  { width: 1280, height: 800, label: 'desktop' },
+];
+
+export async function detectResponsive(
+  page: Page,
+  url: string,
+  opts: { captureScreenshots?: boolean } = {},
+): Promise<ResponsiveReport> {
+  const captures: ViewportCapture[] = [];
+  const issues: string[] = [];
+
+  for (const bp of BREAKPOINTS) {
+    try {
+      await page.setViewportSize({ width: bp.width, height: bp.height });
+      await page.waitForTimeout(500); // allow CSS reflow
+
+      const data = await page.evaluate(() => ({
+        visibleTextLength: (document.body.innerText ?? '').length,
+        hasHamburgerMenu: !!(
+          document.querySelector('[class*="hamburger"],[class*="menu-toggle"],[class*="nav-toggle"],[aria-label*="menu"],[aria-label*="Menu"]')
+        ),
+        hiddenElements: Array.from(document.querySelectorAll('*')).filter(
+          (el: any) => window.getComputedStyle(el).display === 'none'
+        ).length,
+        scrollHeight: document.body.scrollHeight,
+      })).catch(() => ({ visibleTextLength: 0, hasHamburgerMenu: false, hiddenElements: 0, scrollHeight: 0 }));
+
+      let screenshotBuffer: Buffer | undefined;
+      if (opts.captureScreenshots) {
+        screenshotBuffer = await page.screenshot({ type: 'jpeg', quality: 60 }).catch(() => undefined);
+      }
+
+      captures.push({ ...bp, ...data, screenshotBuffer });
+    } catch { /* viewport failed — skip */ }
+  }
+
+  // Restore to desktop
+  await page.setViewportSize({ width: 1280, height: 800 }).catch(() => {});
+
+  const mobile = captures.find(c => c.label === 'mobile');
+  const desktop = captures.find(c => c.label === 'desktop');
+
+  const isResponsive = !!(mobile && desktop && (
+    mobile.hiddenElements !== desktop.hiddenElements ||
+    mobile.scrollHeight !== desktop.scrollHeight ||
+    mobile.hasHamburgerMenu
+  ));
+
+  const hasMobileMenu = captures.some(c => c.label === 'mobile' && c.hasHamburgerMenu);
+
+  if (mobile && desktop && mobile.visibleTextLength > desktop.visibleTextLength * 1.3) {
+    issues.push('Mobile shows significantly more text than desktop — possible responsive issue');
+  }
+  if (!isResponsive && captures.length > 1) {
+    issues.push('Layout appears identical across breakpoints — may not be responsive');
+  }
+
+  return { url, captures, isResponsive, hasMobileMenu, issues };
+}

package/src/retry-policy.ts

@@ -0,0 +1,87 @@
+/**
+ * Retry policy — configurable exponential backoff with jitter.
+ * Covers: 5xx server errors, network timeouts, ECONNREFUSED, ECONNRESET.
+ * NOT retried: 4xx client errors (except 429 — handled separately), redirects.
+ */
+
+export interface RetryPolicyOpts {
+  maxRetries?: number;       // default 3
+  baseDelayMs?: number;      // default 1000
+  maxDelayMs?: number;       // default 30000
+  jitterMs?: number;         // default 500
+  retryOn?: number[];        // HTTP status codes to retry (default: [429, 500, 502, 503, 504])
+}
+
+export interface RetryResult<T> {
+  value: T;
+  attempts: number;
+  totalDelayMs: number;
+}
+
+const DEFAULT_RETRY_STATUSES = [429, 500, 502, 503, 504];
+
+function shouldRetry(error: any, retryOn: number[]): boolean {
+  // Network-level errors
+  if (error?.code && ['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'ENOTFOUND', 'EPIPE'].includes(error.code)) return true;
+  // Playwright navigation timeout
+  if (error?.message && /timeout|net::ERR_/i.test(error.message)) return true;
+  // HTTP status errors
+  if (typeof error?.status === 'number') return retryOn.includes(error.status);
+  return false;
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+export async function withRetry<T>(
+  fn: (attempt: number) => Promise<T>,
+  opts: RetryPolicyOpts = {},
+): Promise<RetryResult<T>> {
+  const {
+    maxRetries = 3,
+    baseDelayMs = 1_000,
+    maxDelayMs = 30_000,
+    jitterMs = 500,
+    retryOn = DEFAULT_RETRY_STATUSES,
+  } = opts;
+
+  let lastError: any;
+  let totalDelayMs = 0;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const value = await fn(attempt);
+      return { value, attempts: attempt + 1, totalDelayMs };
+    } catch (err) {
+      lastError = err;
+      if (attempt === maxRetries) break;
+      if (!shouldRetry(err, retryOn)) throw err; // non-retryable — fail fast
+
+      const backoff = Math.min(maxDelayMs, baseDelayMs * Math.pow(2, attempt));
+      const jitter = Math.random() * jitterMs;
+      const waitMs = Math.round(backoff + jitter);
+      totalDelayMs += waitMs;
+      await delay(waitMs);
+    }
+  }
+  throw lastError;
+}
+
+/** Wraps fetch() with retry policy */
+export async function fetchWithRetry(
+  url: string,
+  init: RequestInit = {},
+  retryOpts: RetryPolicyOpts = {},
+): Promise<Response> {
+  const result = await withRetry(async () => {
+    const res = await fetch(url, init);
+    if (retryOpts.retryOn?.includes(res.status) ?? DEFAULT_RETRY_STATUSES.includes(res.status)) {
+      const err: any = new Error(`HTTP ${res.status}`);
+      err.status = res.status;
+      throw err;
+    }
+    return res;
+  }, retryOpts);
+  return result.value;
+}

package/src/robots-txt.ts

@@ -0,0 +1,96 @@
+/**
+ * Minimal robots.txt fetcher + parser. No external deps. Caches per origin.
+ * Implements the subset of robots.txt spec used in practice:
+ *   User-agent, Disallow, Allow — longest match wins (RFC 9309).
+ */
+
+interface RobotsRule {
+  userAgent: string;
+  disallow: string[];
+  allow: string[];
+}
+
+function parseRobots(text: string): RobotsRule[] {
+  const rules: RobotsRule[] = [];
+  let current: RobotsRule | null = null;
+
+  for (const rawLine of text.split('\n')) {
+    const line = rawLine.split('#')[0].trim();
+    if (!line) { current = null; continue; }
+    const colonIdx = line.indexOf(':');
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim().toLowerCase();
+    const value = line.slice(colonIdx + 1).trim();
+
+    if (key === 'user-agent') {
+      // Start new block only when current block already has rules, otherwise
+      // accumulate multiple User-agent lines into one block.
+      if (!current || current.disallow.length > 0 || current.allow.length > 0) {
+        current = { userAgent: value.toLowerCase(), disallow: [], allow: [] };
+        rules.push(current);
+      } else {
+        current.userAgent = value.toLowerCase();
+      }
+    } else if (key === 'disallow' && current && value) {
+      current.disallow.push(value);
+    } else if (key === 'allow' && current && value) {
+      current.allow.push(value);
+    }
+  }
+
+  return rules;
+}
+
+function isAllowedByRules(rules: RobotsRule[], userAgent: string, pathname: string): boolean {
+  const ua = userAgent.toLowerCase();
+  const exactRules = rules.filter(r => r.userAgent === ua);
+  const wildcardRules = rules.filter(r => r.userAgent === '*');
+  const applicable = exactRules.length > 0 ? exactRules : wildcardRules;
+
+  if (applicable.length === 0) return true;
+
+  // Collect all matched allow/disallow directives; longest path wins.
+  const matched: Array<{ path: string; allow: boolean }> = [];
+  for (const rule of applicable) {
+    for (const p of rule.allow) {
+      if (pathname.startsWith(p)) matched.push({ path: p, allow: true });
+    }
+    for (const p of rule.disallow) {
+      if (pathname.startsWith(p)) matched.push({ path: p, allow: false });
+    }
+  }
+
+  if (matched.length === 0) return true;
+  matched.sort((a, b) => b.path.length - a.path.length);
+  return matched[0].allow;
+}
+
+export class RobotsCache {
+  private readonly cache = new Map<string, RobotsRule[]>();
+
+  async isAllowed(url: string, userAgent = 'ZeTa-Crawler'): Promise<boolean> {
+    let origin: string;
+    let pathname: string;
+    try {
+      const u = new URL(url);
+      origin = u.origin;
+      pathname = u.pathname || '/';
+    } catch {
+      return true;
+    }
+
+    if (!this.cache.has(origin)) {
+      try {
+        const res = await fetch(`${origin}/robots.txt`, {
+          headers: { 'User-Agent': userAgent },
+          signal: AbortSignal.timeout(5_000),
+        });
+        this.cache.set(origin, res.ok ? parseRobots(await res.text()) : []);
+      } catch {
+        this.cache.set(origin, []); // network error or timeout = no restrictions
+      }
+    }
+
+    return isAllowedByRules(this.cache.get(origin)!, userAgent, pathname);
+  }
+}

package/src/screen-reader.ts

@@ -0,0 +1,98 @@
+import type { Page } from 'playwright';
+
+/**
+ * Reads a page as a structured outline (cheap + reliable), the way
+ * Playwright MCP / the accessibility tree works — NOT by sending pixels to a
+ * vision model. Vision is a fallback for image-only pages (added later).
+ *
+ * Returns the interactive elements found, which the Screen Reader Agent then
+ * enriches with MEANING and saves to the Zeta Core.
+ */
+export interface RawElement {
+  role: string;
+  label: string;
+  selectorHint: string;
+  expectedData?: string;
+}
+
+export async function readScreen(page: any): Promise<RawElement[]> {
+  return page.evaluate(() => {
+    // esbuild injects __name() for named arrow-function constants (e.g. `const priority = ...`).
+    // Polyfill prevents ReferenceError when the serialized callback runs in the browser.
+    if (typeof (globalThis as any).__name === 'undefined') (globalThis as any).__name = (fn: any) => fn;
+    const out: { role: string; label: string; selectorHint: string; expectedData?: string }[] = [];
+    const seen = new Set<string>();
+
+    // Noise patterns to skip — cookie banners, footer chrome, version strings
+    // Intentionally excludes standalone "close" and "copy" — too many false positives
+    // (Close account, Close preview, Copy link, Copy to clipboard are all valid test targets)
+    const noiseLabel =
+      /^(cookie|consent|privacy policy|terms of use|copyright|©|\bv\d+\.\d+|got it|dismiss|skip to|powered by|copied|\s*$)/i;
+
+    // Include ARIA-role elements — Headless UI, Radix, Ant Design, Shadcn all use these instead of native tags
+    const nodes = document.querySelectorAll(
+      'input:not([type=hidden]), select, textarea, button, a[href], ' +
+      '[role="button"], [role="combobox"], [role="slider"], [role="switch"], ' +
+      '[role="tab"], [role="menuitem"], [role="searchbox"], [role="spinbutton"]'
+    );
+
+    nodes.forEach((el) => {
+      const htmlEl = el as HTMLElement;
+
+      // Skip invisible elements
+      const style = window.getComputedStyle(htmlEl);
+      if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return;
+      const rect = el.getBoundingClientRect();
+      // Allow zero-size elements that carry an accessible label (sr-only icon buttons, skip-nav links)
+      const hasAccessibleLabel = !!(el.getAttribute('aria-label') || el.getAttribute('aria-labelledby'));
+      if (rect.width === 0 && rect.height === 0 && !hasAccessibleLabel) return;
+
+      // Derive role
+      const tag = el.tagName.toLowerCase();
+      const role =
+        el.getAttribute('role') ||
+        (tag === 'input' ? ((el as HTMLInputElement).type || 'text') : tag);
+
+      // Derive the best human-readable label (prefer aria > placeholder > inner text)
+      const raw = (
+        el.getAttribute('aria-label') ||
+        el.getAttribute('placeholder') ||
+        (el.getAttribute('title') ?? '') ||
+        htmlEl.innerText?.replace(/\s+/g, ' ').trim() ||
+        el.getAttribute('name') ||
+        ''
+      ).substring(0, 80);
+
+      // Skip empty, noise patterns, or very long labels (likely container text)
+      if (!raw || noiseLabel.test(raw) || raw.length > 70) return;
+
+      // Deduplicate by role+normalised label
+      const key = `${role}:${raw.toLowerCase()}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+
+      let expectedData: string | undefined;
+      if (tag === 'input') {
+        const input = el as HTMLInputElement;
+        if (input.type === 'email' || /email/i.test(raw)) expectedData = 'valid_email';
+        else if (input.type === 'password' || /password/i.test(raw)) expectedData = 'password';
+        else if (input.type === 'tel' || /phone|mobile/i.test(raw)) expectedData = 'phone';
+        else if (input.type === 'date' || /\bdate\b/i.test(raw)) expectedData = 'date';
+        else if (/\b(code|otp|token)\b/i.test(raw)) expectedData = 'one_time_code';
+        else if (/\b(search|query)\b/i.test(raw)) expectedData = 'search_term';
+      }
+
+      out.push({ role, label: raw, selectorHint: tag, expectedData });
+    });
+
+    // Prioritise: form fields > buttons > links; within each group keep order
+    const priority = (e: typeof out[0]) => {
+      if (['email', 'password', 'text', 'tel', 'date', 'number', 'select', 'textarea'].includes(e.role)) return 0;
+      if (e.role === 'button' || e.role === 'submit') return 1;
+      return 2;
+    };
+    out.sort((a, b) => priority(a) - priority(b));
+
+    return out.slice(0, 25); // cap at 25 — enough context, not overwhelming
+  });
+}

package/src/screenshot-masker.ts

@@ -0,0 +1,98 @@
+/**
+ * Screenshot masker — blur or black-box PII regions in captured screenshots.
+ *
+ * Strategy: inject a CSS overlay into the page before screenshot capture that
+ * covers detected PII-likely elements (input[type=email], input[type=password],
+ * elements with PII-containing text) with a blur or solid black mask.
+ *
+ * This is a CSS-based approach (no image processing library needed):
+ * 1. Identify likely-PII DOM elements via selectors
+ * 2. Add an overlaid <div> with blur/black filter at each element's bounding box
+ * 3. Take screenshot
+ * 4. Remove overlays
+ *
+ * Falls back gracefully if elements are not found or overlay injection fails.
+ */
+
+import type { Page } from 'playwright';
+
+export interface MaskingOpts {
+  /** Additional CSS selectors to mask (in addition to defaults) */
+  extraSelectors?: string[];
+  /** Masking style: 'blur' or 'blackout' */
+  style?: 'blur' | 'blackout';
+  /** Blur strength in px (default 8) */
+  blurPx?: number;
+}
+
+// Default PII-sensitive selectors
+const DEFAULT_PII_SELECTORS = [
+  'input[type="email"]',
+  'input[type="password"]',
+  'input[type="tel"]',
+  'input[autocomplete="cc-number"]',
+  'input[autocomplete="cc-csc"]',
+  'input[autocomplete="ssn"]',
+  '[data-pii="true"]',
+  '[data-sensitive="true"]',
+];
+
+export async function maskScreenshot(
+  page: Page,
+  opts: MaskingOpts = {},
+): Promise<{ maskedCount: number; screenshot: Buffer }> {
+  const { extraSelectors = [], style = 'blur', blurPx = 8 } = opts;
+  const selectors = [...DEFAULT_PII_SELECTORS, ...extraSelectors];
+
+  let maskedCount = 0;
+  const overlayIds: string[] = [];
+
+  // Inject CSS overlays
+  try {
+    const result = await page.evaluate(({ selectors, style, blurPx }) => {
+      const ids: string[] = [];
+      for (const sel of selectors) {
+        try {
+          const elements = Array.from(document.querySelectorAll(sel));
+          for (const el of elements) {
+            const rect = el.getBoundingClientRect();
+            if (rect.width === 0 || rect.height === 0) continue;
+            const overlay = document.createElement('div');
+            const id = `__zeta_mask_${Math.random().toString(36).slice(2)}`;
+            overlay.id = id;
+            overlay.style.cssText = [
+              'position: fixed',
+              `top: ${rect.top + window.scrollY}px`,
+              `left: ${rect.left + window.scrollX}px`,
+              `width: ${rect.width}px`,
+              `height: ${rect.height}px`,
+              'z-index: 2147483647',
+              style === 'blur'
+                ? `backdrop-filter: blur(${blurPx}px); -webkit-backdrop-filter: blur(${blurPx}px); background: rgba(0,0,0,0.1);`
+                : 'background: #000000;',
+              'pointer-events: none',
+            ].join('; ');
+            document.body.appendChild(overlay);
+            ids.push(id);
+          }
+        } catch { /* selector error */ }
+      }
+      return ids;
+    }, { selectors, style, blurPx });
+
+    overlayIds.push(...result);
+    maskedCount = result.length;
+  } catch { /* non-fatal */ }
+
+  // Take screenshot with overlays active
+  const screenshot = await page.screenshot({ type: 'png', fullPage: false });
+
+  // Remove overlays
+  if (overlayIds.length > 0) {
+    await page.evaluate((ids) => {
+      for (const id of ids) document.getElementById(id)?.remove();
+    }, overlayIds).catch(() => {});
+  }
+
+  return { maskedCount, screenshot };
+}

package/src/seo-checker.ts

@@ -0,0 +1,134 @@
+/**
+ * SEO indexability checker — determines if a page is crawlable and indexable.
+ *
+ * Checks:
+ * 1. X-Robots-Tag response header (noindex, nofollow, noarchive)
+ * 2. <meta name="robots"> tag (noindex, nofollow)
+ * 3. Canonical URL (self-canonical vs cross-canonical)
+ * 4. rel="nofollow" on outbound links
+ * 5. hreflang tags (multilingual)
+ * 6. Open Graph completeness (og:title, og:description, og:image)
+ * 7. Structured data presence (JSON-LD)
+ * 8. Meta description
+ * 9. Title tag length (< 60 chars recommended)
+ * 10. URL structure (query params, fragments, excessive depth)
+ */
+
+import type { Page } from 'playwright';
+
+export interface SeoIssue {
+  rule: string;
+  severity: 'critical' | 'warning' | 'info';
+  message: string;
+  value?: string;
+}
+
+export interface SeoCheckResult {
+  url: string;
+  isIndexable: boolean;
+  canonicalUrl?: string;
+  isSelfCanonical?: boolean;
+  hreflang: Record<string, string>; // lang → url
+  issues: SeoIssue[];
+  score: number; // 0-100
+  checkedAt: string;
+}
+
+export async function checkSeo(page: Page, url: string, responseHeaders: Record<string, string> = {}): Promise<SeoCheckResult> {
+  const issues: SeoIssue[] = [];
+  const checkedAt = new Date().toISOString();
+  let isIndexable = true;
+
+  // 1. X-Robots-Tag
+  const robotsHeader = responseHeaders['x-robots-tag'] ?? '';
+  if (/noindex/i.test(robotsHeader)) {
+    isIndexable = false;
+    issues.push({ rule: 'x-robots-noindex', severity: 'critical', message: 'X-Robots-Tag: noindex found in response header', value: robotsHeader });
+  }
+
+  // 2-9. Page-level checks
+  const pageData = await page.evaluate(() => {
+    const meta = (name: string) => document.querySelector(`meta[name="${name}"]`)?.getAttribute('content') ?? '';
+    const og = (prop: string) => document.querySelector(`meta[property="og:${prop}"]`)?.getAttribute('content') ?? '';
+    const canonical = document.querySelector('link[rel="canonical"]')?.getAttribute('href') ?? '';
+    const hreflang: Record<string, string> = {};
+    document.querySelectorAll('link[rel="alternate"][hreflang]').forEach((el: any) => {
+      hreflang[el.getAttribute('hreflang')] = el.getAttribute('href') ?? '';
+    });
+    const jsonLd = Array.from(document.querySelectorAll('script[type="application/ld+json"]')).map((s: any) => s.textContent ?? '');
+    return {
+      robotsMeta: meta('robots'),
+      description: meta('description'),
+      title: document.title ?? '',
+      canonical,
+      hreflang,
+      ogTitle: og('title'),
+      ogDescription: og('description'),
+      ogImage: og('image'),
+      hasJsonLd: jsonLd.length > 0,
+      jsonLd,
+    };
+  }).catch(() => ({
+    robotsMeta: '', description: '', title: '', canonical: '', hreflang: {},
+    ogTitle: '', ogDescription: '', ogImage: '', hasJsonLd: false, jsonLd: [],
+  }));
+
+  // 2. Meta robots
+  if (/noindex/i.test(pageData.robotsMeta)) {
+    isIndexable = false;
+    issues.push({ rule: 'meta-robots-noindex', severity: 'critical', message: 'Meta robots noindex found', value: pageData.robotsMeta });
+  }
+
+  // 3. Canonical
+  let isSelfCanonical: boolean | undefined;
+  if (pageData.canonical) {
+    isSelfCanonical = pageData.canonical === url || pageData.canonical.replace(/\/$/, '') === url.replace(/\/$/, '');
+    if (!isSelfCanonical) {
+      issues.push({ rule: 'cross-canonical', severity: 'warning', message: 'Cross-canonical points elsewhere', value: pageData.canonical });
+    }
+  } else {
+    issues.push({ rule: 'missing-canonical', severity: 'warning', message: 'No canonical link tag' });
+  }
+
+  // 4. Title
+  if (!pageData.title) {
+    issues.push({ rule: 'missing-title', severity: 'critical', message: 'Page has no title tag' });
+  } else if (pageData.title.length > 60) {
+    issues.push({ rule: 'title-too-long', severity: 'warning', message: `Title ${pageData.title.length} chars (>60)`, value: pageData.title });
+  }
+
+  // 5. Meta description
+  if (!pageData.description) {
+    issues.push({ rule: 'missing-description', severity: 'warning', message: 'Missing meta description' });
+  } else if (pageData.description.length > 160) {
+    issues.push({ rule: 'description-too-long', severity: 'info', message: `Description ${pageData.description.length} chars (>160)` });
+  }
+
+  // 6. OG tags
+  if (!pageData.ogTitle) issues.push({ rule: 'missing-og-title', severity: 'info', message: 'Missing og:title' });
+  if (!pageData.ogImage) issues.push({ rule: 'missing-og-image', severity: 'info', message: 'Missing og:image' });
+
+  // 7. Structured data
+  if (!pageData.hasJsonLd) issues.push({ rule: 'no-structured-data', severity: 'info', message: 'No JSON-LD structured data found' });
+
+  // 8. URL depth
+  try {
+    const depth = new URL(url).pathname.split('/').filter(Boolean).length;
+    if (depth > 5) issues.push({ rule: 'deep-url', severity: 'info', message: `URL depth ${depth} (>5 levels)`, value: url });
+  } catch {}
+
+  const criticals = issues.filter(i => i.severity === 'critical').length;
+  const warnings = issues.filter(i => i.severity === 'warning').length;
+  const score = Math.max(0, 100 - criticals * 20 - warnings * 5 - issues.filter(i => i.severity === 'info').length * 2);
+
+  return {
+    url,
+    isIndexable,
+    canonicalUrl: pageData.canonical || undefined,
+    isSelfCanonical,
+    hreflang: pageData.hreflang,
+    issues,
+    score,
+    checkedAt,
+  };
+}