bun-memory 1.1.25 → 1.1.26

package/example/benchmark.ts

@@ -0,0 +1,107 @@
+// ! Warning:
+// ! This benchmark may take 1-2+ minutes. It repeatedly traverses the entire entity list in
+// ! Counter-Strike 2, storing it into `EntityClassInfoNames`…
+
+import Memory from 'bun-memory';
+
+// Get the latest client_dll.json and offsets.json from:
+// https://github.com/a2x/cs2-dumper/tree/main/output
+
+import ClientDLLJSON from './offsets/client_dll.json';
+import OffsetsJSON from './offsets/offsets.json';
+
+// Load the needed offsets as bigints… It's ugly but… IntelliSense! 🫠…
+const Client = {
+  ...Object.fromEntries(Object.entries(ClientDLLJSON['client.dll'].classes).map(([class_, { fields }]) => [class_, Object.fromEntries(Object.entries(fields).map(([field, value]) => [field, BigInt(value)]))])),
+  Other: Object.fromEntries(Object.entries(OffsetsJSON['client.dll']).map(([key, value]) => [key, BigInt(value)])),
+} as {
+  [Class in keyof (typeof ClientDLLJSON)['client.dll']['classes']]: { [Field in keyof (typeof ClientDLLJSON)['client.dll']['classes'][Class]['fields']]: bigint };
+} & { Other: { [K in keyof (typeof OffsetsJSON)['client.dll']]: bigint } };
+
+// Open a handle to cs2.exe…
+const cs2 = new Memory('cs2.exe');
+
+// Get the base for client.dll…
+const ClientPtr = cs2.modules['client.dll']?.base;
+
+// Make sure client.dll is loaded…
+if (ClientPtr === undefined) {
+  throw new TypeError('ClientPtr must not be undefined.');
+}
+
+// Warmup…
+console.log('Warming up…');
+
+for (let i = 0; i < 1e6; i++) {
+  const GlobalVarsPtr = cs2.u64(ClientPtr + Client.Other.dwGlobalVars);
+  /* */ const CurTime = cs2.f32(GlobalVarsPtr + 0x30n);
+}
+
+// Create caches and scratches to optimize performance…
+const Cache_Names = new Map<bigint, string>();
+
+const EntityChunkScratch = new BigUint64Array(0xf000 / 0x08);
+const EntityListScratch = new BigUint64Array(0x200 / 0x08);
+
+// Start the test…
+console.log('Starting the test…');
+
+const performance1 = performance.now();
+
+const EntityListPtr = cs2.u64(ClientPtr + Client.Other.dwEntityList);
+
+for (let i = 0; i < 1e6; i++) {
+  const EntityClassInfoNames = new Map<string, bigint[]>();
+  const EntityClassInfoPtrs = new Map<bigint, bigint[]>();
+
+  // Traverse the entity list…
+  cs2.read(EntityListPtr + 0x10n, EntityListScratch);
+
+  for (let i = 0; i < 0x40; i++) {
+    const EntityChunkPtr = EntityListScratch[i];
+
+    if (EntityChunkPtr === 0n) {
+      continue;
+    }
+
+    cs2.read(EntityChunkPtr, EntityChunkScratch);
+
+    for (let j = 0, l = 0; j < 0x200; j++, l += 0x0f) {
+      const BaseEntityPtr = EntityChunkScratch[l];
+
+      if (BaseEntityPtr === 0n) {
+        continue;
+      }
+
+      const EntityClassInfoPtr = EntityChunkScratch[l + 0x01];
+
+      let BaseEntityPtrs = EntityClassInfoPtrs.get(EntityClassInfoPtr);
+
+      if (BaseEntityPtrs === undefined) {
+        BaseEntityPtrs = [];
+
+        EntityClassInfoPtrs.set(EntityClassInfoPtr, BaseEntityPtrs);
+      }
+
+      BaseEntityPtrs.push(BaseEntityPtr);
+    }
+
+    for (const [EntityClassInfoPtr, BaseEntityPtrs] of EntityClassInfoPtrs) {
+      let Name = Cache_Names.get(EntityClassInfoPtr);
+
+      if (Name === undefined) {
+        const SchemaClassInfoDataPtr = cs2.u64(EntityClassInfoPtr + 0x30n);
+        /* */ const NamePtr = cs2.u64(SchemaClassInfoDataPtr + 0x08n);
+        /*       */ Name = cs2.cString(NamePtr, 0x2a).toString();
+
+        Cache_Names.set(EntityClassInfoPtr, Name);
+      }
+
+      EntityClassInfoNames.set(Name, BaseEntityPtrs);
+    }
+  }
+}
+
+const performance2 = performance.now();
+
+console.log('Test completed in %fms…', (performance2 - performance1).toFixed(2));

