@crawlith/core 0.1.0

package/src/scoring/hits.ts

@@ -0,0 +1,131 @@
+import { Graph, GraphNode } from '../graph/graph.js';
+
+export interface HITSOptions {
+    iterations?: number;
+}
+
+/**
+ * Computes Hub and Authority scores using the HITS algorithm.
+ * Operates purely on the internal link graph.
+ */
+export function computeHITS(graph: Graph, options: HITSOptions = {}): void {
+    const iterations = options.iterations || 20;
+    const nodes = graph.getNodes();
+
+    // 1. Filter eligible nodes
+    // Eligibility: status 200, non-redirect (redirectChain empty), not noindex, non-external
+    const eligibleNodes = nodes.filter(n =>
+        n.status === 200 &&
+        (!n.redirectChain || n.redirectChain.length === 0) &&
+        !n.noindex
+    );
+
+    if (eligibleNodes.length === 0) return;
+
+    const urlToNode = new Map<string, GraphNode>();
+    for (const node of eligibleNodes) {
+        urlToNode.set(node.url, node);
+        // 2. Initialization
+        node.authorityScore = 1.0;
+        node.hubScore = 1.0;
+    }
+
+    const allEdges = graph.getEdges();
+    // Filter edges: internal links only (both source and target must be in eligibleNodes), no self-links
+    const eligibleEdges = allEdges.filter(e =>
+        e.source !== e.target &&
+        urlToNode.has(e.source) &&
+        urlToNode.has(e.target)
+    );
+
+    // Group edges for efficient iteration
+    const incoming = new Map<string, { source: string, weight: number }[]>();
+    const outgoing = new Map<string, { target: string, weight: number }[]>();
+
+    for (const edge of eligibleEdges) {
+        if (!incoming.has(edge.target)) incoming.set(edge.target, []);
+        incoming.get(edge.target)!.push({ source: edge.source, weight: edge.weight });
+
+        if (!outgoing.has(edge.source)) outgoing.set(edge.source, []);
+        outgoing.get(edge.source)!.push({ target: edge.target, weight: edge.weight });
+    }
+
+    // 3. Iteration
+    for (let i = 0; i < iterations; i++) {
+        // Update Authorities
+        let normAuth = 0;
+        for (const node of eligibleNodes) {
+            const inLinks = incoming.get(node.url) || [];
+            let newAuth = 0;
+            for (const link of inLinks) {
+                const sourceNode = urlToNode.get(link.source)!;
+                newAuth += (sourceNode.hubScore || 0) * link.weight;
+            }
+            node.authorityScore = newAuth;
+            normAuth += newAuth * newAuth;
+        }
+
+        // Normalize Authorities (L2 norm)
+        normAuth = Math.sqrt(normAuth);
+        if (normAuth > 0) {
+            for (const node of eligibleNodes) {
+                node.authorityScore = (node.authorityScore || 0) / normAuth;
+            }
+        }
+
+        // Update Hubs
+        let normHub = 0;
+        for (const node of eligibleNodes) {
+            const outLinks = outgoing.get(node.url) || [];
+            let newHub = 0;
+            for (const link of outLinks) {
+                const targetNode = urlToNode.get(link.target)!;
+                newHub += (targetNode.authorityScore || 0) * link.weight;
+            }
+            node.hubScore = newHub;
+            normHub += newHub * newHub;
+        }
+
+        // Normalize Hubs (L2 norm)
+        normHub = Math.sqrt(normHub);
+        if (normHub > 0) {
+            for (const node of eligibleNodes) {
+                node.hubScore = (node.hubScore || 0) / normHub;
+            }
+        }
+    }
+
+    // 4. Classification Logic
+    classifyLinkRoles(eligibleNodes);
+}
+
+function classifyLinkRoles(nodes: GraphNode[]): void {
+    if (nodes.length === 0) return;
+
+    const authScores = nodes.map(n => n.authorityScore || 0).sort((a, b) => a - b);
+    const hubScores = nodes.map(n => n.hubScore || 0).sort((a, b) => a - b);
+
+    // Use 75th percentile as "high" threshold
+    const medianAuth = authScores[Math.floor(authScores.length / 2)];
+    const medianHub = hubScores[Math.floor(hubScores.length / 2)];
+
+    for (const node of nodes) {
+        const auth = node.authorityScore || 0;
+        const hub = node.hubScore || 0;
+
+        const isHighAuth = auth > medianAuth && auth > 0.0001;
+        const isHighHub = hub > medianHub && hub > 0.0001;
+
+        if (isHighAuth && isHighHub) {
+            node.linkRole = 'power';
+        } else if (isHighAuth) {
+            node.linkRole = 'authority';
+        } else if (isHighHub) {
+            node.linkRole = 'hub';
+        } else if (auth > 0.0001 && hub > 0.0001) {
+            node.linkRole = 'balanced';
+        } else {
+            node.linkRole = 'peripheral';
+        }
+    }
+}

