@jshookmcp/jshook 0.2.1 → 0.2.2

package/dist/tests/modules/monitor/NetworkMonitor.impl.test.js

@@ -1,66 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const loggerState = vi.hoisted(() => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-}));
-vi.mock('@utils/logger', () => ({
-    logger: loggerState,
-}));
-import { NetworkMonitor } from '../../../src/modules/monitor/NetworkMonitor.impl.js';
-function createMockSession() {
-    const listeners = new Map();
-    const send = vi.fn(async (..._args) => ({}));
-    const on = vi.fn((event, handler) => {
-        const group = listeners.get(event) ?? new Set();
-        group.add(handler);
-        listeners.set(event, group);
-    });
-    const off = vi.fn((event, handler) => {
-        listeners.get(event)?.delete(handler);
-    });
-    const emit = (event, payload) => {
-        listeners.get(event)?.forEach((handler) => handler(payload));
-    };
-    return {
-        session: { send, on, off },
-        send,
-        emit,
-    };
-}
-describe('NetworkMonitor impl', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('captures request and response activity through the internal implementation path', async () => {
-        const { session, emit } = createMockSession();
-        const monitor = new NetworkMonitor(session);
-        await monitor.enable();
-        emit('Network.requestWillBeSent', {
-            requestId: 'req-1',
-            request: { url: 'https://example.com/api', method: 'GET', headers: {} },
-            timestamp: 1,
-            type: 'XHR',
-            initiator: {},
-        });
-        emit('Network.responseReceived', {
-            requestId: 'req-1',
-            response: {
-                url: 'https://example.com/api',
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                mimeType: 'application/json',
-                fromDiskCache: false,
-                fromServiceWorker: false,
-                timing: {},
-            },
-            timestamp: 2,
-        });
-        expect(monitor.isEnabled()).toBe(true);
-        expect(monitor.getRequests()).toHaveLength(1);
-        expect(monitor.getResponses()).toHaveLength(1);
-        expect(monitor.getActivity('req-1').response?.status).toBe(200);
-    });
-});

package/dist/tests/modules/monitor/NetworkMonitor.interceptors.test.d.ts

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

package/dist/tests/modules/monitor/NetworkMonitor.interceptors.test.js

@@ -1,24 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildFetchInterceptorCode, buildXHRInterceptorCode, CLEAR_INJECTED_BUFFERS_EXPRESSION, RESET_INJECTED_INTERCEPTORS_EXPRESSION, } from '../../../src/modules/monitor/NetworkMonitor.interceptors.js';
-describe('NetworkMonitor interceptors', () => {
-    it('builds XHR interceptor code with buffer limits and request capture hooks', () => {
-        const code = buildXHRInterceptorCode(25);
-        expect(code).toContain('window.__xhrInterceptorInstalled');
-        expect(code).toContain('window.XMLHttpRequest = function()');
-        expect(code).toContain('xhrRequests.length > 25');
-        expect(code).toContain('window.__getXHRRequests = function()');
-    });
-    it('builds fetch interceptor code with localStorage persistence and limit enforcement', () => {
-        const code = buildFetchInterceptorCode(10);
-        expect(code).toContain('window.__fetchInterceptorInstalled');
-        expect(code).toContain('fetchRequests.length > 10');
-        expect(code).toContain("localStorage.setItem('__capturedAPIs'");
-        expect(code).toContain('window.__getFetchRequests = function()');
-    });
-    it('exports expressions for clearing buffers and restoring original interceptors', () => {
-        expect(CLEAR_INJECTED_BUFFERS_EXPRESSION).toContain('xhrCleared');
-        expect(CLEAR_INJECTED_BUFFERS_EXPRESSION).toContain('fetchCleared');
-        expect(RESET_INJECTED_INTERCEPTORS_EXPRESSION).toContain('window.XMLHttpRequest = window.__originalXMLHttpRequestForHook');
-        expect(RESET_INJECTED_INTERCEPTORS_EXPRESSION).toContain('window.fetch = window.__originalFetchForHook');
-    });
-});

package/dist/tests/modules/monitor/NetworkMonitor.test.d.ts

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

package/dist/tests/modules/monitor/NetworkMonitor.test.js

