@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/native/Win32API.js

@@ -1,271 +0,0 @@
-import koffi from 'koffi';
-import { logger } from '../utils/logger.js';
-export const PROCESS_ACCESS = {
-    TERMINATE: 0x0001,
-    CREATE_THREAD: 0x0002,
-    SET_SESSIONID: 0x0004,
-    VM_OPERATION: 0x0008,
-    VM_READ: 0x0010,
-    VM_WRITE: 0x0020,
-    DUP_HANDLE: 0x0040,
-    CREATE_PROCESS: 0x0080,
-    SET_QUOTA: 0x0100,
-    SET_INFORMATION: 0x0200,
-    QUERY_INFORMATION: 0x0400,
-    SUSPEND_RESUME: 0x0800,
-    QUERY_LIMITED_INFORMATION: 0x1000,
-    ALL_ACCESS: 0x1f0fff,
-};
-export const MEM = {
-    COMMIT: 0x1000,
-    RESERVE: 0x2000,
-    DECOMMIT: 0x4000,
-    RELEASE: 0x8000,
-    FREE: 0x10000,
-    PRIVATE: 0x20000,
-    MAPPED: 0x40000,
-    RESET: 0x80000,
-    TOP_DOWN: 0x100000,
-    WRITE_WATCH: 0x200000,
-    PHYSICAL: 0x400000,
-    LARGE_PAGES: 0x20000000,
-};
-export const PAGE = {
-    NOACCESS: 0x01,
-    READONLY: 0x02,
-    READWRITE: 0x04,
-    WRITECOPY: 0x08,
-    EXECUTE: 0x10,
-    EXECUTE_READ: 0x20,
-    EXECUTE_READWRITE: 0x40,
-    EXECUTE_WRITECOPY: 0x80,
-    GUARD: 0x100,
-    NOCACHE: 0x200,
-    WRITECOMBINE: 0x400,
-};
-export const MEM_TYPE = {
-    IMAGE: 0x1000000,
-    MAPPED: 0x40000,
-    PRIVATE: 0x20000,
-};
-let kernel32 = null;
-let ntdll = null;
-let psapi = null;
-let koffiAvailable = null;
-export function isKoffiAvailable() {
-    if (koffiAvailable !== null) {
-        return koffiAvailable;
-    }
-    try {
-        const testLib = koffi.load('kernel32.dll');
-        testLib.unload();
-        koffiAvailable = true;
-        return true;
-    }
-    catch {
-        koffiAvailable = false;
-        return false;
-    }
-}
-export function isWindows() {
-    return process.platform === 'win32';
-}
-function getKernel32() {
-    if (!kernel32) {
-        kernel32 = koffi.load('kernel32.dll');
-        logger.debug('Loaded kernel32.dll via koffi');
-    }
-    return kernel32;
-}
-function getNtdll() {
-    if (!ntdll) {
-        ntdll = koffi.load('ntdll.dll');
-        logger.debug('Loaded ntdll.dll via koffi');
-    }
-    return ntdll;
-}
-function getPsapi() {
-    if (!psapi) {
-        psapi = koffi.load('psapi.dll');
-        logger.debug('Loaded psapi.dll via koffi');
-    }
-    return psapi;
-}
-export function OpenProcess(dwDesiredAccess, bInheritHandle, dwProcessId) {
-    const fn = getKernel32().func('void * OpenProcess(uint32, int, uint32)');
-    return fn(dwDesiredAccess, bInheritHandle ? 1 : 0, dwProcessId);
-}
-export function CloseHandle(hObject) {
-    const fn = getKernel32().func('int CloseHandle(void *)');
-    return fn(hObject) !== 0;
-}
-export function ReadProcessMemory(hProcess, lpBaseAddress, size) {
-    const fn = getKernel32().func('int ReadProcessMemory(void *, void *, _Out_ uint8_t[len], size_t len, _Out_ size_t *bytesRead)');
-    const buffer = Buffer.alloc(size);
-    const bytesReadBuf = Buffer.alloc(8);
-    const result = fn(hProcess, lpBaseAddress, buffer, BigInt(size), bytesReadBuf);
-    if (result === 0) {
-        const error = GetLastError();
-        throw new Error(`ReadProcessMemory failed. Error: 0x${error.toString(16)}`);
-    }
-    return buffer;
-}
-export function WriteProcessMemory(hProcess, lpBaseAddress, data) {
-    const fn = getKernel32().func('int WriteProcessMemory(void *, void *, uint8_t[len], size_t len, _Out_ size_t *bytesWritten)');
-    const bytesWrittenBuf = Buffer.alloc(8);
-    const result = fn(hProcess, lpBaseAddress, data, BigInt(data.length), bytesWrittenBuf);
-    if (result === 0) {
-        const error = GetLastError();
-        throw new Error(`WriteProcessMemory failed. Error: 0x${error.toString(16)}`);
-    }
-    return Number(bytesWrittenBuf.readBigUInt64LE());
-}
-export function VirtualQueryEx(hProcess, lpAddress) {
-    const fn = getKernel32().func('size_t VirtualQueryEx(void *, void *, _Out_ uint8_t[48], size_t)');
-    const structSize = 48;
-    const buffer = Buffer.alloc(structSize);
-    const result = fn(hProcess, lpAddress, buffer, BigInt(structSize));
-    if (Number(result) !== structSize) {
-        return { success: false, info: {} };
-    }
-    const info = {
-        BaseAddress: buffer.readBigUInt64LE(0),
-        AllocationBase: buffer.readBigUInt64LE(8),
-        AllocationProtect: buffer.readUInt32LE(16),
-        RegionSize: buffer.readBigUInt64LE(24),
-        State: buffer.readUInt32LE(32),
-        Protect: buffer.readUInt32LE(36),
-        Type: buffer.readUInt32LE(40),
-    };
-    return { success: true, info };
-}
-export function VirtualProtectEx(hProcess, lpAddress, dwSize, flNewProtect) {
-    const fn = getKernel32().func('int VirtualProtectEx(void *, void *, size_t, uint32, _Out_ uint32 *)');
-    const oldProtectBuf = Buffer.alloc(4);
-    const result = fn(hProcess, lpAddress, BigInt(dwSize), flNewProtect, oldProtectBuf);
-    return {
-        success: result !== 0,
-        oldProtect: oldProtectBuf.readUInt32LE(0),
-    };
-}
-export function VirtualAllocEx(hProcess, lpAddress, dwSize, flAllocationType, flProtect) {
-    const fn = getKernel32().func('void * VirtualAllocEx(void *, void *, size_t, uint32, uint32)');
-    return fn(hProcess, lpAddress, BigInt(dwSize), flAllocationType, flProtect);
-}
-export function VirtualFreeEx(hProcess, lpAddress, dwSize, dwFreeType) {
-    const fn = getKernel32().func('int VirtualFreeEx(void *, void *, size_t, uint32)');
-    return fn(hProcess, lpAddress, BigInt(dwSize), dwFreeType) !== 0;
-}
-export function CreateRemoteThread(hProcess, lpStartAddress, lpParameter) {
-    const fn = getKernel32().func('void * CreateRemoteThread(void *, void *, size_t, void *, void *, uint32, _Out_ uint32 *)');
-    const threadIdBuf = Buffer.alloc(4);
-    const handle = fn(hProcess, null, 0n, lpStartAddress, lpParameter, 0, threadIdBuf);
-    return {
-        handle,
-        threadId: threadIdBuf.readUInt32LE(0),
-    };
-}
-export function GetModuleHandle(lpModuleName) {
-    const fn = getKernel32().func('void * GetModuleHandleA(char *)');
-    return fn(lpModuleName);
-}
-export function GetProcAddress(hModule, lpProcName) {
-    const fn = getKernel32().func('void * GetProcAddress(void *, char *)');
-    return fn(hModule, lpProcName);
-}
-export function GetLastError() {
-    const fn = getKernel32().func('uint32 GetLastError()');
-    return fn();
-}
-export function NtQueryInformationProcess(hProcess, processInformationClass) {
-    const fn = getNtdll().func('int32 NtQueryInformationProcess(void *, uint32, _Out_ void *, uint32, void *)');
-    const debugPortBuf = Buffer.alloc(8);
-    const status = fn(hProcess, processInformationClass, debugPortBuf, 8, null);
-    return {
-        status,
-        debugPort: Number(debugPortBuf.readBigUInt64LE()),
-    };
-}
-export function EnumProcessModules(hProcess, maxModules = 1024) {
-    const fn = getPsapi().func('int EnumProcessModules(void *, _Out_ void *[], uint32, _Out_ uint32 *)');
-    const moduleBuf = Buffer.alloc(maxModules * 8);
-    const neededBuf = Buffer.alloc(4);
-    const result = fn(hProcess, moduleBuf, maxModules * 8, neededBuf);
-    const needed = neededBuf.readUInt32LE(0);
-    const count = Math.floor(needed / 8);
-    const modules = [];
-    for (let i = 0; i < count; i++) {
-        modules.push(moduleBuf.readBigUInt64LE(i * 8));
-    }
-    return {
-        success: result !== 0,
-        modules,
-        count,
-    };
-}
-export function GetModuleBaseName(hProcess, hModule, maxSize = 260) {
-    const fn = getPsapi().func('uint32 GetModuleBaseNameA(void *, void *, _Out_ char[], uint32)');
-    const buffer = Buffer.alloc(maxSize);
-    fn(hProcess, hModule, buffer, maxSize);
-    let len = 0;
-    while (len < maxSize && buffer[len] !== 0) {
-        len++;
-    }
-    return buffer.toString('utf8', 0, len);
-}
-export function GetModuleFileNameEx(hProcess, hModule, maxSize = 32_768) {
-    const fn = getPsapi().func('uint32 GetModuleFileNameExA(void *, void *, _Out_ char[], uint32)');
-    const buffer = Buffer.alloc(maxSize);
-    const result = fn(hProcess, hModule, buffer, maxSize);
-    if (typeof result !== 'number' || result <= 0) {
-        return null;
-    }
-    let len = 0;
-    while (len < maxSize && buffer[len] !== 0) {
-        len++;
-    }
-    return len > 0 ? buffer.toString('utf8', 0, len) : null;
-}
-export function GetModuleInformation(hProcess, hModule) {
-    const fn = getPsapi().func('int GetModuleInformation(void *, void *, _Out_ uint8_t[24], uint32)');
-    const buffer = Buffer.alloc(24);
-    const result = fn(hProcess, hModule, buffer, 24);
-    const info = {
-        lpBaseOfDll: buffer.readBigUInt64LE(0),
-        SizeOfImage: buffer.readUInt32LE(8),
-        EntryPoint: buffer.readBigUInt64LE(16),
-    };
-    return {
-        success: result !== 0,
-        info,
-    };
-}
-export function openProcessForMemory(pid, writeAccess = false) {
-    const access = writeAccess
-        ? PROCESS_ACCESS.VM_READ |
-            PROCESS_ACCESS.VM_WRITE |
-            PROCESS_ACCESS.VM_OPERATION |
-            PROCESS_ACCESS.QUERY_INFORMATION
-        : PROCESS_ACCESS.VM_READ | PROCESS_ACCESS.QUERY_INFORMATION;
-    const handle = OpenProcess(access, false, pid);
-    if (handle === 0n) {
-        const error = GetLastError();
-        throw new Error(`Failed to open process ${pid}. Error: 0x${error.toString(16)}. Run as Administrator.`);
-    }
-    return handle;
-}
-export function unloadLibraries() {
-    if (kernel32) {
-        kernel32.unload();
-        kernel32 = null;
-    }
-    if (ntdll) {
-        ntdll.unload();
-        ntdll = null;
-    }
-    if (psapi) {
-        psapi.unload();
-        psapi = null;
-    }
-    logger.debug('Unloaded all native libraries');
-}

