test

Test — Quality Assertions

Run pass/fail assertions across accessibility, performance, security, SEO, and mobile readiness. Every assertion becomes a finding. Confidence auto-caps when data is missing.

When to Use

• Auditing accessibility, performance, security, SEO, or mobile readiness
• Running pass/fail assertions against quality thresholds

Protocol

1. search for extraction commands: search("extract page accessibility")
2. connect_tab to the target URL with { background: true }
3. execute Code Mode: smart.extractPage() gathers all dimensions in one call
4. Emit one smart.finding() per assertion — claim states pass or fail
5. Return smart.findings() + page.gaps

Code Example

const page = await smart.extractPage();

// Accessibility
if (page.accessibility) {
  smart.finding({
    claim: page.accessibility.imagesWithoutAlt === 0
      ? "All images have alt text"
      : `${page.accessibility.imagesWithoutAlt} images missing alt text`,
    evidence: [`imagesWithoutAlt: ${page.accessibility.imagesWithoutAlt}`, `nodeCount: ${page.accessibility.nodeCount}`],
    sourceUrl: page.capture.url, confidence: "high",
    method: "extractPage", dimension: "accessibility"
  });
  smart.finding({
    claim: page.accessibility.landmarkCount > 0
      ? `${page.accessibility.landmarkCount} ARIA landmarks found`
      : "No ARIA landmarks — add banner, main, contentinfo",
    evidence: [`landmarkCount: ${page.accessibility.landmarkCount}`],
    sourceUrl: page.capture.url, confidence: "high",
    method: "extractPage", dimension: "accessibility"
  });
}

// Performance
if (page.performance) {
  const lcp = page.performance.webVitals?.lcp;
  const cls = page.performance.webVitals?.cls;
  smart.finding({
    claim: lcp && lcp < 2500 ? `LCP good (${lcp}ms)` : `LCP needs work (${lcp || "unknown"}ms)`,
    evidence: [`LCP: ${lcp}ms`, `CLS: ${cls}`, `thresholds: LCP<2500, CLS<0.1`],
    sourceUrl: page.capture.url, confidence: lcp ? "high" : "low",
    method: "extractPage", dimension: "performance"
  });
}

// Security
if (page.security) {
  smart.finding({
    claim: page.security.securityState === "secure"
      ? "TLS connection is secure" : `Security state: ${page.security.securityState || "unknown"}`,
    evidence: [`protocol: ${page.security.certificate?.protocol || "unknown"}`],
    sourceUrl: page.capture.url, confidence: "high",
    method: "extractPage", dimension: "security"
  });
}

// SEO
if (page.meta) {
  const m = page.meta;
  smart.finding({
    claim: m._title && m.description ? "Title + meta description present" : "SEO meta tags incomplete",
    evidence: [`title: ${m._title || "missing"} (${m._title?.length || 0} chars)`,
               `description: ${m.description || "missing"} (${m.description?.length || 0} chars)`],
    sourceUrl: page.capture.url, confidence: "high",
    method: "extractPage", dimension: "seo"
  });
}

// Mobile readiness
if (page.mobileReadiness) {
  smart.finding({
    claim: page.mobileReadiness.hasViewportMeta ? "Viewport meta tag present" : "Missing viewport meta",
    evidence: [`viewport: ${page.mobileReadiness.viewportContent || "none"}`],
    sourceUrl: page.capture.url, confidence: "high",
    method: "extractPage", dimension: "mobile-readiness"
  });
}

// Tech stack
const tech = await smart.detectTechnologies();
if (tech.technologies?.length) {
  smart.finding({
    claim: `${tech.technologies.length} technologies detected`,
    evidence: tech.technologies.map(t => t.name),
    sourceUrl: page.capture.url, confidence: "high",
    method: "detectTechnologies", dimension: "technology"
  });
}

return { findings: smart.findings(), gaps: page.gaps };