@jshookmcp/jshook 0.2.1 → 0.2.2

package/dist/tests/modules/hook/HookGenerator.generateHookScript.test.js

@@ -1,233 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { generateHookScript, generateFunctionHook, generateXHRHook, generateFetchHook, generateWebSocketHook, generateLocalStorageHook, generateCookieHook, generateEvalHook, generateObjectMethodHook, generateAntiDebugBypass, generateHookTemplate, generateHookChain, getInjectionInstructions, } from '../../../src/modules/hook/HookGenerator.js';
-describe('HookGenerator — generateHookScript dispatch', () => {
-    it('dispatches xhr type to generateXHRHook', () => {
-        const script = generateHookScript('*', 'xhr', 'log');
-        expect(script).toContain('[XHR Hook]');
-    });
-    it('dispatches fetch type to generateFetchHook', () => {
-        const script = generateHookScript('*', 'fetch', 'log');
-        expect(script).toContain('[Fetch Hook]');
-    });
-    it('dispatches websocket type to generateWebSocketHook', () => {
-        const script = generateHookScript('*', 'websocket', 'log');
-        expect(script).toContain('[WebSocket Hook]');
-    });
-    it('dispatches localstorage type to generateLocalStorageHook', () => {
-        const script = generateHookScript('*', 'localstorage', 'log');
-        expect(script).toContain('[Storage Hook]');
-    });
-    it('dispatches cookie type to generateCookieHook', () => {
-        const script = generateHookScript('*', 'cookie', 'log');
-        expect(script).toContain('[Cookie Hook]');
-    });
-    it('dispatches eval type to generateEvalHook', () => {
-        const script = generateHookScript('*', 'eval', 'log');
-        expect(script).toContain('[Eval Hook]');
-    });
-    it('dispatches object-method type to generateObjectMethodHook', () => {
-        const script = generateHookScript('console.log', 'object-method', 'log');
-        expect(script).toContain('[Object Hook]');
-    });
-    it('throws for unknown hook type', () => {
-        expect(() => generateHookScript('x', 'not-real', 'log')).toThrow('Unsupported hook type');
-    });
-    it('passes customCode to function hook', () => {
-        const script = generateHookScript('window.alert', 'function', 'modify', 'args[0] = "intercepted";');
-        expect(script).toContain('args[0] = "intercepted";');
-    });
-    it('passes condition to function hook', () => {
-        const script = generateHookScript('window.alert', 'function', 'log', undefined, { maxCalls: 5 });
-        expect(script).toContain('const maxCalls = 5;');
-    });
-    it('passes performance flag to function hook', () => {
-        const script = generateHookScript('window.alert', 'function', 'log', undefined, undefined, true);
-        expect(script).toContain('performance.now()');
-    });
-});
-describe('HookGenerator — generateFunctionHook', () => {
-    it('generates basic log hook without conditions', () => {
-        const script = generateFunctionHook('document.getElementById', 'log');
-        expect(script).toContain('const originalFunction = document.getElementById');
-        expect(script).toContain("type: 'function'");
-    });
-    it('generates block action hook', () => {
-        const script = generateFunctionHook('window.alert', 'block');
-        expect(script).toContain('window.alert');
-    });
-    it('includes custom code in modify action', () => {
-        const script = generateFunctionHook('window.fetch', 'modify', 'return "modified";');
-        expect(script).toContain('return "modified";');
-    });
-    it('handles condition with minInterval', () => {
-        const script = generateFunctionHook('fn', 'log', undefined, { minInterval: 500 });
-        expect(script).toContain('const minInterval = 500;');
-    });
-    it('handles condition with maxCalls only', () => {
-        const script = generateFunctionHook('fn', 'log', undefined, { maxCalls: 10 });
-        expect(script).toContain('const maxCalls = 10;');
-    });
-    it('includes performance timing when enabled', () => {
-        const script = generateFunctionHook('fn', 'log', undefined, undefined, true);
-        expect(script).toContain('const startTime = performance.now();');
-    });
-});
-describe('HookGenerator — generateXHRHook', () => {
-    it('generates XHR hook script', () => {
-        const script = generateXHRHook('log');
-        expect(script).toContain('[XHR Hook]');
-        expect(script).toContain('XMLHttpRequest');
-    });
-    it('includes custom code', () => {
-        const script = generateXHRHook('modify', 'url = "/changed";');
-        expect(script).toContain('url = "/changed";');
-    });
-    it('includes performance timing', () => {
-        const script = generateXHRHook('log', undefined, undefined, true);
-        expect(script).toContain('[Hook] XHR hooked successfully');
-    });
-});
-describe('HookGenerator — generateFetchHook', () => {
-    it('generates Fetch hook script', () => {
-        const script = generateFetchHook('log');
-        expect(script).toContain('[Fetch Hook]');
-        expect(script).toContain('fetch');
-    });
-    it('includes custom code', () => {
-        const script = generateFetchHook('modify', 'input = "/api/v2";');
-        expect(script).toContain('input = "/api/v2";');
-    });
-});
-describe('HookGenerator — generateWebSocketHook', () => {
-    it('generates WebSocket hook script', () => {
-        const script = generateWebSocketHook('log');
-        expect(script).toContain('[WebSocket Hook]');
-        expect(script).toContain('WebSocket');
-    });
-});
-describe('HookGenerator — generateLocalStorageHook', () => {
-    it('generates localStorage/sessionStorage hook script', () => {
-        const script = generateLocalStorageHook('log');
-        expect(script).toContain('[Storage Hook]');
-        expect(script).toContain('Storage.prototype');
-    });
-});
-describe('HookGenerator — generateCookieHook', () => {
-    it('generates cookie hook script', () => {
-        const script = generateCookieHook('log');
-        expect(script).toContain('[Cookie Hook]');
-        expect(script).toContain('cookie');
-    });
-});
-describe('HookGenerator — generateEvalHook', () => {
-    it('generates eval hook script', () => {
-        const script = generateEvalHook('log');
-        expect(script).toContain('[Eval Hook]');
-        expect(script).toContain('eval');
-    });
-    it('includes custom code', () => {
-        const script = generateEvalHook('modify', 'code = code.replace("bad", "good");');
-        expect(script).toContain('code = code.replace("bad", "good");');
-    });
-});
-describe('HookGenerator — generateObjectMethodHook', () => {
-    it('generates object method hook splitting target', () => {
-        const script = generateObjectMethodHook('console.log', 'log');
-        expect(script).toContain('[Object Hook]');
-        expect(script).toContain("'log'");
-    });
-    it('handles deeply nested target paths', () => {
-        const script = generateObjectMethodHook('window.document.cookie', 'log');
-        expect(script).toContain('[Object Hook]');
-    });
-});
-describe('HookGenerator — generateAntiDebugBypass', () => {
-    it('generates anti-debug bypass script', () => {
-        const script = generateAntiDebugBypass();
-        expect(typeof script).toBe('string');
-        expect(script.length).toBeGreaterThan(0);
-    });
-});
-describe('HookGenerator — generateHookTemplate', () => {
-    it('generates a function hook template', () => {
-        const script = generateHookTemplate('myHook', 'function');
-        expect(script).toContain('myHook');
-        expect(script).toContain('const original = myHook');
-        expect(script).toContain('[Hook] Successfully hooked: myHook');
-    });
-    it('generates a property hook template', () => {
-        const script = generateHookTemplate('window.location.href', 'property');
-        expect(script).toContain('defineProperty');
-        expect(script).toContain('[Hook] Successfully hooked property');
-    });
-    it('generates a prototype hook template', () => {
-        const script = generateHookTemplate('MyClass', 'prototype');
-        expect(script).toContain('const original = MyClass');
-        expect(script).toContain('prototype');
-        expect(script).toContain('[Hook] Successfully hooked prototype: MyClass');
-    });
-});
-describe('HookGenerator — generateHookChain', () => {
-    it('concatenates multiple hook scripts', () => {
-        const chain = generateHookChain([
-            { hookId: 'hook-1', script: 'var a = 1;', instructions: 'First hook' },
-            { hookId: 'hook-2', script: 'var b = 2;', instructions: 'Second hook' },
-            { hookId: 'hook-3', script: 'var c = 3;', instructions: 'Third hook' },
-        ]);
-        expect(chain).toContain('var a = 1;');
-        expect(chain).toContain('var b = 2;');
-        expect(chain).toContain('var c = 3;');
-        expect(chain).toContain('All 3 hooks initialized');
-    });
-    it('handles single hook', () => {
-        const chain = generateHookChain([
-            { hookId: 'solo', script: 'solo();', instructions: 'Only one' },
-        ]);
-        expect(chain).toContain('solo();');
-        expect(chain).toContain('All 1 hooks initialized');
-    });
-    it('handles empty array', () => {
-        const chain = generateHookChain([]);
-        expect(chain).toContain('All 0 hooks initialized');
-    });
-});
-describe('HookGenerator — getInjectionInstructions', () => {
-    it('returns instructions for each supported hook type', () => {
-        const types = [
-            'function',
-            'xhr',
-            'fetch',
-            'websocket',
-            'localstorage',
-            'cookie',
-            'eval',
-            'object-method',
-        ];
-        for (const type of types) {
-            const instructions = getInjectionInstructions(type);
-            expect(typeof instructions).toBe('string');
-            expect(instructions.length).toBeGreaterThan(0);
-        }
-    });
-    it('mentions page_evaluate in instructions', () => {
-        const instructions = getInjectionInstructions('function');
-        expect(instructions).toContain('page_evaluate');
-    });
-});
-describe('HookGenerator — re-exports are available', () => {
-    it('all exported functions are defined', () => {
-        expect(typeof generateFunctionHook).toBe('function');
-        expect(typeof generateXHRHook).toBe('function');
-        expect(typeof generateFetchHook).toBe('function');
-        expect(typeof generateWebSocketHook).toBe('function');
-        expect(typeof generateLocalStorageHook).toBe('function');
-        expect(typeof generateCookieHook).toBe('function');
-        expect(typeof generateEvalHook).toBe('function');
-        expect(typeof generateObjectMethodHook).toBe('function');
-        expect(typeof generateAntiDebugBypass).toBe('function');
-        expect(typeof generateHookTemplate).toBe('function');
-        expect(typeof generateHookChain).toBe('function');
-        expect(typeof getInjectionInstructions).toBe('function');
-        expect(typeof generateHookScript).toBe('function');
-    });
-});

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

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

