@jshookmcp/jshook 0.1.8 → 0.2.0

package/dist/tests/utils/RingBuffer.test.js

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { RingBuffer } from '../../src/utils/RingBuffer.js';
+describe('RingBuffer', () => {
+    it('starts empty and shift on empty returns undefined', () => {
+        const buffer = new RingBuffer(3);
+        expect(buffer.length).toBe(0);
+        expect(buffer.shift()).toBeUndefined();
+    });
+    it('preserves FIFO order for basic push/shift', () => {
+        const buffer = new RingBuffer(3);
+        buffer.push(1);
+        buffer.push(2);
+        buffer.push(3);
+        expect(buffer.toArray()).toEqual([1, 2, 3]);
+        expect(buffer.shift()).toBe(1);
+        expect(buffer.shift()).toBe(2);
+        expect(buffer.length).toBe(1);
+    });
+    it('overwrites oldest item when full at fixed capacity', () => {
+        const buffer = new RingBuffer(3);
+        buffer.push(1);
+        buffer.push(2);
+        buffer.push(3);
+        buffer.push(4);
+        expect(buffer.length).toBe(3);
+        expect(buffer.toArray()).toEqual([2, 3, 4]);
+    });
+    it('supports iterator and map based on logical order', () => {
+        const buffer = new RingBuffer(3);
+        buffer.push(10);
+        buffer.push(20);
+        buffer.push(30);
+        buffer.push(40);
+        expect([...buffer]).toEqual([20, 30, 40]);
+        expect(buffer.map((value, index) => `${index}:${value}`)).toEqual(['0:20', '1:30', '2:40']);
+    });
+    it('clear resets internal state and allows grow path for large capacity', () => {
+        const buffer = new RingBuffer(128);
+        buffer.push(1);
+        buffer.push(2);
+        buffer.clear();
+        expect(buffer.length).toBe(0);
+        for (let i = 0; i < 70; i++) {
+            buffer.push(i);
+        }
+        expect(buffer.length).toBe(70);
+        expect(buffer.toArray()[0]).toBe(0);
+        expect(buffer.toArray()[69]).toBe(69);
+    });
+});

package/dist/tests/utils/TokenBudgetManager.test.d.ts

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

package/dist/tests/utils/TokenBudgetManager.test.js

@@ -0,0 +1,75 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { TokenBudgetManager } from '../../src/utils/TokenBudgetManager.js';
+describe('TokenBudgetManager', () => {
+    beforeEach(() => {
+        const manager = TokenBudgetManager.getInstance();
+        manager.reset();
+        manager.setTrackingEnabled(true);
+        vi.restoreAllMocks();
+    });
+    it('returns singleton instance', () => {
+        const a = TokenBudgetManager.getInstance();
+        const b = TokenBudgetManager.getInstance();
+        expect(a).toBe(b);
+    });
+    it('supports direct construction (DI pattern)', () => {
+        const a = new TokenBudgetManager();
+        const b = new TokenBudgetManager();
+        expect(a).not.toBe(b);
+    });
+    it('records tool calls and aggregates stats', () => {
+        const manager = TokenBudgetManager.getInstance();
+        manager.recordToolCall('page_evaluate', { x: 1 }, { ok: true });
+        manager.recordToolCall('page_evaluate', { x: 2 }, { ok: true });
+        const stats = manager.getStats();
+        expect(stats.toolCallCount).toBe(2);
+        expect(stats.currentUsage).toBeGreaterThan(0);
+        expect(stats.topTools[0]?.tool).toBe('page_evaluate');
+    });
+    it('does not track when tracking is disabled', () => {
+        const manager = TokenBudgetManager.getInstance();
+        manager.setTrackingEnabled(false);
+        manager.recordToolCall('collect_code', { x: 1 }, { y: 2 });
+        const stats = manager.getStats();
+        expect(stats.toolCallCount).toBe(0);
+        expect(stats.currentUsage).toBe(0);
+    });
+    it('handles circular structures without throwing', () => {
+        const manager = TokenBudgetManager.getInstance();
+        const circular = { name: 'root' };
+        circular.self = circular;
+        expect(() => manager.recordToolCall('detect_obfuscation', circular, { ok: true })).not.toThrow();
+        expect(manager.getStats().toolCallCount).toBe(1);
+    });
+    it('triggers auto cleanup via external callback on high usage', () => {
+        const manager = TokenBudgetManager.getInstance();
+        const cleanupFn = vi.fn();
+        manager.setExternalCleanup(cleanupFn);
+        const largeRef = { detailId: 'detail_x', summary: { size: 262_144 } };
+        manager.recordToolCall('network_get_requests', largeRef, largeRef);
+        manager.recordToolCall('network_get_requests', largeRef, largeRef);
+        expect(cleanupFn).toHaveBeenCalled();
+        expect(manager.getStats().warnings.some((w) => w >= 90)).toBe(true);
+    });
+    it('manual cleanup removes old call history and recalculates usage', () => {
+        const manager = TokenBudgetManager.getInstance();
+        const cleanupFn = vi.fn();
+        manager.setExternalCleanup(cleanupFn);
+        const now = Date.now();
+        manager.toolCallHistory = [
+            {
+                toolName: 'old_call',
+                timestamp: now - 10 * 60 * 1000,
+                requestSize: 100,
+                responseSize: 100,
+                estimatedTokens: 50,
+                cumulativeTokens: 50,
+            },
+        ];
+        manager.currentUsage = 50;
+        manager.manualCleanup();
+        expect(cleanupFn).toHaveBeenCalledTimes(1);
+        expect(manager.getStats().toolCallCount).toBe(0);
+        expect(manager.getStats().currentUsage).toBe(0);
+    });
+});

