@jshookmcp/jshook 0.2.1 → 0.2.3

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

@@ -1,309 +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 { PrerequisiteError } from '../../../src/errors/PrerequisiteError.js';
-import { clearAllBreakpointsCore, getBreakpointCore, listBreakpointsCore, removeBreakpointCore, setBreakpointByUrlCore, setBreakpointCore, } from '../../../src/modules/debugger/DebuggerManager.impl.core.breakpoints.js';
-function makeCtx(overrides = {}) {
-    const send = vi.fn(async () => ({ breakpointId: 'bp-default' }));
-    const ctx = {
-        enabled: true,
-        cdpSession: { send },
-        breakpoints: new Map(),
-        ensureSession: vi.fn(async () => {
-            ctx.enabled = true;
-            ctx.cdpSession = { send };
-        }),
-        removeBreakpoint: vi.fn(async (id) => {
-            ctx.breakpoints.delete(id);
-        }),
-        ...overrides,
-    };
-    return ctx;
-}
-describe('BreakpointsCoreExtended - conditional breakpoints', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('stores condition string on URL-based conditional breakpoint', async () => {
-        const ctx = makeCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({ breakpointId: 'bp-cond-1' });
-        const bp = await setBreakpointByUrlCore(ctx, {
-            url: 'https://example.com/app.js',
-            lineNumber: 10,
-            condition: 'i === 5',
-        });
-        expect(bp.condition).toBe('i === 5');
-        expect(bp.enabled).toBe(true);
-        expect(bp.hitCount).toBe(0);
-        expect(ctx.breakpoints.get('bp-cond-1')?.condition).toBe('i === 5');
-    });
-    it('stores condition string on script-based conditional breakpoint', async () => {
-        const ctx = makeCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({ breakpointId: 'bp-cond-2' });
-        const bp = await setBreakpointCore(ctx, {
-            scriptId: 'script-42',
-            lineNumber: 20,
-            condition: 'x > 100',
-        });
-        expect(bp.condition).toBe('x > 100');
-        expect(bp.breakpointId).toBe('bp-cond-2');
-    });
-    it('creates breakpoint without condition when condition is undefined', async () => {
-        const ctx = makeCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({ breakpointId: 'bp-no-cond' });
-        const bp = await setBreakpointByUrlCore(ctx, {
-            url: 'https://example.com/app.js',
-            lineNumber: 5,
-        });
-        expect(bp.condition).toBeUndefined();
-        expect(ctx.cdpSession.send).toHaveBeenCalledWith('Debugger.setBreakpointByUrl', expect.objectContaining({ condition: undefined }));
-    });
-});
-describe('BreakpointsCoreExtended - hit counts', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('initializes hitCount to 0 for URL breakpoints', async () => {
-        const ctx = makeCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({ breakpointId: 'bp-hit' });
-        const bp = await setBreakpointByUrlCore(ctx, {
-            url: 'https://example.com/index.js',
-            lineNumber: 1,
-        });
-        expect(bp.hitCount).toBe(0);
-    });
-    it('initializes hitCount to 0 for script breakpoints', async () => {
-        const ctx = makeCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({ breakpointId: 'bp-script-hit' });
-        const bp = await setBreakpointCore(ctx, {
-            scriptId: 'script-1',
-            lineNumber: 1,
-        });
-        expect(bp.hitCount).toBe(0);
-    });
-    it('records createdAt timestamp on breakpoint creation', async () => {
-        const ctx = makeCtx();
-        const before = Date.now();
-        ctx.cdpSession.send.mockResolvedValueOnce({ breakpointId: 'bp-ts' });
-        const bp = await setBreakpointByUrlCore(ctx, {
-            url: 'https://example.com/app.js',
-            lineNumber: 1,
-        });
-        expect(bp.createdAt).toBeGreaterThanOrEqual(before);
-        expect(bp.createdAt).toBeLessThanOrEqual(Date.now());
-    });
-});
-describe('BreakpointsCoreExtended - breakpoint removal', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('removes a breakpoint from the map and sends CDP command', async () => {
-        const send = vi.fn(async () => ({}));
-        const ctx = makeCtx({ cdpSession: { send } });
-        ctx.breakpoints.set('bp-rm', { breakpointId: 'bp-rm', enabled: true });
-        await removeBreakpointCore(ctx, 'bp-rm');
-        expect(send).toHaveBeenCalledWith('Debugger.removeBreakpoint', { breakpointId: 'bp-rm' });
-        expect(ctx.breakpoints.has('bp-rm')).toBe(false);
-    });
-    it('throws when removing a breakpoint that does not exist', async () => {
-        const ctx = makeCtx();
-        await expect(removeBreakpointCore(ctx, 'nonexistent')).rejects.toThrow('Breakpoint not found: nonexistent');
-    });
-    it('throws when removing breakpoint with empty ID', async () => {
-        const ctx = makeCtx();
-        await expect(removeBreakpointCore(ctx, '')).rejects.toThrow('breakpointId parameter is required');
-    });
-    it('throws PrerequisiteError when debugger not enabled', async () => {
-        const ctx = makeCtx({ enabled: false, cdpSession: null });
-        await expect(removeBreakpointCore(ctx, 'bp-1')).rejects.toBeInstanceOf(PrerequisiteError);
-    });
-    it('propagates CDP error on removal failure', async () => {
-        const send = vi.fn(async () => {
-            throw new Error('CDP protocol error');
-        });
-        const ctx = makeCtx({ cdpSession: { send } });
-        ctx.breakpoints.set('bp-fail', { breakpointId: 'bp-fail' });
-        await expect(removeBreakpointCore(ctx, 'bp-fail')).rejects.toThrow('CDP protocol error');
-        expect(loggerState.error).toHaveBeenCalled();
-    });
-});
-describe('BreakpointsCoreExtended - error handling', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('throws PrerequisiteError when auto-reconnect fails for setBreakpointByUrlCore', async () => {
-        const ctx = makeCtx({
-            enabled: false,
-            cdpSession: null,
-        });
-        ctx.ensureSession = vi.fn(async () => {
-            throw new Error('reconnect failed');
-        });
-        await expect(setBreakpointByUrlCore(ctx, { url: 'https://x.com/a.js', lineNumber: 0 })).rejects.toBeInstanceOf(PrerequisiteError);
-        expect(loggerState.warn).toHaveBeenCalledWith(expect.stringContaining('auto-reconnect failed'));
-    });
-    it('throws PrerequisiteError when auto-reconnect fails for setBreakpointCore', async () => {
-        const ctx = makeCtx({
-            enabled: false,
-            cdpSession: null,
-        });
-        ctx.ensureSession = vi.fn(async () => {
-            throw new Error('cannot reconnect');
-        });
-        await expect(setBreakpointCore(ctx, { scriptId: 's1', lineNumber: 0 })).rejects.toBeInstanceOf(PrerequisiteError);
-    });
-    it('logs warn with non-Error thrown from ensureSession', async () => {
-        const ctx = makeCtx({
-            enabled: false,
-            cdpSession: null,
-        });
-        ctx.ensureSession = vi.fn(async () => {
-            throw 'string error';
-        });
-        await expect(setBreakpointByUrlCore(ctx, { url: 'https://x.com/a.js', lineNumber: 0 })).rejects.toBeInstanceOf(PrerequisiteError);
-        expect(loggerState.warn).toHaveBeenCalledWith(expect.stringContaining('string error'));
-    });
-    it('validates negative lineNumber for setBreakpointByUrlCore', async () => {
-        const ctx = makeCtx();
-        await expect(setBreakpointByUrlCore(ctx, { url: 'https://x.com/a.js', lineNumber: -1 })).rejects.toThrow('lineNumber must be a non-negative number');
-    });
-    it('validates negative columnNumber for setBreakpointByUrlCore', async () => {
-        const ctx = makeCtx();
-        await expect(setBreakpointByUrlCore(ctx, { url: 'https://x.com/a.js', lineNumber: 1, columnNumber: -5 })).rejects.toThrow('columnNumber must be a non-negative number');
-    });
-    it('validates empty scriptId for setBreakpointCore', async () => {
-        const ctx = makeCtx();
-        await expect(setBreakpointCore(ctx, { scriptId: '', lineNumber: 1 })).rejects.toThrow('scriptId parameter is required');
-    });
-    it('validates negative columnNumber for setBreakpointCore', async () => {
-        const ctx = makeCtx();
-        await expect(setBreakpointCore(ctx, { scriptId: 's1', lineNumber: 1, columnNumber: -3 })).rejects.toThrow('columnNumber must be a non-negative number');
-    });
-    it('propagates CDP send error for setBreakpointByUrlCore', async () => {
-        const send = vi.fn(async () => {
-            throw new Error('Protocol method not found');
-        });
-        const ctx = makeCtx({ cdpSession: { send } });
-        await expect(setBreakpointByUrlCore(ctx, { url: 'https://x.com/a.js', lineNumber: 1 })).rejects.toThrow('Protocol method not found');
-        expect(loggerState.error).toHaveBeenCalledWith('Failed to set breakpoint:', expect.any(Error));
-    });
-    it('propagates CDP send error for setBreakpointCore', async () => {
-        const send = vi.fn(async () => {
-            throw new Error('Session closed');
-        });
-        const ctx = makeCtx({ cdpSession: { send } });
-        await expect(setBreakpointCore(ctx, { scriptId: 's1', lineNumber: 1 })).rejects.toThrow('Session closed');
-    });
-});
-describe('BreakpointsCoreExtended - list and get', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('returns empty array from listBreakpointsCore when no breakpoints exist', () => {
-        const ctx = makeCtx();
-        expect(listBreakpointsCore(ctx)).toEqual([]);
-    });
-    it('returns all breakpoints from listBreakpointsCore', () => {
-        const ctx = makeCtx();
-        ctx.breakpoints.set('bp-a', { breakpointId: 'bp-a', hitCount: 0 });
-        ctx.breakpoints.set('bp-b', { breakpointId: 'bp-b', hitCount: 1 });
-        const list = listBreakpointsCore(ctx);
-        expect(list).toHaveLength(2);
-        expect(list.map((b) => b.breakpointId)).toEqual(['bp-a', 'bp-b']);
-    });
-    it('returns undefined from getBreakpointCore for non-existent ID', () => {
-        const ctx = makeCtx();
-        expect(getBreakpointCore(ctx, 'missing')).toBeUndefined();
-    });
-    it('returns the correct breakpoint from getBreakpointCore', () => {
-        const ctx = makeCtx();
-        const info = { breakpointId: 'bp-x', hitCount: 5 };
-        ctx.breakpoints.set('bp-x', info);
-        expect(getBreakpointCore(ctx, 'bp-x')).toBe(info);
-    });
-});
-describe('BreakpointsCoreExtended - clearAllBreakpointsCore', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('calls removeBreakpoint for every breakpoint in the map', async () => {
-        const removed = [];
-        const ctx = makeCtx();
-        ctx.breakpoints.set('bp-1', { breakpointId: 'bp-1' });
-        ctx.breakpoints.set('bp-2', { breakpointId: 'bp-2' });
-        ctx.breakpoints.set('bp-3', { breakpointId: 'bp-3' });
-        ctx.removeBreakpoint = vi.fn(async (id) => {
-            removed.push(id);
-        });
-        await clearAllBreakpointsCore(ctx);
-        expect(removed).toEqual(['bp-1', 'bp-2', 'bp-3']);
-        expect(loggerState.info).toHaveBeenCalledWith('Cleared 3 breakpoints');
-    });
-    it('does nothing when breakpoints map is empty', async () => {
-        const ctx = makeCtx();
-        await clearAllBreakpointsCore(ctx);
-        expect(ctx.removeBreakpoint).not.toHaveBeenCalled();
-        expect(loggerState.info).toHaveBeenCalledWith('Cleared 0 breakpoints');
-    });
-});
-describe('BreakpointsCoreExtended - columnNumber edge cases', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('passes columnNumber=0 for URL breakpoints without error', async () => {
-        const ctx = makeCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({ breakpointId: 'bp-col0' });
-        const bp = await setBreakpointByUrlCore(ctx, {
-            url: 'https://x.com/app.js',
-            lineNumber: 5,
-            columnNumber: 0,
-        });
-        expect(bp.location.columnNumber).toBe(0);
-        expect(ctx.cdpSession.send).toHaveBeenCalledWith('Debugger.setBreakpointByUrl', expect.objectContaining({ columnNumber: 0 }));
-    });
-    it('passes columnNumber=0 for script breakpoints without error', async () => {
-        const ctx = makeCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({ breakpointId: 'bp-col0-s' });
-        const bp = await setBreakpointCore(ctx, {
-            scriptId: 's1',
-            lineNumber: 5,
-            columnNumber: 0,
-        });
-        expect(bp.location.columnNumber).toBe(0);
-    });
-    it('stores location with scriptId for script breakpoints', async () => {
-        const ctx = makeCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({ breakpointId: 'bp-loc' });
-        const bp = await setBreakpointCore(ctx, {
-            scriptId: 'script-99',
-            lineNumber: 42,
-            columnNumber: 7,
-        });
-        expect(bp.location).toEqual({
-            scriptId: 'script-99',
-            lineNumber: 42,
-            columnNumber: 7,
-        });
-    });
-    it('stores location with url for URL breakpoints', async () => {
-        const ctx = makeCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({ breakpointId: 'bp-uloc' });
-        const bp = await setBreakpointByUrlCore(ctx, {
-            url: 'https://example.com/bundle.js',
-            lineNumber: 100,
-            columnNumber: 15,
-        });
-        expect(bp.location).toEqual({
-            url: 'https://example.com/bundle.js',
-            lineNumber: 100,
-            columnNumber: 15,
-        });
-    });
-});

