@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/modules/captcha/assessment-rules.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/modules/captcha/assessment-rules.test.js

@@ -0,0 +1,17 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { CAPTCHA_MATCH_RULES, EXCLUDE_MATCH_RULES, } from '../../../src/modules/captcha/rules/assessment-rules.js';
+describe('captcha assessment rules', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('contains high-confidence include rules for URLs, titles and challenge text', () => {
+        expect(CAPTCHA_MATCH_RULES.url[0]?.pattern.test('/cdn-cgi/challenge-platform')).toBe(true);
+        expect(CAPTCHA_MATCH_RULES.title[0]?.pattern.test('Security Check')).toBe(true);
+        expect(CAPTCHA_MATCH_RULES.text[1]?.pattern.test('请完成安全验证')).toBe(true);
+    });
+    it('contains exclusion rules for otp and account verification flows', () => {
+        expect(EXCLUDE_MATCH_RULES.url[0]?.pattern.test('/verify-email')).toBe(true);
+        expect(EXCLUDE_MATCH_RULES.title[0]?.pattern.test('Enter verification code')).toBe(true);
+        expect(EXCLUDE_MATCH_RULES.text[1]?.pattern.test('Two-factor authentication')).toBe(true);
+    });
+});

package/dist/tests/modules/captcha/dom-rules.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/modules/captcha/dom-rules.test.js

@@ -0,0 +1,18 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DOM_MATCH_RULES } from '../../../src/modules/captcha/rules/dom-rules.js';
+import { CAPTCHA_SELECTORS } from '../../../src/modules/captcha/rules/selectors.js';
+describe('captcha DOM rules', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('maps DOM heuristics to the selector collections with visibility and verifier hints', () => {
+        const sliderRule = DOM_MATCH_RULES.find((rule) => rule.id === 'generic-slider-dom');
+        const widgetRule = DOM_MATCH_RULES.find((rule) => rule.id === 'embedded-widget-dom');
+        const browserCheckRule = DOM_MATCH_RULES.find((rule) => rule.id === 'edge-browser-check-dom');
+        expect(sliderRule?.selectors).toEqual(CAPTCHA_SELECTORS.slider);
+        expect(sliderRule?.requiresVisibility).toBe(true);
+        expect(sliderRule?.verifier).toBe('slider');
+        expect(widgetRule?.providerHint).toBe('embedded_widget');
+        expect(browserCheckRule?.providerHint).toBe('edge_service');
+    });
+});

package/dist/tests/modules/captcha/selectors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/modules/captcha/selectors.test.js

@@ -0,0 +1,18 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { CAPTCHA_SELECTORS, EXCLUDE_SELECTORS } from '../../../src/modules/captcha/rules/selectors.js';
+describe('captcha selectors', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('defines slider, widget and browser-check selector buckets', () => {
+        expect(CAPTCHA_SELECTORS.slider).toContain('.captcha-slider');
+        expect(CAPTCHA_SELECTORS.widget).toContain('[data-sitekey]');
+        expect(CAPTCHA_SELECTORS.browserCheck).toContain('#challenge-form');
+        expect(CAPTCHA_SELECTORS.generic).toContain('[class*="captcha"]');
+    });
+    it('keeps known non-captcha slider-like elements in the exclude list', () => {
+        expect(EXCLUDE_SELECTORS).toContain('[class*="video"]');
+        expect(EXCLUDE_SELECTORS).toContain('[class*="swiper"]');
+        expect(EXCLUDE_SELECTORS).toContain('[class*="progress"]');
+    });
+});

package/dist/tests/modules/captcha/shared.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/modules/captcha/shared.test.js

@@ -0,0 +1,14 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { mergeUnique } from '../../../src/modules/captcha/rules/shared.js';
+describe('captcha shared helpers', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('deduplicates string values while preserving first-seen order', () => {
+        expect(mergeUnique(['slider', 'widget', 'slider', 'text'])).toEqual([
+            'slider',
+            'widget',
+            'text',
+        ]);
+    });
+});

