@jshookmcp/jshook 0.2.3 → 0.2.6

package/dist/src/modules/symbolic/JSVMPSymbolicExecutor.d.ts

@@ -59,6 +59,20 @@ export declare class JSVMPSymbolicExecutor extends SymbolicExecutor {
     private executeAdd;
     private executeSub;
     private executeMul;
+    private executeDiv;
+    private executeMod;
+    private executeAnd;
+    private executeOr;
+    private executeNot;
+    private executeXor;
+    private executeEq;
+    private executeNe;
+    private executeLt;
+    private executeLe;
+    private executeGt;
+    private executeGe;
+    private executeJnz;
+    private executeDup;
     private executeLoad;
     private executeStore;
     private executeJZ;

package/dist/src/modules/symbolic/JSVMPSymbolicExecutor.js

@@ -61,7 +61,7 @@ export class JSVMPSymbolicExecutor extends SymbolicExecutor {
                     break;
                 }
                 executionTrace.push(this.cloneStateInternal(state));
-                state = this.executeInstruction(state, instruction);
+                state = this.executeInstruction(state, instruction, instructions);
                 if (instruction.opcode === JSVMPOpcode.HALT) {
                     break;
                 }
@@ -88,7 +88,7 @@ export class JSVMPSymbolicExecutor extends SymbolicExecutor {
             throw error;
         }
     }
