@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/modules/emulator/chrome-env.test.js

@@ -0,0 +1,384 @@
+import { describe, expect, it } from 'vitest';
+import { chromeEnvironmentTemplate, getChromeEnvironment, } from '../../../src/modules/emulator/templates/chrome-env.js';
+describe('chromeEnvironmentTemplate', () => {
+    describe('window properties', () => {
+        it('has standard window dimensions', () => {
+            expect(chromeEnvironmentTemplate.window.innerWidth).toBe(1920);
+            expect(chromeEnvironmentTemplate.window.innerHeight).toBe(1080);
+            expect(chromeEnvironmentTemplate.window.outerWidth).toBe(1920);
+            expect(chromeEnvironmentTemplate.window.outerHeight).toBe(1080);
+        });
+        it('has default screen position at origin', () => {
+            expect(chromeEnvironmentTemplate.window.screenX).toBe(0);
+            expect(chromeEnvironmentTemplate.window.screenY).toBe(0);
+            expect(chromeEnvironmentTemplate.window.screenLeft).toBe(0);
+            expect(chromeEnvironmentTemplate.window.screenTop).toBe(0);
+        });
+        it('has expected default state values', () => {
+            expect(chromeEnvironmentTemplate.window.devicePixelRatio).toBe(1);
+            expect(chromeEnvironmentTemplate.window.name).toBe('');
+            expect(chromeEnvironmentTemplate.window.closed).toBe(false);
+            expect(chromeEnvironmentTemplate.window.length).toBe(0);
+            expect(chromeEnvironmentTemplate.window.opener).toBeNull();
+            expect(chromeEnvironmentTemplate.window.parent).toBeNull();
+            expect(chromeEnvironmentTemplate.window.top).toBeNull();
+            expect(chromeEnvironmentTemplate.window.self).toBeNull();
+            expect(chromeEnvironmentTemplate.window.frameElement).toBeNull();
+            expect(chromeEnvironmentTemplate.window.frames).toEqual([]);
+        });
+    });
+    describe('navigator properties', () => {
+        it('contains a Chrome user agent string', () => {
+            expect(chromeEnvironmentTemplate.navigator.userAgent).toContain('Chrome/');
+            expect(chromeEnvironmentTemplate.navigator.userAgent).toContain('Mozilla/5.0');
+        });
+        it('identifies as Win32 platform from Google', () => {
+            expect(chromeEnvironmentTemplate.navigator.platform).toBe('Win32');
+            expect(chromeEnvironmentTemplate.navigator.vendor).toBe('Google Inc.');
+        });
+        it('has expected browser capability values', () => {
+            expect(chromeEnvironmentTemplate.navigator.onLine).toBe(true);
+            expect(chromeEnvironmentTemplate.navigator.cookieEnabled).toBe(true);
+            expect(chromeEnvironmentTemplate.navigator.webdriver).toBe(false);
+            expect(chromeEnvironmentTemplate.navigator.maxTouchPoints).toBe(0);
+            expect(chromeEnvironmentTemplate.navigator.pdfViewerEnabled).toBe(true);
+        });
+        it('reports hardware capabilities', () => {
+            expect(chromeEnvironmentTemplate.navigator.hardwareConcurrency).toBe(8);
+            expect(chromeEnvironmentTemplate.navigator.deviceMemory).toBe(8);
+        });
+        it('has correct legacy browser identification', () => {
+            expect(chromeEnvironmentTemplate.navigator.product).toBe('Gecko');
+            expect(chromeEnvironmentTemplate.navigator.productSub).toBe('20030107');
+            expect(chromeEnvironmentTemplate.navigator.vendorSub).toBe('');
+            expect(chromeEnvironmentTemplate.navigator.appName).toBe('Netscape');
+            expect(chromeEnvironmentTemplate.navigator.appCodeName).toBe('Mozilla');
+        });
+        it('has language preferences', () => {
+            expect(chromeEnvironmentTemplate.navigator.language).toBe('zh-CN');
+            expect(chromeEnvironmentTemplate.navigator.languages).toEqual([
+                'zh-CN',
+                'zh',
+                'en-US',
+                'en',
+            ]);
+        });
+    });
+    describe('screen properties', () => {
+        it('matches window dimensions for full screen', () => {
+            expect(chromeEnvironmentTemplate.screen.width).toBe(1920);
+            expect(chromeEnvironmentTemplate.screen.height).toBe(1080);
+            expect(chromeEnvironmentTemplate.screen.availWidth).toBe(1920);
+        });
+        it('has taskbar-adjusted availHeight', () => {
+            expect(chromeEnvironmentTemplate.screen.availHeight).toBe(1040);
+            expect(chromeEnvironmentTemplate.screen.availHeight).toBeLessThan(chromeEnvironmentTemplate.screen.height);
+        });
+        it('has 24-bit color depth', () => {
+            expect(chromeEnvironmentTemplate.screen.colorDepth).toBe(24);
+            expect(chromeEnvironmentTemplate.screen.pixelDepth).toBe(24);
+        });
+        it('has landscape-primary orientation', () => {
+            expect(chromeEnvironmentTemplate.screen.orientation.type).toBe('landscape-primary');
+            expect(chromeEnvironmentTemplate.screen.orientation.angle).toBe(0);
+        });
+    });
+    describe('location properties', () => {
+        it('has a consistent example.com URL', () => {
+            expect(chromeEnvironmentTemplate.location.href).toBe('https://www.example.com/');
+            expect(chromeEnvironmentTemplate.location.origin).toBe('https://www.example.com');
+            expect(chromeEnvironmentTemplate.location.protocol).toBe('https:');
+            expect(chromeEnvironmentTemplate.location.host).toBe('www.example.com');
+            expect(chromeEnvironmentTemplate.location.hostname).toBe('www.example.com');
+            expect(chromeEnvironmentTemplate.location.pathname).toBe('/');
+        });
+        it('has empty port, search and hash', () => {
+            expect(chromeEnvironmentTemplate.location.port).toBe('');
+            expect(chromeEnvironmentTemplate.location.search).toBe('');
+            expect(chromeEnvironmentTemplate.location.hash).toBe('');
+        });
+    });
+    describe('document properties', () => {
+        it('has complete readyState and valid encoding', () => {
+            expect(chromeEnvironmentTemplate.document.readyState).toBe('complete');
+            expect(chromeEnvironmentTemplate.document.characterSet).toBe('UTF-8');
+            expect(chromeEnvironmentTemplate.document.charset).toBe('UTF-8');
+            expect(chromeEnvironmentTemplate.document.inputEncoding).toBe('UTF-8');
+        });
+        it('has html content type', () => {
+            expect(chromeEnvironmentTemplate.document.contentType).toBe('text/html');
+        });
+        it('matches location URL', () => {
+            expect(chromeEnvironmentTemplate.document.URL).toBe(chromeEnvironmentTemplate.location.href);
+            expect(chromeEnvironmentTemplate.document.domain).toBe(chromeEnvironmentTemplate.location.hostname);
+        });
+        it('is visible and not hidden', () => {
+            expect(chromeEnvironmentTemplate.document.hidden).toBe(false);
+            expect(chromeEnvironmentTemplate.document.visibilityState).toBe('visible');
+        });
+        it('has empty referrer and cookie', () => {
+            expect(chromeEnvironmentTemplate.document.referrer).toBe('');
+            expect(chromeEnvironmentTemplate.document.cookie).toBe('');
+        });
+    });
+    describe('performance properties', () => {
+        it('has numeric timeOrigin', () => {
+            expect(typeof chromeEnvironmentTemplate.performance.timeOrigin).toBe('number');
+            expect(chromeEnvironmentTemplate.performance.timeOrigin).toBeGreaterThan(0);
+        });
+        it('has all standard timing properties', () => {
+            const timing = chromeEnvironmentTemplate.performance.timing;
+            const expectedKeys = [
+                'navigationStart',
+                'fetchStart',
+                'domainLookupStart',
+                'domainLookupEnd',
+                'connectStart',
+                'connectEnd',
+                'secureConnectionStart',
+                'requestStart',
+                'responseStart',
+                'responseEnd',
+                'domLoading',
+                'domInteractive',
+                'domContentLoadedEventStart',
+                'domContentLoadedEventEnd',
+                'domComplete',
+                'loadEventStart',
+                'loadEventEnd',
+            ];
+            for (const key of expectedKeys) {
+                expect(timing).toHaveProperty(key);
+                expect(typeof timing[key]).toBe('number');
+            }
+        });
+        it('has zero values for unload and redirect timings', () => {
+            expect(chromeEnvironmentTemplate.performance.timing.unloadEventStart).toBe(0);
+            expect(chromeEnvironmentTemplate.performance.timing.unloadEventEnd).toBe(0);
+            expect(chromeEnvironmentTemplate.performance.timing.redirectStart).toBe(0);
+            expect(chromeEnvironmentTemplate.performance.timing.redirectEnd).toBe(0);
+        });
+    });
+    describe('history properties', () => {
+        it('has initial history state', () => {
+            expect(chromeEnvironmentTemplate.history.length).toBe(1);
+            expect(chromeEnvironmentTemplate.history.scrollRestoration).toBe('auto');
+            expect(chromeEnvironmentTemplate.history.state).toBeNull();
+        });
+    });
+    describe('console methods', () => {
+        it('provides all standard console methods as no-ops', () => {
+            const consoleMethods = [
+                'log', 'warn', 'error', 'info', 'debug', 'trace',
+                'dir', 'dirxml', 'table', 'group', 'groupCollapsed', 'groupEnd',
+                'clear', 'count', 'countReset', 'assert', 'time', 'timeEnd', 'timeLog',
+            ];
+            for (const method of consoleMethods) {
+                expect(typeof chromeEnvironmentTemplate.console[method]).toBe('function');
+                expect(() => chromeEnvironmentTemplate.console[method]()).not.toThrow();
+            }
+        });
+    });
+    describe('crypto', () => {
+        it('has subtle property', () => {
+            expect(chromeEnvironmentTemplate.crypto.subtle).toBeDefined();
+            expect(typeof chromeEnvironmentTemplate.crypto.subtle).toBe('object');
+        });
+        it('getRandomValues fills array with random bytes', () => {
+            const arr = new Uint8Array(16);
+            const result = chromeEnvironmentTemplate.crypto.getRandomValues(arr);
+            expect(result).toBe(arr);
+            expect(Array.from(arr).some((v) => v !== 0)).toBe(true);
+        });
+        it('getRandomValues fills values in range 0-255', () => {
+            const arr = new Uint8Array(100);
+            chromeEnvironmentTemplate.crypto.getRandomValues(arr);
+            for (const val of arr) {
+                expect(val).toBeGreaterThanOrEqual(0);
+                expect(val).toBeLessThan(256);
+            }
+        });
+    });
+    describe('globalFunctions', () => {
+        it('setTimeout and setInterval return 0', () => {
+            expect(chromeEnvironmentTemplate.globalFunctions.setTimeout(() => { }, 100)).toBe(0);
+            expect(chromeEnvironmentTemplate.globalFunctions.setInterval(() => { }, 100)).toBe(0);
+        });
+        it('clearTimeout and clearInterval do not throw', () => {
+            expect(() => chromeEnvironmentTemplate.globalFunctions.clearTimeout(1)).not.toThrow();
+            expect(() => chromeEnvironmentTemplate.globalFunctions.clearInterval(1)).not.toThrow();
+        });
+        it('requestAnimationFrame returns 0 and cancelAnimationFrame does not throw', () => {
+            expect(chromeEnvironmentTemplate.globalFunctions.requestAnimationFrame(() => { })).toBe(0);
+            expect(() => chromeEnvironmentTemplate.globalFunctions.cancelAnimationFrame(1)).not.toThrow();
+        });
+        it('atob decodes base64 correctly', () => {
+            expect(chromeEnvironmentTemplate.globalFunctions.atob('SGVsbG8=')).toBe('Hello');
+        });
+        it('btoa encodes to base64 correctly', () => {
+            expect(chromeEnvironmentTemplate.globalFunctions.btoa('Hello')).toBe('SGVsbG8=');
+        });
+        it('atob and btoa are inverses', () => {
+            const original = 'Test string 123!';
+            const encoded = chromeEnvironmentTemplate.globalFunctions.btoa(original);
+            const decoded = chromeEnvironmentTemplate.globalFunctions.atob(encoded);
+            expect(decoded).toBe(original);
+        });
+        it('fetch returns a resolved promise', async () => {
+            const result = await chromeEnvironmentTemplate.globalFunctions.fetch();
+            expect(result).toBeInstanceOf(Response);
+        });
+    });
+    describe('constructors', () => {
+        it('XMLHttpRequest has required methods', () => {
+            const xhr = new chromeEnvironmentTemplate.constructors.XMLHttpRequest();
+            expect(typeof xhr.open).toBe('function');
+            expect(typeof xhr.send).toBe('function');
+            expect(typeof xhr.setRequestHeader).toBe('function');
+            expect(typeof xhr.addEventListener).toBe('function');
+        });
+        it('WebSocket accepts url and has required methods', () => {
+            const ws = new chromeEnvironmentTemplate.constructors.WebSocket('ws://test');
+            expect(typeof ws.send).toBe('function');
+            expect(typeof ws.close).toBe('function');
+            expect(typeof ws.addEventListener).toBe('function');
+        });
+        it('FormData has all standard methods', () => {
+            const fd = new chromeEnvironmentTemplate.constructors.FormData();
+            expect(typeof fd.append).toBe('function');
+            expect(typeof fd.delete).toBe('function');
+            expect(typeof fd.get).toBe('function');
+            expect(typeof fd.getAll).toBe('function');
+            expect(typeof fd.has).toBe('function');
+            expect(typeof fd.set).toBe('function');
+        });
+        it('Headers has all standard methods', () => {
+            const headers = new chromeEnvironmentTemplate.constructors.Headers();
+            expect(typeof headers.append).toBe('function');
+            expect(typeof headers.delete).toBe('function');
+            expect(typeof headers.get).toBe('function');
+            expect(typeof headers.has).toBe('function');
+            expect(typeof headers.set).toBe('function');
+        });
+        it('URL and URLSearchParams can be instantiated', () => {
+            const url = new chromeEnvironmentTemplate.constructors.URL('https://test.com');
+            expect(url).toBeDefined();
+            const params = new chromeEnvironmentTemplate.constructors.URLSearchParams('a=1');
+            expect(params).toBeDefined();
+            expect(typeof params.append).toBe('function');
+            expect(typeof params.get).toBe('function');
+            expect(typeof params.has).toBe('function');
+        });
+        it('Blob and File can be instantiated', () => {
+            const blob = new chromeEnvironmentTemplate.constructors.Blob([], {});
+            expect(blob).toBeDefined();
+            const file = new chromeEnvironmentTemplate.constructors.File([], 'test.txt');
+            expect(file).toBeDefined();
+        });
+        it('Request and Response can be instantiated', () => {
+            const req = new chromeEnvironmentTemplate.constructors.Request('https://test.com');
+            expect(req).toBeDefined();
+            const res = new chromeEnvironmentTemplate.constructors.Response();
+            expect(res).toBeDefined();
+        });
+    });
+    describe('storage', () => {
+        it('localStorage has all standard methods', () => {
+            const ls = chromeEnvironmentTemplate.storage.localStorage;
+            expect(ls.length).toBe(0);
+            expect(typeof ls.clear).toBe('function');
+            expect(typeof ls.getItem).toBe('function');
+            expect(typeof ls.setItem).toBe('function');
+            expect(typeof ls.removeItem).toBe('function');
+            expect(typeof ls.key).toBe('function');
+        });
+        it('localStorage getItem returns null and key returns null', () => {
+            expect(chromeEnvironmentTemplate.storage.localStorage.getItem('any')).toBeNull();
+            expect(chromeEnvironmentTemplate.storage.localStorage.key(0)).toBeNull();
+        });
+        it('sessionStorage has all standard methods', () => {
+            const ss = chromeEnvironmentTemplate.storage.sessionStorage;
+            expect(ss.length).toBe(0);
+            expect(typeof ss.clear).toBe('function');
+            expect(typeof ss.getItem).toBe('function');
+            expect(typeof ss.setItem).toBe('function');
+            expect(typeof ss.removeItem).toBe('function');
+            expect(typeof ss.key).toBe('function');
+        });
+        it('sessionStorage getItem returns null', () => {
+            expect(chromeEnvironmentTemplate.storage.sessionStorage.getItem('x')).toBeNull();
+        });
+        it('storage mutation methods do not throw', () => {
+            expect(() => chromeEnvironmentTemplate.storage.localStorage.setItem('k', 'v')).not.toThrow();
+            expect(() => chromeEnvironmentTemplate.storage.localStorage.removeItem('k')).not.toThrow();
+            expect(() => chromeEnvironmentTemplate.storage.localStorage.clear()).not.toThrow();
+        });
+    });
+    describe('other (global constructors)', () => {
+        it('exports standard JavaScript globals', () => {
+            expect(chromeEnvironmentTemplate.other.JSON).toBe(JSON);
+            expect(chromeEnvironmentTemplate.other.Math).toBe(Math);
+            expect(chromeEnvironmentTemplate.other.Date).toBe(Date);
+            expect(chromeEnvironmentTemplate.other.Array).toBe(Array);
+            expect(chromeEnvironmentTemplate.other.Object).toBe(Object);
+            expect(chromeEnvironmentTemplate.other.String).toBe(String);
+            expect(chromeEnvironmentTemplate.other.Number).toBe(Number);
+            expect(chromeEnvironmentTemplate.other.Boolean).toBe(Boolean);
+            expect(chromeEnvironmentTemplate.other.RegExp).toBe(RegExp);
+            expect(chromeEnvironmentTemplate.other.Error).toBe(Error);
+            expect(chromeEnvironmentTemplate.other.Promise).toBe(Promise);
+            expect(chromeEnvironmentTemplate.other.Map).toBe(Map);
+            expect(chromeEnvironmentTemplate.other.Set).toBe(Set);
+            expect(chromeEnvironmentTemplate.other.WeakMap).toBe(WeakMap);
+            expect(chromeEnvironmentTemplate.other.WeakSet).toBe(WeakSet);
+            expect(chromeEnvironmentTemplate.other.Symbol).toBe(Symbol);
+            expect(chromeEnvironmentTemplate.other.Proxy).toBe(Proxy);
+            expect(chromeEnvironmentTemplate.other.Reflect).toBe(Reflect);
+        });
+    });
+});
+describe('getChromeEnvironment', () => {
+    it('returns a new object on every call (deep clone)', () => {
+        const env1 = getChromeEnvironment();
+        const env2 = getChromeEnvironment();
+        expect(env1).not.toBe(env2);
+        expect(env1).toEqual(env2);
+    });
+    it('mutations to the returned object do not affect the template', () => {
+        const env = getChromeEnvironment();
+        env['window'] = 'modified';
+        const fresh = getChromeEnvironment();
+        expect(typeof fresh['window']).toBe('object');
+    });
+    it('returns a Record<string, unknown>', () => {
+        const env = getChromeEnvironment();
+        expect(typeof env).toBe('object');
+        expect(env).not.toBeNull();
+    });
+    it('contains expected top-level keys from the template', () => {
+        const env = getChromeEnvironment();
+        const expectedKeys = [
+            'window',
+            'navigator',
+            'screen',
+            'location',
+            'document',
+            'performance',
+            'history',
+        ];
+        for (const key of expectedKeys) {
+            expect(env).toHaveProperty(key);
+        }
+    });
+    it('does not include non-serializable properties (functions, classes)', () => {
+        const env = getChromeEnvironment();
+        const console = env['console'];
+        if (console) {
+            for (const key of Object.keys(console)) {
+                expect(typeof console[key]).not.toBe('function');
+            }
+        }
+        expect(env['globalFunctions']).toBeDefined();
+        expect(env['constructors']).toBeDefined();
+    });
+});

