@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/domains/browser/page-interaction.test.js

@@ -3,77 +3,352 @@ import { PageInteractionHandlers } from '../../../../src/server/domains/browser/
 function parseJson(response) {
     return JSON.parse(response.content[0].text);
 }
-describe('PageInteractionHandlers', () => {
+function createCamoufoxPage() {
+    return {
+        click: vi.fn(async () => { }),
+        fill: vi.fn(async () => { }),
+        hover: vi.fn(async () => { }),
+        selectOption: vi.fn(async () => ['primary']),
+        evaluate: vi.fn(async () => undefined),
+        keyboard: {
+            press: vi.fn(async () => { }),
+        },
+    };
+}
+function createPageController(overrides = {}) {
+    return {
+        click: vi.fn(async () => { }),
+        type: vi.fn(async () => { }),
+        select: vi.fn(async () => { }),
+        hover: vi.fn(async () => { }),
+        scroll: vi.fn(async () => { }),
+        pressKey: vi.fn(async () => { }),
+        ...overrides,
+    };
+}
+describe('PageInteractionHandlers – handlePageClick', () => {
+    let handlers;
+    let pageController;
     beforeEach(() => {
         vi.clearAllMocks();
+        pageController = createPageController();
+        handlers = new PageInteractionHandlers({
+            pageController,
+            getActiveDriver: () => 'chrome',
+            getCamoufoxPage: async () => null,
+        });
+    });
+    it('clicks an element with default options', async () => {
+        const body = parseJson(await handlers.handlePageClick({ selector: '#btn' }));
+        expect(pageController.click).toHaveBeenCalledWith('#btn', {
+            button: 'left',
+            clickCount: 1,
+            delay: undefined,
+        });
+        expect(body.success).toBe(true);
+        expect(body.message).toContain('#btn');
+    });
+    it('passes button, clickCount, delay options', async () => {
+        const body = parseJson(await handlers.handlePageClick({
+            selector: '.item',
+            button: 'right',
+            clickCount: 2,
+            delay: 100,
+        }));
+        expect(pageController.click).toHaveBeenCalledWith('.item', {
+            button: 'right',
+            clickCount: 2,
+            delay: 100,
+        });
+        expect(body.success).toBe(true);
+    });
+    it('returns error when selector is empty', async () => {
+        const body = parseJson(await handlers.handlePageClick({ selector: '' }));
+        expect(body.success).toBe(false);
+        expect(body.message).toContain('selector parameter is required');
+    });
+    it('returns error when selector is whitespace-only', async () => {
+        const body = parseJson(await handlers.handlePageClick({ selector: '   ' }));
+        expect(body.success).toBe(false);
+    });
+    it('returns error when selector is missing', async () => {
+        const body = parseJson(await handlers.handlePageClick({}));
+        expect(body.success).toBe(false);
+    });
+    it('treats navigation-triggering click errors as success', async () => {
+        pageController.click.mockRejectedValueOnce(new Error('Execution context was destroyed'));
+        const body = parseJson(await handlers.handlePageClick({ selector: '#nav-link' }));
+        expect(body.success).toBe(true);
+        expect(body.navigated).toBe(true);
+    });
+    it('treats "detached" error as navigation success', async () => {
+        pageController.click.mockRejectedValueOnce(new Error('Node is detached from document'));
+        const body = parseJson(await handlers.handlePageClick({ selector: '.link' }));
+        expect(body.success).toBe(true);
+        expect(body.navigated).toBe(true);
+    });
+    it('treats "timed out" error as navigation success', async () => {
+        pageController.click.mockRejectedValueOnce(new Error('waiting for selector timed out'));
+        const body = parseJson(await handlers.handlePageClick({ selector: '.link' }));
+        expect(body.success).toBe(true);
+        expect(body.navigated).toBe(true);
+    });
+    it('treats "Target closed" error as navigation success', async () => {
+        pageController.click.mockRejectedValueOnce(new Error('Target closed'));
+        const body = parseJson(await handlers.handlePageClick({ selector: '.link' }));
+        expect(body.success).toBe(true);
+        expect(body.navigated).toBe(true);
+    });
+    it('treats "callFunctionOn" error as navigation success', async () => {
+        pageController.click.mockRejectedValueOnce(new Error('callFunctionOn failed'));
+        const body = parseJson(await handlers.handlePageClick({ selector: '.link' }));
+        expect(body.success).toBe(true);
+        expect(body.navigated).toBe(true);
+    });
+    it('re-throws non-navigation errors', async () => {
+        pageController.click.mockRejectedValueOnce(new Error('Element not visible'));
+        await expect(handlers.handlePageClick({ selector: '#hidden' })).rejects.toThrow('Element not visible');
+    });
+    it('clicks on camoufox driver', async () => {
+        const camoPage = createCamoufoxPage();
+        handlers = new PageInteractionHandlers({
+            pageController,
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => camoPage,
+        });
+        const body = parseJson(await handlers.handlePageClick({ selector: '#btn' }));
+        expect(camoPage.click).toHaveBeenCalledWith('#btn', {
+            button: 'left',
+            clickCount: 1,
+            delay: undefined,
+        });
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+    });
+    it('parses button value case-insensitively', async () => {
+        await handlers.handlePageClick({ selector: '#x', button: 'RIGHT' });
+        expect(pageController.click).toHaveBeenCalledWith('#x', {
+            button: 'right',
+            clickCount: 1,
+            delay: undefined,
+        });
+    });
+    it('defaults invalid button to left', async () => {
+        await handlers.handlePageClick({ selector: '#x', button: 'invalid' });
+        expect(pageController.click).toHaveBeenCalledWith('#x', {
+            button: 'left',
+            clickCount: 1,
+            delay: undefined,
+        });
+    });
+    it('clamps clickCount to min 1', async () => {
+        await handlers.handlePageClick({ selector: '#x', clickCount: -5 });
+        expect(pageController.click).toHaveBeenCalledWith('#x', expect.objectContaining({ clickCount: 1 }));
+    });
+    it('clamps clickCount to max 10', async () => {
+        await handlers.handlePageClick({ selector: '#x', clickCount: 100 });
+        expect(pageController.click).toHaveBeenCalledWith('#x', expect.objectContaining({ clickCount: 10 }));
+    });
+    it('parses string clickCount', async () => {
+        await handlers.handlePageClick({ selector: '#x', clickCount: '3' });
+        expect(pageController.click).toHaveBeenCalledWith('#x', expect.objectContaining({ clickCount: 3 }));
+    });
+    it('clamps delay to min 0', async () => {
+        await handlers.handlePageClick({ selector: '#x', delay: -100 });
+        expect(pageController.click).toHaveBeenCalledWith('#x', expect.objectContaining({ delay: 0 }));
+    });
+    it('clamps delay to max 60000', async () => {
+        await handlers.handlePageClick({ selector: '#x', delay: 999999 });
+        expect(pageController.click).toHaveBeenCalledWith('#x', expect.objectContaining({ delay: 60000 }));
+    });
+    it('truncates clickCount to integer', async () => {
+        await handlers.handlePageClick({ selector: '#x', clickCount: 2.7 });
+        expect(pageController.click).toHaveBeenCalledWith('#x', expect.objectContaining({ clickCount: 2 }));
+    });
+    it('truncates delay to integer', async () => {
+        await handlers.handlePageClick({ selector: '#x', delay: 50.9 });
+        expect(pageController.click).toHaveBeenCalledWith('#x', expect.objectContaining({ delay: 50 }));
+    });
+});
+describe('PageInteractionHandlers – handlePageType', () => {
+    let handlers;
+    let pageController;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        pageController = createPageController();
+        handlers = new PageInteractionHandlers({
+            pageController,
+            getActiveDriver: () => 'chrome',
+            getCamoufoxPage: async () => null,
+        });
+    });
+    it('types into a selector on chrome', async () => {
+        const body = parseJson(await handlers.handlePageType({
+            selector: '#input',
+            text: 'hello',
+            delay: 50,
+        }));
+        expect(pageController.type).toHaveBeenCalledWith('#input', 'hello', {
+            delay: 50,
+        });
+        expect(body.success).toBe(true);
+        expect(body.message).toContain('#input');
     });
-    function createCamoufoxPage() {
-        return {
-            click: vi.fn(async () => { }),
-            fill: vi.fn(async () => { }),
-            hover: vi.fn(async () => { }),
-            selectOption: vi.fn(async () => ['primary']),
-            evaluate: vi.fn(async () => undefined),
-            keyboard: {
-                press: vi.fn(async () => { }),
-            },
-        };
-    }
-    it('routes page_select to camoufox when camoufox is active', async () => {
-        const page = createCamoufoxPage();
-        const pageController = { select: vi.fn() };
-        const handlers = new PageInteractionHandlers({
+    it('types on camoufox using fill', async () => {
+        const camoPage = createCamoufoxPage();
+        handlers = new PageInteractionHandlers({
             pageController,
             getActiveDriver: () => 'camoufox',
-            getCamoufoxPage: async () => page,
+            getCamoufoxPage: async () => camoPage,
         });
-        const body = parseJson(await handlers.handlePageSelect({ selector: '#plan', values: ['primary'] }));
-        expect(page.selectOption).toHaveBeenCalledWith('#plan', ['primary']);
-        expect(pageController.select).not.toHaveBeenCalled();
+        const body = parseJson(await handlers.handlePageType({ selector: '#email', text: 'test@a.com' }));
+        expect(camoPage.fill).toHaveBeenCalledWith('#email', 'test@a.com');
+        expect(pageController.type).not.toHaveBeenCalled();
         expect(body.success).toBe(true);
         expect(body.driver).toBe('camoufox');
     });
-    it('routes page_hover to camoufox when camoufox is active', async () => {
-        const page = createCamoufoxPage();
-        const pageController = { hover: vi.fn() };
-        const handlers = new PageInteractionHandlers({
+});
+describe('PageInteractionHandlers – handlePageSelect', () => {
+    let handlers;
+    let pageController;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        pageController = createPageController();
+        handlers = new PageInteractionHandlers({
+            pageController,
+            getActiveDriver: () => 'chrome',
+            getCamoufoxPage: async () => null,
+        });
+    });
+    it('selects options on chrome', async () => {
+        const body = parseJson(await handlers.handlePageSelect({
+            selector: '#dropdown',
+            values: ['opt1', 'opt2'],
+        }));
+        expect(pageController.select).toHaveBeenCalledWith('#dropdown', 'opt1', 'opt2');
+        expect(body.success).toBe(true);
+        expect(body.message).toContain('#dropdown');
+        expect(body.message).toContain('opt1');
+    });
+    it('selects on camoufox using selectOption', async () => {
+        const camoPage = createCamoufoxPage();
+        handlers = new PageInteractionHandlers({
             pageController,
             getActiveDriver: () => 'camoufox',
-            getCamoufoxPage: async () => page,
+            getCamoufoxPage: async () => camoPage,
         });
+        const body = parseJson(await handlers.handlePageSelect({
+            selector: '#plan',
+            values: ['premium'],
+        }));
+        expect(camoPage.selectOption).toHaveBeenCalledWith('#plan', ['premium']);
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+    });
+});
+describe('PageInteractionHandlers – handlePageHover', () => {
+    let handlers;
+    let pageController;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        pageController = createPageController();
+        handlers = new PageInteractionHandlers({
+            pageController,
+            getActiveDriver: () => 'chrome',
+            getCamoufoxPage: async () => null,
+        });
+    });
+    it('hovers on chrome', async () => {
         const body = parseJson(await handlers.handlePageHover({ selector: '#menu' }));
-        expect(page.hover).toHaveBeenCalledWith('#menu');
-        expect(pageController.hover).not.toHaveBeenCalled();
+        expect(pageController.hover).toHaveBeenCalledWith('#menu');
+        expect(body.success).toBe(true);
+        expect(body.message).toContain('#menu');
+    });
+    it('hovers on camoufox', async () => {
+        const camoPage = createCamoufoxPage();
+        handlers = new PageInteractionHandlers({
+            pageController,
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => camoPage,
+        });
+        const body = parseJson(await handlers.handlePageHover({ selector: '.tooltip' }));
+        expect(camoPage.hover).toHaveBeenCalledWith('.tooltip');
         expect(body.success).toBe(true);
         expect(body.driver).toBe('camoufox');
     });
-    it('routes page_scroll to camoufox when camoufox is active', async () => {
-        const page = createCamoufoxPage();
-        const pageController = { scroll: vi.fn() };
-        const handlers = new PageInteractionHandlers({
+});
+describe('PageInteractionHandlers – handlePageScroll', () => {
+    let handlers;
+    let pageController;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        pageController = createPageController();
+        handlers = new PageInteractionHandlers({
+            pageController,
+            getActiveDriver: () => 'chrome',
+            getCamoufoxPage: async () => null,
+        });
+    });
+    it('scrolls on chrome', async () => {
+        const body = parseJson(await handlers.handlePageScroll({ x: 0, y: 500 }));
+        expect(pageController.scroll).toHaveBeenCalledWith({ x: 0, y: 500 });
+        expect(body.success).toBe(true);
+        expect(body.message).toContain('y=500');
+    });
+    it('scrolls on camoufox via page.evaluate', async () => {
+        const camoPage = createCamoufoxPage();
+        handlers = new PageInteractionHandlers({
             pageController,
             getActiveDriver: () => 'camoufox',
-            getCamoufoxPage: async () => page,
+            getCamoufoxPage: async () => camoPage,
+        });
+        const body = parseJson(await handlers.handlePageScroll({ x: 10, y: 200 }));
+        expect(camoPage.evaluate).toHaveBeenCalledTimes(1);
+        expect(camoPage.evaluate.mock.calls[0]?.[1]).toEqual({
+            x: 10,
+            y: 200,
         });
-        const body = parseJson(await handlers.handlePageScroll({ x: 10, y: 20 }));
-        expect(page.evaluate).toHaveBeenCalledTimes(1);
-        expect(page.evaluate.mock.calls[0]?.[1]).toEqual({ x: 10, y: 20 });
         expect(pageController.scroll).not.toHaveBeenCalled();
         expect(body.success).toBe(true);
         expect(body.driver).toBe('camoufox');
     });
-    it('routes page_press_key to camoufox keyboard when camoufox is active', async () => {
-        const page = createCamoufoxPage();
-        const pageController = { pressKey: vi.fn() };
-        const handlers = new PageInteractionHandlers({
+    it('defaults missing coordinates to 0', async () => {
+        const body = parseJson(await handlers.handlePageScroll({}));
+        expect(body.success).toBe(true);
+        expect(body.message).toContain('x=0');
+        expect(body.message).toContain('y=0');
+    });
+});
+describe('PageInteractionHandlers – handlePagePressKey', () => {
+    let handlers;
+    let pageController;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        pageController = createPageController();
+        handlers = new PageInteractionHandlers({
             pageController,
-            getActiveDriver: () => 'camoufox',
-            getCamoufoxPage: async () => page,
+            getActiveDriver: () => 'chrome',
+            getCamoufoxPage: async () => null,
         });
+    });
+    it('presses a key on chrome', async () => {
         const body = parseJson(await handlers.handlePagePressKey({ key: 'Enter' }));
-        expect(page.keyboard.press).toHaveBeenCalledWith('Enter');
+        expect(pageController.pressKey).toHaveBeenCalledWith('Enter');
+        expect(body.success).toBe(true);
+        expect(body.key).toBe('Enter');
+    });
+    it('presses a key on camoufox', async () => {
+        const camoPage = createCamoufoxPage();
+        handlers = new PageInteractionHandlers({
+            pageController,
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => camoPage,
+        });
+        const body = parseJson(await handlers.handlePagePressKey({ key: 'Escape' }));
+        expect(camoPage.keyboard.press).toHaveBeenCalledWith('Escape');
         expect(pageController.pressKey).not.toHaveBeenCalled();
         expect(body.success).toBe(true);
         expect(body.driver).toBe('camoufox');
+        expect(body.key).toBe('Escape');
     });
 });

package/dist/tests/server/domains/browser/page-navigation-additional.test.d.ts

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

package/dist/tests/server/domains/browser/page-navigation-additional.test.js

@@ -0,0 +1,193 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { PageNavigationHandlers } from '../../../../src/server/domains/browser/handlers/page-navigation.js';
+function parseJson(response) {
+    const text = response.content[0]?.text ?? '';
+    return JSON.parse(text);
+}
+function mockDeps(driver = 'chrome') {
+    const gotoMock = vi.fn().mockResolvedValue(undefined);
+    const camoufoxReloadMock = vi.fn().mockResolvedValue(undefined);
+    const camoufoxGoBackMock = vi.fn().mockResolvedValue(undefined);
+    const camoufoxGoForwardMock = vi.fn().mockResolvedValue(undefined);
+    const camoufoxUrlMock = vi
+        .fn()
+        .mockReturnValue('https://example.com/page');
+    const camoufoxTitleMock = vi.fn().mockResolvedValue('Example');
+    const camoufoxPage = {
+        goto: gotoMock,
+        reload: camoufoxReloadMock,
+        goBack: camoufoxGoBackMock,
+        goForward: camoufoxGoForwardMock,
+        url: camoufoxUrlMock,
+        title: camoufoxTitleMock,
+    };
+    const navigateMock = vi.fn().mockResolvedValue({
+        url: 'https://example.com/chrome',
+        title: 'Chrome Page',
+        loadTime: 0,
+    });
+    const reloadMock = vi.fn().mockResolvedValue(undefined);
+    const goBackMock = vi.fn().mockResolvedValue(undefined);
+    const goForwardMock = vi.fn().mockResolvedValue(undefined);
+    const getURLMock = vi
+        .fn()
+        .mockResolvedValue('https://example.com/chrome');
+    const getTitleMock = vi.fn().mockResolvedValue('Chrome Page');
+    const pageController = {
+        navigate: navigateMock,
+        reload: reloadMock,
+        goBack: goBackMock,
+        goForward: goForwardMock,
+        getURL: getURLMock,
+        getTitle: getTitleMock,
+    };
+    const setPlaywrightPageMock = vi
+        .fn()
+        .mockImplementation(() => undefined);
+    const enableMock = vi.fn().mockResolvedValue(undefined);
+    const isNetworkEnabledMock = vi
+        .fn()
+        .mockReturnValue(false);
+    const consoleMonitor = {
+        setPlaywrightPage: setPlaywrightPageMock,
+        enable: enableMock,
+        isNetworkEnabled: isNetworkEnabledMock,
+    };
+    const deps = {
+        pageController: pageController,
+        consoleMonitor: consoleMonitor,
+        getActiveDriver: vi.fn().mockReturnValue(driver),
+        getCamoufoxPage: vi.fn().mockResolvedValue(camoufoxPage),
+    };
+    return {
+        deps,
+        camoufoxPage,
+        pageController,
+        consoleMonitor,
+    };
+}
+describe('PageNavigationHandlers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('handlePageNavigate', () => {
+        it('navigates via chrome driver', async () => {
+            const { deps, pageController } = mockDeps('chrome');
+            const handler = new PageNavigationHandlers(deps);
+            const result = await handler.handlePageNavigate({ url: 'https://test.com' });
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.url).toBe('https://example.com/chrome');
+            expect(body.title).toBe('Chrome Page');
+            expect(pageController.navigate).toHaveBeenCalledWith('https://test.com', expect.objectContaining({ waitUntil: 'networkidle2' }));
+        });
+        it('navigates via camoufox driver', async () => {
+            const { deps, camoufoxPage, consoleMonitor } = mockDeps('camoufox');
+            const handler = new PageNavigationHandlers(deps);
+            const result = await handler.handlePageNavigate({
+                url: 'https://test.com',
+                waitUntil: 'networkidle2',
+                timeout: 5000,
+            });
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.driver).toBe('camoufox');
+            expect(camoufoxPage.goto).toHaveBeenCalledWith('https://test.com', {
+                waitUntil: 'networkidle',
+                timeout: 5000,
+            });
+            expect(consoleMonitor.setPlaywrightPage).toHaveBeenCalledWith(camoufoxPage);
+        });
+        it('enables network monitoring on camoufox', async () => {
+            const { deps, consoleMonitor } = mockDeps('camoufox');
+            const handler = new PageNavigationHandlers(deps);
+            await handler.handlePageNavigate({
+                url: 'https://test.com',
+                enableNetworkMonitoring: true,
+            });
+            expect(consoleMonitor.enable).toHaveBeenCalledWith({
+                enableNetwork: true,
+                enableExceptions: true,
+            });
+        });
+        it('enables network monitoring on chrome', async () => {
+            const { deps, consoleMonitor } = mockDeps('chrome');
+            const handler = new PageNavigationHandlers(deps);
+            await handler.handlePageNavigate({
+                url: 'https://test.com',
+                enableNetworkMonitoring: true,
+            });
+            expect(consoleMonitor.enable).toHaveBeenCalledWith({
+                enableNetwork: true,
+                enableExceptions: true,
+            });
+        });
+        it('maps "commit" waitUntil to "load" for chrome', async () => {
+            const { deps, pageController } = mockDeps('chrome');
+            const handler = new PageNavigationHandlers(deps);
+            await handler.handlePageNavigate({ url: 'https://test.com', waitUntil: 'commit' });
+            expect(pageController.navigate).toHaveBeenCalledWith('https://test.com', expect.objectContaining({ waitUntil: 'load' }));
+        });
+    });
+    describe('handlePageReload', () => {
+        it('reloads via chrome driver', async () => {
+            const { deps, pageController } = mockDeps('chrome');
+            const handler = new PageNavigationHandlers(deps);
+            const result = await handler.handlePageReload({});
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.message).toBe('Page reloaded');
+            expect(pageController.reload).toHaveBeenCalled();
+        });
+        it('reloads via camoufox driver', async () => {
+            const { deps, camoufoxPage } = mockDeps('camoufox');
+            const handler = new PageNavigationHandlers(deps);
+            const result = await handler.handlePageReload({});
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.driver).toBe('camoufox');
+            expect(camoufoxPage.reload).toHaveBeenCalled();
+        });
+    });
+    describe('handlePageBack', () => {
+        it('goes back via chrome driver', async () => {
+            const { deps, pageController } = mockDeps('chrome');
+            const handler = new PageNavigationHandlers(deps);
+            const result = await handler.handlePageBack({});
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.url).toBe('https://example.com/chrome');
+            expect(pageController.goBack).toHaveBeenCalled();
+        });
+        it('goes back via camoufox driver', async () => {
+            const { deps, camoufoxPage } = mockDeps('camoufox');
+            const handler = new PageNavigationHandlers(deps);
+            const result = await handler.handlePageBack({});
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.driver).toBe('camoufox');
+            expect(body.url).toBe('https://example.com/page');
+            expect(camoufoxPage.goBack).toHaveBeenCalled();
+        });
+    });
+    describe('handlePageForward', () => {
+        it('goes forward via chrome driver', async () => {
+            const { deps, pageController } = mockDeps('chrome');
+            const handler = new PageNavigationHandlers(deps);
+            const result = await handler.handlePageForward({});
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.url).toBe('https://example.com/chrome');
+            expect(pageController.goForward).toHaveBeenCalled();
+        });
+        it('goes forward via camoufox driver', async () => {
+            const { deps, camoufoxPage } = mockDeps('camoufox');
+            const handler = new PageNavigationHandlers(deps);
+            const result = await handler.handlePageForward({});
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.driver).toBe('camoufox');
+            expect(camoufoxPage.goForward).toHaveBeenCalled();
+        });
+    });
+});

package/dist/tests/server/domains/browser/page-navigation.additional.test.d.ts

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