@woosh/meep-engine 3.29.0 → 3.31.0

package/src/engine/ecs/guid/UUID.js

@@ -2,26 +2,63 @@ import { assert } from "../../../core/assert.js";
 import { dec2hex } from "../../../core/binary/dec2hex.js";
 import { hex2dec } from "../../../core/binary/hex2dec.js";
 import { array_copy } from "../../../core/collection/array/array_copy.js";
-import { randomBytes } from "../../../core/math/random/randomBytes.js";
-import { randomUint8 } from "../../../core/math/random/randomUint8.js";
-import { seededRandom } from "../../../core/math/random/seededRandom.js";
 
 // Previous uuid creation time
 let _last_milliseconds = 0;
 let _last_nanoseconds = 0;
 
-// seed random with current time to lower potential correlation
-const random = seededRandom(Date.now());
+/**
+ * Bytes drawn ahead from `crypto.getRandomValues`, and how many of them are still unread.
+ *
+ * These identifiers are not allowed to be a function of the clock. `NetworkSession` mints a
+ * {@link UUID.v1} as a peer's reconnect credential and authenticates a reconnect by comparing against
+ * it, and a v1 carries no entropy beyond the node id and the clock sequence below — so seeding those
+ * from `Date.now()`, as this module used to, reduced that credential to "which millisecond did the
+ * host load". `UUID.string()` also backs element ids, `DynamicRuleDescription.id` and `Tile.uuid`,
+ * which two clients loading in the same millisecond would then collide on outright.
+ *
+ * Drawn a block at a time rather than 16 bytes per call: `getRandomValues` is a per-call cost, and
+ * these are minted in loops. The pool holds no more than one block, so nothing accumulates.
+ * @type {Uint8Array}
+ */
+const _entropy_pool = new Uint8Array(1024);
+
+/**
+ * @type {number} read cursor into {@link _entropy_pool}; `length` means exhausted
+ */
+let _entropy_pool_position = _entropy_pool.length;
+
+/**
+ * Fill `count` bytes of `destination` from `offset` with cryptographically strong randomness.
+ * @param {Uint8Array} destination
+ * @param {number} offset
+ * @param {number} count
+ */
+function fill_random_bytes(destination, offset, count) {
+    for (let i = 0; i < count; i++) {
+        if (_entropy_pool_position >= _entropy_pool.length) {
+            crypto.getRandomValues(_entropy_pool);
+            _entropy_pool_position = 0;
+        }
+
+        destination[offset + i] = _entropy_pool[_entropy_pool_position];
+
+        _entropy_pool_position++;
+    }
+}
 
 // node and clockseq need to be initialized to random values.
 const _node_id = new Uint8Array(6);
 
 // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
-randomBytes(_node_id, 0, random, 6);
+fill_random_bytes(_node_id, 0, 6);
 _node_id[0] |= 0x01;
 
 // Per 4.2.2, randomize (14 bit) clockseq
