@jshookmcp/jshook 0.2.1 → 0.2.2

package/dist/tests/modules/debugger/ScriptManager.impl.class.test.js

@@ -1,226 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const scriptClassMocks = vi.hoisted(() => ({
-    logger: {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        success: vi.fn(),
-    },
-}));
-vi.mock('@utils/logger', () => ({
-    logger: scriptClassMocks.logger,
-}));
-import { ScriptManager } from '../../../src/modules/debugger/ScriptManager.impl.class.js';
-function createSession() {
-    const listeners = new Map();
-    const session = {
-        send: vi.fn(async (method, params) => {
-            if (method === 'Debugger.enable' || method === 'Debugger.disable') {
-                return {};
-            }
-            if (method === 'Debugger.getScriptSource') {
-                return {
-                    scriptSource: `function hello(){ const token${params?.scriptId ?? ''} = "abc"; }\n` +
-                        `const api = fetch('/api/${params?.scriptId ?? '1'}');\n` +
-                        `export default hello;`,
-                };
-            }
-            return {};
-        }),
-        on: vi.fn((event, handler) => {
-            const set = listeners.get(event) ?? new Set();
-            set.add(handler);
-            listeners.set(event, set);
-        }),
-        off: vi.fn(),
-        detach: vi.fn().mockResolvedValue(undefined),
-        emit(event, payload) {
-            listeners.get(event)?.forEach((handler) => handler(payload));
-        },
-    };
-    return { session, listeners };
-}
-function emitScriptParsed(session, scriptId, url, length = 120) {
-    session.emit('Debugger.scriptParsed', {
-        scriptId,
-        url,
-        startLine: 0,
-        startColumn: 0,
-        endLine: 3,
-        endColumn: 0,
-        length,
-    });
-}
-describe('ScriptManager core class internals', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('returns cached script sources without reloading them', async () => {
-        const cdp = createSession();
-        const manager = new ScriptManager({
-            getActivePage: vi.fn().mockResolvedValue({
-                createCDPSession: vi.fn().mockResolvedValue(cdp.session),
-            }),
-        });
-        await manager.init();
-        const script = {
-            scriptId: 'script-1',
-            url: 'https://site/app.js',
-            startLine: 0,
-            startColumn: 0,
-            endLine: 1,
-            endColumn: 0,
-            source: 'const cached = true;',
-            sourceLength: 20,
-        };
-        const loaded = await manager.loadScriptSourceInternal(script);
-        expect(loaded).toBe(true);
-        expect(cdp.session.send).toHaveBeenCalledTimes(1);
-    });
-    it('supports wildcard URL lookup and validates missing identifiers', async () => {
-        const cdp = createSession();
-        const manager = new ScriptManager({
-            getActivePage: vi.fn().mockResolvedValue({
-                createCDPSession: vi.fn().mockResolvedValue(cdp.session),
-            }),
-        });
-        await manager.init();
-        emitScriptParsed(cdp.session, 'script-1', 'https://site/app.js');
-        await expect(manager.getScriptSource()).rejects.toThrow('Either scriptId or url parameter must be provided');
-        const script = await manager.getScriptSource(undefined, '*app*');
-        expect(script?.scriptId).toBe('script-1');
-        expect(script?.source).toContain('function hello');
-    });
-    it('loads sources in batches of eight when includeSource=true', async () => {
-        const cdp = createSession();
-        const resolvers = [];
-        cdp.session.send.mockImplementation((method, params) => {
-            if (method === 'Debugger.enable' || method === 'Debugger.disable') {
-                return Promise.resolve({});
-            }
-            if (method === 'Debugger.getScriptSource') {
-                return new Promise((resolve) => {
-                    resolvers.push(() => resolve({
-                        scriptSource: `const script${params?.scriptId} = true;`,
-                    }));
-                });
-            }
-            return Promise.resolve({});
-        });
-        const manager = new ScriptManager({
-            getActivePage: vi.fn().mockResolvedValue({
-                createCDPSession: vi.fn().mockResolvedValue(cdp.session),
-            }),
-        });
-        await manager.init();
-        for (let index = 1; index <= 9; index++) {
-            emitScriptParsed(cdp.session, `script-${index}`, `https://site/${index}.js`, 20);
-        }
-        const loading = manager.getAllScripts(true, 9);
-        await Promise.resolve();
-        expect(cdp.session.send.mock.calls.filter(([method]) => method === 'Debugger.getScriptSource')).toHaveLength(8);
-        resolvers.splice(0, 8).forEach((resolve) => resolve());
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(cdp.session.send.mock.calls.filter(([method]) => method === 'Debugger.getScriptSource')).toHaveLength(9);
-        resolvers.splice(0).forEach((resolve) => resolve());
-        const scripts = await loading;
-        expect(scripts).toHaveLength(9);
-        expect(scripts.every((script) => typeof script.source === 'string')).toBe(true);
-    });
-    it('searches scripts with regex options and honors max match limits', async () => {
-        const cdp = createSession();
-        const manager = new ScriptManager({
-            getActivePage: vi.fn().mockResolvedValue({
-                createCDPSession: vi.fn().mockResolvedValue(cdp.session),
-            }),
-        });
-        await manager.init();
-        emitScriptParsed(cdp.session, 'script-1', 'https://site/app.js');
-        await manager.getScriptSource('script-1');
-        const result = await manager.searchInScripts('token\\w+', {
-            isRegex: true,
-            contextLines: 0,
-            maxMatches: 1,
-        });
-        expect(result.totalMatches).toBe(1);
-        expect(result.matches[0]?.matchText).toMatch(/^token/);
-        expect(result.matches[0]?.context).not.toContain('\n');
-    });
-    it('clears in-memory script caches and resets close state even when CDP cleanup fails', async () => {
-        const cdp = createSession();
-        cdp.session.send.mockImplementation(async (method) => {
-            if (method === 'Debugger.enable') {
-                return {};
-            }
-            if (method === 'Debugger.disable') {
-                throw new Error('disable failed');
-            }
-            if (method === 'Debugger.getScriptSource') {
-                return { scriptSource: 'const token = "abc";' };
-            }
-            return {};
-        });
-        const manager = new ScriptManager({
-            getActivePage: vi.fn().mockResolvedValue({
-                createCDPSession: vi.fn().mockResolvedValue(cdp.session),
-            }),
-        });
-        await manager.init();
-        emitScriptParsed(cdp.session, 'script-1', 'https://site/app.js');
-        await manager.getScriptSource('script-1');
-        expect(manager.getStats().totalScripts).toBe(1);
-        manager.clear();
-        expect(manager.getStats()).toEqual({
-            totalScripts: 0,
-            totalUrls: 0,
-            indexedKeywords: 0,
-            totalChunks: 0,
-        });
-        emitScriptParsed(cdp.session, 'script-2', 'https://site/app-2.js');
-        await manager.close();
-        expect(scriptClassMocks.logger.warn).toHaveBeenCalledWith('Failed to close CDP session:', expect.any(Error));
-        expect(manager.initialized).toBe(false);
-        expect(manager.cdpSession).toBeNull();
-    });
-    it('indexes keywords in lowercase and chunks scripts for later retrieval', () => {
-        const manager = new ScriptManager({ getActivePage: vi.fn() });
-        manager.CHUNK_SIZE = 5;
-        manager.buildKeywordIndex('script-1', 'https://site/app.js', 'line1\nLine2 tokenValue\nline3\nline4\nline5');
-        manager.chunkScript('script-1', 'abcdefghij');
-        const keywordEntries = manager.keywordIndex.get('tokenvalue');
-        expect(keywordEntries).toHaveLength(1);
-        expect(keywordEntries[0]).toMatchObject({
-            scriptId: 'script-1',
-            url: 'https://site/app.js',
-            line: 2,
-            column: 6,
-        });
-        expect(keywordEntries[0]?.context).toContain('line1');
-        expect(keywordEntries[0]?.context).toContain('line5');
-        expect(manager.getScriptChunk('script-1', 0)).toBe('abcde');
-        expect(manager.getScriptChunk('script-1', 1)).toBe('fghij');
-        expect(manager.getScriptChunk('script-1', 2)).toBeNull();
-    });
-    it('delegates regex enhanced search to the full script searcher', async () => {
-        const manager = new ScriptManager({ getActivePage: vi.fn() });
-        const searchSpy = vi.spyOn(manager, 'searchInScripts').mockResolvedValue({
-            keyword: 'tok.*',
-            totalMatches: 1,
-            matches: [
-                {
-                    scriptId: 'script-1',
-                    url: 'https://site/app.js',
-                    line: 1,
-                    column: 0,
-                    matchText: 'token',
-                    context: 'token',
-                },
-            ],
-        });
-        const result = await manager.searchInScriptsEnhanced('tok.*', { isRegex: true });
-        expect(searchSpy).toHaveBeenCalledWith('tok.*', { isRegex: true });
-        expect(result.searchMethod).toBe('regex');
-        expect(result.totalMatches).toBe(1);
-    });
-});

