@etus/seven-skill 0.1.0-beta.1

package/cli/engine/engines/static-html/detect-html.mjs

@@ -0,0 +1,211 @@
+// SPDX-License-Identifier: Apache-2.0
+// ETUS Digital — Seven Design System. Detector architecture adapted from
+// impeccable (Paul Bakaus, Apache-2.0). See packages/seven-skill/NOTICE.md.
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { isFullPage } from '../../shared/page.mjs'
+import { finding } from '../../findings.mjs'
+import { profileFindings, profileStep, profileStepAsync } from '../../profile/profiler.mjs'
+import {
+  checkElementBorders,
+  checkElementColors,
+  checkElementGlow,
+  checkElementLucideIcon,
+  checkElementMotion,
+  checkElementPillOnButton,
+  checkElementQuality,
+  checkElementTactilePress,
+  checkHtmlPatterns,
+  checkPageLayout,
+  checkPageQualityFromDoc,
+  checkPageTypography,
+  resolveBackground,
+} from '../../rules/checks.mjs'
+import { detectText } from '../regex/detect-text.mjs'
+import {
+  StaticDocument,
+  buildStaticStyleMap,
+  buildStaticWindow,
+  collectStaticCssText,
+} from './css-cascade.mjs'
+
+// ─── Static-HTML engine ─────────────────────────────────────────────────────
+// HTML-file detector. Two layers:
+//  1. The Seven text checks run over the raw markup (inline <style>, style=,
+//     class= attributes are all part of the file text).
+//  2. The document is parsed with htmlparser2, its CSS cascade is resolved by
+//     css-cascade.mjs into a StaticDocument, and per-element + page-level
+//     checks run against the computed styles. This surfaces drift that lives
+//     only in the resolved cascade — a side-stripe border declared in a
+//     stylesheet rule, a low-contrast token pair, mixed radius scales.
+// When the static parser is unavailable the text scan still runs as a fallback.
+
+// Per-element rules: each names a selector and a check. `customPropMap` is
+// reserved for var() resolution the cascade already performs upstream.
+const STATIC_ELEMENT_RULES = [
+  {
+    id: 'side-stripe-border',
+    selector: '*',
+    run: (el, tag, style) => checkElementBorders(tag, style, null),
+  },
+  {
+    id: 'color-rules',
+    selector: '*',
+    run: (el, tag, style, window) => checkElementColors(el, style, tag, window),
+  },
+  {
+    id: 'shadows-not-borders',
+    selector: '*',
+    run: (el, tag, style, window) =>
+      checkElementGlow(tag, style, resolveBackground(el.parentElement || el, window)),
+  },
+  {
+    id: 'motion-rules',
+    selector: '*',
+    run: (el, tag, style) => checkElementMotion(tag, style),
+  },
+  {
+    id: 'missing-tactile-press',
+    selector: 'button,a,[role]',
+    run: (el, tag, style) => checkElementTactilePress(el, style, tag),
+  },
+  {
+    id: 'pill-on-button',
+    selector: 'button,[role="button"]',
+    run: (el, tag, style) => checkElementPillOnButton(el, style, tag),
+  },
+  {
+    id: 'non-lucide-icon',
+    selector: 'svg',
+    run: (el, tag) => checkElementLucideIcon(el, tag),
+  },
+  {
+    id: 'quality-rules',
+    selector: '*',
+    run: (el, tag, style, window) => checkElementQuality(el, style, tag, window),
+  },
+]
+
+/**
+ * @param {string} filePath path to an HTML file
+ * @param {{ ruleIds?: string[], profile?: object }} [options]
+ * @returns {Promise<Array>} normalized findings
+ */
+async function detectHtml(filePath, options = {}) {
+  const profile = options?.profile
+  const ruleIds = options?.ruleIds || null
+
+  const html = profileStep(
+    profile,
+    { engine: 'static-html', phase: 'setup', ruleId: 'read-html', target: filePath },
+    () => fs.readFileSync(filePath, 'utf-8')
+  )
+
+  // Layer 1: the Seven text checks over the raw markup. Always runs — even on
+  // the static-parser success path — so inline style=/class= drift surfaces.
+  const findings = detectText(html, filePath, options)
+
+  let modules
+  try {
+    modules = await profileStepAsync(
+      profile,
+      { engine: 'static-html', phase: 'setup', ruleId: 'import-static-parser', target: filePath },
+      async () => {
+        const [htmlparser2, cssSelect, csstree, domutils] = await Promise.all([
+          import('htmlparser2'),
+          import('css-select'),
+          import('css-tree'),
+          import('domutils'),
+        ])
+        return {
+          parseDocument: htmlparser2.parseDocument,
+          selectAll: cssSelect.selectAll,
+          selectOne: cssSelect.selectOne,
+          is: cssSelect.is,
+          csstree,
+          domutils,
+        }
+      }
+    )
+  } catch {
+    // Static parser unavailable — the text scan above is the result.
+    return findings
+  }
+
+  const resolvedPath = path.resolve(filePath)
+  const fileDir = path.dirname(resolvedPath)
+  let root
+  try {
+    root = profileStep(
+      profile,
+      { engine: 'static-html', phase: 'parse-html', ruleId: 'parse-document', target: filePath },
+      () => modules.parseDocument(html, { lowerCaseAttributeNames: false, lowerCaseTags: true })
+    )
+  } catch {
+    return findings
+  }
+
+  const cssText = collectStaticCssText(root, fileDir, profile, filePath, modules)
+  const document = new StaticDocument(root, modules)
+  buildStaticStyleMap(root, document, cssText, modules, profile, filePath)
+  const window = buildStaticWindow(document)
+
+  // Layer 2a: per-element checks over the resolved cascade.
+  const runElementCheck = (ruleId, callback) =>
+    profile
+      ? profileFindings(profile, { engine: 'static-html', phase: 'element', ruleId, target: filePath }, callback)
+      : callback()
+
+  for (const rule of STATIC_ELEMENT_RULES) {
+    const elements = document.querySelectorAll(rule.selector)
+    for (const el of elements) {
+      const tag = el.tagName.toLowerCase()
+      const style = window.getComputedStyle(el)
+      for (const f of runElementCheck(rule.id, () => rule.run(el, tag, style, window))) {
+        if (ruleIds && !ruleIds.includes(f.id)) continue
+        findings.push(finding(f.id, filePath, f.snippet))
+      }
+    }
+  }
+
+  // Layer 2b: page-level checks — only on full pages.
+  if (isFullPage(html)) {
+    const runPageCheck = (ruleId, callback) =>
+      profile
+        ? profileFindings(profile, { engine: 'static-html', phase: 'page', ruleId, target: filePath }, callback)
+        : callback()
+    const pushPage = (raw) => {
+      for (const f of raw) {
+        if (ruleIds && !ruleIds.includes(f.id)) continue
+        findings.push(finding(f.id, filePath, f.snippet))
+      }
+    }
+    pushPage(runPageCheck('flat-type-hierarchy', () => checkPageTypography(document, window)))
+    pushPage(runPageCheck('layout-rules', () => checkPageLayout(document, window)))
+    pushPage(runPageCheck('skipped-heading', () => checkPageQualityFromDoc(document)))
+    pushPage(
+      runPageCheck('html-patterns', () =>
+        // bounce-easing and layout-transition are already covered by the regex
+        // matchers on the same markup — drop them here to avoid double-counting.
+        checkHtmlPatterns(html).filter(
+          (item) => item.id !== 'bounce-easing' && item.id !== 'layout-transition'
+        )
+      )
+    )
+  }
+
+  // Deduplicate (same antipattern + snippet within 2 lines). The text-scan
+  // layer and the cascade layer can both surface the same drift.
+  const deduped = []
+  for (const f of findings) {
+    const isDupe = deduped.some(
+      (d) => d.antipattern === f.antipattern && d.snippet === f.snippet && Math.abs((d.line || 0) - (f.line || 0)) <= 2
+    )
+    if (!isDupe) deduped.push(f)
+  }
+  return deduped
+}
+
+export { STATIC_ELEMENT_RULES, detectHtml }