package/src/scoring/orphanSeverity.ts

@@ -0,0 +1,176 @@
+export type OrphanType = 'hard' | 'near' | 'soft' | 'crawl-only';
+export type ImpactLevel = 'low' | 'medium' | 'high' | 'critical';
+
+export interface SitegraphNode {
+  url: string;
+  depth: number;
+  inLinks: number;
+  outLinks: number;
+  status: number;
+  discoveredViaSitemap?: boolean;
+  robotsExcluded?: boolean;
+  canonicalUrl?: string;
+  isHomepage?: boolean;
+  wordCount?: number;
+  hasStructuredData?: boolean;
+  pageType?: string;
+  noindex?: boolean;
+  duplicateContent?: boolean;
+  isProductOrCommercial?: boolean;
+}
+
+export interface SitegraphEdge {
+  source: string;
+  target: string;
+}
+
+export interface OrphanScoringOptions {
+  enabled: boolean;
+  severityEnabled: boolean;
+  includeSoftOrphans: boolean;
+  minInbound: number;
+  rootUrl?: string;
+}
+
+export type AnnotatedNode = SitegraphNode & {
+  orphan: boolean;
+  orphanType?: OrphanType;
+  orphanSeverity?: number;
+  impactLevel?: ImpactLevel;
+};
+
+const LOW_VALUE_PATTERNS = [
+  /[?&](page|p)=\d+/i,
+  /\/(page|tag|tags|category|categories)\//i,
+  /[?&](q|query|search|filter|sort)=/i,
+  /\/search(\/|\?|$)/i
+];
+
+function isLowValuePage(node: SitegraphNode): boolean {
+  const type = (node.pageType || '').toLowerCase();
+  if (['pagination', 'tag', 'category', 'filter', 'search', 'archive'].includes(type)) {
+    return true;
+  }
+  if (node.noindex) {
+    return true;
+  }
+  return LOW_VALUE_PATTERNS.some((pattern) => pattern.test(node.url));
+}
+
+function clampScore(score: number): number {
+  return Math.max(0, Math.min(100, Math.round(score)));
+}
+
+export function mapImpactLevel(score: number): ImpactLevel {
+  if (score <= 39) return 'low';
+  if (score <= 69) return 'medium';
+  if (score <= 89) return 'high';
+  return 'critical';
+}
+
+export function calculateOrphanSeverity(orphanType: OrphanType, node: SitegraphNode): number {
+  let score = 0;
+
+  switch (orphanType) {
+    case 'hard':
+      score = 90;
+      break;
+    case 'crawl-only':
+      score = 80;
+      break;
+    case 'near':
+      score = node.inLinks <= 1 ? 70 : 60;
+      break;
+    case 'soft':
+      score = 50;
+      break;
+  }
+
+  let positiveModifier = 0;
+  if ((node.wordCount || 0) > 800) positiveModifier += 10;
+  if (node.hasStructuredData) positiveModifier += 10;
+  if (node.depth <= 2) positiveModifier += 10;
+  if (node.isProductOrCommercial) positiveModifier += 10;
+  positiveModifier = Math.min(20, positiveModifier);
+
+  let negativeModifier = 0;
+  if ((node.wordCount || 0) > 0 && (node.wordCount || 0) < 300) negativeModifier += 20;
+  if (node.noindex) negativeModifier += 20;
+  if (node.duplicateContent) negativeModifier += 20;
+  if ((node.pageType || '').toLowerCase() === 'archive' || (node.pageType || '').toLowerCase() === 'pagination') negativeModifier += 20;
+  negativeModifier = Math.min(20, negativeModifier);
+
+  score += positiveModifier;
+  score -= negativeModifier;
+
+  return clampScore(score);
+}
+
+function consolidateInboundByCanonical(nodes: SitegraphNode[]): Map<string, number> {
+  const canonicalInbound = new Map<string, number>();
+  for (const node of nodes) {
+    const canonical = node.canonicalUrl || node.url;
+    canonicalInbound.set(canonical, (canonicalInbound.get(canonical) || 0) + node.inLinks);
+  }
+  return canonicalInbound;
+}
+
+export function annotateOrphans(nodes: SitegraphNode[], edges: SitegraphEdge[], options: OrphanScoringOptions): AnnotatedNode[] {
+  if (!options.enabled) {
+    return nodes.map((node) => ({ ...node, orphan: false }));
+  }
+
+  const canonicalInbound = consolidateInboundByCanonical(nodes);
+  const nodeByUrl = new Map(nodes.map((node) => [node.url, node]));
+
+  return nodes.map((node) => {
+    const isHomepage = node.isHomepage || (options.rootUrl ? node.url === options.rootUrl : node.depth === 0);
+    if (isHomepage || node.robotsExcluded) {
+      return { ...node, orphan: false };
+    }
+
+    const canonical = node.canonicalUrl || node.url;
+    const inbound = canonicalInbound.get(canonical) || 0;
+
+    let orphanType: OrphanType | undefined;
+
+    if (inbound === 0) {
+      orphanType = node.discoveredViaSitemap ? 'crawl-only' : 'hard';
+    } else if (inbound <= options.minInbound) {
+      orphanType = 'near';
+    }
+
+    if (!orphanType && options.includeSoftOrphans && inbound > 0) {
+      const inboundSources = edges
+        .filter((edge) => edge.target === node.url)
+        .map((edge) => nodeByUrl.get(edge.source))
+        .filter((source): source is SitegraphNode => Boolean(source));
+
+      if (inboundSources.length > 0 && inboundSources.every((source) => isLowValuePage(source))) {
+        orphanType = 'soft';
+      }
+    }
+
+    if (!orphanType) {
+      return { ...node, orphan: false };
+    }
+
+    if (!options.severityEnabled) {
+      return {
+        ...node,
+        orphan: true,
+        orphanType
+      };
+    }
+
+    const orphanSeverity = calculateOrphanSeverity(orphanType, { ...node, inLinks: inbound });
+
+    return {
+      ...node,
+      orphan: true,
+      orphanType,
+      orphanSeverity,
+      impactLevel: mapImpactLevel(orphanSeverity)
+    };
+  });
+}