package/dist/tests/modules/debugger/ScriptManager.impl.extract-function-tree.test.d.ts

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

package/dist/tests/modules/debugger/ScriptManager.impl.extract-function-tree.test.js

@@ -1,200 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const functionTreeMocks = vi.hoisted(() => {
-    const state = {
-        declarations: [],
-        variables: [],
-        parse: vi.fn(),
-        traverse: vi.fn(),
-        generate: vi.fn(),
-        logger: {
-            debug: vi.fn(),
-            info: vi.fn(),
-            warn: vi.fn(),
-            error: vi.fn(),
-            success: vi.fn(),
-        },
-    };
-    const createPath = (node, type) => ({
-        node: type === 'FunctionDeclaration'
-            ? {
-                type,
-                id: { type: 'Identifier', name: node.name },
-                loc: {
-                    start: { line: node.startLine },
-                    end: { line: node.endLine },
-                },
-                mockCode: node.code,
-                mockDeps: node.deps,
-            }
-            : {
-                type,
-                id: { type: 'Identifier', name: node.name },
-                init: { type: node.initType },
-                loc: {
-                    start: { line: node.startLine },
-                    end: { line: node.endLine },
-                },
-                mockCode: node.code,
-                mockDeps: node.deps,
-            },
-        traverse(visitor) {
-            node.deps.forEach((dep) => {
-                visitor.CallExpression?.({
-                    node: {
-                        callee: {
-                            type: 'Identifier',
-                            name: dep,
-                        },
-                    },
-                });
-            });
-        },
-    });
-    return { ...state, createPath };
-});
-vi.mock('@utils/logger', () => ({
-    logger: functionTreeMocks.logger,
-}));
-vi.mock('@babel/parser', () => ({
-    parse: functionTreeMocks.parse,
-}));
-vi.mock('@babel/traverse', () => ({
-    default: functionTreeMocks.traverse,
-    traverse: functionTreeMocks.traverse,
-}));
-vi.mock('@babel/generator', () => ({
-    default: functionTreeMocks.generate,
-    generate: functionTreeMocks.generate,
-}));
-vi.mock('@babel/types', () => ({
-    isIdentifier: (value) => value?.type === 'Identifier',
-    isFunctionExpression: (value) => value?.type === 'FunctionExpression',
-    isArrowFunctionExpression: (value) => value?.type === 'ArrowFunctionExpression',
-}));
-import { extractFunctionTreeCore } from '../../../src/modules/debugger/ScriptManager.impl.extract-function-tree.js';
-describe('ScriptManager extract-function-tree internals', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        functionTreeMocks.declarations = [];
-        functionTreeMocks.variables = [];
-        functionTreeMocks.parse.mockReturnValue({ type: 'File' });
-        functionTreeMocks.traverse.mockImplementation((_ast, visitor) => {
-            functionTreeMocks.declarations.forEach((item) => visitor.FunctionDeclaration?.(functionTreeMocks.createPath(item, 'FunctionDeclaration')));
-            functionTreeMocks.variables.forEach((item) => visitor.VariableDeclarator?.(functionTreeMocks.createPath(item, 'VariableDeclarator')));
-        });
-        functionTreeMocks.generate.mockImplementation((node, options) => ({
-            code: node.mockCode ?? '',
-            comments: options?.comments,
-        }));
-    });
-    it('rejects missing scripts before attempting parsing', async () => {
-        const ctx = {
-            getScriptSource: vi.fn().mockResolvedValue(null),
-        };
-        await expect(extractFunctionTreeCore(ctx, 'script-1', 'main')).rejects.toThrow('Script not found: script-1');
-    });
-    it('wraps parser failures with script context', async () => {
-        const ctx = {
-            getScriptSource: vi.fn().mockResolvedValue({
-                source: 'const =',
-            }),
-        };
-        functionTreeMocks.parse.mockImplementation(() => {
-            throw new Error('Unexpected token');
-        });
-        await expect(extractFunctionTreeCore(ctx, 'script-1', 'main')).rejects.toThrow('Failed to parse script script-1: Unexpected token');
-    });
-    it('extracts function declarations, variable functions, and call graphs', async () => {
-        const ctx = {
-            getScriptSource: vi.fn().mockResolvedValue({
-                source: 'function main() {}',
-            }),
-        };
-        functionTreeMocks.declarations = [
-            {
-                name: 'main',
-                code: 'function main() { helper(); util(); }',
-                deps: ['helper', 'util'],
-                startLine: 1,
-                endLine: 3,
-            },
-            {
-                name: 'helper',
-                code: 'function helper() { return leaf(); }',
-                deps: ['leaf'],
-                startLine: 5,
-                endLine: 7,
-            },
-            {
-                name: 'leaf',
-                code: 'function leaf() { return true; }',
-                deps: [],
-                startLine: 9,
-                endLine: 11,
-            },
-        ];
-        functionTreeMocks.variables = [
-            {
-                name: 'util',
-                code: 'const util = () => 1;',
-                deps: [],
-                startLine: 13,
-                endLine: 13,
-                initType: 'ArrowFunctionExpression',
-            },
-        ];
-        const result = await extractFunctionTreeCore(ctx, 'script-1', 'main', {
-            includeComments: false,
-            maxDepth: 5,
-        });
-        expect(result.mainFunction).toBe('main');
-        expect(result.extractedCount).toBe(4);
-        expect(result.functions.map((func) => func.name)).toEqual(expect.arrayContaining(['main', 'helper', 'leaf', 'util']));
-        expect(result.callGraph).toEqual({
-            main: ['helper', 'util'],
-            helper: ['leaf'],
-            leaf: [],
-            util: [],
-        });
-        expect(result.code).toContain('function main()');
-        expect(result.code).toContain('const util = () => 1;');
-        expect(functionTreeMocks.generate).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ comments: false }));
-        expect(functionTreeMocks.logger.info).toHaveBeenCalledWith(expect.stringContaining('extractFunctionTree: main - extracted 4 functions'));
-    });
-    it('limits extraction by maxDepth and warns on oversized output', async () => {
-        const ctx = {
-            getScriptSource: vi.fn().mockResolvedValue({
-                source: 'function main() {}',
-            }),
-        };
-        functionTreeMocks.declarations = [
-            {
-                name: 'main',
-                code: 'function main() { helper(); }',
-                deps: ['helper'],
-                startLine: 1,
-                endLine: 3,
-            },
-            {
-                name: 'helper',
-                code: 'function helper() { return leaf(); }',
-                deps: ['leaf'],
-                startLine: 5,
-                endLine: 7,
-            },
-            {
-                name: 'leaf',
-                code: 'function leaf() { return true; }',
-                deps: [],
-                startLine: 9,
-                endLine: 11,
-            },
-        ];
-        const result = await extractFunctionTreeCore(ctx, 'script-1', 'main', {
-            maxDepth: 2,
-            maxSize: 0,
-        });
-        expect(result.functions.map((func) => func.name)).toEqual(['main', 'helper']);
-        expect(functionTreeMocks.logger.warn).toHaveBeenCalledWith(expect.stringContaining('Extracted code size'));
-    });
-});