package/dist/src/native/Win32Debug.d.ts

@@ -1,112 +0,0 @@
-export declare const THREAD_ACCESS: {
-    readonly TERMINATE: 1;
-    readonly SUSPEND_RESUME: 2;
-    readonly GET_CONTEXT: 8;
-    readonly SET_CONTEXT: 16;
-    readonly SET_INFORMATION: 32;
-    readonly QUERY_INFORMATION: 64;
-    readonly SET_THREAD_TOKEN: 128;
-    readonly IMPERSONATE: 256;
-    readonly DIRECT_IMPERSONATION: 512;
-    readonly ALL_ACCESS: 2032639;
-};
-export declare const CONTEXT_FLAGS: {
-    readonly AMD64: 1048576;
-    readonly CONTROL: 1048577;
-    readonly INTEGER: 1048578;
-    readonly SEGMENTS: 1048580;
-    readonly FLOATING_POINT: 1048584;
-    readonly DEBUG_REGISTERS: 1048592;
-    readonly FULL: 1048587;
-    readonly ALL: 1048607;
-};
-export declare const DEBUG_EVENT_CODE: {
-    readonly EXCEPTION_DEBUG_EVENT: 1;
-    readonly CREATE_THREAD_DEBUG_EVENT: 2;
-    readonly CREATE_PROCESS_DEBUG_EVENT: 3;
-    readonly EXIT_THREAD_DEBUG_EVENT: 4;
-    readonly EXIT_PROCESS_DEBUG_EVENT: 5;
-    readonly LOAD_DLL_DEBUG_EVENT: 6;
-    readonly UNLOAD_DLL_DEBUG_EVENT: 7;
-    readonly OUTPUT_DEBUG_STRING_EVENT: 8;
-    readonly RIP_EVENT: 9;
-};
-export declare const EXCEPTION_CODE: {
-    readonly SINGLE_STEP: 2147483652;
-    readonly BREAKPOINT: 2147483651;
-    readonly ACCESS_VIOLATION: 3221225477;
-};
-export declare const DBG: {
-    readonly CONTINUE: 65538;
-    readonly EXCEPTION_NOT_HANDLED: 2147549185;
-    readonly REPLY_LATER: 1073807361;
-};
-export declare const DR7: {
-    readonly localEnable: (drIndex: number) => bigint;
-    readonly conditionShift: (drIndex: number) => number;
-    readonly sizeShift: (drIndex: number) => number;
-};
-export declare const TH32CS: {
-    readonly SNAPHEAPLIST: 1;
-    readonly SNAPTHREAD: 4;
-    readonly SNAPMODULE: 8;
-};
-export declare const CONTEXT_SIZE = 1232;
-export interface X64Context {
-    contextFlags: number;
-    dr0: bigint;
-    dr1: bigint;
-    dr2: bigint;
-    dr3: bigint;
-    dr6: bigint;
-    dr7: bigint;
-    rax: bigint;
-    rcx: bigint;
-    rdx: bigint;
-    rbx: bigint;
-    rsp: bigint;
-    rbp: bigint;
-    rsi: bigint;
-    rdi: bigint;
-    r8: bigint;
-    r9: bigint;
-    r10: bigint;
-    r11: bigint;
-    r12: bigint;
-    r13: bigint;
-    r14: bigint;
-    r15: bigint;
-    rip: bigint;
-    eflags: number;
-}
-export declare function parseContext(buf: Buffer): X64Context;
-export declare function writeContext(buf: Buffer, ctx: Partial<X64Context>): void;
-export declare function OpenThread(dwDesiredAccess: number, bInheritHandle: boolean, dwThreadId: number): bigint;
-export declare function SuspendThread(hThread: bigint): number;
-export declare function ResumeThread(hThread: bigint): number;
-export declare function GetThreadContext(hThread: bigint, contextFlags: number): Buffer;
-export declare function SetThreadContext(hThread: bigint, contextBuf: Buffer): void;
-export declare function DebugActiveProcess(dwProcessId: number): void;
-export declare function DebugActiveProcessStop(dwProcessId: number): void;
-export declare function DebugSetProcessKillOnExit(killOnExit: boolean): void;
-export declare const DEBUG_EVENT_SIZE = 176;
-export interface DebugEventInfo {
-    debugEventCode: number;
-    processId: number;
-    threadId: number;
-    exceptionCode?: number;
-    exceptionAddress?: bigint;
-    firstChance?: boolean;
-}
-export declare function WaitForDebugEvent(timeoutMs: number): DebugEventInfo | null;
-export declare function ContinueDebugEvent(dwProcessId: number, dwThreadId: number, dwContinueStatus: number): void;
-export declare function FlushInstructionCache(hProcess: bigint, lpBaseAddress: bigint, dwSize: number): void;
-export declare function EnumerateProcessThreads(pid: number): number[];
-export declare function openThreadForDebug(threadId: number): bigint;
-export declare function encodeDR7(entries: Array<{
-    drIndex: number;
-    enabled: boolean;
-    access: 'execute' | 'write' | 'readwrite' | 'read';
-    size: 1 | 2 | 4 | 8;
-}>): bigint;
-export declare function unloadDebugLibraries(): void;