-let _clock_seq = ((randomUint8(random) << 8) | randomUint8(random)) & 0x3fff;
+const _clock_seq_bytes = new Uint8Array(2);
+fill_random_bytes(_clock_seq_bytes, 0, 2);
+
+let _clock_seq = ((_clock_seq_bytes[0] << 8) | _clock_seq_bytes[1]) & 0x3fff;
 
 /**
  * Universally Unique Identifier (UUID), a 128 bit label used to uniquely identify resources.
@@ -187,16 +224,7 @@ export class UUID {
 
         const data = this.data;
 
-        for (let i = 0; i < 16; i += 4) {
-
-            const r = (random() * 4294967296) >>> 0;
-
-            data[i] = r & 0xff;
-            data[i + 1] = (r >>> 8) & 0xff;
-            data[i + 2] = (r >>> 16) & 0xff;
-            data[i + 3] = (r >>> 24) & 0xff;
-
-        }
+        fill_random_bytes(data, 0, 16);
 
         // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
         data[6] = (data[6] & 0x0f) | 0x40;

package/src/engine/ecs/ik/OneBoneSurfaceAlignmentSolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OneBoneSurfaceAlignmentSolver.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/OneBoneSurfaceAlignmentSolver.js"],"names":[],"mappings":"AA4CA;;GAEG;AACH;IACI,0BAqGC;CACJ;yBA7IwB,eAAe"}
+{"version":3,"file":"OneBoneSurfaceAlignmentSolver.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/OneBoneSurfaceAlignmentSolver.js"],"names":[],"mappings":"AA4CA;;GAEG;AACH;IACI,0BAuGC;CACJ;yBA/IwB,eAAe"}

package/src/engine/ecs/ik/OneBoneSurfaceAlignmentSolver.js

@@ -144,7 +144,9 @@ export class OneBoneSurfaceAlignmentSolver extends IKSolver {
             }
         }
 
-        r.lerp(target, constraint.strength * influence);
+        //slerp, not lerp: see ClingToTerrainSystem.alignToVector. A componentwise blend is not a
+        //unit quaternion, and `ik_write_local_rotation` writes it straight into the Transform64.
+        r.slerp(target, constraint.strength * influence);
 
         ik_write_local_rotation(dataset, bone, r);
     }

package/src/engine/ecs/parent/EntityNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityNode.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/parent/EntityNode.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IAyLI;;;;OAIG;IACH,2CAFY,UAAU,CAYrB;IAvKD;;;OAGG;IACH,qBAFW,MAAM,EAWhB;IA7CD;;;;OAIG;IACH,iBAAgB;IAEhB;;;;OAIG;IACH,mBAAgB;IAEhB;;;;OAIG;IACH,oBAAgC;IAEhC;;;MAGE;IAEF;;;OAGG;IACH,OAFU,MAAM,CAEM;IAQlB;;;;OAIG;IACH,iBAAsB;IAI1B;;;;OAIG;IACH,cAHW,MAAM,GAAC,eAAe,GACpB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,eAAe,GACpB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,eAAe,SACtB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,eAAe,GACpB,OAAO,CAInB;IAED;;;;OAIG;IACH,kBAHW,CAAC,IAAI,EAAE,UAAU,QAAM,uBAcjC;IAED;;;;OAIG;IACH,0BAHW,CAAC,IAAI,EAAE,UAAU,QAAM,uBAKjC;IAED;;;OAGG;IACH,sCAEC;IAED;;;;;;;;OAQG;IACH,8BA4BC;IAED;;;;;;;;;;;;;OAaG;IACH,qBAFa,IAAI,CAShB;IAmBD;;;;OAIG;IACH,8BAaC;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,uBAMC;IAUD;;;OAGG;IACH,6BAyCC;IArDD;;;OAGG;IACH,yBAEC;IAiDD;;;OAGG;IACH,qBAEC;IAED;;;;OAIG;IACH,eAHW,UAAU,GACR,OAAO,CAuBnB;IAED;;;;OAIG;IACH,kBAHW,UAAU,GACR,OAAO,CAenB;IAED,uBAEC;IAED;;;OAGG;IACH,yCA+CC;IAGD,gBAoBC;IAGL;;;OAGG;IACH,uBAFU,OAAO,CAEgB;CANhC;mBA9bkB,uCAAuC;gCAI1B,sBAAsB;4BAD1B,6BAA6B;mBAFtC,cAAc"}
+{"version":3,"file":"EntityNode.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/parent/EntityNode.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IAyLI;;;;OAIG;IACH,2CAFY,UAAU,CAYrB;IAvKD;;;OAGG;IACH,qBAFW,MAAM,EAWhB;IA7CD;;;;OAIG;IACH,iBAAgB;IAEhB;;;;OAIG;IACH,mBAAgB;IAEhB;;;;OAIG;IACH,oBAAgC;IAEhC;;;MAGE;IAEF;;;OAGG;IACH,OAFU,MAAM,CAEM;IAQlB;;;;OAIG;IACH,iBAAsB;IAI1B;;;;OAIG;IACH,cAHW,MAAM,GAAC,eAAe,GACpB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,eAAe,GACpB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,eAAe,SACtB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,eAAe,GACpB,OAAO,CAInB;IAED;;;;OAIG;IACH,kBAHW,CAAC,IAAI,EAAE,UAAU,QAAM,uBAcjC;IAED;;;;OAIG;IACH,0BAHW,CAAC,IAAI,EAAE,UAAU,QAAM,uBAKjC;IAED;;;OAGG;IACH,sCAEC;IAED;;;;;;;;OAQG;IACH,8BA4BC;IAED;;;;;;;;;;;;;OAaG;IACH,qBAFa,IAAI,CAShB;IAmBD;;;;OAIG;IACH,8BAaC;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,uBAMC;IAUD;;;OAGG;IACH,6BAiDC;IA7DD;;;OAGG;IACH,yBAEC;IAyDD;;;OAGG;IACH,qBAEC;IAED;;;;OAIG;IACH,eAHW,UAAU,GACR,OAAO,CAuBnB;IAED;;;;OAIG;IACH,kBAHW,UAAU,GACR,OAAO,CAenB;IAED,uBAEC;IAED;;;OAGG;IACH,yCA+CC;IAGD,gBAoBC;IAGL;;;OAGG;IACH,uBAFU,OAAO,CAEgB;CANhC;mBAtckB,uCAAuC;gCAI1B,sBAAsB;4BAD1B,6BAA6B;mBAFtC,cAAc"}

package/src/engine/ecs/parent/EntityNode.js

@@ -304,8 +304,16 @@ export class EntityNode {
 
 
             // handle component TransformAttachment
+            //
+            // `attachment` is what `removeComponent` returned, so it is non-null exactly when the
+            // node HAD one. The guard used to be `=== null`, which is the inverse: an existing
+            // attachment was removed from the dataset and never put back, and the line below then
+            // wrote `parent` onto a detached instance. The node kept lifetime parentage with no
+            // transform attachment, so it rendered at its raw Transform64 in world space.
             if (attachment === null) {
                 attachment = this.__safe_get_attachment();
+            } else {
+                this_entity.add(attachment);
             }
 
             attachment.parent = parent_entity_id;

package/src/engine/ecs/speaker/VoiceSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VoiceSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/speaker/VoiceSystem.js"],"names":[],"mappings":"AAiKA;IA2CI;;;;OAIG;IACH;;;OA8CC;IA7FD,+BAAuB;IACvB,gZAQE;IAEF;;;OAGG;IACH,0BAAmB;IAEnB;;;OAGG;IACH,eAAW;IAEX;;;OAGG;IACH,4BAAa;IAEb;;;OAGG;IACH,8BAAY;IAEZ;;;;OAIG;IACH,iCAAqC;IAajC;;;OAGG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,kBAAkC;IAGlC;;;;OAIG;IACH,eAAkB;IAElB;;;;OAIG;IACH,oBAAgC;IAEhC;;;OAGG;IACH,oBAAqC;IAErC;;;;OAIG;IACH,gBAAoB;IAGxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAEF,2CAqBE;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,SACN,KAAK,QAsBf;IAED;;;;;;OAMG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,WACN,MAAM,SACN,KAAK,QAiIf;CACJ;sCAncqC,oCAAoC;sBAKpD,YAAY;4BAFN,6BAA6B;4CAxBb,oDAAoD;uBAkBzE,sBAAsB;6BAEhB,qCAAqC;2BADvC,8BAA8B;oCAIrB,gDAAgD;sCAR9C,wCAAwC;kCAP5C,sDAAsD"}
+{"version":3,"file":"VoiceSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/speaker/VoiceSystem.js"],"names":[],"mappings":"AA0KA;IA2CI;;;;OAIG;IACH;;;OA8CC;IA7FD,+BAAuB;IACvB,gZAQE;IAEF;;;OAGG;IACH,0BAAmB;IAEnB;;;OAGG;IACH,eAAW;IAEX;;;OAGG;IACH,4BAAa;IAEb;;;OAGG;IACH,8BAAY;IAEZ;;;;OAIG;IACH,iCAAqC;IAajC;;;OAGG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,kBAAkC;IAGlC;;;;OAIG;IACH,eAAkB;IAElB;;;;OAIG;IACH,oBAAgC;IAEhC;;;OAGG;IACH,oBAAqC;IAErC;;;;OAIG;IACH,gBAAoB;IAGxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAEF,2CAqBE;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,SACN,KAAK,QAsBf;IAED;;;;;;OAMG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,WACN,MAAM,SACN,KAAK,QAiIf;CACJ;sCA5cqC,oCAAoC;sBAKpD,YAAY;4BAFN,6BAA6B;4CAxBb,oDAAoD;uBAkBzE,sBAAsB;6BAEhB,qCAAqC;2BADvC,8BAA8B;oCAIrB,gDAAgD;sCAR9C,wCAAwC;kCAP5C,sDAAsD"}

package/src/engine/ecs/speaker/VoiceSystem.js

@@ -112,6 +112,15 @@ class Context extends SystemEntityContext {
      */
     active_executor = null;
 
