@daneren2005/shared-memory-objects 0.0.1 → 0.0.2

package/README.md

@@ -1,4 +1,28 @@
 # Shared Memory Objects
-A library to try to make making a multi-threaded game in Javascript possible.
+A library to try to make making a multi-threaded game in Javascript possible.  This package is to provide a wrapper to create objects and data structures that are backed by a SharedArrayBuffer and can be shared between multiple threads.  The end result is a package that has all of the slowness of Javascript with all of the baggage of dealing with manual memory allocations.  If you need to multi-thread you are probably better of just using a different language and compiling to WebAssembly.  But if you, like me, just want to use Javascript/Typescript and are willing to deal with dealing with manual memory allocations then this library could save you some time.
 
-TODO
+## Basics
+The core of this package is the MemoryHeap.  You should usually just have a single heap that is shared between all of your different threads.  Each heap can have multiple MemoryBuffers.  By default each buffer is only 8KB but it can be configured up to 1MB, and you can have up to 4k buffers for a total of 4GB.  When you allocate memory, if there is not enough space it will allocate another buffers automatically.  When allocating memory, you will get a AllocatedMemory object that is a wrapper around the allocated memory by calling `heap.allocUI32({count of 32 bit numbers})`.  By default AllocatedMemory is backed by a Uint32Array but you can get any type of array from `AllocatedMemory.getArray(Int32Array);`.
+
+Each allocated memory location can be stored as an int pointer.  You can use `getPointer(int)` to get the bufferPosition (ie: buffer index in the heap) and bufferByteOffset that the memory location points to.  You can also convert a bufferPosition/bufferByteOffset pair to an int pointer with `createPointer(bufferPosition, bufferByteOffset)`.  The pointer format is uses 12 bits for the buffer index and the remaining 20 bits for the byte offset in that buffer for a total of 1MB per buffer and 4GB total of memory.  Each allocated memory object can return either a pointer via `allocatedMemory.pointer` or the raw position/byte offset via `allocatedMemory.getSharedMemory()`.
+
+When passing memory to another thread you can either pass a pointer or a serialized version of the buffer position/byte offset in order to re-create the object in the other thread.
+
+## Data Structures
+- SharedList
+- SharedVector
+- SharedMap
+- SharedString
+
+## Thread Safety
+- Memory allocations is thread safe as long as it does not need to create a new buffer.  Right now that can only be done from the main thread.
+- SharedList, SharedVector, and SharedMap are all not thread safe.
+- SharedString is thread safe with a lock on read/write with a cached version of the string so it doesn't need to lock after the first read unless the string has changed.
+
+## TODO
+- Make creating new buffers from allocations possible from multiple threads
+- Make data structures thread safe
+- Add basic thread safe object example
+
+## Credit
+The entire core of this library is based on a fork of @thi.ng/malloc found at https://github.com/thi-ng/umbrella/blob/develop/packages/malloc.  The only big difference between our MemoryBuffer and their MemPool is making allocations/freeing memory thread safe.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daneren2005/shared-memory-objects",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "author": "daneren2005@gmail.com",
   "description": "Creating objects with a SharedArrayBuffer",
   "homepage": "https://github.com/daneren2005/shared-memory-objects#readme",
@@ -17,9 +17,13 @@
   },
   "type": "module",
   "files": [
-    "src/"
+    "src/",
+    "!__tests__"
   ],
   "main": "./src/main.ts",