package/dist/tests/modules/hook/HookGenerator.test.js

@@ -1,38 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { generateFunctionHook, generateHookChain, generateHookScript, getInjectionInstructions, } from '../../../src/modules/hook/HookGenerator.js';
-describe('HookGenerator', () => {
-    it('generateHookScript dispatches function hook generation', () => {
-        const script = generateHookScript('window.alert', 'function', 'log');
-        expect(script).toContain('const originalFunction = window.alert');
-        expect(script).toContain("type: 'function'");
-    });
-    it('generateHookScript supports object-method type', () => {
-        const script = generateHookScript('window.localStorage.getItem', 'object-method', 'log');
-        expect(script).toContain("const methodName = 'getItem'");
-        expect(script).toContain('[Object Hook]');
-    });
-    it('throws for unsupported hook type', () => {
-        expect(() => generateHookScript('window.x', 'not-real-type', 'log')).toThrow('Unsupported hook type');
-    });
-    it('generateFunctionHook includes condition and performance branches', () => {
-        const script = generateFunctionHook('window.fetch', 'modify', 'args[0] = "/patched";', { maxCalls: 2, minInterval: 10 }, true);
-        expect(script).toContain('const maxCalls = 2;');
-        expect(script).toContain('const minInterval = 10;');
-        expect(script).toContain('const startTime = performance.now();');
-        expect(script).toContain('args[0] = "/patched";');
-    });
-    it('getInjectionInstructions references selected hook type', () => {
-        const instructions = getInjectionInstructions('eval');
-        expect(instructions).toContain('eval');
-        expect(instructions).toContain('page_evaluate');
-    });
-    it('generateHookChain concatenates hook scripts with summary message', () => {
-        const chain = generateHookChain([
-            { hookId: '1', script: 'console.log(1);', instructions: 'a' },
-            { hookId: '2', script: 'console.log(2);', instructions: 'b' },
-        ]);
-        expect(chain).toContain('console.log(1);');
-        expect(chain).toContain('console.log(2);');
-        expect(chain).toContain('All 2 hooks initialized');
-    });
-});

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.compose.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.compose.test.js