-    executeInstruction(state, instruction) {
+    executeInstruction(state, instruction, instructions) {
         const newState = this.cloneStateInternal(state);
         switch (instruction.opcode) {
             case JSVMPOpcode.PUSH:
@@ -106,6 +106,55 @@ export class JSVMPSymbolicExecutor extends SymbolicExecutor {
             case JSVMPOpcode.MUL:
                 this.executeMul(newState);
                 break;
+            case JSVMPOpcode.DIV:
+                this.executeDiv(newState);
+                break;
+            case JSVMPOpcode.MOD:
+                this.executeMod(newState);
+                break;
+            case JSVMPOpcode.AND:
+                this.executeAnd(newState);
+                break;
+            case JSVMPOpcode.OR:
+                this.executeOr(newState);
+                break;
+            case JSVMPOpcode.NOT:
+                this.executeNot(newState);
+                break;
+            case JSVMPOpcode.XOR:
+                this.executeXor(newState);
+                break;
+            case JSVMPOpcode.EQ:
+                this.executeEq(newState);
+                break;
+            case JSVMPOpcode.NE:
+                this.executeNe(newState);
+                break;
+            case JSVMPOpcode.LT:
+                this.executeLt(newState);
+                break;
+            case JSVMPOpcode.LE:
+                this.executeLe(newState);
+                break;
+            case JSVMPOpcode.GT:
+                this.executeGt(newState);
+                break;
+            case JSVMPOpcode.GE:
+                this.executeGe(newState);
+                break;
+            case JSVMPOpcode.JNZ:
+                this.executeJnz(newState, this.asNumberOperand(instruction.operands[0]));
+                return newState;
+            case JSVMPOpcode.RET:
+                newState.pc = instructions.length;
+                return newState;
+            case JSVMPOpcode.DUP:
+                this.executeDup(newState);
+                break;
+            case JSVMPOpcode.LOAD_CONST:
+                this.executePush(newState, instruction.operands[0]);
+                newState.pc++;
+                return newState;
             case JSVMPOpcode.LOAD:
                 this.executeLoad(newState, this.asStringOperand(instruction.operands[0]));
                 break;
@@ -168,6 +217,136 @@ export class JSVMPSymbolicExecutor extends SymbolicExecutor {
             state.stack.push(result);
         }
     }
+    executeDiv(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('number', `${a.name} / ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} / ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeMod(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('number', `${a.name} % ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} % ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeAnd(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} && ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} && ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeOr(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} || ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} || ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeNot(state) {
+        const a = state.stack.pop();
+        if (a) {
+            const result = this.createSymbolicValue('boolean', `!${a.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = !${a.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeXor(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} ^ ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} ^ ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeEq(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} === ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} === ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeNe(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} !== ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} !== ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeLt(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} < ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} < ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeLe(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} <= ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} <= ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeGt(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} > ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} > ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeGe(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} >= ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} >= ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeJnz(state, target) {
+        const condition = state.stack.pop();
+        if (condition) {
+            const constraint = {
+                type: 'inequality',
+                expression: `${condition.name} != 0`,
+                description: '',
+            };
+            state.pathConstraints.push(constraint);
+            state.pc = target;
+        }
+    }
+    executeDup(state) {
+        const value = state.stack[state.stack.length - 1];
+        if (value) {
+            const dup = this.createSymbolicValue(value.type, value.name, value.source);
+            dup.constraints = [...value.constraints];
+            if (value.possibleValues) {
+                dup.possibleValues = [...value.possibleValues];
+            }
+            state.stack.push(dup);
+        }
+    }
     executeLoad(state, varName) {
         const value = state.memory.get(varName);
         if (value) {

package/dist/src/modules/trace/TraceDB.js

@@ -1,3 +1,4 @@
+import { formatBetterSqlite3Error } from '../../utils/betterSqlite3.js';
 let Database;
 try {
     Database = require('better-sqlite3');
@@ -19,9 +20,14 @@ export class TraceDB {
     constructor(options) {
         this.options = options;
         if (!Database) {
-            throw new Error('better-sqlite3 is not installed. Install it with: pnpm add better-sqlite3');
+            throw new Error(formatBetterSqlite3Error(new Error("Cannot find package 'better-sqlite3'")));
+        }
+        try {
+            this.db = new Database(options.dbPath);
+        }
+        catch (error) {
+            throw new Error(formatBetterSqlite3Error(error), { cause: error });
         }
-        this.db = new Database(options.dbPath);
         this.batchSize = options.batchSize ?? 200;
         this.db.pragma('journal_mode = WAL');
         this.db.pragma('synchronous = NORMAL');
@@ -32,61 +38,61 @@ export class TraceDB {
         return this.options.dbPath;
     }
     createSchema() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        timestamp REAL NOT NULL,
-        category TEXT NOT NULL,
-        event_type TEXT NOT NULL,
-        data TEXT NOT NULL DEFAULT '{}',
-        script_id TEXT,
-        line_number INTEGER
-      );
-      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
-      CREATE INDEX IF NOT EXISTS idx_events_category_type ON events(category, event_type);
-      CREATE INDEX IF NOT EXISTS idx_events_script_id ON events(script_id);
-
-      CREATE TABLE IF NOT EXISTS memory_deltas (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        timestamp REAL NOT NULL,
-        address TEXT NOT NULL,
-        old_value TEXT NOT NULL,
-        new_value TEXT NOT NULL,
-        size INTEGER NOT NULL,
-        value_type TEXT NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_memory_timestamp ON memory_deltas(timestamp);
-      CREATE INDEX IF NOT EXISTS idx_memory_address ON memory_deltas(address);
-
-      CREATE TABLE IF NOT EXISTS heap_snapshots (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        timestamp REAL NOT NULL,
-        snapshot_data BLOB,
-        summary TEXT NOT NULL DEFAULT '{}'
-      );
-
-      CREATE TABLE IF NOT EXISTS metadata (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp REAL NOT NULL,
+        category TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        data TEXT NOT NULL DEFAULT '{}',
+        script_id TEXT,
+        line_number INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_events_category_type ON events(category, event_type);
+      CREATE INDEX IF NOT EXISTS idx_events_script_id ON events(script_id);
+
+      CREATE TABLE IF NOT EXISTS memory_deltas (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp REAL NOT NULL,
+        address TEXT NOT NULL,
+        old_value TEXT NOT NULL,
+        new_value TEXT NOT NULL,
+        size INTEGER NOT NULL,
+        value_type TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_memory_timestamp ON memory_deltas(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_memory_address ON memory_deltas(address);
+
+      CREATE TABLE IF NOT EXISTS heap_snapshots (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp REAL NOT NULL,
+        snapshot_data BLOB,
+        summary TEXT NOT NULL DEFAULT '{}'
+      );
+
+      CREATE TABLE IF NOT EXISTS metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
     `);
     }
     prepareStatements() {
-        this.insertEventStmt = this.db.prepare(`
-      INSERT INTO events (timestamp, category, event_type, data, script_id, line_number)
-      VALUES (?, ?, ?, ?, ?, ?)
+        this.insertEventStmt = this.db.prepare(`
+      INSERT INTO events (timestamp, category, event_type, data, script_id, line_number)
+      VALUES (?, ?, ?, ?, ?, ?)
     `);
-        this.insertDeltaStmt = this.db.prepare(`
-      INSERT INTO memory_deltas (timestamp, address, old_value, new_value, size, value_type)
-      VALUES (?, ?, ?, ?, ?, ?)
+        this.insertDeltaStmt = this.db.prepare(`
+      INSERT INTO memory_deltas (timestamp, address, old_value, new_value, size, value_type)
+      VALUES (?, ?, ?, ?, ?, ?)
     `);
-        this.insertSnapshotStmt = this.db.prepare(`
-      INSERT INTO heap_snapshots (timestamp, snapshot_data, summary)
-      VALUES (?, ?, ?)
+        this.insertSnapshotStmt = this.db.prepare(`
+      INSERT INTO heap_snapshots (timestamp, snapshot_data, summary)
+      VALUES (?, ?, ?)
     `);
-        this.upsertMetadataStmt = this.db.prepare(`
-      INSERT INTO metadata (key, value) VALUES (?, ?)
-      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+        this.upsertMetadataStmt = this.db.prepare(`
+      INSERT INTO metadata (key, value) VALUES (?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
     `);
     }
     insertEvent(event) {
@@ -138,19 +144,19 @@ export class TraceDB {
             return { columns, rows: [], rowCount: 0 };
         }
         const columns = Object.keys(rows[0]);
-        const rowArrays = rows.map(row => columns.map(col => row[col]));
+        const rowArrays = rows.map((row) => columns.map((col) => row[col]));
         return { columns, rows: rowArrays, rowCount: rows.length };
     }
     getEventsByTimeRange(start, end) {
         this.ensureOpen();
         this.flush();
-        const stmt = this.db.prepare(`
-      SELECT id, timestamp, category, event_type, data, script_id, line_number
-      FROM events
-      WHERE timestamp >= ? AND timestamp <= ?
-      ORDER BY timestamp ASC
+        const stmt = this.db.prepare(`
+      SELECT id, timestamp, category, event_type, data, script_id, line_number
+      FROM events
+      WHERE timestamp >= ? AND timestamp <= ?
+      ORDER BY timestamp ASC
     `);
-        return stmt.all(start, end).map(row => ({
+        return stmt.all(start, end).map((row) => ({
             id: row['id'],
             timestamp: row['timestamp'],
             category: row['category'],
@@ -163,13 +169,13 @@ export class TraceDB {
     getMemoryDeltasByAddress(address) {
         this.ensureOpen();
         this.flush();
-        const stmt = this.db.prepare(`
-      SELECT id, timestamp, address, old_value, new_value, size, value_type
-      FROM memory_deltas
-      WHERE address = ?
-      ORDER BY timestamp ASC
+        const stmt = this.db.prepare(`
+      SELECT id, timestamp, address, old_value, new_value, size, value_type
+      FROM memory_deltas
+      WHERE address = ?
+      ORDER BY timestamp ASC
     `);
-        return stmt.all(address).map(row => ({
+        return stmt.all(address).map((row) => ({
             id: row['id'],
             timestamp: row['timestamp'],
             address: row['address'],
@@ -181,12 +187,12 @@ export class TraceDB {
     }
     getHeapSnapshots() {
         this.ensureOpen();
-        const stmt = this.db.prepare(`
-      SELECT id, timestamp, snapshot_data, summary
-      FROM heap_snapshots
-      ORDER BY timestamp ASC
+        const stmt = this.db.prepare(`
+      SELECT id, timestamp, snapshot_data, summary
+      FROM heap_snapshots
+      ORDER BY timestamp ASC
     `);
-        return stmt.all().map(row => ({
+        return stmt.all().map((row) => ({
             id: row['id'],
             timestamp: row['timestamp'],
             snapshotData: row['snapshot_data'],

package/dist/src/modules/trace/TraceRecorder.js

@@ -4,11 +4,7 @@ import { resolveArtifactPath } from '../../utils/artifacts.js';
 const CDP_EVENTS_BY_DOMAIN = {
     Debugger: ['Debugger.paused', 'Debugger.resumed', 'Debugger.scriptParsed'],
     Runtime: ['Runtime.consoleAPICalled', 'Runtime.exceptionThrown'],
-    Network: [
-        'Network.requestWillBeSent',
-        'Network.responseReceived',
-        'Network.loadingFinished',
-    ],
+    Network: ['Network.requestWillBeSent', 'Network.responseReceived', 'Network.loadingFinished'],
     Page: ['Page.navigatedWithinDocument', 'Page.loadEventFired'],
 };
 const DEFAULT_CDP_DOMAINS = ['Debugger', 'Runtime', 'Network', 'Page'];

package/dist/src/native/AntiCheatDetector.js

@@ -1,27 +1,77 @@
 import { createHash } from 'node:crypto';
-import { readFileSync } from 'node:fs';
+import { promises as fs } from 'node:fs';
 import { logger } from '../utils/logger.js';
-import { openProcessForMemory, CloseHandle, ReadProcessMemory, VirtualQueryEx, PAGE, EnumProcessModules, GetModuleBaseName, GetModuleInformation, } from './Win32API.js';
+import { openProcessForMemory, CloseHandle, ReadProcessMemory, VirtualQueryEx, PAGE, EnumProcessModules, GetModuleBaseName, GetModuleFileNameEx, GetModuleInformation, } from './Win32API.js';
 import { PEAnalyzer } from './PEAnalyzer.js';
 const ANTI_DEBUG_IMPORTS = [
     {
         dll: 'kernel32.dll',
         funcs: [
-            { name: 'IsDebuggerPresent', mechanism: 'anti_debug_api', confidence: 'high', bypass: 'Hook IsDebuggerPresent to return 0, or patch PEB.BeingDebugged field' },
-            { name: 'CheckRemoteDebuggerPresent', mechanism: 'anti_debug_api', confidence: 'high', bypass: 'Hook CheckRemoteDebuggerPresent to set output to FALSE and return TRUE' },
-            { name: 'OutputDebugStringA', mechanism: 'exception_based', confidence: 'low', bypass: 'May be used for anti-debug timing — monitor for exception handler abuse' },
-            { name: 'GetTickCount', mechanism: 'timing_check', confidence: 'low', bypass: 'Hook GetTickCount to return consistent delta values' },
-            { name: 'GetTickCount64', mechanism: 'timing_check', confidence: 'low', bypass: 'Hook GetTickCount64 to return consistent delta values' },
-            { name: 'QueryPerformanceCounter', mechanism: 'timing_check', confidence: 'medium', bypass: 'Hook QPC to filter out debugging time deltas' },
+            {
+                name: 'IsDebuggerPresent',
+                mechanism: 'anti_debug_api',
+                confidence: 'high',
+                bypass: 'Hook IsDebuggerPresent to return 0, or patch PEB.BeingDebugged field',
+            },
+            {
+                name: 'CheckRemoteDebuggerPresent',
+                mechanism: 'anti_debug_api',
+                confidence: 'high',
+                bypass: 'Hook CheckRemoteDebuggerPresent to set output to FALSE and return TRUE',
+            },
+            {
+                name: 'OutputDebugStringA',
+                mechanism: 'exception_based',
+                confidence: 'low',
+                bypass: 'May be used for anti-debug timing — monitor for exception handler abuse',
+            },
+            {
+                name: 'GetTickCount',
+                mechanism: 'timing_check',
+                confidence: 'low',
+                bypass: 'Hook GetTickCount to return consistent delta values',
+            },
+            {
+                name: 'GetTickCount64',
+                mechanism: 'timing_check',
+                confidence: 'low',
+                bypass: 'Hook GetTickCount64 to return consistent delta values',
+            },
+            {
+                name: 'QueryPerformanceCounter',
+                mechanism: 'timing_check',
+                confidence: 'medium',
+                bypass: 'Hook QPC to filter out debugging time deltas',
+            },
         ],
     },
     {
         dll: 'ntdll.dll',
         funcs: [
-            { name: 'NtQueryInformationProcess', mechanism: 'ntquery_debug', confidence: 'high', bypass: 'Hook NtQueryInformationProcess: return 0 for ProcessDebugPort (7), ProcessDebugObjectHandle (30), ProcessDebugFlags (31)' },
-            { name: 'NtSetInformationThread', mechanism: 'thread_hiding', confidence: 'medium', bypass: 'Hook NtSetInformationThread: intercept ThreadHideFromDebugger (0x11) calls' },
-            { name: 'NtClose', mechanism: 'exception_based', confidence: 'low', bypass: 'NtClose with invalid handle detects debugger via exception — hook to suppress' },
-            { name: 'RtlGetNtGlobalFlags', mechanism: 'heap_flags', confidence: 'medium', bypass: 'Clear NtGlobalFlag (FLG_HEAP_*) in PEB at offset 0xBC (x64)' },
+            {
+                name: 'NtQueryInformationProcess',
+                mechanism: 'ntquery_debug',
+                confidence: 'high',
+                bypass: 'Hook NtQueryInformationProcess: return 0 for ProcessDebugPort (7), ProcessDebugObjectHandle (30), ProcessDebugFlags (31)',
+            },
+            {
+                name: 'NtSetInformationThread',
+                mechanism: 'thread_hiding',
+                confidence: 'medium',
+                bypass: 'Hook NtSetInformationThread: intercept ThreadHideFromDebugger (0x11) calls',
+            },
+            {
+                name: 'NtClose',
+                mechanism: 'exception_based',
+                confidence: 'low',
+                bypass: 'NtClose with invalid handle detects debugger via exception — hook to suppress',
+            },
+            {
+                name: 'RtlGetNtGlobalFlags',
+                mechanism: 'heap_flags',
+                confidence: 'medium',
+                bypass: 'Clear NtGlobalFlag (FLG_HEAP_*) in PEB at offset 0xBC (x64)',
+            },
         ],
     },
 ];
@@ -41,7 +91,7 @@ export class AntiCheatDetector {
                         for (const knownDll of ANTI_DEBUG_IMPORTS) {
                             if (dllLower.includes(knownDll.dll.toLowerCase().replace('.dll', ''))) {
                                 for (const func of knownDll.funcs) {
-                                    if (imp.functions.some(f => f.name === func.name)) {
+                                    if (imp.functions.some((f) => f.name === func.name)) {
                                         detections.push({
                                             mechanism: func.mechanism,
                                             confidence: func.confidence,
@@ -127,11 +177,11 @@ export class AntiCheatDetector {
         try {
             const modules = this._enumerateModules(hProcess);
             const targets = moduleName
-                ? modules.filter(m => m.name.toLowerCase().includes(moduleName.toLowerCase()))
+                ? modules.filter((m) => m.name.toLowerCase().includes(moduleName.toLowerCase()))
                 : modules;
             for (const mod of targets) {
                 try {
-                    const diskData = readFileSync(mod.path);
+                    const diskData = await fs.readFile(mod.path);
                     const sections = await this.peAnalyzer.listSections(pid, mod.base);
                     for (const sec of sections) {
                         if (!sec.isExecutable)
@@ -174,11 +224,12 @@ export class AntiCheatDetector {
                 const hMod = modHandles[i];
                 const name = GetModuleBaseName(hProcess, hMod);
                 const info = GetModuleInformation(hProcess, hMod);
+                const modulePath = GetModuleFileNameEx(hProcess, hMod) ?? name;
                 if (info.success) {
                     modules.push({
                         name,
                         base: `0x${info.info.lpBaseOfDll.toString(16)}`,
-                        path: `C:\\Windows\\System32\\${name}`,
+                        path: modulePath,
                         size: info.info.SizeOfImage,
                     });
                 }

package/dist/src/native/CodeInjector.js

@@ -54,7 +54,7 @@ export class CodeInjector {
         }
     }
     async nopBytes(pid, address, count) {
-        const nops = new Array(count).fill(0x90);
+        const nops = Array.from({ length: count }, () => 0x90);
         return this.patchBytes(pid, address, nops);
     }
     async findCodeCaves(pid, minSize) {
@@ -80,7 +80,7 @@ export class CodeInjector {
                             let caveStart = -1;
                             for (let i = 0; i < chunk.length; i++) {
                                 const b = chunk[i];
-                                if (b === 0x00 || b === 0xCC) {
+                                if (b === 0x00 || b === 0xcc) {
                                     if (caveStart === -1)
                                         caveStart = i;
                                 }
@@ -123,7 +123,7 @@ export class CodeInjector {
         finally {
             CloseHandle(handle);
         }
-        return caves.sort((a, b) => b.size - a.size);
+        return caves.toSorted((a, b) => b.size - a.size);
     }
     async allocateRemote(pid, size) {
         const handle = openProcessForMemory(pid, true);

package/dist/src/native/HardwareBreakpoint.js

@@ -1,7 +1,8 @@
 import { randomUUID } from 'node:crypto';
-import { BREAKPOINT_HIT_TIMEOUT_MS, BREAKPOINT_TRACE_MAX_HITS, } from '../constants.js';
+import { BREAKPOINT_HIT_TIMEOUT_MS, BREAKPOINT_TRACE_MAX_HITS } from '../constants.js';
 import { SuspendThread, ResumeThread, GetThreadContext, SetThreadContext, DebugActiveProcess, DebugActiveProcessStop, DebugSetProcessKillOnExit, WaitForDebugEvent, ContinueDebugEvent, EnumerateProcessThreads, openThreadForDebug, parseContext, writeContext, encodeDR7, CONTEXT_FLAGS, EXCEPTION_CODE, DBG, } from './Win32Debug.js';
 import { CloseHandle } from './Win32API.js';
+const toHex = (v) => `0x${v.toString(16).toUpperCase()}`;
 export class HardwareBreakpointEngine {
     breakpoints = new Map();
     attachedPids = new Set();
@@ -123,10 +124,10 @@ export class HardwareBreakpointEngine {
     applyDRToAllThreads(pid, drIndex, address, access, size, enable) {
         const threads = EnumerateProcessThreads(pid);
         const drAccessMap = {
-            'execute': 'execute',
-            'write': 'write',
-            'readwrite': 'readwrite',
-            'read': 'read',
+            execute: 'execute',
+            write: 'write',
+            readwrite: 'readwrite',
+            read: 'read',
         };
         for (const tid of threads) {
             let hThread;
@@ -172,7 +173,8 @@ export class HardwareBreakpointEngine {
                 try {
                     ResumeThread(hThread);
                 }
-                catch { }
+                catch {
+                }
             }
             finally {
                 CloseHandle(hThread);
@@ -203,7 +205,6 @@ export class HardwareBreakpointEngine {
                     bp.lastHit = Date.now();
                     ctxBuf.writeBigUInt64LE(0n, 0x68);
                     SetThreadContext(hThread, ctxBuf);
-                    const toHex = (v) => `0x${v.toString(16).toUpperCase()}`;
                     return {
                         breakpointId: id,
                         address: bp.address,
@@ -213,14 +214,22 @@ export class HardwareBreakpointEngine {
                         accessType: bp.access,
                         timestamp: Date.now(),
                         registers: {
-                            rax: toHex(ctx.rax), rbx: toHex(ctx.rbx),
-                            rcx: toHex(ctx.rcx), rdx: toHex(ctx.rdx),
-                            rsi: toHex(ctx.rsi), rdi: toHex(ctx.rdi),
-                            rsp: toHex(ctx.rsp), rbp: toHex(ctx.rbp),
-                            r8: toHex(ctx.r8), r9: toHex(ctx.r9),
-                            r10: toHex(ctx.r10), r11: toHex(ctx.r11),
-                            r12: toHex(ctx.r12), r13: toHex(ctx.r13),
-                            r14: toHex(ctx.r14), r15: toHex(ctx.r15),
+                            rax: toHex(ctx.rax),
+                            rbx: toHex(ctx.rbx),
+                            rcx: toHex(ctx.rcx),
+                            rdx: toHex(ctx.rdx),
+                            rsi: toHex(ctx.rsi),
+                            rdi: toHex(ctx.rdi),
+                            rsp: toHex(ctx.rsp),
+                            rbp: toHex(ctx.rbp),
+                            r8: toHex(ctx.r8),
+                            r9: toHex(ctx.r9),
+                            r10: toHex(ctx.r10),
+                            r11: toHex(ctx.r11),
+                            r12: toHex(ctx.r12),
+                            r13: toHex(ctx.r13),
+                            r14: toHex(ctx.r14),
+                            r15: toHex(ctx.r15),
                             rip: toHex(ctx.rip),
                             rflags: `0x${ctx.eflags.toString(16).toUpperCase()}`,
                         },