bumparena 0.0.1 → 0.0.5

package/arena.ts

@@ -19,12 +19,6 @@ export interface ArenaHeaders {
 	header1: number
 	header2: number
 }
-const enum SHIFTOFFSETS {
-	BYTE_8 = 0, // No SHIFT needed
-	BYTE_16 = 1,
-	BYTE_32 = 2,
-	BYTE_64 = 3,
-}
 const enum HEADERS {
 	TOTAL_LENGTH_0_32 = 0,
 	PAYLOAD_LENGTH_0_32 = 1,
@@ -66,6 +60,25 @@ export class Arena {
 		}
 		this._emptySpots = new Uint32Array(currentOffset)
 	}
+
+	private _u(n: number): number {
+		return n >>> 0;
+	}
+
+	private _idx32(byteOffset: number): number {
+		return (byteOffset >>> 0) >> 2;
+	}
+
+	private _makePtr(offset: number, gen: number | bigint): ArenaLocation {
+		const bOffset = BigInt(offset >>> 0);
+		const bGen = BigInt(gen ?? 0);
+		return ((bOffset << 32n) | (bGen & 0xFFFFFFFFn)) as ArenaLocation;
+	}
+
+	private _getOffset(ptr: ArenaLocation): number {
+		return Number(BigInt(ptr) >> 32n) >>> 0;
+	}
+
 	private _getBucketCount(bucketIdx: number): number {
 		return this._emptySpots[this._bucketOffsets[bucketIdx]!]!;
 	}
@@ -82,50 +95,63 @@ export class Arena {
 		this._emptySpots[this._bucketOffsets[bucketIdx]! + slotIdx + 1] = offset;
 	}
 
