@crawlith/core 0.1.1 → 0.1.2

package/tests/db.test.ts

@@ -1,159 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import Database from 'better-sqlite3';
-import { initSchema } from '../src/db/schema.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 { MetricsRepository } from '../src/db/repositories/MetricsRepository.js';
-
-describe('Database Layer', () => {
-  let db: Database.Database;
-  let siteRepo: SiteRepository;
-  let snapshotRepo: SnapshotRepository;
-  let pageRepo: PageRepository;
-  let edgeRepo: EdgeRepository;
-  let metricsRepo: MetricsRepository;
-
-  beforeEach(() => {
-    db = new Database(':memory:');
-    initSchema(db);
-    siteRepo = new SiteRepository(db);
-    snapshotRepo = new SnapshotRepository(db);
-    pageRepo = new PageRepository(db);
-    edgeRepo = new EdgeRepository(db);
-    metricsRepo = new MetricsRepository(db);
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  it('should create and retrieve a site', () => {
-    const domain = 'example.com';
-    const id = siteRepo.createSite(domain);
-    expect(id).toBeGreaterThan(0);
-
-    const site = siteRepo.getSite(domain);
-    expect(site).toBeDefined();
-    expect(site?.domain).toBe(domain);
-  });
-
-  it('should create and retrieve a snapshot', () => {
-    const siteId = siteRepo.createSite('example.com');
-    const snapshotId = snapshotRepo.createSnapshot(siteId, 'full', 'running');
-    expect(snapshotId).toBeGreaterThan(0);
-
-    const snapshot = snapshotRepo.getLatestSnapshot(siteId);
-    expect(snapshot).toBeDefined();
-    expect(snapshot?.status).toBe('running');
-
-    snapshotRepo.updateSnapshotStatus(snapshotId, 'completed', { node_count: 10, edge_count: 5 });
-    const updated = snapshotRepo.getLatestSnapshot(siteId);
-    expect(updated?.status).toBe('completed');
-    expect(updated?.node_count).toBe(10);
-  });
-
-  it('should upsert pages', () => {
-    const siteId = siteRepo.createSite('example.com');
-    const snapshotId = snapshotRepo.createSnapshot(siteId, 'full');
-    const url = 'http://example.com';
-
-    // First insert
-    pageRepo.upsertPage({
-      site_id: siteId,
-      normalized_url: url,
-      last_seen_snapshot_id: snapshotId,
-      http_status: 200,
-      depth: 0
-    });
-
-    let page = pageRepo.getPage(siteId, url);
-    expect(page).toBeDefined();
-    expect(page?.first_seen_snapshot_id).toBe(snapshotId);
-    expect(page?.last_seen_snapshot_id).toBe(snapshotId);
-    expect(page?.http_status).toBe(200);
-
-    // Update (second snapshot)
-    const snapshotId2 = snapshotRepo.createSnapshot(siteId, 'incremental');
-    pageRepo.upsertPage({
-      site_id: siteId,
-      normalized_url: url,
-      last_seen_snapshot_id: snapshotId2,
-      http_status: 200, // same status
-      depth: 0
-    });
-
-    page = pageRepo.getPage(siteId, url);
-    expect(page?.first_seen_snapshot_id).toBe(snapshotId); // Should remain the first one
-    expect(page?.last_seen_snapshot_id).toBe(snapshotId2); // Should update to the second one
-  });
-
-  it('should persist new columns (nofollow, security_error, retries)', () => {
-    const siteId = siteRepo.createSite('new-cols.com');
-    const snapshotId = snapshotRepo.createSnapshot(siteId, 'full');
-    const url = 'http://new-cols.com';
-
-    pageRepo.upsertPage({
-      site_id: siteId,
-      normalized_url: url,
-      last_seen_snapshot_id: snapshotId,
-      nofollow: 1,
-      security_error: 'blocked',
-      retries: 3
-    });
-
-    const page = pageRepo.getPage(siteId, url);
-    expect(page?.nofollow).toBe(1);
-    expect(page?.security_error).toBe('blocked');
-    expect(page?.retries).toBe(3);
-  });
-
-  it('should insert and retrieve edges', () => {
-    const siteId = siteRepo.createSite('example.com');
-    const snapshotId = snapshotRepo.createSnapshot(siteId, 'full');
-
-    // Create pages first
-    pageRepo.upsertPage({ site_id: siteId, normalized_url: 'http://example.com/1', last_seen_snapshot_id: snapshotId });
-    pageRepo.upsertPage({ site_id: siteId, normalized_url: 'http://example.com/2', last_seen_snapshot_id: snapshotId });
-
-    const p1 = pageRepo.getPage(siteId, 'http://example.com/1')!;
-    const p2 = pageRepo.getPage(siteId, 'http://example.com/2')!;
-
-    edgeRepo.insertEdge(snapshotId, p1.id, p2.id, 1.0, 'internal');
-
-    const edges = edgeRepo.getEdgesBySnapshot(snapshotId);
-    expect(edges).toHaveLength(1);
-    expect(edges[0].source_page_id).toBe(p1.id);
-    expect(edges[0].target_page_id).toBe(p2.id);
-  });
-
-  it('should insert and retrieve metrics', () => {
-    const siteId = siteRepo.createSite('example.com');
-    const snapshotId = snapshotRepo.createSnapshot(siteId, 'full');
-    pageRepo.upsertPage({ site_id: siteId, normalized_url: 'http://example.com/1', last_seen_snapshot_id: snapshotId });
-    const p1 = pageRepo.getPage(siteId, 'http://example.com/1')!;
-
-    metricsRepo.insertMetrics({
-      snapshot_id: snapshotId,
-      page_id: p1.id,
-      authority_score: 0.5,
-      hub_score: 0.2,
-      pagerank: 0.8,
-      pagerank_score: 80.0,
-      link_role: 'authority',
-      crawl_status: 'fetched',
-      word_count: 100,
-      thin_content_score: 0.1,
-      external_link_ratio: 0.0,
-      orphan_score: 0,
-      duplicate_cluster_id: null,
-      duplicate_type: null,
-      is_cluster_primary: 0
-    });
-
-    const metrics = metricsRepo.getMetricsForPage(snapshotId, p1.id);
-    expect(metrics).toBeDefined();
-    expect(metrics?.authority_score).toBe(0.5);
-  });
-});

package/tests/db_repos.test.ts

@@ -1,72 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import Database from 'better-sqlite3';
-import { initSchema } from '../src/db/schema.js';
-import { SiteRepository } from '../src/db/repositories/SiteRepository.js';
-import { SnapshotRepository } from '../src/db/repositories/SnapshotRepository.js';
-
-describe('SiteRepository & SnapshotRepository', () => {
-  let db: Database.Database;
-  let siteRepo: SiteRepository;
-  let snapshotRepo: SnapshotRepository;
-
-  beforeEach(() => {
-    db = new Database(':memory:');
-    initSchema(db);
-    siteRepo = new SiteRepository(db);
-    snapshotRepo = new SnapshotRepository(db);
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  it('getAllSites should return all sites ordered by domain', () => {
-    siteRepo.createSite('b.com');
-    siteRepo.createSite('a.com');
-    siteRepo.createSite('c.com');
-
-    const sites = siteRepo.getAllSites();
-    expect(sites).toHaveLength(3);
-    expect(sites[0].domain).toBe('a.com');
-    expect(sites[1].domain).toBe('b.com');
-    expect(sites[2].domain).toBe('c.com');
-  });
-
-  it('getSnapshotCount should return correct count', () => {
-    const siteId = siteRepo.createSite('test.com');
-
-    expect(snapshotRepo.getSnapshotCount(siteId)).toBe(0);
-
-    snapshotRepo.createSnapshot(siteId, 'full');
-    expect(snapshotRepo.getSnapshotCount(siteId)).toBe(1);
-
-    snapshotRepo.createSnapshot(siteId, 'partial');
-    expect(snapshotRepo.getSnapshotCount(siteId)).toBe(2);
-  });
-
-  it('getLatestSnapshot should return the latest snapshot', () => {
-    const siteId = siteRepo.createSite('test.com');
-
-    // First snapshot
-    snapshotRepo.createSnapshot(siteId, 'full', 'completed');
-    // Wait a tiny bit to ensure timestamp diff if needed, but synchronous execution usually implies order
-
-    // Second snapshot
-    const secondId = snapshotRepo.createSnapshot(siteId, 'full', 'running');
-
-    const latest = snapshotRepo.getLatestSnapshot(siteId);
-    expect(latest).toBeDefined();
-    expect(latest?.id).toBe(secondId);
-    expect(latest?.status).toBe('running');
-  });
-
-  it('getLatestSnapshot with status filter', () => {
-    const siteId = siteRepo.createSite('test.com');
-    const firstId = snapshotRepo.createSnapshot(siteId, 'full', 'completed');
-    snapshotRepo.createSnapshot(siteId, 'full', 'running');
-
-    const latestCompleted = snapshotRepo.getLatestSnapshot(siteId, 'completed');
-    expect(latestCompleted).toBeDefined();
-    expect(latestCompleted?.id).toBe(firstId);
-  });
-});

package/tests/diff.test.ts

@@ -1,67 +0,0 @@
-import { test, expect } from 'vitest';
-import { Graph } from '../src/graph/graph.js';
-import { compareGraphs } from '../src/diff/compare.js';
-
-test('detects added and removed urls', () => {
-  const oldGraph = new Graph();
-  oldGraph.addNode('https://example.com/a', 0, 200);
-  oldGraph.addNode('https://example.com/b', 1, 200);
-
-  const newGraph = new Graph();
-  newGraph.addNode('https://example.com/a', 0, 200);
-  newGraph.addNode('https://example.com/c', 1, 200); // Added
-
-  const diff = compareGraphs(oldGraph, newGraph);
-  expect(diff.addedUrls).toContain('https://example.com/c');
-  expect(diff.removedUrls).toContain('https://example.com/b');
-});
-
-test('detects status changes', () => {
-  const oldGraph = new Graph();
-  oldGraph.addNode('https://example.com/a', 0, 200);
-
-  const newGraph = new Graph();
-  newGraph.addNode('https://example.com/a', 0, 404);
-
-  const diff = compareGraphs(oldGraph, newGraph);
-  expect(diff.changedStatus).toHaveLength(1);
-  expect(diff.changedStatus[0]).toEqual({
-    url: 'https://example.com/a',
-    oldStatus: 200,
-    newStatus: 404
-  });
-});
-
-test('detects canonical changes', () => {
-  const oldGraph = new Graph();
-  oldGraph.addNode('https://example.com/a', 0, 200);
-  oldGraph.updateNodeData('https://example.com/a', { canonical: 'https://example.com/canon1' });
-
-  const newGraph = new Graph();
-  newGraph.addNode('https://example.com/a', 0, 200);
-  newGraph.updateNodeData('https://example.com/a', { canonical: 'https://example.com/canon2' });
-
-  const diff = compareGraphs(oldGraph, newGraph);
-  expect(diff.changedCanonical).toHaveLength(1);
-  expect(diff.changedCanonical[0]).toEqual({
-    url: 'https://example.com/a',
-    oldCanonical: 'https://example.com/canon1',
-    newCanonical: 'https://example.com/canon2'
-  });
-});
-
-test('calculates metric deltas', () => {
-  const oldGraph = new Graph();
-  // Orphan: A (depth 1, inLinks 0)
-  oldGraph.addNode('https://example.com/a', 1, 200);
-
-  const newGraph = new Graph();
-  // Not Orphan: Root -> A
-  newGraph.addNode('https://example.com/', 0, 200);
-  newGraph.addNode('https://example.com/a', 1, 200);
-  newGraph.addEdge('https://example.com/', 'https://example.com/a');
-
-  const diff = compareGraphs(oldGraph, newGraph);
-  // Old orphan count: 1 (A). New: 0. Delta: -1.
-  expect(diff.metricDeltas.orphanCount).toBe(-1);
-});

package/tests/duplicate.test.ts

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Graph } from '../src/graph/graph.js';
-import { detectDuplicates } from '../src/graph/duplicate.js';
-import { SimHash } from '../src/graph/simhash.js';
-
-describe('Duplicate Detection', () => {
-    it('should detect exact duplicates based on contentHash', () => {
-        const graph = new Graph();
-        graph.addNode('https://example.com/a', 0, 200);
-        graph.addNode('https://example.com/b', 0, 200);
-        graph.addNode('https://example.com/c', 0, 200);
-
-        graph.updateNodeData('https://example.com/a', { contentHash: 'hash1', uniqueTokenRatio: 1.0 });
-        graph.updateNodeData('https://example.com/b', { contentHash: 'hash1', uniqueTokenRatio: 1.0 });
-        graph.updateNodeData('https://example.com/c', { contentHash: 'hash2', uniqueTokenRatio: 1.0 });
-
-        detectDuplicates(graph);
-
-        expect(graph.duplicateClusters).toHaveLength(1);
-        const cluster = graph.duplicateClusters[0];
-        expect(cluster.type).toBe('exact');
-        expect(cluster.size).toBe(2);
-
-        const nodeA = graph.nodes.get('https://example.com/a')!;
-        const nodeB = graph.nodes.get('https://example.com/b')!;
-        expect(nodeA.duplicateClusterId).toBeDefined();
-        expect(nodeA.duplicateClusterId).toBe(nodeB.duplicateClusterId);
-
-        // One should be primary, one should be collapsed
-        expect(!nodeA.isCollapsed !== !nodeB.isCollapsed).toBe(true);
-    });
-
-    it('should detect near duplicates using SimHash', () => {
-        const graph = new Graph();
-        graph.addNode('https://example.com/x', 0, 200);
-        graph.addNode('https://example.com/y', 0, 200);
-
-        // Calculate simhashes that are 1 bit apart
-        const tokens1 = ['hello', 'world', 'this', 'is', 'a', 'test', 'document'];
-        const tokens2 = ['hello', 'world', 'this', 'is', 'a', 'test', 'document2'];
-
-        const h1 = SimHash.generate(tokens1);
-        const h2 = SimHash.generate(tokens2);
-
-        // Assume standard text gives < 3 diff. For reliability in test, we'll manually set string bigint representations.
-        // Actually, we can just use the calculated ones.
-        graph.updateNodeData('https://example.com/x', { contentHash: 'x', simhash: h1.toString(), uniqueTokenRatio: 1.0 });
-        graph.updateNodeData('https://example.com/y', { contentHash: 'y', simhash: h2.toString(), uniqueTokenRatio: 1.0 });
-
-        detectDuplicates(graph, { simhashThreshold: 10 }); // use high threshold to guarantee match
-
-        expect(graph.duplicateClusters).toHaveLength(1);
-        expect(graph.duplicateClusters[0].type).toBe('near');
-    });
-
-    it('should identify template-heavy clusters', () => {
-        const graph = new Graph();
-        graph.addNode('https://example.com/1', 0, 200);
-        graph.addNode('https://example.com/2', 0, 200);
-
-        graph.updateNodeData('https://example.com/1', { contentHash: 'h1', uniqueTokenRatio: 0.2 });
-        graph.updateNodeData('https://example.com/2', { contentHash: 'h1', uniqueTokenRatio: 0.2 });
-
-        detectDuplicates(graph);
-
-        expect(graph.duplicateClusters[0].type).toBe('template_heavy');
-    });
-
-    it('should mark high severity on missing canonicals', () => {
-        const graph = new Graph();
-        graph.addNode('https://example.com/a', 0, 200);
-        graph.addNode('https://example.com/b', 0, 200);
-
-        graph.updateNodeData('https://example.com/a', { contentHash: 'h1', canonical: 'https://example.com/a' });
-        graph.updateNodeData('https://example.com/b', { contentHash: 'h1', canonical: undefined }); // missing
-
-        detectDuplicates(graph);
-
-        expect(graph.duplicateClusters[0].severity).toBe('high');
-    });
-
-    it('should transfer edges during collapse', () => {
-        const graph = new Graph();
-        graph.addNode('https://example.com/a', 0, 200);
-        graph.addNode('https://example.com/b', 0, 200);
-        graph.addNode('https://example.com/source', 0, 200);
-
-        graph.updateNodeData('https://example.com/a', { contentHash: 'h1' });
-        graph.updateNodeData('https://example.com/b', { contentHash: 'h1' });
-
-        // Add edge pointing to B
-        graph.addEdge('https://example.com/source', 'https://example.com/b', 1);
-
-        // Force A to be the representative by giving it higher inLinks manually, though it's determined dynamically
-        graph.nodes.get('https://example.com/a')!.inLinks = 10;
-
-        detectDuplicates(graph);
-
-        const a = graph.nodes.get('https://example.com/a')!;
-        const b = graph.nodes.get('https://example.com/b')!;
-
-        expect(a.isClusterPrimary).toBe(true);
-        expect(a.isCollapsed).toBe(false);
-        expect(b.isCollapsed).toBe(true);
-        expect(b.collapseInto).toBe('https://example.com/a');
-
-        // Check edge transfer
-        expect(graph.edges.has(Graph.getEdgeKey('https://example.com/source', 'https://example.com/a'))).toBe(true);
-    });
-});

package/tests/extract.test.ts

@@ -1,86 +0,0 @@
-import { extractLinks } from '../src/crawler/extract.js';
-import { test, expect, describe, vi, afterEach } from 'vitest';
-import * as cheerio from 'cheerio';
-
-// Mock cheerio.load to allow us to simulate errors
-vi.mock('cheerio', async (importOriginal) => {
-    const mod = await importOriginal<any>();
-    return {
-        ...mod,
-        load: vi.fn((...args: any[]) => mod.load(...args))
-    };
-});
-
-describe('extractLinks', () => {
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-
-    test('should extract links correctly', () => {
-        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/');
-    });
-
-    test('should handle cheerio errors gracefully', () => {
-        const error = new Error('Cheerio error');
-
-        // Mock cheerio.load to throw an error
-        vi.mocked(cheerio.load).mockImplementationOnce(() => {
-            throw error;
-        });
-
-        const links = extractLinks('<html></html>', 'https://example.com');
-
-        expect(links).toEqual([]);
-        // No console error expected
-    });
-
-    test('should handle non-Error exceptions gracefully', () => {
-        const error = 'String error'; // Simulate a thrown string
-
-        vi.mocked(cheerio.load).mockImplementationOnce(() => {
-            throw error;
-        });
-
-        const links = extractLinks('<html></html>', 'https://example.com');
-
-        expect(links).toEqual([]);
-        // No console error expected
-    });
-
-    test('should ignore invalid URLs that cause URL constructor to throw', () => {
-        const html = '<a href="http://[">Invalid</a>';
-        const links = extractLinks(html, 'https://example.com');
-        expect(links).toEqual([]);
-    });
-
-    test('should ignore non-http protocols', () => {
-        const html = `
-            <a href="mailto:test@example.com">Mail</a>
-            <a href="javascript:void(0)">JS</a>
-            <a href="ftp://example.com/file">FTP</a>
-        `;
-        const links = extractLinks(html, 'https://example.com');
-        expect(links).toEqual([]);
-    });
-
-    test('should ignore links without href', () => {
-        const html = '<a>No Href</a>';
-        const links = extractLinks(html, 'https://example.com');
-        expect(links).toEqual([]);
-    });
-});

package/tests/fetcher.test.ts

@@ -1,110 +0,0 @@
-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;
-
-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 () => {
-  const client = mockAgent.get('https://example.com');
-  client.intercept({ path: '/', method: 'GET' }).reply(200, 'Hello', {
-    headers: { 'content-type': 'text/html', 'etag': '"123"', 'last-modified': 'Mon, 01 Jan 2000 00:00:00 GMT' }
-  });
-
-  const fetcher = new Fetcher();
-  const res = await fetcher.fetch('https://example.com/');
-  expect(res.status).toBe(200);
-  expect(res.body).toBe('Hello');
-  expect(res.etag).toBe('"123"');
-  expect(res.lastModified).toBe('Mon, 01 Jan 2000 00:00:00 GMT');
-  expect(res.redirectChain).toEqual([]);
-});
-
-test('follows redirects', async () => {
-  const client = mockAgent.get('https://example.com');
-  // A -> B
-  client.intercept({ path: '/a', method: 'GET' }).reply(301, '', {
-    headers: { location: '/b' }
-  });
-  // B -> C
-  client.intercept({ path: '/b', method: 'GET' }).reply(302, '', {
-    headers: { location: 'https://other.com/c' }
-  });
-
-  const otherClient = mockAgent.get('https://other.com');
-  // C -> 200
-  otherClient.intercept({ path: '/c', method: 'GET' }).reply(200, 'Final');
-
-  const fetcher = new Fetcher();
-  const res = await fetcher.fetch('https://example.com/a');
-
-  expect(res.status).toBe(200);
-  expect(res.body).toBe('Final');
-  expect(res.finalUrl).toBe('https://other.com/c');
-  expect(res.redirectChain.length).toBe(2);
-  expect(res.redirectChain[0]).toEqual({ url: 'https://example.com/a', status: 301, target: 'https://example.com/b' });
-  expect(res.redirectChain[1]).toEqual({ url: 'https://example.com/b', status: 302, target: 'https://other.com/c' });
-});
-
-test('detects redirect loop', async () => {
-  const client = mockAgent.get('https://loop.com');
-  // A -> B
-  client.intercept({ path: '/a', method: 'GET' }).reply(301, '', { headers: { location: '/b' } });
-  // B -> A (This will be detected as loop)
-  client.intercept({ path: '/b', method: 'GET' }).reply(301, '', { headers: { location: '/a' } });
-
-  const fetcher = new Fetcher();
-  const res = await fetcher.fetch('https://loop.com/a');
-
-  // Should return the redirect_loop security error
-  expect(res.status).toBe('redirect_loop');
-  expect(res.redirectChain.length).toBe(1); // Detected while resolving target of B
-  expect(res.redirectChain[0].url).toBe('https://loop.com/a');
-});
-
-test('sends conditional headers', async () => {
-  const client = mockAgent.get('https://cache.com');
-
-  client.intercept({
-    path: '/',
-    method: 'GET',
-    headers: {
-      'If-None-Match': '"123"',
-      'If-Modified-Since': 'Mon, 01 Jan 2000 00:00:00 GMT'
-    }
-  }).reply(304, '', { headers: { etag: '"123"' } });
-
-  const fetcher = new Fetcher();
-  const res = await fetcher.fetch('https://cache.com/', {
-    etag: '"123"',
-    lastModified: 'Mon, 01 Jan 2000 00:00:00 GMT'
-  });
-
-  expect(res.status).toBe(304);
-  expect(res.body).toBe('');
-});
-
-test('handles max redirects', async () => {
-  const client = mockAgent.get('https://max.com');
-  // 11 redirects
-  for (let i = 0; i < 11; i++) {
-    client.intercept({ path: `/p${i}`, method: 'GET' }).reply(301, '', { headers: { location: `/p${i + 1}` } });
-  }
-
-  // Set maxRedirects to 10 to trigger failure exactly after 10 hops
-  // Increase rate to prevent timeout (11 requests * 500ms > 5000ms)
-  const fetcher = new Fetcher({ maxRedirects: 10, rate: 100 });
-  const res = await fetcher.fetch('https://max.com/p0');
-
-  expect(res.status).toBe('redirect_limit_exceeded');
-  expect(res.redirectChain.length).toBe(10);
-});