@cheatron/native-mock 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cheatron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,21 @@
+# @cheatron/cheatron-native-mock
+
+This package provides a pure JavaScript/TypeScript mock implementation of `@cheatron/cheatron-native`.
+
+It simulates the Windows API (`Kernel32`) and core classes (`Process`, `Thread`) in memory, allowing tests and development on non-Windows platforms without native dependencies.
+
+## Features
+
+- **In-Memory Kernel32**: Simulates memory operations, handle management, and process/thread APIs.
+- **Type-Safe**: Uses `win32-def` for accurate Windows API type definitions.
+- **Dependency-Free**: Removes `koffi` and `win32-api` runtime dependencies.
+- **Test Compatibility**: Passes the standard `@cheatron/cheatron-native` test suite.
+
+## Usage
+
+This package is intended for testing and development environments where native modules cannot be loaded.
+
+```bash
+bun install
+bun test
+```

package/dist/constants.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Process access rights
+ * https://learn.microsoft.com/en-us/windows/win32/procthread/process-security-and-access-rights
+ */
+export declare const ProcessAccess: {
+    readonly TERMINATE: 1;
+    readonly CREATE_THREAD: 2;
+    readonly SET_SESSIONID: 4;
+    readonly VM_OPERATION: 8;
+    readonly VM_READ: 16;
+    readonly VM_WRITE: 32;
+    readonly DUP_HANDLE: 64;
+    readonly CREATE_PROCESS: 128;
+    readonly SET_QUOTA: 256;
+    readonly SET_INFORMATION: 512;
+    readonly QUERY_INFORMATION: 1024;
+    readonly SUSPEND_RESUME: 2048;
+    readonly QUERY_LIMITED_INFORMATION: 4096;
+    readonly SET_LIMITED_INFORMATION: 8192;
+    readonly ALL_ACCESS: 2097151;
+};
+/**
+ * Thread access rights
+ * https://learn.microsoft.com/en-us/windows/win32/procthread/thread-security-and-access-rights
+ */
+export declare const ThreadAccess: {
+    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 SET_LIMITED_INFORMATION: 1024;
+    readonly QUERY_LIMITED_INFORMATION: 2048;
+    readonly ALL_ACCESS: 2097151;
+};
+/**
+ * Memory protection constants
+ * https://learn.microsoft.com/en-us/windows/win32/memory/memory-protection-constants
+ */
+export declare const MemoryProtection: {
+    readonly NOACCESS: 1;
+    readonly READONLY: 2;
+    readonly READWRITE: 4;
+    readonly WRITECOPY: 8;
+    readonly EXECUTE: 16;
+    readonly EXECUTE_READ: 32;
+    readonly EXECUTE_READWRITE: 64;
+    readonly EXECUTE_WRITECOPY: 128;
+    readonly GUARD: 256;
+    readonly NOCACHE: 512;
+    readonly WRITECOMBINE: 1024;
+};
+/**
+ * Memory state constants
+ */
+export declare const MemoryState: {
+    readonly COMMIT: 4096;
+    readonly RESERVE: 8192;
+    readonly FREE: 65536;
+};
+/**
+ * Memory type constants
+ */
+export declare const MemoryType: {
+    readonly PRIVATE: 131072;
+    readonly MAPPED: 262144;
+    readonly IMAGE: 16777216;
+};
+export type ProcessAccessValue = (typeof ProcessAccess)[keyof typeof ProcessAccess];
+export type ThreadAccessValue = (typeof ThreadAccess)[keyof typeof ThreadAccess];
+/**
+ * MEMORY_BASIC_INFORMATION structure
+ * https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-memory_basic_information
+ */
+export interface MemoryBasicInformation {
+    BaseAddress: number | bigint;
+    AllocationBase: number | bigint;
+    AllocationProtect: number;
+    RegionSize: number | bigint;
+    State: number;
+    Protect: number;
+    Type: number;
+}
+export declare const MEMORY_BASIC_INFORMATION: {
+    name: string;
+    spec: unknown;
+};
+export declare const MBI_SIZE: 1 | 2 | 4 | 8 | 16 | 48 | 1232;
+export declare const ContextFlags: {
+    readonly AMD64: 1048576;
+    readonly CONTROL: number;
+    readonly INTEGER: number;
+    readonly SEGMENTS: number;
+    readonly FLOATING_POINT: number;
+    readonly DEBUG_REGISTERS: number;
+    readonly FULL: number;
+    readonly ALL: number;
+};
+/**
+ * M128A structure (128-bit register value)
+ * https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-m128a
+ */
+export declare const M128A: {
+    name: string;
+    spec: unknown;
+};
+export interface M128AValue {
+    Low: bigint;
+    High: bigint;
+}
+/**
+ * CONTEXT structure for x64 (AMD64)
+ * https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-context
+ */
+export declare const CONTEXT: {
+    name: string;
+    spec: unknown;
+};
+export declare const CONTEXT_SIZE: 1 | 2 | 4 | 8 | 16 | 48 | 1232;
+/**
+ * Parsed thread context (x64)
+ */
+export interface ThreadContext {
+    P1Home: bigint;
+    P2Home: bigint;
+    P3Home: bigint;
+    P4Home: bigint;
+    P5Home: bigint;
+    P6Home: bigint;
+    ContextFlags: number;
+    MxCsr: number;
+    SegCs: number;
+    SegDs: number;
+    SegEs: number;
+    SegFs: number;
+    SegGs: number;
+    SegSs: number;
+    EFlags: 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;
+    FltSave: number[];
+    VectorRegister: M128AValue[];
+    VectorControl: bigint;
+    DebugControl: bigint;
+    LastBranchToRip: bigint;
+    LastBranchFromRip: bigint;
+    LastExceptionToRip: bigint;
+    LastExceptionFromRip: bigint;
+}
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"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"}