+    reset() {
+        super.reset();
+
+        // the context is pooled: anything set outside link() survives into the next entity that
+        // draws this object unless it is cleared here
+        this.active_line = null;
+        this.active_executor = null;
+    }
+
     handleSpeakLineEvent({ id }) {
         this.system.sayLine(this.entity, id, this.components[0]);
     }

package/src/engine/ecs/storage/binary/BinaryClassSerializationAdapter.d.ts

@@ -5,6 +5,9 @@
 /**
  * @typedef {import("../../../../core/binary/BinaryBuffer.js").BinaryBuffer} BinaryBuffer
  */
+/**
+ * @typedef {import("../../EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
+ */
 /**
  * Defines how to serialize and deserialize an instance of a given class.
  * This class is intended to be overridden.
@@ -68,6 +71,17 @@ export class BinaryClassSerializationAdapter<T> {
      *
      */
     finalize(): void;
+    /**
+     * Tell `dataset` that {@link deserialize} has just written `entity`'s component in place.
+     *
+     * Called by code that deserializes into a live component — the network applying replicated
+     * state — once the write is done. A component that raises its own signals when it changes needs
+     * nothing here; one that does not says here how a write to it is made visible to what follows it.
+     *
+     * @param {EntityComponentDataset} dataset
+     * @param {number} entity
+     */
+    announce(dataset: EntityComponentDataset, entity: number): void;
     /**
      * Serialize an instance into the passed buffer.
      * Will write at the current {@link BinaryBuffer.position}.
@@ -92,4 +106,5 @@ export class BinaryClassSerializationAdapter<T> {
 }
 export type Class<T = any> = import("../../../../core/primitives/Class.js").Class<T>;
 export type BinaryBuffer = import("../../../../core/binary/BinaryBuffer.js").BinaryBuffer;
+export type EntityComponentDataset = import("../../EntityComponentDataset.js").EntityComponentDataset;
 //# sourceMappingURL=BinaryClassSerializationAdapter.d.ts.map

package/src/engine/ecs/storage/binary/BinaryClassSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryClassSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/storage/binary/BinaryClassSerializationAdapter.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAEI;;;;;;;OAOG;IACH,iBAFU,MAAM,CAAC,CAAC,CAEL;IAEb;;;;;;OAMG;IACH,mBAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,iCAEC;IAED;;;;;OAKG;IACH,iBAEC;IAED;;;;;;OAMG;IACH,kBAHW,YAAY,SACZ,CAAC,QAIX;IAED;;;;;;OAMG;IACH,oBAHW,YAAY,SACZ,CAAC,QAIX;IAGL;;;OAGG;IACH,4CAFU,OAAO,CAE0D;CAN1E;6BApGY,OAAO,sCAAsC,EAAE,KAAK,CAAC,CAAC,CAAC;2BAIvD,OAAO,yCAAyC,EAAE,YAAY"}
+{"version":3,"file":"BinaryClassSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/storage/binary/BinaryClassSerializationAdapter.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAEI;;;;;;;OAOG;IACH,iBAFU,MAAM,CAAC,CAAC,CAEL;IAEb;;;;;;OAMG;IACH,mBAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,iCAEC;IAED;;;;;OAKG;IACH,iBAEC;IAED;;;;;;;;;OASG;IACH,kBAHW,sBAAsB,UACtB,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,kBAHW,YAAY,SACZ,CAAC,QAIX;IAED;;;;;;OAMG;IACH,oBAHW,YAAY,SACZ,CAAC,QAIX;IAGL;;;OAGG;IACH,4CAFU,OAAO,CAE0D;CAN1E;6BAtHY,OAAO,sCAAsC,EAAE,KAAK,CAAC,CAAC,CAAC;2BAIvD,OAAO,yCAAyC,EAAE,YAAY;qCAI9D,OAAO,iCAAiC,EAAE,sBAAsB"}

package/src/engine/ecs/storage/binary/BinaryClassSerializationAdapter.js

@@ -7,6 +7,10 @@
  * @typedef {import("../../../../core/binary/BinaryBuffer.js").BinaryBuffer} BinaryBuffer
  */
 