package/dist/tests/modules/collector/CodeCollector.additional.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/modules/collector/CodeCollector.additional.test.js

@@ -0,0 +1,519 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mocks = vi.hoisted(() => ({
+    launch: vi.fn(),
+    connect: vi.fn(),
+    findBrowserExecutable: vi.fn(),
+    collectInnerImpl: vi.fn(),
+    shouldCollectUrlImpl: vi.fn(),
+    navigateWithRetryImpl: vi.fn(),
+    getPerformanceMetricsImpl: vi.fn(),
+    collectPageMetadataImpl: vi.fn(),
+    calculatePriorityScore: vi.fn(),
+}));
+vi.mock('rebrowser-puppeteer-core', () => ({
+    default: {
+        launch: mocks.launch,
+        connect: mocks.connect,
+    },
+}));
+vi.mock('@utils/browserExecutable', () => ({
+    findBrowserExecutable: mocks.findBrowserExecutable,
+}));
+vi.mock('@utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+vi.mock('@modules/collector/CodeCollectorCollectInternal', () => ({
+    collectInnerImpl: mocks.collectInnerImpl,
+}));
+vi.mock('@modules/collector/CodeCollectorUtilsInternal', () => ({
+    shouldCollectUrlImpl: mocks.shouldCollectUrlImpl,
+    navigateWithRetryImpl: mocks.navigateWithRetryImpl,
+    getPerformanceMetricsImpl: mocks.getPerformanceMetricsImpl,
+    collectPageMetadataImpl: mocks.collectPageMetadataImpl,
+}));
+vi.mock('@modules/collector/PageScriptCollectors', () => ({
+    calculatePriorityScore: mocks.calculatePriorityScore,
+}));
+import { CodeCollector } from '../../../src/modules/collector/CodeCollector.js';
+function createBrowserMock() {
+    return {
+        on: vi.fn(),
+        pages: vi.fn().mockResolvedValue([]),
+        targets: vi.fn().mockReturnValue([]),
+        newPage: vi.fn(),
+        close: vi.fn().mockResolvedValue(undefined),
+        disconnect: vi.fn().mockResolvedValue(undefined),
+        version: vi.fn().mockResolvedValue('Chrome/123'),
+    };
+}
+function createTargetMock(url = 'https://example.com', type = 'page', page = createPageMock(url)) {
+    return {
+        type: vi.fn().mockReturnValue(type),
+        url: vi.fn().mockReturnValue(url),
+        page: vi.fn().mockResolvedValue(page),
+    };
+}
+function createPageMock(url = 'https://example.com') {
+    return {
+        url: vi.fn().mockReturnValue(url),
+        title: vi.fn().mockResolvedValue('Example'),
+        setUserAgent: vi.fn().mockResolvedValue(undefined),
+        evaluateOnNewDocument: vi.fn().mockResolvedValue(undefined),
+        goto: vi.fn().mockResolvedValue(undefined),
+        createCDPSession: vi.fn(),
+    };
+}
+describe('CodeCollector – additional coverage', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mocks.findBrowserExecutable.mockReturnValue(undefined);
+    });
+    describe('constructor', () => {
+        it('applies custom config limits', () => {
+            const collector = new CodeCollector({
+                headless: true,
+                timeout: 5000,
+                maxCollectedUrls: 500,
+                maxFilesPerCollect: 50,
+                maxTotalContentSize: 1024,
+                maxSingleFileSize: 512,
+                viewport: { width: 800, height: 600 },
+                userAgent: 'TestBot/1.0',
+            });
+            expect(collector.MAX_COLLECTED_URLS).toBe(500);
+            expect(collector.MAX_FILES_PER_COLLECT).toBe(50);
+            expect(collector.MAX_RESPONSE_SIZE).toBe(1024);
+            expect(collector.MAX_SINGLE_FILE_SIZE).toBe(512);
+            expect(collector.viewport).toEqual({ width: 800, height: 600 });
+            expect(collector.userAgent).toBe('TestBot/1.0');
+        });
+        it('uses sensible defaults when config omits optional fields', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            expect(collector.MAX_COLLECTED_URLS).toBe(10000);
+            expect(collector.MAX_FILES_PER_COLLECT).toBe(200);
+            expect(collector.viewport).toEqual({ width: 1920, height: 1080 });
+        });
+    });
+    describe('cache management', () => {
+        it('setCacheEnabled toggles the flag', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            collector.setCacheEnabled(false);
+            expect(collector.cacheEnabled).toBe(false);
+            collector.setCacheEnabled(true);
+            expect(collector.cacheEnabled).toBe(true);
+        });
+        it('clearCache resets collected URLs', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            collector.collectedUrls.add('https://site.com/a.js');
+            collector.clearCache();
+            expect(collector.getCollectionStats().totalCollected).toBe(0);
+        });
+        it('clearCollectedFilesCache empties the files map', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            collector.collectedFilesCache.set('url1', { url: 'url1', size: 10 });
+            collector.clearCollectedFilesCache();
+            expect(collector.getCollectedFilesSummary()).toHaveLength(0);
+        });
+    });
+    describe('cleanupCollectedUrls', () => {
+        it('trims URLs when exceeding MAX_COLLECTED_URLS', () => {
+            const collector = new CodeCollector({
+                headless: true,
+                timeout: 1000,
+                maxCollectedUrls: 4,
+            });
+            const urls = collector.collectedUrls;
+            for (let i = 0; i < 5; i++) {
+                urls.add(`https://site.com/${i}.js`);
+            }
+            collector.cleanupCollectedUrls();
+            expect(urls.size).toBe(2);
+        });
+        it('does nothing when URLs are under the limit', () => {
+            const collector = new CodeCollector({
+                headless: true,
+                timeout: 1000,
+                maxCollectedUrls: 100,
+            });
+            collector.collectedUrls.add('https://site.com/a.js');
+            collector.cleanupCollectedUrls();
+            expect(collector.getCollectionStats().totalCollected).toBe(1);
+        });
+    });
+    describe('init', () => {
+        it('does not launch twice when browser is already set', async () => {
+            const browser = createBrowserMock();
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.init();
+            await collector.init();
+            expect(mocks.launch).toHaveBeenCalledTimes(1);
+        });
+        it('deduplicates concurrent init calls', async () => {
+            const browser = createBrowserMock();
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            const [r1, r2] = await Promise.all([collector.init(), collector.init()]);
+            expect(r1).toBeUndefined();
+            expect(r2).toBeUndefined();
+            expect(mocks.launch).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('getStatus', () => {
+        it('returns not running when no browser', async () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            const status = await collector.getStatus();
+            expect(status.running).toBe(false);
+            expect(status.pagesCount).toBe(0);
+        });
+        it('returns running with page count when browser exists', async () => {
+            const browser = createBrowserMock();
+            browser.targets.mockReturnValue([createTargetMock(), createTargetMock('https://site.com/2')]);
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.init();
+            const status = await collector.getStatus();
+            expect(status.running).toBe(true);
+            expect(status.pagesCount).toBe(2);
+            expect(status.version).toBe('Chrome/123');
+        });
+        it('returns not running when browser throws', async () => {
+            const browser = createBrowserMock();
+            browser.version.mockRejectedValue(new Error('disconnected'));
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.init();
+            const status = await collector.getStatus();
+            expect(status.running).toBe(false);
+        });
+    });
+    describe('getActivePage', () => {
+        it('returns the last page when no active index is set', async () => {
+            const page1 = createPageMock('https://site.com/1');
+            const page2 = createPageMock('https://site.com/2');
+            const browser = createBrowserMock();
+            browser.targets.mockReturnValue([
+                createTargetMock('https://site.com/1', 'page', page1),
+                createTargetMock('https://site.com/2', 'page', page2),
+            ]);
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.init();
+            const active = await collector.getActivePage();
+            expect(active).toBe(page2);
+        });
+        it('returns the selected page when activePageIndex is set', async () => {
+            const page1 = createPageMock('https://site.com/1');
+            const page2 = createPageMock('https://site.com/2');
+            const browser = createBrowserMock();
+            browser.targets.mockReturnValue([
+                createTargetMock('https://site.com/1', 'page', page1),
+                createTargetMock('https://site.com/2', 'page', page2),
+            ]);
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.init();
+            await collector.selectPage(0);
+            const active = await collector.getActivePage();
+            expect(active).toBe(page1);
+        });
+        it('creates a new page when pages array is empty', async () => {
+            const newPage = createPageMock();
+            const browser = createBrowserMock();
+            browser.targets.mockReturnValue([]);
+            browser.newPage.mockResolvedValue(newPage);
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.init();
+            const active = await collector.getActivePage();
+            expect(active).toBe(newPage);
+        });
+    });
+    describe('selectPage', () => {
+        it('throws when browser is not connected', async () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await expect(collector.selectPage(0)).rejects.toThrow('Browser not connected');
+        });
+        it('throws on out-of-range index', async () => {
+            const browser = createBrowserMock();
+            browser.targets.mockReturnValue([createTargetMock()]);
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.init();
+            await expect(collector.selectPage(5)).rejects.toThrow('out of range');
+        });
+    });
+    describe('listPages', () => {
+        it('returns empty when no browser', async () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            const pages = await collector.listPages();
+            expect(pages).toEqual([]);
+        });
+        it('returns page metadata', async () => {
+            const target = createTargetMock('https://example.com');
+            const browser = createBrowserMock();
+            browser.targets.mockReturnValue([target]);
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.init();
+            const pages = await collector.listPages();
+            expect(pages).toHaveLength(1);
+            expect(pages[0]).toMatchObject({
+                index: 0,
+                url: 'https://example.com',
+                title: '',
+            });
+        });
+    });
+    describe('createPage', () => {
+        it('creates a page without navigating when no URL provided', async () => {
+            const page = createPageMock();
+            const browser = createBrowserMock();
+            browser.newPage.mockResolvedValue(page);
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 5000 });
+            await collector.init();
+            const newPage = await collector.createPage();
+            expect(newPage).toBe(page);
+            expect(page.setUserAgent).toHaveBeenCalled();
+            expect(page.goto).not.toHaveBeenCalled();
+        });
+        it('creates a page and navigates when URL is provided', async () => {
+            const page = createPageMock();
+            const browser = createBrowserMock();
+            browser.newPage.mockResolvedValue(page);
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 5000 });
+            await collector.init();
+            await collector.createPage('https://target.com');
+            expect(page.goto).toHaveBeenCalledWith('https://target.com', expect.any(Object));
+        });
+    });
+    describe('connect', () => {
+        it('connects via WebSocket endpoint', async () => {
+            const browser = createBrowserMock();
+            mocks.connect.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.connect('ws://127.0.0.1:9222');
+            expect(mocks.connect).toHaveBeenCalledWith({ browserWSEndpoint: 'ws://127.0.0.1:9222' });
+        });
+        it('connects via HTTP URL endpoint', async () => {
+            const browser = createBrowserMock();
+            mocks.connect.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.connect('http://127.0.0.1:9222');
+            expect(mocks.connect).toHaveBeenCalledWith({ browserURL: 'http://127.0.0.1:9222' });
+        });
+        it('disconnects existing browser before connecting', async () => {
+            const oldBrowser = createBrowserMock();
+            const newBrowser = createBrowserMock();
+            mocks.launch.mockResolvedValue(oldBrowser);
+            mocks.connect.mockResolvedValue(newBrowser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.init();
+            await collector.connect('ws://127.0.0.1:9222');
+            expect(oldBrowser.disconnect).toHaveBeenCalled();
+        });
+        it('fails fast when connect handshake never completes', async () => {
+            mocks.connect.mockImplementation(() => new Promise(() => { }));
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            collector.CONNECT_TIMEOUT_MS = 10;
+            const connectPromise = collector.connect({
+                wsEndpoint: 'ws://127.0.0.1:9222/devtools/browser/test',
+                autoConnect: true,
+                channel: 'stable',
+            });
+            await expect(connectPromise).rejects.toThrow(/Timed out after 10ms while connecting to existing browser/);
+        });
+        it('disconnects stale browser if connect resolves after timeout', async () => {
+            let resolveConnect;
+            mocks.connect.mockImplementation(() => new Promise((resolve) => {
+                resolveConnect = resolve;
+            }));
+            const browser = createBrowserMock();
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            collector.CONNECT_TIMEOUT_MS = 10;
+            const connectPromise = collector.connect({
+                wsEndpoint: 'ws://127.0.0.1:9222/devtools/browser/test',
+                autoConnect: true,
+                channel: 'stable',
+            });
+            await expect(connectPromise).rejects.toThrow(/Timed out after 10ms/);
+            resolveConnect(browser);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(browser.disconnect).toHaveBeenCalled();
+            expect(collector.getBrowser()).toBeNull();
+        });
+        it('normalizes non-Error connect failures for autoConnect', async () => {
+            mocks.connect.mockRejectedValue({
+                message: 'connect ECONNREFUSED 127.0.0.1:9222',
+            });
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await expect(collector.connect({
+                wsEndpoint: 'ws://127.0.0.1:9222/devtools/browser/test',
+                autoConnect: true,
+                channel: 'stable',
+            })).rejects.toThrow(/DevToolsActivePort may be stale/);
+        });
+    });
+    describe('close', () => {
+        it('closes browser and clears data', async () => {
+            const browser = createBrowserMock();
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.init();
+            await collector.close();
+            expect(browser.close).toHaveBeenCalled();
+            expect(collector.getBrowser()).toBeNull();
+        });
+        it('disconnects instead of closing when attached to an existing browser', async () => {
+            const browser = createBrowserMock();
+            mocks.connect.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.connect('ws://127.0.0.1:9222/devtools/browser/test');
+            await collector.close();
+            expect(browser.disconnect).toHaveBeenCalled();
+            expect(browser.close).not.toHaveBeenCalled();
+        });
+    });
+    describe('getCollectionStats', () => {
+        it('returns zero counts initially', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            const stats = collector.getCollectionStats();
+            expect(stats.totalCollected).toBe(0);
+            expect(stats.uniqueUrls).toBe(0);
+        });
+    });
+    describe('getFileByUrl', () => {
+        it('returns a cached file by URL', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            const file = { url: 'https://site.com/a.js', size: 100, content: 'abc', type: 'external' };
+            collector.collectedFilesCache.set('https://site.com/a.js', file);
+            expect(collector.getFileByUrl('https://site.com/a.js')).toBe(file);
+        });
+        it('returns null for unknown URL', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            expect(collector.getFileByUrl('https://site.com/nonexistent.js')).toBeNull();
+        });
+    });
+    describe('getCollectedFilesSummary', () => {
+        it('includes truncated and originalSize metadata when present', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            collector.collectedFilesCache.set('url1', {
+                url: 'url1',
+                size: 50,
+                type: 'external',
+                metadata: { truncated: true, originalSize: 500 },
+            });
+            const summary = collector.getCollectedFilesSummary();
+            expect(summary).toHaveLength(1);
+            expect(summary[0]).toMatchObject({
+                url: 'url1',
+                truncated: true,
+                originalSize: 500,
+            });
+        });
+        it('returns undefined for truncated/originalSize when metadata is absent', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            collector.collectedFilesCache.set('url2', {
+                url: 'url2',
+                size: 30,
+                type: 'inline',
+            });
+            const summary = collector.getCollectedFilesSummary();
+            expect(summary[0]?.truncated).toBeUndefined();
+            expect(summary[0]?.originalSize).toBeUndefined();
+        });
+    });
+    describe('getFilesByPattern', () => {
+        it('returns all matching files within limits', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            collector.collectedFilesCache = new Map([
+                ['https://site/a.js', { url: 'https://site/a.js', content: 'a', size: 5, type: 'external' }],
+                ['https://site/b.js', { url: 'https://site/b.js', content: 'b', size: 5, type: 'external' }],
+            ]);
+            const result = collector.getFilesByPattern('\\.js$', 10, 100_000);
+            expect(result.matched).toBe(2);
+            expect(result.returned).toBe(2);
+            expect(result.truncated).toBe(false);
+        });
+        it('limits returned files to count limit even when more match', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            collector.collectedFilesCache = new Map([
+                ['https://site/a.js', { url: 'https://site/a.js', content: 'a', size: 1, type: 'external' }],
+                ['https://site/b.js', { url: 'https://site/b.js', content: 'b', size: 1, type: 'external' }],
+                ['https://site/c.js', { url: 'https://site/c.js', content: 'c', size: 1, type: 'external' }],
+            ]);
+            const result = collector.getFilesByPattern('\\.js$', 2, 100_000);
+            expect(result.matched).toBe(3);
+            expect(result.returned).toBe(2);
+        });
+        it('sets truncated true when size limit prevents all files from being returned', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            collector.collectedFilesCache = new Map([
+                ['https://site/a.js', { url: 'https://site/a.js', content: 'a'.repeat(10), size: 10, type: 'external' }],
+                ['https://site/b.js', { url: 'https://site/b.js', content: 'b'.repeat(10), size: 10, type: 'external' }],
+            ]);
+            const result = collector.getFilesByPattern('\\.js$', 10, 15);
+            expect(result.returned).toBe(1);
+            expect(result.truncated).toBe(true);
+        });
+    });
+    describe('getTopPriorityFiles', () => {
+        it('returns empty when cache is empty', () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            const result = collector.getTopPriorityFiles(5, 100_000);
+            expect(result.files).toHaveLength(0);
+            expect(result.totalFiles).toBe(0);
+        });
+        it('respects max total size constraint', () => {
+            mocks.calculatePriorityScore.mockReturnValue(10);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            collector.collectedFilesCache = new Map([
+                ['u1', { url: 'u1', content: 'x'.repeat(100), size: 100, type: 'external' }],
+                ['u2', { url: 'u2', content: 'y'.repeat(100), size: 100, type: 'external' }],
+            ]);
+            const result = collector.getTopPriorityFiles(10, 150);
+            expect(result.files).toHaveLength(1);
+            expect(result.totalSize).toBe(100);
+        });
+    });
+    describe('getAllStats', () => {
+        it('aggregates cache, compression, and collector stats', async () => {
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            const stats = await collector.getAllStats();
+            expect(stats).toHaveProperty('cache');
+            expect(stats).toHaveProperty('compression');
+            expect(stats).toHaveProperty('collector');
+            expect(stats.collector.collectedUrls).toBe(0);
+        });
+    });
+    describe('delegation methods', () => {
+        it('shouldCollectUrl delegates to implementation', () => {
+            mocks.shouldCollectUrlImpl.mockReturnValue(true);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            const result = collector.shouldCollectUrl('https://example.com/script.js');
+            expect(result).toBe(true);
+            expect(mocks.shouldCollectUrlImpl).toHaveBeenCalledWith('https://example.com/script.js', undefined);
+        });
+        it('collect serializes concurrent calls', async () => {
+            mocks.collectInnerImpl.mockResolvedValue({ files: [], totalSize: 0 });
+            const browser = createBrowserMock();
+            mocks.launch.mockResolvedValue(browser);
+            const collector = new CodeCollector({ headless: true, timeout: 1000 });
+            await collector.init();
+            const results = await Promise.all([
+                collector.collect({ url: 'https://a.com' }),
+                collector.collect({ url: 'https://b.com' }),
+            ]);
+            expect(results).toHaveLength(2);
+            expect(mocks.collectInnerImpl).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/dist/tests/modules/collector/CodeCollector.collectInternal.additional.test.d.ts

@@ -0,0 +1 @@
+export {};