package/cli/engine/engines/visual/screenshot-contrast.mjs

@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: Apache-2.0
+// ETUS Digital — Seven Design System. Detector architecture adapted from
+// impeccable (Paul Bakaus, Apache-2.0). See packages/seven-skill/NOTICE.md.
+function sanitizeScreenshotClip(clip, viewport) {
+  if (!clip) return null;
+  const x = Math.max(0, Math.floor(clip.x || 0));
+  const y = Math.max(0, Math.floor(clip.y || 0));
+  const width = Math.min(
+    Math.max(1, Math.ceil(clip.width || 0)),
+    Math.max(1, viewport?.width || 1600),
+  );
+  const height = Math.min(
+    Math.max(1, Math.ceil(clip.height || 0)),
+    320,
+  );
+  if (width < 1 || height < 1) return null;
+  return { x, y, width, height };
+}
+
+async function compareScreenshotContrast(page, beforeBase64, afterBase64, candidate) {
+  return page.evaluate(async ({ beforeBase64, afterBase64, candidate }) => {
+    const loadImage = (base64) => new Promise((resolve, reject) => {
+      const img = new Image();
+      img.onload = () => resolve(img);
+      img.onerror = () => reject(new Error('Could not decode contrast screenshot'));
+      img.src = `data:image/png;base64,${base64}`;
+    });
+    const [before, after] = await Promise.all([loadImage(beforeBase64), loadImage(afterBase64)]);
+    const width = Math.min(before.width, after.width);
+    const height = Math.min(before.height, after.height);
+    if (width < 1 || height < 1) return null;
+
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d', { willReadFrequently: true });
+    if (!ctx) return null;
+
+    ctx.drawImage(before, 0, 0, width, height);
+    const beforePixels = ctx.getImageData(0, 0, width, height).data;
+    ctx.clearRect(0, 0, width, height);
+    ctx.drawImage(after, 0, 0, width, height);
+    const afterPixels = ctx.getImageData(0, 0, width, height).data;
+
+    const luminance = ({ r, g, b }) => {
+      const convert = c => {
+        const v = c / 255;
+        return v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+      };
+      return 0.2126 * convert(r) + 0.7152 * convert(g) + 0.0722 * convert(b);
+    };
+    const ratio = (a, b) => {
+      const l1 = luminance(a);
+      const l2 = luminance(b);
+      return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
+    };
+
+    const cssTextColor = candidate.textColor && !candidate.preferRenderedForeground
+      ? {
+          r: candidate.textColor.r,
+          g: candidate.textColor.g,
+          b: candidate.textColor.b,
+        }
+      : null;
+    const ratios = [];
+    let glyphPixels = 0;
+    let strongestDelta = 0;
+    for (let i = 0; i < beforePixels.length; i += 4) {
+      const delta = Math.abs(beforePixels[i] - afterPixels[i])
+        + Math.abs(beforePixels[i + 1] - afterPixels[i + 1])
+        + Math.abs(beforePixels[i + 2] - afterPixels[i + 2])
+        + Math.abs(beforePixels[i + 3] - afterPixels[i + 3]);
+      strongestDelta = Math.max(strongestDelta, delta);
+      if (delta < 10) continue;
+      glyphPixels++;
+      const fg = cssTextColor || {
+        r: beforePixels[i],
+        g: beforePixels[i + 1],
+        b: beforePixels[i + 2],
+      };
+      const bg = {
+        r: afterPixels[i],
+        g: afterPixels[i + 1],
+        b: afterPixels[i + 2],
+      };
+      ratios.push(ratio(fg, bg));
+    }
+
+    if (ratios.length < 8) {
+      return {
+        glyphPixels,
+        strongestDelta,
+        worstRatio: null,
+        p10Ratio: null,
+        medianRatio: null,
+      };
+    }
+
+    ratios.sort((a, b) => a - b);
+    const pick = pct => ratios[Math.min(ratios.length - 1, Math.max(0, Math.floor((pct / 100) * ratios.length)))];
+    return {
+      glyphPixels,
+      strongestDelta,
+      worstRatio: ratios[0],
+      p10Ratio: pick(10),
+      medianRatio: pick(50),
+    };
+  }, { beforeBase64, afterBase64, candidate });
+}
+
+async function captureVisualContrastCandidate(page, candidate, viewport) {
+  const clip = sanitizeScreenshotClip(candidate.clip, viewport);
+  if (!clip) return null;
+
+  const beforeBase64 = await page.screenshot({
+    encoding: 'base64',
+    clip,
+    captureBeyondViewport: true,
+  });
+  const token = `impeccable-contrast-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const applied = await page.evaluate(({ selector, token, backgroundClipText }) => {
+    let el;
+    try {
+      el = document.querySelector(selector);
+    } catch {
+      return false;
+    }
+    if (!el) return false;
+    let style = document.getElementById('impeccable-visual-contrast-hide-style');
+    if (!style) {
+      style = document.createElement('style');
+      style.id = 'impeccable-visual-contrast-hide-style';
+      style.textContent = [
+        '[data-impeccable-visual-contrast-target] {',
+        '  color: transparent !important;',
+        '  -webkit-text-fill-color: transparent !important;',
+        '  text-shadow: none !important;',
+        '}',
+        '[data-impeccable-visual-contrast-target][data-impeccable-bgclip-text="true"] {',
+        '  background-image: none !important;',
+        '}',
+      ].join('\n');
+      document.head.appendChild(style);
+    }
+    el.setAttribute('data-impeccable-visual-contrast-target', token);
+    if (backgroundClipText) el.setAttribute('data-impeccable-bgclip-text', 'true');
+    return true;
+  }, {
+    selector: candidate.selector,
+    token,
+    backgroundClipText: candidate.backgroundClipText,
+  });
+  if (!applied) return null;
+
+  let afterBase64;
+  try {
+    afterBase64 = await page.screenshot({
+      encoding: 'base64',
+      clip,
+      captureBeyondViewport: true,
+    });
+  } finally {
+    await page.evaluate(({ selector }) => {
+      try {
+        const el = document.querySelector(selector);
+        if (el) {
+          el.removeAttribute('data-impeccable-visual-contrast-target');
+          el.removeAttribute('data-impeccable-bgclip-text');
+        }
+      } catch {
+        // Ignore invalid or stale selectors during cleanup.
+      }
+    }, { selector: candidate.selector }).catch(() => {});
+  }
+
+  const metrics = await compareScreenshotContrast(page, beforeBase64, afterBase64, candidate);
+  if (!metrics || !Number.isFinite(metrics.p10Ratio) || metrics.glyphPixels < 8) return null;
+  const measuredRatio = metrics.p10Ratio;
+  if (measuredRatio >= candidate.threshold) return null;
+  const textLabel = candidate.text ? ` "${candidate.text}"` : '';
+  const reasonLabel = (candidate.reasons || []).slice(0, 3).join(', ') || 'visual background';
+  return {
+    id: 'low-contrast',
+    snippet: `pixel contrast ${measuredRatio.toFixed(1)}:1 median ${metrics.medianRatio.toFixed(1)}:1 (need ${candidate.threshold}:1) on ${reasonLabel}${textLabel}`,
+  };
+}
+
+export {
+  sanitizeScreenshotClip,
+  compareScreenshotContrast,
+  captureVisualContrastCandidate,
+};

package/cli/engine/findings.mjs

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+// ETUS Digital — Seven Design System. Detector architecture adapted from
+// impeccable (Paul Bakaus, Apache-2.0). See packages/seven-skill/NOTICE.md.
+
+import { getAntipattern } from './registry/seven-antipatterns.mjs'
+
+/**
+ * Build a normalized finding record. Every engine (regex, static-html,
+ * browser) produces findings through this helper so the shape is identical
+ * regardless of detection path.
+ *
+ * @returns {{ antipattern: string, name: string, description: string,
+ *   category: string, severity: string, file: string, line: number,
+ *   snippet: string }}
+ */
+export function finding(id, filePath, snippet, line = 0) {
+  const ap = getAntipattern(id)
+  return {
+    antipattern: id,
+    name: ap ? ap.name : id,
+    description: ap ? ap.description : '',
+    category: ap ? ap.category : 'quality',
+    severity: ap && ap.severity ? ap.severity : 'warning',
+    file: filePath,
+    line,
+    snippet,
+  }
+}

package/cli/engine/node/file-system.mjs

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: Apache-2.0
+// ETUS Digital — Seven Design System. Detector architecture adapted from
+// impeccable (Paul Bakaus, Apache-2.0). See packages/seven-skill/NOTICE.md.
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+// ─── File walker ────────────────────────────────────────────────────────────
+
+export const SKIP_DIRS = new Set([
+  'node_modules', '.git', 'dist', 'build', 'out', '.next', '.nuxt', '.output',
+  '.svelte-kit', '__pycache__', '.turbo', '.vercel', '.netlify', '.cache',
+  'coverage', '.worktrees',
+])
+
+// Markdown is intentionally excluded: docs legitimately contain code examples
+// of anti-patterns (the "do not do this" kind), which the detector must not
+// flag. The detector scans code, not documentation.
+export const SCANNABLE_EXTENSIONS = new Set([
+  '.html', '.htm', '.css', '.scss', '.less',
+  '.jsx', '.tsx', '.js', '.ts', '.mjs', '.cjs',
+  '.vue', '.svelte', '.astro',
+])
+
+export const HTML_EXTENSIONS = new Set(['.html', '.htm'])
+
+// Story and test files are scaffolding, not shipping UI. Their string
+// literals legitimately carry demo prose and intentional anti-pattern
+// examples — the detector targets production code, so the walker skips them.
+const NON_SHIPPING_FILE_RE = /\.(?:stories|story|test|spec)\.[a-z]+$/i
+
+export function isShippingSourceFile(name) {
+  return !NON_SHIPPING_FILE_RE.test(name)
+}
+
+export function walkDir(dir, maxFiles = 50000) {
+  const files = []
+  const stack = [dir]
+  while (stack.length > 0 && files.length < maxFiles) {
+    const current = stack.pop()
+    let entries
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry.name)) continue
+      const full = path.join(current, entry.name)
+      if (entry.isDirectory()) {
+        stack.push(full)
+      } else if (
+        entry.isFile() &&
+        SCANNABLE_EXTENSIONS.has(path.extname(entry.name).toLowerCase()) &&
+        isShippingSourceFile(entry.name)
+      ) {
+        files.push(full)
+      }
+    }
+  }
+  return files
+}
+
+const PACKAGE_NAME_CACHE = new Map()
+
+/**
+ * Walk up from `filePath` until a package.json is found. Returns its `name`
+ * field, or null. Used for the package-aware rule exemption: inside the Seven
+ * monorepo this resolves `@etus/ui`; inside a consumer it resolves files under
+ * `node_modules/@etus/ui/`.
+ */
+export function findOwningPackageName(filePath) {
+  let current = path.dirname(path.resolve(filePath))
+  while (current) {
+    const cached = PACKAGE_NAME_CACHE.get(current)
+    if (cached !== undefined) return cached
+    const candidate = path.join(current, 'package.json')
+    let exists = false
+    try {
+      exists = fs.statSync(candidate).isFile()
+    } catch {
+      exists = false
+    }
+    if (exists) {
+      let name = null
+      try {
+        const pkg = JSON.parse(fs.readFileSync(candidate, 'utf8'))
+        name = typeof pkg.name === 'string' ? pkg.name : null
+      } catch {
+        name = null
+      }
+      PACKAGE_NAME_CACHE.set(current, name)
+      return name
+    }
+    const parent = path.dirname(current)
+    if (parent === current) break
+    current = parent
+  }
+  return null
+}
+
+// ─── Import graph (multi-file awareness) ────────────────────────────────────
+
+function resolveImport(specifier, fromDir, fileSet) {
+  if (!/^[./]/.test(specifier)) return null
+  const base = path.resolve(fromDir, specifier)
+  if (fileSet.has(base)) return base
+  for (const ext of SCANNABLE_EXTENSIONS) {
+    if (fileSet.has(base + ext)) return base + ext
+  }
+  for (const ext of SCANNABLE_EXTENSIONS) {
+    const indexFile = path.join(base, 'index' + ext)
+    if (fileSet.has(indexFile)) return indexFile
+  }
+  return null
+}
+
+export function buildImportGraph(files) {
+  const fileSet = new Set(files)
+  const graph = new Map()
+  for (const file of files) {
+    let content
+    try {
+      content = fs.readFileSync(file, 'utf-8')
+    } catch {
+      graph.set(file, new Set())
+      continue
+    }
+    const dir = path.dirname(file)
+    const imports = new Set()
+    const esRe = /import\s+(?:[\s\S]*?from\s+)?['"]([^'"]+)['"]/g
+    let m
+    while ((m = esRe.exec(content)) !== null) {
+      const resolved = resolveImport(m[1], dir, fileSet)
+      if (resolved) imports.add(resolved)
+    }
+    const cssRe = /@import\s+(?:url\(\s*)?['"]?([^'");\s]+)['"]?\s*\)?/g
+    while ((m = cssRe.exec(content)) !== null) {
+      const resolved = resolveImport(m[1], dir, fileSet)
+      if (resolved) imports.add(resolved)
+    }
+    graph.set(file, imports)
+  }
+  return graph
+}
+
+// ─── Framework dev server detection ─────────────────────────────────────────
+
+export const FRAMEWORK_CONFIGS = [
+  { name: 'Next.js', files: ['next.config.js', 'next.config.mjs', 'next.config.ts'], defaultPort: 3000, portRe: /port\s*[:=]\s*(\d+)/, fingerprint: { header: 'x-powered-by', value: /next/i } },
+  { name: 'SvelteKit', files: ['svelte.config.js', 'svelte.config.ts'], defaultPort: 5173, portRe: /port\s*[:=]\s*(\d+)/, fingerprint: { header: 'x-sveltekit-page', value: null } },
+  { name: 'Nuxt', files: ['nuxt.config.js', 'nuxt.config.ts'], defaultPort: 3000, portRe: /port\s*[:=]\s*(\d+)/, fingerprint: { header: 'x-powered-by', value: /nuxt/i } },
+  { name: 'Vite', files: ['vite.config.js', 'vite.config.ts', 'vite.config.mjs'], defaultPort: 5173, portRe: /port\s*[:=]\s*(\d+)/, fingerprint: { body: /@vite\/client/ } },
+  { name: 'Astro', files: ['astro.config.js', 'astro.config.ts', 'astro.config.mjs'], defaultPort: 4321, portRe: /port\s*[:=]\s*(\d+)/, fingerprint: { body: /astro/i } },
+]
+
+export function detectFrameworkConfig(dir) {
+  let entries
+  try {
+    entries = fs.readdirSync(dir)
+  } catch {
+    return null
+  }
+  const entrySet = new Set(entries)
+  for (const cfg of FRAMEWORK_CONFIGS) {
+    const match = cfg.files.find((f) => entrySet.has(f))
+    if (!match) continue
+    const configPath = path.join(dir, match)
+    let port = cfg.defaultPort
+    try {
+      const portMatch = fs.readFileSync(configPath, 'utf-8').match(cfg.portRe)
+      if (portMatch) port = parseInt(portMatch[1], 10)
+    } catch {
+      // use default
+    }
+    return { name: cfg.name, port, configPath, fingerprint: cfg.fingerprint }
+  }
+  return null
+}
+
+/** Probe whether a dev server is listening; optionally verify framework. */
+export async function isPortListening(port, fingerprint = null) {
+  if (!fingerprint) {
+    const net = await import('node:net')
+    return new Promise((resolve) => {
+      const sock = net.default.createConnection({ port, host: '127.0.0.1' })
+      sock.setTimeout(500)
+      sock.on('connect', () => { sock.destroy(); resolve({ listening: true, matched: true }) })
+      sock.on('error', () => resolve({ listening: false }))
+      sock.on('timeout', () => { sock.destroy(); resolve({ listening: false }) })
+    })
+  }
+  try {
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), 2000)
+    const res = await fetch(`http://localhost:${port}/`, { signal: controller.signal, redirect: 'follow' })
+    clearTimeout(timeout)
+    if (fingerprint.header) {
+      const val = res.headers.get(fingerprint.header)
+      if (val && (!fingerprint.value || fingerprint.value.test(val))) {
+        return { listening: true, matched: true }
+      }
+    }
+    if (fingerprint.body) {
+      const body = await res.text()
+      if (fingerprint.body.test(body)) return { listening: true, matched: true }
+    }
+    return { listening: true, matched: false }
+  } catch {
+    return { listening: false }
+  }
+}