@woosh/meep-engine 3.30.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.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":"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"}

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)) {

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"}

package/src/engine/ecs/EntityManager.js

@@ -31,10 +31,13 @@ export const EntityManagerState = {
 };
 
 /**
+ * How long a system is given to finish starting up or shutting down before a deadlock is suspected and
+ * warned about. Nothing is aborted; the warning is the whole of it.
+ *
  * In seconds
  * @type {number}
  */
-const DEFAULT_SYSTEM_STARTUP_TIMEOUT_CHECK = 5;
+const DEFAULT_SYSTEM_LIFECYCLE_TIMEOUT_CHECK = 5;
 
 /**
  * Brings together {@link System}s and an {@link EntityComponentDataset}
@@ -152,6 +155,23 @@ export class EntityManager {
      */
     __fixedStepAccumulator = 0;
 
+    /**
+     * 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 = 1;
+
     /**
      * Currently attached dataset.
      * Do not modify directly, instead use {@link attachDataset} and {@link detachDataset} respectively.
@@ -180,6 +200,13 @@ export class EntityManager {
      */
     #fixed_step_gates = [];
 
+    /**
+     * Per system, in execution order: whether it opened the fixed step being run
+     * ({@link System#openFixedStep} returned normally), so it — and only it — is closed.
+     * @type {Uint8Array}
+     */
+    #fixed_step_opened = new Uint8Array(8);
+
     /**
      * Whenever a system is added or removed, optimal execution plan changes, this flag tells us to rebuild the current plan
      * see {@link #systemsExecutionOrder}
@@ -212,7 +239,8 @@ export class EntityManager {
                 continue;
             }
 
-            if (system.update === noop && system.fixedUpdate === noop) {
+            if (system.update === noop && system.fixedUpdate === noop
+                && system.openFixedStep === noop && system.closeFixedStep === noop) {
                 // not a simulation system
                 continue;
             }
@@ -557,7 +585,19 @@ export class EntityManager {
         // (All fixedUpdates for a step run before any update() — a clean
         // sim-then-render phase split that also keeps every system on the same
         // tick boundary for deterministic rewind/resim.)
-        this.__fixedStepAccumulator += time_delta_seconds;
+        const time_scale = this.fixedStepTimeScale;
+
+        assert.isFinite(time_scale, 'fixedStepTimeScale');
+        assert.greaterThanOrEqual(time_scale, 0, 'fixedStepTimeScale must be >= 0');
+
+        this.__fixedStepAccumulator += time_delta_seconds * time_scale;
+
+        // which systems opened the current step, so only those are closed
+        let opened = this.#fixed_step_opened;
+        if (opened.length < system_count) {
+            opened = new Uint8Array(system_count);
+            this.#fixed_step_opened = opened;
+        }
 
         const t0 = performance.now();
         while (this.__fixedStepAccumulator >= fixed_step) {
@@ -572,6 +612,19 @@ export class EntityManager {
 
             this.fixedStepTick++;
 
+            for (let i = 0; i < system_count; i++) {
+                const system = systems[i];
+                opened[i] = 0;
+                if (system.openFixedStep !== noop) {
+                    try {
+                        system.openFixedStep();
+                        opened[i] = 1;
+                    } catch (e) {
+                        console.error(`Failed during openFixedStep of system '${computeSystemName(system)}': `, e);
+                    }
+                }
+            }
+
             for (let i = 0; i < system_count; i++) {
                 const system = systems[i];
                 if (system.fixedUpdate !== noop) {
@@ -583,6 +636,19 @@ export class EntityManager {
                 }
             }
 
+            // reverse order: the first system to open a step is the last to close it
+            for (let i = system_count - 1; i >= 0; i--) {
+                if (opened[i] === 0) continue;
+                const system = systems[i];
+                if (system.closeFixedStep !== noop) {
+                    try {
+                        system.closeFixedStep();
+                    } catch (e) {
+                        console.error(`Failed during closeFixedStep of system '${computeSystemName(system)}': `, e);
+                    }
+                }
+            }
+
             this.__fixedStepAccumulator -= fixed_step;
 
             // Runaway guard: cap total fixed-step catch-up per simulate so a long
@@ -776,7 +842,26 @@ export class EntityManager {
             assert.notNull(promise, "promise");
             assert.isFunction(promise.then, "promise.then");
 
-            promise.then(systemReady, systemFailed);
+            const shutdown_check_timeout = setTimeout(
+                () => {
+                    console.warn(`System '${computeSystemName(system)}' failed to complete shutdown process in ${DEFAULT_SYSTEM_LIFECYCLE_TIMEOUT_CHECK}s, check your code for potential deadlocks.`);
+                },
+                DEFAULT_SYSTEM_LIFECYCLE_TIMEOUT_CHECK * 1000,
+            );
+
+            // cleared inside the handlers rather than through `promise.finally`, because `finally`
+            // returns a *derived* promise that rejects with the same reason and that nobody is holding —
+            // an unhandled rejection for every system whose shutdown fails, on top of the failure
+            promise.then(
+                () => {
+                    clearTimeout(shutdown_check_timeout);
+                    systemReady();
+                },
+                (reason) => {
+                    clearTimeout(shutdown_check_timeout);
+                    systemFailed(reason);
+                }
+            );
         } catch (e) {
             console.error(`Failed to execute system shutdown`, e);
             errorCallback(e);
@@ -859,16 +944,23 @@ export class EntityManager {
 
             const startup_check_timeout = setTimeout(
                 () => {
-                    console.warn(`System '${computeSystemName(system)}' failed to complete startup process in ${DEFAULT_SYSTEM_STARTUP_TIMEOUT_CHECK}s, check your code for potential deadlocks.`);
+                    console.warn(`System '${computeSystemName(system)}' failed to complete startup process in ${DEFAULT_SYSTEM_LIFECYCLE_TIMEOUT_CHECK}s, check your code for potential deadlocks.`);
                 },
-                DEFAULT_SYSTEM_STARTUP_TIMEOUT_CHECK * 1000,
+                DEFAULT_SYSTEM_LIFECYCLE_TIMEOUT_CHECK * 1000,
             );
 
-            promise.finally(() => {
-                clearTimeout(startup_check_timeout);
-            });
-
-            promise.then(systemReady, errorCallback);
+            // cleared inside the handlers rather than through `promise.finally`; see the note on the
+            // shutdown side of this
+            promise.then(
+                () => {
+                    clearTimeout(startup_check_timeout);
+                    systemReady();
+                },
+                (reason) => {
+                    clearTimeout(startup_check_timeout);
+                    errorCallback(reason);
+                }
+            );
 
         } catch (e) {
             console.error(`Failed to execute system startup`, e);
@@ -1055,13 +1147,9 @@ export class EntityManager {
             }
         }
 
-        function systemReady(system) {
-            //startup all systems
+        function systemReady() {
             readyCount++;
 
-            system.state.set(SystemState.STOPPED);
-
-            self.on.systemStopped.send1(system);
             if (readyCount === expectedReadyCount) {
                 finalizeShutdown();
             }
@@ -1069,45 +1157,32 @@ export class EntityManager {
 
         let firstFailure = true;
 
-        function systemError(system) {
-            console.error("Failed to shutdown system", system);
+        function systemError(system, error) {
+            console.error("Failed to shutdown system", system, 'Error:', error);
 
             if (firstFailure) {
                 firstFailure = false;
 
                 self.state = EntityManagerState.Failed;
 
-                errorCallback();
+                errorCallback(error);
             }
         }
 
         if (expectedReadyCount === 0) {
             //no systems registered, we're done
             finalizeShutdown();
+            return;
         }
 
         for (const system of systems) {
-
-            system.state.set(SystemState.STOPPING);
-
             const cbOK = systemReady.bind(null, system);
             const cbError = systemError.bind(null, system);
 
-            try {
-                const promise = system.shutdown(this);
-
-                assert.defined(promise, 'promise');
-                assert.notNull(promise, 'promise');
-                assert.isFunction(promise.then, 'promise.then');
-
-                // TODO add timeout
-
-                promise.then(cbOK, cbError);
-            } catch (e) {
-                //failure in shutdown function
-                cbError(e);
-            }
-
+            // `stopSystem` owns the STOPPING/STOPPED transitions, the `systemStopped` signal and the
+            // deadlock warning; this loop only counts. Inlining it here is what let the two drift — the
+            // copy dropped the rejection reason on the floor, which the removeSystem path reported
+            this.stopSystem(system, cbOK, cbError);
         }
     }
 }

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

@@ -76,6 +76,13 @@ export class EntityObserver {
     get isConnected(): boolean;
     /**
      * A shortcut for {@link EntityComponentDataset.removeObserver}
+     *
+     * NOTE: `immediate: true`, mirroring {@link connect}. `connect` replays every existing match
+     * through the complete-callback, so disconnecting has to run the broken-callback for each of
+     * them or the pair is asymmetric and whatever those handlers own is never released - and a
+     * reconnect replays every match on top of the stale state. `EntityManager.detachDataset`
+     * already passes `true`; this shortcut omitted it. A caller that genuinely wants a
+     * non-breaking detach can still call `removeObserver` directly.
      */
     disconnect(): void;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"EntityObserver.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityObserver.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;GAOG;AACH;IAoBI;;;;;;;OAOG;IACH,sDALW,CAAC,UAAU,OAAO,KAAK,IAAI,kBAC3B,CAAC,UAAU,OAAO,KAAK,IAAI,iBAgDrC;IAvED;;;OAGG;IACH,eAFU,MAAM,CAEa;IAE7B;;;;OAIG;IACH,uBAFU,MAAM,EAAE,CAES;IAE3B;;;OAGG;IACH,SAFU,sBAAsB,GAAC,IAAI,CAEtB;IA0BX;;OAEG;IACH,oBAFU,MAAM,CAE2B;IAE3C;;;OAGG;IACH,uCAAyC;IAEzC;;;OAGG;IACH,qCAAoC;IAEpC;;;OAGG;IACH,sBAAoC;IAEpC;;;OAGG;IACH,aAAsB;IAG1B;;;OAGG;IACH,qCAqBC;IAED;;;OAGG;IACH,iBAFW,sBAAsB,QAQhC;IAED;;;OAGG;IACH,2BAEC;IAED;;OAEG;IACH,mBAQC;CACJ;qCAhJY,OAAO,6BAA6B,EAAE,sBAAsB;uBAHlD,6BAA6B"}
