@crawlith/core 0.1.0 → 0.1.1

package/tests/fetcher.test.ts

@@ -1,6 +1,7 @@
-import { test, expect, beforeEach } from 'vitest';
+import { test, expect, beforeEach, vi } from 'vitest';
 import { Fetcher } from '../src/crawler/fetcher.js';
 import { MockAgent, setGlobalDispatcher } from 'undici';
+import { IPGuard } from '../src/core/security/ipGuard.js';
 
 let mockAgent: MockAgent;
 
@@ -8,6 +9,9 @@ beforeEach(() => {
   mockAgent = new MockAgent();
   mockAgent.disableNetConnect();
   setGlobalDispatcher(mockAgent);
+
+  // IPGuard.getSecureDispatcher must return the mockAgent so Fetcher uses it
+  vi.spyOn(IPGuard, 'getSecureDispatcher').mockReturnValue(mockAgent as any);
 });
 
 test('fetches simple page', async () => {

package/tests/fetcher_safety.test.ts

@@ -2,9 +2,15 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { Fetcher } from '../src/crawler/fetcher.js';
 import { request } from 'undici';
 
-vi.mock('undici', () => ({
-    request: vi.fn(),
-}));
+vi.mock('undici', () => {
+    return {
+        request: vi.fn(),
+        Agent: class {
+            dispatch = vi.fn();
+        },
+        Dispatcher: class {}
+    };
+});
 
 describe('Fetcher Safety Integration', () => {
     let fetcher: Fetcher;

package/tests/graph/graph.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Graph } from '../../src/graph/graph.js';
+
+describe('Graph', () => {
+  let graph: Graph;
+
+  beforeEach(() => {
+    graph = new Graph();
+  });
+
+  it('should add a new node', () => {
+    graph.addNode('http://example.com', 0, 200);
+    const node = graph.nodes.get('http://example.com');
+    expect(node).toBeDefined();
+    expect(node?.depth).toBe(0);
+    expect(node?.status).toBe(200);
+  });
+
+  it('should update existing node status if non-zero', () => {
+    graph.addNode('http://example.com', 0, 0);
+    graph.addNode('http://example.com', 1, 200); // Should update status, but not depth?
+    // Wait, addNode implementation:
+    // if (!existing) { ... } else { if (status !== 0) existing.status = status; }
+
+    const node = graph.nodes.get('http://example.com');
+    expect(node?.status).toBe(200);
+    expect(node?.depth).toBe(0); // Depth should not change
+  });
+
+  it('should add an edge', () => {
+    graph.addNode('http://a.com', 0);
+    graph.addNode('http://b.com', 1);
+    graph.addEdge('http://a.com', 'http://b.com', 0.5);
+
+    const edgeKey = Graph.getEdgeKey('http://a.com', 'http://b.com');
+    expect(graph.edges.has(edgeKey)).toBe(true);
+    expect(graph.edges.get(edgeKey)).toBe(0.5);
+
+    const source = graph.nodes.get('http://a.com');
+    const target = graph.nodes.get('http://b.com');
+    expect(source?.outLinks).toBe(1);
+    expect(target?.inLinks).toBe(1);
+  });
+
+  it('should update edge weight if new weight is higher', () => {
+    graph.addNode('http://a.com', 0);
+    graph.addNode('http://b.com', 1);
+    graph.addEdge('http://a.com', 'http://b.com', 0.5);
+    graph.addEdge('http://a.com', 'http://b.com', 0.8);
+
+    const edgeKey = Graph.getEdgeKey('http://a.com', 'http://b.com');
+    expect(graph.edges.get(edgeKey)).toBe(0.8);
+
+    // Should not increment link counts again
+    const source = graph.nodes.get('http://a.com');
+    expect(source?.outLinks).toBe(1);
+  });
+
+  it('should not update edge weight if new weight is lower', () => {
+    graph.addNode('http://a.com', 0);
+    graph.addNode('http://b.com', 1);
+    graph.addEdge('http://a.com', 'http://b.com', 0.8);
+    graph.addEdge('http://a.com', 'http://b.com', 0.5);
+
+    const edgeKey = Graph.getEdgeKey('http://a.com', 'http://b.com');
+    expect(graph.edges.get(edgeKey)).toBe(0.8);
+  });
+
+  it('should serialize to JSON and deserialize from JSON', () => {
+    graph.addNode('http://a.com', 0, 200);
+    graph.addNode('http://b.com', 1, 200);
+    graph.addEdge('http://a.com', 'http://b.com', 1.0);
+    graph.duplicateClusters = [{ id: '1', type: 'exact', size: 2, representative: 'http://a.com', severity: 'high' }];
+    graph.contentClusters = [{ id: 1, count: 2, primaryUrl: 'http://a.com', risk: 'high' }];
+
+    const json = graph.toJSON();
+    const newGraph = Graph.fromJSON(json);
+
+    expect(newGraph.nodes.size).toBe(2);
+    expect(newGraph.edges.size).toBe(1);
+    expect(newGraph.duplicateClusters).toHaveLength(1);
+    expect(newGraph.contentClusters).toHaveLength(1);
+
+    const nodeA = newGraph.nodes.get('http://a.com');
+    expect(nodeA?.status).toBe(200);
+
+    const edgeKey = Graph.getEdgeKey('http://a.com', 'http://b.com');
+    expect(newGraph.edges.get(edgeKey)).toBe(1.0);
+  });
+
+  it('should handle partial JSON in fromJSON', () => {
+    const json = {
+      nodes: [{ url: 'http://a.com', depth: 0, status: 200, inLinks: 0, outLinks: 0 }],
+      // missing edges, clusters
+    };
+    const newGraph = Graph.fromJSON(json);
+    expect(newGraph.nodes.size).toBe(1);
+    expect(newGraph.edges.size).toBe(0);
+  });
+});

package/tests/graphLoader.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { loadGraphFromSnapshot } from '../src/db/graphLoader.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 { MetricsRepository } from '../src/db/repositories/MetricsRepository.js';
+import { Database } from 'better-sqlite3';
+
+describe('GraphLoader', () => {
+    let db: Database;
+
+    beforeEach(() => {
+        process.env.NODE_ENV = 'test';
+        closeDb();
+        db = getDb();
+    });
+
+    afterEach(() => {
+        closeDb();
+    });
+
+    it('should load graph with metrics correctly', () => {
+        const siteRepo = new SiteRepository(db);
+        const snapshotRepo = new SnapshotRepository(db);
+        const pageRepo = new PageRepository(db);
+        const metricsRepo = new MetricsRepository(db);
+
+        const siteId = siteRepo.createSite('example.com');
+        const snapshotId = snapshotRepo.createSnapshot(siteId, 'full');
+        const url = 'http://example.com/page1';
+
+        // Create Page
+        pageRepo.upsertPage({
+            site_id: siteId,
+            normalized_url: url,
+            last_seen_snapshot_id: snapshotId,
+            http_status: 200,
+            depth: 0
+        });
+        const page = pageRepo.getPage(siteId, url)!;
+
+        // Insert Metrics
+        metricsRepo.insertMetrics({
+            snapshot_id: snapshotId,
+            page_id: page.id,
+            authority_score: 0.5,
+            hub_score: 0.2,
+            pagerank: 0.8,
+            pagerank_score: 80.0,
+            link_role: 'authority',
+            crawl_status: 'fetched',
+            word_count: 500,
+            thin_content_score: 10,
+            external_link_ratio: 0.1,
+            orphan_score: 5,
+            duplicate_cluster_id: null,
+            duplicate_type: null,
+            is_cluster_primary: 1
+        });
+
+        // Load Graph
+        const graph = loadGraphFromSnapshot(snapshotId);
+        const node = graph.nodes.get(url);
+
+        expect(node).toBeDefined();
+        expect(node?.authorityScore).toBe(0.5);
+        expect(node?.hubScore).toBe(0.2);
+        // Verify new fields
+        expect(node?.crawlStatus).toBe('fetched');
+        expect(node?.wordCount).toBe(500);
+        expect(node?.thinContentScore).toBe(10);
+        expect(node?.externalLinkRatio).toBe(0.1);
+        expect(node?.orphanScore).toBe(5);
+    });
+
+    it('should handle null metrics gracefully', () => {
+        const siteRepo = new SiteRepository(db);
+        const snapshotRepo = new SnapshotRepository(db);
+        const pageRepo = new PageRepository(db);
+        const metricsRepo = new MetricsRepository(db);
+
+        const siteId = siteRepo.createSite('example.com');
+        const snapshotId = snapshotRepo.createSnapshot(siteId, 'full');
+        const url = 'http://example.com/page2';
+
+        pageRepo.upsertPage({
+            site_id: siteId,
+            normalized_url: url,
+            last_seen_snapshot_id: snapshotId,
+            http_status: 200,
+            depth: 1
+        });
+        const page = pageRepo.getPage(siteId, url)!;
+
+        // Insert Metrics with nulls
+        metricsRepo.insertMetrics({
+            snapshot_id: snapshotId,
+            page_id: page.id,
+            authority_score: null,
+            hub_score: null,
+            pagerank: null,
+            pagerank_score: null,
+            link_role: null,
+            crawl_status: null,
+            word_count: null,
+            thin_content_score: null,
+            external_link_ratio: null,
+            orphan_score: null,
+            duplicate_cluster_id: null,
+            duplicate_type: null,
+            is_cluster_primary: 0
+        });
+
+        const graph = loadGraphFromSnapshot(snapshotId);
+        const node = graph.nodes.get(url);
+
+        expect(node).toBeDefined();
+        // Check undefined
+        expect(node?.crawlStatus).toBeUndefined();
+        expect(node?.wordCount).toBeUndefined();
+        expect(node?.thinContentScore).toBeUndefined();
+    });
+});

package/tests/html_report.test.ts

@@ -1,58 +1,59 @@
 import { describe, expect, test } from 'vitest';
-import { generateHtml } from '../src/report/html.js';
-import { Metrics } from '../src/graph/metrics.js';
+import { renderAnalysisHtml, AnalysisResult, PageAnalysis } from '../src/analysis/analyze.js';
 
-describe('html report generator', () => {
-    test('generates valid html string with metrics', () => {
-        const mockMetrics: Metrics = {
-            totalPages: 10,
-            totalEdges: 20,
-            orphanPages: ['https://example.com/orphan'],
-            nearOrphans: [],
-            deepPages: [],
-            topAuthorityPages: [{ url: 'https://example.com/', authority: 0.9 }],
-            averageOutDegree: 2.0,
-            maxDepthFound: 5,
-            crawlEfficiencyScore: 0.8,
-            averageDepth: 3.0,
-            structuralEntropy: 1.5,
-            topPageRankPages: [],
-            limitReached: false,
-            sessionStats: {
-                pagesFetched: 5,
-                pagesCached: 2,
-                pagesSkipped: 0,
-                totalFound: 7
-            }
-        };
+const mockPage: PageAnalysis = {
+  url: 'https://example.com',
+  status: 200,
+  seoScore: 85,
+  thinScore: 10,
+  title: { value: 'Example Title', length: 13, status: 'ok' },
+  metaDescription: { value: 'Example Desc', length: 12, status: 'ok' },
+  h1: { count: 1, status: 'ok', matchesTitle: true },
+  content: { wordCount: 500, uniqueSentenceCount: 50, textHtmlRatio: 0.6 },
+  images: { totalImages: 2, missingAlt: 0, emptyAlt: 0 },
+  links: { internalLinks: 5, externalLinks: 2, nofollowCount: 0, externalRatio: 0.2 },
+  structuredData: { present: true, valid: true, types: ['Article'] },
+  meta: { canonical: 'https://example.com', noindex: false, nofollow: false }
+};
 
-        const mockGraphData = {
-            nodes: [{ url: 'https://example.com/', depth: 0, inLinks: 5, outLinks: 2, status: 200 }],
-            edges: []
-        };
+const mockResult: AnalysisResult = {
+  site_summary: {
+    pages_analyzed: 1,
+    avg_seo_score: 85,
+    thin_pages: 0,
+    duplicate_titles: 0,
+    site_score: 90
+  },
+  site_scores: { overallScore: 90, seoHealthScore: 85 },
+  pages: [mockPage],
+  active_modules: { seo: true, content: true, accessibility: true }
+};
 
-        const html = generateHtml(mockGraphData, mockMetrics);
+describe('HTML Report Generation', () => {
+  test('generates single page report correctly', () => {
+    // If pages length is 1, it renders single page report
+    const html = renderAnalysisHtml(mockResult);
+    expect(html).toContain('<!DOCTYPE html>');
+    expect(html).toContain('Analysis for https://example.com');
+    expect(html).toContain('Example Title');
+    expect(html).toContain('Example Desc');
+    expect(html).toContain('500 words');
+    expect(html).toContain('<span class="status-ok">Valid</span>');
+  });
 
-        expect(html).toContain('<!DOCTYPE html>');
-        expect(html).toContain('Crawlith Site Graph');
-        expect(html).toContain('10</span>'); // totalPages
-        expect(html).toContain('5 pages</span>'); // pagesFetched
-        expect(html).toContain('2</span>'); // pagesCached
-        expect(html).toContain('https://example.com/orphan');
-        expect(html).toContain('window.GRAPH_DATA =');
-    });
+  test('generates list report correctly', () => {
+    // Modify result to have 2 pages to trigger list view
+    const listResult: AnalysisResult = {
+      ...mockResult,
+      pages: [mockPage, { ...mockPage, url: 'https://example.com/2' }]
+    };
+    const html = renderAnalysisHtml(listResult);
 
-    test('handles missing session stats', () => {
-        const mockMetrics: any = {
-            totalPages: 10,
-            totalEdges: 20,
-            orphanPages: [],
-            averageOutDegree: 2.0,
-            maxDepthFound: 5,
-            topAuthorityPages: [],
-            sessionStats: null
-        };
-        const html = generateHtml({ nodes: [], edges: [] }, mockMetrics as any);
-        expect(html).not.toContain('Session Crawl:');
-    });
+    expect(html).toContain('<!DOCTYPE html>');
+    expect(html).toContain('Crawlith Analysis Report');
+    expect(html).toContain('Pages: 1'); // site_summary.pages_analyzed is 1 in mockResult
+    expect(html).toContain('https://example.com');
+    expect(html).toContain('https://example.com/2');
+    expect(html).toContain('<td>85</td>'); // seoScore
+  });
 });

package/tests/ipGuard.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi } from 'vitest';
+import { IPGuard } from '../src/core/security/ipGuard.js';
+import * as dns from 'dns';
+
+vi.mock('dns', () => ({
+    lookup: vi.fn(),
+    resolve4: vi.fn(),
+    resolve6: vi.fn(),
+}));
+
+describe('IPGuard Secure Lookup', () => {
+    it('should resolve safe IPs', () => {
+        const lookupMock = vi.mocked(dns.lookup);
+        // Mock successful resolution
+        lookupMock.mockImplementation((hostname, options, callback) => {
+            callback(null, '8.8.8.8', 4);
+        });
+
+        const callback = vi.fn();
+        IPGuard.secureLookup('google.com', {}, callback);
+
+        expect(callback).toHaveBeenCalledWith(null, '8.8.8.8', 4);
+    });
+
+    it('should block internal IPs', () => {
+        const lookupMock = vi.mocked(dns.lookup);
+        // Mock internal IP resolution
+        lookupMock.mockImplementation((hostname, options, callback) => {
+            callback(null, '127.0.0.1', 4);
+        });
+
+        const callback = vi.fn();
+        IPGuard.secureLookup('localhost', {}, callback);
+
+        expect(callback).toHaveBeenCalledWith(expect.any(Error), '127.0.0.1', 4);
+        const error = callback.mock.calls[0][0];
+        expect(error.message).toContain('Blocked internal IP');
+        expect(error.code).toBe('EBLOCKED');
+    });
+
+    it('should handle array of IPs (IPv4)', () => {
+        const lookupMock = vi.mocked(dns.lookup);
+        // Mock array resolution
+        lookupMock.mockImplementation((hostname, options, callback) => {
+             // Mocking address array structure
+             const addresses = [
+                 { address: '1.1.1.1', family: 4 },
+                 { address: '127.0.0.1', family: 4 }
+             ];
+             callback(null, addresses as any, 4);
+        });
+
+        const callback = vi.fn();
+        IPGuard.secureLookup('mixed.com', { all: true } as any, callback);
+
+        expect(callback).toHaveBeenCalledWith(expect.any(Error), expect.anything(), 4);
+        const error = callback.mock.calls[0][0];
+        expect(error.message).toContain('Blocked internal IP');
+    });
+
+    it('should pass through DNS errors', () => {
+        const lookupMock = vi.mocked(dns.lookup);
+        const dnsError = new Error('ENOTFOUND');
+        lookupMock.mockImplementation((hostname, options, callback) => {
+            callback(dnsError as any, undefined as any, 0);
+        });
+
+        const callback = vi.fn();
+        IPGuard.secureLookup('invalid.domain', {}, callback);
+
+        expect(callback).toHaveBeenCalledWith(dnsError, undefined, 0);
+    });
+});

package/tests/lock/lockManager.test.ts

@@ -6,6 +6,7 @@ import { existsSync, unlinkSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { isPidAlive } from '../../src/lock/pidCheck.js';
+import { EngineContext } from '../../src/events.js';
 
 // Mock fs and os
 vi.mock('node:fs/promises');
@@ -15,6 +16,8 @@ vi.mock('../../src/lock/pidCheck.js', () => ({
   isPidAlive: vi.fn()
 }));
 
+const mockContext: EngineContext = { emit: vi.fn() };
+
 describe('LockManager', () => {
   const mockHomeDir = '/home/user';
   const lockDir = path.join(mockHomeDir, '.crawlith', 'locks');
@@ -40,23 +43,18 @@ describe('LockManager', () => {
     vi.spyOn(process, 'exit').mockImplementation((code) => {
       throw new Error(`Process exit ${code}`);
     });
-
-    // Mock console to suppress noise
-    vi.spyOn(console, 'log').mockImplementation(() => {});
-    vi.spyOn(console, 'warn').mockImplementation(() => {});
-    vi.spyOn(console, 'error').mockImplementation(() => {});
-
     // Reset static state if any (LockManager stores lockFilePath)
-    // We can't easily reset private static via TS, but we can call releaseLock which clears it if set
     LockManager.releaseLock();
   });
 
   afterEach(() => {
     vi.restoreAllMocks();
+    // Reset static state
+    LockManager.releaseLock();
   });
 
   it('should acquire lock when no lock exists', async () => {
-    await LockManager.acquireLock(command, target, options);
+    await LockManager.acquireLock(command, target, options, mockContext);
 
     expect(fs.mkdir).toHaveBeenCalledWith(lockDir, { recursive: true });
     expect(fs.writeFile).toHaveBeenCalledWith(
@@ -77,9 +75,9 @@ describe('LockManager', () => {
     }));
     vi.mocked(isPidAlive).mockReturnValue(true);
 
-    await expect(LockManager.acquireLock(command, target, options)).rejects.toThrow('Process exit 1');
+    await expect(LockManager.acquireLock(command, target, options, mockContext)).rejects.toThrow('Process exit 1');
 
-    expect(console.error).toHaveBeenCalledWith(expect.stringContaining('already running'));
+    expect(mockContext.emit).toHaveBeenCalledWith(expect.objectContaining({ type: 'error', message: expect.stringContaining('already running') }));
   });
 
   it('should clear stale lock and acquire if PID is dead', async () => {
@@ -93,11 +91,11 @@ describe('LockManager', () => {
     }));
     vi.mocked(isPidAlive).mockReturnValue(false);
 
-    await LockManager.acquireLock(command, target, options);
+    await LockManager.acquireLock(command, target, options, mockContext);
 
     expect(unlinkSync).toHaveBeenCalledWith(lockPath);
     expect(fs.writeFile).toHaveBeenCalled();
-    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Detected stale lock'));
+    expect(mockContext.emit).toHaveBeenCalledWith(expect.objectContaining({ type: 'info', message: expect.stringContaining('Detected stale lock') }));
   });
 
   it('should override lock if force is true', async () => {
@@ -108,24 +106,24 @@ describe('LockManager', () => {
     }));
     vi.mocked(isPidAlive).mockReturnValue(true);
 
-    await LockManager.acquireLock(command, target, options, true); // force = true
+    await LockManager.acquireLock(command, target, options, mockContext, true); // force = true
 
     expect(unlinkSync).toHaveBeenCalledWith(lockPath);
     expect(fs.writeFile).toHaveBeenCalled();
-    expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Force mode enabled'));
+    expect(mockContext.emit).toHaveBeenCalledWith(expect.objectContaining({ type: 'warn', message: expect.stringContaining('Force mode enabled') }));
   });
 
   it('should handle race condition (EEXIST)', async () => {
     vi.mocked(existsSync).mockReturnValue(false);
     vi.mocked(fs.writeFile).mockRejectedValue({ code: 'EEXIST' });
 
-    await expect(LockManager.acquireLock(command, target, options)).rejects.toThrow('Process exit 1');
-    expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Race condition'));
+    await expect(LockManager.acquireLock(command, target, options, mockContext)).rejects.toThrow('Process exit 1');
+    expect(mockContext.emit).toHaveBeenCalledWith(expect.objectContaining({ type: 'error', message: expect.stringContaining('Race condition') }));
   });
 
   it('should release lock on exit', async () => {
     // Acquire first (existsSync returns false by default from beforeEach)
-    await LockManager.acquireLock(command, target, options);
+    await LockManager.acquireLock(command, target, options, mockContext);
 
     // Simulate file exists for release
     vi.mocked(existsSync).mockReturnValue(true);
@@ -135,4 +133,66 @@ describe('LockManager', () => {
 
     expect(unlinkSync).toHaveBeenCalledWith(lockPath);
   });
+
+  it('should register signal handlers and cleanup on SIGINT', async () => {
+    const processOnSpy = vi.spyOn(process, 'on');
+    await LockManager.acquireLock(command, target, options, mockContext);
+
+    // Find the handler
+    const sigintCall = processOnSpy.mock.calls.find(call => call[0] === 'SIGINT');
+    expect(sigintCall).toBeDefined();
+    const handler = sigintCall![1] as () => void;
+
+    // Trigger handler
+    vi.mocked(existsSync).mockReturnValue(true); // Simulate file still exists
+    try {
+      handler();
+    } catch (e: any) {
+      // Expect process.exit(130) which throws error in our mock
+      expect(e.message).toBe('Process exit 130');
+    }
+
+    expect(unlinkSync).toHaveBeenCalledWith(lockPath);
+  });
+
+  it('should register signal handlers and cleanup on SIGTERM', async () => {
+    const processOnSpy = vi.spyOn(process, 'on');
+    await LockManager.acquireLock(command, target, options, mockContext);
+
+    // Find the handler
+    const sigtermCall = processOnSpy.mock.calls.find(call => call[0] === 'SIGTERM');
+    expect(sigtermCall).toBeDefined();
+    const handler = sigtermCall![1] as () => void;
+
+    // Trigger handler
+    vi.mocked(existsSync).mockReturnValue(true);
+    try {
+      handler();
+    } catch (e: any) {
+      expect(e.message).toBe('Process exit 143');
+    }
+
+    expect(unlinkSync).toHaveBeenCalledWith(lockPath);
+  });
+
+  it('should register signal handlers and cleanup on uncaughtException', async () => {
+    const processOnSpy = vi.spyOn(process, 'on');
+    await LockManager.acquireLock(command, target, options, mockContext);
+
+    // Find the handler
+    const uncaughtExceptionCall = processOnSpy.mock.calls.find(call => call[0] === 'uncaughtException');
+    expect(uncaughtExceptionCall).toBeDefined();
+    const handler = uncaughtExceptionCall![1] as (err: Error) => void;
+
+    // Trigger handler
+    vi.mocked(existsSync).mockReturnValue(true);
+    try {
+      handler(new Error('Test error'));
+    } catch (e: any) {
+      expect(e.message).toBe('Process exit 1');
+    }
+
+    expect(unlinkSync).toHaveBeenCalledWith(lockPath);
+    expect(mockContext.emit).toHaveBeenCalledWith(expect.objectContaining({ type: 'error', message: expect.stringContaining('Uncaught Exception'), error: expect.any(Error) }));
+  });
 });

package/tests/normalize.test.ts

@@ -1,5 +1,4 @@
 import { normalizeUrl } from '../src/crawler/normalize.js';
-import { extractLinks } from '../src/crawler/extract.js';
 import { test, expect } from 'vitest';
 
 test('normalizeUrl', () => {
@@ -11,24 +10,6 @@ test('normalizeUrl', () => {
   expect(normalizeUrl('https://example.com/', '')).toBe('https://example.com/');
 });
 
-test('extractLinks', () => {
-  const html = `
-    <html>
-      <body>
-        <a href="/foo">Foo</a>
-        <a href="bar">Bar</a>
-        <a href="https://other.com/baz">Baz</a>
-        <a href="#top">Top</a>
-      </body>
-    </html>
-  `;
-  const links = extractLinks(html, 'https://example.com/page/');
-  expect(links).toContain('https://example.com/foo');
-  expect(links).toContain('https://example.com/page/bar');
-  expect(links).toContain('https://other.com/baz');
-  expect(links).not.toContain('https://example.com/page/#top');
-  expect(links).toContain('https://example.com/page/'); // #top resolves to base url without fragment
-});
 test('normalizeUrl: absolute resolution', () => {
   expect(normalizeUrl('/foo', 'https://example.com')).toBe('https://example.com/foo');
   expect(normalizeUrl('bar', 'https://example.com/baz/')).toBe('https://example.com/baz/bar');
@@ -95,6 +76,12 @@ test('normalizeUrl: skip non-HTML assets', () => {
   expect(normalizeUrl('https://example.com/page', '')).toBe('https://example.com/page');
 });
 
+test('normalizeUrl: invalid URL', () => {
+  expect(normalizeUrl('/foo', '')).toBeNull();
+  expect(normalizeUrl('invalid-url', '')).toBeNull();
+  expect(normalizeUrl('/foo', 'invalid-base')).toBeNull();
+});
+
 test('normalizeUrl: return format', () => {
   const res = normalizeUrl('https://example.com/foo?a=1', '');
   expect(res).toBe('https://example.com/foo?a=1');