package/dist/tests/utils/UnifiedCacheManager.test.d.ts

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

package/dist/tests/utils/UnifiedCacheManager.test.js

@@ -0,0 +1,114 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { UnifiedCacheManager } from '../../src/utils/UnifiedCacheManager.js';
+function mb(value) {
+    return value * 1024 * 1024;
+}
+describe('UnifiedCacheManager', () => {
+    afterEach(() => {
+        UnifiedCacheManager.instance = undefined;
+        vi.restoreAllMocks();
+    });
+    it('returns singleton instance', () => {
+        const first = UnifiedCacheManager.getInstance();
+        const second = UnifiedCacheManager.getInstance();
+        expect(first).toBe(second);
+    });
+    it('aggregates global stats and ignores failing cache stats', async () => {
+        const manager = UnifiedCacheManager.getInstance();
+        const okCache = {
+            name: 'ok-cache',
+            getStats: vi.fn(async () => ({
+                entries: 3,
+                size: 300,
+                hits: 9,
+                misses: 1,
+                hitRate: 0.9,
+            })),
+        };
+        const badCache = {
+            name: 'bad-cache',
+            getStats: vi.fn(async () => {
+                throw new Error('boom');
+            }),
+        };
+        manager.registerCache(okCache);
+        manager.registerCache(badCache);
+        const stats = await manager.getGlobalStats();
+        expect(stats.totalEntries).toBe(3);
+        expect(stats.totalSize).toBe(300);
+        expect(stats.hitRate).toBeCloseTo(0.9);
+        expect(stats.caches.map((cache) => cache.name)).toEqual(['ok-cache']);
+    });
+    it('generates critical size and low hit-rate recommendations', async () => {
+        const manager = UnifiedCacheManager.getInstance();
+        manager.registerCache({
+            name: 'big-cache',
+            getStats: vi.fn(async () => ({
+                entries: 1,
+                size: mb(460),
+                hits: 1,
+                misses: 20,
+                hitRate: 0.05,
+            })),
+        });
+        const stats = await manager.getGlobalStats();
+        expect(stats.recommendations.some((item) => item.includes('CRITICAL'))).toBe(true);
+        expect(stats.recommendations.some((item) => item.includes('Low cache hit rate'))).toBe(true);
+    });
+    it('returns no-op cleanup result when under target', async () => {
+        const manager = UnifiedCacheManager.getInstance();
+        manager.registerCache({
+            name: 'small',
+            getStats: vi.fn(async () => ({ entries: 1, size: mb(5), hits: 9, misses: 1, hitRate: 0.9 })),
+            clear: vi.fn(async () => undefined),
+            cleanup: vi.fn(async () => undefined),
+        });
+        const result = await manager.smartCleanup(mb(10));
+        expect(result.freed).toBe(0);
+        expect(result.before).toBe(result.after);
+    });
+    it('smart cleanup clears low hit-rate cache when over target', async () => {
+        const manager = UnifiedCacheManager.getInstance();
+        const highCacheState = { size: mb(220), entries: 2, hits: 80, misses: 20, hitRate: 0.8 };
+        const lowCacheState = { size: mb(220), entries: 2, hits: 2, misses: 18, hitRate: 0.1 };
+        const lowClear = vi.fn(async () => {
+            lowCacheState.size = 0;
+            lowCacheState.entries = 0;
+            lowCacheState.hits = 0;
+            lowCacheState.misses = 0;
+            lowCacheState.hitRate = 0;
+        });
+        manager.registerCache({
+            name: 'high-cache',
+            getStats: vi.fn(async () => ({ ...highCacheState })),
+        });
+        manager.registerCache({
+            name: 'low-cache',
+            getStats: vi.fn(async () => ({ ...lowCacheState })),
+            clear: lowClear,
+        });
+        const result = await manager.smartCleanup(mb(250));
+        expect(lowClear).toHaveBeenCalled();
+        expect(result.after).toBeLessThanOrEqual(mb(250));
+    });
+    it('clearAll invokes clear on each cache and tolerates errors', async () => {
+        const manager = UnifiedCacheManager.getInstance();
+        const clearA = vi.fn(async () => undefined);
+        const clearB = vi.fn(async () => {
+            throw new Error('fail');
+        });
+        manager.registerCache({
+            name: 'a',
+            getStats: vi.fn(async () => ({ entries: 0, size: 0 })),
+            clear: clearA,
+        });
+        manager.registerCache({
+            name: 'b',
+            getStats: vi.fn(async () => ({ entries: 0, size: 0 })),
+            clear: clearB,
+        });
+        await expect(manager.clearAll()).resolves.toBeUndefined();
+        expect(clearA).toHaveBeenCalledOnce();
+        expect(clearB).toHaveBeenCalledOnce();
+    });
+});