@@ -1,21 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { generateHookChain } from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.compose.js';
-describe('HookGeneratorBuilders.core.generators.compose', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('concatenates hook scripts and announces the final initialization count', () => {
-        const chain = generateHookChain([
-            { hookId: 'a', script: 'console.log("a");', instructions: 'one' },
-            { hookId: 'b', script: 'console.log("b");', instructions: 'two' },
-        ]);
-        expect(chain).toContain('console.log("a");');
-        expect(chain).toContain('console.log("b");');
-        expect(chain.indexOf('console.log("a");')).toBeLessThan(chain.indexOf('console.log("b");'));
-        expect(chain).toContain('All 2 hooks initialized');
-    });
-    it('still returns a summary message when no hooks are provided', () => {
-        const chain = generateHookChain([]);
-        expect(chain).toBe("console.log('[Hook Chain] All 0 hooks initialized');");
-    });
-});

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.network.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.network.test.js

@@ -1,59 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { generateFetchHook, generateWebSocketHook, generateXHRHook, } from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.network.js';
-describe('HookGeneratorBuilders.core.generators.network', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('generates XHR hooks that wrap open, headers, send and response instrumentation', () => {
-        const script = generateXHRHook('log', 'window.__xhrPatched = true;');
-        expect(script).toContain('const XHR = XMLHttpRequest.prototype;');
-        expect(script).toContain('XHR.open = function(method, url, async, user, password)');
-        expect(script).toContain('XHR.setRequestHeader = function(header, value)');
-        expect(script).toContain('XHR.send = function(data)');
-        expect(script).toContain("console.log('[XHR Hook] open:', {");
-        expect(script).toContain("console.log('[XHR Hook] setRequestHeader:', { header, value });");
-        expect(script).toContain("console.log('[XHR Hook] send:', {");
-        expect(script).toContain('if (xhr.readyState === 4) {');
-        expect(script).toContain("console.log('[XHR Hook] responseText:', xhr.responseText?.substring(0, 500));");
-        expect(script).toContain("console.log('[XHR Hook] responseJSON:', xhr.response);");
-        expect(script).toContain("if (event === 'load' || event === 'error' || event === 'abort') {");
-        expect(script).toContain('window.__xhrPatched = true;');
-    });
-    it('supports blocking XHR open calls', () => {
-        const script = generateXHRHook('block');
-        expect(script).toContain('return;');
-        expect(script).toContain("console.log('[Hook] XHR hooked successfully');");
-    });
-    it('generates fetch hooks with request inspection and response parsing branches', () => {
-        const script = generateFetchHook('log', 'window.__fetchPatched = true;');
-        expect(script).toContain('window.fetch = new Proxy(originalFetch');
-        expect(script).toContain('if (resource instanceof Request) {');
-        expect(script).toContain("method = config?.method || 'GET';");
-        expect(script).toContain("console.log('[Fetch Hook] request:', hookContext);");
-        expect(script).toContain('window.__fetchPatched = true;');
-        expect(script).toContain('const startTime = performance.now();');
-        expect(script).toContain('const clonedResponse = response.clone();');
-        expect(script).toContain("if (contentType.includes('application/json')) {");
-        expect(script).toContain("} else if (contentType.includes('text/')) {");
-        expect(script).toContain("console.error('[Fetch Hook] error:', {");
-    });
-    it('supports blocking fetch requests', () => {
-        const script = generateFetchHook('block');
-        expect(script).toContain('return Promise.reject(new Error("Fetch blocked by hook"));');
-    });
-    it('generates websocket hooks that mirror static constants and wrap send and events', () => {
-        const script = generateWebSocketHook('log', 'window.__wsPatched = true;');
-        expect(script).toContain('const OriginalWebSocket = window.WebSocket;');
-        expect(script).toContain('[WebSocket Hook #${wsId}] connecting:');
-        expect(script).toContain('ws.send = function(data)');
-        expect(script).toContain('[WebSocket Hook #${wsId}] send:');
-        expect(script).toContain("ws.addEventListener('message', function(event)");
-        expect(script).toContain("ws.addEventListener('close', function(event)");
-        expect(script).toContain('window.WebSocket.CONNECTING = OriginalWebSocket.CONNECTING;');
-        expect(script).toContain('window.__wsPatched = true;');
-    });
-    it('supports blocking websocket construction', () => {
-        const script = generateWebSocketHook('block');
-        expect(script).toContain('throw new Error("WebSocket blocked by hook");');
-    });
-});

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.runtime.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.runtime.test.js