package/dist/constants.js

@@ -0,0 +1,173 @@
+/**
+ * Process access rights
+ * https://learn.microsoft.com/en-us/windows/win32/procthread/process-security-and-access-rights
+ */
+export const ProcessAccess = {
+    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,
+    SET_LIMITED_INFORMATION: 0x2000,
+    ALL_ACCESS: 0x1fffff,
+};
+/**
+ * Thread access rights
+ * https://learn.microsoft.com/en-us/windows/win32/procthread/thread-security-and-access-rights
+ */
+export const ThreadAccess = {
+    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,
+    SET_LIMITED_INFORMATION: 0x0400,
+    QUERY_LIMITED_INFORMATION: 0x0800,
+    ALL_ACCESS: 0x1fffff,
+};
+/**
+ * Memory protection constants
+ * https://learn.microsoft.com/en-us/windows/win32/memory/memory-protection-constants
+ */
+export const MemoryProtection = {
+    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,
+};
+/**
+ * Memory state constants
+ */
+export const MemoryState = {
+    COMMIT: 0x1000,
+    RESERVE: 0x2000,
+    FREE: 0x10000,
+};
+/**
+ * Memory type constants
+ */
+export const MemoryType = {
+    PRIVATE: 0x20000,
+    MAPPED: 0x40000,
+    IMAGE: 0x1000000,
+};
+import koffi from 'koffi';
+// Koffi struct for MEMORY_BASIC_INFORMATION (64-bit)
+export const MEMORY_BASIC_INFORMATION = koffi.struct('MEMORY_BASIC_INFORMATION', {
+    BaseAddress: 'uint64',
+    AllocationBase: 'uint64',
+    AllocationProtect: 'uint32',
+    __PartitionId: 'uint16',
+    __pad: 'uint16',
+    RegionSize: 'uint64',
+    State: 'uint32',
+    Protect: 'uint32',
+    Type: 'uint32',
+    __pad2: 'uint32',
+});
+export const MBI_SIZE = koffi.sizeof(MEMORY_BASIC_INFORMATION);
+/**
+ * CONTEXT flags for x64
+ * https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-context
+ */
+const CONTEXT_AMD64 = 0x00100000;
+export const ContextFlags = {
+    AMD64: CONTEXT_AMD64,
+    CONTROL: CONTEXT_AMD64 | 0x01,
+    INTEGER: CONTEXT_AMD64 | 0x02,
+    SEGMENTS: CONTEXT_AMD64 | 0x04,
+    FLOATING_POINT: CONTEXT_AMD64 | 0x08,
+    DEBUG_REGISTERS: CONTEXT_AMD64 | 0x10,
+    FULL: CONTEXT_AMD64 | 0x01 | 0x02 | 0x08,
+    ALL: CONTEXT_AMD64 | 0x01 | 0x02 | 0x04 | 0x08 | 0x10,
+};
+/**
+ * M128A structure (128-bit register value)
+ * https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-m128a
+ */
+export const M128A = koffi.struct('M128A', {
+    Low: 'uint64',
+    High: 'int64',
+});
+/**
+ * CONTEXT structure for x64 (AMD64)
+ * https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-context
+ */
+export const CONTEXT = koffi.struct('CONTEXT', {
+    // Register parameter home addresses
+    P1Home: 'uint64',
+    P2Home: 'uint64',
+    P3Home: 'uint64',
+    P4Home: 'uint64',
+    P5Home: 'uint64',
+    P6Home: 'uint64',
+    // Control flags
+    ContextFlags: 'uint32',
+    MxCsr: 'uint32',
+    // Segment registers
+    SegCs: 'uint16',
+    SegDs: 'uint16',
+    SegEs: 'uint16',
+    SegFs: 'uint16',
+    SegGs: 'uint16',
+    SegSs: 'uint16',
+    // Flags
+    EFlags: 'uint32',
+    // Debug registers
+    Dr0: 'uint64',
+    Dr1: 'uint64',
+    Dr2: 'uint64',
+    Dr3: 'uint64',
+    Dr6: 'uint64',
+    Dr7: 'uint64',
+    // Integer registers
+    Rax: 'uint64',
+    Rcx: 'uint64',
+    Rdx: 'uint64',
+    Rbx: 'uint64',
+    Rsp: 'uint64',
+    Rbp: 'uint64',
+    Rsi: 'uint64',
+    Rdi: 'uint64',
+    R8: 'uint64',
+    R9: 'uint64',
+    R10: 'uint64',
+    R11: 'uint64',
+    R12: 'uint64',
+    R13: 'uint64',
+    R14: 'uint64',
+    R15: 'uint64',
+    // Program counter
+    Rip: 'uint64',
+    // Floating point / XMM save area (XMM_SAVE_AREA32 = 512 bytes)
+    FltSave: 'uint8[512]',
+    // Vector registers
+    VectorRegister: 'M128A[26]',
+    VectorControl: 'uint64',
+    // Special debug registers
+    DebugControl: 'uint64',
+    LastBranchToRip: 'uint64',
+    LastBranchFromRip: 'uint64',
+    LastExceptionToRip: 'uint64',
+    LastExceptionFromRip: 'uint64',
+});
+export const CONTEXT_SIZE = koffi.sizeof(CONTEXT);

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './process';
+export * from './thread';
+export * from './kernel32';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './process';
+export * from './thread';
+export * from './kernel32';