package/src/utils/version.ts

@@ -0,0 +1,18 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+let version = '0.0.1';
+
+try {
+    const pkgPath = join(__dirname, '../../package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    version = pkg.version;
+} catch {
+    // Fallback to internal default
+}
+
+export { version };

package/tests/__snapshots__/orphanSeverity.test.ts.snap

@@ -0,0 +1,49 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`orphan detection and severity scoring > canonical consolidation, robots exclusion, and deterministic JSON output snapshot 1`] = `
+"[
+  {
+    "url": "https://example.com/canonical",
+    "depth": 1,
+    "inLinks": 0,
+    "outLinks": 0,
+    "status": 200,
+    "orphan": true,
+    "orphanType": "near",
+    "orphanSeverity": 80,
+    "impactLevel": "high"
+  },
+  {
+    "url": "https://example.com/variant?a=1",
+    "depth": 1,
+    "inLinks": 1,
+    "outLinks": 0,
+    "status": 200,
+    "canonicalUrl": "https://example.com/canonical",
+    "orphan": true,
+    "orphanType": "near",
+    "orphanSeverity": 80,
+    "impactLevel": "high"
+  },
+  {
+    "url": "https://example.com/blocked",
+    "depth": 1,
+    "inLinks": 0,
+    "outLinks": 0,
+    "status": 200,
+    "robotsExcluded": true,
+    "orphan": false
+  },
+  {
+    "url": "https://example.com/redirect-target",
+    "depth": 1,
+    "inLinks": 1,
+    "outLinks": 0,
+    "status": 200,
+    "orphan": true,
+    "orphanType": "near",
+    "orphanSeverity": 80,
+    "impactLevel": "high"
+  }
+]"
+`;