package/dist/tests/utils/WorkerPool.test.d.ts

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

package/dist/tests/utils/WorkerPool.test.js

@@ -0,0 +1,143 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+const workerState = vi.hoisted(() => {
+    class WorkerMock {
+        script;
+        options;
+        listeners = new Map();
+        postMessage = vi.fn();
+        terminate = vi.fn(async () => 0);
+        removeAllListeners = vi.fn((event) => {
+            if (event) {
+                this.listeners.delete(event);
+            }
+            else {
+                this.listeners.clear();
+            }
+            return this;
+        });
+        constructor(script, options) {
+            this.script = script;
+            this.options = options;
+        }
+        on(event, callback) {
+            const callbacks = this.listeners.get(event) ?? [];
+            callbacks.push(callback);
+            this.listeners.set(event, callbacks);
+            return this;
+        }
+        emit(event, payload) {
+            const callbacks = this.listeners.get(event) ?? [];
+            callbacks.forEach((callback) => callback(payload));
+        }
+    }
+    return {
+        instances: [],
+        WorkerMock,
+    };
+});
+vi.mock('node:worker_threads', () => {
+    class WorkerCtor {
+        inner;
+        postMessage;
+        terminate;
+        removeAllListeners;
+        constructor(script, options) {
+            this.inner = new workerState.WorkerMock(script, options);
+            workerState.instances.push(this.inner);
+            this.postMessage = this.inner.postMessage;
+            this.terminate = this.inner.terminate;
+            this.removeAllListeners = this.inner.removeAllListeners;
+        }
+        on(event, callback) {
+            this.inner.on(event, callback);
+            return this;
+        }
+    }
+    return {
+        Worker: WorkerCtor,
+    };
+});
+import { WorkerPool } from '../../src/utils/WorkerPool.js';
+describe('WorkerPool', () => {
+    beforeEach(() => {
+        workerState.instances.length = 0;
+        vi.useFakeTimers();
+    });
+    afterEach(async () => {
+        vi.useRealTimers();
+        vi.restoreAllMocks();
+    });
+    it('validates constructor options', () => {
+        expect(() => new WorkerPool({ workerScript: '   ' })).toThrow('workerScript');
+        expect(() => new WorkerPool({ workerScript: 'x', minWorkers: 3, maxWorkers: 2 })).toThrow('minWorkers cannot be greater than maxWorkers');
+        expect(() => new WorkerPool({ workerScript: 'x', maxWorkers: 0 })).toThrow('maxWorkers');
+    });
+    it('spawns minimum workers on creation', async () => {
+        const pool = new WorkerPool({
+            workerScript: 'mock-script',
+            minWorkers: 2,
+            maxWorkers: 2,
+        });
+        expect(workerState.instances).toHaveLength(2);
+        await pool.close();
+    });
+    it('executes jobs and resolves on successful worker message', async () => {
+        const pool = new WorkerPool({
+            workerScript: 'mock-script',
+            minWorkers: 1,
+            maxWorkers: 1,
+        });
+        const worker = workerState.instances[0];
+        const task = pool.submit({ value: 7 });
+        expect(worker.postMessage).toHaveBeenCalledWith({ jobId: 1, payload: { value: 7 } });
+        worker.emit('message', { jobId: 1, ok: true, result: 99 });
+        await expect(task).resolves.toBe(99);
+        expect(worker.terminate).not.toHaveBeenCalled();
+        await pool.close();
+        expect(worker.terminate).toHaveBeenCalled();
+    });
+    it('rejects on worker timeout and terminates worker', async () => {
+        const pool = new WorkerPool({
+            workerScript: 'mock-script',
+            minWorkers: 0,
+            maxWorkers: 1,
+        });
+        const task = pool.submit({ value: 1 }, 10);
+        const worker = workerState.instances[0];
+        vi.advanceTimersByTime(11);
+        await expect(task).rejects.toThrow('timed out');
+        expect(worker.terminate).toHaveBeenCalled();
+        await pool.close();
+    });
+    it('queues jobs when max workers are busy', async () => {
+        const pool = new WorkerPool({
+            workerScript: 'mock-script',
+            minWorkers: 1,
+            maxWorkers: 1,
+        });
+        const worker = workerState.instances[0];
+        const first = pool.submit({ value: 1 });
+        const second = pool.submit({ value: 2 });
+        expect(worker.postMessage).toHaveBeenCalledTimes(1);
+        expect(worker.postMessage).toHaveBeenNthCalledWith(1, { jobId: 1, payload: { value: 1 } });
+        worker.emit('message', { jobId: 1, ok: true, result: 10 });
+        await expect(first).resolves.toBe(10);
+        expect(worker.postMessage).toHaveBeenCalledTimes(2);
+        expect(worker.postMessage).toHaveBeenNthCalledWith(2, { jobId: 2, payload: { value: 2 } });
+        worker.emit('message', { jobId: 2, ok: true, result: 20 });
+        await expect(second).resolves.toBe(20);
+        await pool.close();
+    });
+    it('rejects active and queued jobs when closed', async () => {
+        const pool = new WorkerPool({
+            workerScript: 'mock-script',
+            minWorkers: 1,
+            maxWorkers: 1,
+        });
+        const first = pool.submit({ value: 1 });
+        const second = pool.submit({ value: 2 });
+        await pool.close();
+        await expect(first).rejects.toThrow('pool is closed');
+        await expect(second).rejects.toThrow('pool is closed');
+    });
+});

