bumparena 0.0.1

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,34 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm run build
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Eugen252009
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,74 @@
+## High-Speed: Linear Bulk Import
+
+Use `reserve()` for high-volume, linear data ingestion. To guarantee maximum throughput and deterministic behavior, `reserve()` **always appends** memory at the end of the arena buffer. No compaction, no relocation, no surprises.
+
+This makes it ideal for tight loops, streaming parsers, and bulk loaders where predictable memory behavior is critical.
+
+---
+
+### Allocation Strategies
+
+#### Performance & GC Efficiency
+
+This Arena is explicitly designed to bypass the typical performance pitfalls of the V8 runtime:
+
+**GC Invisibility**  
+The entire arena is backed by a single `ArrayBuffer`. Since the Garbage Collector does not traverse raw buffer contents, this completely avoids costly mark-and-sweep scans over arena memory.
+
+**Zero Object Churn**  
+Data insertion does not allocate JavaScript objects. All writes are performed directly against the buffer. The engine reuses the same execution paths without producing heap garbage.
+
+**Deferred Management Overhead**  
+Logical pointers (`ArenaLocation`, implemented as `BigInt`) are created *only* when `label()` is invoked. This keeps pointer bookkeeping out of performance-critical hot paths.
+
+---
+
+### Technical Architecture
+
+#### Memory Layout (16-Byte Header)
+
+Each allocation block is prefixed with a fixed-size metadata header:
+
+- Size  
+- Generation ID  
+- Flags / reserved space  
+
+`reserve()` eagerly initializes these headers to ensure full compatibility with `read()` and `label()` without requiring additional bookkeeping passes.
+
+This guarantees **O(1)** access and validation at read time.
+
+---
+
+#### Pointer Security & Validation
+
+An `ArenaLocation` is encoded as a **64-bit BigInt**:
+
+- **High 32 bits** → Physical byte offset inside the arena  
+- **Low 32 bits** → Generation ID  
+
+When `read()` is called, the arena validates the pointer by comparing its generation ID with the one stored in the block header:
+
+- ✅ Match → valid, data is returned  
+- ❌ Mismatch → block was freed or recycled → `null` is returned  
+
+This provides **use-after-free protection** without reference tracking, weak maps, or GC involvement.
+
+---
+
+### 📖 Documentation & Tests
+
+The integrated test suite doubles as a **reference implementation**.  
+See the `// --- SHOWCASE & TESTS ---` section at the end of the source file for:
+
+- Stress tests for dynamic resizing  
+- Validation of pointer expiration semantics  
+- Advanced bucket reuse and fragmentation behavior  
+- Edge cases around generation rollover  
+
+To run the showcase directly, execute the file with Node.js. No external dependencies required.
+
+---
+
+### ⚖️ License
+
+MIT License — use freely in commercial and non-commercial projects.

package/arena.ts