+/**
+ * @typedef {import("../../EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
+ */
+
 /**
  * Defines how to serialize and deserialize an instance of a given class.
  * This class is intended to be overridden.
@@ -79,6 +83,20 @@ export class BinaryClassSerializationAdapter {
         //override as need
     }
 
+    /**
+     * Tell `dataset` that {@link deserialize} has just written `entity`'s component in place.
+     *
+     * Called by code that deserializes into a live component — the network applying replicated
+     * state — once the write is done. A component that raises its own signals when it changes needs
+     * nothing here; one that does not says here how a write to it is made visible to what follows it.
+     *
+     * @param {EntityComponentDataset} dataset
+     * @param {number} entity
+     */
+    announce(dataset, entity) {
+        //override as needed
+    }
+
     /**
      * Serialize an instance into the passed buffer.
      * Will write at the current {@link BinaryBuffer.position}.

package/src/engine/ecs/system/AbstractContextSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractContextSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/system/AbstractContextSystem.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IAeI;;;OAGG;IACH,sDA8BC;IAhDD;;;;OAIG;IACH,wBAAqB;IAErB;;;;OAIG;IACH,gDAA+C;IAa3C;;;;OAIG;IACH,uBAAkC;IAElC;;;;OAIG;IACH,uBAUC;IAGL;;;;;OAKG;IACH,2CAHY,CAAC,GAAC,SAAS,CAOtB;IAED,2BAwBC;IAED,6BAoBC;CACJ;uBAtHsB,cAAc"}
+{"version":3,"file":"AbstractContextSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/system/AbstractContextSystem.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IAeI;;;OAGG;IACH,sDAoCC;IAtDD;;;;OAIG;IACH,wBAAqB;IAErB;;;;OAIG;IACH,gDAA+C;IAa3C;;;;OAIG;IACH,uBAAkC;IAElC;;;;OAIG;IACH,uBAgBC;IAGL;;;;;OAKG;IACH,2CAHY,CAAC,GAAC,SAAS,CAOtB;IAED,2BA4BC;IAED,6BAoBC;CACJ;uBAhIsB,cAAc"}

package/src/engine/ecs/system/AbstractContextSystem.js

@@ -49,10 +49,16 @@ export class AbstractContextSystem extends System {
                 return new ContextClass();
             },
             (ctx) => {
-                // TODO
+                // destroyer: a context owns nothing beyond what `reset` clears, and the pool only
+                // calls this when it is shrinking
+                ctx.reset();
             },
             (ctx) => {
-                //ctx.unlink();
+                // Resetter, run on every `create()`. This used to be a commented-out `ctx.unlink()`,
+                // so a recycled context arrived with every field its subclass had added still
+                // holding the previous entity's values - `link()` only overwrites `entity`,
+                // `system` and the components.
+                ctx.reset();
             }
         );
     }
@@ -90,9 +96,13 @@ export class AbstractContextSystem extends System {
             ctx.components[i] = arguments[i];
         }
 
-        ctx.link();
-
+        // Recorded BEFORE `link()`, which is subclass code and can throw - ParentEntitySystem's
+        // does, for a ParentEntity naming a removed parent. With the record written afterwards the
+        // context was simply lost: the later `unlink` printed "No context found for entity" and
+        // returned, so whatever `link` had already done was never undone.
         this.__live_contexts[entity] = ctx;
+
+        ctx.link();
     }
 
     unlink() {

package/src/engine/ecs/system/SystemEntityContext.d.ts

@@ -27,5 +27,17 @@ export class SystemEntityContext {
     getDataset(): EntityComponentDataset;
     link(): void;
     unlink(): void;
+    /**
+     * Return the context to the state a freshly constructed one is in, so a pooled instance does
+     * not arrive carrying the previous entity's values.
+     *
+     * `AbstractContextSystem` recycles these through an `ObjectPoolFactory` whose resetter was a
+     * commented-out `unlink()`; `link()` only overwrites `entity`, `system` and the components it
+     * was handed, so anything a subclass assigns outside `link` survived into whichever entity
+     * drew the same object next.
+     *
+     * A subclass with fields of its own overrides this, clears them, and calls `super.reset()`.
+     */
+    reset(): void;
 }
 //# sourceMappingURL=SystemEntityContext.d.ts.map

