@woosh/meep-engine 3.29.0 → 3.31.0

package/src/engine/ecs/Entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Entity.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/Entity.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAicI;;;;;;;;;;;;OAYG;IACH,+BAJW,MAAM,WACN,sBAAsB,GACpB,MAAM,CAmBlB;IA7dD;;;;;OAKG;IACH,oBAFU,eAAe,CAES;IAGlC;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,2BAAgB;IAShB;;;;;;OAMG;IACH,SAJU,sBAAsB,CAIjB;IAEf;;;OAGG;IACH,OAFU,WAAW,GAAC,MAAM,CAEN;IAEtB;;;;OAIG;IACH,yBAAgB;IAEhB;;OAEG;IACH;QACI;;WAEG;;MAEL;IAUF;;;OAGG;IACH,eAFW,MAAM,GAAC,WAAW,QAI5B;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,WAAW,GAChB,OAAO,CAMnB;IAED;;;OAGG;IACH,gBAFW,MAAM,GAAC,WAAW,QAI5B;IAED;;;;;;OAMG;IACH,uBAEC;IAED;;OAEG;IACH,4BAUC;IAED;;;OAGG;IACH,oBAEC;IAED;;;;;;OAMG;IACH,+BAFa,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,+BAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,0CAYC;IAED;;;;;OAKG;IACH,8CAQC;IAED;;;;OAIG;IACH,kCAFa,MAAE,IAAI,CA0BlB;IAED;;;;OAIG;IACH,qBAHW,MAAM,qBAWhB;IAED;;;OAGG;IACH,wBAFW,MAAM,gBAmBhB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,sCAGJ,MAAM,CAgBlB;IAED;;;;;;OAMG;IACH,+BALW,MAAM,sCAGJ,MAAM,CA4BlB;IAED;;;;;;OAMG;IACH,WAJa,OAAO,CA0BnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,eALW,sBAAsB,GADpB,MAAM,CA+DlB;IAmCL;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;;6BA7gBY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;qCAIjD,OAAO,6BAA6B,EAAE,sBAAsB;gCATzC,sBAAsB;4BAD1B,kBAAkB;mBAD3B,oCAAoC"}
+{"version":3,"file":"Entity.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/Entity.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IA2dI;;;;;;;;;;;;OAYG;IACH,+BAJW,MAAM,WACN,sBAAsB,GACpB,MAAM,CA4BlB;IAhgBD;;;;;OAKG;IACH,oBAFU,eAAe,CAES;IAGlC;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,2BAAgB;IAShB;;;;;;OAMG;IACH,SAJU,sBAAsB,CAIjB;IAEf;;;OAGG;IACH,OAFU,WAAW,GAAC,MAAM,CAEN;IAEtB;;;;OAIG;IACH,yBAAgB;IAEhB;;OAEG;IACH;QACI;;WAEG;;MAEL;IAUF;;;OAGG;IACH,eAFW,MAAM,GAAC,WAAW,QAI5B;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,WAAW,GAChB,OAAO,CAMnB;IAED;;;OAGG;IACH,gBAFW,MAAM,GAAC,WAAW,QAI5B;IAED;;;;;;OAMG;IACH,uBAEC;IAED;;OAEG;IACH,4BAUC;IAED;;;OAGG;IACH,oBAEC;IAED;;;;;;OAMG;IACH,+BAFa,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,+BAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,0CAYC;IAED;;;;;OAKG;IACH,8CAQC;IAED;;;;OAIG;IACH,kCAFa,MAAE,IAAI,CAwClB;IAED;;;;OAIG;IACH,qBAHW,MAAM,qBAWhB;IAED;;;OAGG;IACH,wBAFW,MAAM,gBAmBhB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,sCAGJ,MAAM,CAgBlB;IAED;;;;;;OAMG;IACH,+BALW,MAAM,sCAGJ,MAAM,CA4BlB;IAED;;;;;;OAMG;IACH,WAJa,OAAO,CA0BnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,eALW,sBAAsB,GADpB,MAAM,CA2ElB;IA4CL;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;;6BAhjBY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;qCAIjD,OAAO,6BAA6B,EAAE,sBAAsB;gCATzC,sBAAsB;4BAD1B,kBAAkB;mBAF3B,oCAAoC"}