package/dist/kernel32.d.ts

@@ -0,0 +1,22 @@
+import * as D from 'win32-def';
+export declare const Kernel32Impl: {
+    OpenProcess: (dwDesiredAccess: D.DWORD, bInheritHandle: D.BOOL, dwProcessId: D.DWORD) => D.HANDLE;
+    GetCurrentProcess: () => D.HANDLE;
+    GetCurrentProcessId: () => D.DWORD;
+    CloseHandle: (hObject: D.HANDLE) => D.BOOL;
+    ReadProcessMemory: (hProcess: D.HANDLE, lpBaseAddress: D.LPCVOID, lpBuffer: Buffer, nSize: D.SIZE_T, _lpNumberOfBytesRead: D.LPDWORD | null) => D.BOOL;
+    WriteProcessMemory: (hProcess: D.HANDLE, lpBaseAddress: D.LPCVOID, lpBuffer: Buffer, nSize: D.SIZE_T, _lpNumberOfBytesWritten: D.LPDWORD | null) => D.BOOL;
+    VirtualAlloc: (lpAddress: D.LPCVOID, dwSize: D.SIZE_T, flAllocationType: D.DWORD, flProtect: D.DWORD) => D.LPVOID;
+    VirtualAllocEx: (hProcess: D.HANDLE, lpAddress: D.LPCVOID, dwSize: D.SIZE_T, flAllocationType: D.DWORD, flProtect: D.DWORD) => D.LPVOID;
+    VirtualQuery: (lpAddress: D.LPCVOID, lpBuffer: Buffer, dwLength: D.SIZE_T) => D.SIZE_T;
+    VirtualQueryEx: (hProcess: D.HANDLE, lpAddress: D.LPCVOID, lpBuffer: Buffer, dwLength: D.SIZE_T) => D.SIZE_T;
+    OpenThread: (_dwDesiredAccess: D.DWORD, _bInheritHandle: D.BOOL, _dwThreadId: D.DWORD) => D.HANDLE;
+    GetCurrentThread: () => D.HANDLE;
+    GetCurrentThreadId: () => D.DWORD;
+    SuspendThread: (hThread: D.HANDLE) => D.DWORD;
+    ResumeThread: (hThread: D.HANDLE) => D.DWORD;
+    GetThreadContext: (_hThread: D.HANDLE, _lpContext: Buffer) => D.BOOL;
+    SetThreadContext: (_hThread: D.HANDLE, _lpContext: Buffer) => D.BOOL;
+    GetLastError: () => D.DWORD;
+};
+//# sourceMappingURL=kernel32.d.ts.map