@@ -1,301 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const loggerState = vi.hoisted(() => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: loggerState,
-}));
-import { NetworkMonitor } from '../../../src/modules/monitor/NetworkMonitor.js';
-function createMockSession() {
-    const listeners = new Map();
-    const send = vi.fn(async (..._args) => ({}));
-    const on = vi.fn((event, handler) => {
-        const group = listeners.get(event) ?? new Set();
-        group.add(handler);
-        listeners.set(event, group);
-    });
-    const off = vi.fn((event, handler) => {
-        listeners.get(event)?.delete(handler);
-    });
-    const emit = (event, payload) => {
-        listeners.get(event)?.forEach((handler) => handler(payload));
-    };
-    return {
-        session: { send, on, off },
-        send,
-        emit,
-    };
-}
-describe('NetworkMonitor', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        loggerState.debug.mockReset();
-        loggerState.info.mockReset();
-        loggerState.warn.mockReset();
-        loggerState.error.mockReset();
-    });
-    it('enables monitoring and captures request/response activity', async () => {
-        const { session, emit } = createMockSession();
-        const monitor = new NetworkMonitor(session);
-        await monitor.enable();
-        emit('Network.requestWillBeSent', {
-            requestId: 'req-1',
-            request: { url: 'https://vmoranv.github.io/jshookmcp/api/users', method: 'GET', headers: {}, postData: '' },
-            timestamp: 1,
-            type: 'XHR',
-            initiator: { type: 'script' },
-        });
-        emit('Network.responseReceived', {
-            requestId: 'req-1',
-            response: {
-                url: 'https://vmoranv.github.io/jshookmcp/api/users',
-                status: 200,
-                statusText: 'OK',
-                headers: { 'content-type': 'application/json' },
-                mimeType: 'application/json',
-                fromDiskCache: false,
-                fromServiceWorker: false,
-                timing: { requestTime: 1 },
-            },
-            timestamp: 2,
-        });
-        expect(monitor.isEnabled()).toBe(true);
-        expect(monitor.getRequests()).toHaveLength(1);
-        expect(monitor.getResponses()).toHaveLength(1);
-        expect(monitor.getActivity('req-1').response?.status).toBe(200);
-        expect(monitor.getStats().byMethod.GET).toBe(1);
-    });
-    it('returns null response body when monitor is disabled or request is incomplete', async () => {
-        const { session, emit } = createMockSession();
-        const monitor = new NetworkMonitor(session);
-        await expect(monitor.getResponseBody('req-missing')).resolves.toBeNull();
-        await monitor.enable();
-        await expect(monitor.getResponseBody('req-missing')).resolves.toBeNull();
-        emit('Network.requestWillBeSent', {
-            requestId: 'req-pending',
-            request: { url: 'https://vmoranv.github.io/jshookmcp/api/pending', method: 'GET', headers: {} },
-            timestamp: 1,
-            type: 'XHR',
-            initiator: {},
-        });
-        await expect(monitor.getResponseBody('req-pending')).resolves.toBeNull();
-    });
-    it('retrieves response body successfully and handles CDP body errors gracefully', async () => {
-        const { session, send, emit } = createMockSession();
-        send.mockImplementation(async (method, params) => {
-            if (method === 'Network.enable')
-                return {};
-            if (method === 'Network.getResponseBody' && params?.requestId === 'req-ok') {
-                return { body: 'payload', base64Encoded: false };
-            }
-            if (method === 'Network.getResponseBody' && params?.requestId === 'req-fail') {
-                throw new Error('Body unavailable');
-            }
-            return {};
-        });
-        const monitor = new NetworkMonitor(session);
-        await monitor.enable();
-        emit('Network.requestWillBeSent', {
-            requestId: 'req-ok',
-            request: { url: 'https://vmoranv.github.io/jshookmcp/api/ok', method: 'GET', headers: {} },
-            timestamp: 1,
-            type: 'XHR',
-            initiator: {},
-        });
-        emit('Network.responseReceived', {
-            requestId: 'req-ok',
-            response: {
-                url: 'https://vmoranv.github.io/jshookmcp/api/ok',
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                mimeType: 'application/json',
-                fromDiskCache: false,
-                fromServiceWorker: false,
-                timing: {},
-            },
-            timestamp: 2,
-        });
-        emit('Network.requestWillBeSent', {
-            requestId: 'req-fail',
-            request: { url: 'https://vmoranv.github.io/jshookmcp/api/fail', method: 'GET', headers: {} },
-            timestamp: 3,
-            type: 'XHR',
-            initiator: {},
-        });
-        emit('Network.responseReceived', {
-            requestId: 'req-fail',
-            response: {
-                url: 'https://vmoranv.github.io/jshookmcp/api/fail',
-                status: 500,
-                statusText: 'FAIL',
-                headers: {},
-                mimeType: 'application/json',
-                fromDiskCache: false,
-                fromServiceWorker: false,
-                timing: {},
-            },
-            timestamp: 4,
-        });
-        await expect(monitor.getResponseBody('req-ok')).resolves.toEqual({
-            body: 'payload',
-            base64Encoded: false,
-        });
-        await expect(monitor.getResponseBody('req-fail')).resolves.toBeNull();
-    });
-    it('collects JavaScript responses and decodes base64 content', async () => {
-        const { session, send, emit } = createMockSession();
-        send.mockImplementation(async (method, params) => {
-            if (method === 'Network.enable')
-                return {};
-            if (method === 'Network.getResponseBody' && params?.requestId === 'js-a') {
-                return {
-                    body: Buffer.from('console.log("A")').toString('base64'),
-                    base64Encoded: true,
-                };
-            }
-            if (method === 'Network.getResponseBody' && params?.requestId === 'js-b') {
-                return {
-                    body: 'console.log("B")',
-                    base64Encoded: false,
-                };
-            }
-            return {};
-        });
-        const monitor = new NetworkMonitor(session);
-        await monitor.enable();
-        emit('Network.requestWillBeSent', {
-            requestId: 'js-a',
-            request: { url: 'https://vmoranv.github.io/jshookmcp/cdn/app.js', method: 'GET', headers: {} },
-            timestamp: 1,
-            type: 'Script',
-            initiator: {},
-        });
-        emit('Network.responseReceived', {
-            requestId: 'js-a',
-            response: {
-                url: 'https://vmoranv.github.io/jshookmcp/cdn/app.js',
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                mimeType: 'application/javascript',
-                fromDiskCache: false,
-                fromServiceWorker: false,
-                timing: {},
-            },
-            timestamp: 2,
-        });
-        emit('Network.requestWillBeSent', {
-            requestId: 'js-b',
-            request: { url: 'https://vmoranv.github.io/jshookmcp/cdn/chunk.js?v=1', method: 'GET', headers: {} },
-            timestamp: 3,
-            type: 'Script',
-            initiator: {},
-        });
-        emit('Network.responseReceived', {
-            requestId: 'js-b',
-            response: {
-                url: 'https://vmoranv.github.io/jshookmcp/cdn/chunk.js?v=1',
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                mimeType: 'text/plain',
-                fromDiskCache: false,
-                fromServiceWorker: false,
-                timing: {},
-            },
-            timestamp: 4,
-        });
-        const jsResponses = await monitor.getAllJavaScriptResponses();
-        expect(jsResponses).toHaveLength(2);
-        expect(jsResponses[0].content).toContain('console.log("A")');
-        expect(jsResponses[1].content).toContain('console.log("B")');
-    });
-    it('fetches JavaScript response bodies concurrently in batches', async () => {
-        const pendingResolvers = new Map();
-        const { session, send, emit } = createMockSession();
-        send.mockImplementation((method, params) => {
-            if (method === 'Network.enable')
-                return Promise.resolve({});
-            if (method === 'Network.getResponseBody' && params?.requestId) {
-                return new Promise((resolve) => {
-                    pendingResolvers.set(params.requestId, () => resolve({
-                        body: `console.log("${params.requestId}")`,
-                        base64Encoded: false,
-                    }));
-                });
-            }
-            return Promise.resolve({});
-        });
-        const monitor = new NetworkMonitor(session);
-        await monitor.enable();
-        for (const requestId of ['js-a', 'js-b']) {
-            emit('Network.requestWillBeSent', {
-                requestId,
-                request: { url: `https://vmoranv.github.io/jshookmcp/cdn/${requestId}.js`, method: 'GET', headers: {} },
-                timestamp: 1,
-                type: 'Script',
-                initiator: {},
-            });
-            emit('Network.responseReceived', {
-                requestId,
-                response: {
-                    url: `https://vmoranv.github.io/jshookmcp/cdn/${requestId}.js`,
-                    status: 200,
-                    statusText: 'OK',
-                    headers: {},
-                    mimeType: 'application/javascript',
-                    fromDiskCache: false,
-                    fromServiceWorker: false,
-                    timing: {},
-                },
-                timestamp: 2,
-            });
-        }
-        const responsesPromise = monitor.getAllJavaScriptResponses();
-        await Promise.resolve();
-        expect(send.mock.calls.filter(([method]) => method === 'Network.getResponseBody')).toHaveLength(2);
-        pendingResolvers.get('js-a')?.();
-        pendingResolvers.get('js-b')?.();
-        const responses = await responsesPromise;
-        expect(responses).toHaveLength(2);
-    });
-    it('clears and resets injected interceptor buffers with robust fallbacks', async () => {
-        const { session, send } = createMockSession();
-        send
-            .mockResolvedValueOnce({
-            result: {
-                value: {
-                    xhrCleared: 3,
-                    fetchCleared: 5,
-                },
-            },
-        })
-            .mockResolvedValueOnce({
-            result: {
-                value: {
-                    xhrReset: true,
-                    fetchReset: true,
-                },
-            },
-        });
-        const monitor = new NetworkMonitor(session);
-        const cleared = await monitor.clearInjectedBuffers();
-        const reset = await monitor.resetInjectedInterceptors();
-        expect(cleared).toEqual({ xhrCleared: 3, fetchCleared: 5 });
-        expect(reset).toEqual({ xhrReset: true, fetchReset: true });
-        send.mockRejectedValueOnce(new Error('runtime failed'));
-        send.mockRejectedValueOnce(new Error('runtime failed'));
-        await expect(monitor.clearInjectedBuffers()).resolves.toEqual({
-            xhrCleared: 0,
-            fetchCleared: 0,
-        });
-        await expect(monitor.resetInjectedInterceptors()).resolves.toEqual({
-            xhrReset: false,
-            fetchReset: false,
-        });
-    });
-});