-	private _initBlock(start: number, dataLength: number, { header0, header1, header2 }: { header0?: number, header1?: number, header2?: number }) {
-		const h0 = (header0 || 0) & 0xFF;
-		const h1 = (header1 || 0) & 0xFF;
-		const h2 = (header2 || 0) & 0xFF;
-		const shift32 = start >> SHIFTOFFSETS.BYTE_32
-		this._view32[shift32 + HEADERS.TOTAL_LENGTH_0_32] = (dataLength + this.HEADER_SIZE_BYTES + this._allignMask) & ~this._allignMask
-		this._view32[shift32 + HEADERS.PAYLOAD_LENGTH_0_32] = dataLength
-		this._view32[shift32 + (HEADERS.DELETED_8 >> SHIFTOFFSETS.BYTE_32)] = (h2 << 24) | (h1 << 16) | (h0 << 8) | 0
+	private _initBlock(start: number, dataLength: number, headers: { header0: number, header1: number, header2: number }) {
+		const idx = this._idx32(start)
+		const { header0: h0, header1: h1, header2: h2 } = headers;
+
+		this._view32[idx + HEADERS.TOTAL_LENGTH_0_32] = this._u((dataLength + this.HEADER_SIZE_BYTES + this._allignMask) & ~this._allignMask);
+		this._view32[idx + HEADERS.PAYLOAD_LENGTH_0_32] = dataLength;
+
+		this._view32[idx + (HEADERS.DELETED_8 >> 2)] = ((h2 || 0) << 24) | ((h1 || 0) << 16) | ((h0 || 0) << 8);
+		this._view8[start + HEADERS.DELETED_8] = 0;
 	}
 
 	public alloc(data: Uint8Array, headers?: ArenaCustomHeaders): ArenaLocation {
-		if (headers == undefined) headers = { header0: 0, header1: 0, header2: 0 }
-		const totalBlockSize = (data.byteLength + this.HEADER_SIZE_BYTES + this._allignMask) & ~this._allignMask;
-		const bucketIdx = (totalBlockSize >> this._allignShift) - 1;
+		headers ||= { header0: 0, header1: 0, header2: 0 };
+
+		const needed = (data.byteLength + this.HEADER_SIZE_BYTES + this._allignMask) & ~this._allignMask;
+		const bucketIdx = (needed >> this._allignShift) - 1;
 		if (bucketIdx >= 0 && bucketIdx < this._bucketcount) {
 			const count = this._getBucketCount(bucketIdx);
 			if (count > 0) {
-				const recycledOffset = this._getBucketOffset(bucketIdx, count - 1);
+				const recycledOffset = this._u(this._getBucketOffset(bucketIdx, count - 1));
 				this._setBucketCount(bucketIdx, count - 1);
 				this._initBlock(recycledOffset, data.length, headers);
-				return (BigInt(recycledOffset) << 32n | BigInt(this._view32[(recycledOffset >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32]!)) as ArenaLocation
+
+				const gen = this._view32[this._idx32(recycledOffset) + HEADERS.GENERATION_BYTE_0_32]!;
+				return this._makePtr(recycledOffset, gen)
 			}
 		}
-		const start = this._offset
-		this._checkForSpace(data.byteLength + this.HEADER_SIZE_BYTES) && this._resize()
-		this._initBlock(start, data.byteLength, headers || {})
+		const start = this._u(this._offset)
+		if (this._checkForSpace(needed)) this._resize()
+		this._initBlock(start, data.byteLength, headers)
+
 		this._view8.set(data, start + this.HEADER_SIZE_BYTES)
-		this._offset = (data.byteLength + this.HEADER_SIZE_BYTES + this._offset + this._allignMask) & ~this._allignMask;
-		return (BigInt(start) << 32n | BigInt(this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32]!)) as ArenaLocation
+		this._offset = this._u((start + needed) & ~this._allignMask);
+
+		const gen = this._view32[this._idx32(start) + HEADERS.GENERATION_BYTE_0_32]!
+		return this._makePtr(start, gen)
 	}
 	public read(location: ArenaLocation): Uint8Array | null {
-		let start = Number(BigInt(location as bigint) >> 32n)
-		const generation = BigInt(location as bigint) & 0xFFFFFFFFn
-		let length = this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.PAYLOAD_LENGTH_0_32]!
-		const diff = generation ^ BigInt(this._view32[((start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32)]!)
-		if (diff !== 0n) return null
-		return this._view8.subarray(start + this.HEADER_SIZE_BYTES, start + this.HEADER_SIZE_BYTES + Number(length))
+		const { start, generation } = this.translate(location);
+		const idx = this._idx32(start)
+		const currgen = BigInt(this._view32[idx + HEADERS.GENERATION_BYTE_0_32]!)
+
+		if (generation !== currgen) return null
+		if (this._view8[start + HEADERS.DELETED_8] === 1) return null
+
+		const dataLength = this._view32[idx + HEADERS.PAYLOAD_LENGTH_0_32]!;
+		return this._view8.subarray(start + this.HEADER_SIZE_BYTES, start + this.HEADER_SIZE_BYTES + dataLength);
 	}
 	public free(location: ArenaLocation): ArenaLocation {
-		let start = Number(BigInt(location as bigint) >> 32n)
-		const currgen = this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32]!
-		this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32] = currgen + 1 // this part can wrap around
-		this._view8[start + HEADERS.DELETED_8] = 1
-		const totalBlockSize = this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.TOTAL_LENGTH_0_32]!
+		const { start, generation: _ } = this.translate(location)
+		const idx = this._idx32(start)
+		const currgen = this._view32[idx + HEADERS.GENERATION_BYTE_0_32]!
+
+		this._view32[idx + HEADERS.GENERATION_BYTE_0_32] = currgen + 1
+		this._view8[this._u(start) + HEADERS.DELETED_8] = 1
+
+		const totalBlockSize = this._view32[this._idx32(start) + HEADERS.TOTAL_LENGTH_0_32]!
 		const bucketIdx = (totalBlockSize >> this._allignShift) - 1
 		if (bucketIdx >= 0 && bucketIdx < this._bucketcount) {
 			const count = this._getBucketCount(bucketIdx)
@@ -135,11 +161,11 @@ export class Arena {
 				this._setBucketCount(bucketIdx, count + 1);
 			}
 		}
-		return 0n as ArenaLocation
+		return this._makePtr(0, 0) as ArenaLocation
 	}
 
 	private _checkForSpace(size: number): boolean {
-		if (this._buffer.byteLength >= this._offset + size) return false
+		if (this._buffer.byteLength >= (this._offset + size)) return false
 		return true
 	}
 
