bun-memory 1.1.36 → 1.1.38

package/structs/Memory.ts

@@ -4,27 +4,21 @@ import type { Module, NetworkUtlVector, Point, QAngle, Quaternion, Region, RGB,
 import Win32Error from './Win32Error';
 
 const {
-  symbols: { CloseHandle, CreateToolhelp32Snapshot, GetLastError, Module32FirstW, Module32NextW, OpenProcess, Process32FirstW, Process32NextW, ReadProcessMemory, VirtualQueryEx, WriteProcessMemory },
+  symbols: { CloseHandle, CreateToolhelp32Snapshot, GetLastError, Module32FirstW, Module32NextW, OpenProcess, Process32FirstW, Process32NextW, ReadProcessMemory, VirtualProtectEx, WriteProcessMemory },
 } = dlopen('kernel32.dll', {
   CloseHandle: { args: [FFIType.u64], returns: FFIType.bool },
-  CreateRemoteThread: { args: [FFIType.u64, FFIType.u64, FFIType.u64, FFIType.u64, FFIType.u64, FFIType.u32, FFIType.ptr], returns: FFIType.u64 },
   CreateToolhelp32Snapshot: { args: [FFIType.u32, FFIType.u32], returns: FFIType.u64 },
   GetCurrentProcess: { args: [], returns: FFIType.ptr },
-  GetExitCodeThread: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.bool },
   GetLastError: { returns: FFIType.u32 },
-  IsWow64Process2: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.bool },
   Module32FirstW: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.bool },
   Module32NextW: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.bool },
   OpenProcess: { args: [FFIType.u32, FFIType.bool, FFIType.u32], returns: FFIType.u64 },
   Process32FirstW: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.bool },
   Process32NextW: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.bool },
-  ReadProcessMemory: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.u64_fast, FFIType.ptr], returns: FFIType.bool },
-  VirtualAllocEx: { args: [FFIType.u64, FFIType.u64, FFIType.u64, FFIType.u32, FFIType.u32], returns: FFIType.u64 },
-  VirtualFreeEx: { args: [FFIType.u64, FFIType.u64, FFIType.u64, FFIType.u32], returns: FFIType.bool },
+  ReadProcessMemory: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.u64, FFIType.ptr], returns: FFIType.bool },
   VirtualProtectEx: { args: [FFIType.u64, FFIType.u64, FFIType.u64, FFIType.u32, FFIType.ptr], returns: FFIType.bool },
   VirtualQueryEx: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.u64], returns: FFIType.u64 },
-  WaitForSingleObject: { args: [FFIType.u64, FFIType.u32], returns: FFIType.u32 },
-  WriteProcessMemory: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.u64_fast, FFIType.ptr], returns: FFIType.bool },
+  WriteProcessMemory: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.u64, FFIType.ptr], returns: FFIType.bool },
 });
 
 /**
@@ -116,17 +110,6 @@ class Memory {
     throw new Error(`Process not found: ${identifier}…`);
   }
 
-  // public call(address: bigint, args: { type: FFIType, value: any }[] = [], timeout: number = 5_000): bigint {}
-
-  /**
-   * Memory protection flags for safe and unsafe regions.
-   * Used to filter readable/writable memory areas.
-   */
-  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 */,
-  };
-
   /**
    * Regex patterns for matching hex strings and wildcards in memory scans.
    * Used by the pattern method.
@@ -177,7 +160,6 @@ class Memory {
   private readonly Scratch16 = new Uint8Array(0x10);
   private readonly Scratch16Float32Array = new Float32Array(this.Scratch16.buffer, this.Scratch16.byteOffset, 0x04);
 
-  private readonly ScratchMemoryBasicInformation = Buffer.allocUnsafe(0x30 /* sizeof(MEMORY_BASIC_INFORMATION) */);
   private readonly ScratchModuleEntry32W = Buffer.allocUnsafe(0x438 /* sizeof(MODULEENTRY32W) */);
 
   private static TextDecoderUTF8 = new TextDecoder('utf-8');
