bun-memory 1.1.38 → 1.1.40

package/README.md

@@ -28,7 +28,7 @@ bun add bun-memory
 
 ## Quick Start
 
-❗ **Important**: [Example: Using Scratches (Recommended)](#example-using-scratches-recommended)
+For maximum performance, it is highly recommended to read about [using scratches](#example-using-scratches-recommended).
 
 ```ts
 import Memory from 'bun-memory';
@@ -55,7 +55,7 @@ cs2.close();
 - `indexOf(needle, address, length, [all])` — Search for a buffer or array in memory (returns all matches if all=true)
 - `pattern(needle, address, length, [all])` — Find a byte pattern in memory (supports wildcards, returns all matches if all=true)
 - `read(address, scratch)` — Read memory into a scratch (no allocations)
-- `write(address, scratch)` — Write a scratch to memory
+- `write(address, scratch, [force])` — Write a scratch to memory
 - Module map: `memory.modules['client.dll']`
 - Typed accessors: `bool`, `f32`, `i32`, `matrix4x4`, `u8`, `u64Array`, `vector3`, etc.
 

package/example/benchmark.ts

@@ -49,7 +49,7 @@ for (let i = 0; i < Iterations; i++) {
 // Create caches and scratches to optimize performance…
 const BaseEntityPtrs = new Map<string, bigint[]>();
 
-const EntityChunkScratch = new BigUint64Array(0xf000 / 0x08);
+const EntityChunkScratch = new BigUint64Array(0xe000 / 0x08);
 const EntityListScratch = new BigUint64Array(0x200 / 0x08);
 
 const EntityClassInfoNames = new Map<bigint, string>();
@@ -77,8 +77,8 @@ for (let i = 0; i < 5; i++) {
 
         void cs2.read(EntityChunkPtr, EntityChunkScratch);
 
-        // Traverse each of the potential 512 entities within this chunk…
-        for (let l = 0; l < 0x1e00; l += 0x0f) {
+        // Traverse the potential 512 entities in that chunk…
+        for (let j = 0x00, l = 0x00; j < 0x200; j++, l += 0x0e) {
           const BaseEntityPtr = EntityChunkScratch[l];
 
           if (BaseEntityPtr === 0n) {

package/example/trigger-bot.ts

@@ -91,8 +91,8 @@ async function tick(ClientPtr: bigint) {
     // Get the entity that we're aiming at from the entity list…
     const EntityListPtr = cs2.u64(ClientPtr + Client.Other.dwEntityList);
     /* */ const EntityChunkPtr = cs2.u64(EntityListPtr + (BigInt(Local_IDEntIndex) >> 0x09n) * 0x08n + 0x10n);
-    /*       */ const BaseEntityPtr = cs2.u64(EntityChunkPtr + (BigInt(Local_IDEntIndex) & 0x1ffn) * 0x78n);
-    /*             */ const EntityClassInfoPtr = cs2.u64(EntityChunkPtr + (BigInt(Local_IDEntIndex) & 0x1ffn) * 0x78n + 0x08n);
+    /*       */ const BaseEntityPtr = cs2.u64(EntityChunkPtr + (BigInt(Local_IDEntIndex) & 0x1ffn) * 0x70n);
+    /*             */ const EntityClassInfoPtr = cs2.u64(EntityChunkPtr + (BigInt(Local_IDEntIndex) & 0x1ffn) * 0x70n + 0x08n);
 
     let Name = Cache_Names.get(EntityClassInfoPtr);
 

package/package.json

@@ -1,29 +1,38 @@
 {
+  "name": "bun-memory",
+  "version": "1.1.40",
   "author": "Stev Peifer <stev@bell.net>",
-  "bugs": {
-    "url": "https://github.com/obscuritysrl/bun-memory/issues"
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/obscuritysrl/bun-memory.git"
   },
-  "description": "Blazing fast, high-performance Windows process memory manipulation for Bun.",
+  "main": "./index.ts",
+  "module": "index.ts",
   "devDependencies": {
     "@types/bun": "latest"
   },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
   "exports": {
     ".": "./index.ts"
   },
-  "license": "MIT",
-  "module": "index.ts",
-  "name": "bun-memory",
-  "peerDependencies": {
-    "typescript": "^5"
+  "bugs": {
+    "url": "https://github.com/obscuritysrl/bun-memory/issues"
   },
-  "private": false,
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/obscuritysrl/bun-memory.git"
+  "description": "Blazing fast, high-performance Windows process memory manipulation for Bun.",
+  "engines": {
+    "bun": ">=1.1.0"
   },
-  "type": "module",
-  "version": "1.1.38",
-  "main": "./index.ts",
+  "files": [
+    "index.ts",
+    "example/*.ts",
+    "runtime/*.ts",
+    "structs/*.ts",
+    "types/*.ts",
+    "README.md",
+    "LICENSE"
+  ],
   "keywords": [
     "bun",
     "ffi",
@@ -35,20 +44,11 @@
     "WriteProcessMemory",
     "typescript"
   ],
-  "files": [
-    "index.ts",
-    "example/*.ts",
-    "runtime/*.ts",
-    "structs/*.ts",
-    "types/*.ts",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "bun": ">=1.1.0"
-  },
+  "license": "MIT",
+  "private": false,
   "scripts": {
     "run:benchmark": "bun ./example/benchmark.ts",
     "run:trigger-bot": "bun ./example/trigger-bot.ts"
-  }
+  },
+  "type": "module"
 }

package/structs/Memory.ts

@@ -1,6 +1,6 @@
 import { CString, FFIType, dlopen, ptr } from 'bun:ffi';
 
-import type { Module, NetworkUtlVector, Point, QAngle, Quaternion, Region, RGB, RGBA, Scratch, UPtr, UPtrArray, Vector2, Vector3, Vector4 } from '../types/Memory';
+import type { Module, Point, QAngle, Quaternion, Region, RGB, RGBA, Scratch, UPtr, UPtrArray, Vector2, Vector3, Vector4 } from '../types/Memory';
 import Win32Error from './Win32Error';
 
 const {
@@ -920,41 +920,6 @@ class Memory {
     return this;
   }
 
-  /**
-   * 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
-   * const cs2 = new Memory('cs2.exe');
-   * const myVector = cs2.networkUtlVector(0x12345678n);
-   * cs2.networkUtlVector(0x12345678n, new Uint32Array([1,2,3]));
-   * ```
-   */
-  public networkUtlVector(address: bigint): NetworkUtlVector;
-  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) {
-      const size = this.u32(address);
-
-      const scratch = new Uint32Array(size);
-
-      void this.read(elementsPtr, scratch);
-
-      return scratch;
-    }
-
-    this.u32(address, values.length, force);
-
-    void this.write(elementsPtr, values, force);
-
-    return this;
-  }
-
   /**
    * Reads or writes a Point (object with x, y).
    * @param address Address to access.
@@ -1772,6 +1737,97 @@ class Memory {
     return this.u64Array(address, lengthOrValues, force);
   }
 
+  /**
+   * Reads a UtlLinkedList of 64-bit unsigned integers and returns its elements as a BigUint64Array.
+   *
+   * This helper reads the list header at `address`, validates the capacity and element pointer,
+   * reads the elements table, and walks the internal linked indices to produce a compact
+   * BigUint64Array of present elements. If the list is empty or invalid an empty array is
+   * returned.
+   *
+   * @param address Address of the UtlLinkedList header in the remote process.
+   * @returns BigUint64Array containing the list elements (empty if the list is invalid or empty).
+   * @todo Create a writer so that users can write linked lists…
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myList = cs2.utlLinkedListU64(0x12345678n);
+   * ```
+   */
+  public utlLinkedListU64(address: bigint): BigUint64Array {
+    const header = new Uint8Array(0x18);
+    const headerUint16Array = new Uint16Array(header.buffer, header.byteOffset);
+    const headerBigUint64Array = new BigUint64Array(header.buffer, header.byteOffset + 0x08, 2);
+
+    void this.read(address, header);
+
+    const capacity = headerUint16Array[0x01] & 0x7fff;
+    const elementsPtr = headerBigUint64Array[0x00];
+    let   index = headerUint16Array[0x08]; // prettier-ignore
+
+    if (capacity === 0 || capacity <= index || elementsPtr === 0n || index === 0xffff) {
+      return new BigUint64Array(0);
+    }
+
+    const scratch = new Uint8Array(capacity << 0x04);
+    const scratchBigUint64Array = new BigUint64Array(scratch.buffer, scratch.byteOffset);
+    const scratchUint16Array = new Uint16Array(scratch.buffer, scratch.byteOffset);
+
+    void this.read(elementsPtr, scratch);
+
+    let   count = 0; // prettier-ignore
+    const result = new BigUint64Array(capacity);
+
+    while (count < capacity && capacity > index && index !== 0xffff) {
+      result[count++] = scratchBigUint64Array[index * 0x02];
+
+      const next = scratchUint16Array[0x05 + index * 0x08];
+
+      if (index === next || next === 0xffff) {
+        break;
+      }
+
+      index = next;
+    }
+
+    return capacity === count ? result : result.subarray(0, count);
+  }
+
+  /**
+   * Reads or writes a UtlVectorU32 (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
+   * const cs2 = new Memory('cs2.exe');
+   * const myVector = cs2.utlVectorU32(0x12345678n);
+   * cs2.utlVectorU32(0x12345678n, new Uint32Array([1,2,3]));
+   * ```
+   */
+  public utlVectorU32(address: bigint): Uint32Array;
+  public utlVectorU32(address: bigint, values: Uint32Array, force?: boolean): this;
+  public utlVectorU32(address: bigint, values?: Uint32Array, force?: boolean): Uint32Array | this {
+    const elementsPtr = this.u64(address + 0x08n);
+
+    if (values === undefined) {
+      const size = this.u32(address);
+
+      const scratch = new Uint32Array(size);
+
+      void this.read(elementsPtr, scratch);
+
+      return scratch;
+    }
+
+    this.u32(address, values.length, force);
+
+    void this.write(elementsPtr, values, force);
+
+    return this;
+  }
+
   /**
    * Reads or writes a Vector2 (object with x, y).
    * @param address Address to access.