@@ -149,45 +175,48 @@ export class Arena {
 		this._view8 = new Uint8Array(this._buffer)
 		this._view32 = new Uint32Array(this._buffer)
 	}
+
 	public size(): number {
 		return this._buffer.byteLength
 	}
+
 	public getBuffer(): Uint8Array {
-		return this._view8.subarray(0, this._offset)
+		return this._view8.subarray(0, this._u(this._offset))
 	}
 	public reserve(size: number): Uint8Array {
-		const start = this._offset
+		const start = this._u(this._offset)
 		this._checkForSpace(start + this.HEADER_SIZE_BYTES + size + this._allignMask & ~this._allignMask) && this._resize()
-		this._initBlock(start, size, {})
-		this._offset = this._offset + size + this.HEADER_SIZE_BYTES + this._allignMask & ~this._allignMask
+		this._initBlock(start, size, { header0: 0, header1: 0, header2: 0 })
+		this._offset = (this._offset + size + this.HEADER_SIZE_BYTES + this._allignMask & ~this._allignMask) >>> 0
 		return this._view8.subarray(start + this.HEADER_SIZE_BYTES, start + this.HEADER_SIZE_BYTES + size)
 	}
 	public translate(ptr: ArenaLocation) {
-		let start = Number(BigInt(ptr as bigint) >> 32n)
-		const generation = BigInt(this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32]!)
+		const start = this._getOffset(ptr)
+		const generation = ptr & 0xFFFFFFFFn;
 		return { start, generation }
 	}
 	public readWithHeaders(ptr: ArenaLocation): Uint8Array | null {
-		let start = Number(BigInt(ptr as bigint) >> 32n)
-		const generation = BigInt(ptr as bigint) & 0xFFFFFFFFn
-		let length = this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.PAYLOAD_LENGTH_0_32]!
-		const diff = generation ^ BigInt(this._view32[((start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32)]!)
-		if (diff !== 0n) return null
+		const { start, generation } = this.translate(ptr)
+		let idx32 = this._idx32(start)
+		let length = this._view32[idx32 + HEADERS.PAYLOAD_LENGTH_0_32]!
+		if (BigInt(this._view32[idx32 + HEADERS.GENERATION_BYTE_0_32]!) !== generation) return null
 		return this._view8.subarray(start + 12, start + this.HEADER_SIZE_BYTES + Number(length))
 	}
 	public label(): Array<ArenaLocation> {
 		const ptrArray = new Array<ArenaLocation>()
 		const limit = this._offset;
 		let pos = 0
-		while (pos < limit) {
-			const totalLength = this._view32[pos >> SHIFTOFFSETS.BYTE_32]!;
+		while (this._u(pos) < this._u(limit)) {
+			const totalLength = this._view32[this._idx32(pos)]!;
 			if (totalLength === 0) {
-				pos = (pos + 16) & ~15
+				pos = this._idx32((pos + 16) & ~15)
 				continue;
 			}
-			const isDeleted = this._view8[pos + HEADERS.DELETED_8] === 1
+			const isDeleted = this._view8[this._u(pos) + HEADERS.DELETED_8] === 1
 			if (!isDeleted) {
-				ptrArray.push(((BigInt(pos) << 32n) | BigInt(this._view32[(pos >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32]!)) as ArenaLocation);
+				ptrArray.push(
+					this._makePtr(pos, this._view32[this._idx32(pos) + HEADERS.GENERATION_BYTE_0_32]!)
+				);
 			}
 			pos += totalLength
 			if (totalLength === 0) break;
@@ -195,20 +224,54 @@ export class Arena {
 		return ptrArray
 	}
 	public getHeaders(ptr: ArenaLocation): ArenaHeaders {
-		let start = Number(BigInt(ptr as bigint) >> 32n)
+		const { start, generation: _ } = this.translate(ptr)
+		const idx = this._u(start)
 		return {
-			totalLength: Number(this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.TOTAL_LENGTH_0_32]!.toString()),
-			payloadlength: Number(this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.PAYLOAD_LENGTH_0_32]!.toString()),
-			deleted: this._view8[start + HEADERS.DELETED_8] === 1,
-			header0: Number(this._view8[start + HEADERS.USER_STATUS_0_8]!.toString()),
-			header1: Number(this._view8[start + HEADERS.USER_STATUS_1_8]!.toString()),
-			header2: Number(this._view8[start + HEADERS.USER_STATUS_2_8]!.toString()),
+			totalLength: Number(this._view32[this._idx32(start) + HEADERS.TOTAL_LENGTH_0_32]!.toString()),
+			payloadlength: Number(this._view32[this._idx32(start) + HEADERS.PAYLOAD_LENGTH_0_32]!.toString()),
+			deleted: this._view8[idx + HEADERS.DELETED_8] === 1,
+			header0: Number(this._view8[idx + HEADERS.USER_STATUS_0_8]!.toString()),
+			header1: Number(this._view8[idx + HEADERS.USER_STATUS_1_8]!.toString()),
+			header2: Number(this._view8[idx + HEADERS.USER_STATUS_2_8]!.toString()),
 		}
 	}
 	public estimate(size: number, amnt: number): number {
 		return (((size + this._allignMask) & ~this._allignMask) + this.HEADER_SIZE_BYTES) * amnt
 	}
-}
-
+	public directAlloc(source: Uint8Array, startn: number, endn: number) {
+		const start = this._u(this._offset)
+		const len = endn - startn;
+		const needed = (len + this.HEADER_SIZE_BYTES + this._allignMask) & ~this._allignMask;
+		const bucketIdx = (needed >> this._allignShift) - 1;
+		if (bucketIdx >= 0 && bucketIdx < this._bucketcount) {
+			const count = this._getBucketCount(bucketIdx);
+			if (count > 0) {
+				const recycledOffset = this._u(this._getBucketOffset(bucketIdx, count - 1));
+				this._setBucketCount(bucketIdx, count - 1);
+				this._initBlock(recycledOffset, needed, { header0: 0, header1: 0, header2: 0 });
+				const gen = this._view32[this._idx32(recycledOffset) + HEADERS.GENERATION_BYTE_0_32]!;
+				this._view8.set(source.subarray(startn, endn), recycledOffset + this.HEADER_SIZE_BYTES)
+				return this._makePtr(recycledOffset, gen)
+			}
+		}
+		if (this._checkForSpace(needed)) this._resize()
+		this._initBlock(start, len, { header0: 0, header1: 0, header2: 0 });
+		this._offset = this._u((start + needed) & ~this._allignMask);
+		this._view8.set(source.subarray(startn, endn), start + this.HEADER_SIZE_BYTES)
+		const gen = this._view32[this._idx32(start) + HEADERS.GENERATION_BYTE_0_32]!
+		return this._makePtr(start, gen)
 
+		// if (this._checkForSpace(needed)) this._resize()
+		// this._initBlock(start, needed, { header0: 0, header1: 0, header2: 0 })
+		// this._view8.set(source.subarray(startn, endn), start + this.HEADER_SIZE_BYTES)
+		// this._offset = this._u((start + needed) & ~this._allignMask);
+		//
+		// const gen = this._view32[this._idx32(start) + HEADERS.GENERATION_BYTE_0_32]!
+		// return this._makePtr(start, gen)
 
+	}
+	public clear() {
+		this._offset = 0
+		this._emptySpots.fill(0)
+	}
+}

