feat: world now can lazy init, no longer cleans itself up

packages/core/src/world/world.ts

@@ -28,8 +28,7 @@ import { universe } from '../universe/universe';
 import { allocateWorldId, releaseWorldId } from './utils/world-index';
 
 type Options = {
-	traits?: ConfigurableTrait[];
-	lazy?: boolean;
+	lazy: true;
 };
 
 export class World {
@@ -71,16 +70,19 @@ export class World {
 
 	constructor(polyArg?: Options | ConfigurableTrait, ...traits: ConfigurableTrait[]) {
 		if (polyArg && typeof polyArg === 'object' && !Array.isArray(polyArg)) {
-			const { traits: optionTraits = [], lazy = false } = polyArg as Options;
-			if (!lazy) this.init(...optionTraits);
+			if (traits.length > 0) {
+				throw new Error(
+					'createWorld({ lazy: true }) does not accept trailing traits. Pass traits to world.init(...traits).'
+				);
+			}
 		} else {
 			this.init(...(polyArg ? [polyArg, ...traits] : traits));
 		}
 	}
 
 	init(...traits: ConfigurableTrait[]) {
 		const ctx = this[$internal];
-		if (this.#isInitialized) return;
+		if (this.#isInitialized) return this;
 
 		this.#isInitialized = true;
 		universe.worlds[this.#id] = this;
@@ -102,6 +104,8 @@ export class World {
 
 		// Create world entity.
 		ctx.worldEntity = createEntity(this, IsExcluded, ...traits);
+
+		return this;
 	}
 
 	spawn(...traits: ConfigurableTrait[]): Entity {
@@ -133,6 +137,12 @@ export class World {
 	}
 
 	destroy() {
+		if (!this.#isInitialized) {
+			throw new Error(
+				'Cannot destroy a world that is not initialized. Call world.init() first.'
+			);
+		}
+
 		// Destroy world entity.
 		destroyEntity(this, this[$internal].worldEntity);
 		this[$internal].worldEntity = null!;
@@ -146,6 +156,10 @@ export class World {
 	}
 
 	reset() {
+		if (!this.#isInitialized) {
+			throw new Error('Cannot reset a world that is not initialized. Call world.init() first.');
+		}
+
 		const ctx = this[$internal];
 
 		// Destroy all entities so any cleanup is done.

packages/core/tests/world.test.ts

@@ -17,10 +17,15 @@
 	});
 
 	it('should optionaly init lazily', () => {
+		const Test = trait({ last: 0, delta: 0 });
+
 		const world = createWorld({ lazy: true });
 		expect(world.isInitialized).toBe(false);
-		world.init();
+
+		world.init(Test);
+
 		expect(world.isInitialized).toBe(true);
+		expect(world.get(Test)).toBeDefined();
 	});
 
 	it('should reset the world', () => {
@@ -65,6 +70,24 @@
 		expect(() => world.destroy()).not.toThrow();
 	});
 
+	it('should be able to init after destroy', () => {
+		const world = createWorld({ lazy: true });
+		expect(world.entities.length).toBe(0);
+
+		world.init();
+		expect(world.entities.length).toBe(1);
+
+		world.destroy();
+		expect(world.entities.length).toBe(0);
+
+		world.init();
+		expect(world.isInitialized).toBe(true);
+
+		// Can add entities
+		world.spawn();
+		expect(world.entities.length).toBe(2);
+	});
+
 	it('errors if more than 16 worlds are created', () => {
 		for (let i = 0; i < 16; i++) {
 			createWorld();