package/dist/tests/utils/artifactRetention.test.d.ts

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

package/dist/tests/utils/artifactRetention.test.js

@@ -0,0 +1,50 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { cleanupArtifacts } from '../../src/utils/artifactRetention.js';
+describe('artifactRetention', () => {
+    let root;
+    beforeEach(async () => {
+        root = await mkdtemp(join(tmpdir(), 'jshook-artifacts-'));
+        await mkdir(join(root, 'artifacts', 'har'), { recursive: true });
+        await mkdir(join(root, 'screenshots', 'manual'), { recursive: true });
+        await mkdir(join(root, 'debugger-sessions'), { recursive: true });
+    });
+    afterEach(async () => {
+        await rm(root, { recursive: true, force: true });
+    });
+    it('removes files older than retention window', async () => {
+        const oldFile = join(root, 'artifacts', 'har', 'old.har');
+        await writeFile(oldFile, 'old');
+        const oldTime = new Date('2024-01-01T00:00:00.000Z');
+        await import('node:fs/promises').then(({ utimes }) => utimes(oldFile, oldTime, oldTime));
+        const result = await cleanupArtifacts({
+            retentionDays: 1,
+            dryRun: false,
+            now: new Date('2024-01-10T00:00:00.000Z').getTime(),
+            directories: [join(root, 'artifacts'), join(root, 'screenshots'), join(root, 'debugger-sessions')],
+        });
+        expect(result.removedFiles).toBe(1);
+        expect(result.removedByAge).toBeGreaterThan(0);
+    });
+    it('trims oldest files when size cap is exceeded', async () => {
+        const older = join(root, 'screenshots', 'manual', 'older.png');
+        const newer = join(root, 'screenshots', 'manual', 'newer.png');
+        await writeFile(older, '1234567890');
+        await writeFile(newer, 'abcdefghij');
+        const oldTime = new Date('2024-01-01T00:00:00.000Z');
+        const newTime = new Date('2024-01-02T00:00:00.000Z');
+        const { utimes } = await import('node:fs/promises');
+        await utimes(older, oldTime, oldTime);
+        await utimes(newer, newTime, newTime);
+        const result = await cleanupArtifacts({
+            maxTotalBytes: 10,
+            dryRun: false,
+            directories: [join(root, 'artifacts'), join(root, 'screenshots'), join(root, 'debugger-sessions')],
+        });
+        expect(result.removedFiles).toBe(1);
+        expect(result.removedBySize).toBeGreaterThan(0);
+        expect(result.remainingBytes).toBeLessThanOrEqual(10);
+    });
+});