package/src/engine/ecs/system/SystemEntityContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SystemEntityContext.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/system/SystemEntityContext.js"],"names":[],"mappings":"AAAA;IAEI;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,eAAc;IAEd;;;OAGG;IACH,YAFU,KAAG,CAEG;IAEhB;;;;OAIG;IACH,uBAHU,OAAO,CAGG;IAEpB;;;OAGG;IACH,qCAEC;IAED,aAMC;IAED,eAOC;CACJ"}
+{"version":3,"file":"SystemEntityContext.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/system/SystemEntityContext.js"],"names":[],"mappings":"AAAA;IAEI;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,eAAc;IAEd;;;OAGG;IACH,YAFU,KAAG,CAEG;IAEhB;;;;OAIG;IACH,uBAHU,OAAO,CAGG;IAEpB;;;OAGG;IACH,qCAEC;IAED,aAMC;IAED,eAOC;IAED;;;;;;;;;;OAUG;IACH,cAUC;CACJ"}

package/src/engine/ecs/system/SystemEntityContext.js

@@ -49,4 +49,27 @@ export class SystemEntityContext {
 
         this.__is_linked = false;
     }
+
+    /**
+     * Return the context to the state a freshly constructed one is in, so a pooled instance does
+     * not arrive carrying the previous entity's values.
+     *
+     * `AbstractContextSystem` recycles these through an `ObjectPoolFactory` whose resetter was a
+     * commented-out `unlink()`; `link()` only overwrites `entity`, `system` and the components it
+     * was handed, so anything a subclass assigns outside `link` survived into whichever entity
+     * drew the same object next.
+     *
+     * A subclass with fields of its own overrides this, clears them, and calls `super.reset()`.
+     */
+    reset() {
+        // NOTE: does NOT call `unlink()`. The pool only ever holds contexts that were unlinked
+        // before release, and calling it again would run the subclass's teardown a second time
+        // against a stale entity id.
+        this.__is_linked = false;
+
+        this.entity = -1;
+        this.system = null;
+
+        this.components.length = 0;
+    }
 }

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