package/dist/tests/modules/monitor/NetworkMonitor.types.test.d.ts

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

package/dist/tests/modules/monitor/NetworkMonitor.types.test.js

@@ -1,69 +0,0 @@
-import { describe, expect, it } from 'vitest';
-describe('NetworkMonitor.types.ts', () => {
-    it('defines NetworkRequest with required fields', () => {
-        const request = {
-            requestId: 'req-1',
-            url: 'https://example.com/api',
-            method: 'GET',
-            headers: { 'content-type': 'application/json' },
-            timestamp: Date.now(),
-        };
-        expect(request.requestId).toBe('req-1');
-        expect(request.url).toBe('https://example.com/api');
-        expect(request.method).toBe('GET');
-        expect(request.headers).toEqual({ 'content-type': 'application/json' });
-        expect(typeof request.timestamp).toBe('number');
-    });
-    it('defines NetworkRequest with optional fields', () => {
-        const request = {
-            requestId: 'req-2',
-            url: 'https://example.com/submit',
-            method: 'POST',
-            headers: {},
-            postData: '{"key":"value"}',
-            timestamp: 1000,
-            type: 'XHR',
-            initiator: { type: 'script' },
-        };
-        expect(request.postData).toBe('{"key":"value"}');
-        expect(request.type).toBe('XHR');
-        expect(request.initiator).toEqual({ type: 'script' });
-    });
-    it('defines NetworkResponse with required fields', () => {
-        const response = {
-            requestId: 'req-1',
-            url: 'https://example.com/api',
-            status: 200,
-            statusText: 'OK',
-            headers: { 'content-type': 'application/json' },
-            mimeType: 'application/json',
-            timestamp: Date.now(),
-        };
-        expect(response.requestId).toBe('req-1');
-        expect(response.status).toBe(200);
-        expect(response.statusText).toBe('OK');
-        expect(response.mimeType).toBe('application/json');
-        expect(typeof response.timestamp).toBe('number');
-    });
-    it('defines NetworkResponse with optional fields', () => {
-        const response = {
-            requestId: 'req-3',
-            url: 'https://example.com/cached',
-            status: 304,
-            statusText: 'Not Modified',
-            headers: {},
-            mimeType: 'text/html',
-            timestamp: 2000,
-            fromCache: true,
-            timing: { requestTime: 100 },
-        };
-        expect(response.fromCache).toBe(true);
-        expect(response.timing).toEqual({ requestTime: 100 });
-    });
-    it('treats NetworkInitiator and NetworkTiming as opaque unknown types', () => {
-        const initiator = { type: 'parser', url: 'https://example.com' };
-        const timing = { requestTime: 1, proxyStart: -1 };
-        expect(initiator).toBeDefined();
-        expect(timing).toBeDefined();
-    });
-});