package/dist/kernel32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel32.d.ts","sourceRoot":"","sources":["../src/kernel32.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,WAAW,CAAC;AAQ/B,eAAO,MAAM,YAAY;mCAGJ,CAAC,CAAC,KAAK,kBACR,CAAC,CAAC,IAAI,eACT,CAAC,CAAC,KAAK,KACnB,CAAC,CAAC,MAAM;6BAGY,CAAC,CAAC,MAAM;+BACN,CAAC,CAAC,KAAK;2BACT,CAAC,CAAC,MAAM,KAAG,CAAC,CAAC,IAAI;kCAS5B,CAAC,CAAC,MAAM,iBACH,CAAC,CAAC,OAAO,YACd,MAAM,SACT,CAAC,CAAC,MAAM,wBACO,CAAC,CAAC,OAAO,GAAG,IAAI,KACrC,CAAC,CAAC,IAAI;mCA0BG,CAAC,CAAC,MAAM,iBACH,CAAC,CAAC,OAAO,YACd,MAAM,SACT,CAAC,CAAC,MAAM,2BACU,CAAC,CAAC,OAAO,GAAG,IAAI,KACxC,CAAC,CAAC,IAAI;8BA6BI,CAAC,CAAC,OAAO,UACZ,CAAC,CAAC,MAAM,oBACE,CAAC,CAAC,KAAK,aACd,CAAC,CAAC,KAAK,KACjB,CAAC,CAAC,MAAM;+BAUC,CAAC,CAAC,MAAM,aACP,CAAC,CAAC,OAAO,UACZ,CAAC,CAAC,MAAM,oBACE,CAAC,CAAC,KAAK,aACd,CAAC,CAAC,KAAK,KACjB,CAAC,CAAC,MAAM;8BAkCE,CAAC,CAAC,OAAO,YACV,MAAM,YACN,CAAC,CAAC,MAAM,KACjB,CAAC,CAAC,MAAM;+BAUC,CAAC,CAAC,MAAM,aACP,CAAC,CAAC,OAAO,YACV,MAAM,YACN,CAAC,CAAC,MAAM,KACjB,CAAC,CAAC,MAAM;mCAsCS,CAAC,CAAC,KAAK,mBACR,CAAC,CAAC,IAAI,eACV,CAAC,CAAC,KAAK,KACnB,CAAC,CAAC,MAAM;4BAGW,CAAC,CAAC,MAAM;8BACN,CAAC,CAAC,KAAK;6BACN,CAAC,CAAC,MAAM,KAAG,CAAC,CAAC,KAAK;4BASnB,CAAC,CAAC,MAAM,KAAG,CAAC,CAAC,KAAK;iCASb,CAAC,CAAC,MAAM,cAAc,MAAM,KAAG,CAAC,CAAC,IAAI;iCAGrC,CAAC,CAAC,MAAM,cAAc,MAAM,KAAG,CAAC,CAAC,IAAI;wBAGhD,CAAC,CAAC,KAAK;CAC1B,CAAC"}

package/dist/kernel32.js