@@ -1 +1 @@
-{"version":3,"file":"system_validate_class.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/system_validate_class.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,iEAiGC;uBAxGsB,aAAa"}
+{"version":3,"file":"system_validate_class.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/system_validate_class.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,iEAqGC;uBA5GsB,aAAa"}

package/src/engine/ecs/system_validate_class.js

@@ -45,8 +45,12 @@ export function system_validate_class(system) {
             throw new Error('No access modifiers specified, must have at least one (such as Read, Write, Create)');
         }
 
-        // backtrace to make sure there are no duplicates
-        for (let j = 0; j < i - 1; j++) {
+        // Backtrace to make sure there are no duplicates. `j < i`, not `j < i - 1`: the old bound
+        // never compared against the immediately preceding element, and ran zero iterations at
+        // i === 1, so any duplicate that happened to sit adjacent in the array went unreported.
+        // `[Read(T), Write(T)]` passed, and `getAccessForComponent` breaks on the first match, so
+        // the writer was scheduled as a reader. The dependency loop below already uses `j = i + 1`.
+        for (let j = 0; j < i; j++) {
             const spec_other = components_used[j];
 
             if (spec_other.resource === spec.resource) {

package/src/engine/ecs/terrain/ecs/cling/ClingToTerrainSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClingToTerrainSystem.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/cling/ClingToTerrainSystem.js"],"names":[],"mappings":"AA8MA;;;;;;;GAOG;AACH,wCANW,UAAU,aACV,OAAO,gBACP,MAAM,yCAsChB;;uBArPsB,wCAAwC;oBAE3C,qCAAqC;AAyCzD;;IAGI,6DAA6C;IAG7C,mHAGE;IAEF;;;OAGG;IACH,aAFU,MAAM,MAAM,CAAC,CAEG;IAE1B,YAAU;IAEV;;;OAGG;IACH,kBAFU,MAAM,CAEwB;IAExC;;;OAGG;IACH,sBAFW,MAAM,QAOhB;IAED;;;;;OAKG;IACH,YAHW,cAAc,aADd,WAAW,YAEX,MAAM,QAyBhB;IAED;;;;;OAKG;IACH,cAHW,cAAc,aADd,WAAW,YAEX,MAAM,QAgBhB;IAED,6BAiDC;CACJ;uBA9KsB,oBAAoB;4BACf,mCAAmC;2BAIpC,qBAAqB;4CANJ,0DAA0D;oBAIlF,eAAe;sBAbb,+CAA+C"}
+{"version":3,"file":"ClingToTerrainSystem.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/cling/ClingToTerrainSystem.js"],"names":[],"mappings":"AA8MA;;;;;;;GAOG;AACH,wCANW,UAAU,aACV,OAAO,gBACP,MAAM,yCA4ChB;;uBA3PsB,wCAAwC;oBAE3C,qCAAqC;AAyCzD;;IAGI,6DAA6C;IAG7C,mHAGE;IAEF;;;OAGG;IACH,aAFU,MAAM,MAAM,CAAC,CAEG;IAE1B,YAAU;IAEV;;;OAGG;IACH,kBAFU,MAAM,CAEwB;IAExC;;;OAGG;IACH,sBAFW,MAAM,QAOhB;IAED;;;;;OAKG;IACH,YAHW,cAAc,aADd,WAAW,YAEX,MAAM,QAyBhB;IAED;;;;;OAKG;IACH,cAHW,cAAc,aADd,WAAW,YAEX,MAAM,QAgBhB;IAED,6BAiDC;CACJ;uBA9KsB,oBAAoB;4BACf,mCAAmC;2BAIpC,qBAAqB;4CANJ,0DAA0D;oBAIlF,eAAe;sBAbb,+CAA+C"}