package/dist/tests/utils/artifacts.test.d.ts

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

package/dist/tests/utils/artifacts.test.js

@@ -0,0 +1,76 @@
+import { resolve } from 'node:path';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const ROOT = resolve('virtual-project-root');
+vi.mock('node:fs/promises', () => ({
+    mkdir: vi.fn(async () => undefined),
+}));
+vi.mock('@src/utils/outputPaths', () => ({
+    getProjectRoot: vi.fn(() => ROOT),
+}));
+import { mkdir } from 'node:fs/promises';
+import { getArtifactDir, getArtifactsRoot, resolveArtifactPath } from '../../src/utils/artifacts.js';
+describe('artifacts utils', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-03-04T05:06:07.000Z'));
+        vi.spyOn(Math, 'random').mockReturnValue(0.123456789);
+    });
+    it('resolves category path and creates directory', async () => {
+        const result = await resolveArtifactPath({
+            category: 'har',
+            toolName: 'network export',
+            target: 'user?id=1',
+            ext: 'json',
+        });
+        expect(result.absolutePath).toContain(resolve(ROOT, 'artifacts', 'har'));
+        expect(result.displayPath).toMatch(/^artifacts\/har\//);
+        expect(result.displayPath).toContain('network_export-user_id_1');
+        expect(mkdir).toHaveBeenCalledWith(resolve(ROOT, 'artifacts', 'har'), { recursive: true });
+    });
+    it('normalizes extensions with leading dot', async () => {
+        const result = await resolveArtifactPath({
+            category: 'reports',
+            toolName: 'reporter',
+            ext: '.md',
+        });
+        expect(result.absolutePath.endsWith('.md')).toBe(true);
+        expect(result.absolutePath.includes('..md')).toBe(false);
+    });
+    it('uses custom directory when inside project root', async () => {
+        const result = await resolveArtifactPath({
+            category: 'tmp',
+            toolName: 'worker',
+            ext: 'txt',
+            customDir: 'custom/out',
+        });
+        expect(result.absolutePath).toContain(resolve(ROOT, 'custom', 'out'));
+        expect(result.displayPath.startsWith('custom/out/')).toBe(true);
+        expect(mkdir).toHaveBeenCalledWith(resolve(ROOT, 'custom', 'out'), { recursive: true });
+    });
+    it('blocks path traversal for custom directory outside project', async () => {
+        await expect(resolveArtifactPath({
+            category: 'tmp',
+            toolName: 'worker',
+            ext: 'txt',
+            customDir: '../escape',
+        })).rejects.toThrow('Path traversal blocked');
+    });
+    it('trims and sanitizes long file name parts', async () => {
+        const result = await resolveArtifactPath({
+            category: 'dumps',
+            toolName: '***very long tool name***'.repeat(8),
+            target: '///target///',
+            ext: 'bin',
+        });
+        const filename = result.displayPath.split('/').pop() ?? '';
+        const baseWithoutExt = filename.replace(/\.bin$/, '');
+        const [toolPart] = baseWithoutExt.split('-');
+        expect(toolPart.length).toBeLessThanOrEqual(60);
+        expect(filename).not.toContain('*');
+        expect(filename).toContain('target');
+    });
+    it('returns artifact root helpers', () => {
+        expect(getArtifactsRoot()).toBe(resolve(ROOT, 'artifacts'));
+        expect(getArtifactDir('wasm')).toBe(resolve(ROOT, 'artifacts', 'wasm'));
+    });
+});