@@ -0,0 +1,170 @@
+import { kernel } from './os/kernel';
+// Constants
+const PSEUDO_HANDLE_PROCESS = 0xffffffffffffffffn; // -1
+const PSEUDO_HANDLE_THREAD = 0xfffffffffffffffen; // -2
+export const Kernel32Impl = {
+    // Process
+    OpenProcess: (dwDesiredAccess, bInheritHandle, dwProcessId) => {
+        return kernel.OpenProcess(dwDesiredAccess, !!bInheritHandle, dwProcessId);
+    },
+    GetCurrentProcess: () => PSEUDO_HANDLE_PROCESS,
+    GetCurrentProcessId: () => kernel.currentProcess.id,
+    CloseHandle: (hObject) => {
+        if (hObject === PSEUDO_HANDLE_PROCESS || hObject === PSEUDO_HANDLE_THREAD) {
+            return 1;
+        }
+        return kernel.CloseHandle(hObject) ? 1 : 0;
+    },
+    // Memory
+    ReadProcessMemory: (hProcess, lpBaseAddress, // bigint | number
+    lpBuffer, // LPVOID
+    nSize, // bigint | number
+    _lpNumberOfBytesRead) => {
+        let process;
+        if (hProcess === PSEUDO_HANDLE_PROCESS) {
+            process = kernel.currentProcess;
+        }
+        else {
+            const handleObj = kernel.getObjectFromHandle(hProcess);
+            if (handleObj && handleObj.type === 'Process') {
+                process = handleObj.object;
+            }
+        }
+        if (!process)
+            return 0;
+        const addr = Number(lpBaseAddress);
+        const size = Number(nSize);
+        try {
+            const data = process.memory.read(addr, size);
+            data.copy(lpBuffer);
+            return 1;
+        }
+        catch (_e) {
+            return 0;
+        }
+    },
+    WriteProcessMemory: (hProcess, lpBaseAddress, lpBuffer, nSize, _lpNumberOfBytesWritten) => {
+        let process;
+        if (hProcess === PSEUDO_HANDLE_PROCESS) {
+            process = kernel.currentProcess;
+        }
+        else {
+            const handleObj = kernel.getObjectFromHandle(hProcess);
+            if (handleObj && handleObj.type === 'Process') {
+                process = handleObj.object;
+            }
+        }
+        if (!process)
+            return 0;
+        const addr = Number(lpBaseAddress);
+        // Ensure we only write nSize bytes essentially
+        const dataToWrite = lpBuffer.subarray(0, Number(nSize));
+        try {
+            if (process.memory.write(addr, dataToWrite) > 0) {
+                return 1;
+            }
+            return 0;
+        }
+        catch (_e) {
+            return 0;
+        }
+    },
+    VirtualAlloc: (lpAddress, dwSize, flAllocationType, flProtect) => {
+        return Kernel32Impl.VirtualAllocEx(PSEUDO_HANDLE_PROCESS, lpAddress, dwSize, flAllocationType, flProtect);
+    },
+    VirtualAllocEx: (hProcess, lpAddress, dwSize, flAllocationType, flProtect) => {
+        let process;
+        if (hProcess === PSEUDO_HANDLE_PROCESS) {
+            process = kernel.currentProcess;
+        }
+        else {
+            const handleObj = kernel.getObjectFromHandle(hProcess);
+            if (handleObj && handleObj.type === 'Process') {
+                process = handleObj.object;
+            }
+        }
+        if (!process)
+            return 0n;
+        const addr = Number(lpAddress);
+        const size = Number(dwSize);
+        // We assume flAllocationType and flProtect match our internal constants or we pass them through
+        // Our MemoryManager uses constants from constants.ts which match Win32
+        try {
+            const allocatedAddr = process.memory.allocate(addr, size, flAllocationType, flProtect);
+            return BigInt(allocatedAddr);
+        }
+        catch (_e) {
+            return 0n;
+        }
+    },
+    VirtualQuery: (lpAddress, lpBuffer, // PMEMORY_BASIC_INFORMATION
+    dwLength) => {
+        // Queries CURRENT process
+        return Kernel32Impl.VirtualQueryEx(PSEUDO_HANDLE_PROCESS, lpAddress, lpBuffer, dwLength);
+    },
+    VirtualQueryEx: (hProcess, lpAddress, lpBuffer, dwLength) => {
+        let process;
+        if (hProcess === PSEUDO_HANDLE_PROCESS) {
+            process = kernel.currentProcess;
+        }
+        else {
+            const handleObj = kernel.getObjectFromHandle(hProcess);
+            if (handleObj && handleObj.type === 'Process') {
+                process = handleObj.object;
+            }
+        }
+        if (!process)
+            return 0n;
+        const addr = Number(lpAddress);
+        const info = process.memory.query(addr);
+        // Serialize info to lpBuffer
+        // BaseAddress (0)
+        lpBuffer.writeBigUInt64LE(BigInt(info.BaseAddress), 0);
+        // AllocationBase (8)
+        lpBuffer.writeBigUInt64LE(BigInt(info.AllocationBase), 8);
+        // AllocationProtect (16)
+        lpBuffer.writeUInt32LE(info.AllocationProtect, 16);
+        // RegionSize (24)
+        lpBuffer.writeBigUInt64LE(BigInt(info.RegionSize), 24);
+        // State (32)
+        lpBuffer.writeUInt32LE(info.State, 32);
+        // Protect (36)
+        lpBuffer.writeUInt32LE(info.Protect, 36);
+        // Type (40)
+        lpBuffer.writeUInt32LE(info.Type, 40);
+        return BigInt(dwLength);
+    },
+    // Thread
+    OpenThread: (_dwDesiredAccess, _bInheritHandle, _dwThreadId) => {
+        return 0x200n;
+    },
+    GetCurrentThread: () => PSEUDO_HANDLE_THREAD,
+    GetCurrentThreadId: () => 98765,
+    SuspendThread: (hThread) => {
+        if (hThread === PSEUDO_HANDLE_THREAD)
+            return 0;
+        const handleObj = kernel.getObjectFromHandle(hThread);
+        if (handleObj && handleObj.type === 'Thread') {
+            // return (handleObj.object as SimulatedThread).suspend();
+            return 0; // SimulatedThread import might be cyclic or tricky, simplified for now
+        }
+        return 0; // Fail
+    },
+    ResumeThread: (hThread) => {
+        if (hThread === PSEUDO_HANDLE_THREAD)
+            return 0;
+        const handleObj = kernel.getObjectFromHandle(hThread);
+        if (handleObj && handleObj.type === 'Thread') {
+            // return (handleObj.object as SimulatedThread).resume();
+            return 0;
+        }
+        return 0;
+    },
+    GetThreadContext: (_hThread, _lpContext) => {
+        return 0;
+    },
+    SetThreadContext: (_hThread, _lpContext) => {
+        return 1;
+    },
+    GetLastError: () => 0,
+};

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const log: import("@cheatron/log").LoggerHelpers;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG,uCAAgC,CAAC"}

