@jshookmcp/jshook 0.1.9 → 0.2.1

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

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

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

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

@@ -0,0 +1,68 @@
+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 { clearBreakpointHitCallbacksCore, getBreakpointHitCallbackCountCore, handleBreakpointResolvedCore, handlePausedCore, handleResumedCore, offBreakpointHitCore, onBreakpointHitCore, } from '../../../src/modules/debugger/DebuggerManager.impl.core.events.js';
+describe('DebuggerManager event core helpers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('registers callbacks and dispatches breakpoint hit events with variables', async () => {
+        const callback = vi.fn();
+        let resolvedState;
+        const ctx = {
+            breakpointHitCallbacks: new Set(),
+            breakpoints: new Map([['bp-1', { breakpointId: 'bp-1', hitCount: 0 }]]),
+            pausedState: null,
+            pausedResolvers: [(state) => (resolvedState = state)],
+            getScopeVariables: vi.fn(async () => ({
+                variables: [{ name: 'token', value: 'abc', type: 'string' }],
+            })),
+        };
+        onBreakpointHitCore(ctx, callback);
+        expect(getBreakpointHitCallbackCountCore(ctx)).toBe(1);
+        await handlePausedCore(ctx, {
+            reason: 'other',
+            hitBreakpoints: ['bp-1'],
+            callFrames: [
+                {
+                    callFrameId: 'cf-1',
+                    functionName: 'main',
+                    location: { scriptId: 'script-1', lineNumber: 10, columnNumber: 1 },
+                    url: 'https://example.com/app.js',
+                    scopeChain: [],
+                    this: {},
+                },
+            ],
+        });
+        expect(ctx.breakpoints.get('bp-1')?.hitCount).toBe(1);
+        expect(callback).toHaveBeenCalledWith(expect.objectContaining({
+            breakpointId: 'bp-1',
+            variables: [{ name: 'token', value: 'abc', type: 'string' }],
+        }));
+        expect(resolvedState.reason).toBe('other');
+        expect(ctx.pausedResolvers).toEqual([]);
+    });
+    it('supports unregistering callbacks and clearing paused state', () => {
+        const callback = vi.fn();
+        const ctx = {
+            breakpointHitCallbacks: new Set([callback]),
+            breakpoints: new Map(),
+            pausedState: { reason: 'other' },
+            pausedResolvers: [],
+            getScopeVariables: vi.fn(),
+        };
+        offBreakpointHitCore(ctx, callback);
+        expect(getBreakpointHitCallbackCountCore(ctx)).toBe(0);
+        clearBreakpointHitCallbacksCore(ctx);
+        handleResumedCore(ctx);
+        handleBreakpointResolvedCore(ctx, { breakpointId: 'missing' });
+        expect(ctx.pausedState).toBeNull();
+    });
+});

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

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

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