package/dist/src/native/Win32Debug.js

@@ -1,284 +0,0 @@
-import koffi from 'koffi';
-import { logger } from '../utils/logger.js';
-import { GetLastError, CloseHandle } from './Win32API.js';
-export const THREAD_ACCESS = {
-    TERMINATE: 0x0001,
-    SUSPEND_RESUME: 0x0002,
-    GET_CONTEXT: 0x0008,
-    SET_CONTEXT: 0x0010,
-    SET_INFORMATION: 0x0020,
-    QUERY_INFORMATION: 0x0040,
-    SET_THREAD_TOKEN: 0x0080,
-    IMPERSONATE: 0x0100,
-    DIRECT_IMPERSONATION: 0x0200,
-    ALL_ACCESS: 0x1f03ff,
-};
-export const CONTEXT_FLAGS = {
-    AMD64: 0x00100000,
-    CONTROL: 0x00100001,
-    INTEGER: 0x00100002,
-    SEGMENTS: 0x00100004,
-    FLOATING_POINT: 0x00100008,
-    DEBUG_REGISTERS: 0x00100010,
-    FULL: 0x0010000b,
-    ALL: 0x0010001f,
-};
-export const DEBUG_EVENT_CODE = {
-    EXCEPTION_DEBUG_EVENT: 1,
-    CREATE_THREAD_DEBUG_EVENT: 2,
-    CREATE_PROCESS_DEBUG_EVENT: 3,
-    EXIT_THREAD_DEBUG_EVENT: 4,
-    EXIT_PROCESS_DEBUG_EVENT: 5,
-    LOAD_DLL_DEBUG_EVENT: 6,
-    UNLOAD_DLL_DEBUG_EVENT: 7,
-    OUTPUT_DEBUG_STRING_EVENT: 8,
-    RIP_EVENT: 9,
-};
-export const EXCEPTION_CODE = {
-    SINGLE_STEP: 0x80000004,
-    BREAKPOINT: 0x80000003,
-    ACCESS_VIOLATION: 0xc0000005,
-};
-export const DBG = {
-    CONTINUE: 0x00010002,
-    EXCEPTION_NOT_HANDLED: 0x80010001,
-    REPLY_LATER: 0x40010001,
-};
-export const DR7 = {
-    localEnable: (drIndex) => 1n << BigInt(drIndex * 2),
-    conditionShift: (drIndex) => 16 + drIndex * 4,
-    sizeShift: (drIndex) => 18 + drIndex * 4,
-};
-export const TH32CS = {
-    SNAPHEAPLIST: 0x00000001,
-    SNAPTHREAD: 0x00000004,
-    SNAPMODULE: 0x00000008,
-};
-export const CONTEXT_SIZE = 1232;
-export function parseContext(buf) {
-    return {
-        contextFlags: buf.readUInt32LE(0x30),
-        eflags: buf.readUInt32LE(0x44),
-        dr0: buf.readBigUInt64LE(0x48),
-        dr1: buf.readBigUInt64LE(0x50),
-        dr2: buf.readBigUInt64LE(0x58),
-        dr3: buf.readBigUInt64LE(0x60),
-        dr6: buf.readBigUInt64LE(0x68),
-        dr7: buf.readBigUInt64LE(0x70),
-        rax: buf.readBigUInt64LE(0x78),
-        rcx: buf.readBigUInt64LE(0x80),
-        rdx: buf.readBigUInt64LE(0x88),
-        rbx: buf.readBigUInt64LE(0x90),
-        rsp: buf.readBigUInt64LE(0x98),
-        rbp: buf.readBigUInt64LE(0xa0),
-        rsi: buf.readBigUInt64LE(0xa8),
-        rdi: buf.readBigUInt64LE(0xb0),
-        r8: buf.readBigUInt64LE(0xb8),
-        r9: buf.readBigUInt64LE(0xc0),
-        r10: buf.readBigUInt64LE(0xc8),
-        r11: buf.readBigUInt64LE(0xd0),
-        r12: buf.readBigUInt64LE(0xd8),
-        r13: buf.readBigUInt64LE(0xe0),
-        r14: buf.readBigUInt64LE(0xe8),
-        r15: buf.readBigUInt64LE(0xf0),
-        rip: buf.readBigUInt64LE(0xf8),
-    };
-}
-export function writeContext(buf, ctx) {
-    if (ctx.contextFlags !== undefined)
-        buf.writeUInt32LE(ctx.contextFlags, 0x30);
-    if (ctx.eflags !== undefined)
-        buf.writeUInt32LE(ctx.eflags, 0x44);
-    if (ctx.dr0 !== undefined)
-        buf.writeBigUInt64LE(ctx.dr0, 0x48);
-    if (ctx.dr1 !== undefined)
-        buf.writeBigUInt64LE(ctx.dr1, 0x50);
-    if (ctx.dr2 !== undefined)
-        buf.writeBigUInt64LE(ctx.dr2, 0x58);
-    if (ctx.dr3 !== undefined)
-        buf.writeBigUInt64LE(ctx.dr3, 0x60);
-    if (ctx.dr6 !== undefined)
-        buf.writeBigUInt64LE(ctx.dr6, 0x68);
-    if (ctx.dr7 !== undefined)
-        buf.writeBigUInt64LE(ctx.dr7, 0x70);
-    if (ctx.rip !== undefined)
-        buf.writeBigUInt64LE(ctx.rip, 0xf8);
-}
-let kernel32Debug = null;
-function getKernel32() {
-    if (!kernel32Debug) {
-        kernel32Debug = koffi.load('kernel32.dll');
-        logger.debug('Loaded kernel32.dll for debug APIs');
-    }
-    return kernel32Debug;
-}
-export function OpenThread(dwDesiredAccess, bInheritHandle, dwThreadId) {
-    const fn = getKernel32().func('void * OpenThread(uint32, int, uint32)');
-    return fn(dwDesiredAccess, bInheritHandle ? 1 : 0, dwThreadId);
-}
-export function SuspendThread(hThread) {
-    const fn = getKernel32().func('uint32 SuspendThread(void *)');
-    const result = fn(hThread);
-    if (result === 0xffffffff) {
-        throw new Error(`SuspendThread failed. Error: 0x${GetLastError().toString(16)}`);
-    }
-    return result;
-}
-export function ResumeThread(hThread) {
-    const fn = getKernel32().func('uint32 ResumeThread(void *)');
-    const result = fn(hThread);
-    if (result === 0xffffffff) {
-        throw new Error(`ResumeThread failed. Error: 0x${GetLastError().toString(16)}`);
-    }
-    return result;
-}
-export function GetThreadContext(hThread, contextFlags) {
-    const fn = getKernel32().func('int GetThreadContext(void *, _Inout_ uint8_t[1232])');
-    const buf = Buffer.alloc(CONTEXT_SIZE);
-    buf.writeUInt32LE(contextFlags, 0x30);
-    const result = fn(hThread, buf);
-    if (result === 0) {
-        throw new Error(`GetThreadContext failed. Error: 0x${GetLastError().toString(16)}`);
-    }
-    return buf;
-}
-export function SetThreadContext(hThread, contextBuf) {
-    const fn = getKernel32().func('int SetThreadContext(void *, uint8_t[1232])');
-    const result = fn(hThread, contextBuf);
-    if (result === 0) {
-        throw new Error(`SetThreadContext failed. Error: 0x${GetLastError().toString(16)}`);
-    }
-}
-export function DebugActiveProcess(dwProcessId) {
-    const fn = getKernel32().func('int DebugActiveProcess(uint32)');
-    const result = fn(dwProcessId);
-    if (result === 0) {
-        throw new Error(`DebugActiveProcess failed for pid ${dwProcessId}. Error: 0x${GetLastError().toString(16)}`);
-    }
-}
-export function DebugActiveProcessStop(dwProcessId) {
-    const fn = getKernel32().func('int DebugActiveProcessStop(uint32)');
-    const result = fn(dwProcessId);
-    if (result === 0) {
-        throw new Error(`DebugActiveProcessStop failed. Error: 0x${GetLastError().toString(16)}`);
-    }
-}
-export function DebugSetProcessKillOnExit(killOnExit) {
-    const fn = getKernel32().func('int DebugSetProcessKillOnExit(int)');
-    fn(killOnExit ? 1 : 0);
-}
-export const DEBUG_EVENT_SIZE = 176;
-export function WaitForDebugEvent(timeoutMs) {
-    const fn = getKernel32().func('int WaitForDebugEvent(_Out_ uint8_t[176], uint32)');
-    const buf = Buffer.alloc(DEBUG_EVENT_SIZE);
-    const result = fn(buf, timeoutMs);
-    if (result === 0)
-        return null;
-    const info = {
-        debugEventCode: buf.readUInt32LE(0x00),
-        processId: buf.readUInt32LE(0x04),
-        threadId: buf.readUInt32LE(0x08),
-    };
-    if (info.debugEventCode === DEBUG_EVENT_CODE.EXCEPTION_DEBUG_EVENT) {
-        info.exceptionCode = buf.readUInt32LE(0x10);
-        info.exceptionAddress = buf.readBigUInt64LE(0x20);
-        info.firstChance = buf.readUInt32LE(0x14) === 0;
-    }
-    return info;
-}
-export function ContinueDebugEvent(dwProcessId, dwThreadId, dwContinueStatus) {
-    const fn = getKernel32().func('int ContinueDebugEvent(uint32, uint32, uint32)');
-    const result = fn(dwProcessId, dwThreadId, dwContinueStatus);
-    if (result === 0) {
-        throw new Error(`ContinueDebugEvent failed. Error: 0x${GetLastError().toString(16)}`);
-    }
-}
-export function FlushInstructionCache(hProcess, lpBaseAddress, dwSize) {
-    const fn = getKernel32().func('int FlushInstructionCache(void *, void *, size_t)');
-    fn(hProcess, lpBaseAddress, BigInt(dwSize));
-}
-export function EnumerateProcessThreads(pid) {
-    const fnSnapshot = getKernel32().func('void * CreateToolhelp32Snapshot(uint32, uint32)');
-    const fnFirst = getKernel32().func('int Thread32First(void *, _Inout_ uint8_t[28])');
-    const fnNext = getKernel32().func('int Thread32Next(void *, _Inout_ uint8_t[28])');
-    const snapshot = fnSnapshot(TH32CS.SNAPTHREAD, 0);
-    if (snapshot === 0n || snapshot === BigInt('0xFFFFFFFFFFFFFFFF')) {
-        throw new Error(`CreateToolhelp32Snapshot failed. Error: 0x${GetLastError().toString(16)}`);
-    }
-    const threads = [];
-    const entry = Buffer.alloc(28);
-    entry.writeUInt32LE(28, 0);
-    try {
-        if (fnFirst(snapshot, entry) !== 0) {
-            do {
-                const ownerPid = entry.readUInt32LE(0x0c);
-                if (ownerPid === pid) {
-                    threads.push(entry.readUInt32LE(0x08));
-                }
-                entry.writeUInt32LE(28, 0);
-            } while (fnNext(snapshot, entry) !== 0);
-        }
-        CloseHandle(snapshot);
-    }
-    catch (e) {
-        console.error('[EnumerateProcessThreads] cleanup error:', e);
-    }
-    return threads;
-}
-export function openThreadForDebug(threadId) {
-    const access = THREAD_ACCESS.SUSPEND_RESUME |
-        THREAD_ACCESS.GET_CONTEXT |
-        THREAD_ACCESS.SET_CONTEXT |
-        THREAD_ACCESS.QUERY_INFORMATION;
-    const handle = OpenThread(access, false, threadId);
-    if (handle === 0n) {
-        throw new Error(`Failed to open thread ${threadId}. Error: 0x${GetLastError().toString(16)}`);
-    }
-    return handle;
-}
-export function encodeDR7(entries) {
-    let dr7 = 0n;
-    for (const entry of entries) {
-        if (!entry.enabled)
-            continue;
-        const { drIndex, access, size } = entry;
-        dr7 |= 1n << BigInt(drIndex * 2);
-        let condition = 0;
-        switch (access) {
-            case 'execute':
-                condition = 0b00;
-                break;
-            case 'write':
-                condition = 0b01;
-                break;
-            case 'readwrite':
-            case 'read':
-                condition = 0b11;
-                break;
-        }
-        dr7 |= BigInt(condition) << BigInt(16 + drIndex * 4);
-        let sizeCode = 0;
-        switch (size) {
-            case 1:
-                sizeCode = 0b00;
-                break;
-            case 2:
-                sizeCode = 0b01;
-                break;
-            case 4:
-                sizeCode = 0b11;
-                break;
-            case 8:
-                sizeCode = 0b10;
-                break;
-        }
-        dr7 |= BigInt(sizeCode) << BigInt(18 + drIndex * 4);
-    }
-    return dr7;
-}
-export function unloadDebugLibraries() {
-    if (kernel32Debug) {
-        kernel32Debug.unload();
-        kernel32Debug = null;
-    }
-}

