@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/tests/modules/collector/CodeCache.test.js

@@ -0,0 +1,86 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { CodeCache } from '../../../src/modules/collector/CodeCache.js';
+const sampleResult = {
+    files: [
+        {
+            url: 'https://vmoranv.github.io/jshookmcp/app.js',
+            content: 'console.log("hello")',
+            size: 20,
+            type: 'external',
+        },
+    ],
+    dependencies: { nodes: [], edges: [] },
+    totalSize: 20,
+    collectTime: 5,
+};
+describe('CodeCache', () => {
+    let cacheDir;
+    beforeEach(async () => {
+        cacheDir = await mkdtemp(join(tmpdir(), 'jshook-cache-'));
+    });
+    afterEach(async () => {
+        await rm(cacheDir, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    it('initializes cache directory', async () => {
+        const cache = new CodeCache({ cacheDir });
+        await expect(cache.init()).resolves.toBeUndefined();
+    });
+    it('stores and retrieves values from cache', async () => {
+        const cache = new CodeCache({ cacheDir, maxAge: 60_000 });
+        await cache.set('https://vmoranv.github.io/jshookmcp', sampleResult);
+        const result = await cache.get('https://vmoranv.github.io/jshookmcp');
+        expect(result).not.toBeNull();
+        expect(result?.files[0]?.url).toBe('https://vmoranv.github.io/jshookmcp/app.js');
+        expect(result?.totalSize).toBe(20);
+    });
+    it('returns null for expired entries', async () => {
+        const cache = new CodeCache({ cacheDir, maxAge: 1 });
+        await cache.set('https://vmoranv.github.io/jshookmcp/expired', sampleResult);
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        const result = await cache.get('https://vmoranv.github.io/jshookmcp/expired');
+        expect(result).toBeNull();
+    });
+    it('cleanup removes oldest files when exceeding max size', async () => {
+        const cache = new CodeCache({ cacheDir, maxSize: 200, maxAge: 60_000 });
+        for (let i = 0; i < 6; i++) {
+            await cache.set(`https://vmoranv.github.io/jshookmcp/${i}`, {
+                ...sampleResult,
+                files: [
+                    {
+                        url: `https://vmoranv.github.io/jshookmcp/${i}.js`,
+                        content: 'x'.repeat(300),
+                        size: 300,
+                        type: 'external',
+                    },
+                ],
+                totalSize: 300,
+            });
+            await new Promise((resolve) => setTimeout(resolve, 2));
+        }
+        const before = await cache.getStats();
+        await cache.cleanup();
+        const after = await cache.getStats();
+        expect(before.diskEntries).toBeGreaterThan(0);
+        expect(after.diskEntries).toBeLessThan(before.diskEntries);
+    });
+    it('clear removes both memory and disk cache entries', async () => {
+        const cache = new CodeCache({ cacheDir, maxAge: 60_000 });
+        await cache.set('https://vmoranv.github.io/jshookmcp/a', sampleResult);
+        await cache.set('https://vmoranv.github.io/jshookmcp/b', sampleResult);
+        expect((await cache.getStats()).diskEntries).toBeGreaterThan(0);
+        await cache.clear();
+        const stats = await cache.getStats();
+        expect(stats.diskEntries).toBe(0);
+        expect(stats.memoryEntries).toBe(0);
+    });
+    it('warmup calls get for each provided URL', async () => {
+        const cache = new CodeCache({ cacheDir });
+        const getSpy = vi.spyOn(cache, 'get').mockResolvedValue(null);
+        await cache.warmup(['https://vmoranv.github.io/jshookmcp/one', 'https://vmoranv.github.io/jshookmcp/two']);
+        expect(getSpy).toHaveBeenCalledTimes(2);
+    });
+});

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

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

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

@@ -0,0 +1,128 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const launchMock = vi.hoisted(() => vi.fn());
+const connectMock = vi.hoisted(() => vi.fn());
+const findBrowserExecutableMock = vi.hoisted(() => vi.fn());
+vi.mock('rebrowser-puppeteer-core', () => ({
+    default: {
+        launch: launchMock,
+        connect: connectMock,
+    },
+}));
+vi.mock('@src/utils/browserExecutable', () => ({
+    findBrowserExecutable: findBrowserExecutableMock,
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+import { CodeCollector } from '../../../src/modules/collector/CodeCollector.js';
+function createBrowserMock() {
+    return {
+        on: vi.fn(),
+        pages: vi.fn().mockResolvedValue([]),
+        newPage: vi.fn(),
+        close: vi.fn().mockResolvedValue(undefined),
+        disconnect: vi.fn().mockResolvedValue(undefined),
+        version: vi.fn().mockResolvedValue('Chrome/123'),
+    };
+}
+describe('CodeCollector', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        findBrowserExecutableMock.mockReturnValue(undefined);
+    });
+    it('initializes browser and reports running status', async () => {
+        const browser = createBrowserMock();
+        launchMock.mockResolvedValue(browser);
+        const collector = new CodeCollector({ headless: true, timeout: 1000 });
+        await collector.init();
+        expect(launchMock).toHaveBeenCalledTimes(1);
+        await expect(collector.getStatus()).resolves.toMatchObject({
+            running: true,
+            pagesCount: 0,
+            effectiveHeadless: true,
+        });
+    });
+    it('throws when configured executablePath does not exist', async () => {
+        const collector = new CodeCollector({
+            headless: true,
+            timeout: 1000,
+            executablePath: 'C:\\definitely-not-existing\\browser.exe',
+        });
+        await expect(collector.init()).rejects.toThrow('Configured browser executable was not found');
+        expect(launchMock).not.toHaveBeenCalled();
+    });
+    it('does not auto-relaunch after an explicit close until init is called again', async () => {
+        const browser = createBrowserMock();
+        const relaunchedBrowser = createBrowserMock();
+        launchMock.mockResolvedValueOnce(browser).mockResolvedValueOnce(relaunchedBrowser);
+        const collector = new CodeCollector({ headless: true, timeout: 1000 });
+        await collector.init();
+        await collector.close();
+        await expect(collector.getActivePage()).rejects.toThrow('Browser was explicitly closed. Call browser_launch or browser_attach first.');
+        expect(launchMock).toHaveBeenCalledTimes(1);
+        await collector.init();
+        expect(launchMock).toHaveBeenCalledTimes(2);
+    });
+    it('filters URLs against wildcard rules', () => {
+        const collector = new CodeCollector({ headless: true, timeout: 1000 });
+        expect(collector.shouldCollectUrl('https://vmoranv.github.io/jshookmcp/app.js', ['*vmoranv.github.io/jshookmcp/*'])).toBe(true);
+        expect(collector.shouldCollectUrl('https://cdn.other.com/lib.js', ['*vmoranv.github.io/jshookmcp/*'])).toBe(false);
+    });
+    it('retries navigation until success', async () => {
+        const collector = new CodeCollector({ headless: true, timeout: 1000 });
+        const page = {
+            goto: vi
+                .fn()
+                .mockRejectedValueOnce(new Error('temporary'))
+                .mockResolvedValueOnce(undefined),
+        };
+        await expect(collector.navigateWithRetry(page, 'https://vmoranv.github.io/jshookmcp', { waitUntil: 'load' }, 3)).resolves.toBeUndefined();
+        expect(page.goto).toHaveBeenCalledTimes(2);
+    });
+    it('throws last navigation error after max retries', async () => {
+        const collector = new CodeCollector({ headless: true, timeout: 1000 });
+        const page = { goto: vi.fn().mockRejectedValue(new Error('fatal')) };
+        await expect(collector.navigateWithRetry(page, 'https://vmoranv.github.io/jshookmcp', { waitUntil: 'load' }, 2)).rejects.toThrow('fatal');
+        expect(page.goto).toHaveBeenCalledTimes(2);
+    });
+    it('returns pattern-matched files with size limits and truncation flag', () => {
+        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' }],
+            ['https://site/c.css', { url: 'https://site/c.css', content: 'c', size: 1, type: 'external' }],
+        ]);
+        const result = collector.getFilesByPattern('\\.js$', 3, 15);
+        expect(result.matched).toBe(2);
+        expect(result.returned).toBe(1);
+        expect(result.truncated).toBe(true);
+        expect(result.totalSize).toBe(10);
+    });
+    it('returns top priority files ordered by scoring helper', () => {
+        const collector = new CodeCollector({ headless: true, timeout: 1000 });
+        collector.collectedFilesCache = new Map([
+            [
+                'https://site/vendor.js',
+                { url: 'https://site/vendor.js', content: 'noop', size: 2000, type: 'external' },
+            ],
+            [
+                'https://site/crypto-api-main.js',
+                {
+                    url: 'https://site/crypto-api-main.js',
+                    content: 'fetch("/x"); const cipher = "aes";',
+                    size: 800,
+                    type: 'inline',
+                },
+            ],
+        ]);
+        const result = collector.getTopPriorityFiles(1, 100_000);
+        expect(result.files).toHaveLength(1);
+        expect(result.files[0]?.url).toContain('crypto-api-main.js');
+    });
+});

package/dist/tests/modules/collector/CodeCompressor.test.d.ts

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

package/dist/tests/modules/collector/CodeCompressor.test.js

@@ -0,0 +1,69 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+import { CodeCompressor } from '../../../src/modules/collector/CodeCompressor.js';
+describe('CodeCompressor', () => {
+    it('compresses and decompresses roundtrip content', async () => {
+        const compressor = new CodeCompressor();
+        const source = 'const x = 1;'.repeat(200);
+        const compressed = await compressor.compress(source);
+        const restored = await compressor.decompress(compressed.compressed);
+        expect(restored).toBe(source);
+        expect(compressed.originalSize).toBe(source.length);
+    });
+    it('uses cache on repeated compression with same input', async () => {
+        const compressor = new CodeCompressor();
+        const source = 'cache-me'.repeat(100);
+        await compressor.compress(source, { useCache: true });
+        await compressor.compress(source, { useCache: true });
+        const stats = compressor.getStats();
+        expect(stats.cacheMisses).toBeGreaterThanOrEqual(1);
+        expect(stats.cacheHits).toBeGreaterThanOrEqual(1);
+    });
+    it('falls back to base64 passthrough when batch item compression fails', async () => {
+        const compressor = new CodeCompressor();
+        const originalCompress = compressor.compress.bind(compressor);
+        vi.spyOn(compressor, 'compress').mockImplementation(async (code, options) => {
+            if (code.includes('bad-item')) {
+                throw new Error('forced failure');
+            }
+            return originalCompress(code, options);
+        });
+        const result = await compressor.compressBatch([
+            { url: 'good.js', content: 'good-content'.repeat(50) },
+            { url: 'bad.js', content: 'bad-item' },
+        ]);
+        const bad = result.find((item) => item.url === 'bad.js');
+        expect(bad).toBeDefined();
+        expect(bad?.compressionRatio).toBe(0);
+        expect(bad?.compressed).toBe(Buffer.from('bad-item').toString('base64'));
+    });
+    it('evaluates compression thresholds correctly', () => {
+        const compressor = new CodeCompressor();
+        expect(compressor.shouldCompress('x'.repeat(1025))).toBe(true);
+        expect(compressor.shouldCompress('x'.repeat(1000), 2000)).toBe(false);
+    });
+    it('selects compression levels by input size', () => {
+        const compressor = new CodeCompressor();
+        expect(compressor.selectCompressionLevel(5 * 1024)).toBe(1);
+        expect(compressor.selectCompressionLevel(50 * 1024)).toBe(6);
+        expect(compressor.selectCompressionLevel(300 * 1024)).toBe(9);
+        expect(compressor.selectCompressionLevel(2 * 1024 * 1024)).toBe(6);
+    });
+    it('stream-compresses large payload into multiple chunks', async () => {
+        const compressor = new CodeCompressor();
+        const onProgress = vi.fn();
+        const source = 'stream-payload-'.repeat(500);
+        const result = await compressor.compressStream(source, { chunkSize: 512, onProgress });
+        expect(result.chunks).toBeGreaterThan(1);
+        expect(result.originalSize).toBe(source.length);
+        expect(onProgress).toHaveBeenCalled();
+    });
+});

package/dist/tests/modules/collector/DOMInspector.test.d.ts

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

package/dist/tests/modules/collector/DOMInspector.test.js

@@ -0,0 +1,142 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+import { DOMInspector } from '../../../src/modules/collector/DOMInspector.js';
+describe('DOMInspector', () => {
+    let page;
+    let collector;
+    let inspector;
+    beforeEach(() => {
+        page = {
+            evaluate: vi.fn(),
+            waitForSelector: vi.fn(),
+            frames: vi.fn(() => [{}]),
+        };
+        collector = {
+            getActivePage: vi.fn().mockResolvedValue(page),
+        };
+        inspector = new DOMInspector(collector);
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('returns selector metadata when element exists', async () => {
+        page.evaluate.mockResolvedValue({
+            found: true,
+            nodeName: 'BUTTON',
+            textContent: 'Submit',
+            visible: true,
+        });
+        const result = await inspector.querySelector('#submit');
+        expect(result.found).toBe(true);
+        expect(result.nodeName).toBe('BUTTON');
+        expect(page.evaluate).toHaveBeenCalled();
+    });
+    it('returns found=false when querySelector evaluation fails', async () => {
+        page.evaluate.mockRejectedValue(new Error('eval failed'));
+        const result = await inspector.querySelector('.missing');
+        expect(result).toEqual({ found: false });
+    });
+    it('returns elements with diagnostics from querySelectorAll', async () => {
+        page.evaluate
+            .mockResolvedValueOnce('complete')
+            .mockResolvedValueOnce({
+            elements: [
+                { found: true, nodeName: 'DIV', textContent: 'A' },
+                { found: true, nodeName: 'DIV', textContent: 'B' },
+            ],
+            diagnostics: { readyState: 'complete', shadowRootCount: 0 },
+        });
+        const result = await inspector.querySelectorAll('.item', 2);
+        expect(result.elements).toHaveLength(2);
+        expect(result.elements[1]?.textContent).toBe('B');
+        expect(result.diagnostics).toMatchObject({
+            readyState: 'complete',
+            frameCount: 1,
+            shadowRootCount: 0,
+            retried: false,
+            waitedForReadyState: false,
+        });
+    });
+    it('waits for document readyState before querying', async () => {
+        vi.useFakeTimers();
+        page.evaluate
+            .mockResolvedValueOnce('loading')
+            .mockResolvedValueOnce('interactive')
+            .mockResolvedValueOnce('complete')
+            .mockResolvedValueOnce({
+            elements: [{ found: true, nodeName: 'INPUT', textContent: '' }],
+            diagnostics: { readyState: 'complete', shadowRootCount: 0 },
+        });
+        const resultPromise = inspector.querySelectorAll('input', 5);
+        await vi.advanceTimersByTimeAsync(300);
+        const result = await resultPromise;
+        expect(result.elements).toHaveLength(1);
+        expect(result.diagnostics.waitedForReadyState).toBe(true);
+        expect(page.evaluate).toHaveBeenCalledTimes(4);
+    });
+    it('retries once when querySelectorAll is empty after hydration', async () => {
+        vi.useFakeTimers();
+        page.evaluate
+            .mockResolvedValueOnce('complete')
+            .mockResolvedValueOnce({
+            elements: [],
+            diagnostics: { readyState: 'complete', shadowRootCount: 0 },
+        })
+            .mockResolvedValueOnce({
+            elements: [{ found: true, nodeName: 'INPUT', textContent: 'email' }],
+            diagnostics: { readyState: 'complete', shadowRootCount: 1 },
+        });
+        const resultPromise = inspector.querySelectorAll('input', 5);
+        await vi.advanceTimersByTimeAsync(500);
+        const result = await resultPromise;
+        expect(result.elements).toHaveLength(1);
+        expect(result.diagnostics.retried).toBe(true);
+        expect(result.diagnostics.shadowRootCount).toBe(1);
+    });
+    it('returns clickable elements with shadow DOM diagnostics', async () => {
+        page.evaluate
+            .mockResolvedValueOnce('complete')
+            .mockResolvedValueOnce({
+            elements: [
+                {
+                    selector: '#submit',
+                    text: 'Submit',
+                    type: 'button',
+                    visible: true,
+                },
+            ],
+            diagnostics: { readyState: 'complete', shadowRootCount: 2 },
+        });
+        const result = await inspector.findClickable('submit');
+        expect(result.elements).toHaveLength(1);
+        expect(result.elements[0]?.selector).toBe('#submit');
+        expect(result.diagnostics).toMatchObject({
+            readyState: 'complete',
+            shadowRootCount: 2,
+            retried: false,
+        });
+    });
+    it('waitForElement returns null on timeout error', async () => {
+        page.waitForSelector.mockRejectedValue(new Error('timeout'));
+        const result = await inspector.waitForElement('#slow', 5);
+        expect(result).toBeNull();
+    });
+    it('returns null when computed style query throws', async () => {
+        page.evaluate.mockRejectedValue(new Error('style error'));
+        await expect(inspector.getComputedStyle('.btn')).resolves.toBeNull();
+    });
+    it('closes and detaches cdp session when present', async () => {
+        const detach = vi.fn().mockResolvedValue(undefined);
+        inspector.cdpSession = { detach };
+        await inspector.close();
+        expect(detach).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/tests/modules/collector/PageController.test.d.ts

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

package/dist/tests/modules/collector/PageController.test.js

@@ -0,0 +1,73 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+import { PageController } from '../../../src/modules/collector/PageController.js';
+describe('PageController', () => {
+    let page;
+    let collector;
+    let controller;
+    beforeEach(() => {
+        page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            title: vi.fn().mockResolvedValue('Demo'),
+            url: vi.fn().mockReturnValue('https://vmoranv.github.io/jshookmcp/final'),
+            click: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn(),
+            waitForSelector: vi.fn().mockResolvedValue(undefined),
+            setViewport: vi.fn().mockResolvedValue(undefined),
+            setUserAgent: vi.fn().mockResolvedValue(undefined),
+            $: vi.fn(),
+        };
+        collector = { getActivePage: vi.fn().mockResolvedValue(page) };
+        controller = new PageController(collector);
+    });
+    it('navigates with defaults and returns page metadata', async () => {
+        const result = await controller.navigate('https://vmoranv.github.io/jshookmcp');
+        expect(page.goto).toHaveBeenCalledWith('https://vmoranv.github.io/jshookmcp', {
+            waitUntil: 'networkidle2',
+            timeout: 30000,
+        });
+        expect(result.url).toBe('https://vmoranv.github.io/jshookmcp/final');
+        expect(result.title).toBe('Demo');
+    });
+    it('click uses default click options', async () => {
+        await controller.click('#submit');
+        expect(page.click).toHaveBeenCalledWith('#submit', {
+            button: 'left',
+            clickCount: 1,
+            delay: undefined,
+        });
+    });
+    it('waitForSelector returns success payload when element appears', async () => {
+        page.evaluate.mockResolvedValue({ tagName: 'button', id: 'submit' });
+        const result = await controller.waitForSelector('#submit', 1000);
+        expect(result.success).toBe(true);
+        expect(result.element?.id).toBe('submit');
+    });
+    it('waitForSelector returns failure payload on timeout', async () => {
+        page.waitForSelector.mockRejectedValue(new Error('timeout'));
+        const result = await controller.waitForSelector('#missing', 10);
+        expect(result.success).toBe(false);
+        expect(result.message).toContain('Timeout waiting for selector');
+    });
+    it('emulateDevice resolves aliases and applies device settings', async () => {
+        const resolved = await controller.emulateDevice('iPhone 13 Pro');
+        expect(resolved).toBe('iPhone');
+        expect(page.setViewport).toHaveBeenCalled();
+        expect(page.setUserAgent).toHaveBeenCalled();
+    });
+    it('emulateDevice rejects unsupported device names', async () => {
+        await expect(controller.emulateDevice('BlackBerry Classic')).rejects.toThrow('Unsupported device');
+    });
+    it('uploadFile throws when file input element is missing', async () => {
+        page.$.mockResolvedValue(null);
+        await expect(controller.uploadFile('#upload', 'D:/tmp/a.txt')).rejects.toThrow('File input not found');
+    });
+});

package/dist/tests/modules/collector/PageScriptCollectors.test.d.ts

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

package/dist/tests/modules/collector/PageScriptCollectors.test.js

@@ -0,0 +1,87 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+import { analyzeDependencies, calculatePriorityScore, collectInlineScripts, collectServiceWorkers, collectWebWorkers, extractDependencies, } from '../../../src/modules/collector/PageScriptCollectors.js';
+describe('PageScriptCollectors', () => {
+    it('extractDependencies parses import/require/dynamic import uniquely', () => {
+        const code = `
+      import x from './a';
+      const y = require("./b");
+      const z = import('./a');
+    `;
+        const deps = extractDependencies(code);
+        expect(deps.sort()).toEqual(['./a', './b']);
+    });
+    it('analyzeDependencies builds nodes and import edges', () => {
+        const files = [
+            { url: 'https://site/a.js', content: `import b from "b";`, type: 'external', size: 10 },
+            { url: 'https://site/b.js', content: 'export default 1', type: 'external', size: 10 },
+        ];
+        const graph = analyzeDependencies(files);
+        expect(graph.nodes).toHaveLength(2);
+        expect(graph.edges).toEqual([
+            { from: 'https://site/a.js', to: 'https://site/b.js', type: 'import' },
+        ]);
+    });
+    it('calculatePriorityScore rewards meaningful urls and penalizes vendor bundles', () => {
+        const high = calculatePriorityScore({
+            url: 'https://x/main-crypto-api.js',
+            type: 'inline',
+            size: 5000,
+            content: '',
+        });
+        const low = calculatePriorityScore({
+            url: 'https://x/vendor/ui-framework.bundle.js',
+            type: 'external',
+            size: 400000,
+            content: '',
+        });
+        expect(high).toBeGreaterThan(low);
+    });
+    it('collectInlineScripts applies max file cap and preserves metadata', async () => {
+        const page = {
+            evaluate: vi.fn().mockResolvedValue([
+                { url: 'inline-script-0', content: 'a', size: 1, type: 'inline', metadata: { truncated: false } },
+                { url: 'inline-script-1', content: 'b', size: 1, type: 'inline', metadata: { truncated: true } },
+                { url: 'inline-script-2', content: 'c', size: 1, type: 'inline', metadata: { truncated: false } },
+            ]),
+        };
+        const result = await collectInlineScripts(page, 10, 2);
+        expect(result).toHaveLength(2);
+        expect(result[1]?.metadata?.truncated).toBe(true);
+    });
+    it('collectServiceWorkers gathers successful worker scripts and skips failed ones', async () => {
+        const page = {
+            evaluate: vi
+                .fn()
+                .mockResolvedValueOnce([
+                { url: 'https://site/sw-1.js', scope: '/', state: 'activated' },
+                { url: 'https://site/sw-2.js', scope: '/', state: 'activated' },
+            ])
+                .mockResolvedValueOnce('self.addEventListener("fetch",()=>{})')
+                .mockRejectedValueOnce(new Error('fetch failed')),
+        };
+        const files = await collectServiceWorkers(page);
+        expect(files).toHaveLength(1);
+        expect(files[0]?.type).toBe('service-worker');
+        expect(files[0]?.url).toContain('sw-1.js');
+    });
+    it('collectWebWorkers resolves relative URLs against current page URL', async () => {
+        const page = {
+            evaluateOnNewDocument: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValueOnce(['/worker.js']).mockResolvedValueOnce('onmessage=()=>{}'),
+            url: vi.fn().mockReturnValue('https://site/app/index.html'),
+        };
+        const files = await collectWebWorkers(page);
+        expect(files).toHaveLength(1);
+        expect(files[0]?.url).toBe('https://site/worker.js');
+        expect(files[0]?.type).toBe('web-worker');
+    });
+});

package/dist/tests/modules/collector/SmartCodeCollector.test.d.ts

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