@@ -0,0 +1,79 @@
+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 { evaluateOnCallFrameCore, getPauseOnExceptionsStateCore, getPausedStateCore, isPausedCore, pauseCore, resumeCore, setPauseOnExceptionsCore, stepIntoCore, stepOutCore, stepOverCore, waitForPausedCore, } from '../../../src/modules/debugger/DebuggerManager.impl.core.execution.js';
+describe('DebuggerManager execution core helpers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('updates pause-on-exception state and issues pause/resume/step commands', async () => {
+        const send = vi.fn(async () => ({}));
+        const ctx = {
+            enabled: true,
+            cdpSession: { send },
+            pauseOnExceptionsState: 'none',
+            pausedState: null,
+            pausedResolvers: [],
+        };
+        await setPauseOnExceptionsCore(ctx, 'all');
+        await pauseCore(ctx);
+        await resumeCore(ctx);
+        await stepIntoCore(ctx);
+        await stepOverCore(ctx);
+        await stepOutCore(ctx);
+        expect(getPauseOnExceptionsStateCore(ctx)).toBe('all');
+        expect(send).toHaveBeenCalledWith('Debugger.setPauseOnExceptions', { state: 'all' });
+        expect(send).toHaveBeenCalledWith('Debugger.pause');
+        expect(send).toHaveBeenCalledWith('Debugger.resume');
+        expect(send).toHaveBeenCalledWith('Debugger.stepInto');
+        expect(send).toHaveBeenCalledWith('Debugger.stepOver');
+        expect(send).toHaveBeenCalledWith('Debugger.stepOut');
+    });
+    it('reports pause state and evaluates expressions on a paused call frame', async () => {
+        const send = vi.fn(async (method) => method === 'Debugger.evaluateOnCallFrame' ? { result: { value: 42 } } : {});
+        const pausedState = {
+            reason: 'other',
+            callFrames: [{ callFrameId: 'cf-1' }],
+            timestamp: 1,
+        };
+        const ctx = {
+            enabled: true,
+            cdpSession: { send },
+            pauseOnExceptionsState: 'none',
+            pausedState,
+            pausedResolvers: [],
+        };
+        expect(getPausedStateCore(ctx)).toBe(pausedState);
+        expect(isPausedCore(ctx)).toBe(true);
+        await expect(waitForPausedCore(ctx, 5)).resolves.toBe(pausedState);
+        await expect(evaluateOnCallFrameCore(ctx, {
+            callFrameId: 'cf-1',
+            expression: '21 * 2',
+        })).resolves.toEqual({ value: 42 });
+    });
+    it('throws prerequisite errors when execution APIs are used without a debugger or pause state', async () => {
+        const ctx = {
+            enabled: false,
+            cdpSession: null,
+            pauseOnExceptionsState: 'none',
+            pausedState: null,
+            pausedResolvers: [],
+        };
+        await expect(pauseCore(ctx)).rejects.toBeInstanceOf(PrerequisiteError);
+        await expect(waitForPausedCore(ctx)).rejects.toBeInstanceOf(PrerequisiteError);
+        ctx.enabled = true;
+        ctx.cdpSession = { send: vi.fn(async () => ({})) };
+        await expect(evaluateOnCallFrameCore(ctx, {
+            callFrameId: 'cf-1',
+            expression: 'x',
+        })).rejects.toBeInstanceOf(PrerequisiteError);
+    });
+});

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

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

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

@@ -0,0 +1,96 @@
+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 { getObjectPropertiesByIdCore, getObjectPropertiesCore, getScopeVariablesCore, } from '../../../src/modules/debugger/DebuggerManager.impl.core.scope.js';
+describe('DebuggerManager scope core helpers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('collects scope variables and optional nested object properties for the active frame', async () => {
+        const send = vi
+            .fn()
+            .mockResolvedValueOnce({
+            result: [
+                {
+                    name: 'user',
+                    value: { type: 'object', objectId: 'obj-2', description: 'Object' },
+                    writable: true,
+                    configurable: true,
+                    enumerable: true,
+                },
+                {
+                    name: 'count',
+                    value: { type: 'number', value: 3 },
+                    writable: true,
+                    configurable: true,
+                    enumerable: true,
+                },
+            ],
+        })
+            .mockResolvedValueOnce({
+            result: [{ name: 'name', value: { type: 'string', value: 'alice' } }],
+        });
+        const ctx = {
+            enabled: true,
+            cdpSession: { send },
+            pausedState: {
+                callFrames: [
+                    {
+                        callFrameId: 'cf-1',
+                        functionName: 'main',
+                        url: 'https://example.com/app.js',
+                        location: { lineNumber: 10, columnNumber: 2 },
+                        scopeChain: [{ type: 'local', object: { objectId: 'obj-1' } }],
+                    },
+                ],
+            },
+        };
+        const result = await getScopeVariablesCore(ctx, {
+            includeObjectProperties: true,
+            maxDepth: 2,
+        });
+        expect(result.success).toBe(true);
+        expect(result.variables).toEqual(expect.arrayContaining([
+            expect.objectContaining({ name: 'user', type: 'object', scope: 'local' }),
+            expect.objectContaining({ name: 'user.name', value: 'alice', scope: 'local' }),
+            expect.objectContaining({ name: 'count', value: 3, type: 'number' }),
+        ]));
+        expect(result.successfulScopes).toBe(1);
+    });
+    it('maps expired object handles to a stable reacquire message', async () => {
+        const ctx = {
+            enabled: true,
+            cdpSession: {
+                send: vi.fn(async () => {
+                    throw new Error('Could not find object with given id');
+                }),
+            },
+            pausedState: null,
+        };
+        await expect(getObjectPropertiesByIdCore(ctx, 'obj-expired')).rejects.toThrow('Object handle is expired or invalid');
+    });
+    it('returns safe defaults for nested properties and enforces debugger prerequisites', async () => {
+        const ctx = {
+            enabled: false,
+            cdpSession: null,
+            pausedState: null,
+        };
+        await expect(getScopeVariablesCore(ctx)).rejects.toBeInstanceOf(PrerequisiteError);
+        expect(await getObjectPropertiesCore(ctx, 'obj-1', 0)).toEqual([]);
+        ctx.enabled = true;
+        ctx.cdpSession = {
+            send: vi.fn(async () => {
+                throw new Error('boom');
+            }),
+        };
+        expect(await getObjectPropertiesCore(ctx, 'obj-1', 1)).toEqual([]);
+    });
+});

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

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

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

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

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

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