package/dist/tests/modules/debugger/ScriptManager.impl.test.d.ts

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

package/dist/tests/modules/debugger/ScriptManager.impl.test.js

@@ -1,8 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ScriptManager as ImplScriptManager } from '../../../src/modules/debugger/ScriptManager.impl.js';
-import { ScriptManager as ClassScriptManager } from '../../../src/modules/debugger/ScriptManager.impl.class.js';
-describe('ScriptManager.impl.ts', () => {
-    it('re-exports the ScriptManager class from the class module', () => {
-        expect(ImplScriptManager).toBe(ClassScriptManager);
-    });
-});

package/dist/tests/modules/debugger/ScriptManager.test.d.ts

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

package/dist/tests/modules/debugger/ScriptManager.test.js

@@ -1,168 +0,0 @@
-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 { ScriptManager } from '../../../src/modules/debugger/ScriptManager.js';
-function createSession() {
-    const listeners = new Map();
-    const send = vi.fn(async (method, params) => {
-        if (method === 'Debugger.getScriptSource') {
-            return {
-                scriptSource: `function hello(){ const token = "abc"; }\n` +
-                    `const api = fetch('/api');\n` +
-                    `export default hello;`,
-            };
-        }
-        if (method === 'Debugger.enable' || method === 'Debugger.disable') {
-            return {};
-        }
-        return { params };
-    });
-    const on = vi.fn((event, handler) => {
-        const group = listeners.get(event) ?? new Set();
-        group.add(handler);
-        listeners.set(event, group);
-    });
-    const emit = (event, payload) => {
-        listeners.get(event)?.forEach((handler) => handler(payload));
-    };
-    return {
-        session: {
-            send,
-            on,
-            off: vi.fn(),
-            detach: vi.fn().mockResolvedValue(undefined),
-        },
-        send,
-        emit,
-    };
-}
-describe('ScriptManager', () => {
-    let manager;
-    let cdp;
-    beforeEach(async () => {
-        cdp = createSession();
-        const page = { createCDPSession: vi.fn().mockResolvedValue(cdp.session) };
-        const collector = { getActivePage: vi.fn().mockResolvedValue(page) };
-        manager = new ScriptManager(collector);
-        await manager.init();
-    });
-    it('captures scriptParsed events and stores script metadata', async () => {
-        cdp.emit('Debugger.scriptParsed', {
-            scriptId: '1',
-            url: 'https://site/app.js',
-            startLine: 0,
-            startColumn: 0,
-            endLine: 10,
-            endColumn: 0,
-            length: 120,
-        });
-        const scripts = await manager.getAllScripts();
-        expect(scripts).toHaveLength(1);
-        expect(scripts[0]?.scriptId).toBe('1');
-    });
-    it('loads script source by scriptId and exposes chunk access', async () => {
-        cdp.emit('Debugger.scriptParsed', {
-            scriptId: '1',
-            url: 'https://site/app.js',
-            startLine: 0,
-            startColumn: 0,
-            endLine: 10,
-            endColumn: 0,
-            length: 120,
-        });
-        const script = await manager.getScriptSource('1');
-        expect(script?.source).toContain('function hello');
-        expect(manager.getScriptChunk('1', 0)).toContain('token');
-    });
-    it('loads multiple script sources concurrently in getAllScripts', async () => {
-        const pendingResolvers = [];
-        cdp.send.mockImplementation((method, params) => {
-            if (method === 'Debugger.getScriptSource') {
-                return new Promise((resolve) => {
-                    pendingResolvers.push(() => resolve({ scriptSource: `const id = "${params?.scriptId}";` }));
-                });
-            }
-            if (method === 'Debugger.enable' || method === 'Debugger.disable') {
-                return Promise.resolve({});
-            }
-            return Promise.resolve({});
-        });
-        for (const scriptId of ['1', '2', '3']) {
-            cdp.emit('Debugger.scriptParsed', {
-                scriptId,
-                url: `https://site/${scriptId}.js`,
-                startLine: 0,
-                startColumn: 0,
-                endLine: 1,
-                endColumn: 0,
-                length: 24,
-            });
-        }
-        const loadPromise = manager.getAllScripts(true);
-        await Promise.resolve();
-        expect(cdp.send.mock.calls.filter(([method]) => method === 'Debugger.getScriptSource')).toHaveLength(3);
-        pendingResolvers.splice(0).forEach((resolve) => resolve());
-        const scripts = await loadPromise;
-        expect(scripts.every((script) => typeof script.source === 'string')).toBe(true);
-    });
-    it('finds scripts by wildcard URL patterns', async () => {
-        cdp.emit('Debugger.scriptParsed', {
-            scriptId: 'a',
-            url: 'https://site/vendor.bundle.js',
-            startLine: 0,
-            startColumn: 0,
-            endLine: 1,
-            endColumn: 0,
-            length: 10,
-        });
-        cdp.emit('Debugger.scriptParsed', {
-            scriptId: 'b',
-            url: 'https://site/app.js',
-            startLine: 0,
-            startColumn: 0,
-            endLine: 1,
-            endColumn: 0,
-            length: 10,
-        });
-        const found = await manager.findScriptsByUrl('*vendor*');
-        expect(found).toHaveLength(1);
-        expect(found[0]?.scriptId).toBe('a');
-    });
-    it('searches loaded script sources and returns contextual matches', async () => {
-        cdp.emit('Debugger.scriptParsed', {
-            scriptId: '1',
-            url: 'https://site/app.js',
-            startLine: 0,
-            startColumn: 0,
-            endLine: 10,
-            endColumn: 0,
-            length: 120,
-        });
-        await manager.getScriptSource('1');
-        const result = await manager.searchInScripts('token', { contextLines: 1 });
-        expect(result.totalMatches).toBeGreaterThan(0);
-        expect(result.matches[0]?.context).toContain('token');
-    });
-    it('searchInScriptsEnhanced uses indexed lookup for non-regex queries', async () => {
-        cdp.emit('Debugger.scriptParsed', {
-            scriptId: '1',
-            url: 'https://site/app.js',
-            startLine: 0,
-            startColumn: 0,
-            endLine: 10,
-            endColumn: 0,
-            length: 120,
-        });
-        await manager.getScriptSource('1');
-        const result = await manager.searchInScriptsEnhanced('token');
-        expect(result.searchMethod).toBe('indexed');
-        expect(result.totalMatches).toBeGreaterThan(0);
-    });
-});

