@woosh/meep-engine 2.104.0 → 2.105.0

package/build/meep.module.js

@@ -60003,28 +60003,6 @@ const RESERVED_HASH_SUBSTITUTE = 0;
 const UNDEFINED_BIN_INDEX = ~0;
 
 
-/**
- * @template K,V
- * @param {HashMapEntry<K,V>} record
- * @param {number} hash
- * @param {K} key
- * @param {function(a:K,b:K):boolean} equality_op
- */
-function entry_equality_check(record, hash, key, equality_op) {
-    if (record.hash !== hash) {
-        return false;
-    }
-
-    if (record.key === key) {
-        return true;
-    }
-
-    const result = equality_op(record.key, key);
-
-    return result;
-}
-
-
 const EMPTY_BINS = new Uint32Array(0);
 
 /**
@@ -60092,6 +60070,10 @@ class HashMap {
      */
     #load_factor = DEFAULT_LOAD_FACTOR;
 
+    /**
+     * Used to track modifications to prevent concurrent changes during iteration
+     * @type {number}
+     */
     #version = 0;
 
     /**
@@ -60204,6 +60186,25 @@ class HashMap {
         return original === RESERVED_HASH ? RESERVED_HASH_SUBSTITUTE : original;
     }
 
+    /**
+     * @param {HashMapEntry<K,V>} record
+     * @param {number} hash
+     * @param {K} key
+     */
+    #entry_equality_check(record, hash, key) {
+        if (record.hash !== hash) {
+            return false;
+        }
+
+        if (record.key === key) {
+            return true;
+        }
+
+        const result = this.keyEqualityFunction(record.key, key);
+
+        return result;
+    }
+
     /**
      *
      * @param {K} k
@@ -60279,11 +60280,12 @@ class HashMap {
                 // check if it's the entry that we're looking for
                 const entry = this.#entries[bin - ENTRY_BASE];
 
-                if (entry_equality_check(entry, raw_hash, key, this.keyEqualityFunction)) {
+                if (this.#entry_equality_check(entry, raw_hash, key)) {
                     // found the right entry
                     entry.value = value;
                     return;
                 }
+
             } else if (bin === BIN_RESERVED_VALUE_EMPTY) {
                 // bin is empty
 
@@ -60342,7 +60344,7 @@ class HashMap {
                 // check if the entry is what we're looking for
                 const entry = this.#entries[bin - ENTRY_BASE];
 
-                if (entry_equality_check(entry, raw_hash, key, this.keyEqualityFunction)) {
+                if (this.#entry_equality_check(entry, raw_hash, key)) {
                     // found the right entry
                     return entry.value;
                 }
@@ -60442,7 +60444,7 @@ class HashMap {
                 const entry_index = bin - ENTRY_BASE;
                 const entry = entries[entry_index];
 
-                if (entry_equality_check(entry, raw_hash, key, this.keyEqualityFunction)) {
+                if (this.#entry_equality_check(entry, raw_hash, key)) {
                     // found the right entry
 
                     // record entry as dead
@@ -60776,16 +60778,27 @@ class CacheElement {
             next.previous = previous;
         }
     }
+
+    toString() {
+        return `CacheElement{ hasNext:${this.next !== null}, hasPrevious:${this.previous !== null}, weight:${this.weight}, key:${this.key}, value:${this.value} }`;
+    }
 }
 
-// TODO validate hashes of held elements to keep them up to date. Keys are assumed to be immutable, but this assumption may be broken by users
-
 /**
  * Hash-based cache, uses LRU (least-recently-used) eviction policy
+ * Make sure that keys being used are truly immutable when it comes to hash and equality calculation, otherwise cache corruption is inevitable
  * @template Key, Value
  * @extends Map<Key,Value>
  */
 class Cache {
+    #maxWeight = Number.POSITIVE_INFINITY;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    #weight = 0;
+
     /**
      * @param {number} [maxWeight=Number.POSITIVE_INFINITY]
      * @param {function(key:Key):number} [keyWeigher= key=>0]
@@ -60809,14 +60822,8 @@ class Cache {
          * @type {number}
          * @private
          */
-        this.maxWeight = maxWeight;
+        this.#maxWeight = maxWeight;
 
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.weight = 0;
 
         /**
          *
@@ -60917,18 +60924,37 @@ class Cache {
         return this.data.size;
     }
 
+    /**
+     * @deprecated use {@link maxWeight} directly instead
+     */
+    setMaxWeight(value) {
+        this.maxWeight = value;
+    }
+
+    /**
+     * Total weight of all elements currently in the cache
+     * @returns {number}
+     */
+    get weight() {
+        return this.#weight;
+    }
+
     /**
      * Will cause evictions if current weight is smaller than what we're setting
      * @param {number} value
      */
-    setMaxWeight(value) {
+    set maxWeight(value) {
         if (typeof value !== "number" || value < 0) {
             throw new Error(`Weight must be a non-negative number, instead was '${value}'`);
         }
 
-        this.maxWeight = value;
+        this.#maxWeight = value;
+
+        this.evictUntilWeight(this.#maxWeight);
+    }
 
-        this.evictUntilWeight(this.maxWeight);
+    get maxWeight() {
+        return this.#maxWeight;
     }
 
     /**
@@ -60947,7 +60973,8 @@ class Cache {
             result += weight;
         }
 
-        this.weight = result;
+        this.#weight = result;
+        this.evictUntilWeight(this.#maxWeight);
     }
 
     /**
@@ -60977,13 +61004,13 @@ class Cache {
 
         const delta_weight = new_weight - old_weight;
 
-        this.weight += delta_weight;
+        this.#weight += delta_weight;
 
         if (
-            this.weight > this.maxWeight
-            && new_weight <= this.maxWeight //make it less likely to drop entire cache
+            this.#weight > this.#maxWeight
+            && new_weight <= this.#maxWeight //make it less likely to drop entire cache
         ) {
-            this.evictUntilWeight(this.maxWeight);
+            this.evictUntilWeight(this.#maxWeight);
         }
 
         return true;
@@ -61039,7 +61066,7 @@ class Cache {
 
         const target = Math.max(targetWeight, 0);
 
-        while (this.weight > target) {
+        while (this.#weight > target) {
             this.evictOne();
         }
     }
@@ -61081,7 +61108,7 @@ class Cache {
              * in which case entire cache will be evicted, but there still won't be enough space
              * @type {number}
              */
-            const weightTarget = this.maxWeight - elementWeight;
+            const weightTarget = this.#maxWeight - elementWeight;
 
             if (weightTarget < 0) {
                 // Special case
@@ -61096,13 +61123,13 @@ class Cache {
             this.data.set(key, element);
 
             //update weight
-            this.weight += elementWeight;
+            this.#weight += elementWeight;
         } else {
             // check if value is the same
             if (value === element.value) ; else {
                 // replace value, adjust weight
-                this.weight -= this.valueWeigher(element.value);
-                this.weight += this.valueWeigher(value);
+                this.#weight -= this.valueWeigher(element.value);
+                this.#weight += this.valueWeigher(value);
 
                 element.value = value;
             }
@@ -61188,7 +61215,7 @@ class Cache {
         this.data.delete(key);
 
         //update weight
-        this.weight -= element.weight;
+        this.#weight -= element.weight;
     }
 
     /**
@@ -61260,7 +61287,7 @@ class Cache {
         this.__first = null;
         this.__last = null;
 
-        this.weight = 0;
+        this.#weight = 0;
     }
 
     /**
@@ -63121,12 +63148,14 @@ class LineBuilder {
      *
      * @type {Line[]}
      */
-    lines = [];
+    #lines = [];
+
     /**
      *
      * @type {number}
      */
-    indentation = 0;
+    #indentation = 0;
+
     /**
      *
      * @type {number}
@@ -63138,7 +63167,7 @@ class LineBuilder {
      * @return {number}
      */
     get count() {
-        return this.lines.length;
+        return this.#lines.length;
     }
 
     /**
@@ -63147,7 +63176,7 @@ class LineBuilder {
      * @param {string} term
      */
     containsSubstring(term) {
-        const lines = this.lines;
+        const lines = this.#lines;
         const n = lines.length;
         for (let i = 0; i < n; i++) {
             const line = lines[i];
@@ -63167,7 +63196,7 @@ class LineBuilder {
      * @returns {LineBuilder}
      */
     indent() {
-        this.indentation++;
+        this.#indentation++;
         return this;
     }
 
@@ -63176,7 +63205,7 @@ class LineBuilder {
      * @returns {LineBuilder}
      */
     dedent() {
-        this.indentation--;
+        this.#indentation--;
         return this;
     }
 
@@ -63187,9 +63216,9 @@ class LineBuilder {
      */
     add(line_text) {
 
-        const line = new Line(line_text, this.indentation);
+        const line = new Line(line_text, this.#indentation);
 
-        this.lines.push(line);
+        this.#lines.push(line);
 
         return this;
     }
@@ -63200,23 +63229,23 @@ class LineBuilder {
      */
     addLines(lines) {
 
-        const other_lines = lines.lines;
+        const other_lines = lines.#lines;
 
         const other_line_count = other_lines.length;
 
         for (let i = 0; i < other_line_count; i++) {
             const otherLine = other_lines[i];
 
-            const line = new Line(otherLine.text, otherLine.indentation + this.indentation);
+            const line = new Line(otherLine.text, otherLine.indentation + this.#indentation);
 
-            this.lines.push(line);
+            this.#lines.push(line);
         }
 
     }
 
     clear() {
-        this.lines = [];
-        this.indentation = 0;
+        this.#lines = [];
+        this.#indentation = 0;
     }
 
     /**
@@ -63228,7 +63257,7 @@ class LineBuilder {
 
         let i, j, l;
 
-        const lines = this.lines;
+        const lines = this.#lines;
 
         for (i = 0, l = lines.length; i < l; i++) {
             const line = lines[i];
@@ -63261,7 +63290,9 @@ class LineBuilder {
 
         for (let i = 0; i < n; i++) {
 
-            r.add(lines[i]);
+            const line_text = lines[i];
+
+            r.add(line_text);
 
         }
 
@@ -66275,7 +66306,7 @@ class GeometrySpatialQueryAccelerator {
      * @param {number} value in bytes
      */
     set cache_size(value) {
-        this.cache.setMaxWeight(value);
+        this.cache.maxWeight = value;
     }
 
     /**

package/editor/tools/v2/BlenderCameraOrientationGizmo.js

@@ -208,7 +208,7 @@ export class BlenderCameraOrientationGizmo extends CanvasView {
                 direction: new Vector3(0, 0, -1),
                 size: this.options.bubbleSizeSecondary,
                 style: this.options.axisStyles.nz,
-                label: "-Y",
+                label: "-Z",
                 labelHideUnselected: true,
                 primary: false
             },

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.104.0",
+  "version": "2.105.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/bvh3/build_triangle_morton_codes.d.ts

@@ -1,6 +1,6 @@
 /**
  * Compute morton codes for each triangle
- * @param {number[]|Uint32Array} morton_codes
+ * @param {number[]|Uint32Array} morton_codes output where the morton codes are to be written to, matching order in {@link index_array}
  * @param {number} tri_count
  * @param {number[]|Uint8Array|Uint16Array|Uint32Array} index_array
  * @param {number[]|Float32Array} position_array

package/src/core/bvh2/bvh3/build_triangle_morton_codes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_triangle_morton_codes.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/build_triangle_morton_codes.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,0DAXW,MAAM,EAAE,GAAC,WAAW,aACpB,MAAM,eACN,MAAM,EAAE,GAAC,UAAU,GAAC,WAAW,GAAC,WAAW,kBAC3C,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,QA4DhB"}
+{"version":3,"file":"build_triangle_morton_codes.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/build_triangle_morton_codes.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,0DAXW,MAAM,EAAE,GAAC,WAAW,aACpB,MAAM,eACN,MAAM,EAAE,GAAC,UAAU,GAAC,WAAW,GAAC,WAAW,kBAC3C,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,QA8DhB"}

package/src/core/bvh2/bvh3/build_triangle_morton_codes.js

@@ -2,7 +2,7 @@ import morton from "../../geom/3d/morton/Morton.js";
 
 /**
  * Compute morton codes for each triangle
- * @param {number[]|Uint32Array} morton_codes
+ * @param {number[]|Uint32Array} morton_codes output where the morton codes are to be written to, matching order in {@link index_array}
  * @param {number} tri_count
  * @param {number[]|Uint8Array|Uint16Array|Uint32Array} index_array
  * @param {number[]|Float32Array} position_array
@@ -37,10 +37,12 @@ export function build_triangle_morton_codes(
 
         const i3 = i * 3;
 
+        // read indices
         const a = index_array[i3];
         const b = index_array[i3 + 1];
         const c = index_array[i3 + 2];
 
+        // read vertex positions
         const a_address = a * 3;
         const ax = position_array[a_address];
         const ay = position_array[a_address + 1];

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.d.ts

@@ -1,4 +1,5 @@
 /**
+ * Given a set of leaves, build intermediate node hierarchy on top, all the way up to the root
  * Assumes nodes are spatially sorted
  * NOTE: {@link unprocessed_nodes} will be modified during execution to save memory
  * @param {BVH} bvh

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_build_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,kEANW,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,aACN,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,GACJ,MAAM,CAyDlB"}
+{"version":3,"file":"ebvh_build_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,kEANW,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,aACN,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,GACJ,MAAM,CAyDlB"}

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.js

@@ -2,6 +2,7 @@ import { assert } from "../../assert.js";
 import { max2 } from "../../math/max2.js";
 
 /**
+ * Given a set of leaves, build intermediate node hierarchy on top, all the way up to the root
  * Assumes nodes are spatially sorted
  * NOTE: {@link unprocessed_nodes} will be modified during execution to save memory
  * @param {BVH} bvh
@@ -19,8 +20,8 @@ export function ebvh_build_hierarchy(
     node_pool_offset
 ) {
 
-    assert.isNonNegativeInteger(input_node_count,'input_node_count');
-    assert.isNonNegativeInteger(node_pool_offset,'node_pool_offset');
+    assert.isNonNegativeInteger(input_node_count, 'input_node_count');
+    assert.isNonNegativeInteger(node_pool_offset, 'node_pool_offset');
 
     let used_index = node_pool_offset;
 

package/src/core/cache/Cache.d.ts

@@ -21,7 +21,8 @@ export class Cache<K, V> {
     readonly onRemoved: Signal<K, V>
 
     readonly weight: number
-    readonly maxWeight: number
+
+    maxWeight: number
 
     size(): number
 

package/src/core/cache/Cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/Cache.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IACI;;;;;;;;OAQG;IACH,sGARW,MAAM,EA6FhB;IAtEG;;;;OAIG;IACH,kBAA0B;IAE1B;;;;OAIG;IACH,eAAe;IAEf;;;;OAIG;IACH,mBAA4B;IAE5B;;;;OAIG;IACH,qBAAgC;IAEhC;;;;OAIG;IACH,gBAAmB;IACnB;;;;OAIG;IACH,eAAkB;IAGlB;;;;OAIG;IACH,aAIE;IAEF;;;OAGG;IACH,WAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEE;IAE7B;;;OAGG;IACH,WAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEE;IAE7B;;;OAGG;IACH,OAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEF;IAG7B;;;;;OAKG;IACH,kBAyBC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAUhB;IAED;;;;OAIG;IACH,wBAYC;IAED;;;;;;OAMG;IACH,yBAHW,GAAG,GACD,OAAO,CAgCnB;IAED;;;;;OAKG;IACH,6BAUC;IAED;;;OAGG;IACH,sBAFa,aAAa,GAAG,EAAC,KAAK,CAAC,GAAC,IAAI,CAIxC;IAED;;;OAGG;IACH,YAFa,OAAO,CAgBnB;IAED;;;OAGG;IACH,+BAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,SAHW,GAAG,SACH,KAAK,QAoEf;IAED;;;;OAIG;IACH,cAHW,GAAG,GACD,OAAO,CAInB;IAED;;;;OAIG;IACH,SAHW,GAAG,GACD,KAAK,GAAC,IAAI,CAYtB;IAGD;;;;;;OAMG;IACH,kBALW,GAAG,kBACM,GAAG,KAAE,KAAK,0BAElB,KAAK,CAchB;IAED;;;;OAIG;IACH,wBAqBC;IAED;;;;OAIG;IACH,YAHW,GAAG,GACD,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,kBAHW,GAAG,GACD,OAAO,CAanB;IAED;;OAEG;IACH,cAcC;IAED;;;OAGG;IACH,aAOC;IAED;;;;;OAKG;IACH,wCAFa,OAAO,CAMnB;IAGL;;;OAGG;IACH,6CAAmB;IAEnB;;;OAGG;IACH,+BA5FiB,OAAO,CA4FF;IAEtB;;;OAGG;IACH,4BA9KiB,OAAO,CA8KL;CAlBlB;mBApgBkB,4BAA4B;6BAIlB,mBAAmB"}
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/Cache.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH;IASI;;;;;;;;OAQG;IACH,sGARW,MAAM,EAuFhB;IAxDG;;;;OAIG;IACH,mBAA4B;IAE5B;;;;OAIG;IACH,qBAAgC;IAEhC;;;;OAIG;IACH,gBAAmB;IACnB;;;;OAIG;IACH,eAAkB;IAGlB;;;;OAIG;IACH,aAIE;IAEF;;;OAGG;IACH,WAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEE;IAE7B;;;OAGG;IACH,WAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEE;IAE7B;;;OAGG;IACH,OAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEF;IAG7B;;;;;OAKG;IACH,kBAyBC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;OAEG;IACH,+BAEC;IAUD;;;OAGG;IACH,2BAQC;IAED,wBAEC;IAxBD;;;OAGG;IACH,qBAEC;IAoBD;;;;OAIG;IACH,wBAaC;IAED;;;;;;OAMG;IACH,yBAHW,GAAG,GACD,OAAO,CAgCnB;IAED;;;;;OAKG;IACH,6BAUC;IAED;;;OAGG;IACH,sBAFa,aAAa,GAAG,EAAC,KAAK,CAAC,GAAC,IAAI,CAIxC;IAED;;;OAGG;IACH,YAFa,OAAO,CAkBnB;IAED;;;OAGG;IACH,+BAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,SAHW,GAAG,SACH,KAAK,QAoEf;IAED;;;;OAIG;IACH,cAHW,GAAG,GACD,OAAO,CAInB;IAED;;;;OAIG;IACH,SAHW,GAAG,GACD,KAAK,GAAC,IAAI,CAYtB;IAGD;;;;;;OAMG;IACH,kBALW,GAAG,kBACM,GAAG,KAAE,KAAK,0BAElB,KAAK,CAchB;IAED;;;;OAIG;IACH,wBAqBC;IAED;;;;OAIG;IACH,YAHW,GAAG,GACD,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,kBAHW,GAAG,GACD,OAAO,CAanB;IAED;;OAEG;IACH,cAcC;IAED;;;OAGG;IACH,aAOC;IAED;;;;;OAKG;IACH,wCAFa,OAAO,CAMnB;IAGL;;;OAGG;IACH,6CAAmB;IAEnB;;;OAGG;IACH,+BA5FiB,OAAO,CA4FF;IAEtB;;;OAGG;IACH,4BA9KiB,OAAO,CA8KL;;CAlBlB;mBA3hBkB,4BAA4B;6BAIlB,mBAAmB"}

package/src/core/cache/Cache.js

@@ -7,14 +7,21 @@ import { returnZero } from "../function/returnZero.js";
 import { strictEquals } from "../function/strictEquals.js";
 import { CacheElement } from "./CacheElement.js";
 
-// TODO validate hashes of held elements to keep them up to date. Keys are assumed to be immutable, but this assumption may be broken by users
-
 /**
  * Hash-based cache, uses LRU (least-recently-used) eviction policy
+ * Make sure that keys being used are truly immutable when it comes to hash and equality calculation, otherwise cache corruption is inevitable
  * @template Key, Value
  * @extends Map<Key,Value>
  */
 export class Cache {
+    #maxWeight = Number.POSITIVE_INFINITY;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    #weight = 0;
+
     /**
      * @param {number} [maxWeight=Number.POSITIVE_INFINITY]
      * @param {function(key:Key):number} [keyWeigher= key=>0]
@@ -44,14 +51,8 @@ export class Cache {
          * @type {number}
          * @private
          */
-        this.maxWeight = maxWeight;
+        this.#maxWeight = maxWeight;
 
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.weight = 0;
 
         /**
          *
@@ -152,18 +153,37 @@ export class Cache {
         return this.data.size;
     }
 
+    /**
+     * @deprecated use {@link maxWeight} directly instead
+     */
+    setMaxWeight(value) {
+        this.maxWeight = value;
+    }
+
+    /**
+     * Total weight of all elements currently in the cache
+     * @returns {number}
+     */
+    get weight() {
+        return this.#weight;
+    }
+
     /**
      * Will cause evictions if current weight is smaller than what we're setting
      * @param {number} value
      */
-    setMaxWeight(value) {
+    set maxWeight(value) {
         if (typeof value !== "number" || value < 0) {
             throw new Error(`Weight must be a non-negative number, instead was '${value}'`);
         }
 
-        this.maxWeight = value;
+        this.#maxWeight = value;
 
-        this.evictUntilWeight(this.maxWeight);
+        this.evictUntilWeight(this.#maxWeight);
+    }
+
+    get maxWeight() {
+        return this.#maxWeight;
     }
 
     /**
@@ -182,7 +202,8 @@ export class Cache {
             result += weight;
         }
 
-        this.weight = result;
+        this.#weight = result;
+        this.evictUntilWeight(this.#maxWeight);
     }
 
     /**
@@ -212,13 +233,13 @@ export class Cache {
 
         const delta_weight = new_weight - old_weight;
 
-        this.weight += delta_weight;
+        this.#weight += delta_weight;
 
         if (
-            this.weight > this.maxWeight
-            && new_weight <= this.maxWeight //make it less likely to drop entire cache
+            this.#weight > this.#maxWeight
+            && new_weight <= this.#maxWeight //make it less likely to drop entire cache
         ) {
-            this.evictUntilWeight(this.maxWeight);
+            this.evictUntilWeight(this.#maxWeight);
         }
 
         return true;
@@ -259,7 +280,9 @@ export class Cache {
         const victim = this.findEvictionVictim();
 
         if (victim !== null) {
-            this.remove(victim.key);
+            const removed_from_hash_table = this.remove(victim.key);
+
+            assert.ok(removed_from_hash_table, `Failed to remove key '${victim.key}', likely reasons:\n\t1. key was mutated (keys must never be mutated)\n\t2. provided hashing function is unstable\n\t3. provided equality function is inconsistent`);
 
             this.onEvicted.send2(victim.key, victim.value);
 
@@ -280,7 +303,7 @@ export class Cache {
 
         const target = Math.max(targetWeight, 0);
 
-        while (this.weight > target) {
+        while (this.#weight > target) {
             this.evictOne();
         }
     }
@@ -322,7 +345,7 @@ export class Cache {
              * in which case entire cache will be evicted, but there still won't be enough space
              * @type {number}
              */
-            const weightTarget = this.maxWeight - elementWeight;
+            const weightTarget = this.#maxWeight - elementWeight;
 
             if (weightTarget < 0) {
                 // Special case
@@ -337,15 +360,15 @@ export class Cache {
             this.data.set(key, element);
 
             //update weight
-            this.weight += elementWeight;
+            this.#weight += elementWeight;
         } else {
             // check if value is the same
             if (value === element.value) {
                 // same value, no action required
             } else {
                 // replace value, adjust weight
-                this.weight -= this.valueWeigher(element.value);
-                this.weight += this.valueWeigher(value);
+                this.#weight -= this.valueWeigher(element.value);
+                this.#weight += this.valueWeigher(value);
 
                 element.value = value;
             }
@@ -431,7 +454,7 @@ export class Cache {
         this.data.delete(key);
 
         //update weight
-        this.weight -= element.weight;
+        this.#weight -= element.weight;
     }
 
     /**
@@ -503,7 +526,7 @@ export class Cache {
         this.__first = null;
         this.__last = null;
 
-        this.weight = 0;
+        this.#weight = 0;
     }
 
     /**