@jshookmcp/jshook 0.1.9 → 0.2.1

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

@@ -0,0 +1,162 @@
+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 collectorHelpers = vi.hoisted(() => ({
+    collectInlineScripts: vi.fn(async () => []),
+    collectServiceWorkers: vi.fn(async () => []),
+    collectWebWorkers: vi.fn(async () => []),
+    analyzeDependencies: vi.fn(() => ({ nodes: [], edges: [] })),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: loggerState,
+}));
+vi.mock('@modules/collector/PageScriptCollectors', () => ({
+    collectInlineScripts: collectorHelpers.collectInlineScripts,
+    collectServiceWorkers: collectorHelpers.collectServiceWorkers,
+    collectWebWorkers: collectorHelpers.collectWebWorkers,
+    analyzeDependencies: collectorHelpers.analyzeDependencies,
+}));
+import { collectInnerImpl } from '../../../src/modules/collector/CodeCollectorCollectInternal.js';
+function createPageAndSession() {
+    const listeners = new Map();
+    const session = {
+        send: vi.fn(async () => ({})),
+        on: vi.fn((event, handler) => {
+            const group = listeners.get(event) ?? new Set();
+            group.add(handler);
+            listeners.set(event, group);
+        }),
+        off: vi.fn((event, handler) => {
+            listeners.get(event)?.delete(handler);
+        }),
+        detach: vi.fn(async () => { }),
+    };
+    const page = {
+        setDefaultTimeout: vi.fn(),
+        setUserAgent: vi.fn(async () => { }),
+        createCDPSession: vi.fn(async () => session),
+        goto: vi.fn(async () => { }),
+        close: vi.fn(async () => { }),
+    };
+    return { page, session };
+}
+describe('CodeCollector collect internals', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('returns cached results before initializing the browser flow', async () => {
+        const cached = {
+            files: [{ url: 'https://example.com/app.js', content: 'code', size: 4, type: 'external' }],
+            dependencies: { nodes: [], edges: [] },
+            totalSize: 4,
+            collectTime: 1,
+        };
+        const ctx = {
+            cacheEnabled: true,
+            cache: {
+                get: vi.fn(async () => cached),
+                set: vi.fn(async () => { }),
+            },
+            init: vi.fn(async () => { }),
+            browser: null,
+            config: {},
+            userAgent: 'ua',
+            applyAntiDetection: vi.fn(async () => { }),
+        };
+        const result = await collectInnerImpl(ctx, {
+            url: 'https://example.com',
+        });
+        expect(result).toBe(cached);
+        expect(ctx.init).not.toHaveBeenCalled();
+    });
+    it('throws when initialization completes without a browser instance', async () => {
+        const ctx = {
+            cacheEnabled: false,
+            cache: {
+                get: vi.fn(async () => null),
+                set: vi.fn(async () => { }),
+            },
+            init: vi.fn(async () => { }),
+            browser: null,
+            config: {},
+            userAgent: 'ua',
+            applyAntiDetection: vi.fn(async () => { }),
+        };
+        await expect(collectInnerImpl(ctx, {
+            url: 'https://example.com',
+        })).rejects.toThrow('Browser not initialized');
+    });
+    it('returns smart summary results and cleans up the page and cdp session', async () => {
+        const { page, session } = createPageAndSession();
+        const ctx = {
+            cacheEnabled: true,
+            cache: {
+                get: vi.fn(async () => null),
+                set: vi.fn(async () => { }),
+            },
+            init: vi.fn(async () => { }),
+            browser: {
+                newPage: vi.fn(async () => page),
+            },
+            config: { timeout: 5000 },
+            userAgent: 'ua',
+            applyAntiDetection: vi.fn(async () => { }),
+            cdpSession: null,
+            cdpListeners: {},
+            MAX_FILES_PER_COLLECT: 5,
+            MAX_SINGLE_FILE_SIZE: 1024,
+            collectedUrls: new Set(),
+            cleanupCollectedUrls: vi.fn(),
+            collectedFilesCache: new Map(),
+            smartCollector: {
+                smartCollect: vi.fn(async () => [
+                    {
+                        url: 'https://example.com/app.js',
+                        size: 10,
+                        type: 'external',
+                        hasEncryption: false,
+                        hasAPI: true,
+                        hasObfuscation: false,
+                        functions: [],
+                        imports: [],
+                        preview: 'code',
+                    },
+                ]),
+            },
+            compressor: {
+                shouldCompress: vi.fn(() => false),
+                compressBatch: vi.fn(async () => []),
+                getStats: vi.fn(() => ({
+                    totalOriginalSize: 0,
+                    totalCompressedSize: 0,
+                    averageRatio: 0,
+                    cacheHits: 0,
+                    cacheMisses: 0,
+                })),
+            },
+        };
+        const result = await collectInnerImpl(ctx, {
+            url: 'https://example.com',
+            smartMode: 'summary',
+        });
+        expect(result).toEqual({
+            files: [],
+            summaries: [
+                expect.objectContaining({
+                    url: 'https://example.com/app.js',
+                    hasAPI: true,
+                }),
+            ],
+            dependencies: { nodes: [], edges: [] },
+            totalSize: 0,
+            collectTime: expect.any(Number),
+        });
+        expect(session.detach).toHaveBeenCalled();
+        expect(page.close).toHaveBeenCalled();
+    });
+});

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

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

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

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi, beforeEach } 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 { collectPageMetadataImpl, getPerformanceMetricsImpl, navigateWithRetryImpl, shouldCollectUrlImpl, } from '../../../src/modules/collector/CodeCollectorUtilsInternal.js';
+describe('CodeCollector utils internals', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('matches urls against wildcard filter rules', () => {
+        expect(shouldCollectUrlImpl('https://example.com/app.js', ['*app.js'])).toBe(true);
+        expect(shouldCollectUrlImpl('https://example.com/app.css', ['*app.js'])).toBe(false);
+        expect(shouldCollectUrlImpl('https://example.com/any', [])).toBe(true);
+    });
+    it('retries navigation until it succeeds', async () => {
+        vi.useFakeTimers();
+        const goto = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('first fail'))
+            .mockResolvedValueOnce(undefined);
+        const navigation = navigateWithRetryImpl({ goto }, 'https://example.com', {}, 2);
+        await vi.advanceTimersByTimeAsync(1000);
+        await navigation;
+        expect(goto).toHaveBeenCalledTimes(2);
+        vi.useRealTimers();
+    });
+    it('collects performance metrics and page metadata with empty-object fallbacks', async () => {
+        const page = {
+            evaluate: vi.fn().mockResolvedValueOnce({ totalTime: 120 }).mockResolvedValueOnce({
+                title: 'Example',
+                url: 'https://example.com',
+            }),
+        };
+        await expect(getPerformanceMetricsImpl(page)).resolves.toEqual({ totalTime: 120 });
+        await expect(collectPageMetadataImpl(page)).resolves.toEqual({
+            title: 'Example',
+            url: 'https://example.com',
+        });
+        page.evaluate = vi.fn().mockRejectedValue(new Error('boom'));
+        await expect(getPerformanceMetricsImpl(page)).resolves.toEqual({});
+        await expect(collectPageMetadataImpl(page)).resolves.toEqual({});
+    });
+});

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

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

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

@@ -0,0 +1,309 @@
+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

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

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

@@ -0,0 +1,84 @@
+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

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