package/bench/arena.ts

@@ -0,0 +1,75 @@
+import { pipeline } from "node:stream/promises";
+import { Arena } from "../arena";
+import { stream } from "./init.ts"
+
+
+let tmp: Uint8Array | null = null
+function getNewArenaTransform() {
+	return new WritableStream<Uint8Array>({
+		write(chunk) {
+			let sourceIdx = 0;
+			const chunkLen = chunk.byteLength;
+
+			if (tmp) {
+				const nextNewline = chunk.indexOf(10);
+				if (nextNewline !== -1) {
+					const totalLen = tmp.byteLength + nextNewline;
+					const target = new Uint8Array(totalLen)
+					target.set(tmp, 0);
+					target.set(chunk.subarray(0, nextNewline), tmp.byteLength);
+					arena.directAlloc(target, 0, target.length)
+					sourceIdx = nextNewline + 1;
+					tmp = null;
+				} else {
+					const newTmp = new Uint8Array(tmp.byteLength + chunkLen);
+					newTmp.set(tmp);
+					newTmp.set(chunk);
+					tmp = newTmp;
+					return;
+				}
+			}
+
+			// 2. Schnelle Schleife für den Rest des Chunks
+			while (true) {
+				const idx = chunk.indexOf(10, sourceIdx);
+				if (idx === -1) break;
+
+				const lineLength = idx - sourceIdx;
+				if (lineLength > 0) {
+					arena.directAlloc(chunk, 0, lineLength);
+				}
+				sourceIdx = idx + 1;
+			}
+
+			if (sourceIdx < chunkLen) {
+				tmp = chunk.slice(sourceIdx); // slice kopiert hier einmalig den Rest
+			}
+		},
+		close() {
+			if (tmp) {
+				arena.directAlloc(tmp, 0, tmp.length)
+				tmp = null
+			}
+		}
+	})
+};
+const arena = new Arena();
+(async () => {
+	const start = performance.now()
+	for (let i = 0; i < 10; i++) {
+		tmp = null
+		const arenatransform = getNewArenaTransform()
+		const reader = stream()
+
+		await pipeline(
+			reader,
+			arenatransform
+		)
+		const _ptr = arena.label()
+		arena.clear()
+	}
+	const end = performance.now()
+	console.log(`${(end - start).toFixed(2)} ms`)
+	console.log(process.memoryUsage())
+	console.log(`arenasize: ${arena.size() / 1024} KB`)
+})();