package/tests/analysis.unit.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from 'vitest';
+import { analyzeTitle, analyzeMetaDescription, applyDuplicateStatuses, analyzeH1 } from '../src/analysis/seo.js';
+import { analyzeContent, calculateThinContentScore } from '../src/analysis/content.js';
+import { analyzeStructuredData } from '../src/analysis/structuredData.js';
+import { analyzeLinks } from '../src/analysis/links.js';
+import { analyzeImageAlts } from '../src/analysis/images.js';
+
+describe('SEO module', () => {
+  test('analyze title edge cases', () => {
+    expect(analyzeTitle('<html></html>').status).toBe('missing');
+    expect(analyzeTitle('<title>short</title>').status).toBe('too_short');
+    expect(analyzeTitle(`<title>${'a'.repeat(61)}</title>`).status).toBe('too_long');
+    expect(analyzeTitle(`<title>${'a'.repeat(55)}</title>`).status).toBe('ok');
+  });
+
+  test('duplicate detection', () => {
+    const values = applyDuplicateStatuses([
+      { value: 'Same', length: 4, status: 'ok' as const },
+      { value: 'same', length: 4, status: 'ok' as const },
+      { value: null, length: 0, status: 'missing' as const }
+    ]);
+    expect(values[0].status).toBe('duplicate');
+    expect(values[1].status).toBe('duplicate');
+    expect(values[2].status).toBe('missing');
+  });
+
+  test('meta description boundaries', () => {
+    expect(analyzeMetaDescription('<meta name="description" content="">').status).toBe('missing');
+    expect(analyzeMetaDescription('<html></html>').status).toBe('missing');
+    expect(analyzeMetaDescription('<meta name="description" content="short">').status).toBe('too_short');
+    expect(analyzeMetaDescription(`<meta name="description" content="${'x'.repeat(150)}">`).status).toBe('ok');
+    expect(analyzeMetaDescription(`<meta name="description" content="${'x'.repeat(170)}">`).status).toBe('too_long');
+  });
+
+  test('h1 variations', () => {
+    expect(analyzeH1('<h1>One</h1>', 'Title').status).toBe('ok');
+    expect(analyzeH1('<h1>One</h1><h1>Two</h1>', 'Title').status).toBe('warning');
+    const noH1 = analyzeH1('<p>none</p>', 'Title');
+    expect(noH1.status).toBe('critical');
+    const same = analyzeH1('<h1>same</h1>', 'Same');
+    expect(same.matchesTitle).toBe(true);
+  });
+});
+
+describe('content module', () => {
+  test('word count strips nav/footer/script/style', () => {
+    const html = '<body><nav>skip me</nav><p>keep words here</p><footer>skip</footer><script>var x</script><style>.x{}</style></body>';
+    const result = analyzeContent(html);
+    expect(result.wordCount).toBe(3);
+    expect(result.uniqueSentenceCount).toBe(1);
+    expect(result.textHtmlRatio).toBeGreaterThan(0);
+  });
+
+  test('thin score boundaries', () => {
+    expect(calculateThinContentScore({ wordCount: 600, textHtmlRatio: 0.5, uniqueSentenceCount: 4 }, 0)).toBe(0);
+    expect(calculateThinContentScore({ wordCount: 0, textHtmlRatio: 0, uniqueSentenceCount: 1 }, 100)).toBe(100);
+  });
+
+  test('content handles malformed/empty html', () => {
+    expect(analyzeContent('').wordCount).toBe(0);
+    expect(analyzeContent('<div><span>broken').wordCount).toBeGreaterThanOrEqual(1);
+  });
+});
+
+describe('structured data', () => {
+  test('valid and invalid JSON-LD parsing', () => {
+    const valid = analyzeStructuredData('<script type="application/ld+json">{"@type":"Article"}</script>');
+    expect(valid.present).toBe(true);
+    expect(valid.valid).toBe(true);
+    expect(valid.types).toContain('Article');
+
+    const invalid = analyzeStructuredData('<script type="application/ld+json">{invalid}</script>');
+    expect(invalid.present).toBe(true);
+    expect(invalid.valid).toBe(false);
+
+    const missing = analyzeStructuredData('<p>none</p>');
+    expect(missing.present).toBe(false);
+  });
+});
+
+describe('links and images', () => {
+  test('link ratio calculation', () => {
+    const html = '<a href="/a">A</a><a href="https://other.com">B</a><a href="https://other.com" rel="nofollow">C</a>';
+    const links = analyzeLinks(html, 'https://example.com/page', 'https://example.com');
+    expect(links.internalLinks).toBe(1);
+    expect(links.externalLinks).toBe(2);
+    expect(links.nofollowCount).toBe(1);
+    expect(links.externalRatio).toBeCloseTo(2 / 3);
+  });
+
+  test('image alt detection', () => {
+    const html = '<img src="a"><img src="b" alt=""><img src="c" alt="ok">';
+    const imgs = analyzeImageAlts(html);
+    expect(imgs.totalImages).toBe(3);
+    expect(imgs.missingAlt).toBe(1);
+    expect(imgs.emptyAlt).toBe(1);
+  });
+});

