@jshookmcp/jshook 0.2.0 → 0.2.2

package/dist/src/modules/process/memory/availability.js

@@ -64,7 +64,9 @@ export async function checkAvailability(platform) {
                     return { available: true };
                 }
                 try {
-                    await execAsync('capsh --print 2>/dev/null | grep -q "cap_sys_ptrace"', { timeout: 2000 });
+                    await execAsync('capsh --print 2>/dev/null | grep -q "cap_sys_ptrace"', {
+                        timeout: 2000,
+                    });
                     return { available: true };
                 }
                 catch {
@@ -75,7 +77,10 @@ export async function checkAvailability(platform) {
                 }
             }
             catch {
-                return { available: false, reason: 'Requires root privileges for /proc/pid/mem access. Run with sudo.' };
+                return {
+                    available: false,
+                    reason: 'Requires root privileges for /proc/pid/mem access. Run with sudo.',
+                };
             }
         case 'darwin':
             try {
@@ -95,7 +100,10 @@ export async function checkAvailability(platform) {
                 };
             }
         default:
-            return { available: false, reason: `Platform ${platform} not supported for memory operations.` };
+            return {
+                available: false,
+                reason: `Platform ${platform} not supported for memory operations.`,
+            };
     }
 }
 export async function checkDebugPort(platform, pid) {
@@ -153,7 +161,10 @@ try {
     @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
 }
     `;
-        const { stdout } = await executePowerShellScript(psScript, { maxBuffer: 1024 * 1024, timeout: 10000 });
+        const { stdout } = await executePowerShellScript(psScript, {
+            maxBuffer: 1024 * 1024,
+            timeout: 10000,
+        });
         const _trimmed = stdout.trim();
         if (!_trimmed)
             throw new Error('PowerShell returned empty output');

package/dist/src/modules/process/memory/index.d.ts

@@ -2,7 +2,7 @@ export type { Platform, PatternType, MemoryReadResult, MemoryWriteResult, Memory
 export { readMemory } from '../../process/memory/reader.js';
 export { writeMemory, batchMemoryWrite } from '../../process/memory/writer.js';
 export { scanMemory, scanMemoryFiltered } from '../../process/memory/scanner.js';
-export { dumpMemoryRegion, enumerateRegions, checkMemoryProtection, enumerateModules } from '../../process/memory/regions.js';
+export { dumpMemoryRegion, enumerateRegions, checkMemoryProtection, enumerateModules, } from '../../process/memory/regions.js';
 export { injectDll, injectShellcode } from '../../process/memory/injector.js';
 export { MemoryMonitorManager } from '../../process/memory/monitor.js';
 export { checkAvailability, checkDebugPort } from '../../process/memory/availability.js';

package/dist/src/modules/process/memory/index.js

@@ -1,7 +1,7 @@
 export { readMemory } from '../../process/memory/reader.js';
 export { writeMemory, batchMemoryWrite } from '../../process/memory/writer.js';
 export { scanMemory, scanMemoryFiltered } from '../../process/memory/scanner.js';
-export { dumpMemoryRegion, enumerateRegions, checkMemoryProtection, enumerateModules } from '../../process/memory/regions.js';
+export { dumpMemoryRegion, enumerateRegions, checkMemoryProtection, enumerateModules, } from '../../process/memory/regions.js';
 export { injectDll, injectShellcode } from '../../process/memory/injector.js';
 export { MemoryMonitorManager } from '../../process/memory/monitor.js';
 export { checkAvailability, checkDebugPort } from '../../process/memory/availability.js';

package/dist/src/modules/process/memory/injector.js

@@ -107,7 +107,10 @@ export async function injectDll(platform, pid, dllPath) {
     }
     try {
         const psScript = buildDllInjectionScript(pid, dllPath);
-        const { stdout } = await executePowerShellScript(psScript, { maxBuffer: 1024 * 1024, timeout: 30000 });
+        const { stdout } = await executePowerShellScript(psScript, {
+            maxBuffer: 1024 * 1024,
+            timeout: 30000,
+        });
         const _trimmed = stdout.trim();
         if (!_trimmed)
             throw new Error('PowerShell returned empty output');
@@ -230,7 +233,10 @@ export async function injectShellcode(platform, pid, shellcode, encoding = 'hex'
             shellcodeBytes = Buffer.from(cleanHex, 'hex');
         }
         const psScript = buildShellcodeInjectionScript(pid, shellcodeBytes);
-        const { stdout } = await executePowerShellScript(psScript, { maxBuffer: 1024 * 1024, timeout: 30000 });
+        const { stdout } = await executePowerShellScript(psScript, {
+            maxBuffer: 1024 * 1024,
+            timeout: 30000,
+        });
         const _trimmed = stdout.trim();
         if (!_trimmed)
             throw new Error('PowerShell returned empty output');

package/dist/src/modules/process/memory/monitor.js

@@ -1,3 +1,4 @@
+import {} from '../../process/memory/types.js';
 export class MemoryMonitorManager {
     activeMonitors = new Map();
     start(pid, address, size = 4, intervalMs = 1000, readMemoryFn, onChange) {

package/dist/src/modules/process/memory/reader.js

@@ -71,7 +71,9 @@ async function readMemoryWindows(pid, address, size) {
         logger.error('Windows memory read failed:', error);
         return {
             success: false,
-            error: error instanceof Error ? error.message : 'PowerShell execution failed. Run as Administrator.',
+            error: error instanceof Error
+                ? error.message
+                : 'PowerShell execution failed. Run as Administrator.',
         };
     }
 }
@@ -84,7 +86,10 @@ async function readMemoryLinux(pid, address, size) {
                 error: 'Failed to read memory. Requires root privileges or ptrace access.',
             };
         }
-        const hexData = stdout.trim().match(/.{1,2}/g)?.join(' ') || stdout.trim();
+        const hexData = stdout
+            .trim()
+            .match(/.{1,2}/g)
+            ?.join(' ') || stdout.trim();
         return {
             success: true,
             data: hexData.toUpperCase(),
@@ -112,18 +117,21 @@ async function readMemoryMac(pid, address, size, checkProtectionFn) {
         return { success: false, error: `Cannot verify memory region: ${prot.error}` };
     }
     if (!prot.isReadable) {
-        return { success: false, error: `Address ${addrHex} is not readable (protection: ${prot.protection ?? 'unknown'})` };
+        return {
+            success: false,
+            error: `Address ${addrHex} is not readable (protection: ${prot.protection ?? 'unknown'})`,
+        };
     }
     const tmpFile = `/tmp/mread_${pid}_${Date.now()}.bin`;
     try {
         const { stdout } = await execAsync(`lldb --batch -p ${pid} -o "memory read --outfile ${tmpFile} --binary ${addrHex} -c ${size}" -o "process detach"`, { timeout: 15000, maxBuffer: 1024 * 1024 * 10 });
         if (!stdout.includes('bytes written')) {
-            const errLine = stdout.split('\n').find(l => l.includes('error:')) ?? stdout;
+            const errLine = stdout.split('\n').find((l) => l.includes('error:')) ?? stdout;
             return { success: false, error: `lldb memory read failed: ${errLine.trim()}` };
         }
         const data = await fs.readFile(tmpFile);
         const hex = Array.from(data)
-            .map(b => b.toString(16).padStart(2, '0').toUpperCase())
+            .map((b) => b.toString(16).padStart(2, '0').toUpperCase())
             .join(' ');
         return { success: true, data: hex };
     }
@@ -161,7 +169,10 @@ export async function readMemory(platform, pid, address, size, checkProtectionFn
             case 'darwin':
                 return readMemoryMac(pid, addrNum, size, checkProtectionFn);
             default:
-                return { success: false, error: `Memory operations not supported on platform: ${platform}` };
+                return {
+                    success: false,
+                    error: `Memory operations not supported on platform: ${platform}`,
+                };
         }
     }
     catch (error) {

package/dist/src/modules/process/memory/regions.dump.js

@@ -1,5 +1,5 @@
 import { logger } from '../../../utils/logger.js';
-import { execFileAsync, executePowerShellScript } from '../../process/memory/types.js';
+import { execFileAsync, executePowerShellScript, } from '../../process/memory/types.js';
 function buildMemoryDumpScript(pid, address, size, outputPath) {
     return `
 Add-Type @"
@@ -56,7 +56,10 @@ try {
 }
 export async function dumpMemoryRegion(platform, pid, startAddress, size, outputPath) {
     if (platform !== 'win32' && platform !== 'darwin') {
-        return { success: false, error: 'Memory dump currently only implemented for Windows and macOS' };
+        return {
+            success: false,
+            error: 'Memory dump currently only implemented for Windows and macOS',
+        };
     }
     if (platform === 'darwin') {
         const addrNum = parseInt(startAddress, 16);
@@ -96,7 +99,10 @@ export async function dumpMemoryRegion(platform, pid, startAddress, size, output
         if (!Number.isInteger(size) || size <= 0)
             return { success: false, error: 'Invalid size' };
         const psScript = buildMemoryDumpScript(pid, addrNum, size, outputPath);
-        const { stdout } = await executePowerShellScript(psScript, { maxBuffer: 1024 * 1024, timeout: 60000 });
+        const { stdout } = await executePowerShellScript(psScript, {
+            maxBuffer: 1024 * 1024,
+            timeout: 60000,
+        });
         const _trimmed = stdout.trim();
         if (!_trimmed)
             throw new Error('PowerShell returned empty output');

package/dist/src/modules/process/memory/regions.enumerate.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'fs';
 import { logger } from '../../../utils/logger.js';
-import { execAsync, executePowerShellScript } from '../../process/memory/types.js';
+import { execAsync, executePowerShellScript, } from '../../process/memory/types.js';
 import { parseProcMaps, formatLinuxProtection } from './linux/mapsParser.js';
 import { nativeMemoryManager } from '../../../native/NativeMemoryManager.js';
 import { isKoffiAvailable } from '../../../native/NativeMemoryManager.utils.js';
@@ -118,9 +118,8 @@ export async function enumerateRegions(platform, pid) {
     if (platform === 'linux') {
         try {
             const mapsContent = readFileSync(`/proc/${pid}/maps`, 'utf-8');
-            const readableRegions = parseProcMaps(mapsContent).filter(region => region.permissions.read);
-            const regions = readableRegions
-                .map(region => ({
+            const readableRegions = parseProcMaps(mapsContent).filter((region) => region.permissions.read);
+            const regions = readableRegions.map((region) => ({
                 baseAddress: `0x${region.start.toString(16)}`,
                 size: Number(region.end - region.start),
                 state: 'COMMIT',
@@ -136,11 +135,17 @@ export async function enumerateRegions(platform, pid) {
         }
     }
     if (platform !== 'win32' && platform !== 'darwin') {
-        return { success: false, error: 'Region enumeration currently only implemented for Windows, Linux, and macOS' };
+        return {
+            success: false,
+            error: 'Region enumeration currently only implemented for Windows, Linux, and macOS',
+        };
     }
     if (platform === 'darwin') {
         try {
-            const { stdout } = await execAsync(`vmmap -v ${pid}`, { timeout: 15000, maxBuffer: 1024 * 1024 * 5 });
+            const { stdout } = await execAsync(`vmmap -v ${pid}`, {
+                timeout: 15000,
+                maxBuffer: 1024 * 1024 * 5,
+            });
             const regions = [];
             const regionRe = /^(\S[^\t]*?)\s{2,}([0-9a-f]+)-([0-9a-f]+)\s+\[.*?\]\s+([a-z-]+)\/([a-z-]+)/;
             for (const line of stdout.split('\n')) {

package/dist/src/modules/process/memory/regions.modules.js

@@ -86,7 +86,10 @@ try {
     @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
 }
     `;
-        const { stdout } = await executePowerShellScript(psScript, { maxBuffer: 1024 * 1024 * 10, timeout: 30000 });
+        const { stdout } = await executePowerShellScript(psScript, {
+            maxBuffer: 1024 * 1024 * 10,
+            timeout: 30000,
+        });
         const _trimmed = stdout.trim();
         if (!_trimmed)
             throw new Error('PowerShell returned empty output');

package/dist/src/modules/process/memory/regions.protection.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'fs';
 import { logger } from '../../../utils/logger.js';
-import { execAsync, executePowerShellScript } from '../../process/memory/types.js';
+import { execAsync, executePowerShellScript, } from '../../process/memory/types.js';
 import { parseProcMaps, formatLinuxProtection } from './linux/mapsParser.js';
 import { nativeMemoryManager } from '../../../native/NativeMemoryManager.js';
 import { isKoffiAvailable } from '../../../native/NativeMemoryManager.utils.js';
@@ -119,7 +119,7 @@ export async function checkMemoryProtection(platform, pid, address) {
         try {
             const mapsContent = readFileSync(`/proc/${pid}/maps`, 'utf-8');
             const regions = parseProcMaps(mapsContent);
-            const region = regions.find(r => addrNum >= r.start && addrNum < r.end);
+            const region = regions.find((r) => addrNum >= r.start && addrNum < r.end);
             if (!region) {
                 return { success: false, error: `Address ${address} not found in any memory region` };
             }
@@ -142,7 +142,10 @@ export async function checkMemoryProtection(platform, pid, address) {
             const addrNum = parseInt(address, 16);
             if (isNaN(addrNum))
                 return { success: false, error: 'Invalid address format' };
-            const { stdout } = await execAsync(`vmmap -v ${pid}`, { timeout: 15000, maxBuffer: 1024 * 1024 * 5 });
+            const { stdout } = await execAsync(`vmmap -v ${pid}`, {
+                timeout: 15000,
+                maxBuffer: 1024 * 1024 * 5,
+            });
             const regionRe = /^(\S[^\t]*?)\s{2,}([0-9a-f]+)-([0-9a-f]+)\s+\[.*?\]\s+([a-z-]+)\/([a-z-]+)/;
             for (const line of stdout.split('\n')) {
                 const m = line.match(regionRe);
@@ -197,7 +200,10 @@ export async function checkMemoryProtection(platform, pid, address) {
             return { success: false, error: 'Invalid address format' };
         }
         const psScript = buildProtectionCheckScript(pid, addrNum);
-        const { stdout } = await executePowerShellScript(psScript, { maxBuffer: 1024 * 1024, timeout: 30000 });
+        const { stdout } = await executePowerShellScript(psScript, {
+            maxBuffer: 1024 * 1024,
+            timeout: 30000,
+        });
         const _trimmed = stdout.trim();
         if (!_trimmed)
             throw new Error('PowerShell returned empty output');

package/dist/src/modules/process/memory/scanner.darwin.js

@@ -10,9 +10,13 @@ export async function scanMemoryMac(pid, pattern, patternType) {
         patternMask = result.mask;
     }
     catch (e) {
-        return { success: false, addresses: [], error: e instanceof Error ? e.message : 'Invalid pattern' };
+        return {
+            success: false,
+            addresses: [],
+            error: e instanceof Error ? e.message : 'Invalid pattern',
+        };
     }
-    const byteList = patternBytes.map(b => `0x${b.toString(16)}`).join(',');
+    const byteList = patternBytes.map((b) => `0x${b.toString(16)}`).join(',');
     const maskList = patternMask.join(',');
     const tag = `${pid}_${Date.now()}`;
     const pyFile = `/tmp/lldb_scan_${tag}.py`;
@@ -66,9 +70,9 @@ def __lldb_init_module(debugger, internal_dict):
             timeout: 120000,
             maxBuffer: 1024 * 1024 * 5,
         });
-        const line = stdout.split('\n').find(l => l.startsWith('SCAN_RESULT:'));
+        const line = stdout.split('\n').find((l) => l.startsWith('SCAN_RESULT:'));
         if (!line) {
-            const errLine = stdout.split('\n').find(l => l.includes('error:')) ?? '';
+            const errLine = stdout.split('\n').find((l) => l.includes('error:')) ?? '';
             return {
                 success: false,
                 addresses: [],
@@ -78,7 +82,11 @@ def __lldb_init_module(debugger, internal_dict):
         return JSON.parse(line.slice('SCAN_RESULT:'.length));
     }
     catch (error) {
-        return { success: false, addresses: [], error: error instanceof Error ? error.message : String(error) };
+        return {
+            success: false,
+            addresses: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
     }
     finally {
         await fs.unlink(pyFile).catch(() => { });

package/dist/src/modules/process/memory/scanner.js

@@ -18,7 +18,11 @@ export async function scanMemory(platform, pid, pattern, patternType = 'hex') {
     }
     catch (error) {
         logger.error('Memory scan failed:', error);
-        return { success: false, addresses: [], error: error instanceof Error ? error.message : String(error) };
+        return {
+            success: false,
+            addresses: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
     }
 }
 export async function scanMemoryFiltered(pid, pattern, addresses, patternType = 'hex', _readMemoryFn, scanMemoryFn) {
@@ -33,13 +37,17 @@ export async function scanMemoryFiltered(pid, pattern, addresses, patternType =
     }
     const fullScan = await scanMemoryFn(pid, pattern, patternType);
     if (!fullScan.success || fullScan.addresses.length === 0) {
-        return { success: true, addresses: [], stats: { resultsFound: 0, patternLength: pattern.length } };
+        return {
+            success: true,
+            addresses: [],
+            stats: { resultsFound: 0, patternLength: pattern.length },
+        };
     }
     const windowSize = 256;
     const results = [];
     for (const matchAddr of fullScan.addresses) {
         const matchNum = parseInt(matchAddr, 16);
-        if (validAddresses.some(a => Math.abs(a - matchNum) < windowSize)) {
+        if (validAddresses.some((a) => Math.abs(a - matchNum) < windowSize)) {
             if (!results.includes(matchAddr)) {
                 results.push(matchAddr);
             }

package/dist/src/modules/process/memory/scanner.linux.js

@@ -43,7 +43,7 @@ export async function scanMemoryLinux(pid, pattern, patternType) {
                 error: formatLinuxProcAccessError(pid, 'maps', error),
             };
         }
-        const linuxRegions = parseProcMaps(mapsContent).filter(r => r.permissions.read);
+        const linuxRegions = parseProcMaps(mapsContent).filter((r) => r.permissions.read);
         let fd;
         try {
             fd = openSync(`/proc/${pid}/mem`, 'r');
@@ -78,7 +78,10 @@ export async function scanMemoryLinux(pid, pattern, patternType) {
                     }
                     catch (error) {
                         const err = error;
-                        if (err?.code === 'EIO' || err?.code === 'EFAULT' || err?.code === 'EACCES' || err?.code === 'EPERM') {
+                        if (err?.code === 'EIO' ||
+                            err?.code === 'EFAULT' ||
+                            err?.code === 'EACCES' ||
+                            err?.code === 'EPERM') {
                             logger.debug('Skipping unreadable Linux memory region chunk', {
                                 pid,
                                 start: `0x${region.start.toString(16)}`,

package/dist/src/modules/process/memory/scanner.windows.js

@@ -1,5 +1,5 @@
 import { logger } from '../../../utils/logger.js';
-import { executePowerShellScript, } from '../../process/memory/types.js';
+import { executePowerShellScript } from '../../process/memory/types.js';
 import { nativeMemoryManager } from '../../../native/NativeMemoryManager.js';
 import { isKoffiAvailable } from '../../../native/NativeMemoryManager.utils.js';
 import { buildPatternBytesAndMask } from './scanner.patterns.js';
@@ -181,7 +181,9 @@ export async function scanMemoryWindows(pid, pattern, patternType) {
         return {
             success: false,
             addresses: [],
-            error: error instanceof Error ? error.message : 'PowerShell execution failed. Run as Administrator.',
+            error: error instanceof Error
+                ? error.message
+                : 'PowerShell execution failed. Run as Administrator.',
         };
     }
 }

package/dist/src/modules/process/memory/writer.js

@@ -75,7 +75,9 @@ async function writeMemoryWindows(pid, address, data) {
         logger.error('Windows memory write failed:', error);
         return {
             success: false,
-            error: error instanceof Error ? error.message : 'PowerShell execution failed. Run as Administrator.',
+            error: error instanceof Error
+                ? error.message
+                : 'PowerShell execution failed. Run as Administrator.',
         };
     }
 }
@@ -116,15 +118,18 @@ async function writeMemoryMac(pid, address, data, checkProtectionFn) {
         return { success: false, error: `Cannot verify memory region: ${prot.error}` };
     }
     if (!prot.isWritable) {
-        return { success: false, error: `Address ${addrHex} is not writable (protection: ${prot.protection ?? 'unknown'})` };
+        return {
+            success: false,
+            error: `Address ${addrHex} is not writable (protection: ${prot.protection ?? 'unknown'})`,
+        };
     }
     try {
         const hexBytes = Array.from(data)
-            .map(b => `0x${b.toString(16).padStart(2, '0')}`)
+            .map((b) => `0x${b.toString(16).padStart(2, '0')}`)
             .join(' ');
         const { stdout } = await execAsync(`lldb --batch -p ${pid} -o "memory write ${addrHex} ${hexBytes}" -o "process detach"`, { timeout: 10000, maxBuffer: 1024 * 1024 });
         if (stdout.includes('error:')) {
-            const errLine = stdout.split('\n').find(l => l.includes('error:')) ?? stdout;
+            const errLine = stdout.split('\n').find((l) => l.includes('error:')) ?? stdout;
             return { success: false, error: `lldb memory write failed: ${errLine.trim()}` };
         }
         return { success: true, bytesWritten: data.length };
@@ -173,7 +178,10 @@ export async function writeMemory(platform, pid, address, data, encoding = 'hex'
             case 'darwin':
                 return writeMemoryMac(pid, addrNum, buffer, checkProtectionFn);
             default:
-                return { success: false, error: `Memory operations not supported on platform: ${platform}` };
+                return {
+                    success: false,
+                    error: `Memory operations not supported on platform: ${platform}`,
+                };
         }
     }
     catch (error) {
@@ -191,12 +199,12 @@ export async function batchMemoryWrite(pid, patches, writeFn) {
             error: result.error,
         });
     }
-    const allSuccess = results.every(r => r.success);
+    const allSuccess = results.every((r) => r.success);
     return {
         success: allSuccess,
         results,
         error: allSuccess
             ? undefined
-            : `Failed to write ${results.filter(r => !r.success).length} of ${results.length} patches`,
+            : `Failed to write ${results.filter((r) => !r.success).length} of ${results.length} patches`,
     };
 }

package/dist/src/modules/security/ExecutionSandbox.js

@@ -82,7 +82,7 @@ export class ExecutionSandbox {
             };
             terminationTimeout = setTimeout(() => {
                 if (!settled) {
-                    worker.terminate();
+                    void worker.terminate();
                     logger.warn(`[ExecutionSandbox] Worker terminated after ${timeoutMs + SANDBOX_TERMINATE_GRACE_MS}ms`);
                     finish({ ok: false, error: 'Execution timed out (worker terminated)', timedOut: true });
                 }
@@ -94,7 +94,7 @@ export class ExecutionSandbox {
                     error: msg.error,
                     timedOut: msg.timedOut || false,
                 });
-                worker.terminate();
+                void worker.terminate();
             });
             worker.on('error', (err) => {
                 finish({

package/dist/src/modules/stealth/CDPTimingProxy.d.ts

@@ -0,0 +1,20 @@
+import type { CDPTimingOptions } from './CDPTimingProxy.types.js';
+export interface CDPSessionLike {
+    send(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    on(event: string, handler: (params: unknown) => void): void;
+    off(event: string, handler: (params: unknown) => void): void;
+}
+export declare class CDPTimingProxy implements CDPSessionLike {
+    private readonly wrapped;
+    private options;
+    constructor(wrapped: CDPSessionLike, options?: Partial<CDPTimingOptions>);
+    send(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    on(event: string, handler: (params: unknown) => void): void;
+    off(event: string, handler: (params: unknown) => void): void;
+    configure(options: Partial<CDPTimingOptions>): void;
+    enterBurstMode(): void;
+    exitBurstMode(): void;
+    getOptions(): Readonly<CDPTimingOptions>;
+    getWrappedSession(): CDPSessionLike;
+}
+export declare function wrapWithJitter(session: CDPSessionLike, options?: Partial<CDPTimingOptions>): CDPTimingProxy;

package/dist/src/modules/stealth/CDPTimingProxy.js

@@ -0,0 +1,41 @@
+import { DEFAULT_TIMING_OPTIONS } from './CDPTimingProxy.types.js';
+export class CDPTimingProxy {
+    wrapped;
+    options;
+    constructor(wrapped, options) {
+        this.wrapped = wrapped;
+        this.options = { ...DEFAULT_TIMING_OPTIONS, ...options };
+    }
+    async send(method, params) {
+        if (this.options.enabled && !this.options.burstMode) {
+            const delay = this.options.minDelayMs +
+                Math.random() * (this.options.maxDelayMs - this.options.minDelayMs);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        return this.wrapped.send(method, params);
+    }
+    on(event, handler) {
+        this.wrapped.on(event, handler);
+    }
+    off(event, handler) {
+        this.wrapped.off(event, handler);
+    }
+    configure(options) {
+        this.options = { ...this.options, ...options };
+    }
+    enterBurstMode() {
+        this.options.burstMode = true;
+    }
+    exitBurstMode() {
+        this.options.burstMode = false;
+    }
+    getOptions() {
+        return { ...this.options };
+    }
+    getWrappedSession() {
+        return this.wrapped;
+    }
+}
+export function wrapWithJitter(session, options) {
+    return new CDPTimingProxy(session, options);
+}

package/dist/src/modules/stealth/CDPTimingProxy.types.d.ts

@@ -0,0 +1,7 @@
+export interface CDPTimingOptions {
+    enabled: boolean;
+    minDelayMs: number;
+    maxDelayMs: number;
+    burstMode: boolean;
+}
+export declare const DEFAULT_TIMING_OPTIONS: CDPTimingOptions;

package/dist/src/modules/stealth/CDPTimingProxy.types.js

@@ -0,0 +1,6 @@
+export const DEFAULT_TIMING_OPTIONS = {
+    enabled: true,
+    minDelayMs: 20,
+    maxDelayMs: 80,
+    burstMode: false,
+};

package/dist/src/modules/stealth/FingerprintManager.d.ts

@@ -0,0 +1,15 @@
+import type { Page } from 'rebrowser-puppeteer-core';
+import type { FingerprintProfile, FingerprintOptions } from './FingerprintManager.types.js';
+export declare class FingerprintManager {
+    private static instance;
+    private activeProfile;
+    private available;
+    private constructor();
+    static getInstance(): FingerprintManager;
+    isAvailable(): boolean;
+    generateFingerprint(options?: FingerprintOptions): Promise<FingerprintProfile | null>;
+    injectFingerprint(page: Page, profile: FingerprintProfile | Record<string, unknown>): Promise<void>;
+    getActiveProfile(): FingerprintProfile | null;
+    clearProfile(): void;
+    static resetInstance(): void;
+}