package/dist/logger.js

@@ -0,0 +1,2 @@
+import { createLogHelper } from '@cheatron/log';
+export const log = createLogHelper('NativeMock');

package/dist/os/handles.d.ts

@@ -0,0 +1,17 @@
+import * as D from 'win32-def';
+export interface ISimulatedObject {
+    id: number;
+}
+export interface HandleObject {
+    type: 'Process' | 'Thread' | 'File' | 'Event' | 'Unknown';
+    object: ISimulatedObject;
+    accessMask: number;
+}
+export declare class HandleTable {
+    private handles;
+    private nextHandleValue;
+    createHandle(object: ISimulatedObject, type: HandleObject['type'], accessMask: number): D.HANDLE;
+    getObject(handle: D.HANDLE): HandleObject | undefined;
+    closeHandle(handle: D.HANDLE): boolean;
+}
+//# sourceMappingURL=handles.d.ts.map

package/dist/os/handles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handles.d.ts","sourceRoot":"","sources":["../../src/os/handles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,WAAW,CAAC;AAE/B,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;IAC1D,MAAM,EAAE,gBAAgB,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAmC;IAClD,OAAO,CAAC,eAAe,CAAM;IAE7B,YAAY,CACV,MAAM,EAAE,gBAAgB,EACxB,IAAI,EAAE,YAAY,CAAC,MAAM,CAAC,EAC1B,UAAU,EAAE,MAAM,GACjB,CAAC,CAAC,MAAM;IAeX,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,GAAG,YAAY,GAAG,SAAS;IAIrD,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,GAAG,OAAO;CAGvC"}

package/dist/os/handles.js

@@ -0,0 +1,21 @@
+export class HandleTable {
+    handles = new Map();
+    nextHandleValue = 4n; // Windows handles are often multiples of 4
+    createHandle(object, type, accessMask) {
+        const handleValue = this.nextHandleValue;
+        this.nextHandleValue += 4n;
+        // Simulate handle reuse? For now, just increment.
+        this.handles.set(handleValue, {
+            type,
+            object,
+            accessMask,
+        });
+        return handleValue;
+    }
+    getObject(handle) {
+        return this.handles.get(BigInt(handle));
+    }
+    closeHandle(handle) {
+        return this.handles.delete(BigInt(handle));
+    }
+}