@@ -0,0 +1,214 @@
+export type ArenaLocation = bigint & { readonly __data_pointer: unique symbol };
+export interface ArenaOptions {
+	initalSize?: number
+	littleEndian?: boolean
+	allignment?: 8 | 16 | 32 | 64
+	bucketOffsets?: number[];
+	bucketCapacities?: number[];
+}
+export interface ArenaCustomHeaders {
+	header0: number,
+	header1: number,
+	header2: number
+}
+export interface ArenaHeaders {
+	totalLength: number
+	payloadlength: number
+	deleted: boolean
+	header0: number
+	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,
+	GENERATION_BYTE_0_32 = 2,
+	DELETED_8 = 12,
+	USER_STATUS_0_8 = 13,
+	USER_STATUS_1_8 = 14,
+	USER_STATUS_2_8 = 15,
+}
+
+export class Arena {
+	private HEADER_SIZE_BYTES = 16
+	private _buffer: ArrayBuffer
+	private _view8: Uint8Array
+	private _view32: Uint32Array
+	private _offset: number
+	private _emptySpots: Uint32Array
+	private _allignMask: 7 | 15 | 31 | 63
+	private _allignShift: number
+	private _bucketOffsets: number[];
+	private _bucketCapacities: number[];
+	private _bucketcount: number;
+
+	constructor(options?: ArenaOptions) {
+		this._buffer = new ArrayBuffer(options?.initalSize || 64 * 1024)
+		this._view8 = new Uint8Array(this._buffer);
+		this._view32 = new Uint32Array(this._buffer)
+		this._offset = 0;
+		//@ts-ignore
+		this._allignMask = ((options?.allignment || 8) - 1!) as number
+		this._allignShift = Math.log2(this._allignMask + 1);
+		this._bucketCapacities = options?.bucketCapacities || [1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024]
+		this._bucketOffsets = [];
+		this._bucketcount = this._bucketCapacities.length;
+		let currentOffset = 0;
+		for (const cap of this._bucketCapacities) {
+			this._bucketOffsets.push(currentOffset)
+			currentOffset += (cap + 1)
+		}
+		this._emptySpots = new Uint32Array(currentOffset)
+	}
+	private _getBucketCount(bucketIdx: number): number {
+		return this._emptySpots[this._bucketOffsets[bucketIdx]!]!;
+	}
+
+	private _setBucketCount(bucketIdx: number, count: number): void {
+		this._emptySpots[this._bucketOffsets[bucketIdx]!] = count;
+	}
+
+	private _getBucketOffset(bucketIdx: number, slotIdx: number): number {
+		return this._emptySpots[this._bucketOffsets[bucketIdx]! + slotIdx + 1]!;
+	}
+
+	private _setBucketOffset(bucketIdx: number, slotIdx: number, offset: number): void {
+		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
+	}
+
+	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;
+		if (bucketIdx >= 0 && bucketIdx < this._bucketcount) {
+			const count = this._getBucketCount(bucketIdx);
+			if (count > 0) {
+				const recycledOffset = 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 start = this._offset
+		this._checkForSpace(data.byteLength + this.HEADER_SIZE_BYTES) && 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
+	}
+	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))
+	}
+	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 bucketIdx = (totalBlockSize >> this._allignShift) - 1
+		if (bucketIdx >= 0 && bucketIdx < this._bucketcount) {
+			const count = this._getBucketCount(bucketIdx)
+			const capacity = this._bucketCapacities[bucketIdx]!
+			if (count < capacity) {
+				this._setBucketOffset(bucketIdx, count, start);
+				this._setBucketCount(bucketIdx, count + 1);
+			}
+		}
+		return 0n as ArenaLocation
+	}
+
+	private _checkForSpace(size: number): boolean {
+		if (this._buffer.byteLength >= this._offset + size) return false
+		return true
+	}
+
+	private _resize() {
+		//@ts-ignore
+		this._buffer = this._buffer.transfer(this._buffer.byteLength * 2)
+		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)
+	}
+	public reserve(size: number): Uint8Array {
+		const start = 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
+		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]!)
+		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
+		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]!;
+			if (totalLength === 0) {
+				pos = (pos + 16) & ~15
+				continue;
+			}
+			const isDeleted = this._view8[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);
+			}
+			pos += totalLength
+			if (totalLength === 0) break;
+		}
+		return ptrArray
+	}
+	public getHeaders(ptr: ArenaLocation): ArenaHeaders {
+		let start = Number(BigInt(ptr as bigint) >> 32n)
+		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()),
+		}
+	}
+	public estimate(size: number, amnt: number): number {
+		return (((size + this._allignMask) & ~this._allignMask) + this.HEADER_SIZE_BYTES) * amnt
+	}
+}
+
+
+

package/dist/arena.d.ts

@@ -0,0 +1,58 @@
+export type ArenaLocation = bigint & {
+    readonly __data_pointer: unique symbol;
+};
+export interface ArenaOptions {
+    initalSize?: number;
+    littleEndian?: boolean;
+    allignment?: 8 | 16 | 32 | 64;
+    bucketOffsets?: number[];
+    bucketCapacities?: number[];
+}
+export interface ArenaCustomHeaders {
+    header0: number;
+    header1: number;
+    header2: number;
+}
+export interface ArenaHeaders {
+    totalLength: number;
+    payloadlength: number;
+    deleted: boolean;
+    header0: number;
+    header1: number;
+    header2: number;
+}
+export declare class Arena {
+    private HEADER_SIZE_BYTES;
+    private _buffer;
+    private _view8;
+    private _view32;
+    private _offset;
+    private _emptySpots;
+    private _allignMask;
+    private _allignShift;
+    private _bucketOffsets;
+    private _bucketCapacities;
+    private _bucketcount;
+    constructor(options?: ArenaOptions);
+    private _getBucketCount;
+    private _setBucketCount;
+    private _getBucketOffset;
+    private _setBucketOffset;
+    private _initBlock;
+    alloc(data: Uint8Array, headers?: ArenaCustomHeaders): ArenaLocation;
+    read(location: ArenaLocation): Uint8Array | null;
+    free(location: ArenaLocation): ArenaLocation;
+    private _checkForSpace;
+    private _resize;
+    size(): number;
+    getBuffer(): Uint8Array;
+    reserve(size: number): Uint8Array;
+    translate(ptr: ArenaLocation): {
+        start: number;
+        generation: bigint;
+    };
+    readWithHeaders(ptr: ArenaLocation): Uint8Array | null;
+    label(): Array<ArenaLocation>;
+    getHeaders(ptr: ArenaLocation): ArenaHeaders;
+    estimate(size: number, amnt: number): number;
+}

