@crawlith/core 0.1.0 → 0.1.1

package/src/scoring/orphanSeverity.ts

@@ -1,7 +1,7 @@
 export type OrphanType = 'hard' | 'near' | 'soft' | 'crawl-only';
 export type ImpactLevel = 'low' | 'medium' | 'high' | 'critical';
 
-export interface SitegraphNode {
+export interface CrawlNode {
   url: string;
   depth: number;
   inLinks: number;
@@ -19,7 +19,7 @@ export interface SitegraphNode {
   isProductOrCommercial?: boolean;
 }
 
-export interface SitegraphEdge {
+export interface CrawlEdge {
   source: string;
   target: string;
 }
@@ -32,7 +32,7 @@ export interface OrphanScoringOptions {
   rootUrl?: string;
 }
 
-export type AnnotatedNode = SitegraphNode & {
+export type AnnotatedNode = CrawlNode & {
   orphan: boolean;
   orphanType?: OrphanType;
   orphanSeverity?: number;
@@ -46,7 +46,7 @@ const LOW_VALUE_PATTERNS = [
   /\/search(\/|\?|$)/i
 ];
 
-function isLowValuePage(node: SitegraphNode): boolean {
+function isLowValuePage(node: CrawlNode): boolean {
   const type = (node.pageType || '').toLowerCase();
   if (['pagination', 'tag', 'category', 'filter', 'search', 'archive'].includes(type)) {
     return true;
@@ -68,7 +68,7 @@ export function mapImpactLevel(score: number): ImpactLevel {
   return 'critical';
 }
 
-export function calculateOrphanSeverity(orphanType: OrphanType, node: SitegraphNode): number {
+export function calculateOrphanSeverity(orphanType: OrphanType, node: CrawlNode): number {
   let score = 0;
 
   switch (orphanType) {
@@ -106,7 +106,7 @@ export function calculateOrphanSeverity(orphanType: OrphanType, node: SitegraphN
   return clampScore(score);
 }
 
-function consolidateInboundByCanonical(nodes: SitegraphNode[]): Map<string, number> {
+function consolidateInboundByCanonical(nodes: CrawlNode[]): Map<string, number> {
   const canonicalInbound = new Map<string, number>();
   for (const node of nodes) {
     const canonical = node.canonicalUrl || node.url;
@@ -115,7 +115,7 @@ function consolidateInboundByCanonical(nodes: SitegraphNode[]): Map<string, numb
   return canonicalInbound;
 }
 
-export function annotateOrphans(nodes: SitegraphNode[], edges: SitegraphEdge[], options: OrphanScoringOptions): AnnotatedNode[] {
+export function annotateOrphans(nodes: CrawlNode[], edges: CrawlEdge[], options: OrphanScoringOptions): AnnotatedNode[] {
   if (!options.enabled) {
     return nodes.map((node) => ({ ...node, orphan: false }));
   }
@@ -144,7 +144,7 @@ export function annotateOrphans(nodes: SitegraphNode[], edges: SitegraphEdge[],
       const inboundSources = edges
         .filter((edge) => edge.target === node.url)
         .map((edge) => nodeByUrl.get(edge.source))
-        .filter((source): source is SitegraphNode => Boolean(source));
+        .filter((source): source is CrawlNode => Boolean(source));
 
       if (inboundSources.length > 0 && inboundSources.every((source) => isLowValuePage(source))) {
         orphanType = 'soft';

package/tests/analysis.unit.test.ts

@@ -76,6 +76,33 @@ describe('structured data', () => {
     const missing = analyzeStructuredData('<p>none</p>');
     expect(missing.present).toBe(false);
   });
+
+  test('handles array of types', () => {
+    const html = '<script type="application/ld+json">{"@type": ["Article", "NewsArticle"]}</script>';
+    const result = analyzeStructuredData(html);
+    expect(result.types).toContain('Article');
+    expect(result.types).toContain('NewsArticle');
+  });
+
+  test('handles @graph structure', () => {
+    const html = '<script type="application/ld+json">{"@graph": [{"@type": "Person"}, {"@type": "Organization"}]}</script>';
+    const result = analyzeStructuredData(html);
+    expect(result.types).toContain('Person');
+    expect(result.types).toContain('Organization');
+  });
+
+  test('handles top-level array', () => {
+    const html = '<script type="application/ld+json">[{"@type": "A"}, {"@type": "B"}]</script>';
+    const result = analyzeStructuredData(html);
+    expect(result.types).toContain('A');
+    expect(result.types).toContain('B');
+  });
+
+  test('handles empty script content', () => {
+     const html = '<script type="application/ld+json">   </script>';
+     const result = analyzeStructuredData(html);
+     expect(result.valid).toBe(false);
+  });
 });
 
 describe('links and images', () => {
@@ -88,6 +115,15 @@ describe('links and images', () => {
     expect(links.externalRatio).toBeCloseTo(2 / 3);
   });
 
+  test('link ratio with no links', () => {
+    const html = '<div><p>No links here</p></div>';
+    const links = analyzeLinks(html, 'https://example.com/page', 'https://example.com');
+    expect(links.internalLinks).toBe(0);
+    expect(links.externalLinks).toBe(0);
+    expect(links.nofollowCount).toBe(0);
+    expect(links.externalRatio).toBe(0);
+  });
+
   test('image alt detection', () => {
     const html = '<img src="a"><img src="b" alt=""><img src="c" alt="ok">';
     const imgs = analyzeImageAlts(html);
@@ -95,4 +131,12 @@ describe('links and images', () => {
     expect(imgs.missingAlt).toBe(1);
     expect(imgs.emptyAlt).toBe(1);
   });
+
+  test('image alt detection no images', () => {
+    const html = '<div><p>No images here</p></div>';
+    const imgs = analyzeImageAlts(html);
+    expect(imgs.totalImages).toBe(0);
+    expect(imgs.missingAlt).toBe(0);
+    expect(imgs.emptyAlt).toBe(0);
+  });
 });

package/tests/analyze.integration.test.ts

@@ -1,13 +1,75 @@
-import { describe, expect, test } from 'vitest';
+import { describe, expect, test, afterEach, vi } from 'vitest';
 import path from 'node:path';
 import fs from 'node:fs/promises';
 import { analyzeSite, renderAnalysisHtml } from '../src/analysis/analyze.js';
+import { getDb, closeDb } from '../src/db/index.js';
+import { SiteRepository } from '../src/db/repositories/SiteRepository.js';
+import { SnapshotRepository } from '../src/db/repositories/SnapshotRepository.js';
+import { PageRepository } from '../src/db/repositories/PageRepository.js';
+import { EdgeRepository } from '../src/db/repositories/EdgeRepository.js';
+import { EngineContext } from '../src/events.js';
+
+const mockContext: EngineContext = { emit: vi.fn() };
 
 describe('analyze integration', () => {
   const fixturePath = path.resolve(import.meta.dirname, 'fixtures/analyze-crawl.json');
 
+  async function setupTestDb(rawData: any) {
+    // Force in-memory DB for this test
+    process.env.CRAWLITH_DB_PATH = ':memory:';
+
+    // Close existing DB connection if any to ensure fresh start
+    closeDb();
+
+    const db = getDb();
+    const siteRepo = new SiteRepository(db);
+    const snapshotRepo = new SnapshotRepository(db);
+    const pageRepo = new PageRepository(db);
+    const edgeRepo = new EdgeRepository(db);
+
+    // Create site and snapshot
+    const domain = 'example.com';
+    const siteId = siteRepo.createSite(domain);
+    const snapshotId = snapshotRepo.createSnapshot(siteId, 'full', 'running');
+
+    // Parse fixture and load pages into db
+    const pages = rawData.pages || rawData.nodes || [];
+    pages.forEach((p: any) => {
+      pageRepo.upsertPage({
+        site_id: siteId,
+        normalized_url: p.url,
+        last_seen_snapshot_id: snapshotId,
+        http_status: p.status || 200,
+        html: p.html || '',
+        depth: p.depth || 0,
+      });
+    });
+
+    if (rawData.edges) {
+      rawData.edges.forEach((e: any) => {
+        const sourceId = pageRepo.getIdByUrl(siteId, e.source);
+        const targetId = pageRepo.getIdByUrl(siteId, e.target);
+        if (sourceId && targetId) {
+          edgeRepo.insertEdge(snapshotId, sourceId, targetId);
+        }
+      });
+    }
+
+    snapshotRepo.updateSnapshotStatus(snapshotId, 'completed', { node_count: pages.length, edge_count: (rawData.edges || []).length });
+    return { db, siteId, snapshotId };
+  }
+
+  afterEach(() => {
+    closeDb();
+    delete process.env.CRAWLITH_DB_PATH;
+  });
+
   test('analyzes full crawl fixture and schema', async () => {
-    const result = await analyzeSite('https://example.com', { fromCrawl: fixturePath });
+    const rawContent = await fs.readFile(fixturePath, 'utf-8');
+    const rawData = JSON.parse(rawContent);
+    await setupTestDb(rawData);
+
+    const result = await analyzeSite('https://example.com', { allPages: true }, mockContext);
 
     expect(result.site_summary.pages_analyzed).toBe(3);
     expect(result.site_summary.duplicate_titles).toBe(2);
@@ -20,79 +82,52 @@ describe('analyze integration', () => {
   });
 
   test('module filter flags behavior', async () => {
-    const seoOnly = await analyzeSite('https://example.com', { fromCrawl: fixturePath, seo: true });
+    const rawContent = await fs.readFile(fixturePath, 'utf-8');
+    const rawData = JSON.parse(rawContent);
+    await setupTestDb(rawData);
+
+    const seoOnly = await analyzeSite('https://example.com', { seo: true }, mockContext);
     expect(seoOnly.pages[0].content.wordCount).toBe(0);
     expect(seoOnly.pages[0].images.totalImages).toBe(0);
 
-    const contentOnly = await analyzeSite('https://example.com', { fromCrawl: fixturePath, content: true });
+    const contentOnly = await analyzeSite('https://example.com', { content: true }, mockContext);
     expect(contentOnly.pages[0].title.status).toBe('missing');
     expect(contentOnly.pages[0].thinScore).toBeGreaterThanOrEqual(0);
 
-    const accessibilityOnly = await analyzeSite('https://example.com', { fromCrawl: fixturePath, accessibility: true });
+    const accessibilityOnly = await analyzeSite('https://example.com', { accessibility: true }, mockContext);
     expect(accessibilityOnly.pages[0].images.totalImages).toBeGreaterThan(0);
     expect(accessibilityOnly.pages[0].title.status).toBe('missing');
   });
 
   test('html report generation', async () => {
-    const result = await analyzeSite('https://example.com', { fromCrawl: fixturePath });
+    const rawContent = await fs.readFile(fixturePath, 'utf-8');
+    const rawData = JSON.parse(rawContent);
+    await setupTestDb(rawData);
+
+    const result = await analyzeSite('https://example.com', {}, mockContext);
     const html = renderAnalysisHtml(result);
     expect(html).toContain('<table');
     expect(html).toContain('Analysis');
   });
 
   test('default database loading', async () => {
-    // Force in-memory DB for this test
-    process.env.CRAWLITH_DB_PATH = ':memory:';
-
-    // Close existing DB connection if any to ensure fresh start
-    const { getDb, closeDb } = await import('../src/db/index.js');
-    closeDb();
-
-    // Setup repositories
-    const { SiteRepository } = await import('../src/db/repositories/SiteRepository.js');
-    const { SnapshotRepository } = await import('../src/db/repositories/SnapshotRepository.js');
-    const { PageRepository } = await import('../src/db/repositories/PageRepository.js');
-
-    const db = getDb();
-    const siteRepo = new SiteRepository(db);
-    const snapshotRepo = new SnapshotRepository(db);
-    const pageRepo = new PageRepository(db);
-
-    // Create site and snapshot
-    const siteId = siteRepo.createSite('example.com');
-    const snapshotId = snapshotRepo.createSnapshot(siteId, 'full', 'running');
+    // This is essentially same as 'analyzes full crawl fixture' but was explicit before.
+    // We can keep it to verify manual DB setup works as expected (which setupTestDb does).
+    const rawContent = await fs.readFile(fixturePath, 'utf-8');
+    const rawData = JSON.parse(rawContent);
+    await setupTestDb(rawData);
 
-    // Parse fixture and load pages into db
-    const rawYaml = await fs.readFile(fixturePath, 'utf-8');
-    const rawData = JSON.parse(rawYaml);
-    (rawData.pages || rawData.nodes).forEach((p: any) => {
-      pageRepo.upsertPage({
-        site_id: siteId,
-        normalized_url: p.url,
-        last_seen_snapshot_id: snapshotId,
-        http_status: p.status || 200,
-        html: p.html || '',
-        depth: p.depth || 0,
-      });
-    });
-
-    snapshotRepo.updateSnapshotStatus(snapshotId, 'completed', { node_count: 3, edge_count: 0 });
-
-    try {
-      const result = await analyzeSite('https://example.com', {});
-      expect(result.site_summary.pages_analyzed).toBe(3);
-    } finally {
-      closeDb();
-      delete process.env.CRAWLITH_DB_PATH;
-    }
+    const result = await analyzeSite('https://example.com', { allPages: true }, mockContext);
+    expect(result.site_summary.pages_analyzed).toBe(3);
   });
 
   test('handles large html and js-only content', async () => {
     const hugeText = '<html><body><script>document.write("x")</script>' + '<p>word </p>'.repeat(1000) + '</body></html>';
-    const tmpFile = path.resolve(import.meta.dirname, 'fixtures/large-analyze.json');
-    await fs.writeFile(tmpFile, JSON.stringify({ pages: [{ url: 'https://example.com/', status: 200, depth: 0, html: hugeText }] }));
-    const result = await analyzeSite('https://example.com', { fromCrawl: tmpFile });
+    const data = { pages: [{ url: 'https://example.com/', status: 200, depth: 0, html: hugeText }] };
+
+    await setupTestDb(data);
+
+    const result = await analyzeSite('https://example.com', {}, mockContext);
     expect(result.pages[0].content.wordCount).toBe(1000);
-    await fs.unlink(tmpFile);
   });
 });

package/tests/analyze_markdown.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from 'vitest';
+import { renderAnalysisMarkdown, AnalysisResult, PageAnalysis } from '../src/analysis/analyze.js';
+
+describe('renderAnalysisMarkdown', () => {
+  const mockPage: PageAnalysis = {
+    url: 'https://example.com/page1',
+    status: 200,
+    title: { value: 'Page 1', length: 6, status: 'ok' },
+    metaDescription: { value: 'Desc 1', length: 6, status: 'ok' },
+    h1: { count: 1, status: 'ok', matchesTitle: true },
+    content: { wordCount: 100, textHtmlRatio: 0.5, uniqueSentenceCount: 10 },
+    thinScore: 0,
+    images: { totalImages: 2, missingAlt: 0, emptyAlt: 0 },
+    links: { internalLinks: 5, externalLinks: 2, nofollowCount: 0, externalRatio: 0.2 },
+    structuredData: { present: true, valid: true, types: ['Article'] },
+    seoScore: 90,
+    meta: {}
+  };
+
+  const mockResult: AnalysisResult = {
+    site_summary: {
+      pages_analyzed: 2,
+      avg_seo_score: 85,
+      thin_pages: 0,
+      duplicate_titles: 0,
+      site_score: 88,
+    },
+    site_scores: {
+      overallScore: 88,
+      seoHealthScore: 85,
+    } as any, // casting to any to avoid mocking full return type of aggregateSiteScore if complex
+    pages: [
+      mockPage,
+      {
+        ...mockPage,
+        url: 'https://example.com/page2',
+        seoScore: 80,
+        thinScore: 10,
+        title: { value: 'Page 2', length: 6, status: 'duplicate' },
+        metaDescription: { value: 'Desc 2', length: 6, status: 'missing' },
+      }
+    ],
+    active_modules: {
+      seo: true,
+      content: true,
+      accessibility: true,
+    },
+  };
+
+  test('renders markdown summary correctly', () => {
+    const markdown = renderAnalysisMarkdown(mockResult);
+
+    expect(markdown).toContain('# Crawlith SEO Analysis Report');
+    expect(markdown).toContain('## 📊 Summary');
+    expect(markdown).toContain('- Pages Analyzed: 2');
+    expect(markdown).toContain('- Overall Site Score: 88.0');
+    expect(markdown).toContain('- Avg SEO Score: 85.0');
+    expect(markdown).toContain('- Thin Pages Found: 0');
+    expect(markdown).toContain('- Duplicate Titles: 0');
+  });
+
+  test('renders page details table header', () => {
+    const markdown = renderAnalysisMarkdown(mockResult);
+
+    expect(markdown).toContain('## 📄 Page Details');
+    expect(markdown).toContain('| URL | SEO Score | Thin Score | Title Status | Meta Status |');
+    expect(markdown).toContain('| :--- | :--- | :--- | :--- | :--- |');
+  });
+
+  test('renders page rows correctly', () => {
+    const markdown = renderAnalysisMarkdown(mockResult);
+
+    // Check first page row
+    expect(markdown).toContain('| https://example.com/page1 | 90 | 0 | ok | ok |');
+
+    // Check second page row
+    expect(markdown).toContain('| https://example.com/page2 | 80 | 10 | duplicate | missing |');
+  });
+
+  test('handles empty pages list', () => {
+    const emptyResult: AnalysisResult = {
+      ...mockResult,
+      pages: [],
+      site_summary: {
+        ...mockResult.site_summary,
+        pages_analyzed: 0,
+      }
+    };
+
+    const markdown = renderAnalysisMarkdown(emptyResult);
+
+    expect(markdown).toContain('- Pages Analyzed: 0');
+    // Should still contain headers
+    expect(markdown).toContain('| URL | SEO Score | Thin Score | Title Status | Meta Status |');
+    // Should not contain any data rows
+    expect(markdown).not.toContain('| https://example.com');
+  });
+});

package/tests/audit/audit.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { auditUrl } from '../../src/audit/index.js';
+import { resolveDns } from '../../src/audit/dns.js';
+import { analyzeTransport } from '../../src/audit/transport.js';
+import { analyzeHeaders } from '../../src/audit/headers.js';
+import { calculateScore } from '../../src/audit/scoring.js';
+import { IPGuard } from '../../src/core/security/ipGuard.js';
+
+// Mock dependencies
+vi.mock('../../src/audit/dns.js', () => ({
+  resolveDns: vi.fn(),
+}));
+vi.mock('../../src/audit/transport.js', () => ({
+  analyzeTransport: vi.fn(),
+}));
+vi.mock('../../src/audit/headers.js', () => ({
+  analyzeHeaders: vi.fn(),
+}));
+vi.mock('../../src/audit/scoring.js', () => ({
+  calculateScore: vi.fn(),
+}));
+vi.mock('../../src/core/security/ipGuard.js', () => ({
+  IPGuard: {
+    validateHost: vi.fn(),
+  },
+}));
+
+describe('auditUrl', () => {
+  const mockUrl = 'https://example.com';
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('should successfully audit a valid URL', async () => {
+    // Setup mocks
+    vi.mocked(IPGuard.validateHost).mockResolvedValue(true);
+
+    const mockDnsResult = { ip: '1.2.3.4' };
+    vi.mocked(resolveDns).mockResolvedValue(mockDnsResult as any);
+
+    const mockTransportResult = {
+      transport: { headers: {} },
+      performance: { loadTime: 100 },
+      issues: [],
+    };
+    vi.mocked(analyzeTransport).mockResolvedValue(mockTransportResult as any);
+
+    const mockHeadersResult = { grade: 'A' };
+    vi.mocked(analyzeHeaders).mockReturnValue(mockHeadersResult as any);
+
+    const mockScoringResult = {
+      score: 95,
+      grade: 'A',
+      issues: [],
+    };
+    vi.mocked(calculateScore).mockReturnValue(mockScoringResult as any);
+
+    // Execute
+    const result = await auditUrl(mockUrl);
+
+    // Verify
+    expect(IPGuard.validateHost).toHaveBeenCalledWith('example.com');
+    expect(resolveDns).toHaveBeenCalledWith('example.com');
+    expect(analyzeTransport).toHaveBeenCalledWith(mockUrl, 10000); // default timeout
+    expect(analyzeHeaders).toHaveBeenCalledWith(mockTransportResult.transport.headers);
+    expect(calculateScore).toHaveBeenCalled();
+
+    expect(result).toEqual({
+      url: mockUrl,
+      transport: mockTransportResult.transport,
+      securityHeaders: mockHeadersResult,
+      dns: mockDnsResult,
+      performance: mockTransportResult.performance,
+      score: mockScoringResult.score,
+      grade: mockScoringResult.grade,
+      issues: mockScoringResult.issues,
+    });
+  });
+
+  it('should throw error for invalid URL protocol', async () => {
+    await expect(auditUrl('ftp://example.com')).rejects.toThrow('Only HTTP and HTTPS protocols are supported');
+  });
+
+  it('should throw error for malformed URL', async () => {
+    await expect(auditUrl('not-a-url')).rejects.toThrow('Invalid URL');
+  });
+
+  it('should throw error if SSRF check fails', async () => {
+    vi.mocked(IPGuard.validateHost).mockResolvedValue(false);
+    await expect(auditUrl(mockUrl)).rejects.toThrow('Access to internal or private infrastructure is prohibited');
+  });
+
+  it('should propagate errors from dependencies', async () => {
+    vi.mocked(IPGuard.validateHost).mockResolvedValue(true);
+    vi.mocked(resolveDns).mockRejectedValue(new Error('DNS Error'));
+    vi.mocked(analyzeTransport).mockResolvedValue({} as any); // Should resolve if DNS fails? Wait, Promise.all fails if any fails.
+
+    await expect(auditUrl(mockUrl)).rejects.toThrow('DNS Error');
+  });
+});

package/tests/audit/scoring.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { calculateScore } from '../../src/audit/scoring.js';
-import { TransportDiagnostics, DnsDiagnostics, SecurityHeadersResult, PerformanceMetrics, AuditIssue } from '../../src/audit/types.js';
+import { TransportDiagnostics, DnsDiagnostics, SecurityHeadersResult, PerformanceMetrics } from '../../src/audit/types.js';
 
 describe('Scoring Engine', () => {
   const mockTransport: TransportDiagnostics = {
@@ -84,8 +84,8 @@ describe('Scoring Engine', () => {
 
   it('should fail on expired cert', () => {
     const expiredTransport = {
-        ...mockTransport,
-        certificate: { ...mockTransport.certificate!, daysUntilExpiry: -5, validTo: '2023-01-01' }
+      ...mockTransport,
+      certificate: { ...mockTransport.certificate!, daysUntilExpiry: -5, validTo: '2023-01-01' }
     };
     const result = calculateScore(expiredTransport, mockDns, mockHeaders, mockPerformance, []);
     expect(result.grade).toBe('F');
@@ -104,30 +104,30 @@ describe('Scoring Engine', () => {
   });
 
   it('should penalize poor performance', () => {
-      const badPerf = { ...mockPerformance, ttfb: 1000, htmlSize: 2000000 };
-      const result = calculateScore(mockTransport, mockDns, mockHeaders, badPerf, []);
-      // TTFB > 800: Lose 10 pts
-      // HTML > 1MB: Lose 5 pts
-      // Total perf score (30) -> 15.
-      expect(result.categoryScores.performance).toBe(15);
-      expect(result.score).toBe(85);
-      expect(result.issues).toEqual(expect.arrayContaining([
-          expect.objectContaining({ id: 'slow-ttfb' }),
-          expect.objectContaining({ id: 'large-html' })
-      ]));
+    const badPerf = { ...mockPerformance, ttfb: 1000, htmlSize: 2000000 };
+    const result = calculateScore(mockTransport, mockDns, mockHeaders, badPerf, []);
+    // TTFB > 800: Lose 10 pts
+    // HTML > 1MB: Lose 5 pts
+    // Total perf score (30) -> 15.
+    expect(result.categoryScores.performance).toBe(15);
+    expect(result.score).toBe(85);
+    expect(result.issues).toEqual(expect.arrayContaining([
+      expect.objectContaining({ id: 'slow-ttfb' }),
+      expect.objectContaining({ id: 'large-html' })
+    ]));
   });
 
   it('should penalize infrastructure issues', () => {
-      const badDns = { ...mockDns, ipv6Support: false, ipCount: 1 };
-      const result = calculateScore(mockTransport, badDns, mockHeaders, mockPerformance, []);
-      // No IPv6: Lose 10 pts
-      // Single IP: Lose 10 pts
-      // Infra score (20) -> 0.
-      expect(result.categoryScores.infrastructure).toBe(0);
-      expect(result.score).toBe(80);
-      expect(result.issues).toEqual(expect.arrayContaining([
-          expect.objectContaining({ id: 'no-ipv6' }),
-          expect.objectContaining({ id: 'single-ip' })
-      ]));
+    const badDns = { ...mockDns, ipv6Support: false, ipCount: 1 };
+    const result = calculateScore(mockTransport, badDns, mockHeaders, mockPerformance, []);
+    // No IPv6: Lose 10 pts
+    // Single IP: Lose 10 pts
+    // Infra score (20) -> 0.
+    expect(result.categoryScores.infrastructure).toBe(0);
+    expect(result.score).toBe(80);
+    expect(result.issues).toEqual(expect.arrayContaining([
+      expect.objectContaining({ id: 'no-ipv6' }),
+      expect.objectContaining({ id: 'single-ip' })
+    ]));
   });
 });

package/tests/audit/transport.test.ts

@@ -1,7 +1,6 @@
 import { describe, it, expect, vi, afterEach } from 'vitest';
 import { analyzeTransport } from '../../src/audit/transport.js';
 import https from 'node:https';
-import http from 'node:http';
 import tls from 'node:tls';
 import { EventEmitter } from 'events';