package/example/trigger-bot.ts

@@ -21,21 +21,12 @@ const {
 });
 
 // Load the needed offsets as bigints…
-const { C_BaseEntity, C_BasePlayerPawn, C_BasePlayerWeapon, C_CSPlayerPawn, C_CSPlayerPawnBase, C_CSWeaponBaseGun, CBasePlayerController, CCSPlayer_WeaponServices, CCSWeaponBaseVData } = Object.fromEntries(
-  Object.entries(ClientDLLJSON['client.dll'].classes).map(([class_, { fields }]) => [class_, Object.fromEntries(Object.entries(fields).map(([field, value]) => [field, BigInt(value)]))])
-) as {
-  [C in keyof (typeof ClientDLLJSON)['client.dll']['classes']]: { [F in keyof (typeof ClientDLLJSON)['client.dll']['classes'][C]['fields']]: bigint };
-};
-
-// Load the needed offsets as bigints…
-const {
-  'client.dll': { dwEntityList, dwGlobalVars, dwLocalPlayerController, dwLocalPlayerPawn },
-  'engine2.dll': {},
-} = Object.fromEntries(
-  Object.entries(OffsetsJSON).map(([name, section]) => [name, Object.fromEntries(Object.entries(section).map(([key, value]) => [key, BigInt(value as number)]))]) //
-) as {
-  [M in keyof typeof OffsetsJSON]: { [K in keyof (typeof OffsetsJSON)[M]]: bigint };
-};
+const Client = {
+  ...Object.fromEntries(Object.entries(ClientDLLJSON['client.dll'].classes).map(([class_, { fields }]) => [class_, Object.fromEntries(Object.entries(fields).map(([field, value]) => [field, BigInt(value)]))])),
+  Other: Object.fromEntries(Object.entries(OffsetsJSON['client.dll']).map(([key, value]) => [key, BigInt(value)])),
+} as {
+  [Class in keyof (typeof ClientDLLJSON)['client.dll']['classes']]: { [Field in keyof (typeof ClientDLLJSON)['client.dll']['classes'][Class]['fields']]: bigint };
+} & { Other: { [K in keyof (typeof OffsetsJSON)['client.dll']]: bigint } };
 
 // Open a handle to cs2.exe…
 const cs2 = new Memory('cs2.exe');