package/dist/arena.js

@@ -0,0 +1,178 @@
+var SHIFTOFFSETS;
+(function (SHIFTOFFSETS) {
+    SHIFTOFFSETS[SHIFTOFFSETS["BYTE_8"] = 0] = "BYTE_8";
+    SHIFTOFFSETS[SHIFTOFFSETS["BYTE_16"] = 1] = "BYTE_16";
+    SHIFTOFFSETS[SHIFTOFFSETS["BYTE_32"] = 2] = "BYTE_32";
+    SHIFTOFFSETS[SHIFTOFFSETS["BYTE_64"] = 3] = "BYTE_64";
+})(SHIFTOFFSETS || (SHIFTOFFSETS = {}));
+var HEADERS;
+(function (HEADERS) {
+    HEADERS[HEADERS["TOTAL_LENGTH_0_32"] = 0] = "TOTAL_LENGTH_0_32";
+    HEADERS[HEADERS["PAYLOAD_LENGTH_0_32"] = 1] = "PAYLOAD_LENGTH_0_32";
+    HEADERS[HEADERS["GENERATION_BYTE_0_32"] = 2] = "GENERATION_BYTE_0_32";
+    HEADERS[HEADERS["DELETED_8"] = 12] = "DELETED_8";
+    HEADERS[HEADERS["USER_STATUS_0_8"] = 13] = "USER_STATUS_0_8";
+    HEADERS[HEADERS["USER_STATUS_1_8"] = 14] = "USER_STATUS_1_8";
+    HEADERS[HEADERS["USER_STATUS_2_8"] = 15] = "USER_STATUS_2_8";
+})(HEADERS || (HEADERS = {}));
+export class Arena {
+    constructor(options) {
+        this.HEADER_SIZE_BYTES = 16;
+        this._buffer = new ArrayBuffer(options?.initalSize || 64 * 1024);
+        this._view8 = new Uint8Array(this._buffer);
+        this._view32 = new Uint32Array(this._buffer);
+        this._offset = 0;
+        //@ts-ignore
+        this._allignMask = ((options?.allignment || 8) - 1);
+        this._allignShift = Math.log2(this._allignMask + 1);
+        this._bucketCapacities = options?.bucketCapacities || [1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024];
+        this._bucketOffsets = [];
+        this._bucketcount = this._bucketCapacities.length;
+        let currentOffset = 0;
+        for (const cap of this._bucketCapacities) {
+            this._bucketOffsets.push(currentOffset);
+            currentOffset += (cap + 1);
+        }
+        this._emptySpots = new Uint32Array(currentOffset);
+    }
+    _getBucketCount(bucketIdx) {
+        return this._emptySpots[this._bucketOffsets[bucketIdx]];
+    }
+    _setBucketCount(bucketIdx, count) {
+        this._emptySpots[this._bucketOffsets[bucketIdx]] = count;
+    }
+    _getBucketOffset(bucketIdx, slotIdx) {
+        return this._emptySpots[this._bucketOffsets[bucketIdx] + slotIdx + 1];
+    }
+    _setBucketOffset(bucketIdx, slotIdx, offset) {
+        this._emptySpots[this._bucketOffsets[bucketIdx] + slotIdx + 1] = offset;
+    }
+    _initBlock(start, dataLength, { header0, header1, header2 }) {
+        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;
+    }
+    alloc(data, headers) {
+        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;
+        if (bucketIdx >= 0 && bucketIdx < this._bucketcount) {
+            const count = this._getBucketCount(bucketIdx);
+            if (count > 0) {
+                const recycledOffset = 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]));
+            }
+        }
+        const start = this._offset;
+        this._checkForSpace(data.byteLength + this.HEADER_SIZE_BYTES) && 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]));
+    }
+    read(location) {
+        let start = Number(BigInt(location) >> 32n);
+        const generation = BigInt(location) & 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));
+    }
+    free(location) {
+        let start = Number(BigInt(location) >> 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 bucketIdx = (totalBlockSize >> this._allignShift) - 1;
+        if (bucketIdx >= 0 && bucketIdx < this._bucketcount) {
+            const count = this._getBucketCount(bucketIdx);
+            const capacity = this._bucketCapacities[bucketIdx];
+            if (count < capacity) {
+                this._setBucketOffset(bucketIdx, count, start);
+                this._setBucketCount(bucketIdx, count + 1);
+            }
+        }
+        return 0n;
+    }
+    _checkForSpace(size) {
+        if (this._buffer.byteLength >= this._offset + size)
+            return false;
+        return true;
+    }
+    _resize() {
+        //@ts-ignore
+        this._buffer = this._buffer.transfer(this._buffer.byteLength * 2);
+        this._view8 = new Uint8Array(this._buffer);
+        this._view32 = new Uint32Array(this._buffer);
+    }
+    size() {
+        return this._buffer.byteLength;
+    }
+    getBuffer() {
+        return this._view8.subarray(0, this._offset);
+    }
+    reserve(size) {
+        const start = 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;
+        return this._view8.subarray(start + this.HEADER_SIZE_BYTES, start + this.HEADER_SIZE_BYTES + size);
+    }
+    translate(ptr) {
+        let start = Number(BigInt(ptr) >> 32n);
+        const generation = BigInt(this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32]);
+        return { start, generation };
+    }
+    readWithHeaders(ptr) {
+        let start = Number(BigInt(ptr) >> 32n);
+        const generation = BigInt(ptr) & 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 + 12, start + this.HEADER_SIZE_BYTES + Number(length));
+    }
+    label() {
+        const ptrArray = new Array();
+        const limit = this._offset;
+        let pos = 0;
+        while (pos < limit) {
+            const totalLength = this._view32[pos >> SHIFTOFFSETS.BYTE_32];
+            if (totalLength === 0) {
+                pos = (pos + 16) & ~15;
+                continue;
+            }
+            const isDeleted = this._view8[pos + HEADERS.DELETED_8] === 1;
+            if (!isDeleted) {
+                ptrArray.push(((BigInt(pos) << 32n) | BigInt(this._view32[(pos >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32])));
+            }
+            pos += totalLength;
+            if (totalLength === 0)
+                break;
+        }
+        return ptrArray;
+    }
+    getHeaders(ptr) {
+        let start = Number(BigInt(ptr) >> 32n);
+        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()),
+        };
+    }
+    estimate(size, amnt) {
+        return (((size + this._allignMask) & ~this._allignMask) + this.HEADER_SIZE_BYTES) * amnt;
+    }
+}

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "bumparena",
+  "version":"0.0.1",
+  "private": false,
+  "type": "module",
+  "main": "dist/arena.js",
+  "module": "dist/arena.js",
+  "types": "dist/arena.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "node ./dist/arena.js"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3"
+  }
+}

package/test/test.ts

@@ -0,0 +1,38 @@
+import { Arena, ArenaCustomHeaders } from "../arena.ts"
+
+//Tests
+function Test() {
+	console.log("running Tests")
+	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)
+	if (res == null) throw new Error(`${testdata} Could not read data`)
+	const resultheaders = a.getHeaders(ptr)
+
+	if (resultheaders.totalLength !== testdata.byteLength + 16) throw new Error(`totalLength not right: got: ${resultheaders.totalLength} needed: ${testdata.byteLength}`)
+	if (resultheaders.payloadlength !== testdata.byteLength) throw new Error(`payloadLength not right: got: ${resultheaders.payloadlength} needed: ${testdata.byteLength}`)
+	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`)
+	}
+	//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!")
+}
+
+Test()

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "lib": ["ES2020"],
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowJs": true,
+    "verbatimModuleSyntax": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // für Build / .d.ts:
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "outDir": "dist"
+  },
+  "include": ["arena.ts"]
+}