bun-memory 1.1.35 → 1.1.37

package/example/benchmark.ts

@@ -10,6 +10,8 @@ import Memory from 'bun-memory';
 import ClientDLLJSON from './offsets/client_dll.json';
 import OffsetsJSON from './offsets/offsets.json';
 
+const Iterations = 1e6;
+
 // Load the needed offsets as bigints… It's ugly but… IntelliSense! 🫠…
 const Client = {
   ...Object.fromEntries(Object.entries(ClientDLLJSON['client.dll'].classes).map(([class_, { fields }]) => [class_, Object.fromEntries(Object.entries(fields).map(([field, value]) => [field, BigInt(value)]))])),
@@ -32,11 +34,12 @@ if (ClientPtr === undefined) {
 // Warmup…
 console.log('Warming up…');
 
-for (let i = 0; i < 1e6; i++) {
+for (let i = 0; i < Iterations; i++) {
   const GlobalVarsPtr = cs2.u64(ClientPtr + Client.Other.dwGlobalVars);
   /* */ const CurTime = cs2.f32(GlobalVarsPtr + 0x30n);
 
   const lPlayerControllerPtr = cs2.u64(ClientPtr + Client.Other.dwLocalPlayerController);
+  /* */ const lPlayerName = cs2.string(lPlayerControllerPtr + Client.CBasePlayerController.m_iszPlayerName, 32);
 
   const lPlayerPawnPtr = cs2.u64(ClientPtr + Client.Other.dwLocalPlayerPawn);
   /* */ const lHealth = cs2.u32(lPlayerPawnPtr + Client.C_BaseEntity.m_iHealth);
@@ -52,75 +55,92 @@ const EntityListScratch = new BigUint64Array(0x200 / 0x08);
 const EntityClassInfoNames = new Map<bigint, string>();
 
 // Start the test…
-console.log('Starting the test…');
+for (let i = 0; i < 10; i++) {
+  console.log('Starting the test…');
 
-const performance1 = performance.now();
+  const start = performance.now();
 
-const EntityListPtr = cs2.u64(ClientPtr + Client.Other.dwEntityList);
+  const EntityListPtr = cs2.u64(ClientPtr + Client.Other.dwEntityList);
 
-for (let i = 0; i < 1e6; i++) {
-  try {
-    // Traverse the entity list and store it in `BaseEntityPtrs`…
-    cs2.read(EntityListPtr + 0x10n, EntityListScratch);
+  for (let j = 0; j < Iterations; j++) {
+    try {
+      // Traverse the entity list and store it in `BaseEntityPtrs`…
+      void cs2.read(EntityListPtr + 0x10n, EntityListScratch);
 
-    // Traverse each of the potential 64 entity chunks…
-    for (let i = 0; i < 0x40; i++) {
-      const EntityChunkPtr = EntityListScratch[i];
+      // Traverse each of the potential 64 entity chunks…
+      for (let k = 0; k < 0x40; k++) {
+        const EntityChunkPtr = EntityListScratch[k];
 
-      if (EntityChunkPtr === 0n) {
-        continue;
-      }
+        if (EntityChunkPtr === 0n) {
+          continue;
+        }
 
-      cs2.read(EntityChunkPtr, EntityChunkScratch);
+        void cs2.read(EntityChunkPtr, EntityChunkScratch);
 
-      // Traverse each of the potential 512 entities within this chunk…
-      // for (let j = 0, l = 0; j < 0x200; j++, l += 0x0f) {
-      for (let l = 0; l < 0x1e00; l += 0x0f) {
-        const BaseEntityPtr = EntityChunkScratch[l];
+        // Traverse each of the potential 512 entities within this chunk…
+        for (let l = 0; l < 0x1e00; l += 0x0f) {
+          const BaseEntityPtr = EntityChunkScratch[l];
 
-        if (BaseEntityPtr === 0n) {
-          continue;
-        }
+          if (BaseEntityPtr === 0n) {
+            continue;
+          }
 
-        const EntityClassInfoPtr = EntityChunkScratch[l + 0x01];
+          const EntityClassInfoPtr = EntityChunkScratch[l + 0x01];
 
-        let Name = EntityClassInfoNames.get(EntityClassInfoPtr);
+          let Name = EntityClassInfoNames.get(EntityClassInfoPtr);
 
-        if (Name === undefined) {
-          const SchemaClassInfoDataPtr = cs2.u64(EntityClassInfoPtr + 0x30n);
-          /* */ const NamePtr = cs2.u64(SchemaClassInfoDataPtr + 0x08n);
-          /*       */ Name = cs2.buffer(NamePtr, 0x20).toString();
+          if (Name === undefined) {
+            const SchemaClassInfoDataPtr = cs2.u64(EntityClassInfoPtr + 0x30n);
+            /* */ const NamePtr = cs2.u64(SchemaClassInfoDataPtr + 0x08n);
+            // /*       */ Name = cs2.buffer(NamePtr, 0x20).toString();
+            /*       */ Name = cs2.string(NamePtr, 0x40);
 
-          EntityClassInfoNames.set(EntityClassInfoPtr, Name);
-        }
+            EntityClassInfoNames.set(EntityClassInfoPtr, Name);
+          }
 
-        let BaseEntityPtrs_ = BaseEntityPtrs.get(Name);
+          let BaseEntityPtrs_ = BaseEntityPtrs.get(Name);
 
-        if (BaseEntityPtrs_ === undefined) {
-          BaseEntityPtrs_ = [];
+          if (BaseEntityPtrs_ === undefined) {
+            BaseEntityPtrs_ = [];
 
-          BaseEntityPtrs.set(Name, BaseEntityPtrs_);
-        }
+            BaseEntityPtrs.set(Name, BaseEntityPtrs_);
+          }
 
-        BaseEntityPtrs_.push(BaseEntityPtr);
+          BaseEntityPtrs_.push(BaseEntityPtr);
+        }
       }
-    }
 
-    // ! —————————————————————————————————————————————————————————————————————————————————————————————
-    // ! YOUR CODE GOES HERE…
-    // ! —————————————————————————————————————————————————————————————————————————————————————————————
-
-    // ! —————————————————————————————————————————————————————————————————————————————————————————————
-    // ! YOUR CODE ENDS HERE…
-    // ! —————————————————————————————————————————————————————————————————————————————————————————————
-  } finally {
-    // Clear the entity list…
-    for (const BaseEntityPtrs_ of BaseEntityPtrs.values()) {
-      BaseEntityPtrs_.length = 0;
+      // ! —————————————————————————————————————————————————————————————————————————————————————————————
+      // ! YOUR CODE GOES HERE…
+      // ! —————————————————————————————————————————————————————————————————————————————————————————————
+
+      // // Log our entities…
+      // console.log(
+      //   'Entities found this tick: %O',
+      //   Object.fromEntries([...BaseEntityPtrs.entries()].map(([Name, { length }]) => [Name, length])) //
+      // );
+
+      // ! —————————————————————————————————————————————————————————————————————————————————————————————
+      // ! YOUR CODE ENDS HERE…
+      // ! —————————————————————————————————————————————————————————————————————————————————————————————
+    } finally {
+      // Clear the entity list…
+      for (const BaseEntityPtrs_ of BaseEntityPtrs.values()) {
+        BaseEntityPtrs_.length = 0;
+      }
     }
   }
-}
 
-const performance2 = performance.now();
+  const end = performance.now();
+
+  const total = end - start;
+  const average = total / Iterations;
 
-console.log('Test completed in %fms…', (performance2 - performance1).toFixed(2));
+  console.log(
+    'Completed %d iterations in %ss, averaging %sms (%sµs) each…', //
+    Iterations,
+    (total / 1_000).toFixed(2),
+    average.toFixed(2),
+    (average * 1_000).toFixed(2)
+  );
+}

package/example/trigger-bot.ts

@@ -1,4 +1,4 @@
-import { FFIType, dlopen } from 'bun:ffi';
+import { FFIType, dlopen, ptr } from 'bun:ffi';
 import { sleep } from 'bun';
 
 import Memory from 'bun-memory';
@@ -32,12 +32,14 @@ const Client = {
 const cs2 = new Memory('cs2.exe');
 
 // Get the base for client.dll…
-const ClientPtr = cs2.modules['client.dll']?.base;
+const client = cs2.modules['client.dll'];
 
-if (ClientPtr === undefined) {
-  throw new TypeError('ClientPtr must not be undefined.');
+if (client === undefined) {
+  throw new TypeError('client must not be undefined.');
 }
 
+const ClientPtr = client.base;
+
 // Create a cache for class name strings… 🫠…
 const Cache_Names = new Map<bigint, string>();
 
@@ -97,7 +99,7 @@ async function tick(ClientPtr: bigint) {
     if (Name === undefined) {
       const SchemaClassInfoDataPtr = cs2.u64(EntityClassInfoPtr + 0x30n);
       /* */ const NamePtr = cs2.u64(SchemaClassInfoDataPtr + 0x08n);
-      /*       */ Name = cs2.cString(NamePtr, 0x80).toString();
+      /*       */ Name = cs2.string(NamePtr, 0x80);
 
       Cache_Names.set(EntityClassInfoPtr, Name);
     }

package/package.json

@@ -22,7 +22,7 @@
     "url": "git://github.com/obscuritysrl/bun-memory.git"
   },
   "type": "module",
-  "version": "1.1.35",
+  "version": "1.1.37",
   "main": "./index.ts",
   "keywords": [
     "bun",

package/structs/Memory.ts

@@ -4,21 +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 },
   CreateToolhelp32Snapshot: { args: [FFIType.u32, FFIType.u32], returns: FFIType.u64 },
+  GetCurrentProcess: { args: [], returns: FFIType.ptr },
   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 },
+  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 },
-  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 },
 });
 
 /**
@@ -28,6 +28,7 @@ const {
  *
  * Many scalar reads utilize `TypedArray` scratches to avoid a second FFI hop, such as calling `bun:ffi.read.*`.
  *
+ * @todo Add call method for calling functions in remote process.
  * @todo Add support for 32 or 64-bit processes using IsWow64Process2 (Windows 10+).
  * @todo When adding 32-bit support, several u64 will need changed to u64_fast.
  *
@@ -109,15 +110,6 @@ class Memory {
     throw new Error(`Process not found: ${identifier}…`);
   }
 
-  /**
-   * 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.
@@ -168,12 +160,12 @@ 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 TextDecoderUTF16 = new TextDecoder('utf-16');
   private static TextDecoderUTF8 = new TextDecoder('utf-8');
 
+  private static TextEncoderUTF8 = new TextEncoder('utf-8');
+
   private readonly hProcess: bigint;
   private readonly th32ProcessID: number;
 
@@ -190,43 +182,6 @@ class Memory {
     return this._modules;
   }
 
-  /**
-   * 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) */
-    let   lpAddress = BigInt(address); // prettier-ignore
-    const lpBuffer = this.ScratchMemoryBasicInformation;
-
-    const bVirtualQueryEx = !!VirtualQueryEx(this.hProcess, lpAddress, lpBuffer, dwLength);
-
-    if (!bVirtualQueryEx) {
-      throw new Win32Error('VirtualQueryEx', GetLastError());
-    }
-
-    const end = lpAddress + BigInt(length);
-    const result: Region[] = [];
-
-    do {
-      const baseAddress = lpBuffer.readBigUInt64LE();
-      const protect = lpBuffer.readUInt32LE(36);
-      const regionSize = lpBuffer.readBigUInt64LE(24);
-      const state = lpBuffer.readUInt32LE(32);
-      const type = lpBuffer.readUInt32LE(40);
-
-      if ((protect & Memory.MemoryProtections.Safe) !== 0 && (protect & Memory.MemoryProtections.Unsafe) === 0 && state === 0x1000 /* MEM_COMMIT */) {
-        result.push({ base: baseAddress, protect, size: regionSize, state, type });
-      }
-
-      lpAddress = baseAddress + regionSize;
-    } while (lpAddress < end && !!VirtualQueryEx(this.hProcess, lpAddress, lpBuffer, dwLength));
-
-    return result;
-  }
-
   /**
    * Closes the process handle.
    * @example
@@ -332,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);
@@ -348,25 +303,57 @@ class Memory {
    * Writes a buffer to memory.
    * @param address Address to write to.
    * @param scratch Buffer to write.
+   * @param force If true, temporarily changes the page protection to PAGE_EXECUTE_READWRITE using `VirtualProtectEx` while performing 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 {
+  private 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 (!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 (!bWriteProcessMemory) {
-      throw new Win32Error('WriteProcessMemory', GetLastError());
+      if (!bVirtualProtectEx2) {
+        throw new Win32Error('VirtualProtectEx', GetLastError());
+      }
     }
 
     return this;
@@ -395,7 +382,7 @@ class Memory {
 
     Scratch1[0x00] = value ? 1 : 0;
 
-    this.write(address, Scratch1);
+    void this.write(address, Scratch1);
 
     return this;
   }
@@ -424,7 +411,7 @@ class Memory {
 
     const value = lengthOrValue;
 
-    this.write(address, value);
+    void this.write(address, value);
 
     return this;
   }
@@ -447,14 +434,20 @@ class Memory {
     if (typeof lengthOrValue === 'number') {
       const scratch = new Uint8Array(lengthOrValue);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
+
+      const indexOf = scratch.indexOf(0x00);
+
+      if (indexOf === -1) {
+        scratch[lengthOrValue - 1] = 0x00;
+      }
 
       return new CString(scratch.ptr);
     }
 
     const scratch = Buffer.from(lengthOrValue);
 
-    this.write(address, scratch);
+    void this.write(address, scratch);
 
     return this;
   }
@@ -482,7 +475,7 @@ class Memory {
 
     Scratch4Float32Array[0x00] = value;
 
-    this.write(address, Scratch4Float32Array);
+    void this.write(address, Scratch4Float32Array);
 
     return this;
   }
@@ -506,14 +499,14 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new Float32Array(length);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -541,7 +534,7 @@ class Memory {
 
     Scratch8Float64Array[0x00] = value;
 
-    this.write(address, Scratch8Float64Array);
+    void this.write(address, Scratch8Float64Array);
 
     return this;
   }
@@ -565,14 +558,14 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new Float64Array(length);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -600,7 +593,7 @@ class Memory {
 
     Scratch2Int16Array[0x00] = value;
 
-    this.write(address, Scratch2Int16Array);
+    void this.write(address, Scratch2Int16Array);
 
     return this;
   }
@@ -624,14 +617,14 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new Int16Array(length);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -659,7 +652,7 @@ class Memory {
 
     Scratch4Int32Array[0x00] = value;
 
-    this.write(address, Scratch4Int32Array);
+    void this.write(address, Scratch4Int32Array);
 
     return this;
   }
@@ -683,14 +676,14 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new Int32Array(length);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -718,7 +711,7 @@ class Memory {
 
     Scratch8BigInt64Array[0x00] = value;
 
-    this.write(address, Scratch8BigInt64Array);
+    void this.write(address, Scratch8BigInt64Array);
 
     return this;
   }
@@ -742,14 +735,14 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new BigInt64Array(length);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -777,7 +770,7 @@ class Memory {
 
     Scratch1Int8Array[0x00] = value;
 
-    this.write(address, Scratch1Int8Array);
+    void this.write(address, Scratch1Int8Array);
 
     return this;
   }
@@ -801,14 +794,14 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new Int8Array(length);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -831,7 +824,7 @@ class Memory {
     if (values === undefined) {
       const scratch = new Float32Array(0x09);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
@@ -840,7 +833,7 @@ class Memory {
       throw new RangeError('values.length must be 9.');
     }
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -863,7 +856,7 @@ class Memory {
     if (values === undefined) {
       const scratch = new Float32Array(0x0c);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
@@ -872,7 +865,7 @@ class Memory {
       throw new RangeError('values.length must be 12.');
     }
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -895,7 +888,7 @@ class Memory {
     if (values === undefined) {
       const scratch = new Float32Array(0x10);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
@@ -904,7 +897,7 @@ class Memory {
       throw new RangeError('values.length must be 16.');
     }
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -931,14 +924,14 @@ class Memory {
 
       const scratch = new Uint32Array(size);
 
-      this.read(elementsPtr, scratch);
+      void this.read(elementsPtr, scratch);
 
       return scratch;
     }
 
     this.u32(address, values.length);
 
-    this.write(elementsPtr, values);
+    void this.write(elementsPtr, values);
 
     return this;
   }
@@ -961,7 +954,7 @@ class Memory {
     const Scratch8Float32Array = this.Scratch8Float32Array;
 
     if (value === undefined) {
-      this.read(address, Scratch8Float32Array);
+      void this.read(address, Scratch8Float32Array);
 
       const x = Scratch8Float32Array[0x00],
             y = Scratch8Float32Array[0x01]; // prettier-ignore
@@ -972,7 +965,7 @@ class Memory {
     Scratch8Float32Array[0x00] = value.x;
     Scratch8Float32Array[0x01] = value.y;
 
-    this.write(address, Scratch8Float32Array);
+    void this.write(address, Scratch8Float32Array);
 
     return this;
   }
@@ -996,7 +989,7 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new Float32Array(length * 2);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       const result = new Array<Vector2>(length);
 
@@ -1020,7 +1013,7 @@ class Memory {
       scratch[j + 0x01] = vector2.y;
     }
 
-    this.write(address, scratch);
+    void this.write(address, scratch);
 
     return this;
   }
@@ -1036,7 +1029,7 @@ class Memory {
       throw new RangeError('values.length must be 2.');
     }
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -1059,7 +1052,7 @@ class Memory {
     const Scratch12Float32Array = this.Scratch12Float32Array;
 
     if (value === undefined) {
-      this.read(address, Scratch12Float32Array);
+      void this.read(address, Scratch12Float32Array);
 
       const pitch = Scratch12Float32Array[0x00],
             roll  = Scratch12Float32Array[0x02],
@@ -1072,7 +1065,7 @@ class Memory {
     Scratch12Float32Array[0x02] = value.roll;
     Scratch12Float32Array[0x01] = value.yaw;
 
-    this.write(address, Scratch12Float32Array);
+    void this.write(address, Scratch12Float32Array);
 
     return this;
   }
@@ -1096,7 +1089,7 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new Float32Array(length * 0x03);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       const result = new Array<QAngle>(length);
 
@@ -1122,7 +1115,7 @@ class Memory {
       scratch[j + 0x01] = qAngle.yaw;
     }
 
-    this.write(address, scratch);
+    void this.write(address, scratch);
 
     return this;
   }
@@ -1150,7 +1143,7 @@ class Memory {
       throw new RangeError('values.length must be 3.');
     }
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -1173,7 +1166,7 @@ class Memory {
     const Scratch16Float32Array = this.Scratch16Float32Array;
 
     if (value === undefined) {
-      this.read(address, Scratch16Float32Array);
+      void this.read(address, Scratch16Float32Array);
 
       const w = Scratch16Float32Array[0x03],
             x = Scratch16Float32Array[0x00],
@@ -1188,7 +1181,7 @@ class Memory {
     Scratch16Float32Array[0x01] = value.y;
     Scratch16Float32Array[0x02] = value.z;
 
-    this.write(address, Scratch16Float32Array);
+    void this.write(address, Scratch16Float32Array);
 
     return this;
   }
@@ -1212,7 +1205,7 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new Float32Array(length * 0x04); // 4 * f32 per Quaternion
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       const result = new Array<Quaternion>(length);
 
@@ -1240,7 +1233,7 @@ class Memory {
       scratch[j + 0x02] = quaternion.z;
     }
 
-    this.write(address, scratch);
+    void this.write(address, scratch);
 
     return this;
   }
@@ -1268,7 +1261,7 @@ class Memory {
       throw new RangeError('values.length must be 4.');
     }
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -1291,7 +1284,7 @@ class Memory {
     const Scratch3 = this.Scratch3;
 
     if (value === undefined) {
-      this.read(address, Scratch3);
+      void this.read(address, Scratch3);
 
       const r = Scratch3[0x00],
             g = Scratch3[0x01],
@@ -1304,7 +1297,9 @@ class Memory {
     Scratch3[0x01] = value.g;
     Scratch3[0x02] = value.b;
 
-    return this.write(address, Scratch3);
+    void this.write(address, Scratch3);
+
+    return this;
   }
 
   /**
@@ -1330,7 +1325,7 @@ class Memory {
       throw new RangeError('values.length must be 3.');
     }
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -1353,7 +1348,7 @@ class Memory {
     const Scratch4 = this.Scratch4;
 
     if (value === undefined) {
-      this.read(address, Scratch4);
+      void this.read(address, Scratch4);
 
       const r = Scratch4[0x00],
             g = Scratch4[0x01],
@@ -1368,7 +1363,9 @@ class Memory {
     Scratch4[0x02] = value.b;
     Scratch4[0x03] = value.a;
 
-    return this.write(address, Scratch4);
+    void this.write(address, Scratch4);
+
+    return this;
   }
 
   /**
@@ -1394,7 +1391,45 @@ class Memory {
       throw new RangeError('values.length must be 4.');
     }
 
-    this.write(address, values);
+    void this.write(address, values);
+
+    return this;
+  }
+
+  /**
+   * Reads or writes a UTF-8 string.
+   * @param address Address to access.
+   * @param lengthOrValue Length to read or string to 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');
+   * const myString = cs2.string(0x12345678n, 16);
+   * cs2.string(0x12345678n, 'hello\0');
+   * ```
+   */
+  public string(address: bigint, length: number): string;
+  public string(address: bigint, value: string): this;
+  public string(address: bigint, lengthOrValue: number | string): string | this {
+    if (typeof lengthOrValue === 'number') {
+      const scratch = new Uint8Array(lengthOrValue);
+
+      void this.read(address, scratch);
+
+      const indexOf = scratch.indexOf(0x00);
+
+      return Memory.TextDecoderUTF8.decode(
+        scratch.subarray(0, indexOf !== -1 ? indexOf : lengthOrValue) //
+      );
+
+      // return new CString(scratch.ptr).valueOf();
+    }
+
+    const scratch = Memory.TextEncoderUTF8.encode(lengthOrValue);
+
+    void this.write(address, scratch);
 
     return this;
   }
@@ -1422,7 +1457,7 @@ class Memory {
 
     Scratch2Uint16Array[0x00] = value;
 
-    this.write(address, Scratch2Uint16Array);
+    void this.write(address, Scratch2Uint16Array);
 
     return this;
   }
@@ -1446,14 +1481,14 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new Uint16Array(length);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -1481,7 +1516,7 @@ class Memory {
 
     Scratch4Uint32Array[0x00] = value;
 
-    this.write(address, Scratch4Uint32Array);
+    void this.write(address, Scratch4Uint32Array);
 
     return this;
   }
@@ -1505,14 +1540,14 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new Uint32Array(length);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -1540,7 +1575,7 @@ class Memory {
 
     Scratch8BigUint64Array[0x00] = value;
 
-    this.write(address, Scratch8BigUint64Array);
+    void this.write(address, Scratch8BigUint64Array);
 
     return this;
   }
@@ -1564,14 +1599,14 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new BigUint64Array(length);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -1599,7 +1634,7 @@ class Memory {
 
     Scratch1[0x00] = value;
 
-    this.write(address, Scratch1);
+    void this.write(address, Scratch1);
 
     return this;
   }
@@ -1623,14 +1658,14 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new Uint8Array(length);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       return scratch;
     }
 
     const values = lengthOrValues;
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -1738,7 +1773,7 @@ class Memory {
       throw new RangeError('values.length must be 2.');
     }
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -1761,7 +1796,7 @@ class Memory {
     const Scratch12Float32Array = this.Scratch12Float32Array;
 
     if (value === undefined) {
-      this.read(address, Scratch12Float32Array);
+      void this.read(address, Scratch12Float32Array);
 
       const x = Scratch12Float32Array[0x00],
             y = Scratch12Float32Array[0x01],
@@ -1774,7 +1809,7 @@ class Memory {
     Scratch12Float32Array[0x01] = value.y;
     Scratch12Float32Array[0x02] = value.z;
 
-    this.write(address, Scratch12Float32Array);
+    void this.write(address, Scratch12Float32Array);
 
     return this;
   }
@@ -1798,7 +1833,7 @@ class Memory {
       const length = lengthOrValues;
       const scratch = new Float32Array(length * 0x03);
 
-      this.read(address, scratch);
+      void this.read(address, scratch);
 
       const result = new Array<Vector3>(length);
 
@@ -1824,7 +1859,7 @@ class Memory {
       scratch[j + 0x02] = vector3.z;
     }
 
-    this.write(address, scratch);
+    void this.write(address, scratch);
 
     return this;
   }
@@ -1840,7 +1875,7 @@ class Memory {
       throw new RangeError('values.length must be 3.');
     }
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -1902,7 +1937,7 @@ class Memory {
       throw new RangeError('values.length must be 4.');
     }
 
-    this.write(address, values);
+    void this.write(address, values);
 
     return this;
   }
@@ -1964,7 +1999,7 @@ class Memory {
       ? Buffer.from(needle.buffer, needle.byteOffset, needle.byteLength)
       : Buffer.from(needle);
 
-    this.read(address, haystack);
+    void this.read(address, haystack);
 
     if (!all) {
       const indexOf = haystack.indexOf(needleBuffer);