package/bench/array.ts

@@ -0,0 +1,61 @@
+import { pipeline } from "node:stream/promises";
+import { noopWriter, stream } from "./init.ts"
+
+const array: Array<string> = [];
+const decode = new TextDecoder()
+let tmp: Uint8Array | null = null // Rest vom vorherigen Chunk
+function getNewArrayTransformStream() {
+	return new WritableStream<Uint8Array>({
+		write(chunk) {
+			if (tmp) {
+				const combined = new Uint8Array(tmp.byteLength + chunk.byteLength)
+				combined.set(tmp, 0)
+				combined.set(chunk, tmp.byteLength)
+				chunk = combined
+				tmp = null
+			}
+
+			let firstIdx = 0
+			let idx: number
+
+			while ((idx = chunk.indexOf(10, firstIdx)) !== -1) {
+				const lineLength = idx - firstIdx
+				if (lineLength > 0) {
+					array.push(decode.decode(chunk.subarray(firstIdx, idx)!)!)
+				}
+				firstIdx = idx + 1
+			}
+
+			if (firstIdx < chunk.byteLength) {
+				tmp = chunk.subarray(firstIdx)
+			}
+		},
+		close() {
+			if (tmp) {
+				//@ts-ignore
+				array.push(tmp)
+				tmp = null
+			}
+		}
+	})
+};
+
+
+await (async () => {
+	const start = performance.now()
+	for (let i = 0; i < 100; i++) {
+		array.length = 0
+		tmp = null
+		const arraytransform = getNewArrayTransformStream()
+		const reader = stream()
+		await pipeline(
+			reader,
+			arraytransform,
+		)
+		for (const iter of array) noopWriter(iter)
+	}
+	const end = performance.now()
+	console.log(`${(end - start).toFixed(2)} ms`)
+	console.log(`Count: ${array.length}`)
+	console.log(process.memoryUsage())
+})();

package/bench/bench.md

@@ -0,0 +1,38 @@
+# Benchmark 1
+
+## bun arena.ts;
+183098.55 ms
+{
+  rss: 11240919040,
+  heapTotal: 8595075072,
+  heapUsed: 4817152633,
+  external: 2157456969,
+  arrayBuffers: 2156686216,
+}
+arenasize: 2097152 KB
+
+
+
+## bun array.ts
+765961.27 ms
+Count: 50000000
+{
+  rss: 28036014080,
+  heapTotal: 9476152320,
+  heapUsed: 11222438346,
+  external: 7170077276,
+  arrayBuffers: 2921230601,
+}
+
+--- 
+
+## Direct Comparison
+
+| Metric | Arena Implementation (Optimized) | Standard Array Implementation | Difference / Factor |
+| :--- | :--- | :--- | :--- |
+| **Total Time** | **183,098 ms** (3.05 min) | **765,961 ms** (12.76 min) | **~4.2x Faster** |
+| **Time per 50M Lines** | **~18.3 sec** | **~76.6 sec** | **- 58.3 sec / Round** |
+| **RAM Usage (RSS)** | **11.24 GB** | **28.04 GB** | **16.8 GB Saved** |
+| **Heap Used (JS Objects)** | **4.82 GB** | **11.22 GB** | **2.3x More Efficient** |
+| **External (Buffer)** | **2.16 GB** | **7.17 GB** | **Compact Memory Footprint** |
+