package/dist/tests/modules/monitor/PerformanceMonitor.test.d.ts

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

package/dist/tests/modules/monitor/PerformanceMonitor.test.js

@@ -1,204 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const loggerState = vi.hoisted(() => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    success: vi.fn(),
-}));
-const writeState = vi.hoisted(() => ({
-    writeFile: vi.fn(async () => undefined),
-}));
-const cdpState = vi.hoisted(() => ({
-    cdpLimit: vi.fn(async (fn) => fn()),
-}));
-const artifactState = vi.hoisted(() => ({
-    resolveArtifactPath: vi.fn(async () => ({
-        absolutePath: '/tmp/artifact.json',
-        displayPath: 'tmp/artifact.json',
-    })),
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: loggerState,
-}));
-vi.mock('node:fs/promises', () => ({
-    writeFile: writeState.writeFile,
-}));
-vi.mock('@src/utils/concurrency', () => ({
-    cdpLimit: cdpState.cdpLimit,
-}));
-vi.mock('@src/utils/artifacts', () => ({
-    resolveArtifactPath: artifactState.resolveArtifactPath,
-}));
-import { PerformanceMonitor } from '../../../src/modules/monitor/PerformanceMonitor.js';
-function createSession(sendImpl) {
-    const listeners = new Map();
-    const emit = (event, payload) => {
-        listeners.get(event)?.forEach((handler) => handler(payload));
-    };
-    const send = vi.fn(async (method, params) => {
-        if (sendImpl)
-            return sendImpl(method, params, emit);
-        return {};
-    });
-    const on = vi.fn((event, handler) => {
-        const set = listeners.get(event) ?? new Set();
-        set.add(handler);
-        listeners.set(event, set);
-    });
-    const off = vi.fn((event, handler) => {
-        listeners.get(event)?.delete(handler);
-    });
-    const detach = vi.fn(async () => { });
-    return { session: { send, on, off, detach }, send, on, off, detach, emit };
-}
-function createCollector(session, evaluateResult) {
-    const page = {
-        createCDPSession: vi.fn(async () => session),
-        evaluate: vi.fn(async () => evaluateResult ?? {}),
-        coverage: {
-            startJSCoverage: vi.fn(async () => undefined),
-            stopJSCoverage: vi.fn(async () => [
-                {
-                    url: 'a.js',
-                    text: '01234567890123456789',
-                    ranges: [{ start: 0, end: 10 }],
-                },
-            ]),
-            startCSSCoverage: vi.fn(async () => undefined),
-            stopCSSCoverage: vi.fn(async () => []),
-        },
-        tracing: {
-            start: vi.fn(async () => undefined),
-            stop: vi.fn(async () => Buffer.from('')),
-        },
-    };
-    return { collector: { getActivePage: vi.fn(async () => page) }, page };
-}
-describe('PerformanceMonitor', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        Object.values(loggerState).forEach((fn) => fn.mockReset?.());
-        writeState.writeFile.mockReset();
-        cdpState.cdpLimit.mockImplementation(async (fn) => fn());
-        artifactState.resolveArtifactPath.mockResolvedValue({
-            absolutePath: '/tmp/artifact.json',
-            displayPath: 'tmp/artifact.json',
-        });
-    });
-    it('collects page performance metrics via page.evaluate', async () => {
-        const { session } = createSession();
-        const metrics = { fcp: 111, lcp: 222, cls: 0.01, ttfb: 45 };
-        const { collector, page } = createCollector(session, metrics);
-        const monitor = new PerformanceMonitor(collector);
-        const result = await monitor.getPerformanceMetrics();
-        expect(page.evaluate).toHaveBeenCalledTimes(1);
-        expect(result).toMatchObject(metrics);
-    });
-    it('starts and stops precise coverage with computed percentages', async () => {
-        const { session } = createSession();
-        const { collector, page } = createCollector(session);
-        page.coverage.stopJSCoverage.mockResolvedValue([
-            {
-                url: 'a.js',
-                text: '01234567890123456789',
-                ranges: [{ start: 0, end: 10 }],
-            },
-        ]);
-        page.coverage.stopCSSCoverage.mockResolvedValue([]);
-        const monitor = new PerformanceMonitor(collector);
-        await monitor.startCoverage();
-        const coverage = await monitor.stopCoverage();
-        expect(page.coverage.startJSCoverage).toHaveBeenCalledWith({
-            resetOnNavigation: undefined,
-            reportAnonymousScripts: undefined,
-        });
-        expect(page.coverage.startCSSCoverage).toHaveBeenCalledWith({
-            resetOnNavigation: undefined,
-        });
-        expect(coverage[0].coveragePercentage).toBe(50);
-    });
-    it('throws when stopCoverage is called before startCoverage', async () => {
-        const { session } = createSession();
-        const { collector } = createCollector(session);
-        const monitor = new PerformanceMonitor(collector);
-        await expect(monitor.stopCoverage()).rejects.toThrow('Coverage not enabled');
-    });
-    it('starts and stops CPU profiling', async () => {
-        const profile = { nodes: [{ id: 1, callFrame: { functionName: 'fn', url: '', lineNumber: 0, columnNumber: 0 } }], startTime: 1, endTime: 2 };
-        const { session, send } = createSession((method) => {
-            if (method === 'Profiler.stop')
-                return { profile };
-            return {};
-        });
-        const { collector } = createCollector(session);
-        const monitor = new PerformanceMonitor(collector);
-        await monitor.startCPUProfiling();
-        const result = await monitor.stopCPUProfiling();
-        expect(send).toHaveBeenCalledWith('Profiler.start');
-        expect(result).toEqual(profile);
-    });
-    it('captures heap snapshot chunks and detaches listener', async () => {
-        const { session, on, off } = createSession((method, _params, emit) => {
-            if (method === 'HeapProfiler.takeHeapSnapshot') {
-                emit('HeapProfiler.addHeapSnapshotChunk', { chunk: 'partA' });
-                emit('HeapProfiler.addHeapSnapshotChunk', { chunk: 'partB' });
-            }
-            return {};
-        });
-        const { collector } = createCollector(session);
-        const monitor = new PerformanceMonitor(collector);
-        const snapshot = await monitor.takeHeapSnapshot();
-        expect(snapshot).toBe('partApartB');
-        expect(on).toHaveBeenCalledWith('HeapProfiler.addHeapSnapshotChunk', expect.any(Function));
-        expect(off).toHaveBeenCalledWith('HeapProfiler.addHeapSnapshotChunk', expect.any(Function));
-    });
-    it('stops tracing, reads stream and saves artifact', async () => {
-        const { session } = createSession();
-        const { collector, page } = createCollector(session);
-        page.tracing.stop.mockResolvedValue(Buffer.from('{"traceEvents":[{"ph":"X"}]}'));
-        const monitor = new PerformanceMonitor(collector);
-        await monitor.startTracing();
-        const result = await monitor.stopTracing({ artifactPath: '/tmp/custom-trace.json' });
-        expect(page.tracing.start).toHaveBeenCalledWith(expect.objectContaining({
-            categories: expect.any(Array),
-        }));
-        expect(writeState.writeFile).toHaveBeenCalledWith('/tmp/custom-trace.json', expect.any(String), 'utf-8');
-        expect(result.eventCount).toBe(1);
-    });
-    it('counts trace events without parsing the full trace payload', async () => {
-        const parseSpy = vi.spyOn(JSON, 'parse');
-        const { session } = createSession();
-        const { collector, page } = createCollector(session);
-        page.tracing.stop.mockResolvedValue(Buffer.from('{"traceEvents":[{"ph":"B"},{"ph":"E"}]}'));
-        const monitor = new PerformanceMonitor(collector);
-        await monitor.startTracing();
-        const result = await monitor.stopTracing({ artifactPath: '/tmp/compact-trace.json' });
-        expect(result.eventCount).toBe(2);
-        expect(parseSpy).not.toHaveBeenCalled();
-    });
-    it('collects heap sampling profile and returns top allocations', async () => {
-        const profile = {
-            head: {
-                callFrame: { functionName: 'root', url: '', lineNumber: 0, columnNumber: 0 },
-                selfSize: 0,
-                children: [
-                    { callFrame: { functionName: 'heavy', url: 'a.js', lineNumber: 1, columnNumber: 1 }, selfSize: 500 },
-                    { callFrame: { functionName: 'light', url: 'b.js', lineNumber: 1, columnNumber: 1 }, selfSize: 50 },
-                ],
-            },
-        };
-        const { session } = createSession((method) => {
-            if (method === 'HeapProfiler.stopSampling')
-                return { profile };
-            return {};
-        });
-        const { collector } = createCollector(session);
-        const monitor = new PerformanceMonitor(collector);
-        await monitor.startHeapSampling({ samplingInterval: 1024 });
-        const result = await monitor.stopHeapSampling({ artifactPath: '/tmp/heap.json', topN: 1 });
-        expect(result.topAllocations).toHaveLength(1);
-        expect(result.topAllocations[0].functionName).toBe('heavy');
-        expect(writeState.writeFile).toHaveBeenCalledWith('/tmp/heap.json', expect.any(String), 'utf-8');
-    });
-});

package/dist/tests/modules/monitor/PlaywrightNetworkMonitor.test.d.ts

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