package/src/engine/ecs/Entity.js

@@ -1,5 +1,6 @@
 import { assert } from "../../core/assert.js";
 import Signal from "../../core/events/signal/Signal.js";
+import { computeComponentClassName } from "./computeComponentClassName.js";
 import { EntityFlags } from "./EntityFlags.js";
 import { EntityReference } from "./EntityReference.js";
 import { EventType } from "./EventType.js";
@@ -287,7 +288,21 @@ export class Entity {
                 //see if entity is built
                 if (this.getFlag(EntityFlags.Built)) {
 
-                    this.dataset.removeComponentFromEntity(this.reference.id, klass);
+                    /*
+                     The component's own class, not the one that was asked for. The search above is
+                     `instanceof`, so it matches a SUBCLASS instance, while the dataset resolves a
+                     class by exact identity — and `Team extends ObservedInteger` is a real
+                     component here. Removing an ObservedInteger from an entity carrying a Team
+                     spliced the Team out of this list and then asked the dataset to remove
+                     ObservedInteger, which either throws "Component class not found" or warns and
+                     removes nothing. The wrapper then believed the component was gone while the
+                     dataset still held it, and removeAllComponents would never revisit it.
+
+                     This is what removeAllComponents already does.
+                    */
+                    const ComponentClass = Object.getPrototypeOf(component).constructor;
+
+                    this.dataset.removeComponentFromEntity(this.reference.id, ComponentClass);
 
                 }
 
@@ -484,18 +499,30 @@ export class Entity {
             }
         }
 
-        for (i = 0; i < element_count; i++) {
-            const component = element[i];
-
-            dataset.addComponentToEntity(entity, component);
-        }
-
+        // Built BEFORE the components go in, and the destruction watch with it. Everything above
+        // has already mutated shared state - the dataset holds a live entity, and the deferred
+        // listeners have been spliced out of this wrapper - so if an add throws while the flag is
+        // still clear, `destroy()` short-circuits on it and there is no API left that will reclaim
+        // what was created: the entity leaks with no handle to it, and a retry allocates a second.
         this.setFlag(EntityFlags.Built);
 
         if (this.getFlag(EntityFlags.WatchDestruction)) {
             dataset.addEntityEventListener(entity, EventType.EntityRemoved, this.#handleEntityDestroyed, this);
         }
 
+        try {
+            for (i = 0; i < element_count; i++) {
+                const component = element[i];
+
+                dataset.addComponentToEntity(entity, component);
+            }
+        } catch (e) {
+            // a partially built entity is not a usable one; take it back out before rethrowing
+            this.destroy();
+
+            throw e;
+        }
+
         this.on.built.send2(entity, dataset);
         return entity;
     }
@@ -529,6 +556,15 @@ export class Entity {
 
         r.reference.bind(dataset, entity);
 
+        // The same destruction watch `build` installs. Without it nothing ever cleared the Built
+        // flag, so after the entity was destroyed by anything other than `Entity.destroy()` this
+        // wrapper still reported `isBuilt` - and `add` took the built branch and wrote into
+        // whatever entity had since inherited the id. That is exactly the recycling hazard the
+        // reference generation exists to catch, bypassed because the flag is what gets consulted.
+        if (r.getFlag(EntityFlags.WatchDestruction)) {
+            dataset.addEntityEventListener(entity, EventType.EntityRemoved, r.#handleEntityDestroyed, r);
+        }
+
         return r;
     }
 }