package/dist/src/native/formatAddress.d.ts

@@ -1,2 +0,0 @@
-export declare function formatAddress(addr: bigint): string;
-export declare function parseAddress(addr: string): bigint;

package/dist/src/native/formatAddress.js

@@ -1,6 +0,0 @@
-export function formatAddress(addr) {
-    return `0x${addr.toString(16).toUpperCase()}`;
-}
-export function parseAddress(addr) {
-    return BigInt(addr.startsWith('0x') || addr.startsWith('0X') ? addr : `0x${addr}`);
-}

package/dist/src/native/platform/PlatformMemoryAPI.d.ts

@@ -1,14 +0,0 @@
-import type { ProcessHandle, MemoryRegionInfo, MemoryReadResult, MemoryWriteResult, ProtectionChangeResult, AllocationResult, ModuleInfo, MemoryProtection, PlatformAvailability } from './types.js';
-export interface PlatformMemoryAPI {
-    readonly platform: 'win32' | 'darwin';
-    checkAvailability(): Promise<PlatformAvailability>;
-    openProcess(pid: number, writeAccess: boolean): ProcessHandle;
-    closeProcess(handle: ProcessHandle): void;
-    readMemory(handle: ProcessHandle, address: bigint, size: number): MemoryReadResult;
-    writeMemory(handle: ProcessHandle, address: bigint, data: Buffer): MemoryWriteResult;
-    queryRegion(handle: ProcessHandle, address: bigint): MemoryRegionInfo | null;
-    changeProtection(handle: ProcessHandle, address: bigint, size: number, newProtection: MemoryProtection): ProtectionChangeResult;
-    allocateMemory(handle: ProcessHandle, size: number, protection: MemoryProtection): AllocationResult;
-    freeMemory(handle: ProcessHandle, address: bigint, size: number): void;
-    enumerateModules(handle: ProcessHandle): ModuleInfo[];
-}

package/dist/src/native/platform/PlatformMemoryAPI.js

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