@@ -1,66 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { generateAntiDebugBypass, generateEvalHook, generateFunctionHook, generateHookTemplate, generateObjectMethodHook, } from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.runtime.js';
-describe('HookGeneratorBuilders.core.generators.runtime', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('generates function hooks with condition, performance and modify branches', () => {
-        const script = generateFunctionHook('window.fetch', 'modify', 'args[0] = "/patched";', { maxCalls: 2, minInterval: 25 }, true);
-        expect(script).toContain('const originalFunction = window.fetch;');
-        expect(script).toContain('const maxCalls = 2;');
-        expect(script).toContain('const minInterval = 25;');
-        expect(script).toContain('const startTime = performance.now();');
-        expect(script).toContain('const endTime = performance.now();');
-        expect(script).toContain('args[0] = "/patched";');
-        expect(script).toContain("console.log('[Hook] Function result:', result);");
-        expect(script).not.toContain('return undefined;');
-    });
-    it('supports blocking function hooks without optional condition or performance code', () => {
-        const script = generateFunctionHook('window.alert', 'block');
-        expect(script).toContain('const originalFunction = window.alert;');
-        expect(script).toContain('return undefined;');
-        expect(script).not.toContain('let callCount = 0;');
-        expect(script).not.toContain('const startTime = performance.now();');
-    });
-    it('generates eval hooks that wrap eval, Function and timer string handlers', () => {
-        const script = generateEvalHook('block', 'window.__patched = true;');
-        expect(script).toContain('window.eval = function(code)');
-        expect(script).toContain('window.Function = function(...args)');
-        expect(script).toContain('window.setTimeout = function(handler, timeout, ...args)');
-        expect(script).toContain('window.setInterval = function(handler, timeout, ...args)');
-        expect(script).toContain('window.__patched = true;');
-        expect(script).toContain('return undefined;');
-        expect(script).toContain('return function() {};');
-        expect(script).toContain('return 0;');
-    });
-    it('generates object method hooks for both methods and accessors', () => {
-        const script = generateObjectMethodHook('window.localStorage.getItem', 'block', 'args[0] = "token";');
-        expect(script).toContain("const targetObject = getObjectByPath('window.localStorage');");
-        expect(script).toContain("const methodName = 'getItem';");
-        expect(script).toContain('targetObject[methodName] = function(...args)');
-        expect(script).toContain('Object.defineProperty(targetObject, methodName, {');
-        expect(script).toContain('Object.setPrototypeOf(targetObject[methodName], originalMethod);');
-        expect(script).toContain('return undefined;');
-        expect(script).toContain('args[0] = "token";');
-    });
-    it('generates anti-debug bypasses for debugger stripping, timing and devtools probes', () => {
-        const script = generateAntiDebugBypass();
-        expect(script).toContain("code.replace(/debugger\\s*;?/g, '')");
-        expect(script).toContain("lastArg.replace(/debugger\\s*;?/g, '')");
-        expect(script).toContain("Object.defineProperty(window, 'outerHeight'");
-        expect(script).toContain("Object.defineProperty(window, 'outerWidth'");
-        expect(script).toContain('Date.now = function()');
-        expect(script).toContain("return 'function () { [native code] }';");
-        expect(script).toContain("Object.defineProperty(window, 'devtools'");
-    });
-    it('generates hook templates for function, property and prototype targets', () => {
-        const functionTemplate = generateHookTemplate('window.fetch', 'function');
-        const propertyTemplate = generateHookTemplate('document.cookie', 'property');
-        const prototypeTemplate = generateHookTemplate('window.WebSocket', 'prototype');
-        expect(functionTemplate).toContain('const original = window.fetch;');
-        expect(propertyTemplate).toContain("Object.getOwnPropertyDescriptor(document, 'cookie')");
-        expect(propertyTemplate).toContain("Object.defineProperty(document, 'cookie', {");
-        expect(prototypeTemplate).toContain('const methodNames = Object.getOwnPropertyNames(original.prototype);');
-        expect(prototypeTemplate).toContain('window.WebSocket.prototype = original.prototype;');
-    });
-});

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.storage.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.storage.test.js

