@woosh/meep-engine 2.104.0 → 2.106.0

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();
         }
     }
@@ -294,6 +317,22 @@ export class Cache {
         let element = this.data.get(key);
 
         if (element === undefined) {
+            //compute weight
+            const elementWeight = this.computeElementWeight(key, value);
+
+            /**
+             * It's possible that element being added is larger than cache's capacity,
+             * in which case entire cache will be evicted, but there still won't be enough space
+             * @type {number}
+             */
+            const weightTarget = this.#maxWeight - elementWeight;
+
+            if (weightTarget < 0) {
+                // Special case
+                // element does not fit into cache, attempting to insert it forcibly would result in a full flush and overflow
+                return;
+            }
+
             element = new CacheElement();
 
             element.key = key;
@@ -311,25 +350,8 @@ export class Cache {
                 this.__last = element;
             }
 
-            //compute weight
-            const elementWeight = this.computeElementWeight(key, value);
-
             element.weight = elementWeight;
 
-
-            /**
-             * It's possible that element being added is larger than cache's capacity,
-             * in which case entire cache will be evicted, but there still won't be enough space
-             * @type {number}
-             */
-            const weightTarget = this.maxWeight - elementWeight;
-
-            if (weightTarget < 0) {
-                // Special case
-                // element does not fit into cache, attempting to insert it forcibly would result in a full flush and overflow
-                return;
-            }
-
             //evict elements until there is enough space for the element
             this.evictUntilWeight(weightTarget);
 
@@ -337,16 +359,21 @@ 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 -= element.weight;
+
+                const elementWeight = this.computeElementWeight(key, value);
+
+                this.#weight += elementWeight;
 
+                // assign new values
+                element.weight = elementWeight;
                 element.value = value;
             }
 
@@ -431,7 +458,7 @@ export class Cache {
         this.data.delete(key);
 
         //update weight
-        this.weight -= element.weight;
+        this.#weight -= element.weight;
     }
 
     /**
@@ -503,7 +530,7 @@ export class Cache {
         this.__first = null;
         this.__last = null;
 
-        this.weight = 0;
+        this.#weight = 0;
     }
 
     /**

package/src/core/cache/Cache.spec.js

@@ -32,6 +32,19 @@ test("trying to insert an element into the cache that's larger than the cache ca
     expect(cache.contains(2)).toBe(false);
 });
 
+test("Recently accessed element should not be targeted for eviction where possible", () => {
+    const cache = new Cache();
+
+    cache.put(2, "hello");
+    cache.put(7, "world");
+
+    cache.get(2);
+
+    cache.evictOne();
+
+    expect(cache.has(2)).toBe(true);
+});
+
 test("removeListener is called when element is evicted", () => {
 
     const removeListener = jest.fn();
@@ -233,3 +246,32 @@ test("silentRemove should not notify", () => {
 
     expect(mock).not.toHaveBeenCalled();
 });
+
+test("setting maxWeight will drop data and update weight", () => {
+
+    const cache = new Cache();
+
+    cache.set("a", 1);
+    cache.set("b", 2);
+    cache.set("c", 3);
+
+    expect(cache.weight).toEqual(3);
+
+    cache.maxWeight = 1;
+
+    expect(cache.maxWeight).toEqual(1);
+    expect(cache.weight).toEqual(1);
+});
+
+test("setting maxWeight to 0 will empty out cache", () => {
+
+    const cache = new Cache();
+
+    cache.set("a", 1);
+    cache.set("b", 2);
+
+    cache.maxWeight = 0;
+
+    expect(cache.size()).toBe(0);
+
+});

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

@@ -30,5 +30,6 @@ export class CacheElement<Key, Value> {
      */
     previous: CacheElement<Key_1, Value_1>;
     unlink(): void;
+    toString(): string;
 }
 //# sourceMappingURL=CacheElement.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"CacheElement.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/CacheElement.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH;IAMQ;;;OAGG;IACH,WAAe;IAEf;;;OAGG;IACH,eAAiB;IAEjB;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,mCAAgB;IAEhB;;;OAGG;IACH,uCAAoB;IAGxB,eAWC;CACJ"}