package/src/engine/ecs/EntityBlueprint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityBlueprint.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityBlueprint.js"],"names":[],"mappings":"AAwDA;;;GAGG;AACH;IAOI;;;;OAIG;IACH,iCAFa,eAAe,CAY3B;IA8CD;;;OAGG;IACH,sEAMC;IAtDD;;;OAGG;IACH,0BAIC;IAED,cAEC;IAED;;;;OAIG;IACH,6CAEC;IAED;;;;OAIG;IACH,oDAcC;IAeD;;;OAGG;IACH,qBAHW,MAAM,GACL,MAAM,CAgBjB;;CACJ;mBAhKkB,aAAa"}
+{"version":3,"file":"EntityBlueprint.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityBlueprint.js"],"names":[],"mappings":"AAiEA;;;GAGG;AACH;IAOI;;;;OAIG;IACH,iCAFa,eAAe,CAY3B;IA8CD;;;OAGG;IACH,sEAMC;IAtDD;;;OAGG;IACH,0BAIC;IAED,cAEC;IAED;;;;OAIG;IACH,6CAEC;IAED;;;;OAIG;IACH,oDAcC;IAeD;;;OAGG;IACH,qBAHW,MAAM,GACL,MAAM,CAgBjB;;CACJ;mBAzKkB,aAAa"}

package/src/engine/ecs/EntityBlueprint.js