package/dist/tests/modules/debugger/DebuggerManager.impl.exports.test.js

@@ -0,0 +1,50 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const exportMocks = vi.hoisted(() => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+    watchManager: vi.fn(),
+    xhrManager: vi.fn(),
+    eventManager: vi.fn(),
+    blackboxManager: vi.fn(),
+    sessionManager: vi.fn(),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: exportMocks.logger,
+}));
+vi.mock('@modules/debugger/WatchExpressionManager', () => ({
+    WatchExpressionManager: exportMocks.watchManager,
+}));
+vi.mock('@modules/debugger/XHRBreakpointManager', () => ({
+    XHRBreakpointManager: exportMocks.xhrManager,
+}));
+vi.mock('@modules/debugger/EventBreakpointManager', () => ({
+    EventBreakpointManager: exportMocks.eventManager,
+}));
+vi.mock('@modules/debugger/BlackboxManager', () => ({
+    BlackboxManager: exportMocks.blackboxManager,
+}));
+vi.mock('@modules/debugger/DebuggerSessionManager', () => ({
+    DebuggerSessionManager: exportMocks.sessionManager,
+}));
+import { DebuggerManager as DebuggerManagerImpl } from '../../../src/modules/debugger/DebuggerManager.impl.js';
+import { DebuggerManager as DebuggerManagerCore } from '../../../src/modules/debugger/DebuggerManager.impl.core.js';
+import { DebuggerManager as DebuggerManagerClass } from '../../../src/modules/debugger/DebuggerManager.impl.core.class.js';
+import { ScriptManager as ScriptManagerImpl } from '../../../src/modules/debugger/ScriptManager.impl.js';
+import { ScriptManager as ScriptManagerClass } from '../../../src/modules/debugger/ScriptManager.impl.class.js';
+describe('debugger internal barrel exports', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('re-exports DebuggerManager through impl barrels', () => {
+        expect(DebuggerManagerImpl).toBe(DebuggerManagerCore);
+        expect(DebuggerManagerCore).toBe(DebuggerManagerClass);
+    });
+    it('re-exports ScriptManager through impl barrel', () => {
+        expect(ScriptManagerImpl).toBe(ScriptManagerClass);
+    });
+});

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

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

package/dist/tests/modules/debugger/DebuggerManager.impl.reexports.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import { DebuggerManager as ImplDebuggerManager } from '../../../src/modules/debugger/DebuggerManager.impl.js';
+import { DebuggerManager as CoreDebuggerManager } from '../../../src/modules/debugger/DebuggerManager.impl.core.js';
+import { DebuggerManager as PublicDebuggerManager } from '../../../src/modules/debugger/DebuggerManager.js';
+import { ScriptManager as ImplScriptManager } from '../../../src/modules/debugger/ScriptManager.impl.js';
+import { ScriptManager as ClassScriptManager } from '../../../src/modules/debugger/ScriptManager.impl.class.js';
+import { ScriptManager as PublicScriptManager } from '../../../src/modules/debugger/ScriptManager.js';
+describe('Debugger internal re-exports', () => {
+    it('re-exports debugger and script manager classes through internal wrapper files', () => {
+        expect(ImplDebuggerManager).toBe(CoreDebuggerManager);
+        expect(PublicDebuggerManager).toBe(CoreDebuggerManager);
+        expect(ImplScriptManager).toBe(ClassScriptManager);
+        expect(PublicScriptManager).toBe(ClassScriptManager);
+    });
+});

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

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

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

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

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

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