@daneren2005/shared-memory-objects 1.6.0 → 1.6.1

package/dist/shared-map.d.ts

@@ -9,6 +9,7 @@ export default class SharedMap<K extends string | number, V extends NumericArray
     private lock;
     private cachedType;
     private cachedValueUnits;
+    private readonly maxTableCapacity;
     private cachedTablePointer;
     private cachedTableMemory?;
     private cachedSlots?;
@@ -28,6 +29,8 @@ export default class SharedMap<K extends string | number, V extends NumericArray
     setAll(entries: Iterable<readonly [K, V[number]]>): void;
     private setNoLock;
     update(key: K, updater: (current: V[number] | undefined) => V[number]): V[number];
+    private resizeForInsert;
+    private reuseTombstone;
     get(key: K): V[number] | undefined;
     getAll(keys: Iterable<K>): Array<V[number] | undefined>;
     private getNoLock;

package/dist/shared-map.js

@@ -12,6 +12,7 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 	lock;
 	cachedType;
 	cachedValueUnits = 1;
+	maxTableCapacity;
 	cachedTablePointer = 0;
 	cachedTableMemory;
 	cachedSlots;
@@ -54,7 +55,7 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 		this.memory = e, t && "firstBlock" in t ? t.firstBlock instanceof n ? (this.pointerMemory = t.firstBlock, this.initialize(t), this.ownsFirstBlock = !1) : this.pointerMemory = new n(e, {
 			length: S.ALLOCATE_COUNT,
 			...t.firstBlock
-		}) : (this.pointerMemory = e.allocUI32(S.ALLOCATE_COUNT), this.initialize(t)), this.lock = new Int32Array(this.pointerMemory.data.buffer, this.pointerMemory.bufferByteOffset + _ * Uint32Array.BYTES_PER_ELEMENT, 1), this.cachedType = Atomics.load(this.pointerMemory.data, x), this.cachedValueUnits = i(this.cachedType);
+		}) : (this.pointerMemory = e.allocUI32(S.ALLOCATE_COUNT), this.initialize(t)), this.lock = new Int32Array(this.pointerMemory.data.buffer, this.pointerMemory.bufferByteOffset + _ * Uint32Array.BYTES_PER_ELEMENT, 1), this.cachedType = Atomics.load(this.pointerMemory.data, x), this.cachedValueUnits = i(this.cachedType), this.maxTableCapacity = 2 ** Math.floor(Math.log2(this.memory.maxAllocationLength / (2 + this.cachedValueUnits)));
 	}
 	initialize(e) {
 		let n = e && "type" in e ? e.type : void 0, a = r(n ?? Uint32Array);
@@ -80,8 +81,8 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 			let e = this.pointerMemory.data, n = e[v] + e[y] + t.length;
 			if (n * h > e[b] * m) {
 				let t = e[b];
-				for (; n * h > t * m;) t *= 2;
-				this.resize(t);
+				for (; n * h > t * m && t < this.maxTableCapacity;) t *= 2;
+				t > e[b] && this.resize(t);
 			}
 			for (let [e, n] of t) this.setNoLock(e, n);
 		} finally {
@@ -90,7 +91,7 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 	}
 	setNoLock(e, t) {
 		let n = c(e), r = this.pointerMemory.data;
-		(r[v] + r[y] + 1) * h > r[b] * m && this.resize(), this.ensureTable();
+		(r[v] + r[y] + 1) * h > r[b] * m && this.resizeForInsert(e), this.ensureTable();
 		let i = this.cachedSlots, a = this.cachedValues, o = this.cachedCapacity, s = o - 1, p = o, g = l(n) & s, _ = -1;
 		for (;;) {
 			let e = i[g];
@@ -99,8 +100,13 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 				i[e] = d, i[p + e] = n, a[e] = t, r[v]++, _ >= 0 && r[y]--;
 				return;
 			}
-			if (e === f) _ < 0 && (_ = g);
-			else if (i[p + g] === n) {
+			if (e === f) {
+				if (_ < 0) _ = g;
+				else if (g === _) {
+					this.reuseTombstone(g, n, t);
+					return;
+				}
+			} else if (i[p + g] === n) {
 				a[g] = t;
 				return;
 			}
@@ -111,26 +117,37 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 		let n = c(e);
 		o(this.lock);
 		try {
-			let e = this.pointerMemory.data;
-			(e[v] + e[y] + 1) * h > e[b] * m && this.resize(), this.ensureTable();
-			let r = this.cachedSlots, i = this.cachedValues, a = this.cachedCapacity, o = a - 1, s = a, c = l(n) & o, p = -1;
+			let r = this.pointerMemory.data;
+			(r[v] + r[y] + 1) * h > r[b] * m && this.resizeForInsert(e), this.ensureTable();
+			let i = this.cachedSlots, a = this.cachedValues, o = this.cachedCapacity, s = o - 1, c = l(n) & s, p = -1;
 			for (;;) {
-				let a = r[c];
-				if (a === u) {
-					let a = t(void 0), o = p >= 0 ? p : c;
-					return r[o] = d, r[s + o] = n, i[o] = a, e[v]++, p >= 0 && e[y]--, a;
+				let e = i[c];
+				if (e === u) {
+					let e = t(void 0), s = p >= 0 ? p : c;
+					return i[s] = d, i[o + s] = n, a[s] = e, r[v]++, p >= 0 && r[y]--, e;
 				}
-				if (a === f) p < 0 && (p = c);
-				else if (r[s + c] === n) {
-					let e = t(i[c]);
-					return i[c] = e, e;
+				if (e === f) {
+					if (c === p) return this.reuseTombstone(c, n, t);
+					p < 0 && (p = c);
+				} else if (i[o + c] === n) {
+					let e = t(a[c]);
+					return a[c] = e, e;
 				}
-				c = c + 1 & o;
+				c = c + 1 & s;
 			}
 		} finally {
 			s(this.lock);
 		}
 	}
+	resizeForInsert(e) {
+		let t = this.pointerMemory.data[v], n = this.pointerMemory.data[b];
+		if (n < this.maxTableCapacity || (t + 1) * h <= n * m) this.resize();
+		else if (t === n && this.getNoLock(e) === void 0) throw Error(`SharedMap is full at capacity ${n}: a larger table would exceed the largest contiguous allocation. Use larger buffers or shard across multiple maps.`);
+	}
+	reuseTombstone(e, t, n) {
+		let r = typeof n == "function" ? n(void 0) : n, i = this.cachedSlots, a = this.cachedValues;
+		return i[e] = d, i[this.cachedCapacity + e] = t, a[e] = r, this.pointerMemory.data[v]++, this.pointerMemory.data[y]--, r;
+	}
 	get(e) {
 		o(this.lock);
 		try {
@@ -152,13 +169,13 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 	getNoLock(e) {
 		let t = c(e);
 		this.ensureTable();
-		let n = this.cachedSlots, r = this.cachedValues, i = this.cachedCapacity, a = i - 1, o = i, s = l(t) & a;
-		for (;;) {
+		let n = this.cachedSlots, r = this.cachedValues, i = this.cachedCapacity, a = i - 1, o = i, s = l(t) & a, f = s;
+		do {
 			let e = n[s];
 			if (e === u) return;
 			if (e === d && n[o + s] === t) return r[s];
 			s = s + 1 & a;
-		}
+		} while (s !== f);
 	}
 	has(e) {
 		return this.get(e) !== void 0;
@@ -168,13 +185,14 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 		o(this.lock);
 		try {
 			this.ensureTable();
-			let e = this.pointerMemory.data, n = this.cachedSlots, r = this.cachedCapacity, i = r - 1, a = r, o = l(t) & i;
-			for (;;) {
+			let e = this.pointerMemory.data, n = this.cachedSlots, r = this.cachedCapacity, i = r - 1, a = r, o = l(t) & i, s = o;
+			do {
 				let r = n[o];
 				if (r === u) return !1;
 				if (r === d && n[a + o] === t) return n[o] = f, e[v]--, e[y]++, !0;
 				o = o + 1 & i;
-			}
+			} while (o !== s);
+			return !1;
 		} finally {
 			s(this.lock);
 		}

package/dist/shared-map.js.map

@@ -1 +1 @@
-{"version":3,"file":"shared-map.js","names":[],"sources":["../src/shared-map.ts"],"sourcesContent":["import AllocatedMemory, { type SharedAllocatedMemory } from './allocated-memory';\nimport type MemoryHeap from './memory-heap';\nimport { getPointer, storeRawPointer } from './utils/pointer';\nimport { get32BitHash, mix32 } from './utils/hash';\nimport { lock, unlock, SIMPLE_LOCK_ALLOCATE_COUNT } from './lock/simple-lock';\nimport { getArrayTypeCode, getByteMultipler, makeArrayView, type NumericArray, type NumericArrayIO, type TypedArrayConstructor } from './utils/array-type';\n\n// Open-addressing hash map with linear probing, held in one contiguous table (no per-bucket lists, no per-operation\n// allocation). A single exclusive lock guards the table so slot reads/writes inside the critical section can be plain\n// memory access instead of per-slot Atomics; the lock's acquire/release provides the cross-thread happens-before.\n//\n// The table uses a Structure-of-Arrays layout: three contiguous regions - states | keys | values - so probing touches\n// the dense states and keys regions (more candidates per cache line) and iteration walks values densely. capacity is\n// always a power of two, so slot = mix(key) & (capacity - 1). state distinguishes EMPTY/FULL/TOMBSTONE, so key 0 and\n// value 0 need no sentinel.\n//\n// Keys are always stored as the 32-bit hash (a numeric key is its own hash); values are stored in the typed array the\n// map was created with (Uint32Array by default, or Int32Array / Float32Array). Iteration is a best-effort scan that is\n// not lock-guarded, so it must not run concurrently with mutation from another thread. A single allocation can't span\n// buffers, so the table is bounded by MemoryHeap.maxAllocationLength.\n\nconst EMPTY = 0;\nconst FULL = 1;\nconst TOMBSTONE = 2;\n\nconst DEFAULT_CAPACITY = 16;\n// Grow when (occupied + tombstones) / capacity exceeds this. Kept as a fraction to avoid floating point in the hot path.\nconst LOAD_NUMERATOR = 3;\nconst LOAD_DENOMINATOR = 4;\n\n// Metadata block layout (pointerMemory)\nconst TABLE_POINTER_INDEX = 0;\nconst LOCK_INDEX = 1;\nconst LENGTH_INDEX = 2;\nconst TOMBSTONE_INDEX = 3;\nconst CAPACITY_INDEX = 4;\nconst TYPE_INDEX = 5;\n\nexport default class SharedMap<K extends string | number, V extends NumericArray = Uint32Array> {\n\tstatic readonly ALLOCATE_COUNT = 6;\n\n\tprivate memory: MemoryHeap;\n\tprivate pointerMemory: AllocatedMemory;\n\t// False when pointerMemory is a slice of another structure's memory (e.g. inlined in SharedQuadtree); that owner frees it\n\tprivate ownsFirstBlock = true;\n\tprivate lock: Int32Array;\n\t// Value type is written once at creation and never changes, so resolve it once instead of reading metadata per op\n\tprivate cachedType: number;\n\t// u32 units per value slot: 1 for 32-bit types, 2 for 64-bit (float64/int64/uint64). The values region and every\n\t// table allocation scale by this.\n\tprivate cachedValueUnits = 1;\n\n\t// Cache the resolved views so most operations avoid rebuilding them. Rebuild whenever the table pointer OR the capacity\n\t// changes: the pointer alone is not enough because the allocator recycles freed addresses (split:false), so a rehash can\n\t// land a differently-sized table at the same address (ABA). The cached views are plain windows into shared memory, so\n\t// they always reflect the current bytes at that address; only the derived capacity (mask/offsets) can go stale, and the\n\t// capacity check catches exactly that.\n\tprivate cachedTablePointer = 0;\n\tprivate cachedTableMemory?: AllocatedMemory;\n\tprivate cachedSlots?: Uint32Array; // whole block as u32: states region, then keys region\n\tprivate cachedValues?: V; // typed view over the values region\n\tprivate cachedCapacity = 0;\n\t// Callers hold the lock, so the acquire fence already published the latest pointer/capacity - plain reads are enough\n\t// and avoid two Atomics.load per operation on the hot path.\n\tprivate ensureTable() {\n\t\tlet data = this.pointerMemory.data;\n\t\tlet pointer = data[TABLE_POINTER_INDEX];\n\t\tlet capacity = data[CAPACITY_INDEX];\n\t\tif(pointer === this.cachedTablePointer && capacity === this.cachedCapacity && this.cachedSlots) {\n\t\t\treturn;\n\t\t}\n\n\t\tlet table = new AllocatedMemory(this.memory, getPointer(pointer, this.memory.positionBits));\n\t\tthis.cachedTableMemory = table;\n\t\tthis.cachedSlots = table.data;\n\t\tthis.cachedValues = this.makeValuesView(table, capacity);\n\t\tthis.cachedCapacity = capacity;\n\t\tthis.cachedTablePointer = pointer;\n\t}\n\tprivate makeValuesView(table: AllocatedMemory, capacity: number): V {\n\t\t// states and keys each take one u32 per slot, so the values region starts after 2 * capacity u32s\n\t\tlet byteOffset = table.bufferByteOffset + capacity * 2 * Uint32Array.BYTES_PER_ELEMENT;\n\t\treturn makeArrayView(this.cachedType, table.data.buffer, byteOffset, capacity) as V;\n\t}\n\t// u32s a table of this capacity needs: states + keys (one each per slot) plus the values region, which is\n\t// cachedValueUnits u32s per slot.\n\tprivate tableLength(capacity: number): number {\n\t\treturn capacity * (2 + this.cachedValueUnits);\n\t}\n\n\tget length(): number {\n\t\treturn Atomics.load(this.pointerMemory.data, LENGTH_INDEX);\n\t}\n\tget capacity(): number {\n\t\treturn Atomics.load(this.pointerMemory.data, CAPACITY_INDEX);\n\t}\n\tget maxHash(): number {\n\t\treturn this.capacity;\n\t}\n\tget type(): number {\n\t\treturn this.cachedType;\n\t}\n\t// Metadata block plus the single table allocation the map currently points at.\n\tget usedMemory(): number {\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\tthis.ensureTable();\n\t\t\t// When inlined, the owner already counts pointerMemory as part of its own firstBlock\n\t\t\tlet ownMemory = this.ownsFirstBlock ? this.pointerMemory.usedMemory : 0;\n\t\t\treturn ownMemory + this.cachedTableMemory!.usedMemory;\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\tconstructor(memory: MemoryHeap, config?: SharedMapConfig<V> | SharedMapMemory | SharedMapMemory & SharedMapConfig<V>) {\n\t\tthis.memory = memory;\n\n\t\tif(config && 'firstBlock' in config) {\n\t\t\t// An AllocatedMemory instance is a caller-reserved slice (e.g. inlined in SharedQuadtree) for us to initialize in\n\t\t\t// place; a plain pointer is the serialized clone path, whose table already exists and is read from metadata.\n\t\t\tif(config.firstBlock instanceof AllocatedMemory) {\n\t\t\t\tthis.pointerMemory = config.firstBlock;\n\t\t\t\tthis.initialize(config);\n\t\t\t\tthis.ownsFirstBlock = false;\n\t\t\t} else {\n\t\t\t\tthis.pointerMemory = new AllocatedMemory(memory, { length: SharedMap.ALLOCATE_COUNT, ...config.firstBlock });\n\t\t\t}\n\t\t} else {\n\t\t\tthis.pointerMemory = memory.allocUI32(SharedMap.ALLOCATE_COUNT);\n\t\t\tthis.initialize(config);\n\t\t}\n\t\tthis.lock = new Int32Array(this.pointerMemory.data.buffer, this.pointerMemory.bufferByteOffset + LOCK_INDEX * Uint32Array.BYTES_PER_ELEMENT, SIMPLE_LOCK_ALLOCATE_COUNT);\n\t\tthis.cachedType = Atomics.load(this.pointerMemory.data, TYPE_INDEX);\n\t\tthis.cachedValueUnits = getByteMultipler(this.cachedType);\n\t}\n\n\t// Allocate the initial table and write the metadata. pointerMemory must already be set. Used by both the fresh-alloc\n\t// path and the inline-in-place path (where pointerMemory is a slice reserved by the owner).\n\tprivate initialize(config?: SharedMapConfig<V> | SharedMapMemory) {\n\t\tlet type = config && 'type' in config ? config.type : undefined;\n\t\tlet typeCode = getArrayTypeCode(type ?? Uint32Array);\n\t\tthis.cachedValueUnits = getByteMultipler(typeCode);\n\t\tlet requestedCapacity = config && 'capacity' in config ? config.capacity : undefined;\n\t\tlet capacity = DEFAULT_CAPACITY;\n\t\twhile(capacity < (requestedCapacity ?? DEFAULT_CAPACITY)) {\n\t\t\tcapacity *= 2;\n\t\t}\n\t\tif(capacity * (2 + this.cachedValueUnits) > this.memory.maxAllocationLength) {\n\t\t\tthrow new Error(`SharedMap capacity ${capacity} exceeds the largest contiguous allocation`);\n\t\t}\n\t\tlet table = this.memory.allocUI32(capacity * (2 + this.cachedValueUnits));\n\t\tstoreRawPointer(this.pointerMemory.data, TABLE_POINTER_INDEX, table.pointer);\n\t\tAtomics.store(this.pointerMemory.data, CAPACITY_INDEX, capacity);\n\t\tAtomics.store(this.pointerMemory.data, TYPE_INDEX, typeCode);\n\t}\n\n\tset(key: K, value: V[number]) {\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\tthis.setNoLock(key, value);\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\tsetAll(entries: Iterable<readonly [K, V[number]]>) {\n\t\tlet batch = Array.from(entries);\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\tlet data = this.pointerMemory.data;\n\t\t\tlet projected = data[LENGTH_INDEX] + data[TOMBSTONE_INDEX] + batch.length;\n\t\t\tif(projected * LOAD_DENOMINATOR > data[CAPACITY_INDEX] * LOAD_NUMERATOR) {\n\t\t\t\tlet capacity = data[CAPACITY_INDEX];\n\t\t\t\twhile(projected * LOAD_DENOMINATOR > capacity * LOAD_NUMERATOR) {\n\t\t\t\t\tcapacity *= 2;\n\t\t\t\t}\n\t\t\t\tthis.resize(capacity);\n\t\t\t}\n\t\t\tfor(let [key, value] of batch) {\n\t\t\t\tthis.setNoLock(key, value);\n\t\t\t}\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\tprivate setNoLock(key: K, value: V[number]) {\n\t\tlet fullHashKey = get32BitHash(key);\n\t\tlet data = this.pointerMemory.data;\n\t\tlet length = data[LENGTH_INDEX];\n\t\tlet tombstones = data[TOMBSTONE_INDEX];\n\t\tif((length + tombstones + 1) * LOAD_DENOMINATOR > data[CAPACITY_INDEX] * LOAD_NUMERATOR) {\n\t\t\tthis.resize();\n\t\t}\n\n\t\tthis.ensureTable();\n\t\tlet slots = this.cachedSlots!;\n\t\tlet values = this.cachedValues! as NumericArrayIO;\n\t\tlet capacity = this.cachedCapacity;\n\t\tlet mask = capacity - 1;\n\t\tlet keysBase = capacity;\n\t\tlet idx = mix32(fullHashKey) & mask;\n\t\tlet firstTomb = -1;\n\t\t// eslint-disable-next-line no-constant-condition\n\t\twhile(true) {\n\t\t\tlet state = slots[idx];\n\t\t\tif(state === EMPTY) {\n\t\t\t\tlet target = firstTomb >= 0 ? firstTomb : idx;\n\t\t\t\tslots[target] = FULL;\n\t\t\t\tslots[keysBase + target] = fullHashKey;\n\t\t\t\tvalues[target] = value;\n\t\t\t\tdata[LENGTH_INDEX]++;\n\t\t\t\tif(firstTomb >= 0) {\n\t\t\t\t\tdata[TOMBSTONE_INDEX]--;\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t} else if(state === TOMBSTONE) {\n\t\t\t\tif(firstTomb < 0) {\n\t\t\t\t\tfirstTomb = idx;\n\t\t\t\t}\n\t\t\t} else if(slots[keysBase + idx] === fullHashKey) {\n\t\t\t\tvalues[idx] = value;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tidx = (idx + 1) & mask;\n\t\t}\n\t}\n\n\t// Atomic read-modify-write under the table lock: resolves the current value (undefined if the key is\n\t// absent), calls updater, and stores the result - so two threads mutating the same key never lose an\n\t// update the way a separate get() + set() can. updater runs inside the lock and must be synchronous and\n\t// must not touch this same map (the lock is not reentrant).\n\tupdate(key: K, updater: (current: V[number] | undefined) => V[number]): V[number] {\n\t\tlet fullHashKey = get32BitHash(key);\n\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\tlet data = this.pointerMemory.data;\n\t\t\tlet length = data[LENGTH_INDEX];\n\t\t\tlet tombstones = data[TOMBSTONE_INDEX];\n\t\t\tif((length + tombstones + 1) * LOAD_DENOMINATOR > data[CAPACITY_INDEX] * LOAD_NUMERATOR) {\n\t\t\t\tthis.resize();\n\t\t\t}\n\n\t\t\tthis.ensureTable();\n\t\t\tlet slots = this.cachedSlots!;\n\t\t\tlet values = this.cachedValues! as NumericArrayIO;\n\t\t\tlet capacity = this.cachedCapacity;\n\t\t\tlet mask = capacity - 1;\n\t\t\tlet keysBase = capacity;\n\t\t\tlet idx = mix32(fullHashKey) & mask;\n\t\t\tlet firstTomb = -1;\n\t\t\t// eslint-disable-next-line no-constant-condition\n\t\t\twhile(true) {\n\t\t\t\tlet state = slots[idx];\n\t\t\t\tif(state === EMPTY) {\n\t\t\t\t\tlet newValue = updater(undefined);\n\t\t\t\t\tlet target = firstTomb >= 0 ? firstTomb : idx;\n\t\t\t\t\tslots[target] = FULL;\n\t\t\t\t\tslots[keysBase + target] = fullHashKey;\n\t\t\t\t\tvalues[target] = newValue;\n\t\t\t\t\tdata[LENGTH_INDEX]++;\n\t\t\t\t\tif(firstTomb >= 0) {\n\t\t\t\t\t\tdata[TOMBSTONE_INDEX]--;\n\t\t\t\t\t}\n\t\t\t\t\treturn newValue;\n\t\t\t\t} else if(state === TOMBSTONE) {\n\t\t\t\t\tif(firstTomb < 0) {\n\t\t\t\t\t\tfirstTomb = idx;\n\t\t\t\t\t}\n\t\t\t\t} else if(slots[keysBase + idx] === fullHashKey) {\n\t\t\t\t\tlet newValue = updater(values[idx]);\n\t\t\t\t\tvalues[idx] = newValue;\n\t\t\t\t\treturn newValue;\n\t\t\t\t}\n\n\t\t\t\tidx = (idx + 1) & mask;\n\t\t\t}\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\tget(key: K): V[number] | undefined {\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\treturn this.getNoLock(key);\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\tgetAll(keys: Iterable<K>): Array<V[number] | undefined> {\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\tlet values: Array<V[number] | undefined> = [];\n\t\t\tfor(let key of keys) {\n\t\t\t\tvalues.push(this.getNoLock(key));\n\t\t\t}\n\t\t\treturn values;\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\tprivate getNoLock(key: K): V[number] | undefined {\n\t\tlet fullHashKey = get32BitHash(key);\n\t\tthis.ensureTable();\n\t\tlet slots = this.cachedSlots!;\n\t\tlet values = this.cachedValues! as NumericArrayIO;\n\t\tlet capacity = this.cachedCapacity;\n\t\tlet mask = capacity - 1;\n\t\tlet keysBase = capacity;\n\t\tlet idx = mix32(fullHashKey) & mask;\n\t\t// eslint-disable-next-line no-constant-condition\n\t\twhile(true) {\n\t\t\tlet state = slots[idx];\n\t\t\tif(state === EMPTY) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tif(state === FULL && slots[keysBase + idx] === fullHashKey) {\n\t\t\t\treturn values[idx];\n\t\t\t}\n\t\t\tidx = (idx + 1) & mask;\n\t\t}\n\t}\n\thas(key: K): boolean {\n\t\treturn this.get(key) !== undefined;\n\t}\n\n\tdelete(key: K): boolean {\n\t\tlet fullHashKey = get32BitHash(key);\n\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\tthis.ensureTable();\n\t\t\tlet data = this.pointerMemory.data;\n\t\t\tlet slots = this.cachedSlots!;\n\t\t\tlet capacity = this.cachedCapacity;\n\t\t\tlet mask = capacity - 1;\n\t\t\tlet keysBase = capacity;\n\t\t\tlet idx = mix32(fullHashKey) & mask;\n\t\t\t// eslint-disable-next-line no-constant-condition\n\t\t\twhile(true) {\n\t\t\t\tlet state = slots[idx];\n\t\t\t\tif(state === EMPTY) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tif(state === FULL && slots[keysBase + idx] === fullHashKey) {\n\t\t\t\t\tslots[idx] = TOMBSTONE;\n\t\t\t\t\tdata[LENGTH_INDEX]--;\n\t\t\t\t\tdata[TOMBSTONE_INDEX]++;\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t\tidx = (idx + 1) & mask;\n\t\t\t}\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\t// Best-effort scan (see class note): not lock-guarded, so must not run concurrently with writes from another thread.\n\t*[Symbol.iterator](): IterableIterator<[number, V[number]]> {\n\t\tthis.ensureTable();\n\t\tlet slots = this.cachedSlots!;\n\t\tlet values = this.cachedValues! as NumericArrayIO;\n\t\tlet capacity = this.cachedCapacity;\n\t\tlet keysBase = capacity;\n\t\tfor(let i = 0; i < capacity; i++) {\n\t\t\tif(slots[i] === FULL) {\n\t\t\t\tyield [slots[keysBase + i], values[i]];\n\t\t\t}\n\t\t}\n\t}\n\n\t// Rehash into a fresh table. Doubles capacity when live entries are crowding the table; when tombstones are the cause,\n\t// a same-size table already reclaims them. Caller must hold the lock.\n\tprivate resize(requestedCapacity?: number) {\n\t\tthis.ensureTable();\n\t\tlet oldTable = this.cachedTableMemory!;\n\t\tlet oldSlots = this.cachedSlots!;\n\t\tlet oldValues = this.cachedValues! as NumericArrayIO;\n\t\tlet oldCapacity = this.cachedCapacity;\n\t\tlet oldKeysBase = oldCapacity;\n\t\tlet length = Atomics.load(this.pointerMemory.data, LENGTH_INDEX);\n\n\t\tlet newCapacity = requestedCapacity ?? oldCapacity;\n\t\tif(requestedCapacity === undefined && (length + 1) * LOAD_DENOMINATOR > oldCapacity * LOAD_NUMERATOR) {\n\t\t\tnewCapacity = oldCapacity * 2;\n\t\t}\n\t\t// A table is one contiguous allocation, so it can never exceed what a single buffer can hand out. Fail here with an\n\t\t// actionable message instead of letting allocUI32 throw a cryptic \"Unable to allocate N numbers\" from deep inside the\n\t\t// heap. Mirrors the same guard in initialize().\n\t\tif(this.tableLength(newCapacity) > this.memory.maxAllocationLength) {\n\t\t\tlet maxEntries = Math.floor(this.memory.maxAllocationLength / (2 + this.cachedValueUnits) * LOAD_NUMERATOR / LOAD_DENOMINATOR);\n\t\t\tthrow new Error(`SharedMap can't grow to capacity ${newCapacity}: its table would exceed the largest contiguous `\n\t\t\t\t+ `allocation (${this.memory.maxAllocationLength} u32s, ~${maxEntries} entries). Use larger buffers or shard across multiple maps.`);\n\t\t}\n\t\tlet newTable = this.memory.allocUI32(this.tableLength(newCapacity));\n\t\tlet newSlots = newTable.data;\n\t\tlet newValues = this.makeValuesView(newTable, newCapacity) as NumericArrayIO;\n\t\tlet mask = newCapacity - 1;\n\t\tlet newKeysBase = newCapacity;\n\n\t\tfor(let i = 0; i < oldCapacity; i++) {\n\t\t\tif(oldSlots[i] !== FULL) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tlet key = oldSlots[oldKeysBase + i];\n\t\t\tlet value = oldValues[i];\n\t\t\tlet idx = mix32(key) & mask;\n\t\t\t// Fresh table has no tombstones, so probe straight to the first empty slot\n\t\t\twhile(newSlots[idx] !== EMPTY) {\n\t\t\t\tidx = (idx + 1) & mask;\n\t\t\t}\n\t\t\tnewSlots[idx] = FULL;\n\t\t\tnewSlots[newKeysBase + idx] = key;\n\t\t\tnewValues[idx] = value;\n\t\t}\n\n\t\tstoreRawPointer(this.pointerMemory.data, TABLE_POINTER_INDEX, newTable.pointer);\n\t\tAtomics.store(this.pointerMemory.data, CAPACITY_INDEX, newCapacity);\n\t\tAtomics.store(this.pointerMemory.data, TOMBSTONE_INDEX, 0);\n\t\t// Invalidate the cached views so the next access rebuilds against the new table\n\t\tthis.cachedTablePointer = 0;\n\t\tthis.cachedSlots = undefined;\n\t\toldTable.free();\n\t}\n\n\tfree() {\n\t\tthis.ensureTable();\n\t\tthis.cachedTableMemory!.free();\n\t\tif(this.ownsFirstBlock) {\n\t\t\tthis.pointerMemory.free();\n\t\t}\n\t}\n\n\tgetSharedMemory(): SharedMapMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.pointerMemory.getSharedMemory(),\n\t\t};\n\t}\n}\n\ninterface SharedMapConfig<V extends NumericArray> {\n\ttype?: TypedArrayConstructor<V>\n\tcapacity?: number\n}\ninterface SharedMapMemory {\n\tfirstBlock: SharedAllocatedMemory | AllocatedMemory\n}\n\nexport type { SharedMapConfig, SharedMapMemory };\n"],"mappings":"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"}
+{"version":3,"file":"shared-map.js","names":["AllocatedMemory","EMPTY","FULL","TOMBSTONE","DEFAULT_CAPACITY","LOAD_NUMERATOR","LOAD_DENOMINATOR","TABLE_POINTER_INDEX","LOCK_INDEX","LENGTH_INDEX","TOMBSTONE_INDEX","CAPACITY_INDEX","TYPE_INDEX","SharedMap","data","pointer","capacity","table","getPointer","byteOffset","makeArrayView","memory","config","getByteMultipler","type","typeCode","getArrayTypeCode","requestedCapacity","storeRawPointer","key","value","batch","entries","projected","fullHashKey","get32BitHash","slots","values","mask","keysBase","idx","mix32","firstTomb","state","target","newValue","updater","length","valueOrUpdater","keys","start","oldTable","oldSlots","oldValues","oldCapacity","oldKeysBase","newCapacity","maxEntries","newTable","newSlots","newValues","newKeysBase","i"],"sources":["../src/shared-map.ts"],"sourcesContent":["import AllocatedMemory, { type SharedAllocatedMemory } from './allocated-memory';\nimport type MemoryHeap from './memory-heap';\nimport { getPointer, storeRawPointer } from './utils/pointer';\nimport { get32BitHash, mix32 } from './utils/hash';\nimport { lock, unlock, SIMPLE_LOCK_ALLOCATE_COUNT } from './lock/simple-lock';\nimport { getArrayTypeCode, getByteMultipler, makeArrayView, type NumericArray, type NumericArrayIO, type TypedArrayConstructor } from './utils/array-type';\n\n// Open-addressing hash map with linear probing, held in one contiguous table (no per-bucket lists, no per-operation\n// allocation). A single exclusive lock guards the table so slot reads/writes inside the critical section can be plain\n// memory access instead of per-slot Atomics; the lock's acquire/release provides the cross-thread happens-before.\n//\n// The table uses a Structure-of-Arrays layout: three contiguous regions - states | keys | values - so probing touches\n// the dense states and keys regions (more candidates per cache line) and iteration walks values densely. capacity is\n// always a power of two, so slot = mix(key) & (capacity - 1). state distinguishes EMPTY/FULL/TOMBSTONE, so key 0 and\n// value 0 need no sentinel.\n//\n// Keys are always stored as the 32-bit hash (a numeric key is its own hash); values are stored in the typed array the\n// map was created with (Uint32Array by default, or Int32Array / Float32Array). Iteration is a best-effort scan that is\n// not lock-guarded, so it must not run concurrently with mutation from another thread. A single allocation can't span\n// buffers, so the table is bounded by MemoryHeap.maxAllocationLength.\n\nconst EMPTY = 0;\nconst FULL = 1;\nconst TOMBSTONE = 2;\n\nconst DEFAULT_CAPACITY = 16;\n// Grow when (occupied + tombstones) / capacity exceeds this. Kept as a fraction to avoid floating point in the hot path.\nconst LOAD_NUMERATOR = 3;\nconst LOAD_DENOMINATOR = 4;\n\n// Metadata block layout (pointerMemory)\nconst TABLE_POINTER_INDEX = 0;\nconst LOCK_INDEX = 1;\nconst LENGTH_INDEX = 2;\nconst TOMBSTONE_INDEX = 3;\nconst CAPACITY_INDEX = 4;\nconst TYPE_INDEX = 5;\n\nexport default class SharedMap<K extends string | number, V extends NumericArray = Uint32Array> {\n\tstatic readonly ALLOCATE_COUNT = 6;\n\n\tprivate memory: MemoryHeap;\n\tprivate pointerMemory: AllocatedMemory;\n\t// False when pointerMemory is a slice of another structure's memory (e.g. inlined in SharedQuadtree); that owner frees it\n\tprivate ownsFirstBlock = true;\n\tprivate lock: Int32Array;\n\t// Value type is written once at creation and never changes, so resolve it once instead of reading metadata per op\n\tprivate cachedType: number;\n\t// u32 units per value slot: 1 for 32-bit types, 2 for 64-bit (float64/int64/uint64). The values region and every\n\t// table allocation scale by this.\n\tprivate cachedValueUnits = 1;\n\tprivate readonly maxTableCapacity: number;\n\n\t// Cache the resolved views so most operations avoid rebuilding them. Rebuild whenever the table pointer OR the capacity\n\t// changes: the pointer alone is not enough because the allocator recycles freed addresses (split:false), so a rehash can\n\t// land a differently-sized table at the same address (ABA). The cached views are plain windows into shared memory, so\n\t// they always reflect the current bytes at that address; only the derived capacity (mask/offsets) can go stale, and the\n\t// capacity check catches exactly that.\n\tprivate cachedTablePointer = 0;\n\tprivate cachedTableMemory?: AllocatedMemory;\n\tprivate cachedSlots?: Uint32Array; // whole block as u32: states region, then keys region\n\tprivate cachedValues?: V; // typed view over the values region\n\tprivate cachedCapacity = 0;\n\t// Callers hold the lock, so the acquire fence already published the latest pointer/capacity - plain reads are enough\n\t// and avoid two Atomics.load per operation on the hot path.\n\tprivate ensureTable() {\n\t\tlet data = this.pointerMemory.data;\n\t\tlet pointer = data[TABLE_POINTER_INDEX];\n\t\tlet capacity = data[CAPACITY_INDEX];\n\t\tif(pointer === this.cachedTablePointer && capacity === this.cachedCapacity && this.cachedSlots) {\n\t\t\treturn;\n\t\t}\n\n\t\tlet table = new AllocatedMemory(this.memory, getPointer(pointer, this.memory.positionBits));\n\t\tthis.cachedTableMemory = table;\n\t\tthis.cachedSlots = table.data;\n\t\tthis.cachedValues = this.makeValuesView(table, capacity);\n\t\tthis.cachedCapacity = capacity;\n\t\tthis.cachedTablePointer = pointer;\n\t}\n\tprivate makeValuesView(table: AllocatedMemory, capacity: number): V {\n\t\t// states and keys each take one u32 per slot, so the values region starts after 2 * capacity u32s\n\t\tlet byteOffset = table.bufferByteOffset + capacity * 2 * Uint32Array.BYTES_PER_ELEMENT;\n\t\treturn makeArrayView(this.cachedType, table.data.buffer, byteOffset, capacity) as V;\n\t}\n\t// u32s a table of this capacity needs: states + keys (one each per slot) plus the values region, which is\n\t// cachedValueUnits u32s per slot.\n\tprivate tableLength(capacity: number): number {\n\t\treturn capacity * (2 + this.cachedValueUnits);\n\t}\n\n\tget length(): number {\n\t\treturn Atomics.load(this.pointerMemory.data, LENGTH_INDEX);\n\t}\n\tget capacity(): number {\n\t\treturn Atomics.load(this.pointerMemory.data, CAPACITY_INDEX);\n\t}\n\tget maxHash(): number {\n\t\treturn this.capacity;\n\t}\n\tget type(): number {\n\t\treturn this.cachedType;\n\t}\n\t// Metadata block plus the single table allocation the map currently points at.\n\tget usedMemory(): number {\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\tthis.ensureTable();\n\t\t\t// When inlined, the owner already counts pointerMemory as part of its own firstBlock\n\t\t\tlet ownMemory = this.ownsFirstBlock ? this.pointerMemory.usedMemory : 0;\n\t\t\treturn ownMemory + this.cachedTableMemory!.usedMemory;\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\tconstructor(memory: MemoryHeap, config?: SharedMapConfig<V> | SharedMapMemory | SharedMapMemory & SharedMapConfig<V>) {\n\t\tthis.memory = memory;\n\n\t\tif(config && 'firstBlock' in config) {\n\t\t\t// An AllocatedMemory instance is a caller-reserved slice (e.g. inlined in SharedQuadtree) for us to initialize in\n\t\t\t// place; a plain pointer is the serialized clone path, whose table already exists and is read from metadata.\n\t\t\tif(config.firstBlock instanceof AllocatedMemory) {\n\t\t\t\tthis.pointerMemory = config.firstBlock;\n\t\t\t\tthis.initialize(config);\n\t\t\t\tthis.ownsFirstBlock = false;\n\t\t\t} else {\n\t\t\t\tthis.pointerMemory = new AllocatedMemory(memory, { length: SharedMap.ALLOCATE_COUNT, ...config.firstBlock });\n\t\t\t}\n\t\t} else {\n\t\t\tthis.pointerMemory = memory.allocUI32(SharedMap.ALLOCATE_COUNT);\n\t\t\tthis.initialize(config);\n\t\t}\n\t\tthis.lock = new Int32Array(this.pointerMemory.data.buffer, this.pointerMemory.bufferByteOffset + LOCK_INDEX * Uint32Array.BYTES_PER_ELEMENT, SIMPLE_LOCK_ALLOCATE_COUNT);\n\t\tthis.cachedType = Atomics.load(this.pointerMemory.data, TYPE_INDEX);\n\t\tthis.cachedValueUnits = getByteMultipler(this.cachedType);\n\t\tthis.maxTableCapacity = 2 ** Math.floor(Math.log2(this.memory.maxAllocationLength / (2 + this.cachedValueUnits)));\n\t}\n\n\t// Allocate the initial table and write the metadata. pointerMemory must already be set. Used by both the fresh-alloc\n\t// path and the inline-in-place path (where pointerMemory is a slice reserved by the owner).\n\tprivate initialize(config?: SharedMapConfig<V> | SharedMapMemory) {\n\t\tlet type = config && 'type' in config ? config.type : undefined;\n\t\tlet typeCode = getArrayTypeCode(type ?? Uint32Array);\n\t\tthis.cachedValueUnits = getByteMultipler(typeCode);\n\t\tlet requestedCapacity = config && 'capacity' in config ? config.capacity : undefined;\n\t\tlet capacity = DEFAULT_CAPACITY;\n\t\twhile(capacity < (requestedCapacity ?? DEFAULT_CAPACITY)) {\n\t\t\tcapacity *= 2;\n\t\t}\n\t\tif(capacity * (2 + this.cachedValueUnits) > this.memory.maxAllocationLength) {\n\t\t\tthrow new Error(`SharedMap capacity ${capacity} exceeds the largest contiguous allocation`);\n\t\t}\n\t\tlet table = this.memory.allocUI32(capacity * (2 + this.cachedValueUnits));\n\t\tstoreRawPointer(this.pointerMemory.data, TABLE_POINTER_INDEX, table.pointer);\n\t\tAtomics.store(this.pointerMemory.data, CAPACITY_INDEX, capacity);\n\t\tAtomics.store(this.pointerMemory.data, TYPE_INDEX, typeCode);\n\t}\n\n\tset(key: K, value: V[number]) {\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\tthis.setNoLock(key, value);\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\tsetAll(entries: Iterable<readonly [K, V[number]]>) {\n\t\tlet batch = Array.from(entries);\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\tlet data = this.pointerMemory.data;\n\t\t\tlet projected = data[LENGTH_INDEX] + data[TOMBSTONE_INDEX] + batch.length;\n\t\t\tif(projected * LOAD_DENOMINATOR > data[CAPACITY_INDEX] * LOAD_NUMERATOR) {\n\t\t\t\tlet capacity = data[CAPACITY_INDEX];\n\t\t\t\twhile(projected * LOAD_DENOMINATOR > capacity * LOAD_NUMERATOR && capacity < this.maxTableCapacity) {\n\t\t\t\t\tcapacity *= 2;\n\t\t\t\t}\n\t\t\t\tif(capacity > data[CAPACITY_INDEX]) {\n\t\t\t\t\tthis.resize(capacity);\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor(let [key, value] of batch) {\n\t\t\t\tthis.setNoLock(key, value);\n\t\t\t}\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\tprivate setNoLock(key: K, value: V[number]) {\n\t\tlet fullHashKey = get32BitHash(key);\n\t\tlet data = this.pointerMemory.data;\n\t\tlet length = data[LENGTH_INDEX];\n\t\tlet tombstones = data[TOMBSTONE_INDEX];\n\t\tif((length + tombstones + 1) * LOAD_DENOMINATOR > data[CAPACITY_INDEX] * LOAD_NUMERATOR) {\n\t\t\tthis.resizeForInsert(key);\n\t\t}\n\n\t\tthis.ensureTable();\n\t\tlet slots = this.cachedSlots!;\n\t\tlet values = this.cachedValues! as NumericArrayIO;\n\t\tlet capacity = this.cachedCapacity;\n\t\tlet mask = capacity - 1;\n\t\tlet keysBase = capacity;\n\t\tlet idx = mix32(fullHashKey) & mask;\n\t\tlet firstTomb = -1;\n\t\t// eslint-disable-next-line no-constant-condition\n\t\twhile(true) {\n\t\t\tlet state = slots[idx];\n\t\t\tif(state === EMPTY) {\n\t\t\t\tlet target = firstTomb >= 0 ? firstTomb : idx;\n\t\t\t\tslots[target] = FULL;\n\t\t\t\tslots[keysBase + target] = fullHashKey;\n\t\t\t\tvalues[target] = value;\n\t\t\t\tdata[LENGTH_INDEX]++;\n\t\t\t\tif(firstTomb >= 0) {\n\t\t\t\t\tdata[TOMBSTONE_INDEX]--;\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t} else if(state === TOMBSTONE) {\n\t\t\t\tif(firstTomb < 0) {\n\t\t\t\t\tfirstTomb = idx;\n\t\t\t\t} else if(idx === firstTomb) {\n\t\t\t\t\t// Returning to the first tombstone means every key was checked without finding an empty slot.\n\t\t\t\t\tthis.reuseTombstone(idx, fullHashKey, value);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t} else if(slots[keysBase + idx] === fullHashKey) {\n\t\t\t\tvalues[idx] = value;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tidx = (idx + 1) & mask;\n\t\t}\n\t}\n\n\t// Atomic read-modify-write under the table lock: resolves the current value (undefined if the key is\n\t// absent), calls updater, and stores the result - so two threads mutating the same key never lose an\n\t// update the way a separate get() + set() can. updater runs inside the lock and must be synchronous and\n\t// must not touch this same map (the lock is not reentrant).\n\tupdate(key: K, updater: (current: V[number] | undefined) => V[number]): V[number] {\n\t\tlet fullHashKey = get32BitHash(key);\n\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\tlet data = this.pointerMemory.data;\n\t\t\tlet length = data[LENGTH_INDEX];\n\t\t\tlet tombstones = data[TOMBSTONE_INDEX];\n\t\t\tif((length + tombstones + 1) * LOAD_DENOMINATOR > data[CAPACITY_INDEX] * LOAD_NUMERATOR) {\n\t\t\t\tthis.resizeForInsert(key);\n\t\t\t}\n\n\t\t\tthis.ensureTable();\n\t\t\tlet slots = this.cachedSlots!;\n\t\t\tlet values = this.cachedValues! as NumericArrayIO;\n\t\t\tlet capacity = this.cachedCapacity;\n\t\t\tlet mask = capacity - 1;\n\t\t\tlet idx = mix32(fullHashKey) & mask;\n\t\t\tlet firstTomb = -1;\n\t\t\t// eslint-disable-next-line no-constant-condition\n\t\t\twhile(true) {\n\t\t\t\tlet state = slots[idx];\n\t\t\t\tif(state === EMPTY) {\n\t\t\t\t\tlet newValue = updater(undefined);\n\t\t\t\t\tlet target = firstTomb >= 0 ? firstTomb : idx;\n\t\t\t\t\tslots[target] = FULL;\n\t\t\t\t\tslots[capacity + target] = fullHashKey;\n\t\t\t\t\tvalues[target] = newValue;\n\t\t\t\t\tdata[LENGTH_INDEX]++;\n\t\t\t\t\tif(firstTomb >= 0) {\n\t\t\t\t\t\tdata[TOMBSTONE_INDEX]--;\n\t\t\t\t\t}\n\t\t\t\t\treturn newValue;\n\t\t\t\t} else if(state === TOMBSTONE) {\n\t\t\t\t\tif(idx === firstTomb) {\n\t\t\t\t\t\treturn this.reuseTombstone(idx, fullHashKey, updater);\n\t\t\t\t\t}\n\t\t\t\t\tif(firstTomb < 0) {\n\t\t\t\t\t\tfirstTomb = idx;\n\t\t\t\t\t}\n\t\t\t\t} else if(slots[capacity + idx] === fullHashKey) {\n\t\t\t\t\tlet newValue = updater(values[idx]);\n\t\t\t\t\tvalues[idx] = newValue;\n\t\t\t\t\treturn newValue;\n\t\t\t\t}\n\n\t\t\t\tidx = (idx + 1) & mask;\n\t\t\t}\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\t// Keep rare capacity handling out of the insertion loops so they stay small enough to inline.\n\tprivate resizeForInsert(key: K) {\n\t\tlet length = this.pointerMemory.data[LENGTH_INDEX];\n\t\tlet capacity = this.pointerMemory.data[CAPACITY_INDEX];\n\t\tif(capacity < this.maxTableCapacity || (length + 1) * LOAD_DENOMINATOR <= capacity * LOAD_NUMERATOR) {\n\t\t\tthis.resize();\n\t\t} else if(length === capacity && this.getNoLock(key) === undefined) {\n\t\t\tthrow new Error(`SharedMap is full at capacity ${capacity}: a larger table would exceed the largest contiguous allocation. `\n\t\t\t\t+ 'Use larger buffers or shard across multiple maps.');\n\t\t}\n\t}\n\n\tprivate reuseTombstone(idx: number, fullHashKey: number, valueOrUpdater: V[number] | ((current: V[number] | undefined) => V[number])): V[number] {\n\t\tlet newValue = typeof valueOrUpdater === 'function' ? valueOrUpdater(undefined) : valueOrUpdater;\n\t\tlet slots = this.cachedSlots!;\n\t\tlet values = this.cachedValues! as NumericArrayIO;\n\t\tslots[idx] = FULL;\n\t\tslots[this.cachedCapacity + idx] = fullHashKey;\n\t\tvalues[idx] = newValue;\n\t\tthis.pointerMemory.data[LENGTH_INDEX]++;\n\t\tthis.pointerMemory.data[TOMBSTONE_INDEX]--;\n\t\treturn newValue;\n\t}\n\n\tget(key: K): V[number] | undefined {\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\treturn this.getNoLock(key);\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\tgetAll(keys: Iterable<K>): Array<V[number] | undefined> {\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\tlet values: Array<V[number] | undefined> = [];\n\t\t\tfor(let key of keys) {\n\t\t\t\tvalues.push(this.getNoLock(key));\n\t\t\t}\n\t\t\treturn values;\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\tprivate getNoLock(key: K): V[number] | undefined {\n\t\tlet fullHashKey = get32BitHash(key);\n\t\tthis.ensureTable();\n\t\tlet slots = this.cachedSlots!;\n\t\tlet values = this.cachedValues! as NumericArrayIO;\n\t\tlet capacity = this.cachedCapacity;\n\t\tlet mask = capacity - 1;\n\t\tlet keysBase = capacity;\n\t\tlet idx = mix32(fullHashKey) & mask;\n\t\tlet start = idx;\n\t\tdo {\n\t\t\tlet state = slots[idx];\n\t\t\tif(state === EMPTY) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tif(state === FULL && slots[keysBase + idx] === fullHashKey) {\n\t\t\t\treturn values[idx];\n\t\t\t}\n\t\t\tidx = (idx + 1) & mask;\n\t\t} while(idx !== start);\n\t\treturn undefined;\n\t}\n\thas(key: K): boolean {\n\t\treturn this.get(key) !== undefined;\n\t}\n\n\tdelete(key: K): boolean {\n\t\tlet fullHashKey = get32BitHash(key);\n\n\t\tlock(this.lock);\n\t\ttry {\n\t\t\tthis.ensureTable();\n\t\t\tlet data = this.pointerMemory.data;\n\t\t\tlet slots = this.cachedSlots!;\n\t\t\tlet capacity = this.cachedCapacity;\n\t\t\tlet mask = capacity - 1;\n\t\t\tlet keysBase = capacity;\n\t\t\tlet idx = mix32(fullHashKey) & mask;\n\t\t\tlet start = idx;\n\t\t\tdo {\n\t\t\t\tlet state = slots[idx];\n\t\t\t\tif(state === EMPTY) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tif(state === FULL && slots[keysBase + idx] === fullHashKey) {\n\t\t\t\t\tslots[idx] = TOMBSTONE;\n\t\t\t\t\tdata[LENGTH_INDEX]--;\n\t\t\t\t\tdata[TOMBSTONE_INDEX]++;\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t\tidx = (idx + 1) & mask;\n\t\t\t} while(idx !== start);\n\t\t\treturn false;\n\t\t} finally {\n\t\t\tunlock(this.lock);\n\t\t}\n\t}\n\n\t// Best-effort scan (see class note): not lock-guarded, so must not run concurrently with writes from another thread.\n\t*[Symbol.iterator](): IterableIterator<[number, V[number]]> {\n\t\tthis.ensureTable();\n\t\tlet slots = this.cachedSlots!;\n\t\tlet values = this.cachedValues! as NumericArrayIO;\n\t\tlet capacity = this.cachedCapacity;\n\t\tlet keysBase = capacity;\n\t\tfor(let i = 0; i < capacity; i++) {\n\t\t\tif(slots[i] === FULL) {\n\t\t\t\tyield [slots[keysBase + i], values[i]];\n\t\t\t}\n\t\t}\n\t}\n\n\t// Rehash into a fresh table. Doubles capacity when live entries are crowding the table; when tombstones are the cause,\n\t// a same-size table already reclaims them. Caller must hold the lock.\n\tprivate resize(requestedCapacity?: number) {\n\t\tthis.ensureTable();\n\t\tlet oldTable = this.cachedTableMemory!;\n\t\tlet oldSlots = this.cachedSlots!;\n\t\tlet oldValues = this.cachedValues! as NumericArrayIO;\n\t\tlet oldCapacity = this.cachedCapacity;\n\t\tlet oldKeysBase = oldCapacity;\n\t\tlet length = Atomics.load(this.pointerMemory.data, LENGTH_INDEX);\n\n\t\tlet newCapacity = requestedCapacity ?? oldCapacity;\n\t\tif(requestedCapacity === undefined && (length + 1) * LOAD_DENOMINATOR > oldCapacity * LOAD_NUMERATOR) {\n\t\t\tnewCapacity = oldCapacity * 2;\n\t\t}\n\t\t// A table is one contiguous allocation, so it can never exceed what a single buffer can hand out. Fail here with an\n\t\t// actionable message instead of letting allocUI32 throw a cryptic \"Unable to allocate N numbers\" from deep inside the\n\t\t// heap. Mirrors the same guard in initialize().\n\t\tif(this.tableLength(newCapacity) > this.memory.maxAllocationLength) {\n\t\t\tlet maxEntries = Math.floor(this.memory.maxAllocationLength / (2 + this.cachedValueUnits) * LOAD_NUMERATOR / LOAD_DENOMINATOR);\n\t\t\tthrow new Error(`SharedMap can't grow to capacity ${newCapacity}: its table would exceed the largest contiguous `\n\t\t\t\t+ `allocation (${this.memory.maxAllocationLength} u32s, ~${maxEntries} entries). Use larger buffers or shard across multiple maps.`);\n\t\t}\n\t\tlet newTable = this.memory.allocUI32(this.tableLength(newCapacity));\n\t\tlet newSlots = newTable.data;\n\t\tlet newValues = this.makeValuesView(newTable, newCapacity) as NumericArrayIO;\n\t\tlet mask = newCapacity - 1;\n\t\tlet newKeysBase = newCapacity;\n\n\t\tfor(let i = 0; i < oldCapacity; i++) {\n\t\t\tif(oldSlots[i] !== FULL) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tlet key = oldSlots[oldKeysBase + i];\n\t\t\tlet value = oldValues[i];\n\t\t\tlet idx = mix32(key) & mask;\n\t\t\t// Fresh table has no tombstones, so probe straight to the first empty slot\n\t\t\twhile(newSlots[idx] !== EMPTY) {\n\t\t\t\tidx = (idx + 1) & mask;\n\t\t\t}\n\t\t\tnewSlots[idx] = FULL;\n\t\t\tnewSlots[newKeysBase + idx] = key;\n\t\t\tnewValues[idx] = value;\n\t\t}\n\n\t\tstoreRawPointer(this.pointerMemory.data, TABLE_POINTER_INDEX, newTable.pointer);\n\t\tAtomics.store(this.pointerMemory.data, CAPACITY_INDEX, newCapacity);\n\t\tAtomics.store(this.pointerMemory.data, TOMBSTONE_INDEX, 0);\n\t\t// Invalidate the cached views so the next access rebuilds against the new table\n\t\tthis.cachedTablePointer = 0;\n\t\tthis.cachedSlots = undefined;\n\t\toldTable.free();\n\t}\n\n\tfree() {\n\t\tthis.ensureTable();\n\t\tthis.cachedTableMemory!.free();\n\t\tif(this.ownsFirstBlock) {\n\t\t\tthis.pointerMemory.free();\n\t\t}\n\t}\n\n\tgetSharedMemory(): SharedMapMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.pointerMemory.getSharedMemory(),\n\t\t};\n\t}\n}\n\ninterface SharedMapConfig<V extends NumericArray> {\n\ttype?: TypedArrayConstructor<V>\n\tcapacity?: number\n}\ninterface SharedMapMemory {\n\tfirstBlock: SharedAllocatedMemory | AllocatedMemory\n}\n\nexport type { SharedMapConfig, SharedMapMemory };\n"],"mappings":";;;;;;AAqBA,IAAMC,IAAQ,GACRC,IAAO,GACPC,IAAY,GAEZC,IAAmB,IAEnBC,IAAiB,GACjBC,IAAmB,GAGnBC,IAAsB,GACtBC,IAAa,GACbC,IAAe,GACfC,IAAkB,GAClBC,IAAiB,GACjBC,IAAa,GAEEC,IAArB,MAAqBA,EAA2E;CAC/F,OAAgB,iBAAiB;CAEjC;CACA;CAEA,iBAAyB;CACzB;CAEA;CAGA,mBAA2B;CAC3B;CAOA,qBAA6B;CAC7B;CACA;CACA;CACA,iBAAyB;CAGzB,cAAsB;EACrB,IAAIC,IAAO,KAAK,cAAc,MAC1BC,IAAUD,EAAKP,IACfS,IAAWF,EAAKH;EACpB,IAAGI,MAAY,KAAK,sBAAsBC,MAAa,KAAK,kBAAkB,KAAK,aAClF;EAGD,IAAIC,IAAQ,IAAIjB,EAAgB,KAAK,QAAQkB,EAAWH,GAAS,KAAK,OAAO,YAAY,CAAC;EAK1F,AAJA,KAAK,oBAAoBE,GACzB,KAAK,cAAcA,EAAM,MACzB,KAAK,eAAe,KAAK,eAAeA,GAAOD,CAAQ,GACvD,KAAK,iBAAiBA,GACtB,KAAK,qBAAqBD;CAC3B;CACA,eAAuB,GAAwB,GAAqB;EAEnE,IAAII,IAAaF,EAAM,mBAAmBD,IAAW,IAAI,YAAY;EACrE,OAAOI,EAAc,KAAK,YAAYH,EAAM,KAAK,QAAQE,GAAYH,CAAQ;CAC9E;CAGA,YAAoB,GAA0B;EAC7C,OAAOA,KAAY,IAAI,KAAK;CAC7B;CAEA,IAAI,SAAiB;EACpB,OAAO,QAAQ,KAAK,KAAK,cAAc,MAAMP,CAAY;CAC1D;CACA,IAAI,WAAmB;EACtB,OAAO,QAAQ,KAAK,KAAK,cAAc,MAAME,CAAc;CAC5D;CACA,IAAI,UAAkB;EACrB,OAAO,KAAK;CACb;CACA,IAAI,OAAe;EAClB,OAAO,KAAK;CACb;CAEA,IAAI,aAAqB;EACxB,EAAK,KAAK,IAAI;EACd,IAAI;GAIH,OAHA,KAAK,YAAY,IAED,KAAK,iBAAiB,KAAK,cAAc,aAAa,KACnD,KAAK,kBAAmB;EAC5C,UAAU;GACT,EAAO,KAAK,IAAI;EACjB;CACD;CAEA,YAAY,GAAoB,GAAsF;EAoBrH,AAnBA,KAAK,SAASU,GAEXC,KAAU,gBAAgBA,IAGzBA,EAAO,sBAAsBtB,KAC/B,KAAK,gBAAgBsB,EAAO,YAC5B,KAAK,WAAWA,CAAM,GACtB,KAAK,iBAAiB,MAEtB,KAAK,gBAAgB,IAAItB,EAAgBqB,GAAQ;GAAE,QAAQR,EAAU;GAAgB,GAAGS,EAAO;EAAW,CAAC,KAG5G,KAAK,gBAAgBD,EAAO,UAAUR,EAAU,cAAc,GAC9D,KAAK,WAAWS,CAAM,IAEvB,KAAK,OAAO,IAAI,WAAW,KAAK,cAAc,KAAK,QAAQ,KAAK,cAAc,mBAAmBd,IAAa,YAAY,mBAAA,CAA6C,GACvK,KAAK,aAAa,QAAQ,KAAK,KAAK,cAAc,MAAMI,CAAU,GAClE,KAAK,mBAAmBW,EAAiB,KAAK,UAAU,GACxD,KAAK,mBAAmB,KAAK,KAAK,MAAM,KAAK,KAAK,KAAK,OAAO,uBAAuB,IAAI,KAAK,iBAAiB,CAAC;CACjH;CAIA,WAAmB,GAA+C;EACjE,IAAIC,IAAOF,KAAU,UAAUA,IAASA,EAAO,OAAO,KAAA,GAClDG,IAAWC,EAAiBF,KAAQ,WAAW;EACnD,KAAK,mBAAmBD,EAAiBE,CAAQ;EACjD,IAAIE,IAAoBL,KAAU,cAAcA,IAASA,EAAO,WAAW,KAAA,GACvEN,IAAWZ;EACf,OAAMY,KAAYW,KAAqBvB,KACtC,KAAY;EAEb,IAAGY,KAAY,IAAI,KAAK,oBAAoB,KAAK,OAAO,qBACvD,MAAU,MAAM,sBAAsBA,EAAS,2CAA2C;EAE3F,IAAIC,IAAQ,KAAK,OAAO,UAAUD,KAAY,IAAI,KAAK,iBAAiB;EAGxE,AAFAY,EAAgB,KAAK,cAAc,MAAMrB,GAAqBU,EAAM,OAAO,GAC3E,QAAQ,MAAM,KAAK,cAAc,MAAMN,GAAgBK,CAAQ,GAC/D,QAAQ,MAAM,KAAK,cAAc,MAAMJ,GAAYa,CAAQ;CAC5D;CAEA,IAAI,GAAQ,GAAkB;EAC7B,EAAK,KAAK,IAAI;EACd,IAAI;GACH,KAAK,UAAUI,GAAKC,CAAK;EAC1B,UAAU;GACT,EAAO,KAAK,IAAI;EACjB;CACD;CAEA,OAAO,GAA4C;EAClD,IAAIC,IAAQ,MAAM,KAAKC,CAAO;EAC9B,EAAK,KAAK,IAAI;EACd,IAAI;GACH,IAAIlB,IAAO,KAAK,cAAc,MAC1BmB,IAAYnB,EAAKL,KAAgBK,EAAKJ,KAAmBqB,EAAM;GACnE,IAAGE,IAAY3B,IAAmBQ,EAAKH,KAAkBN,GAAgB;IACxE,IAAIW,IAAWF,EAAKH;IACpB,OAAMsB,IAAY3B,IAAmBU,IAAWX,KAAkBW,IAAW,KAAK,mBACjF,KAAY;IAEb,AAAGA,IAAWF,EAAKH,MAClB,KAAK,OAAOK,CAAQ;GAEtB;GACA,KAAI,IAAI,CAACa,GAAKC,MAAUC,GACvB,KAAK,UAAUF,GAAKC,CAAK;EAE3B,UAAU;GACT,EAAO,KAAK,IAAI;EACjB;CACD;CAEA,UAAkB,GAAQ,GAAkB;EAC3C,IAAII,IAAcC,EAAaN,CAAG,GAC9Bf,IAAO,KAAK,cAAc;EAO9B,CANaA,EAAKL,KACDK,EAAKJ,KACI,KAAKJ,IAAmBQ,EAAKH,KAAkBN,KACxE,KAAK,gBAAgBwB,CAAG,GAGzB,KAAK,YAAY;EACjB,IAAIO,IAAQ,KAAK,aACbC,IAAS,KAAK,cACdrB,IAAW,KAAK,gBAChBsB,IAAOtB,IAAW,GAClBuB,IAAWvB,GACXwB,IAAMC,EAAMP,CAAW,IAAII,GAC3BI,IAAY;EAEhB,SAAY;GACX,IAAIC,IAAQP,EAAMI;GAClB,IAAGG,MAAU1C,GAAO;IACnB,IAAI2C,IAASF,KAAa,IAAIA,IAAYF;IAK1C,AAJA,EAAMI,KAAU1C,GAChB,EAAMqC,IAAWK,KAAUV,GAC3B,EAAOU,KAAUd,GACjB,EAAKrB,EAAa,IACfiC,KAAa,KACf,EAAKhC,EAAgB;IAEtB;GACD;GAAO,IAAGiC,MAAUxC,GAAW;IAC9B,IAAGuC,IAAY,GACd,IAAYF;SACN,IAAGA,MAAQE,GAAW;KAE5B,KAAK,eAAeF,GAAKN,GAAaJ,CAAK;KAC3C;IACD;GACD,OAAO,IAAGM,EAAMG,IAAWC,OAASN,GAAa;IAChD,EAAOM,KAAOV;IACd;GACD;GAEA,IAAOU,IAAM,IAAKF;EACnB;CACD;CAMA,OAAO,GAAQ,GAAmE;EACjF,IAAIJ,IAAcC,EAAaN,CAAG;EAElC,EAAK,KAAK,IAAI;EACd,IAAI;GACH,IAAIf,IAAO,KAAK,cAAc;GAO9B,CANaA,EAAKL,KACDK,EAAKJ,KACI,KAAKJ,IAAmBQ,EAAKH,KAAkBN,KACxE,KAAK,gBAAgBwB,CAAG,GAGzB,KAAK,YAAY;GACjB,IAAIO,IAAQ,KAAK,aACbC,IAAS,KAAK,cACdrB,IAAW,KAAK,gBAChBsB,IAAOtB,IAAW,GAClBwB,IAAMC,EAAMP,CAAW,IAAII,GAC3BI,IAAY;GAEhB,SAAY;IACX,IAAIC,IAAQP,EAAMI;IAClB,IAAGG,MAAU1C,GAAO;KACnB,IAAI4C,IAAWC,EAAQ,KAAA,CAAS,GAC5BF,IAASF,KAAa,IAAIA,IAAYF;KAQ1C,OAPA,EAAMI,KAAU1C,GAChB,EAAMc,IAAW4B,KAAUV,GAC3B,EAAOU,KAAUC,GACjB,EAAKpC,EAAa,IACfiC,KAAa,KACf,EAAKhC,EAAgB,IAEfmC;IACR;IAAO,IAAGF,MAAUxC,GAAW;KAC9B,IAAGqC,MAAQE,GACV,OAAO,KAAK,eAAeF,GAAKN,GAAaY,CAAO;KAErD,AAAGJ,IAAY,MACd,IAAYF;IAEd,OAAO,IAAGJ,EAAMpB,IAAWwB,OAASN,GAAa;KAChD,IAAIW,IAAWC,EAAQT,EAAOG,EAAI;KAElC,OADA,EAAOA,KAAOK,GACPA;IACR;IAEA,IAAOL,IAAM,IAAKF;GACnB;EACD,UAAU;GACT,EAAO,KAAK,IAAI;EACjB;CACD;CAGA,gBAAwB,GAAQ;EAC/B,IAAIS,IAAS,KAAK,cAAc,KAAKtC,IACjCO,IAAW,KAAK,cAAc,KAAKL;EACvC,IAAGK,IAAW,KAAK,qBAAqB+B,IAAS,KAAKzC,KAAoBU,IAAWX,GACpF,KAAK,OAAO;OACN,IAAG0C,MAAW/B,KAAY,KAAK,UAAUa,CAAG,MAAM,KAAA,GACxD,MAAU,MAAM,iCAAiCb,EAAS,mHACJ;CAExD;CAEA,eAAuB,GAAa,GAAqB,GAAwF;EAChJ,IAAI6B,IAAW,OAAOG,KAAmB,aAAaA,EAAe,KAAA,CAAS,IAAIA,GAC9EZ,IAAQ,KAAK,aACbC,IAAS,KAAK;EAMlB,OALA,EAAMG,KAAOtC,GACb,EAAM,KAAK,iBAAiBsC,KAAON,GACnC,EAAOM,KAAOK,GACd,KAAK,cAAc,KAAKpC,EAAa,IACrC,KAAK,cAAc,KAAKC,EAAgB,IACjCmC;CACR;CAEA,IAAI,GAA+B;EAClC,EAAK,KAAK,IAAI;EACd,IAAI;GACH,OAAO,KAAK,UAAUhB,CAAG;EAC1B,UAAU;GACT,EAAO,KAAK,IAAI;EACjB;CACD;CAEA,OAAO,GAAiD;EACvD,EAAK,KAAK,IAAI;EACd,IAAI;GACH,IAAIQ,IAAuC,CAAC;GAC5C,KAAI,IAAIR,KAAOoB,GACd,EAAO,KAAK,KAAK,UAAUpB,CAAG,CAAC;GAEhC,OAAOQ;EACR,UAAU;GACT,EAAO,KAAK,IAAI;EACjB;CACD;CAEA,UAAkB,GAA+B;EAChD,IAAIH,IAAcC,EAAaN,CAAG;EAClC,KAAK,YAAY;EACjB,IAAIO,IAAQ,KAAK,aACbC,IAAS,KAAK,cACdrB,IAAW,KAAK,gBAChBsB,IAAOtB,IAAW,GAClBuB,IAAWvB,GACXwB,IAAMC,EAAMP,CAAW,IAAII,GAC3BY,IAAQV;EACZ,GAAG;GACF,IAAIG,IAAQP,EAAMI;GAClB,IAAGG,MAAU1C,GACZ;GAED,IAAG0C,MAAUzC,KAAQkC,EAAMG,IAAWC,OAASN,GAC9C,OAAOG,EAAOG;GAEf,IAAOA,IAAM,IAAKF;EACnB,SAAQE,MAAQU;CAEjB;CACA,IAAI,GAAiB;EACpB,OAAO,KAAK,IAAIrB,CAAG,MAAM,KAAA;CAC1B;CAEA,OAAO,GAAiB;EACvB,IAAIK,IAAcC,EAAaN,CAAG;EAElC,EAAK,KAAK,IAAI;EACd,IAAI;GACH,KAAK,YAAY;GACjB,IAAIf,IAAO,KAAK,cAAc,MAC1BsB,IAAQ,KAAK,aACbpB,IAAW,KAAK,gBAChBsB,IAAOtB,IAAW,GAClBuB,IAAWvB,GACXwB,IAAMC,EAAMP,CAAW,IAAII,GAC3BY,IAAQV;GACZ,GAAG;IACF,IAAIG,IAAQP,EAAMI;IAClB,IAAGG,MAAU1C,GACZ,OAAO;IAER,IAAG0C,MAAUzC,KAAQkC,EAAMG,IAAWC,OAASN,GAI9C,OAHA,EAAMM,KAAOrC,GACb,EAAKM,EAAa,IAClB,EAAKC,EAAgB,IACd;IAER,IAAO8B,IAAM,IAAKF;GACnB,SAAQE,MAAQU;GAChB,OAAO;EACR,UAAU;GACT,EAAO,KAAK,IAAI;EACjB;CACD;CAGA,EAAE,OAAO,YAAmD;EAC3D,KAAK,YAAY;EACjB,IAAId,IAAQ,KAAK,aACbC,IAAS,KAAK,cACdrB,IAAW,KAAK,gBAChBuB,IAAWvB;EACf,KAAI,IAAI,IAAI,GAAG,IAAIA,GAAU,KAC5B,AAAGoB,EAAM,OAAOlC,MACf,MAAM,CAACkC,EAAMG,IAAW,IAAIF,EAAO,EAAE;CAGxC;CAIA,OAAe,GAA4B;EAC1C,KAAK,YAAY;EACjB,IAAIc,IAAW,KAAK,mBAChBC,IAAW,KAAK,aAChBC,IAAY,KAAK,cACjBC,IAAc,KAAK,gBACnBC,IAAcD,GACdP,IAAS,QAAQ,KAAK,KAAK,cAAc,MAAMtC,CAAY,GAE3D+C,IAAc7B,KAAqB2B;EAOvC,IANG3B,MAAsB,KAAA,MAAcoB,IAAS,KAAKzC,IAAmBgD,IAAcjD,MACrF,IAAciD,IAAc,IAK1B,KAAK,YAAYE,CAAW,IAAI,KAAK,OAAO,qBAAqB;GACnE,IAAIC,IAAa,KAAK,MAAM,KAAK,OAAO,uBAAuB,IAAI,KAAK,oBAAoBpD,IAAiBC,CAAgB;GAC7H,MAAU,MAAM,oCAAoCkD,EAAY,8DAC9C,KAAK,OAAO,oBAAoB,UAAUC,EAAW,6DAA6D;EACrI;EACA,IAAIC,IAAW,KAAK,OAAO,UAAU,KAAK,YAAYF,CAAW,CAAC,GAC9DG,IAAWD,EAAS,MACpBE,IAAY,KAAK,eAAeF,GAAUF,CAAW,GACrDlB,IAAOkB,IAAc,GACrBK,IAAcL;EAElB,KAAI,IAAIM,IAAI,GAAGA,IAAIR,GAAa,KAAK;GACpC,IAAGF,EAASU,OAAO5D,GAClB;GAGD,IAAI2B,IAAMuB,EAASG,IAAcO,IAC7BhC,IAAQuB,EAAUS,IAClBtB,IAAMC,EAAMZ,CAAG,IAAIS;GAEvB,OAAMqB,EAASnB,OAASvC,IACvB,IAAOuC,IAAM,IAAKF;GAInB,AAFA,EAASE,KAAOtC,GAChB,EAAS2D,IAAcrB,KAAOX,GAC9B,EAAUW,KAAOV;EAClB;EAQA,AANAF,EAAgB,KAAK,cAAc,MAAMrB,GAAqBmD,EAAS,OAAO,GAC9E,QAAQ,MAAM,KAAK,cAAc,MAAM/C,GAAgB6C,CAAW,GAClE,QAAQ,MAAM,KAAK,cAAc,MAAM9C,GAAiB,CAAC,GAEzD,KAAK,qBAAqB,GAC1B,KAAK,cAAc,KAAA,GACnByC,EAAS,KAAK;CACf;CAEA,OAAO;EAGN,AAFA,KAAK,YAAY,GACjB,KAAK,kBAAmB,KAAK,GAC1B,KAAK,kBACP,KAAK,cAAc,KAAK;CAE1B;CAEA,kBAAmC;EAClC,OAAO,EACN,YAAY,KAAK,cAAc,gBAAgB,EAChD;CACD;AACD"}

package/dist/shared-pointer-list.js.map

@@ -1 +1 @@
-{"version":3,"file":"shared-pointer-list.js","names":[],"sources":["../src/shared-pointer-list.ts"],"sourcesContent":["import AllocatedMemory from './allocated-memory';\nimport type MemoryHeap from './memory-heap';\nimport type { SharedListMemory } from './shared-list';\nimport SharedList from './shared-list';\nimport { createPointer, loadPointer } from './utils/pointer';\n\nexport default abstract class SharedPointerList<T extends PointerItem> implements Iterable<T> {\n\tprivate memory: MemoryHeap;\n\tprivate list: SharedList;\n\n\tconstructor(heap: MemoryHeap, memory?: SharedListMemory) {\n\t\tthis.memory = heap;\n\n\t\tif(memory) {\n\t\t\tthis.list = new SharedList(heap, memory);\n\t\t} else {\n\t\t\tthis.list = new SharedList(heap);\n\t\t}\n\t}\n\n\tget length() {\n\t\treturn this.list.length;\n\t}\n\n\tinsert(item: T) {\n\t\tthis.list.insert(createPointer(item.memory.bufferPosition, item.memory.bufferByteOffset, this.memory.positionBits));\n\t}\n\tdelete(item: T) {\n\t\tlet deleted = this.list.deleteValue(createPointer(item.memory.bufferPosition, item.memory.bufferByteOffset, this.memory.positionBits));\n\t\t// This wrapper is single-threaded per instance, so reclaim the tombstoned node right away\n\t\tthis.list.compact();\n\t\treturn deleted;\n\t}\n\n\tcompact() {\n\t\tthis.list.compact();\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tlet iterator = this.list[Symbol.iterator]();\n\n\t\tfor(let { data: pointerData } of iterator) {\n\t\t\tlet { bufferPosition, bufferByteOffset } = loadPointer(pointerData, 0, this.memory.positionBits);\n\t\t\tlet allocatedMemory = new AllocatedMemory(this.memory, {\n\t\t\t\tbufferPosition,\n\t\t\t\tbufferByteOffset,\n\t\t\t});\n\t\t\tyield this.createItem(allocatedMemory);\n\t\t}\n\t}\n\tforEach(callback: (item: T) => void) {\n\t\tfor(let value of this) {\n\t\t\tcallback(value);\n\t\t}\n\t}\n\n\tfind(callback: (item: T) => boolean): T | undefined {\n\t\tfor(let value of this) {\n\t\t\tif(callback(value)) {\n\t\t\t\treturn value;\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\tgetSharedMemory() {\n\t\treturn this.list.getSharedMemory();\n\t}\n\n\tprotected abstract createItem(allocatedMemory: AllocatedMemory): T;\n\n\tfree() {\n\t\tfor(let item of this) {\n\t\t\t// NOTE: Anything that allocates it's own memory (ie: type for Item) needs to call free for that class so we can clear all memory recursively\n\t\t\tif('free' in item && typeof item.free === 'function') {\n\t\t\t\titem.free();\n\t\t\t} else {\n\t\t\t\titem.memory.free();\n\t\t\t}\n\t\t}\n\n\t\tthis.list.free();\n\t}\n}\n\ninterface PointerItem {\n\treadonly memory: AllocatedMemory\n}"],"mappings":";;;;AAMA,IAA8B,IAA9B,MAA8F;CAC7F;CACA;CAEA,YAAY,GAAkB,GAA2B;EAGxD,AAFA,KAAK,SAAS,GAEd,AAGC,KAAK,OAHH,IACU,IAAI,EAAW,GAAM,CAAM,IAE3B,IAAI,EAAW,CAAI;CAEjC;CAEA,IAAI,SAAS;EACZ,OAAO,KAAK,KAAK;CAClB;CAEA,OAAO,GAAS;EACf,KAAK,KAAK,OAAO,EAAc,EAAK,OAAO,gBAAgB,EAAK,OAAO,kBAAkB,KAAK,OAAO,YAAY,CAAC;CACnH;CACA,OAAO,GAAS;EACf,IAAI,IAAU,KAAK,KAAK,YAAY,EAAc,EAAK,OAAO,gBAAgB,EAAK,OAAO,kBAAkB,KAAK,OAAO,YAAY,CAAC;EAGrI,OADA,KAAK,KAAK,QAAQ,GACX;CACR;CAEA,UAAU;EACT,KAAK,KAAK,QAAQ;CACnB;CAEA,EAAE,OAAO,YAAY;EACpB,IAAI,IAAW,KAAK,KAAK,OAAO,SAAS,CAAC;EAE1C,KAAI,IAAI,EAAE,MAAM,OAAiB,GAAU;GAC1C,IAAI,EAAE,mBAAgB,wBAAqB,EAAY,GAAa,GAAG,KAAK,OAAO,YAAY,GAC3F,IAAkB,IAAI,EAAgB,KAAK,QAAQ;IACtD;IACA;GACD,CAAC;GACD,MAAM,KAAK,WAAW,CAAe;EACtC;CACD;CACA,QAAQ,GAA6B;EACpC,KAAI,IAAI,KAAS,MAChB,EAAS,CAAK;CAEhB;CAEA,KAAK,GAA+C;EACnD,KAAI,IAAI,KAAS,MAChB,IAAG,EAAS,CAAK,GAChB,OAAO;CAKV;CAEA,kBAAkB;EACjB,OAAO,KAAK,KAAK,gBAAgB;CAClC;CAIA,OAAO;EACN,KAAI,IAAI,KAAQ,MAEf,AAAG,UAAU,KAAQ,OAAO,EAAK,QAAS,aACzC,EAAK,KAAK,IAEV,EAAK,OAAO,KAAK;EAInB,KAAK,KAAK,KAAK;CAChB;AACD"}
+{"version":3,"file":"shared-pointer-list.js","names":["AllocatedMemory","SharedList","SharedPointerList","heap","memory","createPointer","item","deleted","iterator","pointerData","loadPointer","allocatedMemory","value","callback"],"sources":["../src/shared-pointer-list.ts"],"sourcesContent":["import AllocatedMemory from './allocated-memory';\nimport type MemoryHeap from './memory-heap';\nimport type { SharedListMemory } from './shared-list';\nimport SharedList from './shared-list';\nimport { createPointer, loadPointer } from './utils/pointer';\n\nexport default abstract class SharedPointerList<T extends PointerItem> implements Iterable<T> {\n\tprivate memory: MemoryHeap;\n\tprivate list: SharedList;\n\n\tconstructor(heap: MemoryHeap, memory?: SharedListMemory) {\n\t\tthis.memory = heap;\n\n\t\tif(memory) {\n\t\t\tthis.list = new SharedList(heap, memory);\n\t\t} else {\n\t\t\tthis.list = new SharedList(heap);\n\t\t}\n\t}\n\n\tget length() {\n\t\treturn this.list.length;\n\t}\n\n\tinsert(item: T) {\n\t\tthis.list.insert(createPointer(item.memory.bufferPosition, item.memory.bufferByteOffset, this.memory.positionBits));\n\t}\n\tdelete(item: T) {\n\t\tlet deleted = this.list.deleteValue(createPointer(item.memory.bufferPosition, item.memory.bufferByteOffset, this.memory.positionBits));\n\t\t// This wrapper is single-threaded per instance, so reclaim the tombstoned node right away\n\t\tthis.list.compact();\n\t\treturn deleted;\n\t}\n\n\tcompact() {\n\t\tthis.list.compact();\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tlet iterator = this.list[Symbol.iterator]();\n\n\t\tfor(let { data: pointerData } of iterator) {\n\t\t\tlet { bufferPosition, bufferByteOffset } = loadPointer(pointerData, 0, this.memory.positionBits);\n\t\t\tlet allocatedMemory = new AllocatedMemory(this.memory, {\n\t\t\t\tbufferPosition,\n\t\t\t\tbufferByteOffset,\n\t\t\t});\n\t\t\tyield this.createItem(allocatedMemory);\n\t\t}\n\t}\n\tforEach(callback: (item: T) => void) {\n\t\tfor(let value of this) {\n\t\t\tcallback(value);\n\t\t}\n\t}\n\n\tfind(callback: (item: T) => boolean): T | undefined {\n\t\tfor(let value of this) {\n\t\t\tif(callback(value)) {\n\t\t\t\treturn value;\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\tgetSharedMemory() {\n\t\treturn this.list.getSharedMemory();\n\t}\n\n\tprotected abstract createItem(allocatedMemory: AllocatedMemory): T;\n\n\tfree() {\n\t\tfor(let item of this) {\n\t\t\t// NOTE: Anything that allocates it's own memory (ie: type for Item) needs to call free for that class so we can clear all memory recursively\n\t\t\tif('free' in item && typeof item.free === 'function') {\n\t\t\t\titem.free();\n\t\t\t} else {\n\t\t\t\titem.memory.free();\n\t\t\t}\n\t\t}\n\n\t\tthis.list.free();\n\t}\n}\n\ninterface PointerItem {\n\treadonly memory: AllocatedMemory\n}"],"mappings":";;;;AAMA,IAA8BE,IAA9B,MAA8F;CAC7F;CACA;CAEA,YAAY,GAAkB,GAA2B;EAGxD,AAFA,KAAK,SAASC,GAEd,AAGC,KAAK,OAHHC,IACU,IAAIH,EAAWE,GAAMC,CAAM,IAE3B,IAAIH,EAAWE,CAAI;CAEjC;CAEA,IAAI,SAAS;EACZ,OAAO,KAAK,KAAK;CAClB;CAEA,OAAO,GAAS;EACf,KAAK,KAAK,OAAOE,EAAcC,EAAK,OAAO,gBAAgBA,EAAK,OAAO,kBAAkB,KAAK,OAAO,YAAY,CAAC;CACnH;CACA,OAAO,GAAS;EACf,IAAIC,IAAU,KAAK,KAAK,YAAYF,EAAcC,EAAK,OAAO,gBAAgBA,EAAK,OAAO,kBAAkB,KAAK,OAAO,YAAY,CAAC;EAGrI,OADA,KAAK,KAAK,QAAQ,GACXC;CACR;CAEA,UAAU;EACT,KAAK,KAAK,QAAQ;CACnB;CAEA,EAAE,OAAO,YAAY;EACpB,IAAIC,IAAW,KAAK,KAAK,OAAO,SAAS,CAAC;EAE1C,KAAI,IAAI,EAAE,MAAMC,OAAiBD,GAAU;GAC1C,IAAI,EAAE,mBAAgB,wBAAqBE,EAAYD,GAAa,GAAG,KAAK,OAAO,YAAY,GAC3FE,IAAkB,IAAIX,EAAgB,KAAK,QAAQ;IACtD;IACA;GACD,CAAC;GACD,MAAM,KAAK,WAAWW,CAAe;EACtC;CACD;CACA,QAAQ,GAA6B;EACpC,KAAI,IAAIC,KAAS,MAChB,EAASA,CAAK;CAEhB;CAEA,KAAK,GAA+C;EACnD,KAAI,IAAIA,KAAS,MAChB,IAAGC,EAASD,CAAK,GAChB,OAAOA;CAKV;CAEA,kBAAkB;EACjB,OAAO,KAAK,KAAK,gBAAgB;CAClC;CAIA,OAAO;EACN,KAAI,IAAIN,KAAQ,MAEf,AAAG,UAAUA,KAAQ,OAAOA,EAAK,QAAS,aACzCA,EAAK,KAAK,IAEVA,EAAK,OAAO,KAAK;EAInB,KAAK,KAAK,KAAK;CAChB;AACD"}

package/dist/shared-pool.js.map

@@ -1 +1 @@
-{"version":3,"file":"shared-pool.js","names":[],"sources":["../src/shared-pool.ts"],"sourcesContent":["import type { SharedAllocatedMemory } from './allocated-memory';\nimport AllocatedMemory from './allocated-memory';\nimport { lock, unlock } from './lock/simple-lock';\nimport type MemoryHeap from './memory-heap';\nimport SharedStack from './shared-stack';\nimport { getPointer, loadRawPointer, storeRawPointer } from './utils/pointer';\nimport { getArrayTypeCode, getByteMultipler, makeArrayView, type NumericArray, type NumericArrayIO, type TypedArrayConstructor } from './utils/array-type';\n\nconst LENGTH_INDEX = 0;\nconst TYPE_INDEX = 1;\nconst MAX_CHUNK_SIZE_INDEX = 2;\n// Guards appending a chunk pointer so only one thread grows the pointer stack at a time\nconst GROW_LOCK_INDEX = 3;\n// Pointers to the two backing SharedStacks (their own firstBlocks): the chunk pointers and the recycled indexes\nconst POINTER_STACK_INDEX = 4;\nconst RECYCLE_STACK_INDEX = 5;\n\nconst DEFAULT_MAX_CHUNK_SIZE = 100;\nconst DEFAULT_MAX_LENGTH = 1_000_000;\nconst DEFAULT_MAX_RECYCLED_LENGTH = 100_000;\n\n// Array with stable indexes and maximum contiguous memory sizes (necessary to fit large data sets into max 1MB buffers).\n// The chunk pointers and the recycled indexes both live in SharedStacks, whose segments are never moved or freed once\n// published, so concurrent readers never touch memory that is being reclaimed.\n// https://plflib.org/colony.htm for future enhancements - it seems to be an optimized version of what we were aiming for with this\nexport default class SharedPool<T extends NumericArray = Uint32Array> implements Iterable<T> {\n\tstatic readonly ALLOCATE_COUNT = 6;\n\n\t// u32s a pool with this config needs for its firstBlock, including both inlined stacks. Lets an owner (e.g.\n\t// SharedQuadtree) reserve one contiguous slice and hand it back through the config's firstBlock to inline the pool.\n\tstatic getAllocateCount(memory: MemoryHeap, config?: SharedPoolConfig<NumericArray>): number {\n\t\tlet maxChunkSize = config?.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;\n\t\tlet maxLength = config?.maxLength ?? DEFAULT_MAX_LENGTH;\n\t\tlet maxRecycledLength = config?.maxRecycledLength ?? DEFAULT_MAX_RECYCLED_LENGTH;\n\t\tlet maxSegmentLength = SharedStack.getMaxSegmentLength(memory.maxAllocationLength);\n\t\tlet pointerStackAllocateCount = SharedStack.getAllocateCount(maxLength / maxChunkSize, undefined, maxSegmentLength);\n\t\tlet recycleStackAllocateCount = SharedStack.getAllocateCount(maxRecycledLength, undefined, maxSegmentLength);\n\t\treturn SharedPool.ALLOCATE_COUNT + pointerStackAllocateCount + recycleStackAllocateCount;\n\t}\n\n\tprivate memory: MemoryHeap;\n\n\t// Current Length, Type/DataLength, MaxChunkLength, Grow lock, Pointer stack, Recycle stack\n\tprivate firstBlock: AllocatedMemory;\n\tprivate uint16Array: Uint16Array;\n\tprivate growLock: Int32Array;\n\tprivate pointerStack!: SharedStack;\n\tprivate recycleStack!: SharedStack;\n\treadonly maxLength: number;\n\n\t// False when firstBlock is a slice of another structure's memory (e.g. inlined in SharedQuadtree); that owner frees it\n\tprivate ownsFirstBlock: boolean;\n\n\t// Chunk views cached by pointer index. An array (dense, small integer keys) resolves faster than an object on the hot\n\t// get/set path and never needs rehashing.\n\tprivate cachedFullDataBlock: Array<T | undefined> = [];\n\n\t// Config is written once at construction and never mutated, so it is cached in plain fields\n\tprivate readonly cachedMaxChunkSize: number;\n\tprivate readonly cachedDataLength: number;\n\tprivate readonly cachedType: number;\n\tprivate readonly cachedByteMultipler: number;\n\n\tget length(): number {\n\t\treturn Atomics.load(this.firstBlock.data, LENGTH_INDEX) - this.recycleStack.length;\n\t}\n\tget maxChunkSize(): number {\n\t\treturn this.cachedMaxChunkSize;\n\t}\n\tprivate set maxChunkSize(value: number) {\n\t\tAtomics.store(this.firstBlock.data, MAX_CHUNK_SIZE_INDEX, value);\n\t}\n\n\tget type(): number {\n\t\treturn this.cachedType;\n\t}\n\tprivate set type(value: number) {\n\t\tAtomics.store(this.uint16Array, 0, value);\n\t}\n\tget dataLength(): number {\n\t\treturn this.cachedDataLength;\n\t}\n\tprivate set dataLength(value: number) {\n\t\tAtomics.store(this.uint16Array, 1, value);\n\t}\n\n\tget bufferLength(): number {\n\t\treturn this.cachedMaxChunkSize * this.pointerStack.length;\n\t}\n\tget byteMultipler(): number {\n\t\treturn this.cachedByteMultipler;\n\t}\n\n\t// Own internal memory (which already includes both stacks' inlined firstBlocks) plus every chunk buffer and the\n\t// segments each stack has grown. The stacks' usedMemory excludes their inlined firstBlocks, so they aren't double-counted.\n\tget usedMemory(): number {\n\t\tlet total = this.ownsFirstBlock ? this.firstBlock.usedMemory : 0;\n\t\tfor(let pointer of this.pointerStack) {\n\t\t\ttotal += new AllocatedMemory(this.memory, getPointer(pointer, this.memory.positionBits)).usedMemory;\n\t\t}\n\t\treturn total + this.pointerStack.usedMemory + this.recycleStack.usedMemory;\n\t}\n\n\tconstructor(memory: MemoryHeap, config?: SharedPoolConfig<T> | SharedPoolMemory | SharedPoolMemory & SharedPoolConfig<T>) {\n\t\tthis.memory = memory;\n\n\t\tif(config && 'firstBlock' in config) {\n\t\t\t// An AllocatedMemory instance is a caller-reserved slice (e.g. inlined in SharedQuadtree); a plain pointer is the\n\t\t\t// serialized clone path. Taking the instance directly keeps us off the pointer-resolving construction branch.\n\t\t\tthis.firstBlock = config.firstBlock instanceof AllocatedMemory\n\t\t\t\t? config.firstBlock\n\t\t\t\t: new AllocatedMemory(memory, { length: SharedPool.ALLOCATE_COUNT, ...config.firstBlock });\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\n\t\t\t// Memory passed together with config means the caller reserved the firstBlock slot for us to initialize in place\n\t\t\tif('type' in config || 'dataLength' in config || 'maxLength' in config || 'maxChunkSize' in config || 'maxRecycledLength' in config) {\n\t\t\t\tthis.initialize(config);\n\t\t\t\tthis.ownsFirstBlock = false;\n\t\t\t} else {\n\t\t\t\tthis.pointerStack = new SharedStack(memory, {\n\t\t\t\t\tfirstBlock: getPointer(loadRawPointer(this.firstBlock.data, POINTER_STACK_INDEX), memory.positionBits),\n\t\t\t\t});\n\t\t\t\tthis.recycleStack = new SharedStack(memory, {\n\t\t\t\t\tfirstBlock: getPointer(loadRawPointer(this.firstBlock.data, RECYCLE_STACK_INDEX), memory.positionBits),\n\t\t\t\t});\n\t\t\t\tthis.ownsFirstBlock = true;\n\t\t\t}\n\t\t} else {\n\t\t\tthis.firstBlock = memory.allocUI32(SharedPool.getAllocateCount(memory, config));\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\t\t\tthis.initialize(config);\n\t\t\tthis.ownsFirstBlock = true;\n\t\t}\n\n\t\tthis.cachedType = this.uint16Array[0];\n\t\tthis.cachedDataLength = Math.max(1, this.uint16Array[1]);\n\t\tthis.cachedMaxChunkSize = this.firstBlock.data[MAX_CHUNK_SIZE_INDEX];\n\t\tthis.cachedByteMultipler = getByteMultipler(this.cachedType);\n\t\tthis.maxLength = this.cachedMaxChunkSize * this.pointerStack.maxLength;\n\n\t\tthis.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + GROW_LOCK_INDEX * Uint32Array.BYTES_PER_ELEMENT, 1);\n\t}\n\n\t// Lay out the two inlined stacks (their firstBlocks sliced from ours), record their pointers, and seed the first chunk.\n\t// firstBlock and uint16Array must already be set. Used by both the fresh-alloc path and the inline-in-place path.\n\tprivate initialize(config?: SharedPoolConfig<T>) {\n\t\tlet dataLength = config?.dataLength ?? 1;\n\t\tlet maxChunkSize = config?.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;\n\t\tlet maxLength = config?.maxLength ?? DEFAULT_MAX_LENGTH;\n\t\tlet maxRecycledLength = config?.maxRecycledLength ?? DEFAULT_MAX_RECYCLED_LENGTH;\n\n\t\t// Each stack sizes its inlined firstBlock from its own maxLength, so compute both up front to lay them out. The\n\t\t// stacks cap their segments at what a buffer can hold, so size the inlined blocks against that same cap.\n\t\tlet maxSegmentLength = SharedStack.getMaxSegmentLength(this.memory.maxAllocationLength);\n\t\tlet pointerStackMaxLength = maxLength / maxChunkSize;\n\t\tlet pointerStackAllocateCount = SharedStack.getAllocateCount(pointerStackMaxLength, undefined, maxSegmentLength);\n\t\tlet recycleStackAllocateCount = SharedStack.getAllocateCount(maxRecycledLength, undefined, maxSegmentLength);\n\n\t\t// Inline both stacks' firstBlocks right after the pool header so the whole spine is one contiguous allocation\n\t\tthis.pointerStack = new SharedStack(this.memory, {\n\t\t\tfirstBlock: this.firstBlock.getSubAllocation(SharedPool.ALLOCATE_COUNT, pointerStackAllocateCount),\n\t\t\ttype: Uint32Array,\n\t\t\tmaxLength: pointerStackMaxLength,\n\t\t});\n\t\tstoreRawPointer(this.firstBlock.data, POINTER_STACK_INDEX, this.pointerStack.pointer);\n\t\tthis.recycleStack = new SharedStack(this.memory, {\n\t\t\tfirstBlock: this.firstBlock.getSubAllocation(SharedPool.ALLOCATE_COUNT + pointerStackAllocateCount, recycleStackAllocateCount),\n\t\t\ttype: Uint32Array,\n\t\t\tmaxLength: maxRecycledLength,\n\t\t});\n\t\tstoreRawPointer(this.firstBlock.data, RECYCLE_STACK_INDEX, this.recycleStack.pointer);\n\n\t\tlet typeCode = getArrayTypeCode(config?.type ?? Uint32Array);\n\t\tthis.type = typeCode;\n\t\tthis.dataLength = dataLength;\n\t\tthis.maxChunkSize = maxChunkSize;\n\n\t\tlet byteMultipler = getByteMultipler(typeCode);\n\t\tlet firstArray = this.memory.allocUI32(maxChunkSize * dataLength * byteMultipler);\n\t\tthis.pointerStack.push(firstArray.pointer);\n\t}\n\n\tat(index: number): T {\n\t\tlet dataBlock = this.getFullDataBlock(index);\n\t\treturn this.getDataBlock(dataBlock, index % this.cachedMaxChunkSize);\n\t}\n\tget(index: number, dataIndex = 0): T[number] {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tif(dataIndex >= dataLength) {\n\t\t\tthrow new Error(`${dataIndex} is out of dataLength bounds ${dataLength}`);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(index) as NumericArrayIO;\n\t\treturn dataBlock[(index % this.cachedMaxChunkSize) * dataLength + dataIndex];\n\t}\n\tset(index: number, dataIndex: number, value: T[number]) {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tif(dataIndex >= dataLength) {\n\t\t\tthrow new Error(`${dataIndex} is out of dataLength bounds ${dataLength}`);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(index) as NumericArrayIO;\n\t\tdataBlock[(index % this.cachedMaxChunkSize) * dataLength + dataIndex] = value;\n\t}\n\n\t// Resolve the chunk view holding an index once. Callers touching several fields of the same record read/write straight\n\t// into this view at blockOffset(index) + fieldIndex, avoiding a repeated chunk lookup per field.\n\tblockFor(index: number): T {\n\t\treturn this.getFullDataBlock(index);\n\t}\n\t// Base slot of a record within the view blockFor(index) returns.\n\tblockOffset(index: number): number {\n\t\treturn (index % this.cachedMaxChunkSize) * this.cachedDataLength;\n\t}\n\n\tpush(values: T[number] | Array<T[number]>): number {\n\t\tlet dataLength = this.cachedDataLength;\n\t\tconst isSingleValue = typeof values !== 'object';\n\t\tif(!isSingleValue && values.length > dataLength) {\n\t\t\tthrow new Error(`Can't insert ${values.length} array into shared list of ${dataLength} dataLength`);\n\t\t}\n\n\t\t// Reuse a recycled index if one is available. pop() can come back undefined when another thread drained the last\n\t\t// slot between our two calls, so fall through to a fresh index rather than trusting a length() read\n\t\tlet newIndex = this.recycleStack.length === 0 ? undefined : this.recycleStack.pop();\n\t\tif(newIndex === undefined) {\n\t\t\tnewIndex = Atomics.add(this.firstBlock.data, LENGTH_INDEX, 1);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(newIndex) as NumericArrayIO;\n\t\tlet startIndex = dataLength * (newIndex % this.cachedMaxChunkSize);\n\t\tif(isSingleValue) {\n\t\t\tdataBlock[startIndex] = values;\n\t\t} else {\n\t\t\tfor(let i = 0; i < values.length; i++) {\n\t\t\t\tdataBlock[startIndex + i] = values[i];\n\t\t\t}\n\t\t}\n\n\t\treturn newIndex;\n\t}\n\n\treserveContiguous(count: number): number {\n\t\tif(!Number.isInteger(count) || count < 0) {\n\t\t\tthrow new Error(`Can't reserve ${count} pool entries`);\n\t\t}\n\t\treturn Atomics.add(this.firstBlock.data, LENGTH_INDEX, count);\n\t}\n\n\tdeleteIndex(index: number) {\n\t\tthis.recycleStack.push(index);\n\t}\n\n\tclear() {\n\t\tthis.firstBlock.data[LENGTH_INDEX] = 0;\n\t\tthis.recycleStack.clear();\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tconst recycledValues: { [key: number]: true } = {};\n\t\tfor(let value of this.recycleStack) {\n\t\t\trecycledValues[value] = true;\n\t\t}\n\n\t\tconst maxChunkSize = this.cachedMaxChunkSize;\n\t\t// Snapshot the length once - iteration over a concurrently mutated pool is a snapshot anyway, and re-loading the\n\t\t// atomic every step is pure overhead\n\t\tconst length = Atomics.load(this.firstBlock.data, LENGTH_INDEX);\n\t\tlet dataBlock = this.getFullDataBlock(0);\n\t\tlet dataBlockIndex = 0;\n\t\tfor(let i = 0; i < length; i++) {\n\t\t\tif(!recycledValues[i]) {\n\t\t\t\tlet newDataBlockIndex = Math.floor(i / maxChunkSize);\n\t\t\t\tif(newDataBlockIndex !== dataBlockIndex) {\n\t\t\t\t\tdataBlock = this.getFullDataBlock(i);\n\t\t\t\t\tdataBlockIndex = newDataBlockIndex;\n\t\t\t\t}\n\t\t\t\tyield this.getDataBlock(dataBlock, i % maxChunkSize);\n\t\t\t}\n\t\t}\n\t}\n\n\t*entries(): IterableIterator<[number, T]> {\n\t\tconst recycledValues: { [key: number]: true } = {};\n\t\tfor(let value of this.recycleStack) {\n\t\t\trecycledValues[value] = true;\n\t\t}\n\n\t\tconst maxChunkSize = this.cachedMaxChunkSize;\n\t\tconst length = Atomics.load(this.firstBlock.data, LENGTH_INDEX);\n\t\tlet dataBlock = this.getFullDataBlock(0);\n\t\tlet dataBlockIndex = 0;\n\t\tfor(let i = 0; i < length; i++) {\n\t\t\tif(!recycledValues[i]) {\n\t\t\t\tlet newDataBlockIndex = Math.floor(i / maxChunkSize);\n\t\t\t\tif(newDataBlockIndex !== dataBlockIndex) {\n\t\t\t\t\tdataBlock = this.getFullDataBlock(i);\n\t\t\t\t\tdataBlockIndex = newDataBlockIndex;\n\t\t\t\t}\n\t\t\t\tyield [i, this.getDataBlock(dataBlock, i % maxChunkSize)];\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getFullDataBlock(index: number) {\n\t\tlet pointerIndex = Math.floor(index / this.cachedMaxChunkSize);\n\t\tlet cachedDataBlock = this.cachedFullDataBlock[pointerIndex];\n\t\tif(cachedDataBlock) {\n\t\t\treturn cachedDataBlock;\n\t\t}\n\t\tif(pointerIndex >= this.pointerStack.length) {\n\t\t\t// Only let a single thread append a new chunk at a time - otherwise two concurrent inserts landing in a new\n\t\t\t// chunk would each allocate + push a buffer, orphaning one and leaking memory\n\t\t\tlock(this.growLock);\n\t\t\ttry {\n\t\t\t\t// Re-check under the lock: another thread may have already appended the chunk while we were waiting\n\t\t\t\twhile(pointerIndex >= this.pointerStack.length) {\n\t\t\t\t\tlet newArray = this.memory.allocUI32(this.cachedMaxChunkSize * this.cachedDataLength * this.cachedByteMultipler);\n\t\t\t\t\tthis.pointerStack.push(newArray.pointer);\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tunlock(this.growLock);\n\t\t\t}\n\t\t}\n\n\t\tlet array = new AllocatedMemory(this.memory, getPointer(this.pointerStack.at(pointerIndex), this.memory.positionBits));\n\n\t\tlet blockLength = this.cachedDataLength * this.cachedMaxChunkSize;\n\t\tlet data = makeArrayView(this.cachedType, array.data.buffer, array.bufferByteOffset, blockLength) as T;\n\n\t\tthis.cachedFullDataBlock[pointerIndex] = data;\n\t\treturn data;\n\t}\n\n\tprivate getDataBlock(rawData: T, index: number): T {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tconst start = index * dataLength;\n\t\treturn rawData.subarray(start, start + dataLength) as T;\n\t}\n\n\tfree() {\n\t\tthis.recycleStack.free();\n\n\t\tfor(let pointer of this.pointerStack) {\n\t\t\tlet memory = new AllocatedMemory(this.memory, getPointer(pointer, this.memory.positionBits));\n\t\t\tmemory.free();\n\t\t}\n\t\tthis.pointerStack.free();\n\t\tif(this.ownsFirstBlock) {\n\t\t\tthis.firstBlock.free();\n\t\t}\n\t}\n\n\tgetSharedMemory(): SharedPoolMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.firstBlock.getSharedMemory(),\n\t\t};\n\t}\n}\n\ninterface SharedPoolConfig<T extends NumericArray> {\n\tmaxChunkSize?: number\n\tmaxLength?: number\n\tmaxRecycledLength?: number\n\ttype?: TypedArrayConstructor<T>\n\tdataLength?: number\n}\ninterface SharedPoolMemory {\n\tfirstBlock: SharedAllocatedMemory | AllocatedMemory\n}\n\nexport type { SharedPoolConfig, SharedPoolMemory };\n"],"mappings":"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"}
+{"version":3,"file":"shared-pool.js","names":["AllocatedMemory","SharedStack","LENGTH_INDEX","TYPE_INDEX","MAX_CHUNK_SIZE_INDEX","GROW_LOCK_INDEX","POINTER_STACK_INDEX","RECYCLE_STACK_INDEX","DEFAULT_MAX_CHUNK_SIZE","DEFAULT_MAX_LENGTH","DEFAULT_MAX_RECYCLED_LENGTH","SharedPool","maxChunkSize","config","maxLength","maxRecycledLength","maxSegmentLength","memory","pointerStackAllocateCount","recycleStackAllocateCount","value","total","pointer","getPointer","loadRawPointer","getByteMultipler","dataLength","pointerStackMaxLength","storeRawPointer","typeCode","getArrayTypeCode","byteMultipler","firstArray","dataBlock","index","dataIndex","isSingleValue","values","newIndex","startIndex","i","count","recycledValues","length","dataBlockIndex","newDataBlockIndex","pointerIndex","cachedDataBlock","newArray","array","blockLength","data","makeArrayView","start","rawData"],"sources":["../src/shared-pool.ts"],"sourcesContent":["import type { SharedAllocatedMemory } from './allocated-memory';\nimport AllocatedMemory from './allocated-memory';\nimport { lock, unlock } from './lock/simple-lock';\nimport type MemoryHeap from './memory-heap';\nimport SharedStack from './shared-stack';\nimport { getPointer, loadRawPointer, storeRawPointer } from './utils/pointer';\nimport { getArrayTypeCode, getByteMultipler, makeArrayView, type NumericArray, type NumericArrayIO, type TypedArrayConstructor } from './utils/array-type';\n\nconst LENGTH_INDEX = 0;\nconst TYPE_INDEX = 1;\nconst MAX_CHUNK_SIZE_INDEX = 2;\n// Guards appending a chunk pointer so only one thread grows the pointer stack at a time\nconst GROW_LOCK_INDEX = 3;\n// Pointers to the two backing SharedStacks (their own firstBlocks): the chunk pointers and the recycled indexes\nconst POINTER_STACK_INDEX = 4;\nconst RECYCLE_STACK_INDEX = 5;\n\nconst DEFAULT_MAX_CHUNK_SIZE = 100;\nconst DEFAULT_MAX_LENGTH = 1_000_000;\nconst DEFAULT_MAX_RECYCLED_LENGTH = 100_000;\n\n// Array with stable indexes and maximum contiguous memory sizes (necessary to fit large data sets into max 1MB buffers).\n// The chunk pointers and the recycled indexes both live in SharedStacks, whose segments are never moved or freed once\n// published, so concurrent readers never touch memory that is being reclaimed.\n// https://plflib.org/colony.htm for future enhancements - it seems to be an optimized version of what we were aiming for with this\nexport default class SharedPool<T extends NumericArray = Uint32Array> implements Iterable<T> {\n\tstatic readonly ALLOCATE_COUNT = 6;\n\n\t// u32s a pool with this config needs for its firstBlock, including both inlined stacks. Lets an owner (e.g.\n\t// SharedQuadtree) reserve one contiguous slice and hand it back through the config's firstBlock to inline the pool.\n\tstatic getAllocateCount(memory: MemoryHeap, config?: SharedPoolConfig<NumericArray>): number {\n\t\tlet maxChunkSize = config?.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;\n\t\tlet maxLength = config?.maxLength ?? DEFAULT_MAX_LENGTH;\n\t\tlet maxRecycledLength = config?.maxRecycledLength ?? DEFAULT_MAX_RECYCLED_LENGTH;\n\t\tlet maxSegmentLength = SharedStack.getMaxSegmentLength(memory.maxAllocationLength);\n\t\tlet pointerStackAllocateCount = SharedStack.getAllocateCount(maxLength / maxChunkSize, undefined, maxSegmentLength);\n\t\tlet recycleStackAllocateCount = SharedStack.getAllocateCount(maxRecycledLength, undefined, maxSegmentLength);\n\t\treturn SharedPool.ALLOCATE_COUNT + pointerStackAllocateCount + recycleStackAllocateCount;\n\t}\n\n\tprivate memory: MemoryHeap;\n\n\t// Current Length, Type/DataLength, MaxChunkLength, Grow lock, Pointer stack, Recycle stack\n\tprivate firstBlock: AllocatedMemory;\n\tprivate uint16Array: Uint16Array;\n\tprivate growLock: Int32Array;\n\tprivate pointerStack!: SharedStack;\n\tprivate recycleStack!: SharedStack;\n\treadonly maxLength: number;\n\n\t// False when firstBlock is a slice of another structure's memory (e.g. inlined in SharedQuadtree); that owner frees it\n\tprivate ownsFirstBlock: boolean;\n\n\t// Chunk views cached by pointer index. An array (dense, small integer keys) resolves faster than an object on the hot\n\t// get/set path and never needs rehashing.\n\tprivate cachedFullDataBlock: Array<T | undefined> = [];\n\n\t// Config is written once at construction and never mutated, so it is cached in plain fields\n\tprivate readonly cachedMaxChunkSize: number;\n\tprivate readonly cachedDataLength: number;\n\tprivate readonly cachedType: number;\n\tprivate readonly cachedByteMultipler: number;\n\n\tget length(): number {\n\t\treturn Atomics.load(this.firstBlock.data, LENGTH_INDEX) - this.recycleStack.length;\n\t}\n\tget maxChunkSize(): number {\n\t\treturn this.cachedMaxChunkSize;\n\t}\n\tprivate set maxChunkSize(value: number) {\n\t\tAtomics.store(this.firstBlock.data, MAX_CHUNK_SIZE_INDEX, value);\n\t}\n\n\tget type(): number {\n\t\treturn this.cachedType;\n\t}\n\tprivate set type(value: number) {\n\t\tAtomics.store(this.uint16Array, 0, value);\n\t}\n\tget dataLength(): number {\n\t\treturn this.cachedDataLength;\n\t}\n\tprivate set dataLength(value: number) {\n\t\tAtomics.store(this.uint16Array, 1, value);\n\t}\n\n\tget bufferLength(): number {\n\t\treturn this.cachedMaxChunkSize * this.pointerStack.length;\n\t}\n\tget byteMultipler(): number {\n\t\treturn this.cachedByteMultipler;\n\t}\n\n\t// Own internal memory (which already includes both stacks' inlined firstBlocks) plus every chunk buffer and the\n\t// segments each stack has grown. The stacks' usedMemory excludes their inlined firstBlocks, so they aren't double-counted.\n\tget usedMemory(): number {\n\t\tlet total = this.ownsFirstBlock ? this.firstBlock.usedMemory : 0;\n\t\tfor(let pointer of this.pointerStack) {\n\t\t\ttotal += new AllocatedMemory(this.memory, getPointer(pointer, this.memory.positionBits)).usedMemory;\n\t\t}\n\t\treturn total + this.pointerStack.usedMemory + this.recycleStack.usedMemory;\n\t}\n\n\tconstructor(memory: MemoryHeap, config?: SharedPoolConfig<T> | SharedPoolMemory | SharedPoolMemory & SharedPoolConfig<T>) {\n\t\tthis.memory = memory;\n\n\t\tif(config && 'firstBlock' in config) {\n\t\t\t// An AllocatedMemory instance is a caller-reserved slice (e.g. inlined in SharedQuadtree); a plain pointer is the\n\t\t\t// serialized clone path. Taking the instance directly keeps us off the pointer-resolving construction branch.\n\t\t\tthis.firstBlock = config.firstBlock instanceof AllocatedMemory\n\t\t\t\t? config.firstBlock\n\t\t\t\t: new AllocatedMemory(memory, { length: SharedPool.ALLOCATE_COUNT, ...config.firstBlock });\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\n\t\t\t// Memory passed together with config means the caller reserved the firstBlock slot for us to initialize in place\n\t\t\tif('type' in config || 'dataLength' in config || 'maxLength' in config || 'maxChunkSize' in config || 'maxRecycledLength' in config) {\n\t\t\t\tthis.initialize(config);\n\t\t\t\tthis.ownsFirstBlock = false;\n\t\t\t} else {\n\t\t\t\tthis.pointerStack = new SharedStack(memory, {\n\t\t\t\t\tfirstBlock: getPointer(loadRawPointer(this.firstBlock.data, POINTER_STACK_INDEX), memory.positionBits),\n\t\t\t\t});\n\t\t\t\tthis.recycleStack = new SharedStack(memory, {\n\t\t\t\t\tfirstBlock: getPointer(loadRawPointer(this.firstBlock.data, RECYCLE_STACK_INDEX), memory.positionBits),\n\t\t\t\t});\n\t\t\t\tthis.ownsFirstBlock = true;\n\t\t\t}\n\t\t} else {\n\t\t\tthis.firstBlock = memory.allocUI32(SharedPool.getAllocateCount(memory, config));\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\t\t\tthis.initialize(config);\n\t\t\tthis.ownsFirstBlock = true;\n\t\t}\n\n\t\tthis.cachedType = this.uint16Array[0];\n\t\tthis.cachedDataLength = Math.max(1, this.uint16Array[1]);\n\t\tthis.cachedMaxChunkSize = this.firstBlock.data[MAX_CHUNK_SIZE_INDEX];\n\t\tthis.cachedByteMultipler = getByteMultipler(this.cachedType);\n\t\tthis.maxLength = this.cachedMaxChunkSize * this.pointerStack.maxLength;\n\n\t\tthis.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + GROW_LOCK_INDEX * Uint32Array.BYTES_PER_ELEMENT, 1);\n\t}\n\n\t// Lay out the two inlined stacks (their firstBlocks sliced from ours), record their pointers, and seed the first chunk.\n\t// firstBlock and uint16Array must already be set. Used by both the fresh-alloc path and the inline-in-place path.\n\tprivate initialize(config?: SharedPoolConfig<T>) {\n\t\tlet dataLength = config?.dataLength ?? 1;\n\t\tlet maxChunkSize = config?.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;\n\t\tlet maxLength = config?.maxLength ?? DEFAULT_MAX_LENGTH;\n\t\tlet maxRecycledLength = config?.maxRecycledLength ?? DEFAULT_MAX_RECYCLED_LENGTH;\n\n\t\t// Each stack sizes its inlined firstBlock from its own maxLength, so compute both up front to lay them out. The\n\t\t// stacks cap their segments at what a buffer can hold, so size the inlined blocks against that same cap.\n\t\tlet maxSegmentLength = SharedStack.getMaxSegmentLength(this.memory.maxAllocationLength);\n\t\tlet pointerStackMaxLength = maxLength / maxChunkSize;\n\t\tlet pointerStackAllocateCount = SharedStack.getAllocateCount(pointerStackMaxLength, undefined, maxSegmentLength);\n\t\tlet recycleStackAllocateCount = SharedStack.getAllocateCount(maxRecycledLength, undefined, maxSegmentLength);\n\n\t\t// Inline both stacks' firstBlocks right after the pool header so the whole spine is one contiguous allocation\n\t\tthis.pointerStack = new SharedStack(this.memory, {\n\t\t\tfirstBlock: this.firstBlock.getSubAllocation(SharedPool.ALLOCATE_COUNT, pointerStackAllocateCount),\n\t\t\ttype: Uint32Array,\n\t\t\tmaxLength: pointerStackMaxLength,\n\t\t});\n\t\tstoreRawPointer(this.firstBlock.data, POINTER_STACK_INDEX, this.pointerStack.pointer);\n\t\tthis.recycleStack = new SharedStack(this.memory, {\n\t\t\tfirstBlock: this.firstBlock.getSubAllocation(SharedPool.ALLOCATE_COUNT + pointerStackAllocateCount, recycleStackAllocateCount),\n\t\t\ttype: Uint32Array,\n\t\t\tmaxLength: maxRecycledLength,\n\t\t});\n\t\tstoreRawPointer(this.firstBlock.data, RECYCLE_STACK_INDEX, this.recycleStack.pointer);\n\n\t\tlet typeCode = getArrayTypeCode(config?.type ?? Uint32Array);\n\t\tthis.type = typeCode;\n\t\tthis.dataLength = dataLength;\n\t\tthis.maxChunkSize = maxChunkSize;\n\n\t\tlet byteMultipler = getByteMultipler(typeCode);\n\t\tlet firstArray = this.memory.allocUI32(maxChunkSize * dataLength * byteMultipler);\n\t\tthis.pointerStack.push(firstArray.pointer);\n\t}\n\n\tat(index: number): T {\n\t\tlet dataBlock = this.getFullDataBlock(index);\n\t\treturn this.getDataBlock(dataBlock, index % this.cachedMaxChunkSize);\n\t}\n\tget(index: number, dataIndex = 0): T[number] {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tif(dataIndex >= dataLength) {\n\t\t\tthrow new Error(`${dataIndex} is out of dataLength bounds ${dataLength}`);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(index) as NumericArrayIO;\n\t\treturn dataBlock[(index % this.cachedMaxChunkSize) * dataLength + dataIndex];\n\t}\n\tset(index: number, dataIndex: number, value: T[number]) {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tif(dataIndex >= dataLength) {\n\t\t\tthrow new Error(`${dataIndex} is out of dataLength bounds ${dataLength}`);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(index) as NumericArrayIO;\n\t\tdataBlock[(index % this.cachedMaxChunkSize) * dataLength + dataIndex] = value;\n\t}\n\n\t// Resolve the chunk view holding an index once. Callers touching several fields of the same record read/write straight\n\t// into this view at blockOffset(index) + fieldIndex, avoiding a repeated chunk lookup per field.\n\tblockFor(index: number): T {\n\t\treturn this.getFullDataBlock(index);\n\t}\n\t// Base slot of a record within the view blockFor(index) returns.\n\tblockOffset(index: number): number {\n\t\treturn (index % this.cachedMaxChunkSize) * this.cachedDataLength;\n\t}\n\n\tpush(values: T[number] | Array<T[number]>): number {\n\t\tlet dataLength = this.cachedDataLength;\n\t\tconst isSingleValue = typeof values !== 'object';\n\t\tif(!isSingleValue && values.length > dataLength) {\n\t\t\tthrow new Error(`Can't insert ${values.length} array into shared list of ${dataLength} dataLength`);\n\t\t}\n\n\t\t// Reuse a recycled index if one is available. pop() can come back undefined when another thread drained the last\n\t\t// slot between our two calls, so fall through to a fresh index rather than trusting a length() read\n\t\tlet newIndex = this.recycleStack.length === 0 ? undefined : this.recycleStack.pop();\n\t\tif(newIndex === undefined) {\n\t\t\tnewIndex = Atomics.add(this.firstBlock.data, LENGTH_INDEX, 1);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(newIndex) as NumericArrayIO;\n\t\tlet startIndex = dataLength * (newIndex % this.cachedMaxChunkSize);\n\t\tif(isSingleValue) {\n\t\t\tdataBlock[startIndex] = values;\n\t\t} else {\n\t\t\tfor(let i = 0; i < values.length; i++) {\n\t\t\t\tdataBlock[startIndex + i] = values[i];\n\t\t\t}\n\t\t}\n\n\t\treturn newIndex;\n\t}\n\n\treserveContiguous(count: number): number {\n\t\tif(!Number.isInteger(count) || count < 0) {\n\t\t\tthrow new Error(`Can't reserve ${count} pool entries`);\n\t\t}\n\t\treturn Atomics.add(this.firstBlock.data, LENGTH_INDEX, count);\n\t}\n\n\tdeleteIndex(index: number) {\n\t\tthis.recycleStack.push(index);\n\t}\n\n\tclear() {\n\t\tthis.firstBlock.data[LENGTH_INDEX] = 0;\n\t\tthis.recycleStack.clear();\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tconst recycledValues: { [key: number]: true } = {};\n\t\tfor(let value of this.recycleStack) {\n\t\t\trecycledValues[value] = true;\n\t\t}\n\n\t\tconst maxChunkSize = this.cachedMaxChunkSize;\n\t\t// Snapshot the length once - iteration over a concurrently mutated pool is a snapshot anyway, and re-loading the\n\t\t// atomic every step is pure overhead\n\t\tconst length = Atomics.load(this.firstBlock.data, LENGTH_INDEX);\n\t\tlet dataBlock = this.getFullDataBlock(0);\n\t\tlet dataBlockIndex = 0;\n\t\tfor(let i = 0; i < length; i++) {\n\t\t\tif(!recycledValues[i]) {\n\t\t\t\tlet newDataBlockIndex = Math.floor(i / maxChunkSize);\n\t\t\t\tif(newDataBlockIndex !== dataBlockIndex) {\n\t\t\t\t\tdataBlock = this.getFullDataBlock(i);\n\t\t\t\t\tdataBlockIndex = newDataBlockIndex;\n\t\t\t\t}\n\t\t\t\tyield this.getDataBlock(dataBlock, i % maxChunkSize);\n\t\t\t}\n\t\t}\n\t}\n\n\t*entries(): IterableIterator<[number, T]> {\n\t\tconst recycledValues: { [key: number]: true } = {};\n\t\tfor(let value of this.recycleStack) {\n\t\t\trecycledValues[value] = true;\n\t\t}\n\n\t\tconst maxChunkSize = this.cachedMaxChunkSize;\n\t\tconst length = Atomics.load(this.firstBlock.data, LENGTH_INDEX);\n\t\tlet dataBlock = this.getFullDataBlock(0);\n\t\tlet dataBlockIndex = 0;\n\t\tfor(let i = 0; i < length; i++) {\n\t\t\tif(!recycledValues[i]) {\n\t\t\t\tlet newDataBlockIndex = Math.floor(i / maxChunkSize);\n\t\t\t\tif(newDataBlockIndex !== dataBlockIndex) {\n\t\t\t\t\tdataBlock = this.getFullDataBlock(i);\n\t\t\t\t\tdataBlockIndex = newDataBlockIndex;\n\t\t\t\t}\n\t\t\t\tyield [i, this.getDataBlock(dataBlock, i % maxChunkSize)];\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getFullDataBlock(index: number) {\n\t\tlet pointerIndex = Math.floor(index / this.cachedMaxChunkSize);\n\t\tlet cachedDataBlock = this.cachedFullDataBlock[pointerIndex];\n\t\tif(cachedDataBlock) {\n\t\t\treturn cachedDataBlock;\n\t\t}\n\t\tif(pointerIndex >= this.pointerStack.length) {\n\t\t\t// Only let a single thread append a new chunk at a time - otherwise two concurrent inserts landing in a new\n\t\t\t// chunk would each allocate + push a buffer, orphaning one and leaking memory\n\t\t\tlock(this.growLock);\n\t\t\ttry {\n\t\t\t\t// Re-check under the lock: another thread may have already appended the chunk while we were waiting\n\t\t\t\twhile(pointerIndex >= this.pointerStack.length) {\n\t\t\t\t\tlet newArray = this.memory.allocUI32(this.cachedMaxChunkSize * this.cachedDataLength * this.cachedByteMultipler);\n\t\t\t\t\tthis.pointerStack.push(newArray.pointer);\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tunlock(this.growLock);\n\t\t\t}\n\t\t}\n\n\t\tlet array = new AllocatedMemory(this.memory, getPointer(this.pointerStack.at(pointerIndex), this.memory.positionBits));\n\n\t\tlet blockLength = this.cachedDataLength * this.cachedMaxChunkSize;\n\t\tlet data = makeArrayView(this.cachedType, array.data.buffer, array.bufferByteOffset, blockLength) as T;\n\n\t\tthis.cachedFullDataBlock[pointerIndex] = data;\n\t\treturn data;\n\t}\n\n\tprivate getDataBlock(rawData: T, index: number): T {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tconst start = index * dataLength;\n\t\treturn rawData.subarray(start, start + dataLength) as T;\n\t}\n\n\tfree() {\n\t\tthis.recycleStack.free();\n\n\t\tfor(let pointer of this.pointerStack) {\n\t\t\tlet memory = new AllocatedMemory(this.memory, getPointer(pointer, this.memory.positionBits));\n\t\t\tmemory.free();\n\t\t}\n\t\tthis.pointerStack.free();\n\t\tif(this.ownsFirstBlock) {\n\t\t\tthis.firstBlock.free();\n\t\t}\n\t}\n\n\tgetSharedMemory(): SharedPoolMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.firstBlock.getSharedMemory(),\n\t\t};\n\t}\n}\n\ninterface SharedPoolConfig<T extends NumericArray> {\n\tmaxChunkSize?: number\n\tmaxLength?: number\n\tmaxRecycledLength?: number\n\ttype?: TypedArrayConstructor<T>\n\tdataLength?: number\n}\ninterface SharedPoolMemory {\n\tfirstBlock: SharedAllocatedMemory | AllocatedMemory\n}\n\nexport type { SharedPoolConfig, SharedPoolMemory };\n"],"mappings":"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"}

package/dist/shared-stack.js.map

@@ -1 +1 @@
-{"version":3,"file":"shared-stack.js","names":[],"sources":["../src/shared-stack.ts"],"sourcesContent":["import type { SharedAllocatedMemory } from './allocated-memory';\nimport AllocatedMemory from './allocated-memory';\nimport { lock, unlock } from './lock/simple-lock';\nimport type MemoryHeap from './memory-heap';\nimport { getPointer, storePointer } from './utils/pointer';\nimport { getArrayTypeCode, getByteMultipler, makeArrayView, type NumericArray, type NumericArrayIO, type TypedArrayConstructor } from './utils/array-type';\n\nconst LENGTH_INDEX = 0;\nconst TYPE_INDEX = 1;\nconst BASE_SEGMENT_LENGTH_INDEX = 2;\nconst MAX_SEGMENTS_INDEX = 3;\nconst MAX_SEGMENT_LENGTH_INDEX = 4;\nconst SEGMENT_COUNT_INDEX = 5;\nconst GROW_LOCK_INDEX = 6;\nconst SEGMENT_START_INDEX = 7;\n\nconst DEFAULT_BASE_SEGMENT_LENGTH = 4;\n// Default segment budget. With uncapped power-of-two growth these 20 segments spanned 4,194,300 slots, but that ceiling\n// was never reachable: past segment 14 a segment's block outgrows a 1MB buffer and allocation throws. Capping segments at\n// what a buffer holds, the honest capacity of 20 segments is getCapacity(20, base, cap) instead.\nconst DEFAULT_MAX_SEGMENTS = 20;\n\n// The LENGTH word packs an ABA version counter (high bits) with the live count (low LEN_BITS). Both push and pop bump\n// the version on every successful CAS, so the CAS fails on ANY intervening op - the count can never ABA back to the\n// same value with a slot at a different generation. 22 count bits cover the default max length (4,194,300); the\n// remaining 10 version bits (1024) only need to outlast a single thread's load->CAS window.\nconst LEN_BITS = 22;\nconst LEN_MASK = (1 << LEN_BITS) - 1;\nconst MAX_COUNT = LEN_MASK - 1;\n// Adding this to the packed word bumps the version (high bits) by one. Combined with +1/-1 for the count it repacks the\n// whole word in a single add: the count is guarded from overflowing into the version bits, and a version overflow just\n// wraps harmlessly when the value is coerced back to Uint32 on the atomic store.\nconst VERSION_STEP = 1 << LEN_BITS;\n\n// Per-slot publish handshake. Each data slot has a companion sequence number: even means the slot is empty (free to\n// fill) at some lap, odd means the value is published (safe to read). It only ever increases. push/pop read the slot's\n// sequence and bail out (retry) unless it has the parity they need, then CAS the length; because the versioned CAS\n// rejects any intervening op, the sequence read stays valid all the way through the publish store below.\n\nexport default class SharedStack<T extends NumericArray = Uint32Array> implements Iterable<T[number]> {\n\tstatic readonly BASE_ALLOCATE_COUNT = 8;\n\tstatic readonly DEFAULT_ALLOCATE_COUNT = this.BASE_ALLOCATE_COUNT + DEFAULT_MAX_SEGMENTS;\n\n\t// Largest power-of-two segment length whose block (segmentLength data slots plus an equal run of publish sequences)\n\t// still fits in a single buffer. Segments double until they reach this, then stay flat so a segment can always be\n\t// allocated in one contiguous block. maxAllocationLength is MemoryHeap.maxAllocationLength. byteMultipler is the u32\n\t// units per data slot (2 for 64-bit types), so a length-L segment's block is L * byteMultipler data u32s + L sequence u32s.\n\tstatic getMaxSegmentLength(maxAllocationLength: number, baseSegmentLength = DEFAULT_BASE_SEGMENT_LENGTH, byteMultipler = 1): number {\n\t\tlet segmentLength = baseSegmentLength;\n\t\t// A length-L segment needs a block of L * (byteMultipler + 1) u32s, so the next double fits while\n\t\t// 2L * (byteMultipler + 1) <= maxAllocationLength\n\t\twhile(segmentLength * 2 * (byteMultipler + 1) <= maxAllocationLength) {\n\t\t\tsegmentLength *= 2;\n\t\t}\n\t\treturn segmentLength;\n\t}\n\n\t// Smallest segment count whose summed capacity covers maxLength. Segments double from baseSegmentLength but never grow\n\t// past maxSegmentLength, so once capped they each add a flat maxSegmentLength. Looped rather than solved in closed form\n\t// to avoid float rounding landing a segment short or over.\n\tstatic getMaxSegments(maxLength: number, baseSegmentLength = DEFAULT_BASE_SEGMENT_LENGTH, maxSegmentLength = Infinity): number {\n\t\tlet segments = 0;\n\t\tlet capacity = 0;\n\t\tlet segmentLength = baseSegmentLength;\n\t\twhile(capacity < maxLength) {\n\t\t\tcapacity += segmentLength;\n\t\t\tsegments++;\n\t\t\tsegmentLength = Math.min(segmentLength * 2, maxSegmentLength);\n\t\t}\n\t\treturn segments;\n\t}\n\t// Total capacity of the first `segments` segments under the same doubling-then-capped growth as getMaxSegments\n\tstatic getCapacity(segments: number, baseSegmentLength = DEFAULT_BASE_SEGMENT_LENGTH, maxSegmentLength = Infinity): number {\n\t\tlet capacity = 0;\n\t\tlet segmentLength = baseSegmentLength;\n\t\tfor(let i = 0; i < segments; i++) {\n\t\t\tcapacity += segmentLength;\n\t\t\tsegmentLength = Math.min(segmentLength * 2, maxSegmentLength);\n\t\t}\n\t\treturn capacity;\n\t}\n\tstatic getAllocateCount(maxLength: number, baseSegmentLength = DEFAULT_BASE_SEGMENT_LENGTH, maxSegmentLength = Infinity): number {\n\t\treturn this.BASE_ALLOCATE_COUNT + this.getMaxSegments(maxLength, baseSegmentLength, maxSegmentLength);\n\t}\n\tprivate memory: MemoryHeap;\n\n\t// Length, Type, Base Segment Length, Max Segments, Max Segment Length, Segment Count, Grow Lock, Segments\n\tprivate firstBlock: AllocatedMemory;\n\tprivate uint16Array: Uint16Array;\n\tprivate growLock: Int32Array;\n\treadonly maxLength: number;\n\n\t// False when firstBlock is a slice of another structure's memory (e.g. inlined in SharedPool); that owner frees it\n\tprivate ownsFirstBlock: boolean;\n\n\tprivate cachedSegments: T[] = [];\n\t// Parallel to cachedSegments: the per-slot publish sequences for each slot of that segment. Populated together with\n\t// the data view in getSegment, so whenever cachedSegments[i] is set cachedSequences[i] is too.\n\tprivate cachedSequences: Int32Array[] = [];\n\tprivate cachedBaseSegmentLength = 0;\n\t// Segment growth caps at cachedMaxSegmentLength. Segments 0..(cachedCapSegmentCount - 1) double geometrically and cover\n\t// the first cachedGeometricCapacity slots; every segment beyond that is a flat cachedMaxSegmentLength. Indexing splits\n\t// on cachedGeometricCapacity: below it the fast log2 mapping, above it a plain linear division into capped segments.\n\tprivate cachedMaxSegmentLength = 0;\n\tprivate cachedCapSegmentCount = 0;\n\tprivate cachedGeometricCapacity = 0;\n\t// u32 units per data slot: 1 for 32-bit types, 2 for 64-bit (float64/int64/uint64). A segment block is\n\t// segmentLength * cachedByteMultipler data u32s followed by segmentLength sequence u32s.\n\tprivate cachedByteMultipler = 1;\n\n\tget length(): number {\n\t\treturn Atomics.load(this.firstBlock.data, LENGTH_INDEX) & LEN_MASK;\n\t}\n\tget segmentCount(): number {\n\t\treturn Atomics.load(this.firstBlock.data, SEGMENT_COUNT_INDEX);\n\t}\n\tprivate set segmentCount(value: number) {\n\t\tthis.firstBlock.data[SEGMENT_COUNT_INDEX] = value;\n\t}\n\t\n\tget type(): number {\n\t\treturn this.uint16Array[0];\n\t}\n\tprivate set type(value: number) {\n\t\tAtomics.store(this.uint16Array, 0, value);\n\t}\n\n\tget baseSegmentLength() {\n\t\treturn this.firstBlock.data[BASE_SEGMENT_LENGTH_INDEX];\n\t}\n\tprivate set baseSegmentLength(value: number) {\n\t\tthis.firstBlock.data[BASE_SEGMENT_LENGTH_INDEX] = value;\n\t}\n\tget maxSegments() {\n\t\treturn this.firstBlock.data[MAX_SEGMENTS_INDEX];\n\t}\n\tprivate set maxSegments(value: number) {\n\t\tthis.firstBlock.data[MAX_SEGMENTS_INDEX] = value;\n\t}\n\tget maxSegmentLength() {\n\t\treturn this.firstBlock.data[MAX_SEGMENT_LENGTH_INDEX];\n\t}\n\tprivate set maxSegmentLength(value: number) {\n\t\tthis.firstBlock.data[MAX_SEGMENT_LENGTH_INDEX] = value;\n\t}\n\n\tget pointer() {\n\t\treturn this.firstBlock.pointer;\n\t}\n\n\t// Own internal memory plus every allocated segment. The firstBlock is excluded when inlined in another structure\n\t// (e.g. SharedPool) since that owner already counts it as part of its own internal memory.\n\tget usedMemory(): number {\n\t\tlet total = this.ownsFirstBlock ? this.firstBlock.usedMemory : 0;\n\t\tfor(let i = 0; i < this.segmentCount; i++) {\n\t\t\tlet pointer = getPointer(Atomics.load(this.firstBlock.data, SEGMENT_START_INDEX + i), this.memory.positionBits);\n\t\t\ttotal += new AllocatedMemory(this.memory, pointer).usedMemory;\n\t\t}\n\t\treturn total;\n\t}\n\n\tconstructor(memory: MemoryHeap, config?: SharedStackConfig<T> | SharedStackMemory | SharedStackMemory & SharedStackConfig<T>) {\n\t\tthis.memory = memory;\n\n\t\tif(config && 'firstBlock' in config) {\n\t\t\t// An AllocatedMemory instance is a caller-reserved slice (e.g. inlined in SharedPool); a plain pointer is the\n\t\t\t// serialized clone path. Taking the instance directly keeps us off the pointer-resolving construction branch.\n\t\t\tif(config.firstBlock instanceof AllocatedMemory) {\n\t\t\t\tthis.firstBlock = config.firstBlock;\n\t\t\t} else {\n\t\t\t\tconst maxSegments = new Uint32Array(\n\t\t\t\t\tmemory.buffers[config.firstBlock.bufferPosition].buf,\n\t\t\t\t\tconfig.firstBlock.bufferByteOffset + MAX_SEGMENTS_INDEX * Uint32Array.BYTES_PER_ELEMENT,\n\t\t\t\t\t1,\n\t\t\t\t)[0];\n\t\t\t\tthis.firstBlock = new AllocatedMemory(memory, {\n\t\t\t\t\tlength: SharedStack.BASE_ALLOCATE_COUNT + maxSegments,\n\t\t\t\t\t...config.firstBlock,\n\t\t\t\t});\n\t\t\t}\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\n\t\t\t// Memory passed together with config means the caller reserved the firstBlock slot for us to initialize in place\n\t\t\tif('type' in config || 'baseSegmentLength' in config || 'maxLength' in config) {\n\t\t\t\tthis.initialize(config);\n\t\t\t\tthis.ownsFirstBlock = false;\n\t\t\t} else {\n\t\t\t\tthis.ownsFirstBlock = true;\n\t\t\t}\n\t\t} else {\n\t\t\tlet byteMultipler = getByteMultipler(getArrayTypeCode(config?.type ?? Uint32Array));\n\t\t\tlet baseSegmentLength = config?.baseSegmentLength ?? DEFAULT_BASE_SEGMENT_LENGTH;\n\t\t\tlet maxSegmentLength = this.resolveMaxSegmentLength(baseSegmentLength, config?.maxSegmentLength, byteMultipler);\n\t\t\tlet maxSegments = this.resolveMaxSegments(config?.maxLength, baseSegmentLength, maxSegmentLength);\n\n\t\t\tthis.firstBlock = memory.allocUI32(SharedStack.BASE_ALLOCATE_COUNT + maxSegments);\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\t\t\tthis.ownsFirstBlock = true;\n\n\t\t\tthis.initialize(config);\n\t\t}\n\n\t\tthis.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + GROW_LOCK_INDEX * Uint32Array.BYTES_PER_ELEMENT, 1);\n\t\tthis.cachedByteMultipler = getByteMultipler(this.type);\n\t\tthis.cachedBaseSegmentLength = this.baseSegmentLength;\n\t\tthis.cachedMaxSegmentLength = this.maxSegmentLength;\n\t\t// Segments 0..(K-1) double geometrically up to the cap, where K = log2(cap / base) + 1\n\t\tthis.cachedCapSegmentCount = 32 - Math.clz32(((this.cachedMaxSegmentLength / this.cachedBaseSegmentLength) | 0));\n\t\tthis.cachedGeometricCapacity = this.cachedBaseSegmentLength * ((1 << this.cachedCapSegmentCount) - 1);\n\t\tthis.maxLength = SharedStack.getCapacity(this.maxSegments, this.cachedBaseSegmentLength, this.cachedMaxSegmentLength);\n\t\tif(this.maxLength > MAX_COUNT) {\n\t\t\t// The length word reserves LEN_BITS for the count and the rest for the ABA version tag\n\t\t\tthrow new Error(`SharedStack maxLength ${this.maxLength} exceeds the ${MAX_COUNT} the versioned length counter can address`);\n\t\t}\n\t}\n\n\t// Cap on segment length: the largest a single buffer can hold, optionally lowered to a caller-requested value (floored\n\t// to a power-of-two multiple of the base). Beyond this segments stop doubling and stay flat so each still fits a buffer.\n\tprivate resolveMaxSegmentLength(baseSegmentLength: number, requested?: number, byteMultipler = 1): number {\n\t\tlet cap = SharedStack.getMaxSegmentLength(this.memory.maxAllocationLength, baseSegmentLength, byteMultipler);\n\t\tif(requested) {\n\t\t\tlet floored = baseSegmentLength;\n\t\t\twhile(floored * 2 <= requested) {\n\t\t\t\tfloored *= 2;\n\t\t\t}\n\t\t\tcap = Math.min(cap, floored);\n\t\t}\n\t\treturn cap;\n\t}\n\n\t// Segments needed to cover maxLength (or the default budget when none is given), but never more than the segment-pointer\n\t// spine can hold in a single buffer. Once capped, segments no longer double, so a huge maxLength on a small buffer is\n\t// honestly bounded here instead of blowing up later when the spine (or a segment) can't be allocated.\n\tprivate resolveMaxSegments(maxLength: number | undefined, baseSegmentLength: number, maxSegmentLength: number): number {\n\t\tlet needed = maxLength === undefined\n\t\t\t? DEFAULT_MAX_SEGMENTS\n\t\t\t: SharedStack.getMaxSegments(maxLength, baseSegmentLength, maxSegmentLength);\n\t\tlet spineLimit = this.memory.maxAllocationLength - SharedStack.BASE_ALLOCATE_COUNT;\n\t\treturn Math.min(needed, spineLimit);\n\t}\n\n\tprivate initialize(config?: SharedStackConfig<T>) {\n\t\tlet typeCode = getArrayTypeCode(config?.type ?? Uint32Array);\n\t\tlet byteMultipler = getByteMultipler(typeCode);\n\t\tlet baseSegmentLength = config?.baseSegmentLength ?? DEFAULT_BASE_SEGMENT_LENGTH;\n\t\tlet maxSegmentLength = this.resolveMaxSegmentLength(baseSegmentLength, config?.maxSegmentLength, byteMultipler);\n\t\t// Each segment block holds the data slots (byteMultipler u32s each) followed by one publish sequence u32 per slot\n\t\tlet firstSegmentBlock = this.memory.allocUI32(baseSegmentLength * (byteMultipler + 1));\n\t\tstorePointer(this.firstBlock.data, SEGMENT_START_INDEX, firstSegmentBlock.bufferPosition, firstSegmentBlock.bufferByteOffset, this.memory.positionBits);\n\t\tthis.baseSegmentLength = baseSegmentLength;\n\t\tthis.maxSegmentLength = maxSegmentLength;\n\t\tthis.maxSegments = this.resolveMaxSegments(config?.maxLength, baseSegmentLength, maxSegmentLength);\n\t\tthis.segmentCount = 1;\n\t\tthis.type = typeCode;\n\t}\n\n\tat(index: number): T[number] {\n\t\tlet length = this.length;\n\t\tif(index >= length || index < 0) {\n\t\t\tthrow new Error(`${index} is out of bounds ${length}`);\n\t\t}\n\n\t\tlet geometricCapacity = this.cachedGeometricCapacity;\n\t\tlet segmentIndex: number;\n\t\tlet localIndex: number;\n\t\tif(index < geometricCapacity) {\n\t\t\tlet baseSegmentLength = this.cachedBaseSegmentLength;\n\t\t\tsegmentIndex = 31 - Math.clz32(((index / baseSegmentLength) | 0) + 1);\n\t\t\tlocalIndex = index - baseSegmentLength * ((1 << segmentIndex) - 1);\n\t\t} else {\n\t\t\tlet maxSegmentLength = this.cachedMaxSegmentLength;\n\t\t\tlet offset = index - geometricCapacity;\n\t\t\tlet extra = (offset / maxSegmentLength) | 0;\n\t\t\tsegmentIndex = this.cachedCapSegmentCount + extra;\n\t\t\tlocalIndex = offset - extra * maxSegmentLength;\n\t\t}\n\t\tlet segment = this.cachedSegments[segmentIndex] ?? this.getSegment(segmentIndex);\n\t\t// push() bumps the length before it stores the value and publishes the slot, so an index already counted in length\n\t\t// can still be mid-publish. Wait for the slot's sequence to go odd (published) before reading, otherwise we hand\n\t\t// back a slot whose value hasn't landed yet - for the pool's chunk pointers that means decoding a zeroed pointer.\n\t\tlet sequences = this.cachedSequences[segmentIndex];\n\t\twhile((Atomics.load(sequences, localIndex) & 1) === 0) { /* spin: value is being published on another thread */ }\n\t\treturn (segment as NumericArrayIO)[localIndex];\n\t}\n\n\tpush(value: T[number]): number {\n\t\tlet data = this.firstBlock.data;\n\t\tlet geometricCapacity = this.cachedGeometricCapacity;\n\t\t// eslint-disable-next-line no-constant-condition\n\t\twhile(true) {\n\t\t\t// Plain (relaxed) read is enough: it only seeds the versioned CAS below, which rejects any stale value\n\t\t\tlet packed = data[LENGTH_INDEX];\n\t\t\tlet newIndex = packed & LEN_MASK;\n\t\t\tif(newIndex >= this.maxLength) {\n\t\t\t\tthrow new Error(`${newIndex + 1} is out of bounds ${this.maxLength}`);\n\t\t\t}\n\n\t\t\tlet segmentIndex: number;\n\t\t\tlet localIndex: number;\n\t\t\tif(newIndex < geometricCapacity) {\n\t\t\t\tlet baseSegmentLength = this.cachedBaseSegmentLength;\n\t\t\t\tsegmentIndex = 31 - Math.clz32(((newIndex / baseSegmentLength) | 0) + 1);\n\t\t\t\tlocalIndex = newIndex - baseSegmentLength * ((1 << segmentIndex) - 1);\n\t\t\t} else {\n\t\t\t\tlet maxSegmentLength = this.cachedMaxSegmentLength;\n\t\t\t\tlet offset = newIndex - geometricCapacity;\n\t\t\t\tlet extra = (offset / maxSegmentLength) | 0;\n\t\t\t\tsegmentIndex = this.cachedCapSegmentCount + extra;\n\t\t\t\tlocalIndex = offset - extra * maxSegmentLength;\n\t\t\t}\n\t\t\tlet segment = this.cachedSegments[segmentIndex] ?? this.getSegment(segmentIndex);\n\t\t\tlet sequences = this.cachedSequences[segmentIndex];\n\n\t\t\t// The slot must be empty (even sequence) to fill. Odd means a popper hasn't finished emptying it yet - retry\n\t\t\tlet sequence = Atomics.load(sequences, localIndex);\n\t\t\tif((sequence & 1) !== 0) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\t// Take the slot only if the whole versioned length word is unchanged. The version bump makes this fail on any\n\t\t\t// intervening op, so a win guarantees nothing touched the top - and our sequence read above is still valid\n\t\t\tif(Atomics.compareExchange(data, LENGTH_INDEX, packed, packed + VERSION_STEP + 1) !== packed) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t(segment as NumericArrayIO)[localIndex] = value;\n\t\t\t// Publish: bump to odd (full). Safe as a plain store - no other op can claim this slot until the length comes\n\t\t\t// back down to it, which can't happen (its popper is gated on an odd sequence) until this store lands\n\t\t\tAtomics.store(sequences, localIndex, sequence + 1);\n\t\t\treturn newIndex;\n\t\t}\n\t}\n\n\tpop(): T[number] | undefined {\n\t\tlet data = this.firstBlock.data;\n\t\tlet geometricCapacity = this.cachedGeometricCapacity;\n\t\t// eslint-disable-next-line no-constant-condition\n\t\twhile(true) {\n\t\t\t// Plain (relaxed) read is enough: it only seeds the versioned CAS below, which rejects any stale value\n\t\t\tlet packed = data[LENGTH_INDEX];\n\t\t\tlet length = packed & LEN_MASK;\n\t\t\tif(length <= 0) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tlet oldIndex = length - 1;\n\n\t\t\tlet segmentIndex: number;\n\t\t\tlet localIndex: number;\n\t\t\tif(oldIndex < geometricCapacity) {\n\t\t\t\tlet baseSegmentLength = this.cachedBaseSegmentLength;\n\t\t\t\tsegmentIndex = 31 - Math.clz32(((oldIndex / baseSegmentLength) | 0) + 1);\n\t\t\t\tlocalIndex = oldIndex - baseSegmentLength * ((1 << segmentIndex) - 1);\n\t\t\t} else {\n\t\t\t\tlet maxSegmentLength = this.cachedMaxSegmentLength;\n\t\t\t\tlet offset = oldIndex - geometricCapacity;\n\t\t\t\tlet extra = (offset / maxSegmentLength) | 0;\n\t\t\t\tsegmentIndex = this.cachedCapSegmentCount + extra;\n\t\t\t\tlocalIndex = offset - extra * maxSegmentLength;\n\t\t\t}\n\t\t\tlet segment = this.cachedSegments[segmentIndex] ?? this.getSegment(segmentIndex);\n\t\t\tlet sequences = this.cachedSequences[segmentIndex];\n\n\t\t\t// The slot must be full (odd sequence) to read. Even means a pusher hasn't finished publishing it yet - retry\n\t\t\tlet sequence = Atomics.load(sequences, localIndex);\n\t\t\tif((sequence & 1) === 0) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif(Atomics.compareExchange(data, LENGTH_INDEX, packed, packed + VERSION_STEP - 1) !== packed) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tlet value = (segment as NumericArrayIO)[localIndex] as T[number];\n\t\t\t// Release the slot: bump to even (empty) so a later push may reuse it\n\t\t\tAtomics.store(sequences, localIndex, sequence + 1);\n\t\t\treturn value;\n\t\t}\n\t}\n\n\tclear() {\n\t\t// Mark every occupied slot empty (bump its odd sequence to the next even) before dropping the length, otherwise a\n\t\t// later push reusing the slot would spin forever on a stale full sequence. Not safe to call concurrently with push/pop.\n\t\tlet baseSegmentLength = this.cachedBaseSegmentLength;\n\t\tlet geometricCapacity = this.cachedGeometricCapacity;\n\t\tlet maxSegmentLength = this.cachedMaxSegmentLength;\n\t\tlet oldLength = Atomics.load(this.firstBlock.data, LENGTH_INDEX) & LEN_MASK;\n\t\tfor(let i = 0; i < oldLength; i++) {\n\t\t\tlet segmentIndex: number;\n\t\t\tlet localIndex: number;\n\t\t\tif(i < geometricCapacity) {\n\t\t\t\tsegmentIndex = 31 - Math.clz32(((i / baseSegmentLength) | 0) + 1);\n\t\t\t\tlocalIndex = i - baseSegmentLength * ((1 << segmentIndex) - 1);\n\t\t\t} else {\n\t\t\t\tlet offset = i - geometricCapacity;\n\t\t\t\tlet extra = (offset / maxSegmentLength) | 0;\n\t\t\t\tsegmentIndex = this.cachedCapSegmentCount + extra;\n\t\t\t\tlocalIndex = offset - extra * maxSegmentLength;\n\t\t\t}\n\t\t\tlet sequences = this.cachedSequences[segmentIndex] ?? (this.getSegment(segmentIndex), this.cachedSequences[segmentIndex]);\n\t\t\tlet sequence = Atomics.load(sequences, localIndex);\n\t\t\tif((sequence & 1) !== 0) {\n\t\t\t\tAtomics.store(sequences, localIndex, sequence + 1);\n\t\t\t}\n\t\t}\n\t\tAtomics.store(this.firstBlock.data, LENGTH_INDEX, 0);\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tlet totalDataEntries = this.length;\n\n\t\tlet maxSegmentLength = this.cachedMaxSegmentLength;\n\t\tlet segmentLength = this.baseSegmentLength;\n\t\tlet segmentIndex = 0;\n\t\tlet segment = this.getSegment(segmentIndex);\n\t\tlet segmentDataIndex = 0;\n\t\tfor(let i = 0; i < totalDataEntries; i++) {\n\t\t\tyield (segment as NumericArrayIO)[segmentDataIndex] as T[number];\n\t\t\tsegmentDataIndex++;\n\t\t\tif(segmentDataIndex >= segmentLength) {\n\t\t\t\tsegmentIndex++;\n\t\t\t\tsegment = this.getSegment(segmentIndex);\n\t\t\t\tsegmentDataIndex = 0;\n\t\t\t\tsegmentLength = Math.min(segmentLength * 2, maxSegmentLength);\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getSegment(segmentIndex: number): T {\n\t\tif(this.cachedSegments[segmentIndex]) {\n\t\t\treturn this.cachedSegments[segmentIndex];\n\t\t}\n\n\t\t// Geometric while below the cap, then flat so the block always fits a single buffer\n\t\tlet segmentLength = segmentIndex < this.cachedCapSegmentCount\n\t\t\t? this.cachedBaseSegmentLength << segmentIndex\n\t\t\t: this.cachedMaxSegmentLength;\n\t\tlet segmentDataBlock: AllocatedMemory | undefined;\n\t\tif(segmentIndex >= this.segmentCount) {\n\t\t\t// Lock when growing so another thread doesn't also setup the same segment\n\t\t\tlock(this.growLock);\n\t\t\ttry {\n\t\t\t\t// Re-check under the lock: another thread may have already appended the segment while we were waiting\n\t\t\t\tif(segmentIndex >= this.segmentCount) {\n\t\t\t\t\t// Data slots (byteMultipler u32s each) followed by one publish sequence u32 per slot (calloc-zeroed = 0 = empty)\n\t\t\t\t\tsegmentDataBlock = this.memory.allocUI32(segmentLength * (this.cachedByteMultipler + 1));\n\t\t\t\t\tstorePointer(this.firstBlock.data, SEGMENT_START_INDEX + segmentIndex, segmentDataBlock.bufferPosition, segmentDataBlock.bufferByteOffset, this.memory.positionBits);\n\t\t\t\t\tAtomics.add(this.firstBlock.data, SEGMENT_COUNT_INDEX, 1);\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tunlock(this.growLock);\n\t\t\t}\n\t\t}\n\n\t\tif(!segmentDataBlock) {\n\t\t\tlet pointerNumber = Atomics.load(this.firstBlock.data, SEGMENT_START_INDEX + segmentIndex);\n\t\t\tlet pointer = getPointer(pointerNumber, this.memory.positionBits);\n\t\t\tsegmentDataBlock = new AllocatedMemory(this.memory, pointer);\n\t\t}\n\n\t\tlet data = makeArrayView(this.type, segmentDataBlock.data.buffer, segmentDataBlock.bufferByteOffset, segmentLength) as T;\n\t\t// Publish sequences live after the data region (segmentLength * byteMultipler u32s), always as Int32 regardless of type\n\t\tlet sequenceByteOffset = segmentDataBlock.bufferByteOffset + segmentLength * this.cachedByteMultipler * Uint32Array.BYTES_PER_ELEMENT;\n\t\tthis.cachedSequences[segmentIndex] = new Int32Array(segmentDataBlock.data.buffer, sequenceByteOffset, segmentLength);\n\t\tthis.cachedSegments[segmentIndex] = data;\n\n\t\treturn data;\n\t}\n\n\tfree() {\n\t\tfor(let i = 0; i < this.segmentCount; i++) {\n\t\t\tlet pointerNumber = Atomics.load(this.firstBlock.data, SEGMENT_START_INDEX + i);\n\t\t\tlet pointer = getPointer(pointerNumber, this.memory.positionBits);\n\t\t\tlet rawData = new AllocatedMemory(this.memory, pointer);\n\t\t\trawData.free();\n\t\t}\n\t\tif(this.ownsFirstBlock) {\n\t\t\tthis.firstBlock.free();\n\t\t}\n\t}\n\n\tgetSharedMemory(): SharedStackMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.firstBlock.getSharedMemory(),\n\t\t};\n\t}\n}\n\ninterface SharedStackConfig<T extends NumericArray> {\n\ttype?: TypedArrayConstructor<T>\n\n\tbaseSegmentLength?: number\n\tmaxLength?: number\n\t// Cap on how large a single segment may grow. Defaults to the largest a buffer can hold; a smaller value is floored to\n\t// a power-of-two multiple of baseSegmentLength. Beyond the cap segments stay flat instead of doubling.\n\tmaxSegmentLength?: number\n}\ninterface SharedStackMemory {\n\tfirstBlock: SharedAllocatedMemory | AllocatedMemory\n}\n\nexport type { SharedStackConfig, SharedStackMemory };"],"mappings":"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"}
+{"version":3,"file":"shared-stack.js","names":["AllocatedMemory","LENGTH_INDEX","TYPE_INDEX","BASE_SEGMENT_LENGTH_INDEX","MAX_SEGMENTS_INDEX","MAX_SEGMENT_LENGTH_INDEX","SEGMENT_COUNT_INDEX","GROW_LOCK_INDEX","SEGMENT_START_INDEX","DEFAULT_BASE_SEGMENT_LENGTH","DEFAULT_MAX_SEGMENTS","LEN_BITS","LEN_MASK","MAX_COUNT","VERSION_STEP","SharedStack","segmentLength","baseSegmentLength","byteMultipler","maxAllocationLength","segments","capacity","maxLength","maxSegmentLength","i","value","total","pointer","getPointer","memory","config","maxSegments","getByteMultipler","getArrayTypeCode","cap","requested","floored","needed","spineLimit","typeCode","firstSegmentBlock","storePointer","length","index","geometricCapacity","segmentIndex","localIndex","offset","extra","segment","sequences","data","packed","newIndex","sequence","oldIndex","oldLength","totalDataEntries","segmentDataIndex","segmentDataBlock","pointerNumber","makeArrayView","sequenceByteOffset"],"sources":["../src/shared-stack.ts"],"sourcesContent":["import type { SharedAllocatedMemory } from './allocated-memory';\nimport AllocatedMemory from './allocated-memory';\nimport { lock, unlock } from './lock/simple-lock';\nimport type MemoryHeap from './memory-heap';\nimport { getPointer, storePointer } from './utils/pointer';\nimport { getArrayTypeCode, getByteMultipler, makeArrayView, type NumericArray, type NumericArrayIO, type TypedArrayConstructor } from './utils/array-type';\n\nconst LENGTH_INDEX = 0;\nconst TYPE_INDEX = 1;\nconst BASE_SEGMENT_LENGTH_INDEX = 2;\nconst MAX_SEGMENTS_INDEX = 3;\nconst MAX_SEGMENT_LENGTH_INDEX = 4;\nconst SEGMENT_COUNT_INDEX = 5;\nconst GROW_LOCK_INDEX = 6;\nconst SEGMENT_START_INDEX = 7;\n\nconst DEFAULT_BASE_SEGMENT_LENGTH = 4;\n// Default segment budget. With uncapped power-of-two growth these 20 segments spanned 4,194,300 slots, but that ceiling\n// was never reachable: past segment 14 a segment's block outgrows a 1MB buffer and allocation throws. Capping segments at\n// what a buffer holds, the honest capacity of 20 segments is getCapacity(20, base, cap) instead.\nconst DEFAULT_MAX_SEGMENTS = 20;\n\n// The LENGTH word packs an ABA version counter (high bits) with the live count (low LEN_BITS). Both push and pop bump\n// the version on every successful CAS, so the CAS fails on ANY intervening op - the count can never ABA back to the\n// same value with a slot at a different generation. 22 count bits cover the default max length (4,194,300); the\n// remaining 10 version bits (1024) only need to outlast a single thread's load->CAS window.\nconst LEN_BITS = 22;\nconst LEN_MASK = (1 << LEN_BITS) - 1;\nconst MAX_COUNT = LEN_MASK - 1;\n// Adding this to the packed word bumps the version (high bits) by one. Combined with +1/-1 for the count it repacks the\n// whole word in a single add: the count is guarded from overflowing into the version bits, and a version overflow just\n// wraps harmlessly when the value is coerced back to Uint32 on the atomic store.\nconst VERSION_STEP = 1 << LEN_BITS;\n\n// Per-slot publish handshake. Each data slot has a companion sequence number: even means the slot is empty (free to\n// fill) at some lap, odd means the value is published (safe to read). It only ever increases. push/pop read the slot's\n// sequence and bail out (retry) unless it has the parity they need, then CAS the length; because the versioned CAS\n// rejects any intervening op, the sequence read stays valid all the way through the publish store below.\n\nexport default class SharedStack<T extends NumericArray = Uint32Array> implements Iterable<T[number]> {\n\tstatic readonly BASE_ALLOCATE_COUNT = 8;\n\tstatic readonly DEFAULT_ALLOCATE_COUNT = this.BASE_ALLOCATE_COUNT + DEFAULT_MAX_SEGMENTS;\n\n\t// Largest power-of-two segment length whose block (segmentLength data slots plus an equal run of publish sequences)\n\t// still fits in a single buffer. Segments double until they reach this, then stay flat so a segment can always be\n\t// allocated in one contiguous block. maxAllocationLength is MemoryHeap.maxAllocationLength. byteMultipler is the u32\n\t// units per data slot (2 for 64-bit types), so a length-L segment's block is L * byteMultipler data u32s + L sequence u32s.\n\tstatic getMaxSegmentLength(maxAllocationLength: number, baseSegmentLength = DEFAULT_BASE_SEGMENT_LENGTH, byteMultipler = 1): number {\n\t\tlet segmentLength = baseSegmentLength;\n\t\t// A length-L segment needs a block of L * (byteMultipler + 1) u32s, so the next double fits while\n\t\t// 2L * (byteMultipler + 1) <= maxAllocationLength\n\t\twhile(segmentLength * 2 * (byteMultipler + 1) <= maxAllocationLength) {\n\t\t\tsegmentLength *= 2;\n\t\t}\n\t\treturn segmentLength;\n\t}\n\n\t// Smallest segment count whose summed capacity covers maxLength. Segments double from baseSegmentLength but never grow\n\t// past maxSegmentLength, so once capped they each add a flat maxSegmentLength. Looped rather than solved in closed form\n\t// to avoid float rounding landing a segment short or over.\n\tstatic getMaxSegments(maxLength: number, baseSegmentLength = DEFAULT_BASE_SEGMENT_LENGTH, maxSegmentLength = Infinity): number {\n\t\tlet segments = 0;\n\t\tlet capacity = 0;\n\t\tlet segmentLength = baseSegmentLength;\n\t\twhile(capacity < maxLength) {\n\t\t\tcapacity += segmentLength;\n\t\t\tsegments++;\n\t\t\tsegmentLength = Math.min(segmentLength * 2, maxSegmentLength);\n\t\t}\n\t\treturn segments;\n\t}\n\t// Total capacity of the first `segments` segments under the same doubling-then-capped growth as getMaxSegments\n\tstatic getCapacity(segments: number, baseSegmentLength = DEFAULT_BASE_SEGMENT_LENGTH, maxSegmentLength = Infinity): number {\n\t\tlet capacity = 0;\n\t\tlet segmentLength = baseSegmentLength;\n\t\tfor(let i = 0; i < segments; i++) {\n\t\t\tcapacity += segmentLength;\n\t\t\tsegmentLength = Math.min(segmentLength * 2, maxSegmentLength);\n\t\t}\n\t\treturn capacity;\n\t}\n\tstatic getAllocateCount(maxLength: number, baseSegmentLength = DEFAULT_BASE_SEGMENT_LENGTH, maxSegmentLength = Infinity): number {\n\t\treturn this.BASE_ALLOCATE_COUNT + this.getMaxSegments(maxLength, baseSegmentLength, maxSegmentLength);\n\t}\n\tprivate memory: MemoryHeap;\n\n\t// Length, Type, Base Segment Length, Max Segments, Max Segment Length, Segment Count, Grow Lock, Segments\n\tprivate firstBlock: AllocatedMemory;\n\tprivate uint16Array: Uint16Array;\n\tprivate growLock: Int32Array;\n\treadonly maxLength: number;\n\n\t// False when firstBlock is a slice of another structure's memory (e.g. inlined in SharedPool); that owner frees it\n\tprivate ownsFirstBlock: boolean;\n\n\tprivate cachedSegments: T[] = [];\n\t// Parallel to cachedSegments: the per-slot publish sequences for each slot of that segment. Populated together with\n\t// the data view in getSegment, so whenever cachedSegments[i] is set cachedSequences[i] is too.\n\tprivate cachedSequences: Int32Array[] = [];\n\tprivate cachedBaseSegmentLength = 0;\n\t// Segment growth caps at cachedMaxSegmentLength. Segments 0..(cachedCapSegmentCount - 1) double geometrically and cover\n\t// the first cachedGeometricCapacity slots; every segment beyond that is a flat cachedMaxSegmentLength. Indexing splits\n\t// on cachedGeometricCapacity: below it the fast log2 mapping, above it a plain linear division into capped segments.\n\tprivate cachedMaxSegmentLength = 0;\n\tprivate cachedCapSegmentCount = 0;\n\tprivate cachedGeometricCapacity = 0;\n\t// u32 units per data slot: 1 for 32-bit types, 2 for 64-bit (float64/int64/uint64). A segment block is\n\t// segmentLength * cachedByteMultipler data u32s followed by segmentLength sequence u32s.\n\tprivate cachedByteMultipler = 1;\n\n\tget length(): number {\n\t\treturn Atomics.load(this.firstBlock.data, LENGTH_INDEX) & LEN_MASK;\n\t}\n\tget segmentCount(): number {\n\t\treturn Atomics.load(this.firstBlock.data, SEGMENT_COUNT_INDEX);\n\t}\n\tprivate set segmentCount(value: number) {\n\t\tthis.firstBlock.data[SEGMENT_COUNT_INDEX] = value;\n\t}\n\t\n\tget type(): number {\n\t\treturn this.uint16Array[0];\n\t}\n\tprivate set type(value: number) {\n\t\tAtomics.store(this.uint16Array, 0, value);\n\t}\n\n\tget baseSegmentLength() {\n\t\treturn this.firstBlock.data[BASE_SEGMENT_LENGTH_INDEX];\n\t}\n\tprivate set baseSegmentLength(value: number) {\n\t\tthis.firstBlock.data[BASE_SEGMENT_LENGTH_INDEX] = value;\n\t}\n\tget maxSegments() {\n\t\treturn this.firstBlock.data[MAX_SEGMENTS_INDEX];\n\t}\n\tprivate set maxSegments(value: number) {\n\t\tthis.firstBlock.data[MAX_SEGMENTS_INDEX] = value;\n\t}\n\tget maxSegmentLength() {\n\t\treturn this.firstBlock.data[MAX_SEGMENT_LENGTH_INDEX];\n\t}\n\tprivate set maxSegmentLength(value: number) {\n\t\tthis.firstBlock.data[MAX_SEGMENT_LENGTH_INDEX] = value;\n\t}\n\n\tget pointer() {\n\t\treturn this.firstBlock.pointer;\n\t}\n\n\t// Own internal memory plus every allocated segment. The firstBlock is excluded when inlined in another structure\n\t// (e.g. SharedPool) since that owner already counts it as part of its own internal memory.\n\tget usedMemory(): number {\n\t\tlet total = this.ownsFirstBlock ? this.firstBlock.usedMemory : 0;\n\t\tfor(let i = 0; i < this.segmentCount; i++) {\n\t\t\tlet pointer = getPointer(Atomics.load(this.firstBlock.data, SEGMENT_START_INDEX + i), this.memory.positionBits);\n\t\t\ttotal += new AllocatedMemory(this.memory, pointer).usedMemory;\n\t\t}\n\t\treturn total;\n\t}\n\n\tconstructor(memory: MemoryHeap, config?: SharedStackConfig<T> | SharedStackMemory | SharedStackMemory & SharedStackConfig<T>) {\n\t\tthis.memory = memory;\n\n\t\tif(config && 'firstBlock' in config) {\n\t\t\t// An AllocatedMemory instance is a caller-reserved slice (e.g. inlined in SharedPool); a plain pointer is the\n\t\t\t// serialized clone path. Taking the instance directly keeps us off the pointer-resolving construction branch.\n\t\t\tif(config.firstBlock instanceof AllocatedMemory) {\n\t\t\t\tthis.firstBlock = config.firstBlock;\n\t\t\t} else {\n\t\t\t\tconst maxSegments = new Uint32Array(\n\t\t\t\t\tmemory.buffers[config.firstBlock.bufferPosition].buf,\n\t\t\t\t\tconfig.firstBlock.bufferByteOffset + MAX_SEGMENTS_INDEX * Uint32Array.BYTES_PER_ELEMENT,\n\t\t\t\t\t1,\n\t\t\t\t)[0];\n\t\t\t\tthis.firstBlock = new AllocatedMemory(memory, {\n\t\t\t\t\tlength: SharedStack.BASE_ALLOCATE_COUNT + maxSegments,\n\t\t\t\t\t...config.firstBlock,\n\t\t\t\t});\n\t\t\t}\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\n\t\t\t// Memory passed together with config means the caller reserved the firstBlock slot for us to initialize in place\n\t\t\tif('type' in config || 'baseSegmentLength' in config || 'maxLength' in config) {\n\t\t\t\tthis.initialize(config);\n\t\t\t\tthis.ownsFirstBlock = false;\n\t\t\t} else {\n\t\t\t\tthis.ownsFirstBlock = true;\n\t\t\t}\n\t\t} else {\n\t\t\tlet byteMultipler = getByteMultipler(getArrayTypeCode(config?.type ?? Uint32Array));\n\t\t\tlet baseSegmentLength = config?.baseSegmentLength ?? DEFAULT_BASE_SEGMENT_LENGTH;\n\t\t\tlet maxSegmentLength = this.resolveMaxSegmentLength(baseSegmentLength, config?.maxSegmentLength, byteMultipler);\n\t\t\tlet maxSegments = this.resolveMaxSegments(config?.maxLength, baseSegmentLength, maxSegmentLength);\n\n\t\t\tthis.firstBlock = memory.allocUI32(SharedStack.BASE_ALLOCATE_COUNT + maxSegments);\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\t\t\tthis.ownsFirstBlock = true;\n\n\t\t\tthis.initialize(config);\n\t\t}\n\n\t\tthis.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + GROW_LOCK_INDEX * Uint32Array.BYTES_PER_ELEMENT, 1);\n\t\tthis.cachedByteMultipler = getByteMultipler(this.type);\n\t\tthis.cachedBaseSegmentLength = this.baseSegmentLength;\n\t\tthis.cachedMaxSegmentLength = this.maxSegmentLength;\n\t\t// Segments 0..(K-1) double geometrically up to the cap, where K = log2(cap / base) + 1\n\t\tthis.cachedCapSegmentCount = 32 - Math.clz32(((this.cachedMaxSegmentLength / this.cachedBaseSegmentLength) | 0));\n\t\tthis.cachedGeometricCapacity = this.cachedBaseSegmentLength * ((1 << this.cachedCapSegmentCount) - 1);\n\t\tthis.maxLength = SharedStack.getCapacity(this.maxSegments, this.cachedBaseSegmentLength, this.cachedMaxSegmentLength);\n\t\tif(this.maxLength > MAX_COUNT) {\n\t\t\t// The length word reserves LEN_BITS for the count and the rest for the ABA version tag\n\t\t\tthrow new Error(`SharedStack maxLength ${this.maxLength} exceeds the ${MAX_COUNT} the versioned length counter can address`);\n\t\t}\n\t}\n\n\t// Cap on segment length: the largest a single buffer can hold, optionally lowered to a caller-requested value (floored\n\t// to a power-of-two multiple of the base). Beyond this segments stop doubling and stay flat so each still fits a buffer.\n\tprivate resolveMaxSegmentLength(baseSegmentLength: number, requested?: number, byteMultipler = 1): number {\n\t\tlet cap = SharedStack.getMaxSegmentLength(this.memory.maxAllocationLength, baseSegmentLength, byteMultipler);\n\t\tif(requested) {\n\t\t\tlet floored = baseSegmentLength;\n\t\t\twhile(floored * 2 <= requested) {\n\t\t\t\tfloored *= 2;\n\t\t\t}\n\t\t\tcap = Math.min(cap, floored);\n\t\t}\n\t\treturn cap;\n\t}\n\n\t// Segments needed to cover maxLength (or the default budget when none is given), but never more than the segment-pointer\n\t// spine can hold in a single buffer. Once capped, segments no longer double, so a huge maxLength on a small buffer is\n\t// honestly bounded here instead of blowing up later when the spine (or a segment) can't be allocated.\n\tprivate resolveMaxSegments(maxLength: number | undefined, baseSegmentLength: number, maxSegmentLength: number): number {\n\t\tlet needed = maxLength === undefined\n\t\t\t? DEFAULT_MAX_SEGMENTS\n\t\t\t: SharedStack.getMaxSegments(maxLength, baseSegmentLength, maxSegmentLength);\n\t\tlet spineLimit = this.memory.maxAllocationLength - SharedStack.BASE_ALLOCATE_COUNT;\n\t\treturn Math.min(needed, spineLimit);\n\t}\n\n\tprivate initialize(config?: SharedStackConfig<T>) {\n\t\tlet typeCode = getArrayTypeCode(config?.type ?? Uint32Array);\n\t\tlet byteMultipler = getByteMultipler(typeCode);\n\t\tlet baseSegmentLength = config?.baseSegmentLength ?? DEFAULT_BASE_SEGMENT_LENGTH;\n\t\tlet maxSegmentLength = this.resolveMaxSegmentLength(baseSegmentLength, config?.maxSegmentLength, byteMultipler);\n\t\t// Each segment block holds the data slots (byteMultipler u32s each) followed by one publish sequence u32 per slot\n\t\tlet firstSegmentBlock = this.memory.allocUI32(baseSegmentLength * (byteMultipler + 1));\n\t\tstorePointer(this.firstBlock.data, SEGMENT_START_INDEX, firstSegmentBlock.bufferPosition, firstSegmentBlock.bufferByteOffset, this.memory.positionBits);\n\t\tthis.baseSegmentLength = baseSegmentLength;\n\t\tthis.maxSegmentLength = maxSegmentLength;\n\t\tthis.maxSegments = this.resolveMaxSegments(config?.maxLength, baseSegmentLength, maxSegmentLength);\n\t\tthis.segmentCount = 1;\n\t\tthis.type = typeCode;\n\t}\n\n\tat(index: number): T[number] {\n\t\tlet length = this.length;\n\t\tif(index >= length || index < 0) {\n\t\t\tthrow new Error(`${index} is out of bounds ${length}`);\n\t\t}\n\n\t\tlet geometricCapacity = this.cachedGeometricCapacity;\n\t\tlet segmentIndex: number;\n\t\tlet localIndex: number;\n\t\tif(index < geometricCapacity) {\n\t\t\tlet baseSegmentLength = this.cachedBaseSegmentLength;\n\t\t\tsegmentIndex = 31 - Math.clz32(((index / baseSegmentLength) | 0) + 1);\n\t\t\tlocalIndex = index - baseSegmentLength * ((1 << segmentIndex) - 1);\n\t\t} else {\n\t\t\tlet maxSegmentLength = this.cachedMaxSegmentLength;\n\t\t\tlet offset = index - geometricCapacity;\n\t\t\tlet extra = (offset / maxSegmentLength) | 0;\n\t\t\tsegmentIndex = this.cachedCapSegmentCount + extra;\n\t\t\tlocalIndex = offset - extra * maxSegmentLength;\n\t\t}\n\t\tlet segment = this.cachedSegments[segmentIndex] ?? this.getSegment(segmentIndex);\n\t\t// push() bumps the length before it stores the value and publishes the slot, so an index already counted in length\n\t\t// can still be mid-publish. Wait for the slot's sequence to go odd (published) before reading, otherwise we hand\n\t\t// back a slot whose value hasn't landed yet - for the pool's chunk pointers that means decoding a zeroed pointer.\n\t\tlet sequences = this.cachedSequences[segmentIndex];\n\t\twhile((Atomics.load(sequences, localIndex) & 1) === 0) { /* spin: value is being published on another thread */ }\n\t\treturn (segment as NumericArrayIO)[localIndex];\n\t}\n\n\tpush(value: T[number]): number {\n\t\tlet data = this.firstBlock.data;\n\t\tlet geometricCapacity = this.cachedGeometricCapacity;\n\t\t// eslint-disable-next-line no-constant-condition\n\t\twhile(true) {\n\t\t\t// Plain (relaxed) read is enough: it only seeds the versioned CAS below, which rejects any stale value\n\t\t\tlet packed = data[LENGTH_INDEX];\n\t\t\tlet newIndex = packed & LEN_MASK;\n\t\t\tif(newIndex >= this.maxLength) {\n\t\t\t\tthrow new Error(`${newIndex + 1} is out of bounds ${this.maxLength}`);\n\t\t\t}\n\n\t\t\tlet segmentIndex: number;\n\t\t\tlet localIndex: number;\n\t\t\tif(newIndex < geometricCapacity) {\n\t\t\t\tlet baseSegmentLength = this.cachedBaseSegmentLength;\n\t\t\t\tsegmentIndex = 31 - Math.clz32(((newIndex / baseSegmentLength) | 0) + 1);\n\t\t\t\tlocalIndex = newIndex - baseSegmentLength * ((1 << segmentIndex) - 1);\n\t\t\t} else {\n\t\t\t\tlet maxSegmentLength = this.cachedMaxSegmentLength;\n\t\t\t\tlet offset = newIndex - geometricCapacity;\n\t\t\t\tlet extra = (offset / maxSegmentLength) | 0;\n\t\t\t\tsegmentIndex = this.cachedCapSegmentCount + extra;\n\t\t\t\tlocalIndex = offset - extra * maxSegmentLength;\n\t\t\t}\n\t\t\tlet segment = this.cachedSegments[segmentIndex] ?? this.getSegment(segmentIndex);\n\t\t\tlet sequences = this.cachedSequences[segmentIndex];\n\n\t\t\t// The slot must be empty (even sequence) to fill. Odd means a popper hasn't finished emptying it yet - retry\n\t\t\tlet sequence = Atomics.load(sequences, localIndex);\n\t\t\tif((sequence & 1) !== 0) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\t// Take the slot only if the whole versioned length word is unchanged. The version bump makes this fail on any\n\t\t\t// intervening op, so a win guarantees nothing touched the top - and our sequence read above is still valid\n\t\t\tif(Atomics.compareExchange(data, LENGTH_INDEX, packed, packed + VERSION_STEP + 1) !== packed) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t(segment as NumericArrayIO)[localIndex] = value;\n\t\t\t// Publish: bump to odd (full). Safe as a plain store - no other op can claim this slot until the length comes\n\t\t\t// back down to it, which can't happen (its popper is gated on an odd sequence) until this store lands\n\t\t\tAtomics.store(sequences, localIndex, sequence + 1);\n\t\t\treturn newIndex;\n\t\t}\n\t}\n\n\tpop(): T[number] | undefined {\n\t\tlet data = this.firstBlock.data;\n\t\tlet geometricCapacity = this.cachedGeometricCapacity;\n\t\t// eslint-disable-next-line no-constant-condition\n\t\twhile(true) {\n\t\t\t// Plain (relaxed) read is enough: it only seeds the versioned CAS below, which rejects any stale value\n\t\t\tlet packed = data[LENGTH_INDEX];\n\t\t\tlet length = packed & LEN_MASK;\n\t\t\tif(length <= 0) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tlet oldIndex = length - 1;\n\n\t\t\tlet segmentIndex: number;\n\t\t\tlet localIndex: number;\n\t\t\tif(oldIndex < geometricCapacity) {\n\t\t\t\tlet baseSegmentLength = this.cachedBaseSegmentLength;\n\t\t\t\tsegmentIndex = 31 - Math.clz32(((oldIndex / baseSegmentLength) | 0) + 1);\n\t\t\t\tlocalIndex = oldIndex - baseSegmentLength * ((1 << segmentIndex) - 1);\n\t\t\t} else {\n\t\t\t\tlet maxSegmentLength = this.cachedMaxSegmentLength;\n\t\t\t\tlet offset = oldIndex - geometricCapacity;\n\t\t\t\tlet extra = (offset / maxSegmentLength) | 0;\n\t\t\t\tsegmentIndex = this.cachedCapSegmentCount + extra;\n\t\t\t\tlocalIndex = offset - extra * maxSegmentLength;\n\t\t\t}\n\t\t\tlet segment = this.cachedSegments[segmentIndex] ?? this.getSegment(segmentIndex);\n\t\t\tlet sequences = this.cachedSequences[segmentIndex];\n\n\t\t\t// The slot must be full (odd sequence) to read. Even means a pusher hasn't finished publishing it yet - retry\n\t\t\tlet sequence = Atomics.load(sequences, localIndex);\n\t\t\tif((sequence & 1) === 0) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif(Atomics.compareExchange(data, LENGTH_INDEX, packed, packed + VERSION_STEP - 1) !== packed) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tlet value = (segment as NumericArrayIO)[localIndex] as T[number];\n\t\t\t// Release the slot: bump to even (empty) so a later push may reuse it\n\t\t\tAtomics.store(sequences, localIndex, sequence + 1);\n\t\t\treturn value;\n\t\t}\n\t}\n\n\tclear() {\n\t\t// Mark every occupied slot empty (bump its odd sequence to the next even) before dropping the length, otherwise a\n\t\t// later push reusing the slot would spin forever on a stale full sequence. Not safe to call concurrently with push/pop.\n\t\tlet baseSegmentLength = this.cachedBaseSegmentLength;\n\t\tlet geometricCapacity = this.cachedGeometricCapacity;\n\t\tlet maxSegmentLength = this.cachedMaxSegmentLength;\n\t\tlet oldLength = Atomics.load(this.firstBlock.data, LENGTH_INDEX) & LEN_MASK;\n\t\tfor(let i = 0; i < oldLength; i++) {\n\t\t\tlet segmentIndex: number;\n\t\t\tlet localIndex: number;\n\t\t\tif(i < geometricCapacity) {\n\t\t\t\tsegmentIndex = 31 - Math.clz32(((i / baseSegmentLength) | 0) + 1);\n\t\t\t\tlocalIndex = i - baseSegmentLength * ((1 << segmentIndex) - 1);\n\t\t\t} else {\n\t\t\t\tlet offset = i - geometricCapacity;\n\t\t\t\tlet extra = (offset / maxSegmentLength) | 0;\n\t\t\t\tsegmentIndex = this.cachedCapSegmentCount + extra;\n\t\t\t\tlocalIndex = offset - extra * maxSegmentLength;\n\t\t\t}\n\t\t\tlet sequences = this.cachedSequences[segmentIndex] ?? (this.getSegment(segmentIndex), this.cachedSequences[segmentIndex]);\n\t\t\tlet sequence = Atomics.load(sequences, localIndex);\n\t\t\tif((sequence & 1) !== 0) {\n\t\t\t\tAtomics.store(sequences, localIndex, sequence + 1);\n\t\t\t}\n\t\t}\n\t\tAtomics.store(this.firstBlock.data, LENGTH_INDEX, 0);\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tlet totalDataEntries = this.length;\n\n\t\tlet maxSegmentLength = this.cachedMaxSegmentLength;\n\t\tlet segmentLength = this.baseSegmentLength;\n\t\tlet segmentIndex = 0;\n\t\tlet segment = this.getSegment(segmentIndex);\n\t\tlet segmentDataIndex = 0;\n\t\tfor(let i = 0; i < totalDataEntries; i++) {\n\t\t\tyield (segment as NumericArrayIO)[segmentDataIndex] as T[number];\n\t\t\tsegmentDataIndex++;\n\t\t\tif(segmentDataIndex >= segmentLength) {\n\t\t\t\tsegmentIndex++;\n\t\t\t\tsegment = this.getSegment(segmentIndex);\n\t\t\t\tsegmentDataIndex = 0;\n\t\t\t\tsegmentLength = Math.min(segmentLength * 2, maxSegmentLength);\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getSegment(segmentIndex: number): T {\n\t\tif(this.cachedSegments[segmentIndex]) {\n\t\t\treturn this.cachedSegments[segmentIndex];\n\t\t}\n\n\t\t// Geometric while below the cap, then flat so the block always fits a single buffer\n\t\tlet segmentLength = segmentIndex < this.cachedCapSegmentCount\n\t\t\t? this.cachedBaseSegmentLength << segmentIndex\n\t\t\t: this.cachedMaxSegmentLength;\n\t\tlet segmentDataBlock: AllocatedMemory | undefined;\n\t\tif(segmentIndex >= this.segmentCount) {\n\t\t\t// Lock when growing so another thread doesn't also setup the same segment\n\t\t\tlock(this.growLock);\n\t\t\ttry {\n\t\t\t\t// Re-check under the lock: another thread may have already appended the segment while we were waiting\n\t\t\t\tif(segmentIndex >= this.segmentCount) {\n\t\t\t\t\t// Data slots (byteMultipler u32s each) followed by one publish sequence u32 per slot (calloc-zeroed = 0 = empty)\n\t\t\t\t\tsegmentDataBlock = this.memory.allocUI32(segmentLength * (this.cachedByteMultipler + 1));\n\t\t\t\t\tstorePointer(this.firstBlock.data, SEGMENT_START_INDEX + segmentIndex, segmentDataBlock.bufferPosition, segmentDataBlock.bufferByteOffset, this.memory.positionBits);\n\t\t\t\t\tAtomics.add(this.firstBlock.data, SEGMENT_COUNT_INDEX, 1);\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tunlock(this.growLock);\n\t\t\t}\n\t\t}\n\n\t\tif(!segmentDataBlock) {\n\t\t\tlet pointerNumber = Atomics.load(this.firstBlock.data, SEGMENT_START_INDEX + segmentIndex);\n\t\t\tlet pointer = getPointer(pointerNumber, this.memory.positionBits);\n\t\t\tsegmentDataBlock = new AllocatedMemory(this.memory, pointer);\n\t\t}\n\n\t\tlet data = makeArrayView(this.type, segmentDataBlock.data.buffer, segmentDataBlock.bufferByteOffset, segmentLength) as T;\n\t\t// Publish sequences live after the data region (segmentLength * byteMultipler u32s), always as Int32 regardless of type\n\t\tlet sequenceByteOffset = segmentDataBlock.bufferByteOffset + segmentLength * this.cachedByteMultipler * Uint32Array.BYTES_PER_ELEMENT;\n\t\tthis.cachedSequences[segmentIndex] = new Int32Array(segmentDataBlock.data.buffer, sequenceByteOffset, segmentLength);\n\t\tthis.cachedSegments[segmentIndex] = data;\n\n\t\treturn data;\n\t}\n\n\tfree() {\n\t\tfor(let i = 0; i < this.segmentCount; i++) {\n\t\t\tlet pointerNumber = Atomics.load(this.firstBlock.data, SEGMENT_START_INDEX + i);\n\t\t\tlet pointer = getPointer(pointerNumber, this.memory.positionBits);\n\t\t\tlet rawData = new AllocatedMemory(this.memory, pointer);\n\t\t\trawData.free();\n\t\t}\n\t\tif(this.ownsFirstBlock) {\n\t\t\tthis.firstBlock.free();\n\t\t}\n\t}\n\n\tgetSharedMemory(): SharedStackMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.firstBlock.getSharedMemory(),\n\t\t};\n\t}\n}\n\ninterface SharedStackConfig<T extends NumericArray> {\n\ttype?: TypedArrayConstructor<T>\n\n\tbaseSegmentLength?: number\n\tmaxLength?: number\n\t// Cap on how large a single segment may grow. Defaults to the largest a buffer can hold; a smaller value is floored to\n\t// a power-of-two multiple of baseSegmentLength. Beyond the cap segments stay flat instead of doubling.\n\tmaxSegmentLength?: number\n}\ninterface SharedStackMemory {\n\tfirstBlock: SharedAllocatedMemory | AllocatedMemory\n}\n\nexport type { SharedStackConfig, SharedStackMemory };"],"mappings":"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"}