package/dist/tests/modules/debugger/DebuggerManager.impl.core.breakpoints.test.d.ts

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

package/dist/tests/modules/debugger/DebuggerManager.impl.core.breakpoints.test.js

@@ -1,84 +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 { PrerequisiteError } from '../../../src/errors/PrerequisiteError.js';
-import { clearAllBreakpointsCore, getBreakpointCore, listBreakpointsCore, removeBreakpointCore, setBreakpointByUrlCore, setBreakpointCore, } from '../../../src/modules/debugger/DebuggerManager.impl.core.breakpoints.js';
-describe('DebuggerManager breakpoint core helpers', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('auto-reconnects and stores breakpoints created by url and script id', async () => {
-        const send = vi
-            .fn()
-            .mockResolvedValueOnce({ breakpointId: 'bp-url' })
-            .mockResolvedValueOnce({ breakpointId: 'bp-script' });
-        const ctx = {
-            enabled: false,
-            cdpSession: null,
-            breakpoints: new Map(),
-            ensureSession: vi.fn(async () => {
-                ctx.enabled = true;
-                ctx.cdpSession = { send };
-            }),
-            removeBreakpoint: vi.fn(),
-        };
-        const byUrl = await setBreakpointByUrlCore(ctx, {
-            url: 'https://example.com/app.js',
-            lineNumber: 4,
-            condition: 'x > 1',
-        });
-        const byScript = await setBreakpointCore(ctx, {
-            scriptId: 'script-1',
-            lineNumber: 8,
-            columnNumber: 2,
-        });
-        expect(byUrl.breakpointId).toBe('bp-url');
-        expect(byScript.breakpointId).toBe('bp-script');
-        expect(getBreakpointCore(ctx, 'bp-url')?.condition).toBe('x > 1');
-        expect(listBreakpointsCore(ctx)).toHaveLength(2);
-    });
-    it('validates breakpoint params and removal preconditions', async () => {
-        const ctx = {
-            enabled: true,
-            cdpSession: { send: vi.fn(async () => ({})) },
-            breakpoints: new Map(),
-            ensureSession: vi.fn(),
-            removeBreakpoint: vi.fn(),
-        };
-        await expect(setBreakpointByUrlCore(ctx, { url: '', lineNumber: 1 })).rejects.toThrow('url parameter is required');
-        await expect(setBreakpointCore(ctx, { scriptId: 's', lineNumber: -1 })).rejects.toThrow('lineNumber must be a non-negative number');
-        await expect(removeBreakpointCore(ctx, 'missing')).rejects.toThrow('Breakpoint not found');
-        ctx.enabled = false;
-        await expect(removeBreakpointCore(ctx, 'bp')).rejects.toBeInstanceOf(PrerequisiteError);
-    });
-    it('removes and clears breakpoints through the context callbacks', async () => {
-        const send = vi.fn(async () => ({}));
-        const removed = [];
-        const ctx = {
-            enabled: true,
-            cdpSession: { send },
-            breakpoints: new Map([
-                ['bp-1', { breakpointId: 'bp-1' }],
-                ['bp-2', { breakpointId: 'bp-2' }],
-            ]),
-            ensureSession: vi.fn(),
-            removeBreakpoint: vi.fn(async (id) => {
-                removed.push(id);
-                ctx.breakpoints.delete(id);
-            }),
-        };
-        await removeBreakpointCore({
-            ...ctx,
-            breakpoints: new Map([['bp-1', { breakpointId: 'bp-1' }]]),
-        }, 'bp-1');
-        await clearAllBreakpointsCore(ctx);
-        expect(removed).toEqual(['bp-1', 'bp-2']);
-    });
-});

