bun-memory 1.1.10 → 1.1.11

package/example/trigger-bot.ts

@@ -10,7 +10,12 @@ import ClientDLLJSON from './offsets/client_dll.json';
 import OffsetsJSON from './offsets/offsets.json';
 
 // !
+const buffer = Buffer.from('Hello world!');
+const bufferPtr = ptr(buffer);
 
+const cString = new CString(bufferPtr);
+
+console.log(cString.byteLength, cString.byteOffset); // undefined undefined
 // !
 
 const Delay = 2.5;

package/package.json

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

package/structs/Memory.ts

@@ -4,7 +4,7 @@
 
 import { CString, FFIType, dlopen, read } from 'bun:ffi';
 
-import type { Module, Quaternion, Region, Scratch, Vector2, Vector3 } from '../types/Memory';
+import type { Module, NetworkUtlVector, Quaternion, Region, Scratch, Vector2, Vector3 } from '../types/Memory';
 import Win32Error from './Win32Error';
 
 const { f32, f64, i16, i32, i64, i8, u16, u32, u64, u8 } = read;
@@ -917,6 +917,58 @@ class Memory {
     return this;
   }
 
+  /**
+   * Reads a `NetworkUtlVector` (`Uint32Array`) from memory or writes a `NetworkUtlVector` to memory.
+   *
+   * The vector is represented in memory as a small header with an out-of-line elements buffer.
+   * Layout at `address`:
+   * - 0x00: `uint32` size (number of elements)
+   * - 0x04: `uint32` capacity/reserved (not modified by this method)
+   * - 0x08: `uint64` pointer to a contiguous array of `uint32` elements
+   *
+   * When reading, this method returns a `Uint32Array` containing `size` elements copied from the
+   * elements pointer. When writing, it updates the size field and writes the provided values to the
+   * existing elements buffer (no reallocation is performed).
+   *
+   * @param address - Memory address of the vector header to read from or write to
+   * @param values - Optional `NetworkUtlVector` to write. If omitted, performs a read operation
+   * @returns `NetworkUtlVector` when reading, or this `Memory` instance when writing
+   *
+   * @example
+   * ```typescript
+   * const memory = new Memory('network_app.exe');
+   *
+   * // Read the current vector
+   * const ids = memory.networkUtlVector(0x12345678n);
+   * console.log('IDs:', Array.from(ids));
+   *
+   * // Write new values (must fit the existing buffer capacity)
+   * const next = new Uint32Array([10, 20, 30, 40]);
+   * memory.networkUtlVector(0x12345678n, next);
+   * ```
+   */
+  public networkUtlVector(address: bigint): NetworkUtlVector;
+  public networkUtlVector(address: bigint, values: NetworkUtlVector): this;
+  public networkUtlVector(address: bigint, values?: NetworkUtlVector): NetworkUtlVector | this {
+    const elementsPtr = this.u64(address + 0x08n);
+
+    if (values === undefined) {
+      const size = this.u32(address);
+
+      const scratch = new Uint32Array(size);
+
+      this.read(elementsPtr, scratch);
+
+      return scratch;
+    }
+
+    this.u32(address, values.length);
+
+    this.write(elementsPtr, values);
+
+    return this;
+  }
+
   /**
    * Reads a quaternion (4D rotation) from memory or writes a quaternion to memory.
    * Quaternions are stored as four 32-bit floats: x, y, z, w.

package/types/Memory.ts

@@ -136,6 +136,65 @@ export type Module = {
   size: number;
 };
 
+/**
+ * Represents a contiguous vector of unsigned 32-bit integers used by the network
+ * utility subsystem.
+ *
+ * `NetworkUtlVector` is an alias of `Uint32Array`. In the target process, the
+ * vector’s elements live in an out-of-line buffer referenced by a small header
+ * at `address` (read/write via {@link Memory.networkUtlVector}):
+ *
+ * - 0x00: `uint32` size (number of elements)
+ * - 0x04: `uint32` capacity (preallocated element count)
+ * - 0x08: `uint64` pointer to contiguous `uint32` elements
+ *
+ * This alias provides a type-safe view for high-throughput operations such as
+ * batched identifier handling, index sets, and routing tables, while keeping
+ * zero-copy semantics in userland and avoiding per-element boxing.
+ *
+ * Characteristics:
+ * - Little-endian `uint32` element layout
+ * - Backed by a single contiguous elements buffer
+ * - Suitable for FFI and bulk memory transfers
+ *
+ * Usage notes:
+ * - Use {@link Memory.networkUtlVector} to read or write the elements without
+ *   reallocating the in-process buffer.
+ * - When writing, the implementation updates the size field to `values.length`
+ *   and copies elements into the existing buffer; capacity and pointer are not
+ *   modified.
+ * - Ensure `values.length` does not exceed the current capacity of the in-process
+ *   buffer to avoid truncation or undefined behavior imposed by the target.
+ *
+ * @example
+ * ```typescript
+ * const memory = new Memory('network_app.exe');
+ *
+ * // Read the current vector
+ * const ids: NetworkUtlVector = memory.networkUtlVector(0x12345678n);
+ * console.log(`Count: ${ids.length}`, Array.from(ids));
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Overwrite the vector contents (must fit existing capacity)
+ * const next: NetworkUtlVector = Uint32Array.from([101, 202, 303, 404]);
+ * memory.networkUtlVector(0x12345678n, next);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Append in place by staging into a new typed array, then writing back
+ * const baseAddress = 0x12345678n;
+ * const current = memory.networkUtlVector(baseAddress);
+ * const extended = new Uint32Array(current.length + 1);
+ * extended.set(current);
+ * extended[extended.length - 1] = 0xDEADBEEF;
+ * memory.networkUtlVector(baseAddress, extended); // capacity must allow the new size
+ * ```
+ */
+export type NetworkUtlVector = Uint32Array;
+
 /**
  * Represents a quaternion for 3D rotations.
  *