package/tests/analyze.integration.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { analyzeSite, renderAnalysisHtml } from '../src/analysis/analyze.js';
+
+describe('analyze integration', () => {
+  const fixturePath = path.resolve(import.meta.dirname, 'fixtures/analyze-crawl.json');
+
+  test('analyzes full crawl fixture and schema', async () => {
+    const result = await analyzeSite('https://example.com', { fromCrawl: fixturePath });
+
+    expect(result.site_summary.pages_analyzed).toBe(3);
+    expect(result.site_summary.duplicate_titles).toBe(2);
+    expect(result.site_summary.avg_seo_score).toBeGreaterThanOrEqual(0);
+    expect(result.pages[0]).toHaveProperty('title');
+    expect(result.pages[0]).toHaveProperty('content');
+    expect(result.pages[0]).toHaveProperty('links');
+    expect(result.site_scores.overallScore).toBeGreaterThanOrEqual(0);
+    expect(result.site_scores.overallScore).toBeLessThanOrEqual(100);
+  });
+
+  test('module filter flags behavior', async () => {
+    const seoOnly = await analyzeSite('https://example.com', { fromCrawl: fixturePath, seo: true });
+    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 });
+    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 });
+    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 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');
+
+    // 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;
+    }
+  });
+
+  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 });
+    expect(result.pages[0].content.wordCount).toBe(1000);
+    await fs.unlink(tmpFile);
+  });
+});

package/tests/audit/dns.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect, vi } from 'vitest';
+import { resolveDns } from '../../src/audit/dns.js';
+import dns from 'node:dns/promises';
+
+vi.mock('node:dns/promises');
+
+describe('DNS Diagnostics', () => {
+  it('should resolve all records', async () => {
+    vi.spyOn(dns, 'resolve4').mockResolvedValue(['1.1.1.1']);
+    vi.spyOn(dns, 'resolve6').mockResolvedValue(['2606::1']);
+    vi.spyOn(dns, 'resolveCname').mockRejectedValue(new Error('ENODATA'));
+    vi.spyOn(dns, 'reverse').mockResolvedValue(['one.one.one.one']);
+
+    const result = await resolveDns('example.com');
+    expect(result.a).toEqual(['1.1.1.1']);
+    expect(result.aaaa).toEqual(['2606::1']);
+    expect(result.ipv6Support).toBe(true);
+    expect(result.reverse).toEqual(['one.one.one.one']);
+    expect(result.resolutionTime).toBeGreaterThanOrEqual(0);
+  });
+
+  it('should handle failures gracefully', async () => {
+    vi.spyOn(dns, 'resolve4').mockRejectedValue(new Error('ENOTFOUND'));
+    vi.spyOn(dns, 'resolve6').mockRejectedValue(new Error('ENOTFOUND'));
+    vi.spyOn(dns, 'resolveCname').mockRejectedValue(new Error('ENOTFOUND'));
+
+    const result = await resolveDns('invalid.com');
+    expect(result.a).toEqual([]);
+    expect(result.ipCount).toBe(0);
+  });
+});

package/tests/audit/headers.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { analyzeHeaders } from '../../src/audit/headers.js';
+
+describe('Headers Analysis', () => {
+  it('should detect all secure headers', () => {
+    const headers = {
+      'strict-transport-security': 'max-age=31536000; includeSubDomains',
+      'content-security-policy': "default-src 'self'",
+      'x-frame-options': 'DENY',
+      'x-content-type-options': 'nosniff',
+      'referrer-policy': 'strict-origin-when-cross-origin',
+      'permissions-policy': 'geolocation=()'
+    };
+    const result = analyzeHeaders(headers);
+    expect(result.score).toBe(100);
+    expect(result.strictTransportSecurity.valid).toBe(true);
+  });
+
+  it('should handle missing headers', () => {
+    const headers = {};
+    const result = analyzeHeaders(headers);
+    expect(result.score).toBe(0);
+    expect(result.strictTransportSecurity.present).toBe(false);
+  });
+
+  it('should validate HSTS properly', () => {
+    const headers = {
+      'strict-transport-security': 'max-age=0'
+    };
+    // valid requires max-age
+    const result = analyzeHeaders(headers);
+    expect(result.strictTransportSecurity.valid).toBe(true);
+    // Wait, checkHSTS: includes('max-age=') is true. includes('includeSubDomains') is false.
+    // Issues will contain 'Missing includeSubDomains'.
+    expect(result.strictTransportSecurity.issues).toContain('Missing includeSubDomains');
+  });
+
+  it('should validate invalid HSTS', () => {
+    const headers = {
+      'strict-transport-security': 'invalid'
+    };
+    const result = analyzeHeaders(headers);
+    expect(result.strictTransportSecurity.valid).toBe(false);
+  });
+});