@colyseus/schema 3.0.0-alpha.33 → 3.0.0-alpha.35

package/build/esm/index.mjs

@@ -34,7 +34,6 @@ const $decoder = Symbol("$decoder");
 const $filter = Symbol("$filter");
 const $getByIndex = Symbol("$getByIndex");
 const $deleteByIndex = Symbol("$deleteByIndex");
-const $descriptors = Symbol("$descriptors");
 /**
  * Used to hold ChangeTree instances whitin the structures
  */
@@ -44,11 +43,6 @@ const $changes = Symbol('$changes');
  * (MapSchema, ArraySchema, etc.)
  */
 const $childType = Symbol('$childType');
-/**
- * Special ChangeTree property to identify new instances
- * (Once they're encoded, they're not new anymore)
- */
-const $isNew = Symbol("$isNew");
 /**
  * Optional "discard" method for custom types (ArraySchema)
  * (Discards changes for next serialization)
@@ -58,6 +52,14 @@ const $onEncodeEnd = Symbol('$onEncodeEnd');
  * When decoding, this method is called after the instance is fully decoded
  */
 const $onDecodeEnd = Symbol("$onDecodeEnd");
+/**
+ * Metadata
+ */
+const $descriptors = Symbol("$descriptors");
+const $numFields = "$__numFields";
+const $refTypeFieldIndexes = "$__refTypeFieldIndexes";
+const $viewFieldIndexes = "$__viewFieldIndexes";
+const $fieldIndexesByViewTag = "$__fieldIndexesByViewTag";
 
 const registeredTypes = {};
 const identifiers = new Map();
@@ -104,7 +106,7 @@ const Metadata = {
             };
         }
         // map -1 as last field index