package/bench/generateTestdata.ts

@@ -0,0 +1,3 @@
+import { generateData } from "./init.ts"
+
+generateData(12345, 10_000_000)

package/bench/init.ts

@@ -0,0 +1,38 @@
+import { createWriteStream, createReadStream } from "node:fs";
+const testfile = "test3.txt"
+function splitmix32(a: number) {
+	return function() {
+		a |= 0; a = a + 0x9e3779b9 | 0;
+		let t = a ^ a >>> 16; t = Math.imul(t, 0x21f0aaad);
+		t = t ^ t >>> 15; t = Math.imul(t, 0x735a2d97);
+		return ((t = t ^ t >>> 15) >>> 0) / 4294967296;
+	}
+};
+
+export function noopWriter(_data: any) { return true; };
+
+async function generateTestData(seed: number, count: number) {
+	const writer = createWriteStream(testfile, { highWaterMark: 16 * 1024 * 1024 })
+	const random = splitmix32(seed)
+	const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+	for (let i = 0; i < count; i++) {
+		let str = '';
+		const len = Math.floor(random() * 5) + 10;
+		for (let j = 0; j < len; j++) {
+			str += characters.charAt(Math.floor(Math.random() * characters.length));
+		}
+		if (!writer.write(str + "\n")) {
+			await new Promise((res, _rej) => {
+				writer.once("drain", res)
+			})
+		}
+	}
+};
+
+export const stream = () => {
+	return createReadStream(testfile)
+};
+
+export function generateData(seed: number, count: number) {
+	generateTestData(seed, count);
+}

package/package.json

@@ -1,16 +1,37 @@
 {
   "name": "bumparena",
-  "version":"0.0.1",
+  "version":"0.0.5",
   "private": false,
   "type": "module",
   "main": "dist/arena.js",
   "module": "dist/arena.js",
   "types": "dist/arena.d.ts",
+  "license":"MIT",
   "scripts": {
     "build": "tsc",
     "test": "node ./dist/arena.js"
   },
+ "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eugen252009/bumparena.git"
+  },
   "devDependencies": {
     "@types/node": "^25.2.3"
-  }
+  },
+  "keywords": [
+	"arena",
+	"typescript",
+	"javascript",
+	"simulation",
+	"game-engine",
+	"algorithm",
+	"data-structure",
+	"buffer",
+	"uint8array",
+	"memory",
+	"testing",
+	"cjs",
+	"esm",
+	"library"
+]
 }

package/test/directAccess.ts

@@ -0,0 +1,28 @@
+import { Arena } from "../arena"
+
+export function TestDirectAlloc(): boolean {
+	//Init
+	const count = 255
+	const a = new Arena()
+	const testdata = new Array<Uint8Array>()
+	for (let i = 0; i < count; i++) {
+		const data = new Uint8Array([i, 1, 2, 3, 4, 5, 6, 7])
+		testdata.push(data)
+
+		a.directAlloc(data, 0, data.length)
+	}
+
+	const ptrs = a.label()
+	if (ptrs.length !== count) throw new Error(`Allocated wrong amount of items!: needed: ${count}, got: ${ptrs.length}`)
+
+	for (let i = 0; i < ptrs.length; i++) {
+		const buf = a.read(ptrs[i])
+		if (!buf) throw new Error(`data at index ${i} is Empty.`)
+
+		for (let j = 0; j < testdata.length; j++) {
+			if (buf[j] !== testdata[i][j]) throw new Error(`dataset ${i} at ${j} is broken!`)
+		}
+	}
+	return true
+}
+

package/test/{test.ts → ptrs.ts}

