bun-memory 1.1.15 → 1.1.17

package/README.md

@@ -125,24 +125,35 @@ while (true) {
 }
 ```
 
-```ts
-const scratch = Buffer.allocUnsafe(0x100);
-memory.read(myAddress, scratch);
-```
+### Searching Memory
 
-```ts
-const scratch = new Uint32Array(0x10);
-memory.read(myAddress, scratch);
-```
-
-### Pattern Scanning
+#### `findPattern`
 
 Pattern scanning is temporarily disabled but will return shortly.
 
+#### `indexOf`
+
+Find the first occurrence of a byte sequence within a memory range and return the absolute address (`bigint`) of the first match, or `-1n` when not found. Accepts any Scratch-compatible input (`Buffer`, `TypedArray`, `DataView`, `ArrayBuffer`, or `SharedArrayBuffer`). No region or protection checking is performed; ensure the range is readable before calling.
+
 ```ts
-const offset = memory.findPattern('aa??bbccdd??ff', mainModule.modBaseAddr, mainModule.modBaseSize);
-const value = memory.bool(offset + 0x1234n);
-memory.close();
+// Attach…
+const memory = new Memory('cs2.exe');
+
+// Get the loaded client.dll…
+const client = cs2.modules['client.dll'];
+
+// Choose any Scratch type for the needle (bytes are matched exactly as laid out in memory).
+const needle = Buffer.from([0x48, 0x8b, 0x05, 0x00, 0x00, 0x00, 0x00]);
+// const needle = new Uint8Array([0x48, 0x8B, 0x05, 0x00, 0x00, 0x00, 0x00]);
+// const needle = new Uint32Array([0xDEADBEEF, 0x11223344]);
+// const needle = new DataView(Uint8Array.from([0xde, 0xad, 0xbe, 0xef]).buffer);
+
+// Search client.dll for the byte sequence…
+const addeess = memory.indexOf(needle, client.base, client.size);
+
+if (address !== -1n) {
+  console.log(`Found at 0x${address.toString(16)}`);
+}
 ```
 
 ## Notes

package/package.json

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

package/structs/Memory.ts

@@ -429,6 +429,47 @@ class Memory {
     return this;
   }
 
+  /**
+   * Reads a raw byte buffer from memory or writes a raw byte buffer to memory.
+   *
+   * When reading, exactly `length` bytes are copied from `address` into a new `Buffer`.
+   * Bytes are returned exactly as laid out in memory—no decoding, alignment, or transformation
+   * is applied. When writing, the contents of `value` are copied to `address` verbatim.
+   *
+   * @param address - Memory address to read from or write to
+   * @param lengthOrValue - Number of bytes to read (when reading), or `Buffer` to write (when writing)
+   * @returns `Buffer` when reading, or this `Memory` instance when writing
+   *
+   * @example
+   * ```typescript
+   * // Read 16 bytes from memory
+   * const bytes = memory.buffer(0x12345678n, 16);
+   *
+   * // Write a 4-byte patch (NOP sled, for example)
+   * const patch = Buffer.from([0x90, 0x90, 0x90, 0x90]);
+   * memory.buffer(0x12345678n, patch);
+   * ```
+   */
+  public buffer(address: bigint, length: number): Buffer;
+  public buffer(address: bigint, value: Buffer): this;
+  public buffer(address: bigint, lengthOrValue: number | Buffer): Buffer | this {
+    if (typeof lengthOrValue === 'number') {
+      const length = lengthOrValue;
+
+      const scratch = Buffer.allocUnsafe(length);
+
+      this.read(address, scratch);
+
+      return scratch;
+    }
+
+    const value = lengthOrValue;
+
+    this.write(address, value);
+
+    return this;
+  }
+
   /**
    * Reads a NUL-terminated C string from memory or writes a NUL-terminated C string to memory.
    *