bun-memory 1.1.21 → 1.1.23

package/structs/Memory.ts

@@ -1,14 +1,10 @@
 import { CString, FFIType, dlopen, read } from 'bun:ffi';
 
-import type { Module, NetworkUtlVector, QAngle, Quaternion, Region, Scratch, Vector2, Vector3, Vector4 } from '../types/Memory';
+import type { Module, NetworkUtlVector, Point, QAngle, Quaternion, Region, RGB, RGBA, Scratch, UPtr, UPtrArray, Vector2, Vector3, Vector4 } from '../types/Memory';
 import Win32Error from './Win32Error';
 
 const { f32, f64, i16, i32, i64, i8, u16, u32, u64, u8 } = read;
 
-/**
- * Kernel32 Windows API functions imported via Foreign Function Interface (FFI).
- * These functions provide low-level access to process and memory management operations.
- */
 const { symbols: Kernel32 } = dlopen('kernel32.dll', {
   CloseHandle: { args: [FFIType.u64], returns: FFIType.bool },
   CreateToolhelp32Snapshot: { args: [FFIType.u32, FFIType.u32], returns: FFIType.u64 },
@@ -25,45 +21,26 @@ const { symbols: Kernel32 } = dlopen('kernel32.dll', {
 });
 
 /**
- * Memory class provides cross-process memory manipulation capabilities on Windows systems.
- * This class allows reading from and writing to memory addresses in external processes,
- * supporting various data types including primitives, arrays, and custom structures like vectors and quaternions.
+ * Provides cross-process memory manipulation for native applications.
  *
- * @todo Reimplement `findPattern(…)`.
+ * Use this class to read and write memory, access modules, and work with common data structures in external processes.
  *
  * @example
- * ```typescript
- * // Connect to a process by name
- * const memory = new Memory('notepad.exe');
- *
- * // Connect to a process by ID
- * const memory = new Memory(1234);
- *
- * // Read a 32-bit integer from memory
- * const value = memory.i32(0x12345678n);
- *
- * // Write a float to memory
- * memory.f32(0x12345678n, 3.14159);
- *
- * // Clean up when done
- * memory.close();
+ * ```ts
+ * import Memory from './structs/Memory';
+ * const cs2 = new Memory('cs2.exe');
+ * const myFloat = cs2.f32(0x12345678n);
+ * cs2.close();
  * ```
  */
 class Memory {
   /**
-   * Creates a new Memory instance and attaches to the specified process.
-   *
-   * @param identifier - Either a process ID (number) or process name (string)
-   * @throws {Win32Error} When process operations fail
-   * @throws {Error} When the specified process is not found
-   *
+   * Opens a process by PID or executable name.
+   * @param identifier Process ID or executable name.
+   * @throws If the process cannot be found or opened.
    * @example
-   * ```typescript
-   * // Attach to process by name
-   * const memory = new Memory('calculator.exe');
-   *
-   * // Attach to process by ID
-   * const memory = new Memory(5432);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
    * ```
    */
   constructor(identifier: number | string) {
@@ -125,107 +102,65 @@ class Memory {
     throw new Error(`Process not found: ${identifier}…`);
   }
 
-  /**
-   * Memory protection constants used for determining safe memory regions.
-   * Safe regions can be read from or written to, while unsafe regions should be avoided.
-   */
   private static readonly MemoryProtections = {
     Safe: 0x10 /* PAGE_EXECUTE */ | 0x20 /* PAGE_EXECUTE_READ */ | 0x40 /* PAGE_EXECUTE_READWRITE */ | 0x80 /* PAGE_EXECUTE_WRITECOPY */ | 0x02 /* PAGE_READONLY */ | 0x04 /* PAGE_READWRITE */ | 0x08 /* PAGE_WRITECOPY */,
     Unsafe: 0x100 /* PAGE_GUARD */ | 0x01 /* PAGE_NOACCESS */,
   };
 
   /**
-   * Internal storage for loaded modules information.
+   * Map of loaded modules in the process, keyed by module name.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const mainModule = cs2.modules['cs2.exe'];
+   * ```
    */
   private _modules: { [key: string]: Module };
 
-  /**
-   * Pre-allocated scratch buffers for memory operations to avoid repeated allocations.
-   * These buffers are reused across multiple read/write operations for performance.
-   */
   private readonly Scratch1 = new Uint8Array(0x01);
   private readonly Scratch2 = new Uint8Array(0x02);
+  private readonly Scratch3 = new Uint8Array(0x03);
   private readonly Scratch4 = new Uint8Array(0x04);
   private readonly Scratch8 = new Uint8Array(0x08);
   private readonly Scratch12 = new Uint8Array(0x0c);
   private readonly Scratch16 = new Uint8Array(0x10);
 
-  /**
-   * Buffer views of the scratch arrays for easier data manipulation.
-   */
   private readonly Scratch1Buffer = Buffer.from(this.Scratch1.buffer, this.Scratch1.byteOffset, this.Scratch1.byteLength);
   private readonly Scratch2Buffer = Buffer.from(this.Scratch2.buffer, this.Scratch2.byteOffset, this.Scratch2.byteLength);
+  private readonly Scratch3Buffer = Buffer.from(this.Scratch3.buffer, this.Scratch3.byteOffset, this.Scratch3.byteLength);
   private readonly Scratch4Buffer = Buffer.from(this.Scratch4.buffer, this.Scratch4.byteOffset, this.Scratch4.byteLength);
   private readonly Scratch8Buffer = Buffer.from(this.Scratch8.buffer, this.Scratch8.byteOffset, this.Scratch8.byteLength);
   private readonly Scratch12Buffer = Buffer.from(this.Scratch12.buffer, this.Scratch12.byteOffset, this.Scratch12.byteLength);
   private readonly Scratch16Buffer = Buffer.from(this.Scratch16.buffer, this.Scratch16.byteOffset, this.Scratch16.byteLength);
 
-  /**
-   * Scratch buffers for Windows API structures.
-   */
   private readonly ScratchMemoryBasicInformation = Buffer.allocUnsafe(0x30 /* sizeof(MEMORY_BASIC_INFORMATION) */);
   private readonly ScratchModuleEntry32W = Buffer.allocUnsafe(0x438 /* sizeof(MODULEENTRY32W) */);
 
-  /**
-   * Reusable UTF-16 decoder for interpreting raw process memory as UTF-16 text.
-   * Kept as a singleton to avoid repeated allocations in hot paths.
-   */
   private static readonly TextDecoderUTF16 = new TextDecoder('utf-16');
-
-  /**
-   * Reusable UTF-8 decoder for interpreting raw process memory as UTF-8 text.
-   * Kept as a singleton to avoid repeated allocations in hot paths.
-   */
   private static readonly TextDecoderUTF8 = new TextDecoder('utf-8');
 
-  /**
-   * Handle to the target process.
-   */
   private readonly hProcess: bigint;
 
-  /**
-   * Process ID of the target process.
-   */
   private readonly th32ProcessID: number;
 
   /**
-   * Gets the loaded modules for the target process.
-   *
-   * @returns A frozen object containing module information indexed by module name
-   *
+   * Gets all loaded modules in the process.
+   * @returns Map of module name to module info.
    * @example
-   * ```typescript
-   * const modules = memory.modules;
-   *
-   * // Access a specific module
-   * const mainModule = modules['notepad.exe'];
-   * console.log(`Base address: 0x${mainModule.base.toString(16)}`);
-   * console.log(`Size: ${mainModule.size} bytes`);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const modules = cs2.modules;
    * ```
    */
   public get modules(): Memory['_modules'] {
     return this._modules;
   }
 
-  // Internal methods
-
   /**
-   * Retrieves memory region information for a specified address range.
-   * This method queries the virtual memory layout to identify safe regions for memory operations.
-   *
-   * @param address - Starting memory address
-   * @param length - Length of the memory range to query
-   * @returns Array of Region objects describing the memory layout
-   * @throws {Win32Error} When memory query operations fail
-   *
-   * @example
-   * ```typescript
-   * const regions = memory.regions(0x10000000n, 0x1000n);
-   *
-   * regions.forEach(region => {
-   *   console.log(`Region: 0x${region.base.toString(16)} - Size: ${region.size}`);
-   * });
-   * ```
+   * Returns memory regions in a given address range.
+   * @param address Start address.
+   * @param length Number of bytes to scan.
+   * @returns Array of memory regions.
    */
   private regions(address: bigint, length: bigint | number): Region[] {
     const dwLength = 0x30; /* sizeof(MEMORY_BASIC_INFORMATION) */
@@ -258,91 +193,40 @@ class Memory {
     return result;
   }
 
-  // Core memory operations
-
   /**
-   * Follows a multi-level pointer chain and returns the resolved absolute address.
-   *
-   * This helper walks a sequence of offsets starting at `address`, repeatedly
-   * dereferencing intermediate pointers as 64-bit unsigned integers, and finally
-   * adding the last offset without dereferencing.
-   *
-   * Semantics:
-   * - If `offsets` is empty, the original `address` is returned unchanged.
-   * - For each offset except the last, the method adds the offset to the current
-   *   address and dereferences a `uint64` at that location to get the next base.
-   * - If any intermediate dereference yields `0n`:
-   *   - when `throw_` is `true`, an error is thrown;
-   *   - otherwise, `-1n` is returned to indicate a null chain.
-   * - After all intermediate dereferences succeed, the final offset is **added**
-   *   (no dereference) and the resulting absolute address is returned.
-   *
-   * @param address - Starting absolute memory address (BigInt).
-   * @param offsets - Readonly list of `bigint` offsets that define the pointer path.
-   * @param throw_ - When `true`, throw on a null pointer encounter (default: `false`).
-   * @returns The resolved absolute address, or `-1n` if a null pointer was encountered and `throw_` is `false`.
-   * @throws {Error} When a null pointer is encountered and `throw_` is `true`.
-   *
+   * Follows a pointer chain with offsets.
+   * @param address Base address.
+   * @param offsets Array of pointer offsets.
+   * @returns Final address after following the chain, or -1n if any pointer is null.
    * @example
-   * ```typescript
-   * // Typical multi-level pointer chain (moduleBase + 0x123456 → [0x10, 0x20] → +0x30 final)
-   * const client = memory.modules['client.dll'];
-   * const resolved = memory.follow(client.base, [0x10n, 0x20n, 0x30n]);
-   *
-   * if (resolved !== -1n) {
-   *   const health = memory.f32(resolved);
-   *   console.log('Health:', health);
-   * }
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myAddress = cs2.follow(0x10000000n, [0x10n, 0x20n]);
    * ```
    */
-  public follow(address: bigint, offsets: readonly bigint[], throw_ = false): bigint {
+  public follow(address: bigint, offsets: readonly bigint[]): bigint {
     const last = offsets.length - 1;
 
-    if (last === -1) {
-      return address;
-    }
-
     for (let i = 0; i < last; i++) {
-      address = this.u64((address += offsets[i]));
+      address = this.u64(address + offsets[i]);
 
       if (address === 0n) {
-        if (throw_) {
-          throw new Error('address must not be 0n.');
-        }
-
         return -1n;
       }
     }
 
-    return address + offsets[last];
+    return address + (offsets[last] ?? 0n);
   }
 
   /**
-   * Reads data from the target process memory into the provided scratch buffer and returns that
-   * same scratch object (strongly typed). This is a low-level, zero-copy helper used internally by
-   * typed readers.
-   *
-   * @typeParam T - Concrete scratch type extending {@link Scratch} (for example, `Scratch16`,
-   * `Scratch32`, a CString scratch, etc.).
-   *
-   * @param address - Absolute memory address to read from (BigInt).
-   * @param scratch - Destination scratch instance to receive the bytes.
-   * @returns The same scratch instance you passed in, typed as `T`.
-   * @throws {Win32Error} When the underlying `ReadProcessMemory` call fails.
-   *
-   * @todo Research what it will take to add CString to the Scratch type.
-   *
+   * Reads memory into a buffer.
+   * @param address Address to read from.
+   * @param scratch Buffer to fill.
+   * @returns The filled buffer.
    * @example
    * ```ts
-   * // Strongly typed result based on the scratch you pass in:
-   * const s16 = memory.Scratch16;
-   * const out16 = memory.read(0x12345678n, s16);
-   * ```
-   *
-   * @example
-   * ```ts
-   * const myScratch = Buffer.allocUnsafe(64);
-   * const out = memory.read(0x1000_2000n, myScratch);
+   * const cs2 = new Memory('cs2.exe');
+   * const myBuffer = cs2.read(0x12345678n, new Uint8Array(4));
    * ```
    */
   public read<T extends Scratch>(address: bigint, scratch: T): T {
@@ -361,17 +245,14 @@ class Memory {
   }
 
   /**
-   * Writes data from a scratch buffer to the target process memory.
-   * This is a low-level method used internally by the typed write methods.
-   *
-   * @param address - Memory address to write to
-   * @param scratch - Buffer containing the data to write
-   * @throws {Win32Error} When the write operation fails
-   *
+   * Writes a buffer to memory.
+   * @param address Address to write to.
+   * @param scratch Buffer to write.
+   * @returns This instance.
    * @example
-   * ```typescript
-   * const buffer = new Uint8Array([0x41, 0x42, 0x43, 0x44]);
-   * memory.write(0x12345678n, buffer);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * cs2.write(0x12345678n, new Uint8Array([1,2,3,4]));
    * ```
    */
   private write(address: bigint, scratch: Scratch): this {
@@ -389,17 +270,12 @@ class Memory {
     return this;
   }
 
-  // Public read / write methods…
-
   /**
-   * Closes the handle to the target process and releases resources.
-   * This method should be called when the Memory instance is no longer needed.
-   *
+   * Closes the process handle.
    * @example
-   * ```typescript
-   * const memory = new Memory('notepad.exe');
-   * // ... perform memory operations
-   * memory.close(); // Clean up resources
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * cs2.close();
    * ```
    */
   public close(): void {
@@ -409,19 +285,11 @@ class Memory {
   }
 
   /**
-   * Refreshes the list of modules loaded in the target process.
-   * This method should be called if modules are loaded or unloaded during runtime.
-   *
-   * @throws {Win32Error} When module enumeration fails
-   *
+   * Refreshes the module list for the process.
    * @example
-   * ```typescript
-   * // Initial modules
-   * console.log('Initial modules:', Object.keys(memory.modules));
-   *
-   * // After some time, refresh to get updated module list
-   * memory.refresh();
-   * console.log('Updated modules:', Object.keys(memory.modules));
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * cs2.refresh();
    * ```
    */
   public refresh(): void {
@@ -462,23 +330,16 @@ class Memory {
     return;
   }
 
-  // Typed read/write methods
-
   /**
-   * Reads a boolean value from memory or writes a boolean value to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional value to write. If omitted, performs a read operation
-   * @returns The boolean value when reading, or this Memory instance when writing
-   *
+   * Reads or writes a boolean value.
+   * @param address Address to access.
+   * @param value Optional value to write.
+   * @returns The boolean at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read a boolean value
-   * const isAlive = memory.bool(0x12345678n);
-   * console.log('Player is alive:', isAlive);
-   *
-   * // Write a boolean value
-   * memory.bool(0x12345678n, true);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myBool = cs2.bool(0x12345678n);
+   * cs2.bool(0x12345678n, true);
    * ```
    */
   public bool(address: bigint): boolean;
@@ -498,24 +359,15 @@ class Memory {
   }
 
   /**
-   * Reads a raw byte buffer from memory or writes a raw byte buffer to memory.
-   *
-   * When reading, exactly `length` bytes are copied from `address` into a new `Buffer`.
-   * Bytes are returned exactly as laid out in memory—no decoding, alignment, or transformation
-   * is applied. When writing, the contents of `value` are copied to `address` verbatim.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValue - Number of bytes to read (when reading), or `Buffer` to write (when writing)
-   * @returns `Buffer` when reading, or this `Memory` instance when writing
-   *
+   * Reads or writes a Buffer.
+   * @param address Address to access.
+   * @param lengthOrValue Length to read or Buffer to write.
+   * @returns Buffer read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read 16 bytes from memory
-   * const bytes = memory.buffer(0x12345678n, 16);
-   *
-   * // Write a 4-byte patch (NOP sled, for example)
-   * const patch = Buffer.from([0x90, 0x90, 0x90, 0x90]);
-   * memory.buffer(0x12345678n, patch);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myBuffer = cs2.buffer(0x12345678n, 8);
+   * cs2.buffer(0x12345678n, Buffer.from([1,2,3,4]));
    * ```
    */
   public buffer(address: bigint, length: number): Buffer;
@@ -539,31 +391,15 @@ class Memory {
   }
 
   /**
-   * Reads a NUL-terminated C string from memory or writes a NUL-terminated C string to memory.
-   *
-   * When reading, up to `length` bytes are copied into a temporary buffer and a `CString`
-   * is constructed from that buffer. Ensure the requested `length` is large enough to
-   * include the terminator to avoid truncation. When writing, pass a `CString` that is
-   * already NUL-terminated.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValue - Number of bytes to read (when reading), or `CString` to write (when writing)
-   * @returns `CString` when reading, or this `Memory` instance when writing
-   *
-   * @todo Investigate odd behavior when reading strings longer than `lengthOrValue`.
-   * @todo Research and consider alternatives that do not require so many new allocations.
-   *
+   * Reads or writes a C-style string.
+   * @param address Address to access.
+   * @param lengthOrValue Length to read or CString to write.
+   * @returns CString read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read up to 64 bytes and interpret as a C string
-   * const playerName = memory.cString(0x12345678n, 64);
-   * console.log('Player name:', playerName.toString());
-   *
-   * // Write a C string (NUL-terminated)
-   * const valueBuffer = Buffer.from('PlayerOne\0');
-   * const valuePtr = ptr(valueBuffer);
-   * const value = new CString(valuePtr);
-   * memory.cString(0x12345678n, value);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myCString = cs2.cString(0x12345678n, 16);
+   * cs2.cString(0x12345678n, new CString('hello'));
    * ```
    */
   public cString(address: bigint, length: number): CString;
@@ -585,20 +421,15 @@ class Memory {
   }
 
   /**
-   * Reads a 32-bit floating-point value from memory or writes a 32-bit floating-point value to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional value to write. If omitted, performs a read operation
-   * @returns The float value when reading, or this Memory instance when writing
-   *
+   * Reads or writes a 32-bit float.
+   * @param address Address to access.
+   * @param value Optional value to write.
+   * @returns The float at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read a float value
-   * const playerHealth = memory.f32(0x12345678n);
-   * console.log('Player health:', playerHealth);
-   *
-   * // Write a float value
-   * memory.f32(0x12345678n, 100.0);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myFloat = cs2.f32(0x12345678n);
+   * cs2.f32(0x12345678n, 1.23);
    * ```
    */
   public f32(address: bigint): number;
@@ -618,21 +449,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of 32-bit floating-point values from memory or writes an array of 32-bit floating-point values to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of values to write
-   * @returns Float32Array when reading, or this Memory instance when writing
-   *
+   * Reads or writes a Float32Array.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or Float32Array to write.
+   * @returns Float32Array read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read an array of 10 float values
-   * const coordinates = memory.f32Array(0x12345678n, 10);
-   * console.log('Coordinates:', coordinates);
-   *
-   * // Write an array of float values
-   * const newCoordinates = new Float32Array([1.0, 2.5, 3.14, 4.2]);
-   * memory.f32Array(0x12345678n, newCoordinates);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myArray = cs2.f32Array(0x12345678n, 3);
+   * cs2.f32Array(0x12345678n, new Float32Array([1,2,3]));
    * ```
    */
   public f32Array(address: bigint, length: number): Float32Array;
@@ -655,20 +480,15 @@ class Memory {
   }
 
   /**
-   * Reads a 64-bit floating-point value from memory or writes a 64-bit floating-point value to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional value to write. If omitted, performs a read operation
-   * @returns The double value when reading, or this Memory instance when writing
-   *
+   * Reads or writes a 64-bit float.
+   * @param address Address to access.
+   * @param value Optional value to write.
+   * @returns The float at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read a double precision value
-   * const preciseValue = memory.f64(0x12345678n);
-   * console.log('Precise value:', preciseValue);
-   *
-   * // Write a double precision value
-   * memory.f64(0x12345678n, 3.141592653589793);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myFloat = cs2.f64(0x12345678n);
+   * cs2.f64(0x12345678n, 1.23);
    * ```
    */
   public f64(address: bigint): number;
@@ -688,21 +508,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of 64-bit floating-point values from memory or writes an array of 64-bit floating-point values to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of values to write
-   * @returns Float64Array when reading, or this Memory instance when writing
-   *
+   * Reads or writes a Float64Array.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or Float64Array to write.
+   * @returns Float64Array read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read an array of 5 double precision values
-   * const preciseData = memory.f64Array(0x12345678n, 5);
-   * console.log('Precise data:', preciseData);
-   *
-   * // Write an array of double precision values
-   * const newData = new Float64Array([1.1, 2.2, 3.3, 4.4, 5.5]);
-   * memory.f64Array(0x12345678n, newData);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myArray = cs2.f64Array(0x12345678n, 2);
+   * cs2.f64Array(0x12345678n, new Float64Array([1,2]));
    * ```
    */
   public f64Array(address: bigint, length: number): Float64Array;
@@ -725,20 +539,15 @@ class Memory {
   }
 
   /**
-   * Reads a signed 16-bit integer value from memory or writes a signed 16-bit integer value to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional value to write. If omitted, performs a read operation
-   * @returns The int16 value when reading, or this Memory instance when writing
-   *
+   * Reads or writes a 16-bit integer.
+   * @param address Address to access.
+   * @param value Optional value to write.
+   * @returns The int at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read a signed 16-bit integer
-   * const temperature = memory.i16(0x12345678n);
-   * console.log('Temperature:', temperature);
-   *
-   * // Write a signed 16-bit integer
-   * memory.i16(0x12345678n, -273);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myInt = cs2.i16(0x12345678n);
+   * cs2.i16(0x12345678n, 42);
    * ```
    */
   public i16(address: bigint): number;
@@ -758,21 +567,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of signed 16-bit integer values from memory or writes an array of signed 16-bit integer values to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of values to write
-   * @returns Int16Array when reading, or this Memory instance when writing
-   *
+   * Reads or writes an Int16Array.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or Int16Array to write.
+   * @returns Int16Array read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read an array of audio samples
-   * const samples = memory.i16Array(0x12345678n, 1024);
-   * console.log('Audio samples:', samples);
-   *
-   * // Write audio samples
-   * const newSamples = new Int16Array([-100, 200, -300, 400]);
-   * memory.i16Array(0x12345678n, newSamples);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myArray = cs2.i16Array(0x12345678n, 2);
+   * cs2.i16Array(0x12345678n, new Int16Array([1,2]));
    * ```
    */
   public i16Array(address: bigint, length: number): Int16Array;
@@ -795,20 +598,15 @@ class Memory {
   }
 
   /**
-   * Reads a signed 32-bit integer value from memory or writes a signed 32-bit integer value to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional value to write. If omitted, performs a read operation
-   * @returns The int32 value when reading, or this Memory instance when writing
-   *
+   * Reads or writes a 32-bit integer.
+   * @param address Address to access.
+   * @param value Optional value to write.
+   * @returns The int at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read a player's score
-   * const score = memory.i32(0x12345678n);
-   * console.log('Player score:', score);
-   *
-   * // Set a new score
-   * memory.i32(0x12345678n, 999999);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myInt = cs2.i32(0x12345678n);
+   * cs2.i32(0x12345678n, 42);
    * ```
    */
   public i32(address: bigint): number;
@@ -828,21 +626,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of signed 32-bit integer values from memory or writes an array of signed 32-bit integer values to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of values to write
-   * @returns Int32Array when reading, or this Memory instance when writing
-   *
+   * Reads or writes an Int32Array.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or Int32Array to write.
+   * @returns Int32Array read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read inventory item counts
-   * const inventory = memory.i32Array(0x12345678n, 20);
-   * console.log('Inventory:', inventory);
-   *
-   * // Set inventory values
-   * const newInventory = new Int32Array([99, 50, 25, 10, 5]);
-   * memory.i32Array(0x12345678n, newInventory);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myArray = cs2.i32Array(0x12345678n, 2);
+   * cs2.i32Array(0x12345678n, new Int32Array([1,2]));
    * ```
    */
   public i32Array(address: bigint, length: number): Int32Array;
@@ -865,20 +657,15 @@ class Memory {
   }
 
   /**
-   * Reads a signed 64-bit integer value from memory or writes a signed 64-bit integer value to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional value to write. If omitted, performs a read operation
-   * @returns The int64 value when reading, or this Memory instance when writing
-   *
+   * Reads or writes a 64-bit integer.
+   * @param address Address to access.
+   * @param value Optional value to write.
+   * @returns The bigint at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read a large number (timestamp, file size, etc.)
-   * const timestamp = memory.i64(0x12345678n);
-   * console.log('Timestamp:', timestamp);
-   *
-   * // Write a large number
-   * memory.i64(0x12345678n, 9223372036854775807n);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myBigInt = cs2.i64(0x12345678n);
+   * cs2.i64(0x12345678n, 123n);
    * ```
    */
   public i64(address: bigint): bigint;
@@ -898,21 +685,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of signed 64-bit integer values from memory or writes an array of signed 64-bit integer values to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of values to write
-   * @returns BigInt64Array when reading, or this Memory instance when writing
-   *
+   * Reads or writes a BigInt64Array.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or BigInt64Array to write.
+   * @returns BigInt64Array read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read an array of large numbers
-   * const largeNumbers = memory.i64Array(0x12345678n, 10);
-   * console.log('Large numbers:', largeNumbers);
-   *
-   * // Write an array of large numbers
-   * const newNumbers = new BigInt64Array([1n, 2n, 3n, 4n, 5n]);
-   * memory.i64Array(0x12345678n, newNumbers);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myArray = cs2.i64Array(0x12345678n, 2);
+   * cs2.i64Array(0x12345678n, new BigInt64Array([1n,2n]));
    * ```
    */
   public i64Array(address: bigint, length: number): BigInt64Array;
@@ -935,20 +716,15 @@ class Memory {
   }
 
   /**
-   * Reads a signed 8-bit integer value from memory or writes a signed 8-bit integer value to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional value to write. If omitted, performs a read operation
-   * @returns The int8 value when reading, or this Memory instance when writing
-   *
+   * Reads or writes an 8-bit integer.
+   * @param address Address to access.
+   * @param value Optional value to write.
+   * @returns The int at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read a small signed value (e.g., direction, state)
-   * const direction = memory.i8(0x12345678n);
-   * console.log('Direction:', direction);
-   *
-   * // Write a small signed value
-   * memory.i8(0x12345678n, -127);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myInt = cs2.i8(0x12345678n);
+   * cs2.i8(0x12345678n, 7);
    * ```
    */
   public i8(address: bigint): number;
@@ -968,21 +744,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of signed 8-bit integer values from memory or writes an array of signed 8-bit integer values to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of values to write
-   * @returns Int8Array when reading, or this Memory instance when writing
-   *
+   * Reads or writes an Int8Array.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or Int8Array to write.
+   * @returns Int8Array read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read an array of small signed values
-   * const directions = memory.i8Array(0x12345678n, 8);
-   * console.log('Movement directions:', directions);
-   *
-   * // Write movement directions
-   * const newDirections = new Int8Array([-1, 0, 1, -1, 0, 1, -1, 0]);
-   * memory.i8Array(0x12345678n, newDirections);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myArray = cs2.i8Array(0x12345678n, 2);
+   * cs2.i8Array(0x12345678n, new Int8Array([1,2]));
    * ```
    */
   public i8Array(address: bigint, length: number): Int8Array;
@@ -1005,28 +775,15 @@ class Memory {
   }
 
   /**
-   * Reads a 3×3 matrix from memory or writes a 3×3 matrix to memory.
-   *
-   * The matrix is represented as 9 contiguous 32-bit floating-point values (`Float32Array`).
-   * No transposition or stride is applied—values are copied exactly as stored in memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param values - Optional `Float32Array` of length 9 to write. If omitted, performs a read operation
-   * @returns `Float32Array` of length 9 when reading, or this `Memory` instance when writing
-   * @throws {RangeError} When `values.length` is not exactly 9
-   *
+   * Reads or writes a 3x3 matrix (Float32Array of length 9).
+   * @param address Address to access.
+   * @param values Optional Float32Array to write.
+   * @returns The matrix at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read a 3×3 matrix
-   * const matrix = memory.matrix3x3(0x12345678n); // Float32Array(9)
-   *
-   * // Write a 3×3 matrix (length must be 9)
-   * const next = new Float32Array([
-   *   1, 0, 0,
-   *   0, 1, 0,
-   *   0, 0, 1
-   * ]);
-   * memory.matrix3x3(0x12345678n, next);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myMatrix = cs2.matrix3x3(0x12345678n);
+   * cs2.matrix3x3(0x12345678n, new Float32Array(9));
    * ```
    */
   public matrix3x3(address: bigint): Float32Array;
@@ -1049,6 +806,18 @@ class Memory {
     return this;
   }
 
+  /**
+   * Reads or writes a 3x4 matrix (Float32Array of length 12).
+   * @param address Address to access.
+   * @param values Optional Float32Array to write.
+   * @returns The matrix at address, or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myMatrix = cs2.matrix3x4(0x12345678n);
+   * cs2.matrix3x4(0x12345678n, new Float32Array(12));
+   * ```
+   */
   public matrix3x4(address: bigint): Float32Array;
   public matrix3x4(address: bigint, values: Float32Array): this;
   public matrix3x4(address: bigint, values?: Float32Array): Float32Array | this {
@@ -1070,29 +839,15 @@ class Memory {
   }
 
   /**
-   * Reads a 4×4 matrix from memory or writes a 4×4 matrix to memory.
-   *
-   * The matrix is represented as 16 contiguous 32-bit floating-point values (`Float32Array`).
-   * No transposition or stride is applied—values are copied exactly as stored in memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param values - Optional `Float32Array` of length 16 to write. If omitted, performs a read operation
-   * @returns `Float32Array` of length 16 when reading, or this `Memory` instance when writing
-   * @throws {RangeError} When `values.length` is not exactly 16
-   *
+   * Reads or writes a 4x4 matrix (Float32Array of length 16).
+   * @param address Address to access.
+   * @param values Optional Float32Array to write.
+   * @returns The matrix at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read a 4×4 matrix
-   * const matrix = memory.matrix4x4(0x12345678n); // Float32Array(16)
-   *
-   * // Write a 4×4 matrix (length must be 16)
-   * const next = new Float32Array([
-   *   1, 0, 0, 0,
-   *   0, 1, 0, 0,
-   *   0, 0, 1, 0,
-   *   0, 0, 0, 1
-   * ]);
-   * memory.matrix4x4(0x12345678n, next);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myMatrix = cs2.matrix4x4(0x12345678n);
+   * cs2.matrix4x4(0x12345678n, new Float32Array(16));
    * ```
    */
   public matrix4x4(address: bigint): Float32Array;
@@ -1116,31 +871,15 @@ class Memory {
   }
 
   /**
-   * Reads a `NetworkUtlVector` (`Uint32Array`) from memory or writes a `NetworkUtlVector` to memory.
-   *
-   * The vector is represented in memory as a small header with an out-of-line elements buffer.
-   * Layout at `address`:
-   * - 0x00: `uint32` size (number of elements)
-   * - 0x04: `uint32` capacity/reserved (not modified by this method)
-   * - 0x08: `uint64` pointer to a contiguous array of `uint32` elements
-   *
-   * When reading, this method returns a `Uint32Array` containing `size` elements copied from the
-   * elements pointer. When writing, it updates the size field and writes the provided values to the
-   * existing elements buffer (no reallocation is performed).
-   *
-   * @param address - Memory address of the vector header to read from or write to
-   * @param values - Optional `NetworkUtlVector` to write. If omitted, performs a read operation
-   * @returns `NetworkUtlVector` when reading, or this `Memory` instance when writing
-   *
+   * Reads or writes a NetworkUtlVector (Uint32Array).
+   * @param address Address to access.
+   * @param values Optional Uint32Array to write.
+   * @returns The vector at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read the current vector
-   * const ids = memory.networkUtlVector(0x12345678n);
-   * console.log('IDs:', Array.from(ids));
-   *
-   * // Write new values (must fit the existing buffer capacity)
-   * const next = new Uint32Array([10, 20, 30, 40]);
-   * memory.networkUtlVector(0x12345678n, next);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myVector = cs2.networkUtlVector(0x12345678n);
+   * cs2.networkUtlVector(0x12345678n, new Uint32Array([1,2,3]));
    * ```
    */
   public networkUtlVector(address: bigint): NetworkUtlVector;
@@ -1166,24 +905,97 @@ class Memory {
   }
 
   /**
-   * Reads a set of Euler angles from memory or writes a set of Euler angles to memory.
-   *
-   * Angles are stored as three 32-bit floats in the order **pitch, yaw, roll**.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional `QAngle` to write. If omitted, performs a read operation
-   * @returns The `QAngle` value when reading, or this `Memory` instance when writing
-   *
+   * Reads or writes a Point (object with x, y).
+   * @param address Address to access.
+   * @param value Optional Point to write.
+   * @returns The point at address, or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myPoint = cs2.point(0x12345678n);
+   * cs2.point(0x12345678n, { x: 1, y: 2 });
+   * ```
+   */
+  public point(address: bigint): Point;
+  public point(address: bigint, value: Point): this;
+  public point(address: bigint, value?: Point): Point | this {
+    if (value === undefined) {
+      this.read(address, this.Scratch8);
+
+      const x = f32(this.Scratch8.ptr);
+      const y = f32(this.Scratch8.ptr, 0x04);
+
+      return { x, y };
+    }
+
+    this.Scratch8Buffer.writeFloatLE(value.x);
+    this.Scratch8Buffer.writeFloatLE(value.y, 0x04);
+
+    this.write(address, this.Scratch8);
+
+    return this;
+  }
+
+  /**
+   * Reads or writes an array of Points.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or array to write.
+   * @returns Array of points read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read current view angles
-   * const view = memory.qAngle(0x12345678n);
-   *
-   * // Write new view angles (e.g., level the roll)
-   * memory.qAngle(0x12345678n, { ...view, roll: 0 });
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myPoints = cs2.pointArray(0x12345678n, 2);
+   * cs2.pointArray(0x12345678n, [{ x: 1, y: 2 }, { x: 3, y: 4 }]);
    * ```
    */
+  public pointArray(address: bigint, length: number): Point[];
+  public pointArray(address: bigint, value: Point[]): this;
+  public pointArray(address: bigint, lengthOrValues: number | Point[]): Point[] | this {
+    if (typeof lengthOrValues === 'number') {
+      const length = lengthOrValues;
+      const scratch = new Float32Array(length * 2);
+
+      this.read(address, scratch);
+
+      const result = new Array<Vector2>(length);
+
+      for (let i = 0, j = 0; i < length; i++, j += 0x02) {
+        const x = scratch[j];
+        const y = scratch[j + 0x01];
+
+        result[i] = { x, y };
+      }
+
+      return result;
+    }
+
+    const values = lengthOrValues;
+    const scratch = new Float32Array(values.length * 0x02);
+
+    for (let i = 0, j = 0; i < values.length; i++, j += 0x02) {
+      const vector2 = values[i];
+
+      scratch[j] = vector2.x;
+      scratch[j + 0x01] = vector2.y;
+    }
+
+    this.write(address, scratch);
 
+    return this;
+  }
+
+  /**
+   * Reads or writes a QAngle (object with pitch, yaw, roll).
+   * @param address Address to access.
+   * @param value Optional QAngle to write.
+   * @returns The QAngle at address, or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myQAngle = cs2.qAngle(0x12345678n);
+   * cs2.qAngle(0x12345678n, { pitch: 1, yaw: 2, roll: 3 });
+   * ```
+   */
   public qAngle(address: bigint): QAngle;
   public qAngle(address: bigint, value: QAngle): this;
   public qAngle(address: bigint, value?: QAngle): QAngle | this {
@@ -1207,22 +1019,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of Euler angles from memory or writes an array of Euler angles to memory.
-   *
-   * Each element is three 32-bit floats in the order **pitch, yaw, roll**.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of `QAngle` values to write
-   * @returns `QAngle[]` when reading, or this `Memory` instance when writing
-   *
+   * Reads or writes an array of QAngles.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or array to write.
+   * @returns Array of QAngles read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read bone aim offsets
-   * const bones = memory.qAngleArray(0x12345678n, 64);
-   *
-   * // Write new bone angles (e.g., reset all roll to zero)
-   * bones.forEach(b => (b.roll = 0));
-   * memory.qAngleArray(0x12345678n, bones);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myQAngles = cs2.qAngleArray(0x12345678n, 2);
+   * cs2.qAngleArray(0x12345678n, [{ pitch: 1, yaw: 2, roll: 3 }]);
    * ```
    */
   public qAngleArray(address: bigint, length: number): QAngle[];
@@ -1263,21 +1068,15 @@ class Memory {
   }
 
   /**
-   * Reads a quaternion (4D rotation) from memory or writes a quaternion to memory.
-   * Quaternions are stored as four 32-bit floats: x, y, z, w.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional quaternion to write. If omitted, performs a read operation
-   * @returns The Quaternion object when reading, or this Memory instance when writing
-   *
+   * Reads or writes a Quaternion (object with w, x, y, z).
+   * @param address Address to access.
+   * @param value Optional Quaternion to write.
+   * @returns The Quaternion at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read player rotation
-   * const rotation = memory.quaternion(0x12345678n);
-   * console.log('Player rotation:', rotation);
-   *
-   * // Set player rotation to identity
-   * memory.quaternion(0x12345678n, { x: 0, y: 0, z: 0, w: 1 });
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myQuaternion = cs2.quaternion(0x12345678n);
+   * cs2.quaternion(0x12345678n, { w: 1, x: 0, y: 0, z: 0 });
    * ```
    */
   public quaternion(address: bigint): Quaternion;
@@ -1305,21 +1104,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of quaternions from memory or writes an array of quaternions to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of quaternions to write
-   * @returns Array of Quaternion objects when reading, or this Memory instance when writing
-   *
+   * Reads or writes an array of Quaternions.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or array to write.
+   * @returns Array of Quaternions read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read bone rotations for skeletal animation
-   * const boneRotations = memory.quaternionArray(0x12345678n, 50);
-   * console.log('Bone rotations:', boneRotations);
-   *
-   * // Set all bones to identity rotation
-   * const identityRotations = Array(50).fill({ x: 0, y: 0, z: 0, w: 1 });
-   * memory.quaternionArray(0x12345678n, identityRotations);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myQuaternions = cs2.quaternionArray(0x12345678n, 2);
+   * cs2.quaternionArray(0x12345678n, [{ w: 1, x: 0, y: 0, z: 0 }]);
    * ```
    */
   public quaternionArray(address: bigint, length: number): Quaternion[];
@@ -1363,20 +1156,81 @@ class Memory {
   }
 
   /**
-   * Reads an unsigned 16-bit integer value from memory or writes an unsigned 16-bit integer value to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional value to write. If omitted, performs a read operation
-   * @returns The uint16 value when reading, or this Memory instance when writing
-   *
+   * Reads or writes an RGB color (object with r, g, b).
+   * @param address Address to access.
+   * @param value Optional RGB to write.
+   * @returns The RGB at address, or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myRGB = cs2.rgb(0x12345678n);
+   * cs2.rgb(0x12345678n, { r: 255, g: 0, b: 0 });
+   * ```
+   */
+  public rgb(address: bigint): RGB;
+  public rgb(address: bigint, value: RGB): this;
+  public rgb(address: bigint, value?: RGB): RGB | this {
+    if (value === undefined) {
+      this.read(address, this.Scratch4);
+
+      const r = this.Scratch3Buffer.readUInt8(),
+            g = this.Scratch3Buffer.readUInt8(0x01),
+            b = this.Scratch3Buffer.readUInt8(0x02); // prettier-ignore
+
+      return { r, g, b };
+    }
+
+    this.Scratch3Buffer.writeUInt8(value.r);
+    this.Scratch3Buffer.writeUInt8(value.g, 0x01);
+    this.Scratch3Buffer.writeUInt8(value.b, 0x02);
+
+    return this.write(address, this.Scratch4);
+  }
+
+  /**
+   * Reads or writes an RGBA color (object with r, g, b, a).
+   * @param address Address to access.
+   * @param value Optional RGBA to write.
+   * @returns The RGBA at address, or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myRGBA = cs2.rgba(0x12345678n);
+   * cs2.rgba(0x12345678n, { r: 255, g: 0, b: 0, a: 255 });
+   * ```
+   */
+  public rgba(address: bigint): RGBA;
+  public rgba(address: bigint, value: RGBA): this;
+  public rgba(address: bigint, value?: RGBA): RGBA | this {
+    if (value === undefined) {
+      this.read(address, this.Scratch4);
+
+      const r = this.Scratch4Buffer.readUInt8(),
+            g = this.Scratch4Buffer.readUInt8(0x01),
+            b = this.Scratch4Buffer.readUInt8(0x02),
+            a = this.Scratch4Buffer.readUInt8(0x03); // prettier-ignore
+
+      return { r, g, b, a };
+    }
+
+    this.Scratch4Buffer.writeUInt8(value.r);
+    this.Scratch4Buffer.writeUInt8(value.g, 0x01);
+    this.Scratch4Buffer.writeUInt8(value.b, 0x02);
+    this.Scratch4Buffer.writeUInt8(value.a, 0x03);
+
+    return this.write(address, this.Scratch4);
+  }
+
+  /**
+   * Reads or writes a 16-bit unsigned integer.
+   * @param address Address to access.
+   * @param value Optional value to write.
+   * @returns The value at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read a port number or small positive value
-   * const port = memory.u16(0x12345678n);
-   * console.log('Network port:', port);
-   *
-   * // Write a port number
-   * memory.u16(0x12345678n, 8080);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myInt = cs2.u16(0x12345678n);
+   * cs2.u16(0x12345678n, 42);
    * ```
    */
   public u16(address: bigint): number;
@@ -1396,21 +1250,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of unsigned 16-bit integer values from memory or writes an array of unsigned 16-bit integer values to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of values to write
-   * @returns Uint16Array when reading, or this Memory instance when writing
-   *
+   * Reads or writes a Uint16Array.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or Uint16Array to write.
+   * @returns Uint16Array read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read an array of port numbers
-   * const ports = memory.u16Array(0x12345678n, 10);
-   * console.log('Active ports:', ports);
-   *
-   * // Write port configuration
-   * const newPorts = new Uint16Array([80, 443, 8080, 3000, 5432]);
-   * memory.u16Array(0x12345678n, newPorts);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myArray = cs2.u16Array(0x12345678n, 2);
+   * cs2.u16Array(0x12345678n, new Uint16Array([1,2]));
    * ```
    */
   public u16Array(address: bigint, length: number): Uint16Array;
@@ -1433,20 +1281,15 @@ class Memory {
   }
 
   /**
-   * Reads an unsigned 32-bit integer value from memory or writes an unsigned 32-bit integer value to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional value to write. If omitted, performs a read operation
-   * @returns The uint32 value when reading, or this Memory instance when writing
-   *
+   * Reads or writes a 32-bit unsigned integer.
+   * @param address Address to access.
+   * @param value Optional value to write.
+   * @returns The value at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read player's money (always positive)
-   * const money = memory.u32(0x12345678n);
-   * console.log('Player money:', money);
-   *
-   * // Give player maximum money
-   * memory.u32(0x12345678n, 4294967295);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myInt = cs2.u32(0x12345678n);
+   * cs2.u32(0x12345678n, 42);
    * ```
    */
   public u32(address: bigint): number;
@@ -1466,21 +1309,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of unsigned 32-bit integer values from memory or writes an array of unsigned 32-bit integer values to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of values to write
-   * @returns Uint32Array when reading, or this Memory instance when writing
-   *
+   * Reads or writes a Uint32Array.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or Uint32Array to write.
+   * @returns Uint32Array read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read resource amounts
-   * const resources = memory.u32Array(0x12345678n, 6);
-   * console.log('Resources:', resources);
-   *
-   * // Set resource amounts
-   * const newResources = new Uint32Array([1000, 2000, 3000, 4000, 5000, 6000]);
-   * memory.u32Array(0x12345678n, newResources);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myArray = cs2.u32Array(0x12345678n, 2);
+   * cs2.u32Array(0x12345678n, new Uint32Array([1,2]));
    * ```
    */
   public u32Array(address: bigint, length: number): Uint32Array;
@@ -1503,20 +1340,15 @@ class Memory {
   }
 
   /**
-   * Reads an unsigned 64-bit integer value from memory or writes an unsigned 64-bit integer value to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional value to write. If omitted, performs a read operation
-   * @returns The uint64 value when reading, or this Memory instance when writing
-   *
+   * Reads or writes a 64-bit unsigned integer.
+   * @param address Address to access.
+   * @param value Optional value to write.
+   * @returns The bigint at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read a very large positive number
-   * const recordId = memory.u64(0x12345678n);
-   * console.log('Record ID:', recordId);
-   *
-   * // Write a very large positive number
-   * memory.u64(0x12345678n, 18446744073709551615n);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myBigInt = cs2.u64(0x12345678n);
+   * cs2.u64(0x12345678n, 123n);
    * ```
    */
   public u64(address: bigint): bigint;
@@ -1536,21 +1368,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of unsigned 64-bit integer values from memory or writes an array of unsigned 64-bit integer values to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of values to write
-   * @returns BigUint64Array when reading, or this Memory instance when writing
-   *
+   * Reads or writes a BigUint64Array.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or BigUint64Array to write.
+   * @returns BigUint64Array read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read an array of record IDs
-   * const recordIds = memory.u64Array(0x12345678n, 100);
-   * console.log('Record IDs:', recordIds);
-   *
-   * // Write record IDs
-   * const newIds = new BigUint64Array([1000n, 2000n, 3000n, 4000n]);
-   * memory.u64Array(0x12345678n, newIds);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myArray = cs2.u64Array(0x12345678n, 2);
+   * cs2.u64Array(0x12345678n, new BigUint64Array([1n,2n]));
    * ```
    */
   public u64Array(address: bigint, length: number): BigUint64Array;
@@ -1573,20 +1399,15 @@ class Memory {
   }
 
   /**
-   * Reads an unsigned 8-bit integer value from memory or writes an unsigned 8-bit integer value to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional value to write. If omitted, performs a read operation
-   * @returns The uint8 value when reading, or this Memory instance when writing
-   *
+   * Reads or writes an 8-bit unsigned integer.
+   * @param address Address to access.
+   * @param value Optional value to write.
+   * @returns The value at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read a byte value (0-255)
-   * const opacity = memory.u8(0x12345678n);
-   * console.log('UI opacity:', opacity);
-   *
-   * // Set opacity to maximum
-   * memory.u8(0x12345678n, 255);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myInt = cs2.u8(0x12345678n);
+   * cs2.u8(0x12345678n, 7);
    * ```
    */
   public u8(address: bigint): number;
@@ -1606,21 +1427,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of unsigned 8-bit integer values from memory or writes an array of unsigned 8-bit integer values to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of values to write
-   * @returns Uint8Array when reading, or this Memory instance when writing
-   *
+   * Reads or writes a Uint8Array.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or Uint8Array to write.
+   * @returns Uint8Array read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read pixel data
-   * const pixels = memory.u8Array(0x12345678n, 1024);
-   * console.log('Pixel data:', pixels);
-   *
-   * // Write pixel data
-   * const newPixels = new Uint8Array([255, 128, 64, 32, 16, 8, 4, 2]);
-   * memory.u8Array(0x12345678n, newPixels);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myArray = cs2.u8Array(0x12345678n, 2);
+   * cs2.u8Array(0x12345678n, new Uint8Array([1,2]));
    * ```
    */
   public u8Array(address: bigint, length: number): Uint8Array;
@@ -1643,117 +1458,107 @@ class Memory {
   }
 
   /**
-   * Reads a 2D vector from memory or writes a 2D vector to memory.
-   * Vectors are stored as two 32-bit floats: x, y.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional vector to write. If omitted, performs a read operation
-   * @returns The Vector2 object when reading, or this Memory instance when writing
-   *
+   * Reads or writes a pointer-sized unsigned integer.
+   * @param address Address to access.
+   * @param value Optional value to write.
+   * @returns The value at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read player position
-   * const position = memory.vector2(0x12345678n);
-   * console.log('Player position:', position);
-   *
-   * // Teleport player to origin
-   * memory.vector2(0x12345678n, { x: 0, y: 0 });
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myPtr = cs2.uPtr(0x12345678n);
+   * cs2.uPtr(0x12345678n, 123n);
    * ```
    */
-  public vector2(address: bigint): Vector2;
-  public vector2(address: bigint, value: Vector2): this;
-  public vector2(address: bigint, value?: Vector2): Vector2 | this {
+  public uPtr(address: bigint): UPtr;
+  public uPtr(address: bigint, value: UPtr): this;
+  public uPtr(address: bigint, value?: UPtr): UPtr | this {
+    // TypeScript is funny sometimes, isn't it?… 🫠…
     if (value === undefined) {
-      this.read(address, this.Scratch8);
+      return this.u64(address);
+    }
 
-      const x = f32(this.Scratch8.ptr);
-      const y = f32(this.Scratch8.ptr, 0x04);
+    return this.u64(address, value);
+  }
 
-      return { x, y };
+  /**
+   * Reads or writes an array of pointer-sized unsigned integers.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or array to write.
+   * @returns Array read or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myPtrs = cs2.uPtrArray(0x12345678n, 2);
+   * cs2.uPtrArray(0x12345678n, new BigUint64Array([1n,2n]));
+   * ```
+   */
+  public uPtrArray(address: bigint, length: number): UPtrArray;
+  public uPtrArray(address: bigint, values: UPtrArray): this;
+  public uPtrArray(address: bigint, lengthOrValues: UPtrArray | number): UPtrArray | this {
+    // TypeScript is funny sometimes, isn't it?… 🫠…
+    if (typeof lengthOrValues === 'number') {
+      return this.u64Array(address, lengthOrValues);
     }
 
-    this.Scratch8Buffer.writeFloatLE(value.x);
-    this.Scratch8Buffer.writeFloatLE(value.y, 0x04);
+    return this.u64Array(address, lengthOrValues);
+  }
 
-    this.write(address, this.Scratch8);
+  /**
+   * Reads or writes a Vector2 (object with x, y).
+   * @param address Address to access.
+   * @param value Optional Vector2 to write.
+   * @returns The Vector2 at address, or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myVector2 = cs2.vector2(0x12345678n);
+   * cs2.vector2(0x12345678n, { x: 1, y: 2 });
+   * ```
+   */
+  public vector2(address: bigint): Vector2;
+  public vector2(address: bigint, value: Vector2): this;
+  public vector2(address: bigint, value?: Vector2): Vector2 | this {
+    // TypeScript is funny sometimes, isn't it?… 🫠…
+    if (value === undefined) {
+      return this.point(address);
+    }
 
-    return this;
+    return this.point(address, value);
   }
 
   /**
-   * Reads an array of 2D vectors from memory or writes an array of 2D vectors to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of vectors to write
-   * @returns Array of Vector2 objects when reading, or this Memory instance when writing
-   *
+   * Reads or writes an array of Vector2.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or array to write.
+   * @returns Array of Vector2 read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read waypoints for AI pathfinding
-   * const waypoints = memory.vector2Array(0x12345678n, 20);
-   * console.log('AI waypoints:', waypoints);
-   *
-   * // Set new waypoints
-   * const newWaypoints = [
-   *   { x: 10, y: 20 },
-   *   { x: 30, y: 40 },
-   *   { x: 50, y: 60 }
-   * ];
-   * memory.vector2Array(0x12345678n, newWaypoints);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myVectors = cs2.vector2Array(0x12345678n, 2);
+   * cs2.vector2Array(0x12345678n, [{ x: 1, y: 2 }, { x: 3, y: 4 }]);
    * ```
    */
   public vector2Array(address: bigint, length: number): Vector2[];
   public vector2Array(address: bigint, values: Vector2[]): this;
   public vector2Array(address: bigint, lengthOrValues: Vector2[] | number): Vector2[] | this {
+    // TypeScript is funny sometimes, isn't it?… 🫠…
     if (typeof lengthOrValues === 'number') {
-      const length = lengthOrValues;
-      const scratch = new Float32Array(length * 2);
-
-      this.read(address, scratch);
-
-      const result = new Array<Vector2>(length);
-
-      for (let i = 0, j = 0; i < length; i++, j += 0x02) {
-        const x = scratch[j];
-        const y = scratch[j + 0x01];
-
-        result[i] = { x, y };
-      }
-
-      return result;
+      return this.pointArray(address, lengthOrValues);
     }
 
-    const values = lengthOrValues;
-    const scratch = new Float32Array(values.length * 0x02);
-
-    for (let i = 0, j = 0; i < values.length; i++, j += 0x02) {
-      const vector2 = values[i];
-
-      scratch[j] = vector2.x;
-      scratch[j + 0x01] = vector2.y;
-    }
-
-    this.write(address, scratch);
-
-    return this;
+    return this.pointArray(address, lengthOrValues);
   }
 
   /**
-   * Reads a 3D vector from memory or writes a 3D vector to memory.
-   * Vectors are stored as three 32-bit floats: x, y, z.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional vector to write. If omitted, performs a read operation
-   * @returns The Vector3 object when reading, or this Memory instance when writing
-   *
+   * Reads or writes a Vector3 (object with x, y, z).
+   * @param address Address to access.
+   * @param value Optional Vector3 to write.
+   * @returns The Vector3 at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read player 3D position
-   * const position = memory.vector3(0x12345678n);
-   * console.log('Player 3D position:', position);
-   *
-   * // Teleport player to specific location
-   * memory.vector3(0x12345678n, { x: 100, y: 50, z: 200 });
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myVector3 = cs2.vector3(0x12345678n);
+   * cs2.vector3(0x12345678n, { x: 1, y: 2, z: 3 });
    * ```
    */
   public vector3(address: bigint): Vector3;
@@ -1779,25 +1584,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of 3D vectors from memory or writes an array of 3D vectors to memory.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of vectors to write
-   * @returns Array of Vector3 objects when reading, or this Memory instance when writing
-   *
+   * Reads or writes an array of Vector3.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or array to write.
+   * @returns Array of Vector3 read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read vertex positions for 3D model
-   * const vertices = memory.vector3Array(0x12345678n, 500);
-   * console.log('3D vertices:', vertices);
-   *
-   * // Update vertex positions
-   * const newVertices = [
-   *   { x: 1.0, y: 0.0, z: 0.0 },
-   *   { x: 0.0, y: 1.0, z: 0.0 },
-   *   { x: 0.0, y: 0.0, z: 1.0 }
-   * ];
-   * memory.vector3Array(0x12345678n, newVertices);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myVectors = cs2.vector3Array(0x12345678n, 2);
+   * cs2.vector3Array(0x12345678n, [{ x: 1, y: 2, z: 3 }]);
    * ```
    */
   public vector3Array(address: bigint, length: number): Vector3[];
@@ -1839,22 +1634,15 @@ class Memory {
   }
 
   /**
-   * Reads a 4D vector from memory or writes a 4D vector to memory.
-   *
-   * Uses the same 16-byte layout as {@link Memory.quaternion}: four 32-bit floats
-   * stored in the order **x, y, z, w**. Returned objects are shaped as `{ w, x, y, z }`.
-   *
-   * @param address - Memory address to read from or write to
-   * @param value - Optional `Vector4` to write. If omitted, performs a read operation
-   * @returns The `Vector4` value when reading, or this `Memory` instance when writing
-   *
+   * Reads or writes a Vector4 (object with w, x, y, z).
+   * @param address Address to access.
+   * @param value Optional Vector4 to write.
+   * @returns The Vector4 at address, or this instance if writing.
    * @example
-   * ```typescript
-   * // Read directional data in projective space
-   * const value = memory.vector4(0x12345678n);
-   *
-   * // Write a vector4 value (e.g., identity quaternion)
-   * memory.vector4(0x12345678n, { x: 0, y: 0, z: 0, w: 1 });
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myVector4 = cs2.vector4(0x12345678n);
+   * cs2.vector4(0x12345678n, { w: 1, x: 0, y: 0, z: 0 });
    * ```
    */
   public vector4(address: bigint): Vector4;
@@ -1869,23 +1657,15 @@ class Memory {
   }
 
   /**
-   * Reads an array of 4D vectors from memory or writes an array of 4D vectors to memory.
-   *
-   * Each element uses the same 16-byte layout as {@link Memory.quaternionArray}:
-   * four 32-bit floats stored in the order **x, y, z, w**.
-   *
-   * @param address - Memory address to read from or write to
-   * @param lengthOrValues - Length of array to read, or array of `Vector4` values to write
-   * @returns `Vector4[]` when reading, or this `Memory` instance when writing
-   *
+   * Reads or writes an array of Vector4.
+   * @param address Address to access.
+   * @param lengthOrValues Length to read or array to write.
+   * @returns Array of Vector4 read or this instance if writing.
    * @example
-   * ```typescript
-   * // Read per-vertex tangent vectors (xyzw)
-   * const tangents = memory.vector4Array(0x12345678n, 1024);
-   *
-   * // Write tangent vectors (eg. normalize w to 1.0)
-   * tangents.forEach(v => (v.w = 1.0));
-   * memory.vector4Array(0x12345678n, tangents);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myVectors = cs2.vector4Array(0x12345678n, 2);
+   * cs2.vector4Array(0x12345678n, [{ w: 1, x: 0, y: 0, z: 0 }]);
    * ```
    */
   public vector4Array(address: bigint, length: number): Vector4[];
@@ -1902,37 +1682,17 @@ class Memory {
   // Public utility methods…
 
   /**
-   * Searches a memory range for a byte sequence and returns the absolute address of the first match.
-   *
-   * This method reads `length` bytes starting at `address` into a temporary buffer and performs a
-   * subsequence search. No region or protection checking is performed; ensure the range is readable
-   * before calling.
-   *
-   * The `needle` accepts any Scratch-compatible buffer or view (`Buffer`, `TypedArray`, or `DataView`).
-   * Bytes are matched exactly as laid out in memory. :contentReference[oaicite:0]{index=0}
-   *
-   * @param needle - Byte sequence to search for (Scratch-compatible buffer or view)
-   * @param address - Base memory address to begin searching (inclusive)
-   * @param length - Number of bytes to scan
-   * @returns Absolute address (`bigint`) of the first match, or `-1n` when not found
-   *
+   * Finds the address of a buffer within a memory region.
+   * @param needle Buffer to search for.
+   * @param address Start address.
+   * @param length Number of bytes to search.
+   * @returns Address of the buffer if found, or -1n.
    * @example
-   * ```typescript
-   * // Search a loaded module for a byte sequence
-   * const client = memory.modules['client.dll'];
-   *
-   * const needle = Buffer.from([0x48, 0x8B, 0x05, 0x00, 0x00, 0x00, 0x00]);
-   * const matchAddress = memory.indexOf(needle, client.base, client.size);
-   * ```
-   *
-   * @example
-   * ```typescript
-   * // Search using a Uint32Array needle (bytes are matched exactly as laid out in memory)
-   * const needle = new Uint32Array([0xDEADBEEF, 0x11223344]);
-   * const matchAddress = memory.indexOf(needle, client.base, client.size);
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myAddress = cs2.indexOf(new Uint8Array([1,2,3]), 0x10000000n, 100);
    * ```
    */
-
   public indexOf(needle: Scratch, address: bigint, length: number): bigint {
     const haystackUint8Array = new Uint8Array(length);