+{"version":3,"file":"EntityObserver.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityObserver.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;GAOG;AACH;IAoBI;;;;;;;OAOG;IACH,sDALW,CAAC,UAAU,OAAO,KAAK,IAAI,kBAC3B,CAAC,UAAU,OAAO,KAAK,IAAI,iBAgDrC;IAvED;;;OAGG;IACH,eAFU,MAAM,CAEa;IAE7B;;;;OAIG;IACH,uBAFU,MAAM,EAAE,CAES;IAE3B;;;OAGG;IACH,SAFU,sBAAsB,GAAC,IAAI,CAEtB;IA0BX;;OAEG;IACH,oBAFU,MAAM,CAE2B;IAE3C;;;OAGG;IACH,uCAAyC;IAEzC;;;OAGG;IACH,qCAAoC;IAEpC;;;OAGG;IACH,sBAAoC;IAEpC;;;OAGG;IACH,aAAsB;IAG1B;;;OAGG;IACH,qCAqBC;IAED;;;OAGG;IACH,iBAFW,sBAAsB,QAQhC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;;;;;;OASG;IACH,mBAQC;CACJ;qCAvJY,OAAO,6BAA6B,EAAE,sBAAsB;uBAHlD,6BAA6B"}

package/src/engine/ecs/EntityObserver.js

@@ -136,6 +136,13 @@ export class EntityObserver {
 
     /**
      * A shortcut for {@link EntityComponentDataset.removeObserver}
+     *
+     * NOTE: `immediate: true`, mirroring {@link connect}. `connect` replays every existing match
+     * through the complete-callback, so disconnecting has to run the broken-callback for each of
+     * them or the pair is asymmetric and whatever those handlers own is never released - and a
+     * reconnect replays every match on top of the stale state. `EntityManager.detachDataset`
+     * already passes `true`; this shortcut omitted it. A caller that genuinely wants a
+     * non-breaking detach can still call `removeObserver` directly.
      */
     disconnect() {
         if (this.dataset === null) {
@@ -143,7 +150,7 @@ export class EntityObserver {
             return;
         }
         //de-register updates
-        this.dataset.removeObserver(this);
+        this.dataset.removeObserver(this, true);
         this.dataset = null;
     }
 }