package/dist/tests/utils/browserExecutable.test.d.ts

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

package/dist/tests/utils/browserExecutable.test.js

@@ -0,0 +1,69 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const existsSyncMock = vi.fn();
+const executablePathMock = vi.fn();
+vi.mock('fs', () => ({
+    existsSync: (...args) => existsSyncMock(...args),
+}));
+vi.mock('rebrowser-puppeteer-core', () => ({
+    default: {
+        executablePath: (...args) => executablePathMock(...args),
+    },
+}));
+async function loadModule() {
+    return import('../../src/utils/browserExecutable.js');
+}
+describe('browserExecutable utils', () => {
+    beforeEach(async () => {
+        vi.resetModules();
+        vi.clearAllMocks();
+        delete process.env.PUPPETEER_EXECUTABLE_PATH;
+        delete process.env.BROWSER_EXECUTABLE_PATH;
+    });
+    it('resolves from BROWSER_EXECUTABLE_PATH when file exists', async () => {
+        process.env.BROWSER_EXECUTABLE_PATH = '/browser-bin';
+        existsSyncMock.mockImplementation((p) => p === '/browser-bin');
+        const { findBrowserExecutable } = await loadModule();
+        expect(findBrowserExecutable()).toBe('/browser-bin');
+    });
+    it('falls back to puppeteer executable path when env missing', async () => {
+        executablePathMock.mockReturnValue('/managed-browser-bin');
+        existsSyncMock.mockImplementation((p) => p === '/managed-browser-bin');
+        const { findBrowserExecutable } = await loadModule();
+        expect(findBrowserExecutable()).toBe('/managed-browser-bin');
+    });
+    it('returns undefined when no executable is available', async () => {
+        executablePathMock.mockReturnValue('/none');
+        existsSyncMock.mockReturnValue(false);
+        const { findBrowserExecutable } = await loadModule();
+        expect(findBrowserExecutable()).toBeUndefined();
+    });
+    it('uses cache on repeated calls', async () => {
+        process.env.BROWSER_EXECUTABLE_PATH = '/cached-browser';
+        existsSyncMock.mockImplementation((p) => p === '/cached-browser');
+        const { findBrowserExecutable } = await loadModule();
+        expect(findBrowserExecutable()).toBe('/cached-browser');
+        expect(findBrowserExecutable()).toBe('/cached-browser');
+        expect(existsSyncMock).toHaveBeenCalledTimes(2);
+    });
+    it('clearBrowserPathCache forces re-resolution', async () => {
+        process.env.BROWSER_EXECUTABLE_PATH = '/first-browser';
+        existsSyncMock.mockImplementation((p) => p === '/first-browser' || p === '/second-browser');
+        const mod = await loadModule();
+        expect(mod.findBrowserExecutable()).toBe('/first-browser');
+        process.env.BROWSER_EXECUTABLE_PATH = '/second-browser';
+        mod.clearBrowserPathCache();
+        expect(mod.findBrowserExecutable()).toBe('/second-browser');
+    });
+    it('re-resolves when cached path no longer exists', async () => {
+        process.env.BROWSER_EXECUTABLE_PATH = '/stale-browser';
+        executablePathMock.mockReturnValue('/fresh-browser');
+        existsSyncMock
+            .mockReturnValueOnce(true)
+            .mockReturnValueOnce(false)
+            .mockReturnValueOnce(false)
+            .mockReturnValueOnce(true);
+        const mod = await loadModule();
+        expect(mod.findBrowserExecutable()).toBe('/stale-browser');
+        expect(mod.findBrowserExecutable()).toBe('/fresh-browser');
+    });
+});

package/dist/tests/utils/cache.test.d.ts

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