-        Object.defineProperty(metadata, -1, {
+        Object.defineProperty(metadata, $numFields, {
             value: index,
             enumerable: false,
             configurable: true
@@ -117,14 +119,14 @@ const Metadata = {
         });
         // if child Ref/complex type, add to -4
         if (typeof (metadata[index].type) !== "string") {
-            if (metadata[-4] === undefined) {
-                Object.defineProperty(metadata, -4, {
+            if (metadata[$refTypeFieldIndexes] === undefined) {
+                Object.defineProperty(metadata, $refTypeFieldIndexes, {
                     value: [],
                     enumerable: false,
                     configurable: true,
                 });
             }
-            metadata[-4].push(index);
+            metadata[$refTypeFieldIndexes].push(index);
         }
     },
     setTag(metadata, fieldName, tag) {
@@ -132,25 +134,25 @@ const Metadata = {
         const field = metadata[index];
         // add 'tag' to the field
         field.tag = tag;
-        if (!metadata[-2]) {
+        if (!metadata[$viewFieldIndexes]) {
             // -2: all field indexes with "view" tag
-            Object.defineProperty(metadata, -2, {
+            Object.defineProperty(metadata, $viewFieldIndexes, {
                 value: [],
                 enumerable: false,
                 configurable: true
             });
             // -3: field indexes by "view" tag
-            Object.defineProperty(metadata, -3, {
+            Object.defineProperty(metadata, $fieldIndexesByViewTag, {
                 value: {},
                 enumerable: false,
                 configurable: true
             });
         }
-        metadata[-2].push(index);
-        if (!metadata[-3][tag]) {
-            metadata[-3][tag] = [];
+        metadata[$viewFieldIndexes].push(index);
+        if (!metadata[$fieldIndexesByViewTag][tag]) {
+            metadata[$fieldIndexesByViewTag][tag] = [];
         }
-        metadata[-3][tag].push(index);
+        metadata[$fieldIndexesByViewTag][tag].push(index);
     },
     setFields(target, fields) {
         const metadata = (target.prototype.constructor[Symbol.metadata] ??= {});
@@ -175,7 +177,7 @@ const Metadata = {
         //
         const metadata = {};
         klass[Symbol.metadata] = metadata;
-        Object.defineProperty(metadata, -1, {
+        Object.defineProperty(metadata, $numFields, {
             value: 0,
             enumerable: false,
             configurable: true,
@@ -189,7 +191,7 @@ const Metadata = {
             if (parentMetadata) {
                 // assign parent metadata to current
                 Object.assign(metadata, parentMetadata);
-                for (let i = 0; i <= parentMetadata[-1]; i++) {
+                for (let i = 0; i <= parentMetadata[$numFields]; i++) {
                     const fieldName = parentMetadata[i].name;
                     Object.defineProperty(metadata, fieldName, {
                         value: parentMetadata[fieldName],
@@ -197,8 +199,8 @@ const Metadata = {
                         configurable: true,
                     });
                 }
-                Object.defineProperty(metadata, -1, {
-                    value: parentMetadata[-1],
+                Object.defineProperty(metadata, $numFields, {
+                    value: parentMetadata[$numFields],
                     enumerable: false,
                     configurable: true,
                     writable: true,
@@ -210,40 +212,69 @@ const Metadata = {
     },
     isValidInstance(klass) {
         return (klass.constructor[Symbol.metadata] &&
-            Object.prototype.hasOwnProperty.call(klass.constructor[Symbol.metadata], -1));
+            Object.prototype.hasOwnProperty.call(klass.constructor[Symbol.metadata], $numFields));
     },
     getFields(klass) {
         const metadata = klass[Symbol.metadata];
         const fields = {};
-        for (let i = 0; i <= metadata[-1]; i++) {
+        for (let i = 0; i <= metadata[$numFields]; i++) {
             fields[metadata[i].name] = metadata[i].type;
         }
         return fields;
     }
 };
 
-var _a$5;
+function setOperationAtIndex(changeSet, index) {
+    const operationsIndex = changeSet.indexes[index];
+    if (operationsIndex === undefined) {
+        changeSet.indexes[index] = changeSet.operations.push(index) - 1;
+    }
+    else {
+        changeSet.operations[operationsIndex] = index;
+    }
+}
+function deleteOperationAtIndex(changeSet, index) {
+    const operationsIndex = changeSet.indexes[index];
+    if (operationsIndex !== undefined) {
+        changeSet.operations[operationsIndex] = undefined;
+    }
+    delete changeSet.indexes[index];
+}
+function enqueueChangeTree(root, changeTree, changeSet, queueRootIndex = changeTree[changeSet].queueRootIndex) {
+    if (root && root[changeSet][queueRootIndex] !== changeTree) {
+        changeTree[changeSet].queueRootIndex = root[changeSet].push(changeTree) - 1;
+    }
+}
 class ChangeTree {
-    static { _a$5 = $isNew; }
     constructor(ref) {
         this.isFiltered = false;
         this.isPartiallyFiltered = false;
-        this.currentOperationIndex = 0;
-        this.changes = new Map();
-        this.allChanges = new Map();
-        this[_a$5] = true;
+        this.indexedOperations = {};
+        //
+        // TODO:
+        //   try storing the index + operation per item.
+        //   example: 1024 & 1025 => ADD, 1026 => DELETE
+        //
+        // => https://chatgpt.com/share/67107d0c-bc20-8004-8583-83b17dd7c196
+        //
+        this.changes = { indexes: {}, operations: [] };
+        this.allChanges = { indexes: {}, operations: [] };
+        /**
+         * Is this a new instance? Used on ArraySchema to determine OPERATION.MOVE_AND_ADD operation.
+         */
+        this.isNew = true;
         this.ref = ref;
         //
         // Does this structure have "filters" declared?
         //
-        if (ref.constructor[Symbol.metadata]?.[-2]) {
-            this.allFilteredChanges = new Map();
-            this.filteredChanges = new Map();
+        if (ref.constructor[Symbol.metadata]?.[$viewFieldIndexes]) {
+            this.allFilteredChanges = { indexes: {}, operations: [] };
+            this.filteredChanges = { indexes: {}, operations: [] };
         }
     }
     setRoot(root) {
         this.root = root;
-        this.root.add(this);
+        const isNewChangeTree = this.root.add(this);
         const metadata = this.ref.constructor[Symbol.metadata];
         if (this.root.types.hasFilters) {
             //
@@ -254,22 +285,24 @@ class ChangeTree {
             //
             this.checkIsFiltered(metadata, this.parent, this.parentIndex);
             if (this.isFiltered || this.isPartiallyFiltered) {
-                this.root.allFilteredChanges.set(this, this.allFilteredChanges);
-                this.root.filteredChanges.set(this, this.filteredChanges);
+                enqueueChangeTree(root, this, 'filteredChanges');
+                if (isNewChangeTree) {
+                    this.root.allFilteredChanges.push(this);
+                }
             }
         }
         if (!this.isFiltered) {
-            this.root.changes.set(this, this.changes);
-            this.root.allChanges.set(this, this.allChanges);
+            enqueueChangeTree(root, this, 'changes');
+            if (isNewChangeTree) {
+                this.root.allChanges.push(this);
+            }
         }
-        this.ensureRefId();
+        // Recursively set root on child structures
         if (metadata) {
-            metadata[-4]?.forEach((index) => {
+            metadata[$refTypeFieldIndexes]?.forEach((index) => {
                 const field = metadata[index];
                 const value = this.ref[field.name];
-                if (value) {
-                    value[$changes].setRoot(root);
-                }
+                value?.[$changes].setRoot(root);
             });
         }
         else if (this.ref[$childType] && typeof (this.ref[$childType]) !== "string") {
@@ -286,31 +319,36 @@ class ChangeTree {
         if (!root) {
             return;
         }
-        root.add(this);
         const metadata = this.ref.constructor[Symbol.metadata];
         // skip if parent is already set
         if (root !== this.root) {
             this.root = root;
+            const isNewChangeTree = root.add(this);
             if (root.types.hasFilters) {
                 this.checkIsFiltered(metadata, parent, parentIndex);
                 if (this.isFiltered || this.isPartiallyFiltered) {
-                    this.root.filteredChanges.set(this, this.filteredChanges);
-                    this.root.allFilteredChanges.set(this, this.filteredChanges);
+                    enqueueChangeTree(root, this, 'filteredChanges');
+                    if (isNewChangeTree) {
+                        this.root.allFilteredChanges.push(this);
+                    }
                 }
             }
             if (!this.isFiltered) {
-                this.root.changes.set(this, this.changes);
-                this.root.allChanges.set(this, this.allChanges);
+                enqueueChangeTree(root, this, 'changes');
+                if (isNewChangeTree) {
+                    this.root.allChanges.push(this);
+                }
             }
-            this.ensureRefId();
+        }
+        else {
+            root.add(this);
         }
         // assign same parent on child structures
         if (metadata) {
-            metadata[-4]?.forEach((index) => {
+            metadata[$refTypeFieldIndexes]?.forEach((index) => {
                 const field = metadata[index];
                 const value = this.ref[field.name];
                 value?.[$changes].setParent(this.ref, root, index);
-                // console.log(this.ref.constructor.name, field.name, value);
                 // try { throw new Error(); } catch (e) {
                 //     console.log(e.stack);
                 // }
@@ -329,7 +367,7 @@ class ChangeTree {
         //
         const metadata = this.ref.constructor[Symbol.metadata];
         if (metadata) {
-            metadata[-4]?.forEach((index) => {
+            metadata[$refTypeFieldIndexes]?.forEach((index) => {
                 const field = metadata[index];
                 const value = this.ref[field.name];
                 if (value) {
@@ -345,8 +383,10 @@ class ChangeTree {
         }
     }
     operation(op) {
-        this.changes.set(--this.currentOperationIndex, op);
-        this.root?.changes.set(this, this.changes);
+        // operations without index use negative values to represent them
+        // this is checked during .encode() time.
+        this.changes.operations.push(-op);
+        enqueueChangeTree(this.root, this, 'changes');
     }
     change(index, operation = OPERATION.ADD) {
         const metadata = this.ref.constructor[Symbol.metadata];
@@ -354,7 +394,7 @@ class ChangeTree {
         const changeSet = (isFiltered)
             ? this.filteredChanges
             : this.changes;
-        const previousOperation = changeSet.get(index);
+        const previousOperation = this.indexedOperations[index];
         if (!previousOperation || previousOperation === OPERATION.DELETE) {
             const op = (!previousOperation)
                 ? operation
@@ -364,16 +404,19 @@ class ChangeTree {
             //
             // TODO: are DELETE operations being encoded as ADD here ??
             //
-            changeSet.set(index, op);
+            this.indexedOperations[index] = op;
         }
+        setOperationAtIndex(changeSet, index);
         if (isFiltered) {
-            this.allFilteredChanges.set(index, OPERATION.ADD);
-            this.root?.filteredChanges.set(this, this.filteredChanges);
-            this.root?.allFilteredChanges.set(this, this.allFilteredChanges);
+            setOperationAtIndex(this.allFilteredChanges, index);
+            if (this.root) {
+                enqueueChangeTree(this.root, this, 'filteredChanges');
+                enqueueChangeTree(this.root, this, 'allFilteredChanges');
+            }
         }
         else {
-            this.allChanges.set(index, OPERATION.ADD);
-            this.root?.changes.set(this, this.changes);
+            setOperationAtIndex(this.allChanges, index);
+            enqueueChangeTree(this.root, this, 'changes');
         }
     }
     shiftChangeIndexes(shiftIndex) {
@@ -385,12 +428,15 @@ class ChangeTree {
         const changeSet = (this.isFiltered)
             ? this.filteredChanges
             : this.changes;
-        const changeSetEntries = Array.from(changeSet.entries());
-        changeSet.clear();
-        // Re-insert each entry with the shifted index
-        for (const [index, op] of changeSetEntries) {
-            changeSet.set(index + shiftIndex, op);
+        const newIndexedOperations = {};
+        const newIndexes = {};
+        for (const index in this.indexedOperations) {
+            newIndexedOperations[Number(index) + shiftIndex] = this.indexedOperations[index];
+            newIndexes[Number(index) + shiftIndex] = changeSet[index];
         }
+        this.indexedOperations = newIndexedOperations;
+        changeSet.indexes = newIndexes;
+        changeSet.operations = changeSet.operations.map((index) => index + shiftIndex);
     }
     shiftAllChangeIndexes(shiftIndex, startIndex = 0) {
         //
@@ -406,24 +452,36 @@ class ChangeTree {
             this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
         }
     }
-    _shiftAllChangeIndexes(shiftIndex, startIndex = 0, allChangeSet) {
-        Array.from(allChangeSet.entries()).forEach(([index, op]) => {
-            if (index >= startIndex) {
-                allChangeSet.delete(index);
-                allChangeSet.set(index + shiftIndex, op);
+    _shiftAllChangeIndexes(shiftIndex, startIndex = 0, changeSet) {
+        const newIndexes = {};
+        for (const key in changeSet.indexes) {
+            const index = changeSet.indexes[key];
+            if (index > startIndex) {
+                newIndexes[Number(key) + shiftIndex] = index;
             }
-        });
+            else {
+                newIndexes[key] = index;
+            }
+        }
+        changeSet.indexes = newIndexes;
+        for (let i = 0; i < changeSet.operations.length; i++) {
+            const index = changeSet.operations[i];
+            if (index > startIndex) {
+                changeSet.operations[i] = index + shiftIndex;
+            }
+        }
     }
     indexedOperation(index, operation, allChangesIndex = index) {
-        if (this.filteredChanges !== undefined) {
-            this.allFilteredChanges.set(allChangesIndex, OPERATION.ADD);
-            this.filteredChanges.set(index, operation);
-            this.root?.filteredChanges.set(this, this.filteredChanges);
+        this.indexedOperations[index] = operation;
+        if (this.filteredChanges) {
+            setOperationAtIndex(this.allFilteredChanges, allChangesIndex);
+            setOperationAtIndex(this.filteredChanges, index);
+            enqueueChangeTree(this.root, this, 'filteredChanges');
         }
         else {
-            this.allChanges.set(allChangesIndex, OPERATION.ADD);
-            this.changes.set(index, operation);
-            this.root?.changes.set(this, this.changes);
+            setOperationAtIndex(this.allChanges, allChangesIndex);
+            setOperationAtIndex(this.changes, index);
+            enqueueChangeTree(this.root, this, 'changes');
         }
     }
     getType(index) {
@@ -442,8 +500,7 @@ class ChangeTree {
         }
     }
     getChange(index) {
-        // TODO: optimize this. avoid checking against multiple instances
-        return this.changes.get(index) ?? this.filteredChanges?.get(index);
+        return this.indexedOperations[index];
     }
     //
     // used during `.encode()`
@@ -467,8 +524,9 @@ class ChangeTree {
         const changeSet = (this.filteredChanges)
             ? this.filteredChanges
             : this.changes;
+        this.indexedOperations[index] = operation ?? OPERATION.DELETE;
+        setOperationAtIndex(changeSet, index);
         const previousValue = this.getValue(index);
-        changeSet.set(index, operation ?? OPERATION.DELETE);
         // remove `root` reference
         if (previousValue && previousValue[$changes]) {
             //
@@ -484,23 +542,26 @@ class ChangeTree {
             this.root?.remove(previousValue[$changes]);
         }
         //
-        // FIXME: this is looking a bit ugly (and repeated from `.change()`)
+        // FIXME: this is looking a ugly and repeated
         //
         if (this.filteredChanges) {
-            this.root?.filteredChanges.set(this, this.filteredChanges);
-            this.allFilteredChanges.delete(allChangesIndex);
+            deleteOperationAtIndex(this.allFilteredChanges, allChangesIndex);
+            enqueueChangeTree(this.root, this, 'filteredChanges');
         }
         else {
-            this.root?.changes.set(this, this.changes);
-            this.allChanges.delete(allChangesIndex);
+            deleteOperationAtIndex(this.allChanges, allChangesIndex);
+            enqueueChangeTree(this.root, this, 'changes');
         }
     }
     endEncode() {
-        this.changes.clear();
+        this.indexedOperations = {};
+        // // clear changes
+        // this.changes.indexes = {};
+        // this.changes.operations.length = 0;
         // ArraySchema and MapSchema have a custom "encode end" method
         this.ref[$onEncodeEnd]?.();
         // Not a new instance anymore
-        delete this[$isNew];
+        this.isNew = false;
     }
     discard(discardAll = false) {
         //
@@ -509,13 +570,22 @@ class ChangeTree {
         //      REPLACE in case same key is used on next patches.
         //
         this.ref[$onEncodeEnd]?.();
-        this.changes.clear();
-        this.filteredChanges?.clear();
-        // reset operation index
-        this.currentOperationIndex = 0;
+        this.indexedOperations = {};
+        this.changes.indexes = {};
+        this.changes.operations.length = 0;
+        this.changes.queueRootIndex = undefined;
+        if (this.filteredChanges !== undefined) {
+            this.filteredChanges.indexes = {};
+            this.filteredChanges.operations.length = 0;
+            this.filteredChanges.queueRootIndex = undefined;
+        }
         if (discardAll) {
-            this.allChanges.clear();
-            this.allFilteredChanges?.clear();
+            this.allChanges.indexes = {};
+            this.allChanges.operations.length = 0;
+            if (this.allFilteredChanges !== undefined) {
+                this.allFilteredChanges.indexes = {};
+                this.allFilteredChanges.operations.length = 0;
+            }
             // remove children references
             this.forEachChild((changeTree, _) => this.root?.remove(changeTree));
         }
@@ -524,12 +594,13 @@ class ChangeTree {
      * Recursively discard all changes from this, and child structures.
      */
     discardAll() {
-        this.changes.forEach((_, fieldIndex) => {
-            const value = this.getValue(fieldIndex);
+        const keys = Object.keys(this.indexedOperations);
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const value = this.getValue(Number(keys[i]));
             if (value && value[$changes]) {
                 value[$changes].discardAll();
             }
-        });
+        }
         this.discard();
     }
     ensureRefId() {
@@ -540,42 +611,48 @@ class ChangeTree {
         this.refId = this.root.getNextUniqueId();
     }
     get changed() {
-        return this.changes.size > 0;
+        return (Object.entries(this.indexedOperations).length > 0);
     }
     checkIsFiltered(metadata, parent, parentIndex) {
         // Detect if current structure has "filters" declared
-        this.isPartiallyFiltered = metadata?.[-2] !== undefined;
+        this.isPartiallyFiltered = metadata?.[$viewFieldIndexes] !== undefined;
         if (this.isPartiallyFiltered) {
-            this.filteredChanges = this.filteredChanges || new Map();
-            this.allFilteredChanges = this.allFilteredChanges || new Map();
+            this.filteredChanges = this.filteredChanges || { indexes: {}, operations: [] };
+            this.allFilteredChanges = this.allFilteredChanges || { indexes: {}, operations: [] };
         }
-        if (parent) {
-            if (!Metadata.isValidInstance(parent)) {
-                const parentChangeTree = parent[$changes];
-                parent = parentChangeTree.parent;
-                parentIndex = parentChangeTree.parentIndex;
-            }
-            const parentMetadata = parent?.constructor?.[Symbol.metadata];
-            this.isFiltered = (parent && parentMetadata?.[-2]?.includes(parentIndex));
-            //
-            // TODO: refactor this!
-            //
-            //      swapping `changes` and `filteredChanges` is required here
-            //      because "isFiltered" may not be imedialely available on `change()`
-            //
-            if (this.isFiltered) {
-                this.filteredChanges = new Map();
-                this.allFilteredChanges = new Map();
-                if (this.changes.size > 0) {
-                    // swap changes reference
-                    const changes = this.changes;
-                    this.changes = this.filteredChanges;
-                    this.filteredChanges = changes;
-                    // swap "all changes" reference
-                    const allFilteredChanges = this.allFilteredChanges;
-                    this.allFilteredChanges = this.allChanges;
-                    this.allChanges = allFilteredChanges;
-                }
+        // skip if parent is not set
+        if (!parent) {
+            return;
+        }
+        if (!Metadata.isValidInstance(parent)) {
+            const parentChangeTree = parent[$changes];
+            parent = parentChangeTree.parent;
+            parentIndex = parentChangeTree.parentIndex;
+        }
+        const parentMetadata = parent.constructor?.[Symbol.metadata];
+        this.isFiltered = parentMetadata?.[$viewFieldIndexes]?.includes(parentIndex);
+        //
+        // TODO: refactor this!
+        //
+        //      swapping `changes` and `filteredChanges` is required here
+        //      because "isFiltered" may not be imedialely available on `change()`
+        //
+        if (this.isFiltered) {
+            this.filteredChanges = { indexes: {}, operations: [] };
+            this.allFilteredChanges = { indexes: {}, operations: [] };
+            if (this.changes.operations.length > 0) {
+                // swap changes reference
+                const changes = this.changes;
+                this.changes = this.filteredChanges;
+                this.filteredChanges = changes;
+                // swap "all changes" reference
+                const allFilteredChanges = this.allFilteredChanges;
+                this.allFilteredChanges = this.allChanges;
+                this.allChanges = allFilteredChanges;
+                // console.log("SWAP =>", {
+                //     "this.allFilteredChanges": this.allFilteredChanges,
+                //     "this.allChanges": this.allChanges
+                // })
             }
         }
     }
@@ -644,21 +721,24 @@ function utf8Write(view, str, it) {
             view[it.offset++] = c;
         }
         else if (c < 0x800) {
-            view[it.offset++] = 0xc0 | (c >> 6);
-            view[it.offset++] = 0x80 | (c & 0x3f);
+            view[it.offset] = 0xc0 | (c >> 6);
+            view[it.offset + 1] = 0x80 | (c & 0x3f);
+            it.offset += 2;
         }
         else if (c < 0xd800 || c >= 0xe000) {
-            view[it.offset++] = 0xe0 | (c >> 12);
-            view[it.offset++] = 0x80 | (c >> 6 & 0x3f);
-            view[it.offset++] = 0x80 | (c & 0x3f);
+            view[it.offset] = 0xe0 | (c >> 12);
+            view[it.offset + 1] = 0x80 | (c >> 6 & 0x3f);
+            view[it.offset + 2] = 0x80 | (c & 0x3f);
+            it.offset += 3;
         }
         else {
             i++;
             c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
-            view[it.offset++] = 0xf0 | (c >> 18);
-            view[it.offset++] = 0x80 | (c >> 12 & 0x3f);
-            view[it.offset++] = 0x80 | (c >> 6 & 0x3f);
-            view[it.offset++] = 0x80 | (c & 0x3f);
+            view[it.offset] = 0xf0 | (c >> 18);
+            view[it.offset + 1] = 0x80 | (c >> 12 & 0x3f);
+            view[it.offset + 2] = 0x80 | (c >> 6 & 0x3f);
+            view[it.offset + 3] = 0x80 | (c & 0x3f);
+            it.offset += 4;
         }
     }
 }
@@ -887,7 +967,7 @@ function encodeValue(encoder, bytes, type, value, operation, it) {
  * Used for Schema instances.
  * @private
  */
-const encodeSchemaOperation = function (encoder, bytes, changeTree, index, operation, it) {
+const encodeSchemaOperation = function (encoder, bytes, changeTree, index, operation, it, _, __, metadata) {
     // "compress" field index + operation
     bytes[it.offset++] = (index | operation) & 255;
     // Do not encode value for DELETE operations
@@ -895,7 +975,7 @@ const encodeSchemaOperation = function (encoder, bytes, changeTree, index, opera
         return;
     }
     const ref = changeTree.ref;
-    const metadata = ref.constructor[Symbol.metadata];
+    // const metadata: Metadata = ref.constructor[Symbol.metadata];
     const field = metadata[index];
     // TODO: inline this function call small performance gain
     encodeValue(encoder, bytes, metadata[index].type, ref[field.name], operation, it);
@@ -1590,6 +1670,7 @@ class ArraySchema {
         const proxy = new Proxy(this, {
             get: (obj, prop) => {
                 if (typeof (prop) !== "symbol" &&
+                    // FIXME: d8 accuses this as low performance
                     !isNaN(prop) // https://stackoverflow.com/a/175787/892698
                 ) {
                     return this.items[prop];
@@ -1607,7 +1688,7 @@ class ArraySchema {
                         if (setValue[$changes]) {
                             assertInstanceType(setValue, obj[$childType], obj, key);
                             if (obj.items[key] !== undefined) {
-                                if (setValue[$changes][$isNew]) {
+                                if (setValue[$changes].isNew) {
                                     this[$changes].indexedOperation(Number(key), OPERATION.MOVE_AND_ADD);
                                 }
                                 else {
@@ -1619,7 +1700,7 @@ class ArraySchema {
                                     }
                                 }
                             }
-                            else if (setValue[$changes][$isNew]) {
+                            else if (setValue[$changes].isNew) {
                                 this[$changes].indexedOperation(Number(key), OPERATION.ADD);
                             }
                         }
@@ -1653,7 +1734,9 @@ class ArraySchema {
         });
         this[$changes] = new ChangeTree(proxy);
         this[$changes].indexes = {};
-        this.push.apply(this, items);
+        if (items.length > 0) {
+            this.push(...items);
+        }
         return proxy;
     }
     set length(newLength) {
@@ -1672,15 +1755,18 @@ class ArraySchema {
     }
     push(...values) {
         let length = this.tmpItems.length;
-        values.forEach((value, i) => {
-            // skip null values
+        const changeTree = this[$changes];
+        // values.forEach((value, i) => {
+        for (let i = 0, l = values.length; i < values.length; i++, length++) {
+            const value = values[i];
             if (value === undefined || value === null) {
+                // skip null values
                 return;
             }
             else if (typeof (value) === "object" && this[$childType]) {
                 assertInstanceType(value, this[$childType], this, i);
+                // TODO: move value[$changes]?.setParent() to this block.
             }
-            const changeTree = this[$changes];
             changeTree.indexedOperation(length, OPERATION.ADD, this.items.length);
             this.items.push(value);
             this.tmpItems.push(value);
@@ -1689,8 +1775,9 @@ class ArraySchema {
             // (to avoid encoding "refId" operations before parent's "ADD" operation)
             //
             value[$changes]?.setParent(this, changeTree.root, length);
-            length++;
-        });
+        }
+        //     length++;
+        // });
         return length;
     }
     /**
@@ -1711,6 +1798,7 @@ class ArraySchema {
         }
         this[$changes].delete(index, undefined, this.items.length - 1);
         // this.tmpItems[index] = undefined;
+        // this.tmpItems.pop();
         this.deletedIndexes[index] = true;
         return this.items.pop();
     }
@@ -1775,9 +1863,12 @@ class ArraySchema {
             //
             // TODO: do not use [$changes] at decoding time.
             //
-            changeTree.root?.changes.delete(changeTree);
-            changeTree.root?.allChanges.delete(changeTree);
-            changeTree.root?.allFilteredChanges.delete(changeTree);
+            const root = changeTree.root;
+            if (root !== undefined) {
+                root.removeChangeFromChangeSet("changes", changeTree);
+                root.removeChangeFromChangeSet("allChanges", changeTree);
+                root.removeChangeFromChangeSet("allFilteredChanges", changeTree);
+            }
         });
         changeTree.discard(true);
         changeTree.operation(OPERATION.CLEAR);
@@ -1821,6 +1912,7 @@ class ArraySchema {
         const changeTree = this[$changes];
         changeTree.delete(index);
         changeTree.shiftAllChangeIndexes(-1, index);
+        // this.deletedIndexes[index] = true;
         return this.items.shift();
     }
     /**
@@ -1901,10 +1993,12 @@ class ArraySchema {
         changeTree.shiftChangeIndexes(items.length);
         // new index
         if (changeTree.isFiltered) {
-            changeTree.filteredChanges.set(this.items.length, OPERATION.ADD);
+            setOperationAtIndex(changeTree.filteredChanges, this.items.length);
+            // changeTree.filteredChanges[this.items.length] = OPERATION.ADD;
         }
         else {
-            changeTree.allChanges.set(this.items.length, OPERATION.ADD);
+            setOperationAtIndex(changeTree.allChanges, this.items.length);
+            // changeTree.allChanges[this.items.length] = OPERATION.ADD;
         }
         // FIXME: should we use OPERATION.MOVE here instead?
         items.forEach((_, index) => {
@@ -2245,7 +2339,7 @@ class MapSchema {
         const isReplace = typeof (changeTree.indexes[key]) !== "undefined";
         const index = (isReplace)
             ? changeTree.indexes[key]
-            : changeTree.indexes[-1] ?? 0;
+            : changeTree.indexes[$numFields] ?? 0;
         let operation = (isReplace)
             ? OPERATION.REPLACE
             : OPERATION.ADD;
@@ -2257,7 +2351,7 @@ class MapSchema {
         if (!isReplace) {
             this.$indexes.set(index, key);
             changeTree.indexes[key] = index;
-            changeTree.indexes[-1] = index + 1;
+            changeTree.indexes[$numFields] = index + 1;
         }
         else if (!isRef &&
             this.$items.get(key) === value) {
@@ -2332,8 +2426,11 @@ class MapSchema {
     }
     [$onEncodeEnd]() {
         const changeTree = this[$changes];
-        const changes = changeTree.changes.entries();
-        for (const [fieldIndex, operation] of changes) {
+        const keys = Object.keys(changeTree.indexedOperations);
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const fieldIndex = Number(key);
+            const operation = changeTree.indexedOperations[key];
             if (operation === OPERATION.DELETE) {
                 const index = this[$getByIndex](fieldIndex);
                 delete changeTree.indexes[index];
@@ -2436,7 +2533,7 @@ class TypeContext {
         });
         const metadata = (klass[Symbol.metadata] ??= {});
         // if any schema/field has filters, mark "context" as having filters.
-        if (metadata[-2]) {
+        if (metadata[$viewFieldIndexes]) {
             this.hasFilters = true;
         }
         if (parentFieldViewTag !== undefined) {
@@ -2499,8 +2596,8 @@ const DEFAULT_VIEW_TAG = -1;
 //         // detect index for this field, considering inheritance
 //         //
 //         const parent = Object.getPrototypeOf(context.metadata);
-//         let fieldIndex: number = context.metadata[-1] // current structure already has fields defined
-//             ?? (parent && parent[-1]) // parent structure has fields defined
+//         let fieldIndex: number = context.metadata[$numFields] // current structure already has fields defined
+//             ?? (parent && parent[$numFields]) // parent structure has fields defined
 //             ?? -1; // no fields defined
 //         fieldIndex++;
 //         if (
@@ -2629,8 +2726,8 @@ function view(tag = DEFAULT_VIEW_TAG) {
         //     //
         //     metadata[fieldIndex] = {
         //         type: undefined,
-        //         index: (metadata[-1] // current structure already has fields defined
-        //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+        //         index: (metadata[$numFields] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
         //             ?? -1) + 1 // no fields defined
         //     }
         // }
@@ -2673,8 +2770,8 @@ function type(type, options) {
             //
             // detect index for this field, considering inheritance
             //
-            fieldIndex = metadata[-1] // current structure already has fields defined
-                ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+            fieldIndex = metadata[$numFields] // current structure already has fields defined
+                ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
                 ?? -1; // no fields defined
             fieldIndex++;
         }
@@ -2701,7 +2798,7 @@ function getPropertyDescriptor(fieldCached, fieldIndex, type, complexTypeKlass)
     return {
         get: function () { return this[fieldCached]; },
         set: function (value) {
-            const previousValue = this[fieldCached] || undefined;
+            const previousValue = this[fieldCached] ?? undefined;
             // skip if value is the same as cached.
             if (value === previousValue) {
                 return;
@@ -2773,8 +2870,8 @@ function deprecated(throws = true) {
         //     //
         //     metadata[field] = {
         //         type: undefined,
-        //         index: (metadata[-1] // current structure already has fields defined
-        //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+        //         index: (metadata[$numFields] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
         //             ?? -1) + 1 // no fields defined
         //     }
         // }
@@ -2812,15 +2909,18 @@ function dumpChanges(schema) {
         ops: {},
         refs: []
     };
-    $root.changes.forEach((operations, changeTree) => {
+    // for (const refId in $root.changes) {
+    $root.changes.forEach(changeTree => {
+        const changes = changeTree.indexedOperations;
         dump.refs.push(`refId#${changeTree.refId}`);
-        operations.forEach((op, index) => {
+        for (const index in changes) {
+            const op = changes[index];
             const opName = OPERATION[op];
             if (!dump.ops[opName]) {
                 dump.ops[opName] = 0;
             }
             dump.ops[OPERATION[op]]++;
-        });
+        }
     });
     return dump;
 }
@@ -2846,6 +2946,7 @@ var _a$2, _b$2;
 class Schema {
     static { this[_a$2] = encodeSchemaOperation; }
     static { this[_b$2] = decodeSchemaOperation; }
+    // public [$changes]: ChangeTree;
     /**
      * Assign the property descriptors required to track changes on this instance.
      * @param instance
@@ -2905,12 +3006,7 @@ class Schema {
         // inline
         // Schema.initialize(this);
         //
-        Object.defineProperty(this, $changes, {
-            value: new ChangeTree(this),
-            enumerable: false,
-            writable: true
-        });
-        Object.defineProperties(this, this.constructor[Symbol.metadata]?.[$descriptors] || {});
+        Schema.initialize(this);
         //
         // Assign initial values
         //
@@ -2984,7 +3080,7 @@ class Schema {
         const changeTree = ref[$changes];
         const contents = (jsonContents) ? ` - ${JSON.stringify(ref.toJSON())}` : "";
         let output = "";
-        output += `${getIndent(level)}${ref.constructor.name} (${ref[$changes].refId})${contents}\n`;
+        output += `${getIndent(level)}${ref.constructor.name} (refId: ${ref[$changes].refId})${contents}\n`;
         changeTree.forEachChild((childChangeTree) => output += this.debugRefIds(childChangeTree.ref, jsonContents, level + 1));
         return output;
     }
@@ -3002,18 +3098,26 @@ class Schema {
         const changeSetName = (isEncodeAll) ? "allChanges" : "changes";
         let output = `${instance.constructor.name} (${changeTree.refId}) -> .${changeSetName}:\n`;
         function dumpChangeSet(changeSet) {
-            Array.from(changeSet)
-                .sort((a, b) => a[0] - b[0])
-                .forEach(([index, operation]) => output += `- [${index}]: ${OPERATION[operation]} (${JSON.stringify(changeTree.getValue(index, isEncodeAll))})\n`);
+            changeSet.operations
+                .filter(op => op)
+                .forEach((index) => {
+                const operation = changeTree.indexedOperations[index];
+                console.log({ index, operation });
+                output += `- [${index}]: ${OPERATION[operation]} (${JSON.stringify(changeTree.getValue(Number(index), isEncodeAll))})\n`;
+            });
         }
         dumpChangeSet(changeSet);
         // display filtered changes
-        if (!isEncodeAll && changeTree.filteredChanges?.size > 0) {
+        if (!isEncodeAll &&
+            changeTree.filteredChanges &&
+            (changeTree.filteredChanges.operations).filter(op => op).length > 0) {
             output += `${instance.constructor.name} (${changeTree.refId}) -> .filteredChanges:\n`;
             dumpChangeSet(changeTree.filteredChanges);
         }
         // display filtered changes
-        if (isEncodeAll && changeTree.allFilteredChanges?.size > 0) {
+        if (isEncodeAll &&
+            changeTree.allFilteredChanges &&
+            (changeTree.allFilteredChanges.operations).filter(op => op).length > 0) {
             output += `${instance.constructor.name} (${changeTree.refId}) -> .allFilteredChanges:\n`;
             dumpChangeSet(changeTree.allFilteredChanges);
         }
@@ -3022,10 +3126,12 @@ class Schema {
     static debugChangesDeep(ref, changeSetName = "changes") {
         let output = "";
         const rootChangeTree = ref[$changes];
+        const root = rootChangeTree.root;
         const changeTrees = new Map();
         let totalInstances = 0;
         let totalOperations = 0;
-        for (const [changeTree, changes] of (rootChangeTree.root[changeSetName].entries())) {
+        for (const [refId, changes] of Object.entries(root[changeSetName])) {
+            const changeTree = root.changeTrees[refId];
             let includeChangeTree = false;
             let parentChangeTrees = [];
             let parentChangeTree = changeTree.parent?.[$changes];
@@ -3044,7 +3150,7 @@ class Schema {
             }
             if (includeChangeTree) {
                 totalInstances += 1;
-                totalOperations += changes.size;
+                totalOperations += Object.keys(changes).length;
                 changeTrees.set(changeTree, parentChangeTrees.reverse());
             }
         }
@@ -3062,12 +3168,13 @@ class Schema {
                     visitedParents.add(parentChangeTree);
                 }
             });
-            const changes = changeTree.changes;
+            const changes = changeTree.indexedOperations;
             const level = parentChangeTrees.length;
             const indent = getIndent(level);
             const parentIndex = (level > 0) ? `(${changeTree.parentIndex}) ` : "";
-            output += `${indent}${parentIndex}${changeTree.ref.constructor.name} (refId: ${changeTree.refId}) - changes: ${changes.size}\n`;
-            for (const [index, operation] of changes) {
+            output += `${indent}${parentIndex}${changeTree.ref.constructor.name} (refId: ${changeTree.refId}) - changes: ${Object.keys(changes).length}\n`;
+            for (const index in changes) {
+                const operation = changes[index];
                 output += `${getIndent(level + 1)}${OPERATION[operation]}: ${index}\n`;
             }
         }
@@ -3428,59 +3535,90 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+function spliceOne(arr, index) {
+    // manually splice an array
+    if (index === -1 || index >= arr.length) {
+        return false;
+    }
+    const len = arr.length - 1;
+    for (let i = index; i < len; i++) {
+        arr[i] = arr[i + 1];
+    }
+    arr.length = len;
+    return true;
+}
+
 class Root {
     constructor(types) {
         this.types = types;
         this.nextUniqueId = 0;
-        this.refCount = new WeakMap();
+        this.refCount = {};
+        this.changeTrees = {};
         // all changes
-        this.allChanges = new Map();
-        this.allFilteredChanges = new Map();
+        this.allChanges = [];
+        this.allFilteredChanges = []; // TODO: do not initialize it if filters are not used
         // pending changes to be encoded
-        this.changes = new Map();
-        this.filteredChanges = new Map();
+        this.changes = [];
+        this.filteredChanges = []; // TODO: do not initialize it if filters are not used
     }
     getNextUniqueId() {
         return this.nextUniqueId++;
     }
     add(changeTree) {
-        const previousRefCount = this.refCount.get(changeTree);
+        // FIXME: move implementation of `ensureRefId` to `Root` class
+        changeTree.ensureRefId();
+        const isNewChangeTree = (this.changeTrees[changeTree.refId] === undefined);
+        if (isNewChangeTree) {
+            this.changeTrees[changeTree.refId] = changeTree;
+        }
+        const previousRefCount = this.refCount[changeTree.refId];
         if (previousRefCount === 0) {
             //
             // When a ChangeTree is re-added, it means that it was previously removed.
             // We need to re-add all changes to the `changes` map.
             //
-            changeTree.allChanges.forEach((operation, index) => {
-                changeTree.changes.set(index, operation);
-            });
+            const ops = changeTree.allChanges.operations;
+            let len = ops.length;
+            while (len--) {
+                changeTree.indexedOperations[ops[len]] = OPERATION.ADD;
+                setOperationAtIndex(changeTree.changes, len);
+            }
         }
-        const refCount = (previousRefCount || 0) + 1;
-        this.refCount.set(changeTree, refCount);
-        return refCount;
+        this.refCount[changeTree.refId] = (previousRefCount || 0) + 1;
+        return isNewChangeTree;
     }
     remove(changeTree) {
-        const refCount = (this.refCount.get(changeTree)) - 1;
+        const refCount = (this.refCount[changeTree.refId]) - 1;
         if (refCount <= 0) {
             //
             // Only remove "root" reference if it's the last reference
             //
             changeTree.root = undefined;
-            this.allChanges.delete(changeTree);
-            this.changes.delete(changeTree);
+            delete this.changeTrees[changeTree.refId];
+            this.removeChangeFromChangeSet("allChanges", changeTree);
+            this.removeChangeFromChangeSet("changes", changeTree);
             if (changeTree.isFiltered || changeTree.isPartiallyFiltered) {
-                this.allFilteredChanges.delete(changeTree);
-                this.filteredChanges.delete(changeTree);
+                this.removeChangeFromChangeSet("allFilteredChanges", changeTree);
+                this.removeChangeFromChangeSet("filteredChanges", changeTree);
             }
-            this.refCount.set(changeTree, 0);
+            this.refCount[changeTree.refId] = 0;
         }
         else {
-            this.refCount.set(changeTree, refCount);
+            this.refCount[changeTree.refId] = refCount;
         }
         changeTree.forEachChild((child, _) => this.remove(child));
         return refCount;
     }
+    removeChangeFromChangeSet(changeSetName, changeTree) {
+        const changeSet = this[changeSetName];
+        const index = changeSet.indexOf(changeTree);
+        if (index !== -1) {
+            spliceOne(changeSet, index);
+            // changeSet[index] = undefined;
+        }
+    }
     clear() {
-        this.changes.clear();
+        this.changes.length = 0;
     }
 }
 
@@ -3504,20 +3642,26 @@ class Encoder {
         this.state = state;
         this.state[$changes].setRoot(this.root);
     }
-    encode(it = { offset: 0 }, view, buffer = this.sharedBuffer, changeTrees = this.root.changes, isEncodeAll = this.root.allChanges === changeTrees, initialOffset = it.offset // cache current offset in case we need to resize the buffer
+    encode(it = { offset: 0 }, view, buffer = this.sharedBuffer, changeSetName = "changes", isEncodeAll = changeSetName === "allChanges", initialOffset = it.offset // cache current offset in case we need to resize the buffer
     ) {
         const hasView = (view !== undefined);
         const rootChangeTree = this.state[$changes];
-        const shouldClearChanges = !isEncodeAll && !hasView;
-        for (const [changeTree, changes] of changeTrees.entries()) {
+        const shouldDiscardChanges = !isEncodeAll && !hasView;
+        const changeTrees = this.root[changeSetName];
+        for (let i = 0, numChangeTrees = changeTrees.length; i < numChangeTrees; i++) {
+            const changeTree = changeTrees[i];
+            // // Root#removeChangeFromChangeSet() is now removing instead of setting to "undefined"
+            // if (changeTree === undefined) { continue; }
+            const operations = changeTree[changeSetName];
             const ref = changeTree.ref;
             const ctor = ref.constructor;
             const encoder = ctor[$encoder];
             const filter = ctor[$filter];
+            const metadata = ctor[Symbol.metadata];
             // try { throw new Error(); } catch (e) {
             //     // only print if not coming from Reflection.ts
             //     if (!e.stack.includes("src/Reflection.ts")) {
-            //         console.log("ChangeTree:", { ref: ref.constructor.name, });
+            //         console.log("ChangeTree:", { refId: changeTree.refId, ref: ref.constructor.name });
             //     }
             // }
             if (hasView) {
@@ -3535,7 +3679,13 @@ class Encoder {
                 buffer[it.offset++] = SWITCH_TO_STRUCTURE & 255;
                 number$1(buffer, changeTree.refId, it);
             }
-            for (const [fieldIndex, operation] of changes.entries()) {
+            for (let j = 0, numChanges = operations.operations.length; j < numChanges; j++) {
+                const fieldIndex = operations.operations[j];
+                const operation = (fieldIndex < 0)
+                    ? Math.abs(fieldIndex) // "pure" operation without fieldIndex (e.g. CLEAR, REVERSE, etc.)
+                    : (isEncodeAll)
+                        ? OPERATION.ADD
+                        : changeTree.indexedOperations[fieldIndex];
                 //
                 // first pass (encodeAll), identify "filtered" operations without encoding them
                 // they will be encoded per client, based on their view.
@@ -3543,7 +3693,7 @@ class Encoder {
                 // TODO: how can we optimize filtering out "encode all" operations?
                 // TODO: avoid checking if no view tags were defined
                 //
-                if (filter && !filter(ref, fieldIndex, view)) {
+                if (fieldIndex === undefined || operation === undefined || (filter && !filter(ref, fieldIndex, view))) {
                     // console.log("ADD AS INVISIBLE:", fieldIndex, changeTree.ref.constructor.name)
                     // view?.invisible.add(changeTree);
                     continue;
@@ -3558,16 +3708,14 @@ class Encoder {
                 //         });
                 //     }
                 // }
-                encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView);
+                // console.log("encode...", { ref: changeTree.ref.constructor.name, refId: changeTree.refId, fieldIndex, operation });
+                encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView, metadata);
+            }
+            if (shouldDiscardChanges) {
+                changeTree.discard();
+                // Not a new instance anymore
+                changeTree.isNew = false;
             }
-            // if (shouldClearChanges) {
-            //     // changeTree.endEncode();
-            //     changeTree.changes.clear();
-            //     // ArraySchema and MapSchema have a custom "encode end" method
-            //     changeTree.ref[$onEncodeEnd]?.();
-            //     // Not a new instance anymore
-            //     delete changeTree[$isNew];
-            // }
         }
         if (it.offset > buffer.byteLength) {
             const newSize = getNextPowerOf2(buffer.byteLength * 2);
@@ -3584,51 +3732,54 @@ class Encoder {
             if (buffer === this.sharedBuffer) {
                 this.sharedBuffer = buffer;
             }
-            return this.encode({ offset: initialOffset }, view, buffer, changeTrees, isEncodeAll);
+            return this.encode({ offset: initialOffset }, view, buffer, changeSetName, isEncodeAll);
         }
         else {
-            //
-            // only clear changes after making sure buffer resize is not required.
-            //
-            if (shouldClearChanges) {
-                //
-                // FIXME: avoid iterating over change trees twice.
-                //
-                this.onEndEncode(changeTrees);
-            }
+            // //
+            // // only clear changes after making sure buffer resize is not required.
+            // //
+            // if (shouldClearChanges) {
+            //     //
+            //     // FIXME: avoid iterating over change trees twice.
+            //     //
+            //     this.onEndEncode(changeTrees);
+            // }
             return buffer.subarray(0, it.offset);
         }
     }
     encodeAll(it = { offset: 0 }, buffer = this.sharedBuffer) {
-        // console.log(`\nencodeAll(), this.root.allChanges (${this.root.allChanges.size})`);
+        // console.log(`\nencodeAll(), this.root.allChanges (${(Object.keys(this.root.allChanges).length)})`);
         // this.debugChanges("allChanges");
-        return this.encode(it, undefined, buffer, this.root.allChanges, true);
+        return this.encode(it, undefined, buffer, "allChanges", true);
     }
     encodeAllView(view, sharedOffset, it, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;
-        // console.log(`\nencodeAllView(), this.root.allFilteredChanges (${this.root.allFilteredChanges.size})`);
+        // console.log(`\nencodeAllView(), this.root.allFilteredChanges (${(Object.keys(this.root.allFilteredChanges).length)})`);
         // this.debugChanges("allFilteredChanges");
+        // console.log("\n\nENCODE ALL FOR VIEW...\n\n")
         // try to encode "filtered" changes
-        this.encode(it, view, bytes, this.root.allFilteredChanges, true, viewOffset);
+        this.encode(it, view, bytes, "allFilteredChanges", true, viewOffset);
         return Buffer.concat([
             bytes.subarray(0, sharedOffset),
             bytes.subarray(viewOffset, it.offset)
         ]);
     }
     debugChanges(field) {
-        const changeSet = (typeof (field) === "string")
+        const rootChangeSet = (typeof (field) === "string")
             ? this.root[field]
             : field;
-        Array.from(changeSet.entries()).map((item) => {
-            const metadata = item[0].ref.constructor[Symbol.metadata];
-            console.log("->", { ref: item[0].ref.constructor.name, refId: item[0].refId, changes: item[1].size });
-            item[1].forEach((op, index) => {
+        rootChangeSet.forEach((changeTree) => {
+            const changeSet = changeTree[field];
+            const metadata = changeTree.ref.constructor[Symbol.metadata];
+            console.log("->", { ref: changeTree.ref.constructor.name, refId: changeTree.refId, changes: Object.keys(changeSet).length });
+            for (const index in changeSet) {
+                const op = changeSet[index];
                 console.log("  ->", {
                     index,
                     field: metadata?.[index],
                     op: OPERATION[op],
                 });
-            });
+            }
         });
     }
     encodeView(view, sharedOffset, it, bytes = this.sharedBuffer) {
@@ -3638,23 +3789,31 @@ class Encoder {
         // console.log(`\nencodeView(), this.root.filteredChanges (${this.root.filteredChanges.size})`);
         // this.debugChanges("filteredChanges");
         // encode visibility changes (add/remove for this view)
-        const viewChangesIterator = view.changes.entries();
-        for (const [changeTree, changes] of viewChangesIterator) {
-            if (changes.size === 0) {
-                // FIXME: avoid having empty changes if no changes were made
-                // console.log("changes.size === 0", changeTree.ref.constructor.name);
+        const refIds = Object.keys(view.changes);
+        // console.log("ENCODE VIEW:", refIds);
+        for (let i = 0, numRefIds = refIds.length; i < numRefIds; i++) {
+            const refId = refIds[i];
+            const changes = view.changes[refId];
+            const changeTree = this.root.changeTrees[refId];
+            if (changeTree === undefined ||
+                Object.keys(changes).length === 0 // FIXME: avoid having empty changes if no changes were made
+            ) {
+                // console.log("changes.size === 0, skip", changeTree.ref.constructor.name);
                 continue;
             }
             const ref = changeTree.ref;
-            const ctor = ref['constructor'];
+            const ctor = ref.constructor;
             const encoder = ctor[$encoder];
+            const metadata = ctor[Symbol.metadata];
             bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
             number$1(bytes, changeTree.refId, it);
-            const changesIterator = changes.entries();
-            for (const [fieldIndex, operation] of changesIterator) {
+            const keys = Object.keys(changes);
+            for (let i = 0, numChanges = keys.length; i < numChanges; i++) {
+                const key = keys[i];
+                const operation = changes[key];
                 // isEncodeAll = false
                 // hasView = true
-                encoder(this, bytes, changeTree, fieldIndex, operation, it, false, true);
+                encoder(this, bytes, changeTree, Number(key), operation, it, false, true, metadata);
             }
         }
         //
@@ -3662,35 +3821,46 @@ class Encoder {
         // (to allow re-using StateView's for multiple clients)
         //
         // clear "view" changes after encoding
-        view.changes.clear();
+        view.changes = {};
+        // console.log("FILTERED CHANGES:", this.root.filteredChanges);
         // try to encode "filtered" changes
-        this.encode(it, view, bytes, this.root.filteredChanges, false, viewOffset);
+        this.encode(it, view, bytes, "filteredChanges", false, viewOffset);
         return Buffer.concat([
             bytes.subarray(0, sharedOffset),
             bytes.subarray(viewOffset, it.offset)
         ]);
     }
     onEndEncode(changeTrees = this.root.changes) {
-        const changeTreesIterator = changeTrees.entries();
-        for (const [changeTree, _] of changeTreesIterator) {
-            changeTree.endEncode();
-            // changeTree.changes.clear();
-            // // ArraySchema and MapSchema have a custom "encode end" method
-            // changeTree.ref[$onEncodeEnd]?.();
-            // // Not a new instance anymore
-            // delete changeTree[$isNew];
-        }
+        // changeTrees.forEach(function(changeTree) {
+        //     changeTree.endEncode();
+        // });
+        // for (const refId in changeTrees) {
+        //     const changeTree = this.root.changeTrees[refId];
+        //     changeTree.endEncode();
+        //     // changeTree.changes.clear();
+        //     // // ArraySchema and MapSchema have a custom "encode end" method
+        //     // changeTree.ref[$onEncodeEnd]?.();
+        //     // // Not a new instance anymore
+        //     // delete changeTree[$isNew];
+        // }
     }
     discardChanges() {
+        // console.log("DISCARD CHANGES!");
         // discard shared changes
-        if (this.root.changes.size > 0) {
-            this.onEndEncode(this.root.changes);
-            this.root.changes.clear();
+        let length = this.root.changes.length;
+        if (length > 0) {
+            while (length--) {
+                this.root.changes[length]?.endEncode();
+            }
+            this.root.changes.length = 0;
         }
         // discard filtered changes
-        if (this.root.filteredChanges.size > 0) {
-            this.onEndEncode(this.root.filteredChanges);
-            this.root.filteredChanges.clear();
+        length = this.root.filteredChanges.length;
+        if (length > 0) {
+            while (length--) {
+                this.root.filteredChanges[length]?.endEncode();
+            }
+            this.root.filteredChanges.length = 0;
         }
     }
     tryEncodeTypeId(bytes, baseType, targetType, it) {
@@ -3703,19 +3873,6 @@ class Encoder {
     }
 }
 
-function spliceOne(arr, index) {
-    // manually splice an array
-    if (index === -1 || index >= arr.length) {
-        return false;
-    }
-    const len = arr.length - 1;
-    for (let i = index; i < len; i++) {
-        arr[i] = arr[i + 1];
-    }
-    arr.length = len;
-    return true;
-}
-
 class DecodingWarning extends Error {
     constructor(message) {
         super(message);
@@ -3877,7 +4034,7 @@ class Decoder {
                 }
                 ref[$onDecodeEnd]?.();
                 ref = nextRef;
-                decoder = ref['constructor'][$decoder];
+                decoder = ref.constructor[$decoder];
                 continue;
             }
             const result = decoder(this, bytes, it, ref, allChanges);
@@ -4354,7 +4511,7 @@ class StateView {
          * Manual "ADD" operations for changes per ChangeTree, specific to this view.
          * (This is used to force encoding a property, even if it was not changed)
          */
-        this.changes = new Map();
+        this.changes = {};
     }
     // TODO: allow to set multiple tags at once
     add(obj, tag = DEFAULT_VIEW_TAG, checkIncludeParent = true) {
@@ -4376,10 +4533,10 @@ class StateView {
         // TODO: when adding an item of a MapSchema, the changes may not
         // be set (only the parent's changes are set)
         //
-        let changes = this.changes.get(changeTree);
+        let changes = this.changes[changeTree.refId];
         if (changes === undefined) {
-            changes = new Map();
-            this.changes.set(changeTree, changes);
+            changes = {};
+            this.changes[changeTree.refId] = changes;
         }
         // set tag
         if (tag !== DEFAULT_VIEW_TAG) {
@@ -4396,9 +4553,9 @@ class StateView {
             }
             tags.add(tag);
             // Ref: add tagged properties
-            metadata?.[-3]?.[tag]?.forEach((index) => {
+            metadata?.[$fieldIndexesByViewTag]?.[tag]?.forEach((index) => {
                 if (changeTree.getChange(index) !== OPERATION.DELETE) {
-                    changes.set(index, OPERATION.ADD);
+                    changes[index] = OPERATION.ADD;
                 }
             });
         }
@@ -4407,16 +4564,21 @@ class StateView {
             const changeSet = (changeTree.isFiltered || changeTree.isPartiallyFiltered)
                 ? changeTree.allFilteredChanges
                 : changeTree.allChanges;
-            changeSet.forEach((op, index) => {
+            for (let i = 0, len = changeSet.operations.length; i < len; i++) {
+                const index = changeSet.operations[i];
+                if (index === undefined) {
+                    continue;
+                } // skip "undefined" indexes
+                const op = changeTree.indexedOperations[index];
                 const tagAtIndex = metadata?.[index].tag;
                 if ((isInvisible || // if "invisible", include all
                     tagAtIndex === undefined || // "all change" with no tag
                     tagAtIndex === tag // tagged property
                 ) &&
                     op !== OPERATION.DELETE) {
-                    changes.set(index, op);
+                    changes[index] = op;
                 }
-            });
+            }
         }
         // Add children of this ChangeTree to this view
         changeTree.forEachChild((change, index) => {
@@ -4442,10 +4604,10 @@ class StateView {
         }
         // add parent's tag properties
         if (changeTree.getChange(parentIndex) !== OPERATION.DELETE) {
-            let changes = this.changes.get(changeTree);
+            let changes = this.changes[changeTree.refId];
             if (changes === undefined) {
-                changes = new Map();
-                this.changes.set(changeTree, changes);
+                changes = {};
+                this.changes[changeTree.refId] = changes;
             }
             if (!this.tags) {
                 this.tags = new WeakMap();
@@ -4459,7 +4621,7 @@ class StateView {
                 tags = this.tags.get(changeTree);
             }
             tags.add(tag);
-            changes.set(parentIndex, OPERATION.ADD);
+            changes[parentIndex] = OPERATION.ADD;
         }
     }
     remove(obj, tag = DEFAULT_VIEW_TAG) {
@@ -4471,32 +4633,32 @@ class StateView {
         this.items.delete(changeTree);
         const ref = changeTree.ref;
         const metadata = ref.constructor[Symbol.metadata];
-        let changes = this.changes.get(changeTree);
+        let changes = this.changes[changeTree.refId];
         if (changes === undefined) {
-            changes = new Map();
-            this.changes.set(changeTree, changes);
+            changes = {};
+            this.changes[changeTree.refId] = changes;
         }
         if (tag === DEFAULT_VIEW_TAG) {
             // parent is collection (Map/Array)
             const parent = changeTree.parent;
             if (!Metadata.isValidInstance(parent)) {
                 const parentChangeTree = parent[$changes];
-                let changes = this.changes.get(parentChangeTree);
+                let changes = this.changes[parentChangeTree.refId];
                 if (changes === undefined) {
-                    changes = new Map();
-                    this.changes.set(parentChangeTree, changes);
+                    changes = {};
+                    this.changes[parentChangeTree.refId] = changes;
                 }
                 // DELETE / DELETE BY REF ID
-                changes.set(changeTree.parentIndex, OPERATION.DELETE);
+                changes[changeTree.parentIndex] = OPERATION.DELETE;
             }
             else {
                 // delete all "tagged" properties.
-                metadata[-2].forEach((index) => changes.set(index, OPERATION.DELETE));
+                metadata[$viewFieldIndexes].forEach((index) => changes[index] = OPERATION.DELETE);
             }
         }
         else {
             // delete only tagged properties
-            metadata[-3][tag].forEach((index) => changes.set(index, OPERATION.DELETE));
+            metadata[$fieldIndexesByViewTag][tag].forEach((index) => changes[index] = OPERATION.DELETE);
         }
         // remove tag
         if (this.tags && this.tags.has(changeTree)) {