package/dist/tests/modules/debugger/DebuggerManager.impl.core.class.test.d.ts

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

package/dist/tests/modules/debugger/DebuggerManager.impl.core.class.test.js

@@ -1,223 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const classMocks = vi.hoisted(() => {
-    const createManagerClass = () => class {
-        session;
-        close = vi.fn().mockResolvedValue(undefined);
-        clearAll = vi.fn();
-        constructor(session) {
-            this.session = session;
-        }
-    };
-    return {
-        logger: {
-            debug: vi.fn(),
-            info: vi.fn(),
-            warn: vi.fn(),
-            error: vi.fn(),
-            success: vi.fn(),
-        },
-        WatchExpressionManager: createManagerClass(),
-        XHRBreakpointManager: createManagerClass(),
-        EventBreakpointManager: createManagerClass(),
-        BlackboxManager: createManagerClass(),
-        DebuggerSessionManager: class {
-            exportSession = vi.fn().mockReturnValue({ metadata: {} });
-            saveSession = vi.fn().mockResolvedValue('session.json');
-            loadSessionFromFile = vi.fn().mockResolvedValue(undefined);
-            importSession = vi.fn().mockResolvedValue(undefined);
-            listSavedSessions = vi.fn().mockResolvedValue([]);
-            constructor(_manager) { }
-        },
-    };
-});
-vi.mock('@utils/logger', () => ({
-    logger: classMocks.logger,
-}));
-vi.mock('@modules/debugger/WatchExpressionManager', () => ({
-    WatchExpressionManager: classMocks.WatchExpressionManager,
-}));
-vi.mock('@modules/debugger/XHRBreakpointManager', () => ({
-    XHRBreakpointManager: classMocks.XHRBreakpointManager,
-}));
-vi.mock('@modules/debugger/EventBreakpointManager', () => ({
-    EventBreakpointManager: classMocks.EventBreakpointManager,
-}));
-vi.mock('@modules/debugger/BlackboxManager', () => ({
-    BlackboxManager: classMocks.BlackboxManager,
-}));
-vi.mock('@modules/debugger/DebuggerSessionManager', () => ({
-    DebuggerSessionManager: classMocks.DebuggerSessionManager,
-}));
-import { DebuggerManager } from '../../../src/modules/debugger/DebuggerManager.impl.core.class.js';
-function createCDPSession() {
-    const listeners = new Map();
-    return {
-        session: {
-            send: vi.fn().mockResolvedValue({}),
-            on: vi.fn((event, handler) => {
-                const set = listeners.get(event) ?? new Set();
-                set.add(handler);
-                listeners.set(event, set);
-            }),
-            off: vi.fn((event, handler) => {
-                listeners.get(event)?.delete(handler);
-            }),
-            detach: vi.fn().mockResolvedValue(undefined),
-            emit(event, payload) {
-                listeners.get(event)?.forEach((handler) => handler(payload));
-            },
-        },
-        listeners,
-    };
-}
-describe('DebuggerManager core class internals', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('initializes advanced feature managers and tracks the active session', async () => {
-        const cdp = createCDPSession();
-        const collector = {
-            getActivePage: vi.fn().mockResolvedValue({
-                createCDPSession: vi.fn().mockResolvedValue(cdp.session),
-            }),
-        };
-        const manager = new DebuggerManager(collector);
-        const runtimeInspector = { inspect: vi.fn() };
-        await manager.init();
-        await manager.initAdvancedFeatures(runtimeInspector);
-        expect(manager.getWatchManager()).toBeInstanceOf(classMocks.WatchExpressionManager);
-        expect(manager.getXHRManager()).toBeInstanceOf(classMocks.XHRBreakpointManager);
-        expect(manager.getEventManager()).toBeInstanceOf(classMocks.EventBreakpointManager);
-        expect(manager.getBlackboxManager()).toBeInstanceOf(classMocks.BlackboxManager);
-        expect(manager.advancedFeatureSession).toBe(cdp.session);
-    });
-    it('marks itself disconnected and clears advanced managers on session disconnect', async () => {
-        const cdp = createCDPSession();
-        const collector = {
-            getActivePage: vi.fn().mockResolvedValue({
-                createCDPSession: vi.fn().mockResolvedValue(cdp.session),
-            }),
-        };
-        const manager = new DebuggerManager(collector);
-        await manager.init();
-        await manager.initAdvancedFeatures({ inspect: vi.fn() });
-        cdp.session.emit('disconnected');
-        expect(manager.isEnabled()).toBe(false);
-        expect(manager.cdpSession).toBeNull();
-        expect(manager.advancedFeatureSession).toBeNull();
-        expect(manager._xhrManager).toBeNull();
-        expect(manager._eventManager).toBeNull();
-        expect(manager._blackboxManager).toBeNull();
-    });
-    it('reinitializes advanced features when the session changed or managers are missing', async () => {
-        const collector = {
-            getActivePage: vi.fn(),
-        };
-        const manager = new DebuggerManager(collector);
-        const currentSession = { send: vi.fn() };
-        manager.cdpSession = currentSession;
-        manager.advancedFeatureSession = { send: vi.fn() };
-        manager._xhrManager = null;
-        manager._eventManager = {};
-        manager._blackboxManager = {};
-        const ensureSessionSpy = vi.spyOn(manager, 'ensureSession').mockResolvedValue(undefined);
-        const initAdvancedSpy = vi
-            .spyOn(manager, 'initAdvancedFeatures')
-            .mockResolvedValue(undefined);
-        await manager.ensureAdvancedFeatures();
-        expect(ensureSessionSpy).toHaveBeenCalledTimes(1);
-        expect(initAdvancedSpy).toHaveBeenCalledTimes(1);
-        manager.advancedFeatureSession = currentSession;
-        manager._xhrManager = {};
-        initAdvancedSpy.mockClear();
-        await manager.ensureAdvancedFeatures();
-        expect(initAdvancedSpy).not.toHaveBeenCalled();
-    });
-    it('normalizes paused and breakpoint-resolved event payloads defensively', () => {
-        const manager = new DebuggerManager({ getActivePage: vi.fn() });
-        const paused = manager.normalizePausedEventParams({
-            callFrames: [
-                {
-                    callFrameId: 'cf-1',
-                    functionName: 42,
-                    location: {
-                        scriptId: 'script-1',
-                        lineNumber: 'bad',
-                    },
-                    url: null,
-                    scopeChain: [
-                        {
-                            type: 'mystery',
-                            object: {},
-                            name: 10,
-                            startLocation: { scriptId: 1 },
-                        },
-                    ],
-                    this: 'self',
-                },
-            ],
-            reason: 10,
-            data: { ok: true },
-            hitBreakpoints: ['bp-1', 2],
-        });
-        expect(paused).toEqual({
-            callFrames: [
-                {
-                    callFrameId: 'cf-1',
-                    functionName: '',
-                    location: {
-                        scriptId: 'script-1',
-                        lineNumber: 0,
-                        columnNumber: 0,
-                    },
-                    url: '',
-                    scopeChain: [
-                        {
-                            type: 'local',
-                            object: {
-                                type: 'object',
-                                objectId: undefined,
-                                className: undefined,
-                                description: undefined,
-                            },
-                            name: undefined,
-                            startLocation: {
-                                scriptId: '',
-                                lineNumber: 0,
-                                columnNumber: 0,
-                            },
-                            endLocation: undefined,
-                        },
-                    ],
-                    this: 'self',
-                },
-            ],
-            reason: 'unknown',
-            data: { ok: true },
-            hitBreakpoints: ['bp-1'],
-        });
-        expect(manager.normalizeBreakpointResolvedParams({
-            breakpointId: 5,
-            location: { scriptId: 'script-1' },
-        })).toEqual({
-            breakpointId: '',
-            location: { scriptId: 'script-1' },
-        });
-    });
-    it('calls disable during close when enabled and detaches residual sessions', async () => {
-        const manager = new DebuggerManager({ getActivePage: vi.fn() });
-        const detach = vi.fn().mockResolvedValue(undefined);
-        manager.enabled = true;
-        manager.cdpSession = { detach };
-        const disableSpy = vi.spyOn(manager, 'disable').mockResolvedValue(undefined);
-        await manager.close();
-        expect(disableSpy).toHaveBeenCalledTimes(1);
-        expect(detach).toHaveBeenCalledTimes(1);
-        const secondManager = new DebuggerManager({ getActivePage: vi.fn() });
-        const secondDetach = vi.fn().mockResolvedValue(undefined);
-        secondManager.cdpSession = { detach: secondDetach };
-        await secondManager.close();
-        expect(secondDetach).toHaveBeenCalledTimes(1);
-        expect(secondManager.cdpSession).toBeNull();
-    });
-});

package/dist/tests/modules/debugger/DebuggerManager.impl.core.events.test.d.ts

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