@@ -57,26 +48,26 @@ async function tick(ClientPtr: bigint) {
     ticks++;
 
     // Read relevant info from memory…
-    const GlobalVarsPtr = cs2.u64(ClientPtr + dwGlobalVars);
+    const GlobalVarsPtr = cs2.u64(ClientPtr + Client.Other.dwGlobalVars);
     /* */ const CurTime = cs2.f32(GlobalVarsPtr + 0x30n);
 
-    const Local_PlayerControllerPtr = cs2.u64(ClientPtr + dwLocalPlayerController);
-    /* */ const Local_TickBase = cs2.u32(Local_PlayerControllerPtr + CBasePlayerController.m_nTickBase);
-
-    const Local_PlayerPawnPtr = cs2.u64(ClientPtr + dwLocalPlayerPawn);
-    /* */ const Local_FlashOverlayAlpha = cs2.f32(Local_PlayerPawnPtr + C_CSPlayerPawnBase.m_flFlashOverlayAlpha);
-    /* */ const Local_IDEntIndex = cs2.i32(Local_PlayerPawnPtr + C_CSPlayerPawn.m_iIDEntIndex);
-    /* */ const Local_IsScoped = cs2.i32(Local_PlayerPawnPtr + C_CSPlayerPawn.m_bIsScoped);
-    /* */ const Local_Player_WeaponServicesPtr = cs2.u64(Local_PlayerPawnPtr + C_BasePlayerPawn.m_pWeaponServices);
-    /*       */ const Local_NextAttack = cs2.f32(Local_Player_WeaponServicesPtr + CCSPlayer_WeaponServices.m_flNextAttack);
-    /* */ const Local_TeamNum = cs2.u8(Local_PlayerPawnPtr + C_BaseEntity.m_iTeamNum);
-    /* */ const Local_WeaponBasePtr = cs2.u64(Local_PlayerPawnPtr + C_CSPlayerPawn.m_pClippingWeapon);
-    /*       */ const Local_Clip1 = cs2.i32(Local_WeaponBasePtr + C_BasePlayerWeapon.m_iClip1);
-    /*       */ const Local_NextPrimaryAttackTick = cs2.u32(Local_WeaponBasePtr + C_BasePlayerWeapon.m_nNextPrimaryAttackTick);
-    /*       */ const Local_WeaponBaseVDataPtr = cs2.u64(Local_WeaponBasePtr + C_BaseEntity.m_nSubclassID + 0x08n);
-    /*             */ const Local_IsFullAuto = cs2.bool(Local_WeaponBaseVDataPtr + CCSWeaponBaseVData.m_bIsFullAuto);
-    /*             */ const Local_WeaponType = cs2.i32(Local_WeaponBaseVDataPtr + CCSWeaponBaseVData.m_WeaponType);
-    /*       */ const Local_ZoomLevel = cs2.i32(Local_WeaponBasePtr + C_CSWeaponBaseGun.m_zoomLevel);
+    const Local_PlayerControllerPtr = cs2.u64(ClientPtr + Client.Other.dwLocalPlayerController);
+    /* */ const Local_TickBase = cs2.u32(Local_PlayerControllerPtr + Client.CBasePlayerController.m_nTickBase);
+
+    const Local_PlayerPawnPtr = cs2.u64(ClientPtr + Client.Other.dwLocalPlayerPawn);
+    /* */ const Local_FlashOverlayAlpha = cs2.f32(Local_PlayerPawnPtr + Client.C_CSPlayerPawnBase.m_flFlashOverlayAlpha);
+    /* */ const Local_IDEntIndex = cs2.i32(Local_PlayerPawnPtr + Client.C_CSPlayerPawn.m_iIDEntIndex);
+    /* */ const Local_IsScoped = cs2.i32(Local_PlayerPawnPtr + Client.C_CSPlayerPawn.m_bIsScoped);
+    /* */ const Local_Player_WeaponServicesPtr = cs2.u64(Local_PlayerPawnPtr + Client.C_BasePlayerPawn.m_pWeaponServices);
+    /*       */ const Local_NextAttack = cs2.f32(Local_Player_WeaponServicesPtr + Client.CCSPlayer_WeaponServices.m_flNextAttack);
+    /* */ const Local_TeamNum = cs2.u8(Local_PlayerPawnPtr + Client.C_BaseEntity.m_iTeamNum);
+    /* */ const Local_WeaponBasePtr = cs2.u64(Local_PlayerPawnPtr + Client.C_CSPlayerPawn.m_pClippingWeapon);
+    /*       */ const Local_Clip1 = cs2.i32(Local_WeaponBasePtr + Client.C_BasePlayerWeapon.m_iClip1);
+    /*       */ const Local_NextPrimaryAttackTick = cs2.u32(Local_WeaponBasePtr + Client.C_BasePlayerWeapon.m_nNextPrimaryAttackTick);
+    /*       */ const Local_WeaponBaseVDataPtr = cs2.u64(Local_WeaponBasePtr + Client.C_BaseEntity.m_nSubclassID + 0x08n);
+    /*             */ const Local_IsFullAuto = cs2.bool(Local_WeaponBaseVDataPtr + Client.CCSWeaponBaseVData.m_bIsFullAuto);
+    /*             */ const Local_WeaponType = cs2.i32(Local_WeaponBaseVDataPtr + Client.CCSWeaponBaseVData.m_WeaponType);
+    /*       */ const Local_ZoomLevel = cs2.i32(Local_WeaponBasePtr + Client.C_CSWeaponBaseGun.m_zoomLevel);
 
     // Conditions where we should not fire…
     if (CurTime < Local_NextAttack) {
@@ -96,7 +87,7 @@ async function tick(ClientPtr: bigint) {
     // Weapon types: https://swiftlys2.net/sdk/cs2/types/csweapontype
 
     // Get the entity that we're aiming at from the entity list…
-    const EntityListPtr = cs2.u64(ClientPtr + dwEntityList);
+    const EntityListPtr = cs2.u64(ClientPtr + Client.Other.dwEntityList);
     /* */ const EntityChunkPtr = cs2.u64(EntityListPtr + (BigInt(Local_IDEntIndex) >> 0x09n) * 0x08n + 0x10n);
     /*       */ const BaseEntityPtr = cs2.u64(EntityChunkPtr + (BigInt(Local_IDEntIndex) & 0x1ffn) * 0x78n);
     /*             */ const EntityClassInfoPtr = cs2.u64(EntityChunkPtr + (BigInt(Local_IDEntIndex) & 0x1ffn) * 0x78n + 0x08n);
@@ -117,7 +108,7 @@ async function tick(ClientPtr: bigint) {
     }
 
     const PlayerPawnPtr = BaseEntityPtr;
-    /* */ const TeamNum = cs2.u8(PlayerPawnPtr + BigInt(C_BaseEntity.m_iTeamNum));
+    /* */ const TeamNum = cs2.u8(PlayerPawnPtr + Client.C_BaseEntity.m_iTeamNum);
 
     if (TeamNum === Local_TeamNum) {
       return;
@@ -131,7 +122,7 @@ async function tick(ClientPtr: bigint) {
     // If the gun is automatic, hold the trigger until we're no longer aiming at them…
     do {
       await sleep(random() * Delay + Delay);
-    } while (Local_IDEntIndex === cs2.u32(Local_PlayerPawnPtr + C_CSPlayerPawn.m_iIDEntIndex) && Local_IsFullAuto);
+    } while (Local_IDEntIndex === cs2.u32(Local_PlayerPawnPtr + Client.C_CSPlayerPawn.m_iIDEntIndex) && Local_IsFullAuto);
 
     // Release the trigger…
     mouse_event(0x04, 0x00, 0x00, 0x00, 0n);

package/package.json

@@ -22,7 +22,7 @@
     "url": "git://github.com/obscuritysrl/bun-memory.git"
   },
   "type": "module",
-  "version": "1.1.25",
+  "version": "1.1.26",
   "main": "./index.ts",
   "keywords": [
     "bun",
@@ -46,5 +46,9 @@
   ],
   "engines": {
     "bun": ">=1.1.0"
+  },
+  "scripts": {
+    "run:benchmark": "bun ./example/benchmark.ts",
+    "run:trigger-bot": "bun ./example/trigger-bot.ts"
   }
 }

package/runtime/extensions.ts

@@ -190,7 +190,7 @@ constructors.forEach(
   ({ prototype }) =>
     !Object.getOwnPropertyDescriptor(prototype, 'ptr') &&
     Object.defineProperty(prototype, 'ptr', {
-      configurable: true,
+      configurable: false,
       enumerable: false,
       /**
        * Returns a native pointer to the underlying memory.

package/structs/Memory.ts

@@ -1,9 +1,11 @@
-import { CString, FFIType, dlopen } from 'bun:ffi';
+import { CString, FFIType, dlopen, ptr } from 'bun:ffi';
 
 import type { Module, NetworkUtlVector, Point, QAngle, Quaternion, Region, RGB, RGBA, Scratch, UPtr, UPtrArray, Vector2, Vector3, Vector4 } from '../types/Memory';
 import Win32Error from './Win32Error';
 
-const { symbols: Kernel32 } = dlopen('kernel32.dll', {
+const {
+  symbols: { CloseHandle, CreateToolhelp32Snapshot, GetLastError, Module32FirstW, Module32NextW, OpenProcess, Process32FirstW, Process32NextW, ReadProcessMemory, VirtualQueryEx, WriteProcessMemory },
+} = dlopen('kernel32.dll', {
   CloseHandle: { args: [FFIType.u64], returns: FFIType.bool },
   CreateToolhelp32Snapshot: { args: [FFIType.u32, FFIType.u32], returns: FFIType.u64 },
   GetLastError: { returns: FFIType.u32 },
@@ -27,6 +29,7 @@ const { symbols: Kernel32 } = dlopen('kernel32.dll', {
  * Many scalar reads utilize `TypedArray` scratches to avoid a second FFI hop, such as calling `bun:ffi.read.*`.
  *
  * @todo Add support for 32 or 64-bit processes using IsWow64Process2 (Windows 10+).
+ * @todo When adding 32-bit support, several u64 will need changed to u64_fast.
  *
  * @example
  * ```ts
@@ -50,21 +53,21 @@ class Memory {
     const dwFlags = 0x00000002; /* TH32CS_SNAPPROCESS */
     const th32ProcessID = 0;
 
-    const hSnapshot = Kernel32.CreateToolhelp32Snapshot(dwFlags, th32ProcessID);
+    const hSnapshot = CreateToolhelp32Snapshot(dwFlags, th32ProcessID);
 
     if (hSnapshot === -1n) {
-      throw new Win32Error('CreateToolhelp32Snapshot', Kernel32.GetLastError());
+      throw new Win32Error('CreateToolhelp32Snapshot', GetLastError());
     }
 
     const lppe = Buffer.allocUnsafe(0x238 /* sizeof(PROCESSENTRY32) */);
     /* */ lppe.writeUInt32LE(0x238 /* sizeof(PROCESSENTRY32) */);
 
-    const bProcess32FirstW = Kernel32.Process32FirstW(hSnapshot, lppe);
+    const bProcess32FirstW = Process32FirstW(hSnapshot, lppe);
 
     if (!bProcess32FirstW) {
-      Kernel32.CloseHandle(hSnapshot);
+      CloseHandle(hSnapshot);
 
-      throw new Win32Error('Process32FirstW', Kernel32.GetLastError());
+      throw new Win32Error('Process32FirstW', GetLastError());
     }
 
     do {
@@ -81,12 +84,12 @@ class Memory {
       const desiredAccess = 0x001f0fff; /* PROCESS_ALL_ACCESS */
       const inheritHandle = false;
 
-      const hProcess = Kernel32.OpenProcess(desiredAccess, inheritHandle, th32ProcessID);
+      const hProcess = OpenProcess(desiredAccess, inheritHandle, th32ProcessID);
 
       if (hProcess === 0n) {
-        Kernel32.CloseHandle(hSnapshot);
+        CloseHandle(hSnapshot);
 
-        throw new Win32Error('OpenProcess', Kernel32.GetLastError());
+        throw new Win32Error('OpenProcess', GetLastError());
       }
 
       this._modules = {};
@@ -96,12 +99,12 @@ class Memory {
 
       this.refresh();
 
-      Kernel32.CloseHandle(hSnapshot);
+      CloseHandle(hSnapshot);
 
       return;
-    } while (Kernel32.Process32NextW(hSnapshot, lppe));
+    } while (Process32NextW(hSnapshot, lppe));
 
-    Kernel32.CloseHandle(hSnapshot);
+    CloseHandle(hSnapshot);
 
     throw new Error(`Process not found: ${identifier}…`);
   }
@@ -180,10 +183,10 @@ class Memory {
     let   lpAddress = BigInt(address); // prettier-ignore
     const lpBuffer = this.ScratchMemoryBasicInformation;
 
-    const bVirtualQueryEx = !!Kernel32.VirtualQueryEx(this.hProcess, lpAddress, lpBuffer, dwLength);
+    const bVirtualQueryEx = !!VirtualQueryEx(this.hProcess, lpAddress, lpBuffer, dwLength);
 
     if (!bVirtualQueryEx) {
-      throw new Win32Error('VirtualQueryEx', Kernel32.GetLastError());
+      throw new Win32Error('VirtualQueryEx', GetLastError());
     }
 
     const end = lpAddress + BigInt(length);
@@ -201,11 +204,101 @@ class Memory {
       }
 
       lpAddress = baseAddress + regionSize;
-    } while (lpAddress < end && !!Kernel32.VirtualQueryEx(this.hProcess, lpAddress, lpBuffer, dwLength));
+    } while (lpAddress < end && !!VirtualQueryEx(this.hProcess, lpAddress, lpBuffer, dwLength));
 
     return result;
   }
 
+  /**
+   * Closes the process handle.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * cs2.close();
+   * ```
+   */
+  public close(): void {
+    CloseHandle(this.hProcess);
+
+    return;
+  }
+
+  /**
+   * Disposes resources held by this Memory instance.
+   * Called automatically when using `using` blocks.
+   * @example
+   * ```ts
+   * using const mem = new Memory('cs2.exe');
+   * // mem is disposed at the end of the block
+   * ```
+   */
+  public [Symbol.dispose](): void {
+    this.close();
+
+    return;
+  }
+
+  /**
+   * Asynchronously disposes resources held by this Memory instance.
+   * Use in `await using` blocks for async cleanup.
+   * @example
+   * ```ts
+   * await using const mem = new Memory('cs2.exe');
+   * // mem is disposed asynchronously at the end of the block
+   * ```
+   */
+  public [Symbol.asyncDispose](): Promise<void> {
+    this.close();
+
+    return Promise.resolve();
+  }
+
+  /**
+   * Refreshes the module list for the process.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * cs2.refresh();
+   * ```
+   */
+  public refresh(): void {
+    const dwFlags = 0x00000008 /* TH32CS_SNAPMODULE */ | 0x00000010; /* TH32CS_SNAPMODULE32 */
+
+    const hSnapshot = CreateToolhelp32Snapshot(dwFlags, this.th32ProcessID)!;
+
+    if (hSnapshot === -1n) {
+      throw new Win32Error('CreateToolhelp32Snapshot', GetLastError());
+    }
+
+    this.ScratchModuleEntry32W.writeUInt32LE(0x438 /* sizeof(MODULEENTRY32W) */);
+
+    const lpme = this.ScratchModuleEntry32W;
+
+    const bModule32FirstW = Module32FirstW(hSnapshot, lpme);
+
+    if (!bModule32FirstW) {
+      CloseHandle(hSnapshot);
+
+      throw new Win32Error('Module32FirstW', GetLastError());
+    }
+
+    const modules: Memory['_modules'] = {};
+
+    do {
+      const modBaseAddr = lpme.readBigUInt64LE(0x18);
+      const modBaseSize = lpme.readUInt32LE(0x20);
+      const szModule = lpme.toString('utf16le', 0x30, 0x230).replace(/\0+$/, '');
+
+      modules[szModule] = Object.freeze({ base: modBaseAddr, name: szModule, size: modBaseSize });
+    } while (Module32NextW(hSnapshot, lpme));
+
+    CloseHandle(hSnapshot);
+
+    this._modules = Object.freeze(modules);
+
+    return;
+  }
+
   /**
    * Follows a pointer chain with offsets.
    * @param address Base address.
@@ -236,6 +329,7 @@ class Memory {
    * @param address Address to read from.
    * @param scratch Buffer to fill.
    * @returns The filled buffer.
+   * @todo Consider inlining the call in the if to cut a binding… I hate the idea… 🫠…
    * @example
    * ```ts
    * const cs2 = new Memory('cs2.exe');
@@ -244,14 +338,14 @@ class Memory {
    */
   public read<T extends Scratch>(address: bigint, scratch: T): T {
     const lpBaseAddress = address;
-    const lpBuffer = scratch.ptr;
+    const lpBuffer = ptr(scratch);
     const nSize = scratch.byteLength;
     const numberOfBytesRead = 0x00n;
 
-    const bReadProcessMemory = Kernel32.ReadProcessMemory(this.hProcess, lpBaseAddress, lpBuffer, nSize, numberOfBytesRead);
+    const bReadProcessMemory = ReadProcessMemory(this.hProcess, lpBaseAddress, lpBuffer, nSize, numberOfBytesRead);
 
     if (!bReadProcessMemory) {
-      throw new Win32Error('ReadProcessMemory', Kernel32.GetLastError());
+      throw new Win32Error('ReadProcessMemory', GetLastError());
     }
 
     return scratch;
@@ -262,6 +356,8 @@ class Memory {
    * @param address Address to write to.
    * @param scratch Buffer to write.
    * @returns This instance.
+   * @todo Add a `force: boolean` option that uses `VirtualProtectEx` for a temporary protection change when set to `true`.
+   * @todo Consider inlining the call in the if to cut a binding… I hate the idea… 🫠…
    * @example
    * ```ts
    * const cs2 = new Memory('cs2.exe');
@@ -274,75 +370,15 @@ class Memory {
     const nSize = scratch.byteLength;
     const numberOfBytesWritten = 0x00n;
 
-    const WriteProcessMemory = Kernel32.WriteProcessMemory(this.hProcess, lpBaseAddress, lpBuffer, nSize, numberOfBytesWritten);
+    const bWriteProcessMemory = WriteProcessMemory(this.hProcess, lpBaseAddress, lpBuffer, nSize, numberOfBytesWritten);
 
-    if (!WriteProcessMemory) {
-      throw new Win32Error('WriteProcessMemory', Kernel32.GetLastError());
+    if (!bWriteProcessMemory) {
+      throw new Win32Error('WriteProcessMemory', GetLastError());
     }
 
     return this;
   }
 
-  /**
-   * Closes the process handle.
-   * @example
-   * ```ts
-   * const cs2 = new Memory('cs2.exe');
-   * cs2.close();
-   * ```
-   */
-  public close(): void {
-    Kernel32.CloseHandle(this.hProcess);
-
-    return;
-  }
-
-  /**
-   * Refreshes the module list for the process.
-   * @example
-   * ```ts
-   * const cs2 = new Memory('cs2.exe');
-   * cs2.refresh();
-   * ```
-   */
-  public refresh(): void {
-    const dwFlags = 0x00000008 /* TH32CS_SNAPMODULE */ | 0x00000010; /* TH32CS_SNAPMODULE32 */
-
-    const hSnapshot = Kernel32.CreateToolhelp32Snapshot(dwFlags, this.th32ProcessID)!;
-
-    if (hSnapshot === -1n) {
-      throw new Win32Error('CreateToolhelp32Snapshot', Kernel32.GetLastError());
-    }
-
-    this.ScratchModuleEntry32W.writeUInt32LE(0x438 /* sizeof(MODULEENTRY32W) */);
-
-    const lpme = this.ScratchModuleEntry32W;
-
-    const bModule32FirstW = Kernel32.Module32FirstW(hSnapshot, lpme);
-
-    if (!bModule32FirstW) {
-      Kernel32.CloseHandle(hSnapshot);
-
-      throw new Win32Error('Module32FirstW', Kernel32.GetLastError());
-    }
-
-    const modules: Memory['_modules'] = {};
-
-    do {
-      const modBaseAddr = lpme.readBigUInt64LE(0x18);
-      const modBaseSize = lpme.readUInt32LE(0x20);
-      const szModule = lpme.toString('utf16le', 0x30, 0x230).replace(/\0+$/, '');
-
-      modules[szModule] = Object.freeze({ base: modBaseAddr, name: szModule, size: modBaseSize });
-    } while (Kernel32.Module32NextW(hSnapshot, lpme));
-
-    Kernel32.CloseHandle(hSnapshot);
-
-    this._modules = Object.freeze(modules);
-
-    return;
-  }
-
   /**
    * Reads or writes a boolean value.
    * @param address Address to access.
@@ -996,6 +1032,22 @@ class Memory {
     return this;
   }
 
+  public pointRaw(address: bigint): Float32Array;
+  public pointRaw(address: bigint, values: Float32Array): this;
+  public pointRaw(address: bigint, values?: Float32Array): Float32Array | this {
+    if (values === undefined) {
+      return this.f32Array(address, 0x02);
+    }
+
+    if (values.length !== 0x02) {
+      throw new RangeError('values.length must be 2.');
+    }
+
+    this.write(address, values);
+
+    return this;
+  }
+
   /**
    * Reads or writes a QAngle (object with pitch, yaw, roll).
    * @param address Address to access.
@@ -1059,6 +1111,7 @@ class Memory {
         const pitch = scratch[j];
         const yaw = scratch[j + 0x01];
         const roll = scratch[j + 0x02];
+
         result[i] = { pitch, yaw, roll };
       }
 
@@ -1081,6 +1134,34 @@ class Memory {
     return this;
   }
 
+  /**
+   * Reads or writes a raw QAngle as a Float32Array.
+   * @param address Address to access.
+   * @param values Optional Float32Array to write.
+   * @returns Float32Array read or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const raw = cs2.qAngleRaw(0x12345678n);
+   * cs2.qAngleRaw(0x12345678n, new Float32Array([1,2,3]));
+   * ```
+   */
+  public qAngleRaw(address: bigint): Float32Array;
+  public qAngleRaw(address: bigint, values: Float32Array): this;
+  public qAngleRaw(address: bigint, values?: Float32Array): Float32Array | this {
+    if (values === undefined) {
+      return this.f32Array(address, 0x03);
+    }
+
+    if (values.length !== 0x03) {
+      throw new RangeError('values.length must be 3.');
+    }
+
+    this.write(address, values);
+
+    return this;
+  }
+
   /**
    * Reads or writes a Quaternion (object with w, x, y, z).
    * @param address Address to access.
@@ -1171,6 +1252,34 @@ class Memory {
     return this;
   }
 
+  /**
+   * Reads or writes a raw Quaternion as a Float32Array.
+   * @param address Address to access.
+   * @param values Optional Float32Array to write.
+   * @returns Float32Array read or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const raw = cs2.quaternionRaw(0x12345678n);
+   * cs2.quaternionRaw(0x12345678n, new Float32Array([1,0,0,0]));
+   * ```
+   */
+  public quaternionRaw(address: bigint): Float32Array;
+  public quaternionRaw(address: bigint, values: Float32Array): this;
+  public quaternionRaw(address: bigint, values?: Float32Array): Float32Array | this {
+    if (values === undefined) {
+      return this.f32Array(address, 0x04);
+    }
+
+    if (values.length !== 0x04) {
+      throw new RangeError('values.length must be 4.');
+    }
+
+    this.write(address, values);
+
+    return this;
+  }
+
   /**
    * Reads or writes an RGB color (object with r, g, b).
    * @param address Address to access.
@@ -1205,6 +1314,34 @@ class Memory {
     return this.write(address, Scratch3);
   }
 
+  /**
+   * Reads or writes a raw RGB value as a Uint8Array.
+   * @param address Address to access.
+   * @param values Optional buffer to write.
+   * @returns Uint8Array read or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const raw = cs2.rgbRaw(0x12345678n);
+   * cs2.rgbRaw(0x12345678n, new Uint8Array([255,0,0]));
+   * ```
+   */
+  public rgbRaw(address: bigint): Uint8Array;
+  public rgbRaw(address: bigint, values: Buffer | Uint8Array | Uint8ClampedArray): this;
+  public rgbRaw(address: bigint, values?: Buffer | Uint8Array | Uint8ClampedArray): Uint8Array | this {
+    if (values === undefined) {
+      return this.u8Array(address, 0x03);
+    }
+
+    if (values.length !== 0x03) {
+      throw new RangeError('values.length must be 3.');
+    }
+
+    this.write(address, values);
+
+    return this;
+  }
+
   /**
    * Reads or writes an RGBA color (object with r, g, b, a).
    * @param address Address to access.
@@ -1241,6 +1378,34 @@ class Memory {
     return this.write(address, Scratch4);
   }
 
+  /**
+   * Reads or writes a raw RGBA value as a Uint8Array.
+   * @param address Address to access.
+   * @param values Optional buffer to write.
+   * @returns Uint8Array read or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const raw = cs2.rgbaRaw(0x12345678n);
+   * cs2.rgbaRaw(0x12345678n, new Uint8Array([255,0,0,255]));
+   * ```
+   */
+  public rgbaRaw(address: bigint): Uint8Array;
+  public rgbaRaw(address: bigint, values: Buffer | Uint8Array | Uint8ClampedArray): this;
+  public rgbaRaw(address: bigint, values?: Buffer | Uint8Array | Uint8ClampedArray): Uint8Array | this {
+    if (values === undefined) {
+      return this.u8Array(address, 0x04);
+    }
+
+    if (values.length !== 0x04) {
+      throw new RangeError('values.length must be 4.');
+    }
+
+    this.write(address, values);
+
+    return this;
+  }
+
   /**
    * Reads or writes a 16-bit unsigned integer.
    * @param address Address to access.
@@ -1569,6 +1734,22 @@ class Memory {
     return this.pointArray(address, lengthOrValues);
   }
 
+  public vector2Raw(address: bigint): Float32Array;
+  public vector2Raw(address: bigint, values: Float32Array): this;
+  public vector2Raw(address: bigint, values?: Float32Array): Float32Array | this {
+    if (values === undefined) {
+      return this.f32Array(address, 0x02);
+    }
+
+    if (values.length !== 0x02) {
+      throw new RangeError('values.length must be 2.');
+    }
+
+    this.write(address, values);
+
+    return this;
+  }
+
   /**
    * Reads or writes a Vector3 (object with x, y, z).
    * @param address Address to access.
@@ -1655,6 +1836,22 @@ class Memory {
     return this;
   }
 
+  public vector3Raw(address: bigint): Float32Array;
+  public vector3Raw(address: bigint, values: Float32Array): this;
+  public vector3Raw(address: bigint, values?: Float32Array): Float32Array | this {
+    if (values === undefined) {
+      return this.f32Array(address, 0x03);
+    }
+
+    if (values.length !== 0x03) {
+      throw new RangeError('values.length must be 3.');
+    }
+
+    this.write(address, values);
+
+    return this;
+  }
+
   /**
    * Reads or writes a Vector4 (object with w, x, y, z).
    * @param address Address to access.
@@ -1701,6 +1898,22 @@ class Memory {
     return this.quaternionArray(address, lengthOrValues);
   }
 
+  public vector4Raw(address: bigint): Float32Array;
+  public vector4Raw(address: bigint, values: Float32Array): this;
+  public vector4Raw(address: bigint, values?: Float32Array): Float32Array | this {
+    if (values === undefined) {
+      return this.f32Array(address, 0x04);
+    }
+
+    if (values.length !== 0x04) {
+      throw new RangeError('values.length must be 4.');
+    }
+
+    this.write(address, values);
+
+    return this;
+  }
+
   // Public utility methods…
 
   /**