@skewedaspect/sage 0.9.5 → 0.9.6

package/dist/managers/entity.d.ts

@@ -90,6 +90,14 @@ export declare class GameEntityManager implements Disposable {
      */
     private _registerEntityActions;
     $frameUpdate(dt: number): void;
+    /**
+     * Deep-clone a definition's defaultState for a new instance.
+     *
+     * A shallow spread would hand every instance of a type the same nested arrays and objects — mutate one
+     * entity's inventory slots and you mutate its neighbor's. Definitions must keep defaultState as plain,
+     * structured-cloneable data.
+     */
+    private _cloneDefaultState;
     /**
      * Honor the `mesh` create option by building the definition's mesh on the current level.
      */

package/dist/managers/level.d.ts

@@ -49,12 +49,22 @@ export declare class LevelManager implements Disposable {
     private _propertyHandlers;
     /** The currently active level */
     private _currentLevel;
+    /** The level currently inside load(), if any */
+    private _loadingLevel;
     /** Unsubscribe functions for event subscriptions */
     private _eventUnsubscribers;
     /**
      * Gets the currently active level
      */
     get currentLevel(): Level | null;
+    /**
+     * Gets the level currently being loaded, if any.
+     *
+     * During a transition, `currentLevel` still points at the outgoing level while the incoming one builds its
+     * scene — anything that needs "the level work is happening in right now" (dynamic entity mesh creation during
+     * spawn processing, for instance) must prefer this over `currentLevel`.
+     */
+    get loadingLevel(): Level | null;
     /**
      * Gets the registered property handlers
      */

package/dist/sage.es.js

@@ -59,7 +59,7 @@ var he = class {
 			configurable: !0
 		});
 	}
-}, k = "0.9.5", A = class {
+}, k = "0.9.6", A = class {
 	canvas;
 	renderEngine;
 	physics;
@@ -1606,18 +1606,25 @@ var Ae = ke(16), G = class {
 		this._log.trace(`Updating ${this.entities.size} entities with dt=${e}`);
 		for (let t of this.entities.values()) t.parent || t.$update(e);
 	}
+	_cloneDefaultState(e) {
+		try {
+			return structuredClone(e.defaultState);
+		} catch (t) {
+			throw Error(`Entity type '${e.type}' has a defaultState that cannot be structured-cloned. defaultState must be plain data (no functions, class instances, or DOM references).`, { cause: t });
+		}
+	}
 	async _buildDefinitionMesh(e, t) {
 		if (!t.mesh) return;
 		if (t.node) {
 			this._log.warn(`Ignoring 'mesh' option for entity ${e.id}: 'node' was supplied, and the two are exclusive.`);
 			return;
 		}
-		let n = this._engine.managers.levelManager.currentLevel;
-		if (!n?.isLoaded) {
+		let { levelManager: n } = this._engine.managers, r = n.loadingLevel ?? n.currentLevel;
+		if (!r?.isLoaded) {
 			this._log.warn(`Cannot build a mesh for entity ${e.id}: no level is loaded.`);
 			return;
 		}
-		await n.createEntityMesh(e, { enabled: t.mesh === "enabled" });
+		await r.createEntityMesh(e, { enabled: t.mesh === "enabled" });
 	}
 	registerEntityDefinition(e) {
 		this._log.debug(`Registering entity definition: ${e.type}`);
@@ -1639,7 +1646,7 @@ var Ae = ke(16), G = class {
 			if (r && r.length > 0) {
 				this._log.trace(`Recycling entity from pool for type: ${e}`);
 				let i = r.pop();
-				if (i.$reset(n.defaultState, n.tags ?? []), i.$setEntityManager(this), t.initialState && (i.state = {
+				if (i.$reset(this._cloneDefaultState(n), n.tags ?? []), i.$setEntityManager(this), t.initialState && (i.state = {
 					...i.state,
 					...t.initialState
 				}), t.tags) for (let e of t.tags) i.$addTag(e);
@@ -1648,7 +1655,7 @@ var Ae = ke(16), G = class {
 		}
 		this._log.trace(`Using entity definition with ${n.behaviors?.length || 0} behaviors`);
 		let r = {
-			...n.defaultState,
+			...this._cloneDefaultState(n),
 			...t.initialState
 		};
 		if (n.onBeforeCreate) {
@@ -1683,7 +1690,7 @@ var Ae = ke(16), G = class {
 			if (n?.poolable) {
 				this._log.trace(`Pooling entity ${e} instead of destroying`);
 				for (let e of [...t.children]) await this.destroyEntity(e.id);
-				t.parent && t.parent.$removeChild(t), this._unindexEntity(t), t.$reset(n.defaultState, n.tags ?? []);
+				t.parent && t.parent.$removeChild(t), this._unindexEntity(t), t.$reset(this._cloneDefaultState(n), n.tags ?? []);
 				let r = this._pools.get(t.type);
 				r || (r = [], this._pools.set(t.type, r)), r.push(t), this.entities.delete(e), this._log.debug(`Entity ${e} pooled`);
 				return;
@@ -2397,10 +2404,14 @@ var ze = class {
 	_loadedLevels = /* @__PURE__ */ new Map();
 	_propertyHandlers = /* @__PURE__ */ new Map();
 	_currentLevel = null;
+	_loadingLevel = null;
 	_eventUnsubscribers = [];
 	get currentLevel() {
 		return this._currentLevel;
 	}
+	get loadingLevel() {
+		return this._loadingLevel;
+	}
 	get propertyHandlers() {
 		return this._propertyHandlers;
 	}
@@ -2474,7 +2485,13 @@ var ze = class {
 		if (n) return this._log.warn(`Level '${t.name}' is already loaded`), n;
 		this._log.debug(`Loading level: ${t.name}`);
 		let r = this._createLevelInstance(t);
-		return await r.load(), this._loadedLevels.set(t.name, r), r;
+		this._loadingLevel = r;
+		try {
+			await r.load();
+		} finally {
+			this._loadingLevel = null;
+		}
+		return this._loadedLevels.set(t.name, r), r;
 	}
 	async activateLevel(e) {
 		let t = await this.loadLevel(e);