@@ -1,43 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { generateCookieHook, generateLocalStorageHook, getInjectionInstructions, } from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.storage.js';
-describe('HookGeneratorBuilders.core.generators.storage', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('generates storage hooks for mutators and readers', () => {
-        const script = generateLocalStorageHook('log', 'window.__storagePatched = true;');
-        expect(script).toContain('const originalSetItem = Storage.prototype.setItem;');
-        expect(script).toContain('Storage.prototype.setItem = function(key, value)');
-        expect(script).toContain('Storage.prototype.getItem = function(key)');
-        expect(script).toContain('Storage.prototype.removeItem = function(key)');
-        expect(script).toContain('Storage.prototype.clear = function()');
-        expect(script).toContain('[Storage Hook] ${storageType}.setItem:');
-        expect(script).toContain('[Storage Hook] ${storageType}.getItem:');
-        expect(script).toContain('[Storage Hook] ${storageType}.removeItem:');
-        expect(script).toContain('[Storage Hook] ${storageType}.clear:');
-        expect(script).toContain('window.__storagePatched = true;');
-    });
-    it('supports blocking storage writes', () => {
-        const script = generateLocalStorageHook('block');
-        expect(script).toContain('return;');
-        expect(script).toContain('return originalSetItem.apply(this, arguments);');
-    });
-    it('generates cookie hooks with getter, setter and parsing helpers', () => {
-        const script = generateCookieHook('log', 'window.__cookiePatched = true;');
-        expect(script).toContain("Object.getOwnPropertyDescriptor(Document.prototype, 'cookie')");
-        expect(script).toContain("Object.getOwnPropertyDescriptor(HTMLDocument.prototype, 'cookie')");
-        expect(script).toContain('function parseCookie(cookieString)');
-        expect(script).toContain("Object.defineProperty(document, 'cookie'");
-        expect(script).toContain("console.log('[Cookie Hook] get:', {");
-        expect(script).toContain("console.log('[Cookie Hook] set:', {");
-        expect(script).toContain('window.__cookiePatched = true;');
-    });
-    it('supports blocking cookie writes', () => {
-        const script = generateCookieHook('block');
-        expect(script).toContain('return;');
-    });
-    it('returns injection instructions that mention the selected hook type', () => {
-        const instructions = getInjectionInstructions('cookie');
-        expect(instructions).toBe('This hook script monitors cookie operations. Inject it into the target page via page_evaluate or console_execute to activate.');
-    });
-});

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.core.generators.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import * as generators from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.js';
-import * as compose from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.compose.js';
-import * as network from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.network.js';
-import * as runtime from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.runtime.js';
-import * as storage from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.storage.js';
-describe('HookGeneratorBuilders.core.generators.ts', () => {
-    it('aggregates runtime, network, storage and compose generator helpers', () => {
-        expect(generators.generateFunctionHook).toBe(runtime.generateFunctionHook);
-        expect(generators.generateEvalHook).toBe(runtime.generateEvalHook);
-        expect(generators.generateObjectMethodHook).toBe(runtime.generateObjectMethodHook);
-        expect(generators.generateAntiDebugBypass).toBe(runtime.generateAntiDebugBypass);
-        expect(generators.generateHookTemplate).toBe(runtime.generateHookTemplate);
-        expect(generators.generateXHRHook).toBe(network.generateXHRHook);
-        expect(generators.generateFetchHook).toBe(network.generateFetchHook);
-        expect(generators.generateWebSocketHook).toBe(network.generateWebSocketHook);
-        expect(generators.generateCookieHook).toBe(storage.generateCookieHook);
-        expect(generators.generateLocalStorageHook).toBe(storage.generateLocalStorageHook);
-        expect(generators.getInjectionInstructions).toBe(storage.getInjectionInstructions);
-        expect(generators.generateHookChain).toBe(compose.generateHookChain);
-    });
-});