package/dist/tests/modules/debugger/WatchExpressionManager.test.d.ts

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

package/dist/tests/modules/debugger/WatchExpressionManager.test.js

@@ -1,61 +0,0 @@
-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 { WatchExpressionManager } from '../../../src/modules/debugger/WatchExpressionManager.js';
-describe('WatchExpressionManager', () => {
-    let runtimeInspector;
-    let manager;
-    beforeEach(() => {
-        runtimeInspector = {
-            evaluate: vi.fn(),
-        };
-        manager = new WatchExpressionManager(runtimeInspector);
-    });
-    it('adds and removes watch expressions', () => {
-        const id = manager.addWatch('foo + bar', 'sum');
-        expect(manager.getWatch(id)?.name).toBe('sum');
-        expect(manager.removeWatch(id)).toBe(true);
-        expect(manager.getWatch(id)).toBeUndefined();
-    });
-    it('toggles watch enabled state', () => {
-        const id = manager.addWatch('count');
-        expect(manager.setWatchEnabled(id, false)).toBe(true);
-        expect(manager.getWatch(id)?.enabled).toBe(false);
-    });
-    it('evaluates watches and tracks value history on change', async () => {
-        runtimeInspector.evaluate
-            .mockResolvedValueOnce({ n: 1 })
-            .mockResolvedValueOnce({ n: 2 });
-        const id = manager.addWatch('obj.n');
-        const first = await manager.evaluateAll();
-        const second = await manager.evaluateAll();
-        expect(first[0]?.valueChanged).toBe(true);
-        expect(second[0]?.valueChanged).toBe(true);
-        expect(manager.getValueHistory(id)?.length).toBe(2);
-    });
-    it('returns timeout error result when evaluation exceeds timeout', async () => {
-        runtimeInspector.evaluate.mockImplementation(() => new Promise(() => { }));
-        manager.addWatch('slowExpr');
-        const result = await manager.evaluateAll(undefined, 10);
-        expect(result[0]?.error?.message).toContain('Evaluation timeout');
-    });
-    it('exports and imports watch definitions', () => {
-        manager.addWatch('a + b', 'sum');
-        const tokenWatch = manager.addWatch('token', 'token');
-        manager.setWatchEnabled(tokenWatch, false);
-        const exported = manager.exportWatches();
-        const runtime2 = { evaluate: vi.fn() };
-        const importedManager = new WatchExpressionManager(runtime2);
-        importedManager.importWatches(exported);
-        expect(importedManager.getAllWatches()).toHaveLength(2);
-        expect(importedManager.getAllWatches()[0]?.expression).toBe('a + b');
-        expect(importedManager.getAllWatches()[1]?.enabled).toBe(false);
-    });
-});

package/dist/tests/modules/debugger/XHRBreakpointManager.test.d.ts

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