pagesight 0.11.0 → 0.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pagesight",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "See your site the way search engines and AI see it.",
   "keywords": [
     "seo",

package/src/index.ts

@@ -4,6 +4,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { registerAuditTool } from "./tools/audit.js";
 import { registerCruxTool } from "./tools/crux.js";
 import { registerInspectTool } from "./tools/inspect.js";
+import { registerLinksTool } from "./tools/links.js";
 import { registerMetatagsTool } from "./tools/metatags.js";
 import { registerPagespeedTool } from "./tools/pagespeed.js";
 import { registerPerformanceTool } from "./tools/performance.js";
@@ -22,6 +23,7 @@ const server = new McpServer({
 registerAuditTool(server);
 registerCruxTool(server);
 registerInspectTool(server);
+registerLinksTool(server);
 registerMetatagsTool(server);
 registerPagespeedTool(server);
 registerPerformanceTool(server);

package/src/lib/psi.ts

@@ -79,6 +79,10 @@ export interface PsiResult {
 export type PsiStrategy = "mobile" | "desktop";
 export type PsiCategoryType = "performance" | "accessibility" | "best-practices" | "seo";
 
+export function hasApiKey(): boolean {
+  return !!process.env.GOOGLE_API_KEY;
+}
+
 export async function runPagespeed(
   url: string,
   options?: {

package/src/tools/audit.ts

@@ -3,6 +3,7 @@ import { z } from "zod";
 import { inspectUrl, listSitemaps } from "../lib/gsc.js";
 import { type PsiCategoryType, type PsiResult, runPagespeed } from "../lib/psi.js";
 import { auditAiCrawlers, fetchRobotsTxt, isAllowed } from "../lib/robots.js";
+import { fetchSitemap, inspectSingle, sampleUrls } from "./sample-inspect.js";
 
 type Severity = "HIGH" | "MEDIUM" | "LOW";
 
@@ -128,9 +129,11 @@ function addPagespeedFindings(result: PsiResult, findings: Finding[]) {
     const fontItems = renderBlocking.details.items.filter((i) => i.url && String(i.url).includes("fonts"));
     if (fontItems.length > 0) {
       const wastedMs = fontItems.reduce((sum, i) => sum + (i.wastedMs ? Number(i.wastedMs) : 0), 0);
+      const isGoogleFonts = fontItems.some((i) => String(i.url).includes("fonts.googleapis.com"));
+      const label = isGoogleFonts ? "Render-blocking Google Fonts" : "Render-blocking font CSS";
       findings.push({
         severity: "MEDIUM",
-        message: `Render-blocking Google Fonts (${Math.round(wastedMs)}ms wasted)`,
+        message: `${label} (${Math.round(wastedMs)}ms wasted)`,
         source: "pagespeed",
       });
     }
@@ -208,6 +211,36 @@ function addSitemapFindings(sitemapCount: number, totalSubmitted: number, totalI
   }
 }
 
+function formatDrillDown(
+  inspections: Array<{ url: string; verdict: string; coverageState: string; error: string | null }>,
+): string {
+  const valid = inspections.filter((r) => !r.error);
+  if (valid.length === 0) return "";
+
+  const indexed = valid.filter((r) => r.verdict === "PASS").length;
+  const lines: string[] = [`        Auto-inspected ${valid.length} URLs:`];
+  lines.push(`        - ${indexed}/${valid.length} indexed`);
+
+  const stateCounts: Record<string, { count: number; urls: string[] }> = {};
+  for (const r of valid) {
+    if (r.verdict !== "PASS") {
+      const path = new URL(r.url).pathname;
+      const existing = stateCounts[r.coverageState];
+      if (existing) {
+        existing.count++;
+        existing.urls.push(path);
+      } else {
+        stateCounts[r.coverageState] = { count: 1, urls: [path] };
+      }
+    }
+  }
+  for (const [state, { count, urls }] of Object.entries(stateCounts)) {
+    lines.push(`        - ${count}/${valid.length} ${state}: ${urls.join(", ")}`);
+  }
+
+  return lines.join("\n");
+}
+
 function addInspectFindings(verdict: string, coverageState: string, findings: Finding[]) {
   if (verdict === "FAIL") {
     findings.push({ severity: "HIGH", message: `URL not indexed: ${coverageState}`, source: "inspect" });
@@ -219,26 +252,28 @@ function addInspectFindings(verdict: string, coverageState: string, findings: Fi
 function formatAudit(url: string, findings: Finding[], errors: string[]): string {
   const lines: string[] = [`=== Site Audit: ${url} ===`, ""];
 
+  // Lead with errors so partial results are obvious
+  if (errors.length > 0) {
+    lines.push(`${errors.length} check${errors.length > 1 ? "s" : ""} failed — results below are partial:`, "");
+    for (const e of errors) {
+      lines.push(`  FAIL  ${e}`);
+    }
+    lines.push("");
+  }
+
   // Sort: HIGH first, then MEDIUM, then LOW
   const order: Record<string, number> = { HIGH: 0, MEDIUM: 1, LOW: 2 };
   findings.sort((a, b) => order[a.severity] - order[b.severity]);
 
-  if (findings.length === 0) {
+  if (findings.length === 0 && errors.length === 0) {
     lines.push("No issues found.");
-  } else {
-    lines.push(`${findings.length} findings:`, "");
+  } else if (findings.length > 0) {
+    lines.push(`${findings.length} finding${findings.length > 1 ? "s" : ""}:`, "");
     for (const f of findings) {
       lines.push(`${f.severity.padEnd(6)}  ${f.message}`);
     }
   }
 
-  if (errors.length > 0) {
-    lines.push("", "--- Errors (partial audit) ---", "");
-    for (const e of errors) {
-      lines.push(`- ${e}`);
-    }
-  }
-
   return lines.join("\n");
 }
 
@@ -310,6 +345,33 @@ export function registerAuditTool(server: McpServer): void {
           }
         }
         addSitemapFindings(sitemaps.length, totalSubmitted, totalIndexed, findings);
+
+        // Auto-drill-down: when indexing is low, sample-inspect to explain why
+        const indexPct = totalSubmitted > 0 ? (totalIndexed / totalSubmitted) * 100 : 100;
+        if (site_url && indexPct < 50 && sitemaps.length > 0) {
+          try {
+            const sitemapPath = (sitemaps.find((s) => !s.isSitemapsIndex) ?? sitemaps[0]).path;
+            let parsed = await fetchSitemap(sitemapPath);
+            if (parsed.isSitemapIndex && parsed.childSitemaps.length > 0) {
+              parsed = await fetchSitemap(parsed.childSitemaps[0]);
+            }
+            if (parsed.urls.length > 0) {
+              const sampled = sampleUrls(parsed.urls, 5, "spread");
+              const inspections = [];
+              for (const u of sampled) {
+                inspections.push(await inspectSingle(u, site_url));
+              }
+              const drillDown = formatDrillDown(inspections);
+              // Append drill-down to the sitemap finding
+              const sitemapFinding = findings.find((f) => f.source === "sitemaps" && f.severity === "HIGH");
+              if (sitemapFinding) {
+                sitemapFinding.message += `\n${drillDown}`;
+              }
+            }
+          } catch {
+            // Drill-down is best-effort — don't fail the audit
+          }
+        }
       } else if (sitemapResult.status === "rejected") {
         errors.push(`Sitemaps: ${sitemapResult.reason}`);
       }

package/src/tools/links.ts

@@ -0,0 +1,183 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+interface LinkResult {
+  href: string;
+  status: number | null;
+  redirectChain: Array<{ url: string; status: number }>;
+  finalUrl: string | null;
+  error: string | null;
+}
+
+async function checkLink(href: string): Promise<LinkResult> {
+  const chain: Array<{ url: string; status: number }> = [];
+  let current = href;
+
+  try {
+    for (let i = 0; i < 10; i++) {
+      const res = await fetch(current, {
+        method: "GET",
+        headers: { "User-Agent": "Mozilla/5.0 (compatible; Googlebot/2.1)", Accept: "text/html" },
+        redirect: "manual",
+      });
+
+      chain.push({ url: current, status: res.status });
+
+      if (res.status >= 300 && res.status < 400) {
+        const location = res.headers.get("location");
+        if (!location) break;
+        current = new URL(location, current).href;
+        continue;
+      }
+
+      return {
+        href,
+        status: res.status,
+        redirectChain: chain,
+        finalUrl: chain.length > 1 ? current : null,
+        error: null,
+      };
+    }
+
+    return {
+      href,
+      status: chain[chain.length - 1]?.status ?? null,
+      redirectChain: chain,
+      finalUrl: current,
+      error: "Too many redirects",
+    };
+  } catch (err) {
+    return {
+      href,
+      status: null,
+      redirectChain: chain,
+      finalUrl: null,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+function extractInternalLinks(html: string, origin: string): string[] {
+  const links = new Set<string>();
+
+  for (const match of html.matchAll(/<a\s[^>]*href=["']([^"'#]+)/gi)) {
+    const raw = match[1].trim();
+    if (!raw || raw.startsWith("javascript:") || raw.startsWith("mailto:") || raw.startsWith("tel:")) continue;
+
+    try {
+      const resolved = new URL(raw, origin).href;
+      if (resolved.startsWith(origin) && !resolved.includes("/cdn-cgi/")) {
+        links.add(resolved);
+      }
+    } catch {
+      // Invalid URL, skip
+    }
+  }
+
+  return [...links];
+}
+
+function formatResults(url: string, results: LinkResult[]): string {
+  const lines: string[] = [`=== Internal Links: ${url} ===`, `Found ${results.length} internal links`, ""];
+
+  const broken = results.filter((r) => r.error || (r.status && r.status >= 400));
+  const redirected = results.filter((r) => !r.error && r.redirectChain.length > 1 && r.status && r.status < 400);
+  const ok = results.filter((r) => !r.error && r.redirectChain.length === 1 && r.status && r.status < 400);
+
+  // Summary
+  lines.push("--- Summary ---", "");
+  lines.push(`OK: ${ok.length}`);
+  if (redirected.length > 0) lines.push(`Redirected: ${redirected.length}`);
+  if (broken.length > 0) lines.push(`Broken: ${broken.length}`);
+  lines.push("");
+
+  // Broken links
+  if (broken.length > 0) {
+    lines.push("--- Broken Links ---", "");
+    for (const r of broken) {
+      if (r.error) {
+        lines.push(`FAIL  ${r.href}`);
+        lines.push(`      Error: ${r.error}`);
+      } else {
+        lines.push(`FAIL  ${r.href} → ${r.status}`);
+      }
+    }
+    lines.push("");
+  }
+
+  // Redirect chains
+  if (redirected.length > 0) {
+    lines.push("--- Redirect Chains ---", "");
+    for (const r of redirected) {
+      const hops = r.redirectChain.length - 1;
+      const chainStr = r.redirectChain.map((h) => `${h.status}`).join(" → ");
+      lines.push(`REDIRECT  ${r.href}`);
+      lines.push(`          ${chainStr} → ${r.finalUrl} (${hops} hop${hops > 1 ? "s" : ""})`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+export function registerLinksTool(server: McpServer): void {
+  server.tool(
+    "links",
+    "Check internal links on a page. Fetches the page, extracts all internal <a href> links, and checks each for broken links (404/5xx), redirect chains, and errors.",
+    {
+      url: z.string().url().describe("The page URL to check internal links for."),
+    },
+    async ({ url }) => {
+      try {
+        const origin = new URL(url).origin;
+
+        // Fetch the page
+        const res = await fetch(url, {
+          headers: { "User-Agent": "Mozilla/5.0 (compatible; Googlebot/2.1)", Accept: "text/html" },
+          redirect: "follow",
+        });
+
+        if (!res.ok) {
+          return {
+            content: [{ type: "text", text: `Error fetching ${url}: HTTP ${res.status}` }],
+          };
+        }
+
+        const html = await res.text();
+        const links = extractInternalLinks(html, origin);
+
+        if (links.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No internal links found on ${url}\nNote: this page may use client-side rendering (SPA). Only static <a href> links in the HTML are detected.`,
+              },
+            ],
+          };
+        }
+
+        // Check links with concurrency 5
+        const concurrency = 5;
+        const results: LinkResult[] = [];
+        let i = 0;
+
+        while (i < links.length) {
+          const batch = links.slice(i, i + concurrency);
+          const settled = await Promise.all(batch.map((href) => checkLink(href)));
+          results.push(...settled);
+          i += concurrency;
+        }
+
+        return {
+          content: [{ type: "text", text: formatResults(url, results) }],
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error checking links: ${msg}` }],
+        };
+      }
+    },
+  );
+}

package/src/tools/metatags.ts

@@ -140,6 +140,7 @@ interface SchemaRule {
   required: string[];
   recommended: string[];
   imageFields: string[];
+  nestedRequired?: Record<string, string[]>;
 }
 
 // Required/recommended fields sourced from Google's Rich Results documentation
@@ -169,6 +170,7 @@ const SCHEMA_RULES: Record<string, SchemaRule> = {
     required: ["name", "image"],
     recommended: ["description", "offers", "brand", "review", "aggregateRating"],
     imageFields: ["image"],
+    nestedRequired: { offers: ["price", "priceCurrency"] },
   },
   LocalBusiness: {
     required: ["name", "address"],
@@ -200,6 +202,43 @@ const SCHEMA_RULES: Record<string, SchemaRule> = {
     recommended: ["duration", "contentUrl", "embedUrl"],
     imageFields: ["thumbnailUrl"],
   },
+  SoftwareApplication: {
+    required: ["name", "offers"],
+    recommended: ["applicationCategory", "operatingSystem", "review", "aggregateRating"],
+    imageFields: ["image"],
+    nestedRequired: { offers: ["price", "priceCurrency"] },
+  },
+  Dataset: {
+    required: ["name", "description"],
+    recommended: ["distribution", "creator", "license"],
+    imageFields: [],
+    nestedRequired: { distribution: ["contentUrl", "encodingFormat"] },
+  },
+  TechArticle: {
+    required: ["headline", "image", "datePublished", "author"],
+    recommended: ["dateModified", "publisher"],
+    imageFields: ["image"],
+  },
+  BlogPosting: {
+    required: ["headline", "image", "datePublished", "author"],
+    recommended: ["dateModified", "publisher"],
+    imageFields: ["image"],
+  },
+  HowTo: {
+    required: ["name", "step"],
+    recommended: ["image", "totalTime", "estimatedCost"],
+    imageFields: ["image"],
+  },
+  Course: {
+    required: ["name", "description"],
+    recommended: ["provider", "offers"],
+    imageFields: [],
+  },
+  JobPosting: {
+    required: ["title", "description", "datePosted", "hiringOrganization"],
+    recommended: ["employmentType", "jobLocation", "baseSalary", "validThrough"],
+    imageFields: [],
+  },
 };
 
 interface ValidationIssue {
@@ -216,9 +255,14 @@ function getNestedValue(obj: Record<string, unknown>, field: string): unknown {
   return undefined;
 }
 
-function validateJsonLd(blocks: unknown[]): { issues: ValidationIssue[]; imageUrls: string[] } {
+function validateJsonLd(blocks: unknown[]): {
+  issues: ValidationIssue[];
+  imageUrls: string[];
+  validatedTypes: Set<string>;
+} {
   const issues: ValidationIssue[] = [];
   const imageUrls: string[] = [];
+  const validatedTypes = new Set<string>();
 
   function validateBlock(data: unknown) {
     if (Array.isArray(data)) {
@@ -234,6 +278,7 @@ function validateJsonLd(blocks: unknown[]): { issues: ValidationIssue[]; imageUr
     for (const type of types) {
       const rule = SCHEMA_RULES[String(type)];
       if (!rule) continue;
+      validatedTypes.add(String(type));
 
       for (const field of rule.required) {
         if (getNestedValue(obj, field) === undefined) {
@@ -247,6 +292,27 @@ function validateJsonLd(blocks: unknown[]): { issues: ValidationIssue[]; imageUr
         }
       }
 
+      // Check nested required fields (e.g., offers.price inside Product)
+      if (rule.nestedRequired) {
+        for (const [parent, fields] of Object.entries(rule.nestedRequired)) {
+          const parentVal = obj[parent];
+          if (parentVal && typeof parentVal === "object") {
+            const targets = Array.isArray(parentVal) ? parentVal : [parentVal];
+            for (const target of targets) {
+              if (target && typeof target === "object") {
+                const nested = target as Record<string, unknown>;
+                for (const field of fields) {
+                  if (nested[field] === undefined || nested[field] === null || nested[field] === "") {
+                    issues.push({ type: String(type), level: "required", field: `${parent}.${field}` });
+                  }
+                }
+                break; // Only check the first item in arrays
+              }
+            }
+          }
+        }
+      }
+
       // Collect image URLs for validation
       for (const field of rule.imageFields) {
         const val = obj[field];
@@ -262,17 +328,18 @@ function validateJsonLd(blocks: unknown[]): { issues: ValidationIssue[]; imageUr
       }
     }
 
-    // Recurse into nested objects
+    // Recurse into nested objects and arrays (e.g., @graph)
     for (const val of Object.values(obj)) {
-      if (val && typeof val === "object" && !Array.isArray(val)) {
-        const nested = val as Record<string, unknown>;
-        if (nested["@type"]) validateBlock(nested);
+      if (Array.isArray(val)) {
+        for (const item of val) validateBlock(item);
+      } else if (val && typeof val === "object") {
+        validateBlock(val);
       }
     }
   }
 
   for (const block of blocks) validateBlock(block);
-  return { issues, imageUrls };
+  return { issues, imageUrls, validatedTypes };
 }
 
 // What each recommended field enables (sourced from Google Rich Results docs)
@@ -293,12 +360,31 @@ const FIELD_HINTS: Record<string, string> = {
   "Event.offers": "shows ticket prices in search",
   "Recipe.author": "shown in recipe rich results",
   "VideoObject.duration": "shown in video rich results",
+  "SoftwareApplication.applicationCategory": "shown in software rich results",
+  "SoftwareApplication.operatingSystem": "shown in software rich results",
+  "SoftwareApplication.review": "enables star ratings",
+  "SoftwareApplication.aggregateRating": "enables aggregate star ratings",
+  "Dataset.distribution": "enables dataset download in search",
+  "Dataset.creator": "shown in dataset rich results",
+  "Dataset.license": "shown in dataset rich results",
+  "Course.provider": "shown in course rich results",
+  "Course.offers": "enables price display for courses",
+  "JobPosting.employmentType": "shown in job search results",
+  "JobPosting.jobLocation": "shown in job search results",
+  "JobPosting.baseSalary": "enables salary display in job search",
 };
 
-function formatValidation(issues: ValidationIssue[]): string[] {
-  if (issues.length === 0) return ["All validated types have their required fields."];
-
+function formatValidation(issues: ValidationIssue[], validatedTypes: Set<string>): string[] {
   const lines: string[] = [];
+
+  // Show PASS for types with no required issues
+  const typesWithRequiredIssues = new Set(issues.filter((i) => i.level === "required").map((i) => i.type));
+  for (const type of validatedTypes) {
+    if (!typesWithRequiredIssues.has(type)) {
+      lines.push(`PASS     ${type} — all required fields present`);
+    }
+  }
+
   const required = issues.filter((i) => i.level === "required");
   const recommended = issues.filter((i) => i.level === "recommended");
 
@@ -404,6 +490,20 @@ function formatMetatags(url: string, parsed: ParsedHead): string {
   if (robots) lines.push(`Robots: ${robots}`);
   const author = getMeta(parsed.meta, "author");
   if (author) lines.push(`Author: ${author}`);
+
+  // HTML entity warnings
+  const entityCheck = [
+    { label: "title", value: parsed.title },
+    { label: "description", value: getMeta(parsed.meta, "description") },
+    { label: "og:title", value: getMeta(parsed.meta, "og:title") },
+    { label: "og:description", value: getMeta(parsed.meta, "og:description") },
+  ];
+  for (const { label, value } of entityCheck) {
+    if (value && /&(?:amp|lt|gt|quot|apos|#\d+|#x[\da-f]+);/i.test(value)) {
+      lines.push(`WARN: ${label} contains HTML entities — may render incorrectly in social previews`);
+    }
+  }
+
   lines.push("");
 
   // Open Graph
@@ -566,10 +666,10 @@ export function registerMetatagsTool(server: McpServer): void {
 
         // Structured data validation
         if (parsed.jsonLd.length > 0) {
-          const { issues, imageUrls } = validateJsonLd(parsed.jsonLd);
-          if (issues.length > 0 || imageUrls.length > 0) {
+          const { issues, imageUrls, validatedTypes } = validateJsonLd(parsed.jsonLd);
+          if (validatedTypes.size > 0 || imageUrls.length > 0) {
             output.push("", "--- Structured Data Validation ---", "");
-            output.push(...formatValidation(issues));
+            output.push(...formatValidation(issues, validatedTypes));
 
             // HEAD-check image URLs from structured data
             if (imageUrls.length > 0) {

package/src/tools/pagespeed.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import {
+  hasApiKey,
   type PsiAudit,
   type PsiAuditDetailItem,
   type PsiCategoryType,
@@ -8,6 +9,9 @@ import {
   runPagespeed,
 } from "../lib/psi.js";
 
+const QUOTA_NOTE =
+  "\n\nNote: No GOOGLE_API_KEY configured — using shared quota (400 req/day). Set your own key to avoid rate limits.";
+
 function scoreLabel(score: number | null): string {
   if (score === null) return "N/A";
   const pct = Math.round(score * 100);
@@ -536,7 +540,8 @@ export function registerPagespeedTool(server: McpServer): void {
       if (url) {
         try {
           const result = await runPagespeed(url, opts);
-          return { content: [{ type: "text", text: formatPagespeed(url, result) }] };
+          const text = formatPagespeed(url, result) + (hasApiKey() ? "" : QUOTA_NOTE);
+          return { content: [{ type: "text", text }] };
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           return { content: [{ type: "text", text: `Error running PageSpeed analysis: ${msg}` }] };
@@ -569,6 +574,8 @@ export function registerPagespeedTool(server: McpServer): void {
         output += `\n\n--- Errors ---\n${errorLines.join("\n")}`;
       }
 
+      if (!hasApiKey()) output += QUOTA_NOTE;
+
       return { content: [{ type: "text", text: output }] };
     },
   );

package/src/tools/sample-inspect.ts

@@ -2,13 +2,13 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { inspectUrl, listSitemaps } from "../lib/gsc.js";
 
-interface SitemapParseResult {
+export interface SitemapParseResult {
   urls: string[];
   isSitemapIndex: boolean;
   childSitemaps: string[];
 }
 
-function parseSitemapXml(xml: string): SitemapParseResult {
+export function parseSitemapXml(xml: string): SitemapParseResult {
   const urls: string[] = [];
   const childSitemaps: string[] = [];
 
@@ -28,7 +28,7 @@ function parseSitemapXml(xml: string): SitemapParseResult {
   return { urls, isSitemapIndex, childSitemaps };
 }
 
-async function fetchSitemap(sitemapUrl: string): Promise<SitemapParseResult> {
+export async function fetchSitemap(sitemapUrl: string): Promise<SitemapParseResult> {
   const res = await fetch(sitemapUrl, {
     headers: { "User-Agent": "Pagesight/1.0" },
   });
@@ -41,7 +41,7 @@ async function fetchSitemap(sitemapUrl: string): Promise<SitemapParseResult> {
   return parseSitemapXml(xml);
 }
 
-function sampleUrls(urls: string[], count: number, strategy: string): string[] {
+export function sampleUrls(urls: string[], count: number, strategy: string): string[] {
   if (urls.length <= count) return [...urls];
 
   if (strategy === "first") {
@@ -66,7 +66,7 @@ function sampleUrls(urls: string[], count: number, strategy: string): string[] {
   return shuffled.slice(0, count);
 }
 
-interface InspectionSummary {
+export interface InspectionSummary {
   url: string;
   verdict: string;
   coverageState: string;
@@ -78,7 +78,7 @@ interface InspectionSummary {
   error: string | null;
 }
 
-async function inspectSingle(url: string, siteUrl: string): Promise<InspectionSummary> {
+export async function inspectSingle(url: string, siteUrl: string): Promise<InspectionSummary> {
   try {
     const r = await inspectUrl(url, siteUrl);
     const idx = r.indexStatusResult;