+  "exports": {
+    ".": "./src/main.ts"
+  },
   "scripts": {
     "dev": "vite",
     "lint": "eslint src/ --ext .js,.cjs,.mjs,.ts,.cts,.mts --ignore-path .gitignore",

package/src/__tests__/memory-heap.spec.ts

@@ -1,92 +0,0 @@
-import AllocatedMemory from '../allocated-memory';
-import MemoryHeap from '../memory-heap';
-
-describe('MemoryHeap', () => {
-	it('auto grows memory as needed', () => {
-		let memory = new MemoryHeap({ bufferSize: 200 });
-		const startedUsed = memory.currentUsed;
-
-		let allocated = memory.allocUI32(10);
-		expect(allocated.data.length).toEqual(10);
-		memory.allocUI32(10);
-		expect(memory.buffers.length).toEqual(1);
-		// Don't try to get exact size since actual used memory depends on how much memory malloc is using for internal representation
-		expect(memory.currentUsed).toBeGreaterThan(startedUsed + 20 * 4);
-		expect(memory.totalAllocated).toEqual(200);
-		const midUsed = memory.currentUsed;
-
-		memory.allocUI32(20);
-		expect(memory.buffers.length).toEqual(2);
-		expect(memory.currentUsed).toBeGreaterThan(midUsed + 20 * 4);
-		expect(memory.totalAllocated).toEqual(400);
-	});
-	it('can re-create from raw memory and continue working', () => {
-		let mainMemory = new MemoryHeap({ bufferSize: 200 });
-		let copyMemory = new MemoryHeap({
-			buffers: mainMemory.buffers.map(buffer => buffer.buf as SharedArrayBuffer)
-		});
-
-		let mainBlock = mainMemory.allocUI32(10);
-		let copyBlock = new AllocatedMemory(copyMemory, mainBlock.getSharedMemory());
-		expect(copyBlock.data.length).toEqual(12);
-
-		mainBlock.data[1] = 10;
-		expect(copyBlock.data[1]).toEqual(10);
-	});
-
-	it('grabs free memory from any used buffer', () => {
-		let memory = new MemoryHeap({ bufferSize: 200 });
-
-		let block1 = memory.allocUI32(20);
-		let block2 = memory.allocUI32(20);
-		let block3 = memory.allocUI32(20);
-		expect(memory.buffers.length).toEqual(3);
-		let maxMemory = memory.currentUsed;
-
-		block1.free();
-		expect(memory.currentUsed).toBeLessThan(maxMemory);
-		memory.allocUI32(20);
-		expect(memory.buffers.length).toEqual(3);
-		expect(memory.currentUsed).toEqual(maxMemory);
-		
-		block2.free();
-		expect(memory.currentUsed).toBeLessThan(maxMemory);
-		memory.allocUI32(20);
-		expect(memory.buffers.length).toEqual(3);
-		expect(memory.currentUsed).toEqual(maxMemory);
-		
-		block3.free();
-		expect(memory.currentUsed).toBeLessThan(maxMemory);
-		memory.allocUI32(20);
-		expect(memory.buffers.length).toEqual(3);
-		expect(memory.currentUsed).toEqual(maxMemory);
-	});
-
-	it('growing memory by doubles while freeing previous', () => {
-		let memory = new MemoryHeap({
-			bufferSize: 1_024 * 16
-		});
-		let allocSize = 40;
-
-		let oldMemory = memory.allocUI32(allocSize);
-		for(let i = 0; i < 5; i++) {
-			allocSize *= 2;
-			let newMemory = memory.allocUI32(allocSize);
-			expect(newMemory.bufferByteOffset).toBeGreaterThan(oldMemory.bufferByteOffset);
-
-			oldMemory.free();
-			oldMemory = newMemory;
-		}
-	});
-
-	it('Block creating with bufferSize greater than 1MB', () => {
-		let error: Error | null = null;
-		try {
-			new MemoryHeap({ bufferSize: Math.pow(2, 30) });
-		} catch(e) {
-			error = e as Error;
-		}
-
-		expect(error).not.toBeNull();
-	});
-});

package/src/__tests__/serialize-object.spec.ts

@@ -1,23 +0,0 @@
-import MemoryHeap from '../memory-heap';
-import { serializeObjectToMemory, createObjectFromMemory } from '../serialize-object';
-
-describe('SerializeObject', () => {
-	let heap: MemoryHeap;
-	beforeEach(() => {
-		heap = new MemoryHeap();
-	});
-
-	it('simple', () => {
-		const object = {
-			test: 12.5,
-			test2: 'string',
-			fa: 'blue'
-		};
-		let memory = serializeObjectToMemory(heap, object);
-
-		let clone = createObjectFromMemory<typeof object>(memory);
-		expect(clone.test).toEqual(12.5);
-		expect(clone.test2).toEqual('string');
-		expect(clone.fa).toEqual('blue');
-	});
-});

package/src/__tests__/shared-data.bench.ts

@@ -1,166 +0,0 @@
-import { bench } from 'vitest';
-import SharedList from '../shared-list';
-import MemoryHeap from '../memory-heap';
-import SharedMap from '../shared-map';
-import SharedVector from '../shared-vector';
-
-const INSERT_COUNT = 1_000;
-describe(`Shared Data Structures: ${INSERT_COUNT} inserts`, () => {
-	bench('shared list', () => {
-		let memory = new MemoryHeap();
-		let list = new SharedList(memory);
-
-		for(let i = 0; i < INSERT_COUNT; i++) {
-			list.insert(Math.random() * 1_000_000);
-		}
-	});
-	bench('shared map', () => {
-		let memory = new MemoryHeap();
-		let list = new SharedMap<number>(memory);
-
-		for(let i = 0; i < INSERT_COUNT; i++) {
-			list.set(Math.random() * 1_000_000, Math.random() * 1_000_000);
-		}
-	});
-	bench('shared vector', () => {
-		let memory = new MemoryHeap();
-		let list = new SharedVector(memory);
-
-		for(let i = 0; i < INSERT_COUNT; i++) {
-			list.push(Math.random() * 1_000_000);
-		}
-	});
-	bench('shared vector with correct amount initialized', () => {
-		let memory = new MemoryHeap();
-		let list = new SharedVector(memory, {
-			bufferLength: INSERT_COUNT + 2
-		});
-
-		for(let i = 0; i < INSERT_COUNT; i++) {
-			list.push(Math.random() * 1_000_000);
-		}
-	});
-	bench('native array', () => {
-		let list: Array<number> = [];
-		for(let i = 0; i < INSERT_COUNT; i++) {
-			list.push(Math.random() * 1_000_000);
-		}
-	});
-});
-
-const DELETE_COUNT = 1_000;
-describe(`Shared Data Structures: ${DELETE_COUNT} deletes end element`, () => {
-	const INSERT_COUNT = 2_000;
-
-	let sharedList: SharedList;
-	bench('shared list', () => {
-		for(let i = 0; i < DELETE_COUNT; i++) {
-			sharedList.deleteIndex(0);
-		}
-	}, {
-		setup: (task) => {
-			task.opts.beforeEach = () => {
-				let memory = new MemoryHeap();
-				sharedList = new SharedList(memory);
-				for(let i = 0; i < INSERT_COUNT; i++) {
-					sharedList.insert(Math.random() * 1_000_000);
-				}
-			};
-		}
-	});
-
-	let sharedVector: SharedVector;
-	bench('shared vector', () => {
-		for(let i = 0; i < DELETE_COUNT; i++) {
-			sharedVector.pop();
-		}
-	}, {
-		setup: (task) => {
-			task.opts.beforeEach = () => {
-				let memory = new MemoryHeap({
-					bufferSize: 1024 * 16
-				});
-				sharedVector = new SharedVector(memory);
-				for(let i = 0; i < INSERT_COUNT; i++) {
-					sharedVector.push(Math.random() * 1_000_000);
-				}
-			};
-		}
-	});
-
-	let nativeList: Array<number> = [];
-	bench('native array', () => {
-		for(let i = 0; i < DELETE_COUNT; i++) {
-			nativeList.pop();
-		}
-	}, {
-		setup: (task) => {
-			task.opts.beforeEach = () => {
-				nativeList = [];
-				for(let i = 0; i < INSERT_COUNT; i++) {
-					nativeList.push(Math.random() * 1_000_000);
-				}
-			};
-		}
-	});
-});
-
-describe(`Shared Data Structures: ${DELETE_COUNT} deletes random element`, () => {
-	const INSERT_COUNT = 2_000;
-
-	let sharedList: SharedList;
-	bench('shared list', () => {
-		for(let i = 0; i < DELETE_COUNT; i++) {
-			sharedList.deleteIndex(randomIndex(sharedList));
-		}
-	}, {
-		setup: (task) => {
-			task.opts.beforeEach = () => {
-				let memory = new MemoryHeap();
-				sharedList = new SharedList(memory);
-				for(let i = 0; i < INSERT_COUNT; i++) {
-					sharedList.insert(Math.random() * 1_000_000);
-				}
-			};
-		}
-	});
-
-	let sharedVector: SharedVector;
-	bench('shared vector', () => {
-		for(let i = 0; i < DELETE_COUNT; i++) {
-			sharedVector.deleteIndex(randomIndex(sharedList));
-		}
-	}, {
-		setup: (task) => {
-			task.opts.beforeEach = () => {
-				let memory = new MemoryHeap({
-					bufferSize: 1024 * 16
-				});
-				sharedVector = new SharedVector(memory);
-				for(let i = 0; i < INSERT_COUNT; i++) {
-					sharedVector.push(Math.random() * 1_000_000);
-				}
-			};
-		}
-	});
-
-	let nativeList: Array<number> = [];
-	bench('native array', () => {
-		for(let i = 0; i < DELETE_COUNT; i++) {
-			nativeList.splice(randomIndex(nativeList), 1);
-		}
-	}, {
-		setup: (task) => {
-			task.opts.beforeEach = () => {
-				nativeList = [];
-				for(let i = 0; i < INSERT_COUNT; i++) {
-					nativeList.push(Math.random() * 1_000_000);
-				}
-			};
-		}
-	});
-});
-
-function randomIndex(array: { length: number }) {
-	return Math.floor(Math.random() * array.length);
-}

package/src/__tests__/shared-list.spec.ts

@@ -1,247 +0,0 @@
-import SharedList from '../shared-list';
-import MemoryHeap from '../memory-heap';
-
-describe('SharedList', () => {
-	let memory: MemoryHeap;
-	beforeEach(() => {
-		memory = new MemoryHeap();
-	});
-
-	it('can insert items', () => {
-		let list = new SharedList(memory);
-
-		list.insert(5);
-		expect(list.length).toEqual(1);
-
-		list.insert(10);
-		list.insert(4);
-		expect(list.length).toEqual(3);
-
-		expect(flat(list)).toEqual([5, 10, 4]);
-	});
-	it('can delete items by index', () => {
-		let list = new SharedList(memory);
-		let startMemory = memory.currentUsed;
-		list.insert(5);
-		list.insert(10);
-		list.insert(4);
-		list.insert(8);
-		list.insert(20);
-		let fullMemory = memory.currentUsed;
-
-		list.deleteIndex(2);
-		expect(flat(list)).toEqual([5, 10, 8, 20]);
-		expect(memory.currentUsed).toBeLessThan(fullMemory);
-		expect(list.length).toEqual(4);
-
-		list.deleteIndex(0);
-		expect(flat(list)).toEqual([10, 8, 20]);
-		list.deleteIndex(2);
-		expect(flat(list)).toEqual([10, 8]);
-
-		// Do nothing for bug deletes
-		list.deleteIndex(2);
-		expect(flat(list)).toEqual([10, 8]);
-		
-		// Delete everything and should still work
-		list.deleteIndex(0);
-		list.deleteIndex(0);
-		expect(flat(list)).toEqual([]);
-		expect(list.length).toEqual(0);
-		expect(memory.currentUsed).toEqual(startMemory);
-
-		list.insert(80);
-		list.insert(52);
-		expect(flat(list)).toEqual([80, 52]);
-	});
-	it('can delete items by value', () => {
-		let list = new SharedList(memory);
-		let startMemory = memory.currentUsed;
-		list.insert(5);
-		list.insert(10);
-		list.insert(4);
-		list.insert(8);
-		list.insert(20);
-		let fullMemory = memory.currentUsed;
-
-		list.deleteValue(4);
-		expect(flat(list)).toEqual([5, 10, 8, 20]);
-		expect(memory.currentUsed).toBeLessThan(fullMemory);
-		expect(list.length).toEqual(4);
-
-		list.deleteValue(5);
-		expect(flat(list)).toEqual([10, 8, 20]);
-		list.deleteValue(20);
-		expect(flat(list)).toEqual([10, 8]);
-
-		// Do nothing for bug deletes
-		list.deleteValue(15);
-		expect(flat(list)).toEqual([10, 8]);
-		
-		// Delete everything and should still work
-		list.deleteValue(10);
-		list.deleteValue(8);
-		expect(flat(list)).toEqual([]);
-		expect(list.length).toEqual(0);
-		expect(memory.currentUsed).toEqual(startMemory);
-
-		list.insert(80);
-		list.insert(52);
-		expect(flat(list)).toEqual([80, 52]);
-	});
-
-	it('can delete during iteration', () => {
-		let list = new SharedList(memory);
-		list.insert(5);
-		list.insert(10);
-		list.insert(4);
-		list.insert(8);
-		list.insert(20);
-		let fullMemory = memory.currentUsed;
-
-		for(let { data, deleteCurrent } of list) {
-			if(data[0] === 10 || data[0] === 20) {
-				deleteCurrent();
-			}
-		}
-		
-		expect(flat(list)).toEqual([5, 4, 8]);
-		expect(list.length).toEqual(3);
-		expect(memory.currentUsed).toBeLessThan(fullMemory);
-
-		// Delete concurrent indexes
-		for(let { data, deleteCurrent } of list) {
-			if(data[0] === 5 || data[0] === 4) {
-				deleteCurrent();
-			}
-		}
-		expect(flat(list)).toEqual([8]);
-		expect(list.length).toEqual(1);
-	});
-
-	it('can insert and delete over and over again without leaking memory', () => {
-		let list = new SharedList(memory);
-		list.insert(5);
-		list.insert(10);
-		let startMemory = memory.currentUsed;
-
-		for(let i = 0; i < 10; i++) {
-			list.insert(70);
-			list.deleteIndex(2);
-		}
-		for(let i = 0; i < 10; i++) {
-			list.insert(70);
-			list.deleteValue(70);
-		}
-
-		expect(memory.currentUsed).toEqual(startMemory);
-	});
-
-	it('can share memory and insert/delete items from either instance', () => {
-		let mainList = new SharedList(memory);
-		let secondList = new SharedList(memory, mainList.getSharedMemory());
-
-		mainList.insert(5);
-		mainList.insert(60);
-		secondList.insert(14);
-		mainList.insert(8);
-		secondList.deleteIndex(1);
-
-		expect(flat(mainList)).toEqual([5, 14, 8]);
-		expect(flat(secondList)).toEqual([5, 14, 8]);
-	});
-	it.skip('can delete item mid-iteration');
-
-	it('free', () => {
-		let startMemory = memory.currentUsed;
-		let list = new SharedList(memory);
-		list.insert(5);
-		list.insert(10);
-		list.insert(4);
-
-		list.free();
-		expect(memory.currentUsed).toEqual(startMemory);
-	});
-
-	it('with int32', () => {
-		let list = new SharedList(memory, {
-			type: Int32Array
-		});
-
-		list.insert(5);
-		expect(list.length).toEqual(1);
-
-		list.insert(-10);
-		list.insert(4);
-		expect(list.length).toEqual(3);
-
-		expect(flat(list)).toEqual([5, -10, 4]);
-	});
-	it('with float32', () => {
-		let list = new SharedList(memory, {
-			type: Float32Array
-		});
-
-		list.insert(5.5);
-		expect(list.length).toEqual(1);
-
-		list.insert(-10);
-		list.insert(4);
-		expect(list.length).toEqual(3);
-
-		expect(flat(list)).toEqual([5.5, -10, 4]);
-	});
-
-	it('with dataLength = 3', () => {
-		let list = new SharedList(memory, {
-			type: Int32Array,
-			dataLength: 3
-		});
-
-		list.insert(5);
-		expect(list.length).toEqual(1);
-
-		list.insert([-10, 20, 1]);
-		list.insert([4, -40]);
-		expect(list.length).toEqual(3);
-
-		expect(flat(list)).toEqual([
-			5, 0, 0,
-			-10, 20, 1,
-			4, -40, 0
-		]);
-
-		// Don't delete middle values
-		list.deleteValue(20);
-		expect(flat(list)).toEqual([
-			5, 0, 0,
-			-10, 20, 1,
-			4, -40, 0
-		]);
-
-		// Allow deleting first value only
-		list.deleteValue(-10);
-		expect(flat(list)).toEqual([
-			5, 0, 0,
-			4, -40, 0
-		]);
-		expect(list.length).toEqual(2);
-
-		// Allow deleting entire set of values
-		list.deleteValue([4, 10, 0]);
-		list.deleteValue([5, 0, 0]);
-		expect(flat(list)).toEqual([
-			4, -40, 0
-		]);
-		expect(list.length).toEqual(1);
-	});
-});
-
-function flat(list: SharedList<any>) {
-	return [...list].reduce((array, value) => {
-		// @ts-expect-error
-		array.push(...value.data);
-
-		return array;
-	}, []);
-}

package/src/__tests__/shared-map.spec.ts

@@ -1,98 +0,0 @@
-import MemoryHeap from '../memory-heap';
-import SharedMap from '../shared-map';
-
-describe('SharedMap', () => {
-	let memory: MemoryHeap;
-	beforeEach(() => {
-		memory = new MemoryHeap();
-	});
-
-	describe('SharedMap<string>', () => {
-		it('insert and remove items', () => {
-			let map = new SharedMap<string>(memory);
-
-			// NOTE: If values are changed make sure we have at least one hash collision
-			map.set('ds', 3);
-			map.set('asd', 72);
-			map.set('gfredf', 8);
-			map.set('z', 65);
-			// Map should only have one instance of each key - replace
-			map.set('ds', 1);
-			map.set('red', 10);
-			expect(map.length).toEqual(5);
-
-			expect(map.get('gfredf')).toEqual(8);
-			expect(map.get('ds')).toEqual(1);
-			expect(map.get('z')).toEqual(65);
-			expect(map.get('blue')).toBeUndefined();
-			expect(map.get('red')).toEqual(10);
-
-			map.delete('ds');
-			expect(map.length).toEqual(4);
-			expect(map.get('ds')).toEqual(undefined);
-			map.delete('ds');
-			expect(map.length).toEqual(4);
-
-			map.delete('dfsdfsd');
-			expect(map.length).toEqual(4);
-			map.delete('gfredf');
-			expect(map.length).toEqual(3);
-		});
-
-		it('free', () => {
-			let startMemory = memory.currentUsed;
-			let map = new SharedMap<string>(memory);
-			map.set('ds', 3);
-			map.set('asd', 72);
-			map.set('gfredf', 8);
-			map.set('z', 65);
-
-			map.free();
-			expect(memory.currentUsed).toEqual(startMemory);
-		});
-
-		it('can be created from shared memory', () => {
-			let startMemory = memory.currentUsed;
-			let mainMap = new SharedMap<string>(memory);
-			let cloneMap = new SharedMap<string>(memory, mainMap.getSharedMemory());
-
-			mainMap.set('ds', 3);
-			mainMap.set('asd', 72);
-			cloneMap.set('ds', 1);
-			cloneMap.set('red', 10);
-
-			expect(mainMap.length).toEqual(3);
-			expect(cloneMap.length).toEqual(3);
-			
-			expect(mainMap.get('ds')).toEqual(1);
-			expect(cloneMap.get('ds')).toEqual(1);
-
-			cloneMap.free();
-			expect(memory.currentUsed).toEqual(startMemory);
-		});
-
-		it('inserting many items will grow hash table', () => {
-			let map = new SharedMap<string>(memory);
-			const previousMaxHash = map.maxHash;
-			for(let i = 0; i < 5; i++) {
-				insertRandom(map);
-			}
-			expect(map.length).toEqual(5);
-
-			expect(map.maxHash).toEqual(previousMaxHash);
-			for(let i = 0; i < 20; i++) {
-				insertRandom(map);
-			}
-			expect(map.length).toEqual(25);
-			expect(map.maxHash).toBeGreaterThan(previousMaxHash);
-
-			for(let i = 0; i < map.length; i++) {
-				expect(map.get(`${i + 1}`)).not.toBeUndefined();
-			}
-		});
-
-		function insertRandom(map: SharedMap<string>) {
-			map.set(`${map.length + 1}`, Math.random() * 1_000_000);
-		}
-	});
-});

package/src/__tests__/shared-string.spec.ts

@@ -1,75 +0,0 @@
-import MemoryHeap from '../memory-heap';
-import SharedString from '../shared-string';
-
-describe('SharedString', () => {
-	it('can create', () => {
-		let memory = new MemoryHeap();
-		let string = new SharedString(memory, 'Test');
-
-		expect(string.value).toEqual('Test');
-	});
-
-	it('utf16 characters work', () => {
-		let memory = new MemoryHeap();
-		let string = new SharedString(memory, 'Teǭst');
-
-		expect(string.value).toEqual('Teǭst');	
-	});
-
-	it('can initialize from memory without the string allocated yet', () => {
-		let memory = new MemoryHeap();
-		let allocatedMemory = memory.allocUI32(SharedString.ALLOCATE_COUNT);
-		let string = new SharedString(memory, {
-			...allocatedMemory.getSharedMemory(),
-			value: 'Test'
-		});
-
-		expect(string.value).toEqual('Test');
-	});
-	it('can work from uninitialized memory', () => {
-		let memory = new MemoryHeap();
-		let allocatedMemory = memory.allocUI32(SharedString.ALLOCATE_COUNT);
-		let string = new SharedString(memory, allocatedMemory.getSharedMemory());
-
-		expect(string.value).toEqual('');
-	});
-
-	it('can be set to new memory strings', () => {
-		let memory = new MemoryHeap();
-		let string = new SharedString(memory, 'Tests again22222222222222222222');
-		let startMemory = memory.currentUsed;
-		let copy = new SharedString(memory, string.getSharedMemory());
-
-		expect(copy.value).toEqual('Tests again22222222222222222222');
-		
-		copy.value = 'Blows again22222222222222222222';
-		expect(string.value).toEqual('Blows again22222222222222222222');
-		expect(memory.currentUsed).toEqual(startMemory);
-
-		string.value = 'Yo';
-		expect(string.value).toEqual('Yo');
-		expect(copy.value).toEqual('Yo');
-		expect(memory.currentUsed).toBeLessThan(startMemory);
-
-		string.value = 'Yo Mama Is So Fat2222222222222222222222222222222222222222';
-		expect(memory.currentUsed).toBeGreaterThan(startMemory);
-	});
-
-	it('can set to empty string', () => {
-		let memory = new MemoryHeap();
-		let string = new SharedString(memory, '');
-
-		expect(string.value).toEqual('');
-	});
-
-	it('free', () => {
-		let memory = new MemoryHeap();
-		let startMemory = memory.currentUsed;
-		let string = new SharedString(memory, 'Tests');
-		// No memory leak from changing values
-		string.value = 'Blob';
-		string.free();
-
-		expect(memory.currentUsed).toEqual(startMemory);
-	});
-});

package/src/__tests__/shared-vector.spec.ts

@@ -1,163 +0,0 @@
-import MemoryHeap from '../memory-heap';
-import SharedVector from '../shared-vector';
-
-describe('SharedVector', () => {
-	let memory: MemoryHeap;
-	beforeEach(() => {
-		memory = new MemoryHeap({
-			bufferSize: 1024 * 16
-		});
-	});
-
-	it('insert into vector', () => {
-		let vector = new SharedVector(memory, {
-			type: Uint32Array
-		});
-
-		vector.push(10);
-		vector.push(52);
-		vector.push(4);
-
-		expect(vector.length).toEqual(3);
-		expect(flat(vector)).toEqual([10, 52, 4]);
-	});
-
-	it('continually grows memory as needed', () => {
-		let vector = new SharedVector(memory, {
-			type: Uint32Array
-		});
-
-		const expectedValues = [];
-		for(let i = 0; i < 1_000; i++) {
-			vector.push(i);
-			expectedValues.push(i);
-		}
-
-		expect(vector.length).toEqual(1_000);
-		expect(flat(vector)).toEqual(expectedValues);
-	});
-
-	it('pop', () => {
-		let vector = new SharedVector(memory);
-
-		vector.push(10);
-		vector.push(52);
-		vector.push(4);
-		vector.push(8);
-
-		expect([...vector.pop()]).toEqual([8]);
-		expect(vector.length).toEqual(3);
-		expect([...vector.pop()]).toEqual([4]);
-		expect(vector.length).toEqual(2);
-		expect(flat(vector)).toEqual([10, 52]);
-	});
-
-	it('deleteIndex', () => {
-		let vector = new SharedVector(memory);
-
-		vector.push(10);
-		vector.push(52);
-		vector.push(4);
-		vector.push(8);
-
-		vector.deleteIndex(3);
-		expect(vector.length).toEqual(3);
-		expect(flat(vector)).toEqual([10, 52, 4]);
-		
-		vector.deleteIndex(1);
-		expect(vector.length).toEqual(2);
-		expect(flat(vector)).toEqual([10, 4]);
-		
-		vector.deleteIndex(0);
-		expect(vector.length).toEqual(1);
-		expect(flat(vector)).toEqual([4]);
-	});
-
-	it('with dataLength: 3', () => {
-		let vector = new SharedVector(memory, {
-			type: Uint32Array,
-			dataLength: 3
-		});
-
-		vector.push(10);
-		vector.push([52, 32, 6]);
-		vector.push([40, 41, 42]);
-
-		expect(vector.length).toEqual(3);
-		expect(flat(vector)).toEqual([
-			10, 0, 0,
-			52, 32, 6,
-			40, 41, 42
-		]);
-
-		expect([...vector.pop()]).toEqual([40, 41, 42]);
-		expect(vector.length).toEqual(2);
-		expect(flat(vector)).toEqual([
-			10, 0, 0,
-			52, 32, 6
-		]);
-
-		vector.deleteIndex(0);
-		expect(vector.length).toEqual(1);
-		expect(flat(vector)).toEqual([
-			52, 32, 6
-		]);
-	});
-
-	it('can work from memory', () => {
-		let mainVector = new SharedVector(memory, {
-			type: Uint32Array,
-			dataLength: 3
-		});
-		let cloneVector = new SharedVector(memory, mainVector.getSharedMemory());
-
-		mainVector.push(10);
-		mainVector.push([52, 32, 6]);
-		mainVector.push([40, 41, 42]);
-
-		expect(mainVector.length).toEqual(3);
-		expect(flat(mainVector)).toEqual([
-			10, 0, 0,
-			52, 32, 6,
-			40, 41, 42
-		]);
-		expect(cloneVector.length).toEqual(3);
-		expect(flat(cloneVector)).toEqual([
-			10, 0, 0,
-			52, 32, 6,
-			40, 41, 42
-		]);
-
-		// Make sure growing works
-		for(let i = 0; i < 10; i++) {
-			cloneVector.push(i);
-		}
-		for(let i = 0; i < 10; i++) {
-			mainVector.push(i);
-		}
-		expect(mainVector.length).toEqual(23);
-		expect(cloneVector.length).toEqual(23);
-	});
-
-	it('free', () => {
-		let startMemory = memory.currentUsed;
-		let vector = new SharedVector(memory, {
-			type: Uint32Array
-		});
-
-		for(let i = 0; i < 1_000; i++) {
-			vector.push(i);
-		}
-
-		vector.free();
-		expect(memory.currentUsed).toEqual(startMemory);
-	});
-});
-
-function flat(list: SharedVector<any>) {
-	return [...list].reduce((array, value) => {
-		array.push(...value);
-
-		return array;
-	}, []);
-}

package/src/utils/__tests__/pointer.spec.ts

@@ -1,18 +0,0 @@
-import { MAX_BYTE_OFFSET_LENGTH, MAX_POSITION_LENGTH, createPointer, getPointer } from '../pointer';
-
-describe('pointer', () => {
-	it('check all numbers', () => {
-		const SKIP_POSITIONS = 10;
-		const SKIP_BYTE_OFFSETS = 10;
-
-		for(let position = 0; position < MAX_POSITION_LENGTH; position += SKIP_POSITIONS) {
-			for(let byteOffset = 1; byteOffset < MAX_BYTE_OFFSET_LENGTH; byteOffset *= SKIP_BYTE_OFFSETS) {
-				let pointer = createPointer(position, byteOffset);
-
-				let { bufferPosition, bufferByteOffset } = getPointer(pointer);
-				expect(bufferPosition).toEqual(position);
-				expect(bufferByteOffset).toEqual(byteOffset);
-			}
-		}
-	});
-});