package/dist/tests/modules/entry-and-barrels.test.d.ts

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

package/dist/tests/modules/entry-and-barrels.test.js

@@ -0,0 +1,213 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('@server/MCPServer', () => ({
+    MCPServer: vi.fn(),
+}));
+vi.mock('@utils/config', () => ({
+    getConfig: vi.fn(),
+    validateConfig: vi.fn(() => ({ valid: true, errors: [] })),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+vi.mock('@server/registry/index', () => ({
+    initRegistry: vi.fn(async () => { }),
+}));
+vi.mock('@utils/artifactRetention', () => ({
+    cleanupArtifacts: vi.fn(async () => ({ removedFiles: 0, removedBytes: 0 })),
+    getArtifactRetentionConfig: vi.fn(() => ({
+        enabled: false,
+        cleanupOnStart: false,
+        retentionDays: 7,
+    })),
+    startArtifactRetentionScheduler: vi.fn(() => () => { }),
+}));
+import { resolveCliFastPath } from '../../src/utils/cliFastPath.js';
+describe('resolveCliFastPath', () => {
+    const fakeModuleUrl = 'file:///fake/src/index.ts';
+    it('returns handled=false for no arguments', () => {
+        const result = resolveCliFastPath([], fakeModuleUrl);
+        expect(result.handled).toBe(false);
+        expect(result.exitCode).toBe(0);
+    });
+    it('returns handled=true for --help', () => {
+        const result = resolveCliFastPath(['--help'], fakeModuleUrl);
+        expect(result.handled).toBe(true);
+        expect(result.exitCode).toBe(0);
+        expect(result.output).toContain('Usage:');
+    });
+    it('returns handled=true for -h', () => {
+        const result = resolveCliFastPath(['-h'], fakeModuleUrl);
+        expect(result.handled).toBe(true);
+        expect(result.output).toContain('Usage:');
+    });
+    it('returns handled=true for help subcommand', () => {
+        const result = resolveCliFastPath(['help'], fakeModuleUrl);
+        expect(result.handled).toBe(true);
+        expect(result.output).toContain('Usage:');
+    });
+    it('returns handled=true for --version', () => {
+        const result = resolveCliFastPath(['--version'], fakeModuleUrl);
+        expect(result.handled).toBe(true);
+        expect(result.exitCode).toBe(0);
+        expect(result.output).toBeDefined();
+        expect(result.output.endsWith('\n')).toBe(true);
+    });
+    it('returns handled=true for -v', () => {
+        const result = resolveCliFastPath(['-v'], fakeModuleUrl);
+        expect(result.handled).toBe(true);
+    });
+    it('returns handled=true for -V', () => {
+        const result = resolveCliFastPath(['-V'], fakeModuleUrl);
+        expect(result.handled).toBe(true);
+    });
+    it('returns handled=true for version subcommand', () => {
+        const result = resolveCliFastPath(['version'], fakeModuleUrl);
+        expect(result.handled).toBe(true);
+    });
+    it('returns handled=false for unknown arguments', () => {
+        const result = resolveCliFastPath(['--unknown', '--flag'], fakeModuleUrl);
+        expect(result.handled).toBe(false);
+    });
+    it('trims whitespace from arguments', () => {
+        const result = resolveCliFastPath(['  --help  '], fakeModuleUrl);
+        expect(result.handled).toBe(true);
+    });
+    it('filters empty arguments', () => {
+        const result = resolveCliFastPath(['', '  ', '--help'], fakeModuleUrl);
+        expect(result.handled).toBe(true);
+    });
+    it('help output contains expected sections', () => {
+        const result = resolveCliFastPath(['--help'], fakeModuleUrl);
+        expect(result.output).toContain('jshook');
+        expect(result.output).toContain('Behavior:');
+        expect(result.output).toContain('MCP server');
+        expect(result.output).toContain('environment variables');
+    });
+});
+describe('src/index.ts — isFatalError logic (tested via error classification)', () => {
+    it('identifies fatal error codes', () => {
+        const FATAL_ERROR_CODES = new Set([
+            'ERR_WORKER_OUT_OF_MEMORY',
+            'ERR_MEMORY_ALLOCATION_FAILED',
+        ]);
+        const FATAL_ERRNO_CODES = new Set(['ENOMEM', 'ENOSPC', 'EMFILE', 'ENFILE']);
+        expect(FATAL_ERROR_CODES.has('ERR_WORKER_OUT_OF_MEMORY')).toBe(true);
+        expect(FATAL_ERROR_CODES.has('ERR_MEMORY_ALLOCATION_FAILED')).toBe(true);
+        expect(FATAL_ERRNO_CODES.has('ENOMEM')).toBe(true);
+        expect(FATAL_ERRNO_CODES.has('ENOSPC')).toBe(true);
+        expect(FATAL_ERRNO_CODES.has('EMFILE')).toBe(true);
+        expect(FATAL_ERRNO_CODES.has('ENFILE')).toBe(true);
+    });
+    it('RangeError with allocation message is fatal', () => {
+        const err = new RangeError('Invalid array length: allocation failed');
+        expect(err instanceof RangeError).toBe(true);
+        expect(err.message.includes('allocation')).toBe(true);
+    });
+    it('regular Error is not fatal', () => {
+        const err = new Error('some random error');
+        expect(err instanceof RangeError).toBe(false);
+    });
+});
+describe('src/index.ts — formatUnknownError logic', () => {
+    function formatUnknownError(input) {
+        if (input instanceof Error) {
+            return `${input.name}: ${input.message}`;
+        }
+        try {
+            return typeof input === 'string' ? input : JSON.stringify(input);
+        }
+        catch {
+            return String(input);
+        }
+    }
+    it('formats Error instances', () => {
+        const err = new TypeError('bad type');
+        expect(formatUnknownError(err)).toBe('TypeError: bad type');
+    });
+    it('formats string input as-is', () => {
+        expect(formatUnknownError('plain string')).toBe('plain string');
+    });
+    it('formats number input as JSON', () => {
+        expect(formatUnknownError(42)).toBe('42');
+    });
+    it('formats object input as JSON', () => {
+        expect(formatUnknownError({ code: 'ERR' })).toBe('{"code":"ERR"}');
+    });
+    it('formats null as JSON', () => {
+        expect(formatUnknownError(null)).toBe('null');
+    });
+    it('handles circular references with fallback', () => {
+        const circular = {};
+        circular.self = circular;
+        expect(typeof formatUnknownError(circular)).toBe('string');
+    });
+});
+describe('browser module index exports', () => {
+    it('re-exports all browser module entities', async () => {
+        const browserModule = await import('../../src/modules/browser/index.js');
+        expect(browserModule.UnifiedBrowserManager).toBeDefined();
+        expect(browserModule.BrowserModeManager).toBeDefined();
+        expect(browserModule.CamoufoxBrowserManager).toBeDefined();
+        expect(browserModule.BrowserDiscovery).toBeDefined();
+    });
+});
+describe('process module index exports', () => {
+    it('re-exports ProcessManager and DEFAULT_CHROMIUM_CONFIG', async () => {
+        const processModule = await import('../../src/modules/process/ProcessManager.js');
+        expect(processModule.ProcessManager).toBeDefined();
+        expect(processModule.DEFAULT_CHROMIUM_CONFIG).toBeDefined();
+        expect(processModule.DEFAULT_CHROMIUM_CONFIG.processNamePattern).toBeDefined();
+    });
+});
+describe('hook barrel exports', () => {
+    it('HookGeneratorBuilders.ts re-exports all functions', async () => {
+        const builders = await import('../../src/modules/hook/HookGeneratorBuilders.js');
+        expect(builders.generateFunctionHook).toBeDefined();
+        expect(builders.generateXHRHook).toBeDefined();
+        expect(builders.generateFetchHook).toBeDefined();
+        expect(builders.generateWebSocketHook).toBeDefined();
+        expect(builders.generateLocalStorageHook).toBeDefined();
+        expect(builders.generateCookieHook).toBeDefined();
+        expect(builders.generateEvalHook).toBeDefined();
+        expect(builders.generateObjectMethodHook).toBeDefined();
+        expect(builders.generateAntiDebugBypass).toBeDefined();
+        expect(builders.generateHookTemplate).toBeDefined();
+        expect(builders.generateHookChain).toBeDefined();
+        expect(builders.getInjectionInstructions).toBeDefined();
+    });
+    it('HookGeneratorBuilders.core.ts re-exports all functions', async () => {
+        const core = await import('../../src/modules/hook/HookGeneratorBuilders.core.js');
+        expect(core.generateFunctionHook).toBeDefined();
+        expect(core.generateXHRHook).toBeDefined();
+        expect(core.generateFetchHook).toBeDefined();
+        expect(core.generateWebSocketHook).toBeDefined();
+        expect(core.generateLocalStorageHook).toBeDefined();
+        expect(core.generateCookieHook).toBeDefined();
+        expect(core.generateEvalHook).toBeDefined();
+        expect(core.generateObjectMethodHook).toBeDefined();
+        expect(core.generateAntiDebugBypass).toBeDefined();
+        expect(core.generateHookTemplate).toBeDefined();
+        expect(core.generateHookChain).toBeDefined();
+        expect(core.getInjectionInstructions).toBeDefined();
+    });
+    it('HookGeneratorBuilders.core.generators.ts aggregates sub-module exports', async () => {
+        const generators = await import('../../src/modules/hook/HookGeneratorBuilders.core.generators.js');
+        expect(generators.generateFunctionHook).toBeDefined();
+        expect(generators.generateEvalHook).toBeDefined();
+        expect(generators.generateAntiDebugBypass).toBeDefined();
+        expect(generators.generateHookTemplate).toBeDefined();
+        expect(generators.generateObjectMethodHook).toBeDefined();
+        expect(generators.generateFetchHook).toBeDefined();
+        expect(generators.generateWebSocketHook).toBeDefined();
+        expect(generators.generateXHRHook).toBeDefined();
+        expect(generators.generateCookieHook).toBeDefined();
+        expect(generators.generateLocalStorageHook).toBeDefined();
+        expect(generators.getInjectionInstructions).toBeDefined();
+        expect(generators.generateHookChain).toBeDefined();
+    });
+});

package/dist/tests/modules/hook/AIHookGeneratorTemplates.test.d.ts

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