@@ -1,21 +1,30 @@
 import Entity from "./Entity.js";
 
 /**
+ * Rebuilds `template` as a fresh tree, substituting `$name` strings out of `seed` where one is
+ * given.
+ *
+ * The no-seed path used to return the template BY IDENTITY, and only the seeded path rebuilt. A
+ * blueprint is a factory, so that made every entity built without a seed share one object with
+ * every sibling and with the blueprint itself — any component storing its `fromJSON` argument
+ * rather than copying out of it, which `PropertySet` does — and mutating one entity's properties
+ * wrote through to the others and to everything built afterwards. `templateSeed` is documented
+ * optional, so that is the default shape of the public API.
+ *
+ * A `$name` string with no seed to resolve it against is still left verbatim, as it was.
  *
  * @param {Object} template
  * @param {Object} [seed]
  */
 function populateJsonTemplate(template, seed) {
-    if (seed === undefined) {
-        return template;
-    } else if (template === null) {
+    if (template === null) {
         return template;
     } else {
 
         const templateType = typeof template;
 
         if (templateType === "string") {
-            if (template.startsWith('$')) {
+            if (seed !== undefined && template.startsWith('$')) {
                 const varName = template.slice(1);
 
                 return seed[varName];

package/src/engine/ecs/EntityComponentDataset.d.ts

@@ -1,3 +1,11 @@
+/**
+ * How many handler slots the shared entity-event dispatch stack currently has reserved. Zero whenever
+ * no dispatch is in progress, so a non-zero reading at rest means a dispatch leaked its reservation
+ * and the stack will never be reused below that mark again. Diagnostic only — nothing in the dispatch
+ * path reads it.
+ * @returns {number}
+ */
+export function entity_event_dispatch_stack_depth(): number;
 /**
  * Represents a storage for entities and their associated components.
  * Entities are just integer IDs and components are stored in a virtual table, where each component type has a separate column and each entity is a row in that table.

package/src/engine/ecs/EntityComponentDataset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityComponentDataset.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityComponentDataset.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"EntityComponentDataset.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityComponentDataset.js"],"names":[],"mappings":"AAmqEA;;;;;;GAMG;AACH,qDAFa,MAAM,CAIlB;AAtjED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wDAfyB,MAAM;IAiB3B;;;;OAIG;IACH,wBAA+B;IAE/B;;;;;OAKG;IACH,yBAAsC;IAEtC;;;;;;;;;OASG;IACH,2BAAkC;IAElC;;;;;OAKG;IACH,yBAAsB;IAEtB;;;;OAIG;IACH,4BAAgC;IAEhC;;;;OAIG;IACH,2BAAuB;IAEvB;;;;OAIG;IACH,mBAAgB;IAEhB;;;;OAIG;IACH,oBAAgB;IAEhB;;;;;;;OAOG;IACH,mBAAe;IAEf;;;OAGG;IACH,8BAA+B;IAE/B;;;OAGG;IACH,8BAA+B;IAG/B;;;;OAIG;IACH,+BAA4B;IAE5B;;;;OAIG;IACH,kCAA+B;IAE/B;;;OAGG;IACH,kBAAe;IAGf;;;;;;OAMG;IACH,+BAJW,MAAM,iCAsChB;IAED;;;;;OAKG;IACH,sBAJW,cAAc,cACd,OAAO,GACL,OAAO,CAqDnB;IAED;;;;;OAKG;IACH,yBAJW,cAAc,cACd,OAAO,GACL,OAAO,CA6DnB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,yBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,qBACN,EAAE,SAmCZ;IAED;;;;;;;OAOG;IACH,6BANW,EAAE,iBACF,MAAM,aACN,MAAM,GACJ,MAAM,CAoClB;IAED;;;;;;;OAOG;IACH,4BAJW,MAAM,GACJ,EAAE,CA0Bd;IAED;;;;;OAKG;IACH,yBAJW,KAAK,EAAE,GACL,IAAI,CAmPhB;IAED;;;;OAIG;IACH,mCAHW,KAAK,EAAE,GACL,OAAO,CAenB;IAED;;;;;OAKG;IACH,gCAHW,KAAK,WAAS,GACb,OAAO,CASlB;IAED;;;OAGG;IACH,uBAFa,KAAK,EAAE,CAInB;IAED;;;;OAIG;IACH,kCAHW,KAAK,EAAE,GACL,OAAO,CAgBnB;IAED;;;;OAIG;IACH,4BAHW,KAAK,WAAS,GACZ,OAAO,CAanB;IAED;;;;OAIG;IACH,8BAHW,KAAK,GACH,OAAO,CAkBnB;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACJ,IAAI,CAmBhB;IAED;;;;;OAKG;IACH,+BAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;OAIG;IACH,2BAiBC;IAED;;;OAGG;IACH,gBAFa,MAAM,CAQlB;IAED;;;;;OAKG;IACH,gCAJW,MAAM,GAEJ,IAAI,CAQhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;OAIG;IACH,qCAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,OAAO,CAwCnB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,EAAE,GACN,IAAI,CAQhB;IAED;;;;;OAKG;IACH,qCAJW,MAAM,SACN,KAAK,GACH,IAAI,CAUhB;IAED;;;;;OAKG;IACH,4CAJW,MAAM,mBACN,MAAM,GACJ,IAAI,CAiBhB;IAED;;;;;;;OAOG;IACH,mDAgBC;IAED;;;;OAIG;IACH,iCAHW,WAAS,KAAK,GACZ,MAAM,CAalB;IAED;;;;OAIG;IACH,wCAFa,MAAM,CAUlB;IAED;;;;;;;OAOG;IACH;gBAFqB,MAAM;;MA2B1B;IAED;;;;;;;;OAQG;IACH,mCAJW,MAAM,0BAEJ,IAAI,CAqBhB;IAED;;;;;;;OAOG;IACH,4CALW,MAAM,mBACN,MAAM,4BAEJ,IAAI,CAsChB;IAED;;;;;OAKG;IACH,oCAJW,MAAM,mBACN,MAAM,OAUhB;IAED;;;;;;OAMG;IACH,6BAJW,MAAM,+DAEJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,6BAJW,MAAM,mEAiBhB;IAED;;;;;;;OAOG;IACH,iCALW,MAAM,mEAahB;IAED;;;;;;;OAOG;IACH,sDALW,KAAK,sCAGH,IAAI,CAiBhB;IAED;;;;;;;;;;;;;OAaG;IACH,gEAJ6B,OAAO,YACzB,MAAM,GACJ,IAAI,CAsEhB;IAED;;;;;;;OAOG;IACH,uEAFa,IAAI,CA0DhB;IAkBD;;;;;;;;;;OAUG;IACH,qHAJiC,MAAM,KAAK,IAAI,kBAEnC,IAAI,CAahB;IAED;;;;;;OAMG;IACH,2CALW,MAAM,qCAGJ,IAAI,CAShB;IAED;;;;;;;OAOG;IACH,+CAyBC;IAED;;;;;;OAMG;IACH,iDAsBC;IAED;;;;;OAKG;IACH,wCAgCC;IAED;;;;;OAKG;IACH,0CA2BC;IAED;;;;;;;;;OASG;IACH,kCARW,MAAM,sCAGJ,IAAI,CAuBhB;IAED;;;;;;;;;OASG;IACH,qCARW,MAAM,sCAGJ,OAAO,CAkCnB;IAED;;;;;;;;;;OAUG;IACH,+BATW,MAAM,cACN,MAAM,uCAGJ,IAAI,CAiChB;IAED;;;;;;;;;;OAUG;IACH,kCATW,MAAM,cACN,MAAM,sCAGJ,OAAO,CA2CnB;IAED;;;;;;;OAOG;IACH,kBANW,MAAM,QACN,MAAM,gBAEJ,IAAI,CAmBhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,OAAO,CAenB;IAED;;;;OAIG;IACH,SAHa,IAAI,CAShB;IAED;;;;;OAKG;IACH,YAHa,IAAI,CAgBhB;IAED;;;;OAIG;IACH,yCAHW,MAAM,kEAkBhB;IAED;;;;;OAKG;IACH,mBAHW,sBAAsB,6BACpB,IAAI,CA6DhB;IAED;;;;;OAKG;IACH,qEAHW,CAAC,cAAc,EAAE,MAAM,EAAE,UAAU,OAAO,EAAE,cAAc,EAAE,MAAM,KAAK,IAAI,GACzE,IAAI,CAkEhB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,+BAJW,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,kBAE3B,IAAI,CAgBhB;IAGL;;;;;OAKG;IACH,mCAFU,OAAO,CAEwC;IAIzD;;OAEG;IACH,4BAnoBgB,UAAU,MAAM,CAAC,CAmoBoB;IAErD;;OAEG;IACH,iCArae,MAAM,wCAGJ,OAAO,CAka+B;IA1oBnD;;;OAGG;IACH,qBAFY,UAAU,MAAM,CAAC,CAY5B;CAwmBJ;6BAvlEY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;6BAIjD,OAAO,qBAAqB,EAAE,cAAc"}

package/src/engine/ecs/EntityComponentDataset.js

@@ -8,6 +8,7 @@ import {
 import Signal from "../../core/events/signal/Signal.js";
 import { SignalHandler } from "../../core/events/signal/SignalHandler.js";
 import { max3 } from "../../core/math/max3.js";
+import { number_compare_ascending } from "../../core/primitives/numbers/number_compare_ascending.js";
 
 import { EventType } from "./EventType.js";
 
@@ -717,9 +718,66 @@ export class EntityComponentDataset {
             self.observers = newStore;
         }
 
+        /**
+         * Every registered observer has to survive the new map, and this has to be settled BEFORE
+         * anything is written.
+         *
+         * `EntityObserver.build` throws for a component type that is absent from the map it is
+         * handed, and it used to run from `updateObservers` - after the occupancy bitset and the
+         * component stores had already been rewritten to the new stride. The throw then left
+         * `componentTypeCount` at the old value while every address was computed for the new one,
+         * so `entity_id * componentTypeCount + component_index` read a bit belonging to a different
+         * entity: `hasComponent` answered for the wrong row and `traverseEntities` yielded the
+         * wrong set, for the whole dataset, from a call the API documents as safe-or-throwing.
+         *
+         * `existingComponentsRemovalCheck` guarantees no live *instances* of a removed type; it
+         * says nothing about observers watching one.
+         */
+        function observerCompatibilityCheck() {
+            const incompatible = [];
+
+            const stores = self.observers;
+
+            for (let i = 0; i < stores.length; i++) {
+                const observers = stores[i];
+
+                if (observers === undefined) {
+                    continue;
+                }
+
+                for (let j = 0; j < observers.length; j++) {
+                    const observer = observers[j];
+
+                    if (incompatible.indexOf(observer) !== -1) {
+                        continue;
+                    }
+
+                    for (let k = 0; k < observer.componentTypeCount; k++) {
+                        const type = observer.componentTypes[k];
+
+                        if (map.indexOf(type) === -1) {
+                            incompatible.push(observer);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if (incompatible.length > 0) {
+                const described = incompatible
+                    .map(o => o.componentTypes.map(t => t.typeName ?? t.name).join('+'))
+                    .join(', ');
+
+                throw new Error(`Component types can not be unmapped due to observers watching them: ${described}`);
+            }
+        }
+
         //make sure that no components exist of type scheduled for removal
         existingComponentsRemovalCheck();
 
+        //...and that every observer can still be built against the new map
+        observerCompatibilityCheck();
+
         const indexRemapping = computeComponentIndexRemapping();
 
         updateComponentOccupancy(indexRemapping);
@@ -1201,14 +1259,24 @@ export class EntityComponentDataset {
         //inset component instance into component dataset
         this.components[component_index][entity_id] = component_instance;
 
-        //process observers
-        this.processObservers_ComponentAdded(entity_id, component_index);
-
         //dispatch events
         const componentClass = this.componentTypeMap[component_index];
 
-        //dispatch event to components
-        this.sendEvent(entity_id, EventType.ComponentAdded, { klass: componentClass, instance: component_instance });
+        try {
+            //process observers
+            this.processObservers_ComponentAdded(entity_id, component_index);
+        } finally {
+            // Dispatched even when an observer threw. Observer callbacks are systems' `link`
+            // methods - arbitrary user code - and by the time one runs the component is already
+            // fully present: the bit is set and the instance is written. Letting the throw skip the
+            // event left a `promiseComponent`/`getComponentAsync` waiter pending for ever, neither
+            // resolved nor rejected, over a component that IS there. The exception still
+            // propagates, so the caller is told; the waiters just are not left hanging by it.
+            //
+            // The order is unchanged - observers, then the event - because systems link before
+            // listeners see the component, and that is what consumers are written against.
+            this.sendEvent(entity_id, EventType.ComponentAdded, { klass: componentClass, instance: component_instance });
+        }
     }
 
     /**
@@ -1990,7 +2058,7 @@ export class EntityComponentDataset {
 
         const inputClassCount = component_classes.length;
 
-        const componentIndices = new Array(inputClassCount);
+        const componentIndices = [];
 
         //map component classes to indices
 
@@ -1998,11 +2066,29 @@ export class EntityComponentDataset {
 
         for (i = 0; i < inputClassCount; i++) {
             const klass = component_classes[i];
-            componentIndices[i] = this.computeComponentTypeIndex(klass);
+
+            const index = this.computeComponentTypeIndex(klass);
+
+            if (index === -1) {
+                // Not registered here. The index used to be stored and used unchecked, so
+                // `componentOccupancy.get(entityOccupancyAddress - 1)` read the last component bit
+                // of the PREVIOUS entity, and when that bit was set the next line dereferenced
+                // `this.components[-1]`, which is undefined. "Serialize these types if present" -
+                // the documented use - is exactly the shape that passes a superset.
+                continue;
+            }
+
+            componentIndices.push(index);
         }
 
+        const indexCount = componentIndices.length;
+
         //sort component indices array for faster traversal
-        componentIndices.sort();
+        //
+        //NOTE: with a comparator. A bare `sort()` orders lexicographically, so [2, 10, 9] came out
+        //as [10, 2, 9] - which defeats the point and made the compacted output order depend on the
+        //decimal spelling of an internal index.
+        componentIndices.sort(number_compare_ascending);
 
         const entityOccupancy = this.entityOccupancy;
         const componentOccupancy = this.componentOccupancy;
@@ -2018,7 +2104,7 @@ export class EntityComponentDataset {
 
             componentCount = 0;
 
-            for (j = 0; j < inputClassCount; j++) {
+            for (j = 0; j < indexCount; j++) {
 
                 const componentIndex = componentIndices[j];
                 if (componentOccupancy.get(entityOccupancyAddress + componentIndex)) {
@@ -2123,6 +2209,17 @@ const entityListenersProxy = [];
  */
 let entityListenersProxyPointer = 0;
 
+/**
+ * How many handler slots the shared entity-event dispatch stack currently has reserved. Zero whenever
+ * no dispatch is in progress, so a non-zero reading at rest means a dispatch leaked its reservation
+ * and the stack will never be reused below that mark again. Diagnostic only — nothing in the dispatch
+ * path reads it.
+ * @returns {number}
+ */
+export function entity_event_dispatch_stack_depth() {
+    return entityListenersProxyPointer;
+}
+
 /**
  *
  * @param {Object<SignalHandler[]>} hash
@@ -2159,15 +2256,24 @@ function dispatchEventListenersByHash(hash, entity, name, event) {
     }
 
 
-    //invoke handlers
-    for (let i = 0; i < numListeners; i++) {
-        const handler = entityListenersProxy[i + pointerOffset];
+    /**
+     * `finally`, because the restore is what hands these slots back. A handler that throws unwinds
+     * past a bare restore — through every enclosing dispatch frame too, since `sendEvent` does not
+     * catch — and the pointer then stays at that dispatch's high-water mark for the life of the page,
+     * with `entityListenersProxy` growing above it and holding every handler and `context` it ever
+     * saw. User handlers are exactly the code most likely to throw.
+     */
+    try {
+        //invoke handlers
+        for (let i = 0; i < numListeners; i++) {
+            const handler = entityListenersProxy[i + pointerOffset];
 
-        handler.handle.call(handler.context, event, entity);
+            handler.handle.call(handler.context, event, entity);
+        }
+    } finally {
+        //reset proxy
+        entityListenersProxyPointer = pointerOffset;
     }
-
-    //reset proxy
-    entityListenersProxyPointer = pointerOffset;
 }
 
 /**
@@ -2201,13 +2307,16 @@ function dispatchAnyEventListenersByHash(listeners, entity, name, event) {
     }
 
 
-    //invoke handlers
-    for (let i = 0; i < numListeners; i++) {
-        const handler = entityListenersProxy[i + pointerOffset];
+    //`finally` for the same reason as in dispatchEventListenersByHash above
+    try {
+        //invoke handlers
+        for (let i = 0; i < numListeners; i++) {
+            const handler = entityListenersProxy[i + pointerOffset];
 
-        handler.handle.call(handler.context, name, event, entity);
+            handler.handle.call(handler.context, name, event, entity);
+        }
+    } finally {
+        //reset proxy
+        entityListenersProxyPointer = pointerOffset;
     }
-
-    //reset proxy
-    entityListenersProxyPointer = pointerOffset;
 }

package/src/engine/ecs/EntityManager.d.ts

@@ -113,6 +113,22 @@ export class EntityManager {
      * @type {number}
      */
     private __fixedStepAccumulator;
+    /**
+     * Multiplier on the wall time {@link update} feeds into the fixed-step accumulator — and on
+     * nothing else. Systems still receive {@link fixedUpdateStepSize} in `fixedUpdate`, and the
+     * variable-rate `update` pass still receives the raw delta.
+     *
+     * So this changes how often a fixed step runs, never how long one is: at `1.05` the simulation
+     * advances 5% more steps per wall second, each one the same size, and the interpolation alpha
+     * stays a true fraction of a step. That is what network time dilation needs — a client running a
+     * few percent fast or slow to keep the host's input buffer at depth — and what dropping or
+     * doubling whole steps could not give it: a skipped step reads as a hitch.
+     *
+     * Must be finite and non-negative. `0` freezes the fixed-step simulation (the `update` pass keeps
+     * running).
+     * @type {number}
+     */
+    fixedStepTimeScale: number;
     /**
      * Currently attached dataset.
      * Do not modify directly, instead use {@link attachDataset} and {@link detachDataset} respectively.

package/src/engine/ecs/EntityManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAqBU,MAAM;;;;;;;;;AAiBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,aAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;;;MAGL;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,+BAA2B;IAE3B;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IAuBf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BA2GC;IAED;;;;OAIG;IACH,4BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,QAavD;IAED;;;OAGG;IACH,8BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,GAC3C,OAAO,CAYnB;IAoBD;;;OAGG;IACH,uBAFa,KAAK,EAAE,CAuBnB;IAED;;;;;OAKG;IACH,uBAJW,sBAAsB,QA4ChC;IAGD;;;OAGG;IACH,sBA2BC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAgBC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,cAkBhB;IAGD;;;OAGG;IACH,2BAFW,MAAM,QAuFhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,6CA6DC;IAED;;;;OAIG;IACH,mCAFa,QAAQ,OAAO,CAAC,CA2C5B;IAED;;;;;OAKG;IACH,mBAmCC;IAED;;;;;OAKG;IACH,oBAqFC;IAED;;;;;OAKG;IACH,kEAyEC;IAED;;;;OAIG;IACH,2BAHW,KAAK,GACH,oBAAgB,CA0B5B;IAED;;;;OAIG;IACH,kCAJW,KAAK,SACL,WAAW,GACT,oBAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAoFC;IAGL;;OAEG;IACH,yBA9tBe,sBAAsB,UA8tBA;IACrC;;OAEG;IACH,0BAAqC;IAErC;;OAEG;IACH,+BA7lBe,MAAM,UA6lBW;;CAd/B;6BAxkCY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;uBAN1B,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B;4BAEhC,aAAa"}
+{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAqBU,MAAM;;;;;;;;;AAoBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,aAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;;;MAGL;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,+BAA2B;IAE3B;;;;;;;;;;;;;;OAcG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IA8Bf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BA4GC;IAED;;;;OAIG;IACH,4BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,QAavD;IAED;;;OAGG;IACH,8BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,GAC3C,OAAO,CAYnB;IAoBD;;;OAGG;IACH,uBAFa,KAAK,EAAE,CAuBnB;IAED;;;;;OAKG;IACH,uBAJW,sBAAsB,QA4ChC;IAGD;;;OAGG;IACH,sBA2BC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAgBC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,cAkBhB;IAGD;;;OAGG;IACH,2BAFW,MAAM,QA6HhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,6CA6DC;IAED;;;;OAIG;IACH,mCAFa,QAAQ,OAAO,CAAC,CA2C5B;IAED;;;;;OAKG;IACH,mBAsDC;IAED;;;;;OAKG;IACH,oBA4FC;IAED;;;;;OAKG;IACH,kEAyEC;IAED;;;;OAIG;IACH,2BAHW,KAAK,GACH,oBAAgB,CA0B5B;IAED;;;;OAIG;IACH,kCAJW,KAAK,SACL,WAAW,GACT,oBAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAmEC;IAGL;;OAEG;IACH,yBA7wBe,sBAAsB,UA6wBA;IACrC;;OAEG;IACH,0BAAqC;IAErC;;OAEG;IACH,+BA5oBe,MAAM,UA4oBW;;CAd/B;6BAnpCY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;uBAN1B,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B;4BAEhC,aAAa"}