+{"version":3,"file":"CacheElement.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/CacheElement.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH;IAMQ;;;OAGG;IACH,WAAe;IAEf;;;OAGG;IACH,eAAiB;IAEjB;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,mCAAgB;IAEhB;;;OAGG;IACH,uCAAoB;IAGxB,eAWC;IAED,mBAEC;CACJ"}

package/src/core/cache/CacheElement.js

@@ -52,4 +52,8 @@ export 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} }`;
+    }
 }

package/src/core/codegen/LineBuilder.d.ts

@@ -9,16 +9,6 @@ declare class LineBuilder {
      * @returns {LineBuilder}
      */
     static fromText(text: string): LineBuilder;
-    /**
-     *
-     * @type {Line[]}
-     */
-    lines: Line[];
-    /**
-     *
-     * @type {number}
-     */
-    indentation: number;
     /**
      *
      * @type {number}
@@ -62,19 +52,6 @@ declare class LineBuilder {
      * @returns {string}
      */
     build(): string;
-}
-/**
- * Created by Alex on 08/06/2015.
- */
-declare class Line {
-    /**
-     *
-     * @param {string} text
-     * @param {number} indent
-     * @constructor
-     */
-    constructor(text: string, indent: number);
-    text: string;
-    indentation: number;
+    #private;
 }
 //# sourceMappingURL=LineBuilder.d.ts.map

package/src/core/codegen/LineBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LineBuilder.d.ts","sourceRoot":"","sources":["../../../../src/core/codegen/LineBuilder.js"],"names":[],"mappings":";AAoBA;;GAEG;AACH;IAkII;;;;OAIG;IACH,sBAHW,MAAM,GACJ,WAAW,CAkBvB;IArJD;;;OAGG;IACH,OAFU,IAAI,EAAE,CAEL;IACX;;;OAGG;IACH,aAFU,MAAM,CAEA;IAChB;;;OAGG;IACH,cAFU,MAAM,CAEqB;IAErC;;;OAGG;IACH,oBAEC;IAED;;;;OAIG;IACH,wBAFW,MAAM,GADL,OAAO,CAiBlB;IAED;;;OAGG;IACH,UAFa,WAAW,CAKvB;IAED;;;OAGG;IACH,UAFa,WAAW,CAKvB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,WAAW,CASvB;IAED;;;OAGG;IACH,gBAFW,WAAW,QAgBrB;IAED,cAGC;IAED;;;OAGG;IACH,SAFa,MAAM,CAsBlB;CAwBJ;AA/KD;;GAEG;AAGH;IACI;;;;;OAKG;IACH,kBAJW,MAAM,UACN,MAAM,EAMhB;IAFG,aAAgB;IAChB,oBAAyB;CAEhC"}
+{"version":3,"file":"LineBuilder.d.ts","sourceRoot":"","sources":["../../../../src/core/codegen/LineBuilder.js"],"names":[],"mappings":";AAoBA;;GAEG;AACH;IAoII;;;;OAIG;IACH,sBAHW,MAAM,GACJ,WAAW,CAoBvB;IA7ID;;;OAGG;IACH,cAFU,MAAM,CAEqB;IAErC;;;OAGG;IACH,oBAEC;IAED;;;;OAIG;IACH,wBAFW,MAAM,GADL,OAAO,CAiBlB;IAED;;;OAGG;IACH,UAFa,WAAW,CAKvB;IAED;;;OAGG;IACH,UAFa,WAAW,CAKvB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,WAAW,CASvB;IAED;;;OAGG;IACH,gBAFW,WAAW,QAgBrB;IAED,cAGC;IAED;;;OAGG;IACH,SAFa,MAAM,CAsBlB;;CA0BJ"}

package/src/core/codegen/LineBuilder.js

@@ -27,12 +27,14 @@ class LineBuilder {
      *
      * @type {Line[]}
      */
-    lines = [];
+    #lines = [];
+
     /**
      *
      * @type {number}
      */
-    indentation = 0;
+    #indentation = 0;
+
     /**
      *
      * @type {number}
@@ -44,7 +46,7 @@ class LineBuilder {
      * @return {number}
      */
     get count() {
-        return this.lines.length;
+        return this.#lines.length;
     }
 
     /**
@@ -53,7 +55,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];
@@ -73,7 +75,7 @@ class LineBuilder {
      * @returns {LineBuilder}
      */
     indent() {
-        this.indentation++;
+        this.#indentation++;
         return this;
     }
 
@@ -82,7 +84,7 @@ class LineBuilder {
      * @returns {LineBuilder}
      */
     dedent() {
-        this.indentation--;
+        this.#indentation--;
         return this;
     }
 
@@ -93,9 +95,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;
     }
@@ -106,23 +108,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;
     }
 
     /**
@@ -134,7 +136,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];
@@ -167,7 +169,9 @@ class LineBuilder {
 
         for (let i = 0; i < n; i++) {
 
-            r.add(lines[i]);
+            const line_text = lines[i];
+
+            r.add(line_text);
 
         }
 

package/src/core/collection/map/HashMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/HashMap.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;GAYG;AACH,uFAIC;AAsHD;;;;;;;GAOG;AACH;IA2DI;;;;;;OAMG;IACH,4FALuB,MAAM,EAsC5B;IAlBG;;;;;OAKG;IACH,iCAAsC;IACtC;;;;;OAKG;IACH,qCAA8C;IAOlD,mBAEC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IA2HD;;;;OAIG;IACH,SAHW,CAAC,SACD,CAAC,QAoEX;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,CAAC,GAAC,SAAS,CA+BvB;IAED;;;;;;;;OAQG;IACH,kBALW,CAAC,kBACQ,CAAC,KAAE,CAAC,0BAEZ,CAAC,CAcZ;IAED;;;;;OAKG;IACH,cAJW,CAAC,SACD,CAAC,GACA,CAAC,CAYZ;IAuBD;;;;OAIG;IACH,YAHW,CAAC,GACC,OAAO,CA+CnB;IAED;;;;;OAKG;IACH,4CAFa,OAAO,CA+BnB;IAOD;;OAEG;IACH,gBAkDC;IAmBD,2CAwBC;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;OAEG;IACH,cA6BC;IA+BD;;;OAGG;IACH,UAFa,SAAS,CAAC,CAAC,CAOvB;IAED;;;OAGG;IACH,QAFa,SAAS,CAAC,CAAC,CAMvB;IAhDD,yDA2BC;;CAsBJ"}
+{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/HashMap.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;GAYG;AACH,uFAIC;AA8FD;;;;;;;GAOG;AACH;IA+DI;;;;;;OAMG;IACH,4FALuB,MAAM,EAsC5B;IAlBG;;;;;OAKG;IACH,iCAAsC;IACtC;;;;;OAKG;IACH,qCAA8C;IAOlD,mBAEC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAuJD;;;;OAIG;IACH,SAHW,CAAC,SACD,CAAC,QA0EX;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,CAAC,GAAC,SAAS,CA+BvB;IAED;;;;;;;;OAQG;IACH,kBALW,CAAC,kBACQ,CAAC,KAAE,CAAC,0BAEZ,CAAC,CAcZ;IAED;;;;;OAKG;IACH,cAJW,CAAC,SACD,CAAC,GACA,CAAC,CAYZ;IAuBD;;;;OAIG;IACH,YAHW,CAAC,GACC,OAAO,CA+CnB;IAED;;;;;OAKG;IACH,4CAFa,OAAO,CA+BnB;IAOD;;OAEG;IACH,gBAsDC;IAmBD,2CAwBC;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;OAEG;IACH,cA6BC;IA+BD;;;OAGG;IACH,UAFa,SAAS,CAAC,CAAC,CAOvB;IAED;;;OAGG;IACH,QAFa,SAAS,CAAC,CAAC,CAMvB;IAhDD,yDA2BC;;CAsBJ"}

package/src/core/collection/map/HashMap.js

@@ -124,30 +124,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);
-
-    assert.isBoolean(result, `result(a=${record.key},b=${key})`);
-
-    return result;
-}
-
-
 const EMPTY_BINS = new Uint32Array(0);
 
 /**
@@ -215,6 +191,10 @@ export class HashMap {
      */
     #load_factor = DEFAULT_LOAD_FACTOR;
 
+    /**
+     * Used to track modifications to prevent concurrent changes during iteration
+     * @type {number}
+     */
     #version = 0;
 
     /**
@@ -291,6 +271,8 @@ export class HashMap {
         this.#bin_count = 2 ** this.#bin_count_power_of_two;
         this.#bin_count_mask = this.#bin_count - 1;
 
+        const old_entry_allocation_count = this.#entries_allocated_count;
+
         this.#entries_allocated_count = 2 ** this.#entries_count_power_of_two;
 
         const BinsArray = UintArrayForCount(this.#entries_allocated_count + ENTRY_BASE);
@@ -302,7 +284,7 @@ export class HashMap {
 
         this.#entries = new_entries;
 
-        array_copy(old_entries, 0, new_entries, 0, min2(old_entries.length, this.#entries_allocated_count));
+        array_copy(old_entries, 0, new_entries, 0, min2(old_entry_allocation_count, this.#entries_allocated_count));
 
         if (this.#size > 0) {
             // re-hash
@@ -339,6 +321,29 @@ export 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;
+        }
+
+        assert.equal(record.hash, this.#build_key_hash(record.key), `Key hash has diverged for key ${record.key}, likely key was mutated or hash function is unstable`);
+
+        const result = this.keyEqualityFunction(record.key, key);
+
+        assert.isBoolean(result, `result(a=${record.key},b=${key})`);
+
+        return result;
+    }
+
     /**
      *
      * @param {K} k
@@ -354,6 +359,9 @@ export class HashMap {
 
         if (this.#entries[i] !== undefined) {
             const entry = this.#entries[i];
+
+            assert.equal(entry.hash, RESERVED_HASH, 'Entry is occupied');
+
             entry.hash = hash;
             entry.key = k;
             entry.value = v;
@@ -402,6 +410,7 @@ export class HashMap {
 
         const raw_hash = this.#build_key_hash(key);
         let bin_index = this.#compute_bin_index(raw_hash);
+
         assert.isFiniteNumber(bin_index, 'hash');
 
         let first_deleted_bin_index = UNDEFINED_BIN_INDEX;
@@ -415,11 +424,12 @@ export 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
 
@@ -436,7 +446,11 @@ export class HashMap {
                 assert.equal(this.#entries[entry_index].value, value, 'entry.value');
                 assert.equal(this.#entries[entry_index].key, key, 'entry.key');
 
-                this.#bins[bin_index] = entry_index + ENTRY_BASE;
+                const bin_value = entry_index + ENTRY_BASE;
+
+                this.#bins[bin_index] = bin_value;
+
+                assert.equal(bin_value, this.#bins[bin_index], 'Bin value write error');
 
                 break;
 
@@ -484,7 +498,7 @@ export 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;
                 }
@@ -588,7 +602,7 @@ export 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
@@ -670,7 +684,11 @@ export class HashMap {
 
         let written_entries = 0;
 
-        for (let existing_entry_index = this.#entries_start; existing_entry_index < entries_bound; existing_entry_index++) {
+        for (
+            let existing_entry_index = this.#entries_start;
+            existing_entry_index < entries_bound;
+            existing_entry_index++
+        ) {
             const entry = entries[existing_entry_index];
 
             const hash = entry.hash;

package/src/core/model/node-graph/NodeGraph.js

@@ -244,7 +244,7 @@ export class NodeGraph {
      * @return {NodeInstance[]}
      */
     getNodes() {
-        return this.nodes.data.slice();
+        return this.nodes.asArray().slice();
     }
 
     /**
@@ -252,7 +252,7 @@ export class NodeGraph {
      * @return {Connection[]}
      */
     getConnections() {
-        return this.connections.data.slice();
+        return this.connections.asArray().slice();
     }
 
     /**

package/src/engine/graphics/ecs/mesh/Mesh.js

@@ -397,7 +397,7 @@ class Mesh {
                 const matrixWorld = skeletonBone.matrixWorld;
 
 
-                result.threejs_setFromMatrixPosition(matrixWorld);
+                result.setFromMatrixPosition(matrixWorld.elements);
             }
 
         }

package/src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js

@@ -41,7 +41,7 @@ export class GeometrySpatialQueryAccelerator {
      * @param {number} value in bytes
      */
     set cache_size(value) {
-        this.cache.setMaxWeight(value);
+        this.cache.maxWeight = value;
     }
 
     /**