@@ -1,18 +1,12 @@
-import { Arena, ArenaCustomHeaders } from "../arena.ts"
+import { Arena } from "../arena"
 
-//Tests
-function Test() {
-	console.log("running Tests")
+
+export function TestCheckPtrAccess(): boolean {
+	//Init
 	const a = new Arena()
 	const testdata = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7])
 	const headers = { header0: 42, header1: 24, header2: 240 };
-	_testCheckPtrAccess(a, testdata, headers)
-}
 
-function _testCheckPtrAccess(a: Arena, testdata: Uint8Array, headers: ArenaCustomHeaders) {
-	// USE-AFTER-FREE
-	const useAfterFreePtr = a.alloc(testdata, headers)
-	a.free(useAfterFreePtr)
 	// free Slot reuse
 	const ptr = a.alloc(testdata, headers)
 	const res = a.read(ptr)
@@ -24,15 +18,20 @@ function _testCheckPtrAccess(a: Arena, testdata: Uint8Array, headers: ArenaCusto
 	if (resultheaders.header0 !== headers.header0) throw new Error(`header0: got: ${resultheaders.header0} needed: ${headers.header0}`)
 	if (resultheaders.header1 !== headers.header1) throw new Error(`header1: got: ${resultheaders.header1} needed: ${headers.header1}`)
 	if (resultheaders.header2 !== headers.header2) throw new Error(`header2: got: ${resultheaders.header2} needed: ${headers.header2}`)
+	if (res.toString() !== testdata.toString()) throw new Error(`${testdata} had a problem with data integrety`)
 
-	if (res.toString() !== testdata.toString()) {
-		throw new Error(`${testdata} had a problem with data integrety`)
-	}
-	//final use after free with Generation this should never be possible
-	if (a.read(useAfterFreePtr) !== null) {
-		throw new Error(`Use after Free is Possible, this is a big Problem`)
-	}
-	console.log("CheckPtrAccess Done!")
+	return true
 }
+export function TestUseAfterFree(): boolean {
+	//Init
+	const a = new Arena()
+	const testdata = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7])
 
-Test()
+	// USE-AFTER-FREE init
+	const useAfterFreePtr = a.alloc(testdata)
+	a.free(useAfterFreePtr)
+	//final use after free with Generation this should never be possible
+	if (a.read(useAfterFreePtr) !== null) throw new Error(`Use after Free is Possible, this is a big Problem`)
+
+	return true
+}

package/test/reserve.ts

@@ -0,0 +1,28 @@
+import { Arena } from "../arena"
+
+
+export function TestCheckReserve(): boolean {
+	//Init
+	const count = 1_000
+	const a = new Arena()
+	const testdata = new Array<Uint8Array>()
+	for (let i = 0; i < count; i++) {
+		const data = new Uint8Array([i, 1, 2, 3, 4, 5, 6, 7])
+		testdata.push(data)
+
+		const buf = a.reserve(data.byteLength)
+		buf.set(data)
+	}
+
+	const ptrs = a.label()
+
+	for (let i = 0; i < ptrs.length; i++) {
+		const buf = a.read(ptrs[i])
+		if (!buf) throw new Error(`reservation failed at item: ${i}`)
+		for (let j = 0; j < ptrs.length; j++) {
+			if (buf[j] !== testdata[i][j]) throw new Error(`reservation failed at item ${i}:${j}`)
+		}
+	}
+
+	return true
+}

package/test/test.test.ts

@@ -0,0 +1,12 @@
+import { describe, test } from "node:test"
+import { equal } from "node:assert"
+import { TestCheckPtrAccess, TestUseAfterFree } from "./ptrs.ts"
+import { TestCheckReserve } from "./reserve.ts"
+import { TestDirectAlloc } from "./directAccess.ts"
+
+describe("Arena Checks", () => {
+	test("Pointer Access", () => equal(TestCheckPtrAccess(), true, "Data corruption is possible!"))
+	test("Use after free", () => equal(TestUseAfterFree(), true, "Use after free is possible!"))
+	test("Test Reserving Data", () => equal(TestCheckReserve(), true, "Something with the reservation is not working properly"))
+	test("Test allocating data directly", () => equal(TestDirectAlloc(), true, "Direct alloc isnt working properly"))
+})