package/dist/tests/modules/hook/HookGeneratorBuilders.core.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.core.test.js

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import * as core from '../../../src/modules/hook/HookGeneratorBuilders.core.js';
-import * as generators from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.js';
-const asMap = (value) => value;
-describe('HookGeneratorBuilders.core.ts', () => {
-    it('re-exports the aggregated generator surface', () => {
-        const exportKeys = [
-            'generateAntiDebugBypass',
-            'generateCookieHook',
-            'generateEvalHook',
-            'generateFetchHook',
-            'generateFunctionHook',
-            'generateHookChain',
-            'generateHookTemplate',
-            'generateLocalStorageHook',
-            'generateObjectMethodHook',
-            'generateWebSocketHook',
-            'generateXHRHook',
-            'getInjectionInstructions',
-        ];
-        for (const key of exportKeys) {
-            expect(asMap(core)[key]).toBe(asMap(generators)[key]);
-        }
-    });
-});

package/dist/tests/modules/hook/HookGeneratorBuilders.reexports.test.d.ts

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

package/dist/tests/modules/hook/HookGeneratorBuilders.reexports.test.js

@@ -1,66 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import * as builders from '../../../src/modules/hook/HookGeneratorBuilders.js';
-import * as core from '../../../src/modules/hook/HookGeneratorBuilders.core.js';
-import * as compose from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.compose.js';
-import * as generators from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.js';
-import * as network from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.network.js';
-import * as runtime from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.runtime.js';
-import * as storage from '../../../src/modules/hook/HookGeneratorBuilders.core.generators.storage.js';
-const asMap = (value) => value;
-describe('HookGeneratorBuilders re-exports', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('re-exports the full core surface from HookGeneratorBuilders', () => {
-        const exportKeys = [
-            'generateAntiDebugBypass',
-            'generateCookieHook',
-            'generateEvalHook',
-            'generateFetchHook',
-            'generateFunctionHook',
-            'generateHookChain',
-            'generateHookTemplate',
-            'generateLocalStorageHook',
-            'generateObjectMethodHook',
-            'generateWebSocketHook',
-            'generateXHRHook',
-            'getInjectionInstructions',
-        ];
-        for (const key of exportKeys) {
-            expect(asMap(builders)[key]).toBe(asMap(core)[key]);
-        }
-    });
-    it('re-exports the aggregated generator surface from HookGeneratorBuilders.core', () => {
-        const exportKeys = [
-            'generateAntiDebugBypass',
-            'generateCookieHook',
-            'generateEvalHook',
-            'generateFetchHook',
-            'generateFunctionHook',
-            'generateHookChain',
-            'generateHookTemplate',
-            'generateLocalStorageHook',
-            'generateObjectMethodHook',
-            'generateWebSocketHook',
-            'generateXHRHook',
-            'getInjectionInstructions',
-        ];
-        for (const key of exportKeys) {
-            expect(asMap(core)[key]).toBe(asMap(generators)[key]);
-        }
-    });
-    it('aggregates runtime, network, storage and compose helpers in the generators entrypoint', () => {
-        expect(generators.generateFunctionHook).toBe(runtime.generateFunctionHook);
-        expect(generators.generateEvalHook).toBe(runtime.generateEvalHook);
-        expect(generators.generateObjectMethodHook).toBe(runtime.generateObjectMethodHook);
-        expect(generators.generateAntiDebugBypass).toBe(runtime.generateAntiDebugBypass);
-        expect(generators.generateHookTemplate).toBe(runtime.generateHookTemplate);
-        expect(generators.generateXHRHook).toBe(network.generateXHRHook);
-        expect(generators.generateFetchHook).toBe(network.generateFetchHook);
-        expect(generators.generateWebSocketHook).toBe(network.generateWebSocketHook);
-        expect(generators.generateLocalStorageHook).toBe(storage.generateLocalStorageHook);
-        expect(generators.generateCookieHook).toBe(storage.generateCookieHook);
-        expect(generators.getInjectionInstructions).toBe(storage.getInjectionInstructions);
-        expect(generators.generateHookChain).toBe(compose.generateHookChain);
-    });
-});

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

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

package/dist/tests/modules/hook/HookGeneratorBuilders.test.js

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import * as builders from '../../../src/modules/hook/HookGeneratorBuilders.js';
-import * as core from '../../../src/modules/hook/HookGeneratorBuilders.core.js';
-const asMap = (value) => value;
-describe('HookGeneratorBuilders.ts', () => {
-    it('re-exports the core builder surface', () => {
-        const exportKeys = [
-            'generateAntiDebugBypass',
-            'generateCookieHook',
-            'generateEvalHook',
-            'generateFetchHook',
-            'generateFunctionHook',
-            'generateHookChain',
-            'generateHookTemplate',
-            'generateLocalStorageHook',
-            'generateObjectMethodHook',
-            'generateWebSocketHook',
-            'generateXHRHook',
-            'getInjectionInstructions',
-        ];
-        for (const key of exportKeys) {
-            expect(asMap(builders)[key]).toBe(asMap(core)[key]);
-        }
-    });
-});

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

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