@@ -305,7 +287,7 @@ class Memory {
   public read<T extends Scratch>(address: bigint, scratch: T): T {
     const lpBaseAddress = address;
     const lpBuffer = ptr(scratch);
-    const nSize = scratch.byteLength;
+    const nSize = BigInt(scratch.byteLength);
     const numberOfBytesRead = 0x00n;
 
     const bReadProcessMemory = ReadProcessMemory(this.hProcess, lpBaseAddress, lpBuffer, nSize, numberOfBytesRead);
@@ -321,25 +303,57 @@ class Memory {
    * Writes a buffer to memory.
    * @param address Address to write to.
    * @param scratch Buffer to write.
+   * @param force When writing, if true temporarily changes page protection to allow the 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');
    * cs2.write(0x12345678n, new Uint8Array([1,2,3,4]));
+   * // Force a write by temporarily changing memory protection
+   * cs2.write(0x12345678n, new Uint8Array([1,2,3,4]), true);
    * ```
    */
-  private write(address: bigint, scratch: Scratch): this {
+  public write(address: bigint, scratch: Scratch, force: boolean = false): this {
     const lpBaseAddress = address;
     const lpBuffer = scratch.ptr;
-    const nSize = scratch.byteLength;
+    const nSize = BigInt(scratch.byteLength);
     const numberOfBytesWritten = 0x00n;
 
-    const bWriteProcessMemory = WriteProcessMemory(this.hProcess, lpBaseAddress, lpBuffer, nSize, numberOfBytesWritten);
+    if (!force) {
+      const bWriteProcessMemory = WriteProcessMemory(this.hProcess, lpBaseAddress, lpBuffer, nSize, numberOfBytesWritten);
+
+      if (!bWriteProcessMemory) {
+        throw new Win32Error('WriteProcessMemory', GetLastError());
+      }
+
+      return this;
+    }
+
+    const dwSize = nSize;
+    const flNewProtect = 0x40; /* PAGE_EXECUTE_READWRITE */
+    const lpflOldProtect = Buffer.allocUnsafe(0x04);
+
+    const bVirtualProtectEx = VirtualProtectEx(this.hProcess, lpBaseAddress, dwSize, flNewProtect, lpflOldProtect.ptr);
 
-    if (!bWriteProcessMemory) {
-      throw new Win32Error('WriteProcessMemory', GetLastError());
+    if (!bVirtualProtectEx) {
+      throw new Win32Error('VirtualProtectEx', GetLastError());
+    }
+
+    try {
+      const bWriteProcessMemory = WriteProcessMemory(this.hProcess, lpBaseAddress, lpBuffer, nSize, numberOfBytesWritten);
+
+      if (!bWriteProcessMemory) {
+        throw new Win32Error('WriteProcessMemory', GetLastError());
+      }
+    } finally {
+      const flNewProtect2 = lpflOldProtect.readUInt32LE(0x00);
+      const lpflOldProtect2 = Buffer.allocUnsafe(0x04);
+
+      const bVirtualProtectEx2 = VirtualProtectEx(this.hProcess, lpBaseAddress, dwSize, flNewProtect2, lpflOldProtect2.ptr);
+
+      if (!bVirtualProtectEx2) {
+        throw new Win32Error('VirtualProtectEx', GetLastError());
+      }
     }
 
     return this;
@@ -349,6 +363,7 @@ class Memory {
    * Reads or writes a boolean value.
    * @param address Address to access.
    * @param value Optional value to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The boolean at address, or this instance if writing.
    * @example
    * ```ts
@@ -358,8 +373,8 @@ class Memory {
    * ```
    */
   public bool(address: bigint): boolean;
-  public bool(address: bigint, value: boolean): this;
-  public bool(address: bigint, value?: boolean): boolean | this {
+  public bool(address: bigint, value: boolean, force?: boolean): this;
+  public bool(address: bigint, value?: boolean, force?: boolean): boolean | this {
     const Scratch1 = this.Scratch1;
 
     if (value === undefined) {
@@ -368,7 +383,7 @@ class Memory {
 
     Scratch1[0x00] = value ? 1 : 0;
 
-    this.write(address, Scratch1);
+    void this.write(address, Scratch1, force);
 
     return this;
   }
@@ -377,6 +392,7 @@ class Memory {
    * Reads or writes a Buffer.
    * @param address Address to access.
    * @param lengthOrValue Length to read or Buffer to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Buffer read or this instance if writing.
    * @example
    * ```ts
@@ -386,8 +402,8 @@ class Memory {
    * ```
    */
   public buffer(address: bigint, length: number): Buffer;
-  public buffer(address: bigint, value: Buffer): this;
-  public buffer(address: bigint, lengthOrValue: number | Buffer): Buffer | this {
+  public buffer(address: bigint, value: Buffer, force?: boolean): this;
+  public buffer(address: bigint, lengthOrValue: number | Buffer, force?: boolean): Buffer | this {
     if (typeof lengthOrValue === 'number') {
       const length = lengthOrValue;
       const scratch = Buffer.allocUnsafe(length);
@@ -397,7 +413,7 @@ class Memory {
 
     const value = lengthOrValue;
 
-    this.write(address, value);
+    void this.write(address, value, force);
 
     return this;
   }
@@ -406,6 +422,7 @@ class Memory {
    * Reads or writes a C-style string.
    * @param address Address to access.
    * @param lengthOrValue Length to read or CString to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns CString read or this instance if writing.
    * @example
    * ```ts
@@ -415,8 +432,8 @@ class Memory {
    * ```
    */
   public cString(address: bigint, length: number): CString;
-  public cString(address: bigint, value: CString): this;
-  public cString(address: bigint, lengthOrValue: number | CString): CString | this {
+  public cString(address: bigint, value: CString, force?: boolean): this;
+  public cString(address: bigint, lengthOrValue: number | CString, force?: boolean): CString | this {
     if (typeof lengthOrValue === 'number') {
       const scratch = new Uint8Array(lengthOrValue);
 
@@ -433,7 +450,7 @@ class Memory {
 
     const scratch = Buffer.from(lengthOrValue);
 
-    this.write(address, scratch);
+    void this.write(address, scratch, force);
 
     return this;
   }
@@ -442,6 +459,7 @@ class Memory {
    * Reads or writes a 32-bit float.
    * @param address Address to access.
    * @param value Optional value to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The float at address, or this instance if writing.
    * @example
    * ```ts
@@ -451,8 +469,8 @@ class Memory {
    * ```
    */
   public f32(address: bigint): number;
-  public f32(address: bigint, value: number): this;
-  public f32(address: bigint, value?: number): number | this {
+  public f32(address: bigint, value: number, force?: boolean): this;
+  public f32(address: bigint, value?: number, force?: boolean): number | this {
     const Scratch4Float32Array = this.Scratch4Float32Array; // prettier-ignore
 
     if (value === undefined) {
@@ -461,7 +479,7 @@ class Memory {
 
     Scratch4Float32Array[0x00] = value;
 
-    this.write(address, Scratch4Float32Array);
+    void this.write(address, Scratch4Float32Array, force);
 
     return this;
   }
@@ -470,6 +488,7 @@ class Memory {
    * Reads or writes a Float32Array.
    * @param address Address to access.
    * @param lengthOrValues Length to read or Float32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Float32Array read or this instance if writing.
    * @example
    * ```ts
@@ -479,8 +498,8 @@ class Memory {
    * ```
    */
   public f32Array(address: bigint, length: number): Float32Array;
-  public f32Array(address: bigint, values: Float32Array): this;
-  public f32Array(address: bigint, lengthOrValues: Float32Array | number): Float32Array | this {
+  public f32Array(address: bigint, values: Float32Array, force?: boolean): this;
+  public f32Array(address: bigint, lengthOrValues: Float32Array | number, force?: boolean): Float32Array | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new Float32Array(length);
@@ -492,7 +511,7 @@ class Memory {
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -501,6 +520,7 @@ class Memory {
    * Reads or writes a 64-bit float.
    * @param address Address to access.
    * @param value Optional value to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The float at address, or this instance if writing.
    * @example
    * ```ts
@@ -510,8 +530,8 @@ class Memory {
    * ```
    */
   public f64(address: bigint): number;
-  public f64(address: bigint, value: number): this;
-  public f64(address: bigint, value?: number): number | this {
+  public f64(address: bigint, value: number, force?: boolean): this;
+  public f64(address: bigint, value?: number, force?: boolean): number | this {
     const Scratch8Float64Array = this.Scratch8Float64Array; // prettier-ignore
 
     if (value === undefined) {
@@ -520,7 +540,7 @@ class Memory {
 
     Scratch8Float64Array[0x00] = value;
 
-    this.write(address, Scratch8Float64Array);
+    void this.write(address, Scratch8Float64Array, force);
 
     return this;
   }
@@ -529,6 +549,7 @@ class Memory {
    * Reads or writes a Float64Array.
    * @param address Address to access.
    * @param lengthOrValues Length to read or Float64Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Float64Array read or this instance if writing.
    * @example
    * ```ts
@@ -538,8 +559,8 @@ class Memory {
    * ```
    */
   public f64Array(address: bigint, length: number): Float64Array;
-  public f64Array(address: bigint, values: Float64Array): this;
-  public f64Array(address: bigint, lengthOrValues: Float64Array | number): Float64Array | this {
+  public f64Array(address: bigint, values: Float64Array, force?: boolean): this;
+  public f64Array(address: bigint, lengthOrValues: Float64Array | number, force?: boolean): Float64Array | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new Float64Array(length);
@@ -551,7 +572,7 @@ class Memory {
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -560,6 +581,7 @@ class Memory {
    * Reads or writes a 16-bit integer.
    * @param address Address to access.
    * @param value Optional value to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The int at address, or this instance if writing.
    * @example
    * ```ts
@@ -569,8 +591,8 @@ class Memory {
    * ```
    */
   public i16(address: bigint): number;
-  public i16(address: bigint, value: number): this;
-  public i16(address: bigint, value?: number): number | this {
+  public i16(address: bigint, value: number, force?: boolean): this;
+  public i16(address: bigint, value?: number, force?: boolean): number | this {
     const Scratch2Int16Array = this.Scratch2Int16Array; // prettier-ignore
 
     if (value === undefined) {
@@ -579,7 +601,7 @@ class Memory {
 
     Scratch2Int16Array[0x00] = value;
 
-    this.write(address, Scratch2Int16Array);
+    void this.write(address, Scratch2Int16Array, force);
 
     return this;
   }
@@ -588,6 +610,7 @@ class Memory {
    * Reads or writes an Int16Array.
    * @param address Address to access.
    * @param lengthOrValues Length to read or Int16Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Int16Array read or this instance if writing.
    * @example
    * ```ts
@@ -597,8 +620,8 @@ class Memory {
    * ```
    */
   public i16Array(address: bigint, length: number): Int16Array;
-  public i16Array(address: bigint, values: Int16Array): this;
-  public i16Array(address: bigint, lengthOrValues: Int16Array | number): Int16Array | this {
+  public i16Array(address: bigint, values: Int16Array, force?: boolean): this;
+  public i16Array(address: bigint, lengthOrValues: Int16Array | number, force?: boolean): Int16Array | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new Int16Array(length);
@@ -610,7 +633,7 @@ class Memory {
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -619,6 +642,7 @@ class Memory {
    * Reads or writes a 32-bit integer.
    * @param address Address to access.
    * @param value Optional value to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The int at address, or this instance if writing.
    * @example
    * ```ts
@@ -628,8 +652,8 @@ class Memory {
    * ```
    */
   public i32(address: bigint): number;
-  public i32(address: bigint, value: number): this;
-  public i32(address: bigint, value?: number): number | this {
+  public i32(address: bigint, value: number, force?: boolean): this;
+  public i32(address: bigint, value?: number, force?: boolean): number | this {
     const Scratch4Int32Array = this.Scratch4Int32Array;
 
     if (value === undefined) {
@@ -638,7 +662,7 @@ class Memory {
 
     Scratch4Int32Array[0x00] = value;
 
-    this.write(address, Scratch4Int32Array);
+    void this.write(address, Scratch4Int32Array, force);
 
     return this;
   }
@@ -647,6 +671,7 @@ class Memory {
    * Reads or writes an Int32Array.
    * @param address Address to access.
    * @param lengthOrValues Length to read or Int32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Int32Array read or this instance if writing.
    * @example
    * ```ts
@@ -656,8 +681,8 @@ class Memory {
    * ```
    */
   public i32Array(address: bigint, length: number): Int32Array;
-  public i32Array(address: bigint, values: Int32Array): this;
-  public i32Array(address: bigint, lengthOrValues: Int32Array | number): Int32Array | this {
+  public i32Array(address: bigint, values: Int32Array, force?: boolean): this;
+  public i32Array(address: bigint, lengthOrValues: Int32Array | number, force?: boolean): Int32Array | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new Int32Array(length);
@@ -669,7 +694,7 @@ class Memory {
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -678,6 +703,7 @@ class Memory {
    * Reads or writes a 64-bit integer.
    * @param address Address to access.
    * @param value Optional value to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The bigint at address, or this instance if writing.
    * @example
    * ```ts
@@ -687,8 +713,8 @@ class Memory {
    * ```
    */
   public i64(address: bigint): bigint;
-  public i64(address: bigint, value: bigint): this;
-  public i64(address: bigint, value?: bigint): bigint | this {
+  public i64(address: bigint, value: bigint, force?: boolean): this;
+  public i64(address: bigint, value?: bigint, force?: boolean): bigint | this {
     const Scratch8BigInt64Array = this.Scratch8BigInt64Array;
 
     if (value === undefined) {
@@ -697,7 +723,7 @@ class Memory {
 
     Scratch8BigInt64Array[0x00] = value;
 
-    this.write(address, Scratch8BigInt64Array);
+    void this.write(address, Scratch8BigInt64Array, force);
 
     return this;
   }
@@ -706,6 +732,7 @@ class Memory {
    * Reads or writes a BigInt64Array.
    * @param address Address to access.
    * @param lengthOrValues Length to read or BigInt64Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns BigInt64Array read or this instance if writing.
    * @example
    * ```ts
@@ -715,8 +742,8 @@ class Memory {
    * ```
    */
   public i64Array(address: bigint, length: number): BigInt64Array;
-  public i64Array(address: bigint, values: BigInt64Array): this;
-  public i64Array(address: bigint, lengthOrValues: BigInt64Array | number): BigInt64Array | this {
+  public i64Array(address: bigint, values: BigInt64Array, force?: boolean): this;
+  public i64Array(address: bigint, lengthOrValues: BigInt64Array | number, force?: boolean): BigInt64Array | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new BigInt64Array(length);
@@ -728,7 +755,7 @@ class Memory {
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -737,6 +764,7 @@ class Memory {
    * Reads or writes an 8-bit integer.
    * @param address Address to access.
    * @param value Optional value to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The int at address, or this instance if writing.
    * @example
    * ```ts
@@ -746,8 +774,8 @@ class Memory {
    * ```
    */
   public i8(address: bigint): number;
-  public i8(address: bigint, value: number): this;
-  public i8(address: bigint, value?: number): number | this {
+  public i8(address: bigint, value: number, force?: boolean): this;
+  public i8(address: bigint, value?: number, force?: boolean): number | this {
     const Scratch1Int8Array = this.Scratch1Int8Array;
 
     if (value === undefined) {
@@ -756,7 +784,7 @@ class Memory {
 
     Scratch1Int8Array[0x00] = value;
 
-    this.write(address, Scratch1Int8Array);
+    void this.write(address, Scratch1Int8Array, force);
 
     return this;
   }
@@ -765,6 +793,7 @@ class Memory {
    * Reads or writes an Int8Array.
    * @param address Address to access.
    * @param lengthOrValues Length to read or Int8Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Int8Array read or this instance if writing.
    * @example
    * ```ts
@@ -774,8 +803,8 @@ class Memory {
    * ```
    */
   public i8Array(address: bigint, length: number): Int8Array;
-  public i8Array(address: bigint, values: Int8Array): this;
-  public i8Array(address: bigint, lengthOrValues: Int8Array | number): Int8Array | this {
+  public i8Array(address: bigint, values: Int8Array, force?: boolean): this;
+  public i8Array(address: bigint, lengthOrValues: Int8Array | number, force?: boolean): Int8Array | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new Int8Array(length);
@@ -787,7 +816,7 @@ class Memory {
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -796,6 +825,7 @@ class Memory {
    * Reads or writes a 3x3 matrix (Float32Array of length 9).
    * @param address Address to access.
    * @param values Optional Float32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The matrix at address, or this instance if writing.
    * @example
    * ```ts
@@ -805,8 +835,8 @@ class Memory {
    * ```
    */
   public matrix3x3(address: bigint): Float32Array;
-  public matrix3x3(address: bigint, values: Float32Array): this;
-  public matrix3x3(address: bigint, values?: Float32Array): Float32Array | this {
+  public matrix3x3(address: bigint, values: Float32Array, force?: boolean): this;
+  public matrix3x3(address: bigint, values?: Float32Array, force?: boolean): Float32Array | this {
     if (values === undefined) {
       const scratch = new Float32Array(0x09);
 
@@ -819,7 +849,7 @@ class Memory {
       throw new RangeError('values.length must be 9.');
     }
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -828,6 +858,7 @@ class Memory {
    * Reads or writes a 3x4 matrix (Float32Array of length 12).
    * @param address Address to access.
    * @param values Optional Float32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The matrix at address, or this instance if writing.
    * @example
    * ```ts
@@ -837,8 +868,8 @@ class Memory {
    * ```
    */
   public matrix3x4(address: bigint): Float32Array;
-  public matrix3x4(address: bigint, values: Float32Array): this;
-  public matrix3x4(address: bigint, values?: Float32Array): Float32Array | this {
+  public matrix3x4(address: bigint, values: Float32Array, force?: boolean): this;
+  public matrix3x4(address: bigint, values?: Float32Array, force?: boolean): Float32Array | this {
     if (values === undefined) {
       const scratch = new Float32Array(0x0c);
 
@@ -851,7 +882,7 @@ class Memory {
       throw new RangeError('values.length must be 12.');
     }
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -860,6 +891,7 @@ class Memory {
    * Reads or writes a 4x4 matrix (Float32Array of length 16).
    * @param address Address to access.
    * @param values Optional Float32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The matrix at address, or this instance if writing.
    * @example
    * ```ts
@@ -869,8 +901,8 @@ class Memory {
    * ```
    */
   public matrix4x4(address: bigint): Float32Array;
-  public matrix4x4(address: bigint, values: Float32Array): this;
-  public matrix4x4(address: bigint, values?: Float32Array): Float32Array | this {
+  public matrix4x4(address: bigint, values: Float32Array, force?: boolean): this;
+  public matrix4x4(address: bigint, values?: Float32Array, force?: boolean): Float32Array | this {
     if (values === undefined) {
       const scratch = new Float32Array(0x10);
 
@@ -883,7 +915,7 @@ class Memory {
       throw new RangeError('values.length must be 16.');
     }
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -892,6 +924,7 @@ class Memory {
    * Reads or writes a NetworkUtlVector (Uint32Array).
    * @param address Address to access.
    * @param values Optional Uint32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The vector at address, or this instance if writing.
    * @example
    * ```ts
@@ -901,8 +934,8 @@ class Memory {
    * ```
    */
   public networkUtlVector(address: bigint): NetworkUtlVector;
-  public networkUtlVector(address: bigint, values: NetworkUtlVector): this;
-  public networkUtlVector(address: bigint, values?: NetworkUtlVector): NetworkUtlVector | this {
+  public networkUtlVector(address: bigint, values: NetworkUtlVector, force?: boolean): this;
+  public networkUtlVector(address: bigint, values?: NetworkUtlVector, force?: boolean): NetworkUtlVector | this {
     const elementsPtr = this.u64(address + 0x08n);
 
     if (values === undefined) {
@@ -915,9 +948,9 @@ class Memory {
       return scratch;
     }
 
-    this.u32(address, values.length);
+    this.u32(address, values.length, force);
 
-    this.write(elementsPtr, values);
+    void this.write(elementsPtr, values, force);
 
     return this;
   }
@@ -926,6 +959,7 @@ class Memory {
    * Reads or writes a Point (object with x, y).
    * @param address Address to access.
    * @param value Optional Point to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The point at address, or this instance if writing.
    * @example
    * ```ts
@@ -935,8 +969,8 @@ class Memory {
    * ```
    */
   public point(address: bigint): Point;
-  public point(address: bigint, value: Point): this;
-  public point(address: bigint, value?: Point): Point | this {
+  public point(address: bigint, value: Point, force?: boolean): this;
+  public point(address: bigint, value?: Point, force?: boolean): Point | this {
     const Scratch8Float32Array = this.Scratch8Float32Array;
 
     if (value === undefined) {
@@ -951,7 +985,7 @@ class Memory {
     Scratch8Float32Array[0x00] = value.x;
     Scratch8Float32Array[0x01] = value.y;
 
-    this.write(address, Scratch8Float32Array);
+    void this.write(address, Scratch8Float32Array, force);
 
     return this;
   }
@@ -960,6 +994,7 @@ class Memory {
    * Reads or writes an array of Points.
    * @param address Address to access.
    * @param lengthOrValues Length to read or array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Array of points read or this instance if writing.
    * @example
    * ```ts
@@ -969,8 +1004,8 @@ class Memory {
    * ```
    */
   public pointArray(address: bigint, length: number): Point[];
-  public pointArray(address: bigint, value: Point[]): this;
-  public pointArray(address: bigint, lengthOrValues: number | Point[]): Point[] | this {
+  public pointArray(address: bigint, value: Point[], force?: boolean): this;
+  public pointArray(address: bigint, lengthOrValues: number | Point[], force?: boolean): Point[] | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new Float32Array(length * 2);
@@ -999,14 +1034,27 @@ class Memory {
       scratch[j + 0x01] = vector2.y;
     }
 
-    this.write(address, scratch);
+    void this.write(address, scratch, force);
 
     return this;
   }
 
+  /**
+   * Reads or writes a raw Point (two Float32 values) as a Float32Array.
+   * @param address Address to access.
+   * @param values Optional Float32Array of length 2 to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
+   * @returns Float32Array read or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myPoint = cs2.pointRaw(0x12345678n);
+   * cs2.pointRaw(0x12345678n, new Float32Array([1, 2]));
+   * ```
+   */
   public pointRaw(address: bigint): Float32Array;
-  public pointRaw(address: bigint, values: Float32Array): this;
-  public pointRaw(address: bigint, values?: Float32Array): Float32Array | this {
+  public pointRaw(address: bigint, values: Float32Array, force?: boolean): this;
+  public pointRaw(address: bigint, values?: Float32Array, force?: boolean): Float32Array | this {
     if (values === undefined) {
       return this.f32Array(address, 0x02);
     }
@@ -1015,7 +1063,7 @@ class Memory {
       throw new RangeError('values.length must be 2.');
     }
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -1033,8 +1081,8 @@ class Memory {
    * ```
    */
   public qAngle(address: bigint): QAngle;
-  public qAngle(address: bigint, value: QAngle): this;
-  public qAngle(address: bigint, value?: QAngle): QAngle | this {
+  public qAngle(address: bigint, value: QAngle, force?: boolean): this;
+  public qAngle(address: bigint, value?: QAngle, force?: boolean): QAngle | this {
     const Scratch12Float32Array = this.Scratch12Float32Array;
 
     if (value === undefined) {
@@ -1051,7 +1099,7 @@ class Memory {
     Scratch12Float32Array[0x02] = value.roll;
     Scratch12Float32Array[0x01] = value.yaw;
 
-    this.write(address, Scratch12Float32Array);
+    void this.write(address, Scratch12Float32Array, force);
 
     return this;
   }
@@ -1069,8 +1117,8 @@ class Memory {
    * ```
    */
   public qAngleArray(address: bigint, length: number): QAngle[];
-  public qAngleArray(address: bigint, values: QAngle[]): this;
-  public qAngleArray(address: bigint, lengthOrValues: QAngle[] | number): QAngle[] | this {
+  public qAngleArray(address: bigint, values: QAngle[], force?: boolean): this;
+  public qAngleArray(address: bigint, lengthOrValues: QAngle[] | number, force?: boolean): QAngle[] | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new Float32Array(length * 0x03);
@@ -1101,7 +1149,7 @@ class Memory {
       scratch[j + 0x01] = qAngle.yaw;
     }
 
-    this.write(address, scratch);
+    void this.write(address, scratch, force);
 
     return this;
   }
@@ -1110,6 +1158,7 @@ class Memory {
    * Reads or writes a raw QAngle as a Float32Array.
    * @param address Address to access.
    * @param values Optional Float32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Float32Array read or this instance if writing.
    * @example
    * ```ts
@@ -1119,8 +1168,8 @@ class Memory {
    * ```
    */
   public qAngleRaw(address: bigint): Float32Array;
-  public qAngleRaw(address: bigint, values: Float32Array): this;
-  public qAngleRaw(address: bigint, values?: Float32Array): Float32Array | this {
+  public qAngleRaw(address: bigint, values: Float32Array, force?: boolean): this;
+  public qAngleRaw(address: bigint, values?: Float32Array, force?: boolean): Float32Array | this {
     if (values === undefined) {
       return this.f32Array(address, 0x03);
     }
@@ -1129,7 +1178,7 @@ class Memory {
       throw new RangeError('values.length must be 3.');
     }
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -1138,6 +1187,7 @@ class Memory {
    * Reads or writes a Quaternion (object with w, x, y, z).
    * @param address Address to access.
    * @param value Optional Quaternion to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The Quaternion at address, or this instance if writing.
    * @example
    * ```ts
@@ -1147,8 +1197,8 @@ class Memory {
    * ```
    */
   public quaternion(address: bigint): Quaternion;
-  public quaternion(address: bigint, value: Quaternion): this;
-  public quaternion(address: bigint, value?: Quaternion): Quaternion | this {
+  public quaternion(address: bigint, value: Quaternion, force?: boolean): this;
+  public quaternion(address: bigint, value?: Quaternion, force?: boolean): Quaternion | this {
     const Scratch16Float32Array = this.Scratch16Float32Array;
 
     if (value === undefined) {
@@ -1167,7 +1217,7 @@ class Memory {
     Scratch16Float32Array[0x01] = value.y;
     Scratch16Float32Array[0x02] = value.z;
 
-    this.write(address, Scratch16Float32Array);
+    void this.write(address, Scratch16Float32Array, force);
 
     return this;
   }
@@ -1176,6 +1226,7 @@ class Memory {
    * Reads or writes an array of Quaternions.
    * @param address Address to access.
    * @param lengthOrValues Length to read or array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Array of Quaternions read or this instance if writing.
    * @example
    * ```ts
@@ -1185,8 +1236,8 @@ class Memory {
    * ```
    */
   public quaternionArray(address: bigint, length: number): Quaternion[];
-  public quaternionArray(address: bigint, values: Quaternion[]): this;
-  public quaternionArray(address: bigint, lengthOrValues: Quaternion[] | number): Quaternion[] | this {
+  public quaternionArray(address: bigint, values: Quaternion[], force?: boolean): this;
+  public quaternionArray(address: bigint, lengthOrValues: Quaternion[] | number, force?: boolean): Quaternion[] | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new Float32Array(length * 0x04); // 4 * f32 per Quaternion
@@ -1219,7 +1270,7 @@ class Memory {
       scratch[j + 0x02] = quaternion.z;
     }
 
-    this.write(address, scratch);
+    void this.write(address, scratch, force);
 
     return this;
   }
@@ -1228,6 +1279,7 @@ class Memory {
    * Reads or writes a raw Quaternion as a Float32Array.
    * @param address Address to access.
    * @param values Optional Float32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Float32Array read or this instance if writing.
    * @example
    * ```ts
@@ -1237,8 +1289,8 @@ class Memory {
    * ```
    */
   public quaternionRaw(address: bigint): Float32Array;
-  public quaternionRaw(address: bigint, values: Float32Array): this;
-  public quaternionRaw(address: bigint, values?: Float32Array): Float32Array | this {
+  public quaternionRaw(address: bigint, values: Float32Array, force?: boolean): this;
+  public quaternionRaw(address: bigint, values?: Float32Array, force?: boolean): Float32Array | this {
     if (values === undefined) {
       return this.f32Array(address, 0x04);
     }
@@ -1247,7 +1299,7 @@ class Memory {
       throw new RangeError('values.length must be 4.');
     }
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -1256,6 +1308,7 @@ class Memory {
    * Reads or writes an RGB color (object with r, g, b).
    * @param address Address to access.
    * @param value Optional RGB to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The RGB at address, or this instance if writing.
    * @example
    * ```ts
@@ -1265,8 +1318,8 @@ class Memory {
    * ```
    */
   public rgb(address: bigint): RGB;
-  public rgb(address: bigint, value: RGB): this;
-  public rgb(address: bigint, value?: RGB): RGB | this {
+  public rgb(address: bigint, value: RGB, force?: boolean): this;
+  public rgb(address: bigint, value?: RGB, force?: boolean): RGB | this {
     const Scratch3 = this.Scratch3;
 
     if (value === undefined) {
@@ -1283,13 +1336,16 @@ class Memory {
     Scratch3[0x01] = value.g;
     Scratch3[0x02] = value.b;
 
-    return this.write(address, Scratch3);
+    void this.write(address, Scratch3, force);
+
+    return this;
   }
 
   /**
    * Reads or writes a raw RGB value as a Uint8Array.
    * @param address Address to access.
    * @param values Optional buffer to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Uint8Array read or this instance if writing.
    * @example
    * ```ts
@@ -1299,8 +1355,9 @@ class Memory {
    * ```
    */
   public rgbRaw(address: bigint): Uint8Array;
-  public rgbRaw(address: bigint, values: Buffer | Uint8Array | Uint8ClampedArray): this;
-  public rgbRaw(address: bigint, values?: Buffer | Uint8Array | Uint8ClampedArray): Uint8Array | this {
+  public rgbRaw(address: bigint): Uint8Array;
+  public rgbRaw(address: bigint, values: Buffer | Uint8Array | Uint8ClampedArray, force?: boolean): this;
+  public rgbRaw(address: bigint, values?: Buffer | Uint8Array | Uint8ClampedArray, force?: boolean): Uint8Array | this {
     if (values === undefined) {
       return this.u8Array(address, 0x03);
     }
@@ -1309,7 +1366,7 @@ class Memory {
       throw new RangeError('values.length must be 3.');
     }
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -1318,6 +1375,7 @@ class Memory {
    * Reads or writes an RGBA color (object with r, g, b, a).
    * @param address Address to access.
    * @param value Optional RGBA to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The RGBA at address, or this instance if writing.
    * @example
    * ```ts
@@ -1327,8 +1385,8 @@ class Memory {
    * ```
    */
   public rgba(address: bigint): RGBA;
-  public rgba(address: bigint, value: RGBA): this;
-  public rgba(address: bigint, value?: RGBA): RGBA | this {
+  public rgba(address: bigint, value: RGBA, force?: boolean): this;
+  public rgba(address: bigint, value?: RGBA, force?: boolean): RGBA | this {
     const Scratch4 = this.Scratch4;
 
     if (value === undefined) {
@@ -1347,13 +1405,16 @@ class Memory {
     Scratch4[0x02] = value.b;
     Scratch4[0x03] = value.a;
 
-    return this.write(address, Scratch4);
+    void this.write(address, Scratch4, force);
+
+    return this;
   }
 
   /**
    * Reads or writes a raw RGBA value as a Uint8Array.
    * @param address Address to access.
    * @param values Optional buffer to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Uint8Array read or this instance if writing.
    * @example
    * ```ts
@@ -1363,8 +1424,9 @@ class Memory {
    * ```
    */
   public rgbaRaw(address: bigint): Uint8Array;
-  public rgbaRaw(address: bigint, values: Buffer | Uint8Array | Uint8ClampedArray): this;
-  public rgbaRaw(address: bigint, values?: Buffer | Uint8Array | Uint8ClampedArray): Uint8Array | this {
+  public rgbaRaw(address: bigint): Uint8Array;
+  public rgbaRaw(address: bigint, values: Buffer | Uint8Array | Uint8ClampedArray, force?: boolean): this;
+  public rgbaRaw(address: bigint, values?: Buffer | Uint8Array | Uint8ClampedArray, force?: boolean): Uint8Array | this {
     if (values === undefined) {
       return this.u8Array(address, 0x04);
     }
@@ -1373,7 +1435,7 @@ class Memory {
       throw new RangeError('values.length must be 4.');
     }
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -1382,8 +1444,10 @@ class Memory {
    * Reads or writes a UTF-8 string.
    * @param address Address to access.
    * @param lengthOrValue Length to read or string to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The string at address, or this instance if writing.
    * @notice When writing, remember to null-terminate your string (e.g., 'hello\0').
+   * @todo Compare performance when using CString vs TextDecoder when reading…
    * @example
    * ```ts
    * const cs2 = new Memory('cs2.exe');
@@ -1392,8 +1456,9 @@ class Memory {
    * ```
    */
   public string(address: bigint, length: number): string;
-  public string(address: bigint, value: string): this;
-  public string(address: bigint, lengthOrValue: number | string): string | this {
+  public string(address: bigint, length: number): string;
+  public string(address: bigint, value: string, force?: boolean): this;
+  public string(address: bigint, lengthOrValue: number | string, force?: boolean): string | this {
     if (typeof lengthOrValue === 'number') {
       const scratch = new Uint8Array(lengthOrValue);
 
@@ -1410,7 +1475,7 @@ class Memory {
 
     const scratch = Memory.TextEncoderUTF8.encode(lengthOrValue);
 
-    this.write(address, scratch);
+    void this.write(address, scratch, force);
 
     return this;
   }
@@ -1419,6 +1484,7 @@ class Memory {
    * Reads or writes a 16-bit unsigned integer.
    * @param address Address to access.
    * @param value Optional value to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The value at address, or this instance if writing.
    * @example
    * ```ts
@@ -1428,8 +1494,8 @@ class Memory {
    * ```
    */
   public u16(address: bigint): number;
-  public u16(address: bigint, value: number): this;
-  public u16(address: bigint, value?: number): number | this {
+  public u16(address: bigint, value: number, force?: boolean): this;
+  public u16(address: bigint, value?: number, force?: boolean): number | this {
     const Scratch2Uint16Array = this.Scratch2Uint16Array;
 
     if (value === undefined) {
@@ -1438,7 +1504,7 @@ class Memory {
 
     Scratch2Uint16Array[0x00] = value;
 
-    this.write(address, Scratch2Uint16Array);
+    void this.write(address, Scratch2Uint16Array, force);
 
     return this;
   }
@@ -1447,6 +1513,7 @@ class Memory {
    * Reads or writes a Uint16Array.
    * @param address Address to access.
    * @param lengthOrValues Length to read or Uint16Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Uint16Array read or this instance if writing.
    * @example
    * ```ts
@@ -1456,8 +1523,8 @@ class Memory {
    * ```
    */
   public u16Array(address: bigint, length: number): Uint16Array;
-  public u16Array(address: bigint, values: Uint16Array): this;
-  public u16Array(address: bigint, lengthOrValues: Uint16Array | number): Uint16Array | this {
+  public u16Array(address: bigint, values: Uint16Array, force?: boolean): this;
+  public u16Array(address: bigint, lengthOrValues: Uint16Array | number, force?: boolean): Uint16Array | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new Uint16Array(length);
@@ -1469,7 +1536,7 @@ class Memory {
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -1478,6 +1545,7 @@ class Memory {
    * Reads or writes a 32-bit unsigned integer.
    * @param address Address to access.
    * @param value Optional value to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The value at address, or this instance if writing.
    * @example
    * ```ts
@@ -1487,8 +1555,8 @@ class Memory {
    * ```
    */
   public u32(address: bigint): number;
-  public u32(address: bigint, value: number): this;
-  public u32(address: bigint, value?: number): number | this {
+  public u32(address: bigint, value: number, force?: boolean): this;
+  public u32(address: bigint, value?: number, force?: boolean): number | this {
     const Scratch4Uint32Array = this.Scratch4Uint32Array;
 
     if (value === undefined) {
@@ -1497,7 +1565,7 @@ class Memory {
 
     Scratch4Uint32Array[0x00] = value;
 
-    this.write(address, Scratch4Uint32Array);
+    void this.write(address, Scratch4Uint32Array, force);
 
     return this;
   }
@@ -1506,6 +1574,7 @@ class Memory {
    * Reads or writes a Uint32Array.
    * @param address Address to access.
    * @param lengthOrValues Length to read or Uint32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Uint32Array read or this instance if writing.
    * @example
    * ```ts
@@ -1515,8 +1584,8 @@ class Memory {
    * ```
    */
   public u32Array(address: bigint, length: number): Uint32Array;
-  public u32Array(address: bigint, values: Uint32Array): this;
-  public u32Array(address: bigint, lengthOrValues: Uint32Array | number): Uint32Array | this {
+  public u32Array(address: bigint, values: Uint32Array, force?: boolean): this;
+  public u32Array(address: bigint, lengthOrValues: Uint32Array | number, force?: boolean): Uint32Array | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new Uint32Array(length);
@@ -1528,7 +1597,7 @@ class Memory {
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -1537,6 +1606,7 @@ class Memory {
    * Reads or writes a 64-bit unsigned integer.
    * @param address Address to access.
    * @param value Optional value to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The bigint at address, or this instance if writing.
    * @example
    * ```ts
@@ -1546,8 +1616,8 @@ class Memory {
    * ```
    */
   public u64(address: bigint): bigint;
-  public u64(address: bigint, value: bigint): this;
-  public u64(address: bigint, value?: bigint): bigint | this {
+  public u64(address: bigint, value: bigint, force?: boolean): this;
+  public u64(address: bigint, value?: bigint, force?: boolean): bigint | this {
     const Scratch8BigUint64Array = this.Scratch8BigUint64Array;
 
     if (value === undefined) {
@@ -1556,7 +1626,7 @@ class Memory {
 
     Scratch8BigUint64Array[0x00] = value;
 
-    this.write(address, Scratch8BigUint64Array);
+    void this.write(address, Scratch8BigUint64Array, force);
 
     return this;
   }
@@ -1565,6 +1635,7 @@ class Memory {
    * Reads or writes a BigUint64Array.
    * @param address Address to access.
    * @param lengthOrValues Length to read or BigUint64Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns BigUint64Array read or this instance if writing.
    * @example
    * ```ts
@@ -1574,8 +1645,8 @@ class Memory {
    * ```
    */
   public u64Array(address: bigint, length: number): BigUint64Array;
-  public u64Array(address: bigint, values: BigUint64Array): this;
-  public u64Array(address: bigint, lengthOrValues: BigUint64Array | number): BigUint64Array | this {
+  public u64Array(address: bigint, values: BigUint64Array, force?: boolean): this;
+  public u64Array(address: bigint, lengthOrValues: BigUint64Array | number, force?: boolean): BigUint64Array | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new BigUint64Array(length);
@@ -1587,7 +1658,7 @@ class Memory {
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -1596,6 +1667,7 @@ class Memory {
    * Reads or writes an 8-bit unsigned integer.
    * @param address Address to access.
    * @param value Optional value to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The value at address, or this instance if writing.
    * @example
    * ```ts
@@ -1605,8 +1677,8 @@ class Memory {
    * ```
    */
   public u8(address: bigint): number;
-  public u8(address: bigint, value: number): this;
-  public u8(address: bigint, value?: number): number | this {
+  public u8(address: bigint, value: number, force?: boolean): this;
+  public u8(address: bigint, value?: number, force?: boolean): number | this {
     const Scratch1 = this.Scratch1;
 
     if (value === undefined) {
@@ -1615,7 +1687,7 @@ class Memory {
 
     Scratch1[0x00] = value;
 
-    this.write(address, Scratch1);
+    void this.write(address, Scratch1, force);
 
     return this;
   }
@@ -1624,6 +1696,7 @@ class Memory {
    * Reads or writes a Uint8Array.
    * @param address Address to access.
    * @param lengthOrValues Length to read or Uint8Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Uint8Array read or this instance if writing.
    * @example
    * ```ts
@@ -1633,8 +1706,8 @@ class Memory {
    * ```
    */
   public u8Array(address: bigint, length: number): Uint8Array;
-  public u8Array(address: bigint, values: Uint8Array): this;
-  public u8Array(address: bigint, lengthOrValues: Uint8Array | number): Uint8Array | this {
+  public u8Array(address: bigint, values: Uint8Array, force?: boolean): this;
+  public u8Array(address: bigint, lengthOrValues: Uint8Array | number, force?: boolean): Uint8Array | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new Uint8Array(length);
@@ -1646,7 +1719,7 @@ class Memory {
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -1655,6 +1728,7 @@ class Memory {
    * Reads or writes a pointer-sized unsigned integer.
    * @param address Address to access.
    * @param value Optional value to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The value at address, or this instance if writing.
    * @example
    * ```ts
@@ -1664,20 +1738,21 @@ class Memory {
    * ```
    */
   public uPtr(address: bigint): UPtr;
-  public uPtr(address: bigint, value: UPtr): this;
-  public uPtr(address: bigint, value?: UPtr): UPtr | this {
+  public uPtr(address: bigint, value: UPtr, force?: boolean): this;
+  public uPtr(address: bigint, value?: UPtr, force?: boolean): UPtr | this {
     // TypeScript is funny sometimes, isn't it?… 🫠…
     if (value === undefined) {
       return this.u64(address);
     }
 
-    return this.u64(address, value);
+    return this.u64(address, value, force);
   }
 
   /**
    * Reads or writes an array of pointer-sized unsigned integers.
    * @param address Address to access.
    * @param lengthOrValues Length to read or array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Array read or this instance if writing.
    * @example
    * ```ts
@@ -1687,20 +1762,21 @@ class Memory {
    * ```
    */
   public uPtrArray(address: bigint, length: number): UPtrArray;
-  public uPtrArray(address: bigint, values: UPtrArray): this;
-  public uPtrArray(address: bigint, lengthOrValues: UPtrArray | number): UPtrArray | this {
+  public uPtrArray(address: bigint, values: UPtrArray, force?: boolean): this;
+  public uPtrArray(address: bigint, lengthOrValues: UPtrArray | number, force?: boolean): UPtrArray | this {
     // TypeScript is funny sometimes, isn't it?… 🫠…
     if (typeof lengthOrValues === 'number') {
       return this.u64Array(address, lengthOrValues);
     }
 
-    return this.u64Array(address, lengthOrValues);
+    return this.u64Array(address, lengthOrValues, force);
   }
 
   /**
    * Reads or writes a Vector2 (object with x, y).
    * @param address Address to access.
    * @param value Optional Vector2 to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The Vector2 at address, or this instance if writing.
    * @example
    * ```ts
@@ -1710,42 +1786,56 @@ class Memory {
    * ```
    */
   public vector2(address: bigint): Vector2;
-  public vector2(address: bigint, value: Vector2): this;
-  public vector2(address: bigint, value?: Vector2): Vector2 | this {
+  public vector2(address: bigint, value: Vector2, force?: boolean): this;
+  public vector2(address: bigint, value?: Vector2, force?: boolean): Vector2 | this {
     // TypeScript is funny sometimes, isn't it?… 🫠…
     if (value === undefined) {
       return this.point(address);
     }
 
-    return this.point(address, value);
+    return this.point(address, value, force);
   }
 
   /**
    * Reads or writes an array of Vector2.
    * @param address Address to access.
    * @param lengthOrValues Length to read or array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Array of Vector2 read or this instance if writing.
    * @example
    * ```ts
    * const cs2 = new Memory('cs2.exe');
-   * const myVectors = cs2.vector2Array(0x12345678n, 2);
+   * const myVector2s = 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 {
+  public vector2Array(address: bigint, values: Vector2[], force?: boolean): this;
+  public vector2Array(address: bigint, lengthOrValues: Vector2[] | number, force?: boolean): Vector2[] | this {
     // TypeScript is funny sometimes, isn't it?… 🫠…
     if (typeof lengthOrValues === 'number') {
       return this.pointArray(address, lengthOrValues);
     }
 
-    return this.pointArray(address, lengthOrValues);
+    return this.pointArray(address, lengthOrValues, force);
   }
 
+  /**
+   * Reads or writes a raw Vector2 as a Float32Array.
+   * @param address Address to access.
+   * @param values Optional Float32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
+   * @returns Float32Array read or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myVector2 = cs2.vector2Raw(0x12345678n);
+   * cs2.vector2Raw(0x12345678n, new Float32Array([1, 2]));
+   * ```
+   */
   public vector2Raw(address: bigint): Float32Array;
-  public vector2Raw(address: bigint, values: Float32Array): this;
-  public vector2Raw(address: bigint, values?: Float32Array): Float32Array | this {
+  public vector2Raw(address: bigint, values: Float32Array, force?: boolean): this;
+  public vector2Raw(address: bigint, values?: Float32Array, force?: boolean): Float32Array | this {
     if (values === undefined) {
       return this.f32Array(address, 0x02);
     }
@@ -1754,7 +1844,7 @@ class Memory {
       throw new RangeError('values.length must be 2.');
     }
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -1763,6 +1853,7 @@ class Memory {
    * Reads or writes a Vector3 (object with x, y, z).
    * @param address Address to access.
    * @param value Optional Vector3 to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The Vector3 at address, or this instance if writing.
    * @example
    * ```ts
@@ -1772,8 +1863,8 @@ class Memory {
    * ```
    */
   public vector3(address: bigint): Vector3;
-  public vector3(address: bigint, value: Vector3): this;
-  public vector3(address: bigint, value?: Vector3): Vector3 | this {
+  public vector3(address: bigint, value: Vector3, force?: boolean): this;
+  public vector3(address: bigint, value?: Vector3, force?: boolean): Vector3 | this {
     const Scratch12Float32Array = this.Scratch12Float32Array;
 
     if (value === undefined) {
@@ -1790,7 +1881,7 @@ class Memory {
     Scratch12Float32Array[0x01] = value.y;
     Scratch12Float32Array[0x02] = value.z;
 
-    this.write(address, Scratch12Float32Array);
+    void this.write(address, Scratch12Float32Array, force);
 
     return this;
   }
@@ -1799,17 +1890,18 @@ class Memory {
    * Reads or writes an array of Vector3.
    * @param address Address to access.
    * @param lengthOrValues Length to read or array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Array of Vector3 read or this instance if writing.
    * @example
    * ```ts
    * const cs2 = new Memory('cs2.exe');
-   * const myVectors = cs2.vector3Array(0x12345678n, 2);
+   * const myVector3s = cs2.vector3Array(0x12345678n, 2);
    * cs2.vector3Array(0x12345678n, [{ x: 1, y: 2, z: 3 }]);
    * ```
    */
   public vector3Array(address: bigint, length: number): Vector3[];
-  public vector3Array(address: bigint, values: Vector3[]): this;
-  public vector3Array(address: bigint, lengthOrValues: Vector3[] | number): Vector3[] | this {
+  public vector3Array(address: bigint, values: Vector3[], force?: boolean): this;
+  public vector3Array(address: bigint, lengthOrValues: Vector3[] | number, force?: boolean): Vector3[] | this {
     if (typeof lengthOrValues === 'number') {
       const length = lengthOrValues;
       const scratch = new Float32Array(length * 0x03);
@@ -1840,14 +1932,27 @@ class Memory {
       scratch[j + 0x02] = vector3.z;
     }
 
-    this.write(address, scratch);
+    void this.write(address, scratch, force);
 
     return this;
   }
 
+  /**
+   * Reads or writes a raw Vector3 as a Float32Array.
+   * @param address Address to access.
+   * @param values Optional Float32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
+   * @returns Float32Array read or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myVector3 = cs2.vector3Raw(0x12345678n);
+   * cs2.vector3Raw(0x12345678n, new Float32Array([1, 2, 3]));
+   * ```
+   */
   public vector3Raw(address: bigint): Float32Array;
-  public vector3Raw(address: bigint, values: Float32Array): this;
-  public vector3Raw(address: bigint, values?: Float32Array): Float32Array | this {
+  public vector3Raw(address: bigint, values: Float32Array, force?: boolean): this;
+  public vector3Raw(address: bigint, values?: Float32Array, force?: boolean): Float32Array | this {
     if (values === undefined) {
       return this.f32Array(address, 0x03);
     }
@@ -1856,7 +1961,7 @@ class Memory {
       throw new RangeError('values.length must be 3.');
     }
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }
@@ -1865,6 +1970,7 @@ class Memory {
    * Reads or writes a Vector4 (object with w, x, y, z).
    * @param address Address to access.
    * @param value Optional Vector4 to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns The Vector4 at address, or this instance if writing.
    * @example
    * ```ts
@@ -1874,42 +1980,57 @@ class Memory {
    * ```
    */
   public vector4(address: bigint): Vector4;
-  public vector4(address: bigint, value: Vector4): this;
-  public vector4(address: bigint, value?: Vector4): Vector4 | this {
+  public vector4(address: bigint, value: Vector4, force?: boolean): this;
+  public vector4(address: bigint, value?: Vector4, force?: boolean): Vector4 | this {
     // TypeScript is funny sometimes, isn't it?… 🫠…
     if (value === undefined) {
       return this.quaternion(address);
     }
 
-    return this.quaternion(address, value);
+    return this.quaternion(address, value, force);
   }
 
   /**
    * Reads or writes an array of Vector4.
    * @param address Address to access.
    * @param lengthOrValues Length to read or array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
    * @returns Array of Vector4 read or this instance if writing.
    * @example
    * ```ts
    * const cs2 = new Memory('cs2.exe');
-   * const myVectors = cs2.vector4Array(0x12345678n, 2);
+   * const myVector4s = cs2.vector4Array(0x12345678n, 2);
    * cs2.vector4Array(0x12345678n, [{ w: 1, x: 0, y: 0, z: 0 }]);
    * ```
    */
   public vector4Array(address: bigint, length: number): Vector4[];
-  public vector4Array(address: bigint, values: Vector4[]): this;
-  public vector4Array(address: bigint, lengthOrValues: Vector4[] | number): Vector4[] | this {
+  public vector4Array(address: bigint, values: Vector4[], force?: boolean): this;
+  public vector4Array(address: bigint, lengthOrValues: Vector4[] | number, force?: boolean): Vector4[] | this {
     // TypeScript is funny sometimes, isn't it?… 🫠…
     if (typeof lengthOrValues === 'number') {
       return this.quaternionArray(address, lengthOrValues);
     }
 
-    return this.quaternionArray(address, lengthOrValues);
+    return this.quaternionArray(address, lengthOrValues, force);
   }
 
   public vector4Raw(address: bigint): Float32Array;
-  public vector4Raw(address: bigint, values: Float32Array): this;
-  public vector4Raw(address: bigint, values?: Float32Array): Float32Array | this {
+  /**
+   * Reads or writes a raw Vector4 as a Float32Array.
+   * @param address Address to access.
+   * @param values Optional Float32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
+   * @returns Float32Array read or this instance if writing.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myVector4 = cs2.vector4Raw(0x12345678n);
+   * cs2.vector4Raw(0x12345678n, new Float32Array([1, 0, 0, 0]));
+   * ```
+   */
+  public vector4Raw(address: bigint): Float32Array;
+  public vector4Raw(address: bigint, values: Float32Array, force?: boolean): this;
+  public vector4Raw(address: bigint, values?: Float32Array, force?: boolean): Float32Array | this {
     if (values === undefined) {
       return this.f32Array(address, 0x04);
     }
@@ -1918,7 +2039,7 @@ class Memory {
       throw new RangeError('values.length must be 4.');
     }
 
-    this.write(address, values);
+    void this.write(address, values, force);
 
     return this;
   }