@colyseus/schema 3.0.0-alpha.30 → 3.0.0-alpha.32

package/build/cjs/index.js

@@ -36,6 +36,7 @@ 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
  */
@@ -71,34 +72,67 @@ function getType(identifier) {
 }
 
 const Metadata = {
-    addField(metadata, index, field, type, descriptor) {
+    addField(metadata, index, name, type, descriptor) {
         if (index > 64) {
-            throw new Error(`Can't define field '${field}'.\nSchema instances may only have up to 64 fields.`);
+            throw new Error(`Can't define field '${name}'.\nSchema instances may only have up to 64 fields.`);
         }
-        metadata[field] = Object.assign(metadata[field] || {}, // avoid overwriting previous field metadata (@owned / @deprecated)
+        metadata[index] = Object.assign(metadata[index] || {}, // avoid overwriting previous field metadata (@owned / @deprecated)
         {
             type: (Array.isArray(type))
                 ? { array: type[0] }
                 : type,
             index,
-            descriptor,
+            name,
         });
+        // create "descriptors" map
+        metadata[$descriptors] ??= {};
+        if (descriptor) {
+            // for encoder
+            metadata[$descriptors][name] = descriptor;
+            metadata[$descriptors][`_${name}`] = {
+                value: undefined,
+                writable: true,
+                enumerable: false,
+                configurable: true,
+            };
+        }
+        else {
+            // for decoder
+            metadata[$descriptors][name] = {
+                value: undefined,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            };
+        }
         // map -1 as last field index
         Object.defineProperty(metadata, -1, {
             value: index,
             enumerable: false,
             configurable: true
         });
-        // map index => field name (non enumerable)
-        Object.defineProperty(metadata, index, {
-            value: field,
+        // map field name => index (non enumerable)
+        Object.defineProperty(metadata, name, {
+            value: index,
             enumerable: false,
             configurable: true,
         });
+        // if child Ref/complex type, add to -4
+        if (typeof (metadata[index].type) !== "string") {
+            if (metadata[-4] === undefined) {
+                Object.defineProperty(metadata, -4, {
+                    value: [],
+                    enumerable: false,
+                    configurable: true,
+                });
+            }
+            metadata[-4].push(index);
+        }
     },
     setTag(metadata, fieldName, tag) {
+        const index = metadata[fieldName];
+        const field = metadata[index];
         // add 'tag' to the field
-        const field = metadata[fieldName];
         field.tag = tag;
         if (!metadata[-2]) {
             // -2: all field indexes with "view" tag
@@ -114,20 +148,14 @@ const Metadata = {
                 configurable: true
             });
         }
-        metadata[-2].push(field.index);
+        metadata[-2].push(index);
         if (!metadata[-3][tag]) {
             metadata[-3][tag] = [];
         }
-        metadata[-3][tag].push(field.index);
+        metadata[-3][tag].push(index);
     },
     setFields(target, fields) {
         const metadata = (target.prototype.constructor[Symbol.metadata] ??= {});
-        // target[$track] = function (changeTree, index: number, operation: OPERATION = OPERATION.ADD) {
-        //     changeTree.change(index, operation, encodeSchemaOperation);
-        // };
-        // target[$encoder] = encodeSchemaOperation;
-        // target[$decoder] = decodeSchemaOperation;
-        // if (!target.prototype.toJSON) { target.prototype.toJSON = Schema.prototype.toJSON; }
         let index = 0;
         for (const field in fields) {
             const type = fields[field];
@@ -135,7 +163,7 @@ const Metadata = {
             const complexTypeKlass = (Array.isArray(type))
                 ? getType("array")
                 : (typeof (Object.keys(type)[0]) === "string") && getType(Object.keys(type)[0]);
-            Metadata.addField(metadata, index, field, type, getPropertyDescriptor(`_${field}`, index, type, complexTypeKlass, metadata, field));
+            Metadata.addField(metadata, index, field, type, getPropertyDescriptor(`_${field}`, index, type, complexTypeKlass));
             index++;
         }
     },
@@ -164,8 +192,9 @@ const Metadata = {
                 // assign parent metadata to current
                 Object.assign(metadata, parentMetadata);
                 for (let i = 0; i <= parentMetadata[-1]; i++) {
-                    Object.defineProperty(metadata, i, {
-                        value: parentMetadata[i],
+                    const fieldName = parentMetadata[i].name;
+                    Object.defineProperty(metadata, fieldName, {
+                        value: parentMetadata[fieldName],
                         enumerable: false,
                         configurable: true,
                     });
@@ -189,7 +218,7 @@ const Metadata = {
         const metadata = klass[Symbol.metadata];
         const fields = {};
         for (let i = 0; i <= metadata[-1]; i++) {
-            fields[metadata[i]] = metadata[metadata[i]].type;
+            fields[metadata[i].name] = metadata[i].type;
         }
         return fields;
     }
@@ -198,48 +227,59 @@ const Metadata = {
 var _a$5;
 class ChangeTree {
     static { _a$5 = $isNew; }
-    ;
     constructor(ref) {
-        this.indexes = {}; // TODO: remove this, only used by MapSchema/SetSchema/CollectionSchema (`encodeKeyValueOperation`)
+        this.isFiltered = false;
+        this.isPartiallyFiltered = false;
         this.currentOperationIndex = 0;
-        this.allChanges = new Map();
-        this.allFilteredChanges = new Map();
         this.changes = new Map();
-        this.filteredChanges = new Map();
+        this.allChanges = new Map();
         this[_a$5] = true;
         this.ref = ref;
+        //
+        // Does this structure have "filters" declared?
+        //
+        if (ref.constructor[Symbol.metadata]?.[-2]) {
+            this.allFilteredChanges = new Map();
+            this.filteredChanges = new Map();
+        }
     }
     setRoot(root) {
         this.root = root;
         this.root.add(this);
-        //
-        // At Schema initialization, the "root" structure might not be available
-        // yet, as it only does once the "Encoder" has been set up.
-        //
-        // So the "parent" may be already set without a "root".
-        //
-        this.checkIsFiltered(this.parent, this.parentIndex);
-        // unique refId for the ChangeTree.
-        this.ensureRefId();
+        const metadata = this.ref.constructor[Symbol.metadata];
+        if (this.root.types.hasFilters) {
+            //
+            // At Schema initialization, the "root" structure might not be available
+            // yet, as it only does once the "Encoder" has been set up.
+            //
+            // So the "parent" may be already set without a "root".
+            //
+            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);
+            }
+        }
         if (!this.isFiltered) {
             this.root.changes.set(this, this.changes);
+            this.root.allChanges.set(this, this.allChanges);
         }
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this.root.allFilteredChanges.set(this, this.allFilteredChanges);
-            this.root.filteredChanges.set(this, this.filteredChanges);
+        this.ensureRefId();
+        if (metadata) {
+            metadata[-4]?.forEach((index) => {
+                const field = metadata[index];
+                const value = this.ref[field.name];
+                if (value) {
+                    value[$changes].setRoot(root);
+                }
+            });
         }
-        if (!this.isFiltered) {
-            this.root.allChanges.set(this, this.allChanges);
+        else if (this.ref[$childType] && typeof (this.ref[$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            this.ref.forEach((value, key) => {
+                value[$changes].setRoot(root);
+            });
         }
-        this.forEachChild((changeTree, _) => {
-            changeTree.setRoot(root);
-        });
-        // this.allChanges.forEach((_, index) => {
-        //     const childRef = this.ref[$getByIndex](index);
-        //     if (childRef && childRef[$changes]) {
-        //         childRef[$changes].setRoot(root);
-        //     }
-        // });
     }
     setParent(parent, root, parentIndex) {
         this.parent = parent;
@@ -249,48 +289,60 @@ class ChangeTree {
             return;
         }
         root.add(this);
+        const metadata = this.ref.constructor[Symbol.metadata];
         // skip if parent is already set
-        if (root === this.root) {
-            this.forEachChild((changeTree, atIndex) => {
-                changeTree.setParent(this.ref, root, atIndex);
-            });
-            return;
+        if (root !== this.root) {
+            this.root = root;
+            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);
+                }
+            }
+            if (!this.isFiltered) {
+                this.root.changes.set(this, this.changes);
+                this.root.allChanges.set(this, this.allChanges);
+            }
+            this.ensureRefId();
         }
-        this.root = root;
-        this.checkIsFiltered(parent, parentIndex);
-        if (!this.isFiltered) {
-            this.root.changes.set(this, this.changes);
-            this.root.allChanges.set(this, this.allChanges);
+        // assign same parent on child structures
+        if (metadata) {
+            metadata[-4]?.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);
+                // }
+            });
         }
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this.root.filteredChanges.set(this, this.filteredChanges);
-            this.root.allFilteredChanges.set(this, this.filteredChanges);
+        else if (this.ref[$childType] && typeof (this.ref[$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            this.ref.forEach((value, key) => {
+                value[$changes].setParent(this.ref, root, this.indexes[key] ?? key);
+            });
         }
-        this.ensureRefId();
-        this.forEachChild((changeTree, atIndex) => {
-            changeTree.setParent(this.ref, root, atIndex);
-        });
     }
     forEachChild(callback) {
         //
         // assign same parent on child structures
         //
-        if (Metadata.isValidInstance(this.ref)) {
-            const metadata = this.ref['constructor'][Symbol.metadata];
-            // FIXME: need to iterate over parent metadata instead.
-            for (const field in metadata) {
-                const value = this.ref[field];
-                if (value && value[$changes]) {
-                    callback(value[$changes], metadata[field].index);
+        const metadata = this.ref.constructor[Symbol.metadata];
+        if (metadata) {
+            metadata[-4]?.forEach((index) => {
+                const field = metadata[index];
+                const value = this.ref[field.name];
+                if (value) {
+                    callback(value[$changes], index);
                 }
-            }
+            });
         }
-        else if (typeof (this.ref) === "object") {
+        else if (this.ref[$childType] && typeof (this.ref[$childType]) !== "string") {
             // MapSchema / ArraySchema, etc.
             this.ref.forEach((value, key) => {
-                if (Metadata.isValidInstance(value)) {
-                    callback(value[$changes], this.ref[$changes].indexes[key] ?? key);
-                }
+                callback(value[$changes], this.indexes[key] ?? key);
             });
         }
     }
@@ -299,8 +351,8 @@ class ChangeTree {
         this.root?.changes.set(this, this.changes);
     }
     change(index, operation = exports.OPERATION.ADD) {
-        const metadata = this.ref['constructor'][Symbol.metadata];
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
+        const metadata = this.ref.constructor[Symbol.metadata];
+        const isFiltered = this.isFiltered || (metadata?.[index]?.tag !== undefined);
         const changeSet = (isFiltered)
             ? this.filteredChanges
             : this.changes;
@@ -311,14 +363,14 @@ class ChangeTree {
                 : (previousOperation === exports.OPERATION.DELETE)
                     ? exports.OPERATION.DELETE_AND_ADD
                     : operation;
+            //
+            // TODO: are DELETE operations being encoded as ADD here ??
+            //
             changeSet.set(index, op);
         }
-        //
-        // TODO: are DELETE operations being encoded as ADD here ??
-        //
         if (isFiltered) {
-            this.root?.filteredChanges.set(this, this.filteredChanges);
             this.allFilteredChanges.set(index, exports.OPERATION.ADD);
+            this.root?.filteredChanges.set(this, this.filteredChanges);
             this.root?.allFilteredChanges.set(this, this.allFilteredChanges);
         }
         else {
@@ -365,9 +417,7 @@ class ChangeTree {
         });
     }
     indexedOperation(index, operation, allChangesIndex = index) {
-        const metadata = this.ref['constructor'][Symbol.metadata];
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
-        if (isFiltered) {
+        if (this.filteredChanges !== undefined) {
             this.allFilteredChanges.set(allChangesIndex, exports.OPERATION.ADD);
             this.filteredChanges.set(index, operation);
             this.root?.filteredChanges.set(this, this.filteredChanges);
@@ -380,8 +430,8 @@ class ChangeTree {
     }
     getType(index) {
         if (Metadata.isValidInstance(this.ref)) {
-            const metadata = this.ref['constructor'][Symbol.metadata];
-            return metadata[metadata[index]].type;
+            const metadata = this.ref.constructor[Symbol.metadata];
+            return metadata[index].type;
         }
         else {
             //
@@ -395,7 +445,7 @@ class ChangeTree {
     }
     getChange(index) {
         // TODO: optimize this. avoid checking against multiple instances
-        return this.changes.get(index) ?? this.filteredChanges.get(index);
+        return this.changes.get(index) ?? this.filteredChanges?.get(index);
     }
     //
     // used during `.encode()`
@@ -416,16 +466,13 @@ class ChangeTree {
             }
             return;
         }
-        const metadata = this.ref['constructor'][Symbol.metadata];
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
-        const changeSet = (isFiltered)
+        const changeSet = (this.filteredChanges)
             ? this.filteredChanges
             : this.changes;
         const previousValue = this.getValue(index);
         changeSet.set(index, operation ?? exports.OPERATION.DELETE);
         // remove `root` reference
         if (previousValue && previousValue[$changes]) {
-            previousValue[$changes].root = undefined;
             //
             // FIXME: this.root is "undefined"
             //
@@ -436,12 +483,18 @@ class ChangeTree {
             //
             // (the property descriptors should NOT be used at decoding time. only at encoding time.)
             //
-            this.root?.remove(previousValue[$changes]);
+            const refCount = this.root?.remove(previousValue[$changes]);
+            //
+            // Only remove "root" reference if it's the last reference
+            //
+            if (refCount <= 0) {
+                previousValue[$changes].root = undefined;
+            }
         }
         //
         // FIXME: this is looking a bit ugly (and repeated from `.change()`)
         //
-        if (isFiltered) {
+        if (this.filteredChanges) {
             this.root?.filteredChanges.set(this, this.filteredChanges);
             this.allFilteredChanges.delete(allChangesIndex);
         }
@@ -452,6 +505,7 @@ class ChangeTree {
     }
     endEncode() {
         this.changes.clear();
+        // ArraySchema and MapSchema have a custom "encode end" method
         this.ref[$onEncodeEnd]?.();
         // Not a new instance anymore
         delete this[$isNew];
@@ -464,12 +518,12 @@ class ChangeTree {
         //
         this.ref[$onEncodeEnd]?.();
         this.changes.clear();
-        this.filteredChanges.clear();
+        this.filteredChanges?.clear();
         // reset operation index
         this.currentOperationIndex = 0;
         if (discardAll) {
             this.allChanges.clear();
-            this.allFilteredChanges.clear();
+            this.allFilteredChanges?.clear();
             // remove children references
             this.forEachChild((changeTree, _) => this.root?.remove(changeTree));
         }
@@ -496,48 +550,41 @@ class ChangeTree {
     get changed() {
         return this.changes.size > 0;
     }
-    checkIsFiltered(parent, parentIndex) {
+    checkIsFiltered(metadata, parent, parentIndex) {
         // Detect if current structure has "filters" declared
-        this.isPartiallyFiltered = (this.ref['constructor']?.[Symbol.metadata]?.[-2] !== undefined);
-        if (parent && !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));
-        // this.isFiltered = this.ref['constructor']?.[Symbol.metadata]?.[-4];
-        // // Detect if parent has "filters" declared
-        // while (parent && !this.isFiltered) {
-        //     const metadata: Metadata = parent['constructor'][Symbol.metadata];
-        //     // this.isFiltered = metadata?.[-4];
-        //     const fieldName = metadata?.[parentIndex];
-        //     const isParentOwned = metadata?.[fieldName]?.tag !== undefined;
-        //     this.isFiltered = isParentOwned || parent[$changes].isFiltered; // metadata?.[-2]
-        //     parent = parent[$changes].parent;
-        // };
-        // console.log("ChangeTree.checkIsFiltered", {
-        //     parent: parent?.constructor.name,
-        //     ref: this.ref.constructor.name,
-        //     isFiltered: this.isFiltered,
-        //     isPartiallyFiltered: this.isPartiallyFiltered,
-        // });
-        //
-        // TODO: refactor this!
-        //
-        //      swapping `changes` and `filteredChanges` is required here
-        //      because "isFiltered" may not be imedialely available on `change()`
-        //
-        if (this.isFiltered && 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;
+        this.isPartiallyFiltered = metadata?.[-2] !== undefined;
+        if (this.isPartiallyFiltered) {
+            this.filteredChanges = this.filteredChanges || new Map();
+            this.allFilteredChanges = this.allFilteredChanges || new Map();
+        }
+        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;
+                }
+            }
         }
     }
 }
@@ -821,62 +868,11 @@ var encode = /*#__PURE__*/Object.freeze({
     writeFloat64: writeFloat64
 });
 
-class EncodeSchemaError extends Error {
-}
-function assertType(value, type, klass, field) {
-    let typeofTarget;
-    let allowNull = false;
-    switch (type) {
-        case "number":
-        case "int8":
-        case "uint8":
-        case "int16":
-        case "uint16":
-        case "int32":
-        case "uint32":
-        case "int64":
-        case "uint64":
-        case "float32":
-        case "float64":
-            typeofTarget = "number";
-            if (isNaN(value)) {
-                console.log(`trying to encode "NaN" in ${klass.constructor.name}#${field}`);
-            }
-            break;
-        case "string":
-            typeofTarget = "string";
-            allowNull = true;
-            break;
-        case "boolean":
-            // boolean is always encoded as true/false based on truthiness
-            return;
-    }
-    if (typeof (value) !== typeofTarget && (!allowNull || (allowNull && value !== null))) {
-        let foundValue = `'${JSON.stringify(value)}'${(value && value.constructor && ` (${value.constructor.name})`) || ''}`;
-        throw new EncodeSchemaError(`a '${typeofTarget}' was expected, but ${foundValue} was provided in ${klass.constructor.name}#${field}`);
-    }
-}
-function assertInstanceType(value, type, klass, field) {
-    if (!(value instanceof type)) {
-        throw new EncodeSchemaError(`a '${type.name}' was expected, but '${value && value.constructor.name}' was provided in ${klass.constructor.name}#${field}`);
-    }
-}
-
-function encodePrimitiveType(type, bytes, value, klass, field, it) {
-    assertType(value, type, klass, field);
-    const encodeFunc = encode[type];
-    if (encodeFunc) {
-        encodeFunc(bytes, value, it);
-        // encodeFunc(bytes, value);
-    }
-    else {
-        throw new EncodeSchemaError(`a '${type}' was expected, but ${value} was provided in ${klass.constructor.name}#${field}`);
+function encodeValue(encoder, bytes, type, value, operation, it) {
+    if (typeof (type) === "string") {
+        encode[type]?.(bytes, value, it);
     }
-}
-function encodeValue(encoder, bytes, ref, type, value, field, operation, it) {
-    if (type[Symbol.metadata] !== undefined) {
-        // TODO: move this to the `@type()` annotation
-        assertInstanceType(value, type, ref, field);
+    else if (type[Symbol.metadata] !== undefined) {
         //
         // Encode refId for this instance.
         // The actual instance is going to be encoded on next `changeTree` iteration.
@@ -887,21 +883,7 @@ function encodeValue(encoder, bytes, ref, type, value, field, operation, it) {
             encoder.tryEncodeTypeId(bytes, type, value.constructor, it);
         }
     }
-    else if (typeof (type) === "string") {
-        //
-        // Primitive values
-        //
-        encodePrimitiveType(type, bytes, value, ref, field, it);
-    }
     else {
-        //
-        // Custom type (MapSchema, ArraySchema, etc)
-        //
-        const definition = getType(Object.keys(type)[0]);
-        //
-        // ensure a ArraySchema has been provided
-        //
-        assertInstanceType(ref[field], definition.constructor, ref, field);
         //
         // Encode refId for this instance.
         // The actual instance is going to be encoded on next `changeTree` iteration.
@@ -914,26 +896,23 @@ function encodeValue(encoder, bytes, ref, type, value, field, operation, it) {
  * @private
  */
 const encodeSchemaOperation = function (encoder, bytes, changeTree, index, operation, it) {
-    const ref = changeTree.ref;
-    const metadata = ref['constructor'][Symbol.metadata];
-    const field = metadata[index];
-    const type = metadata[field].type;
-    const value = ref[field];
     // "compress" field index + operation
     bytes[it.offset++] = (index | operation) & 255;
     // Do not encode value for DELETE operations
     if (operation === exports.OPERATION.DELETE) {
         return;
     }
+    const ref = changeTree.ref;
+    const metadata = ref.constructor[Symbol.metadata];
+    const field = metadata[index];
     // TODO: inline this function call small performance gain
-    encodeValue(encoder, bytes, ref, type, value, field, operation, it);
+    encodeValue(encoder, bytes, metadata[index].type, ref[field.name], operation, it);
 };
 /**
  * Used for collections (MapSchema, CollectionSchema, SetSchema)
  * @private
  */
-const encodeKeyValueOperation = function (encoder, bytes, changeTree, field, operation, it) {
-    const ref = changeTree.ref;
+const encodeKeyValueOperation = function (encoder, bytes, changeTree, index, operation, it) {
     // encode operation
     bytes[it.offset++] = operation & 255;
     // custom operations
@@ -941,25 +920,26 @@ const encodeKeyValueOperation = function (encoder, bytes, changeTree, field, ope
         return;
     }
     // encode index
-    number$1(bytes, field, it);
+    number$1(bytes, index, it);
     // Do not encode value for DELETE operations
     if (operation === exports.OPERATION.DELETE) {
         return;
     }
+    const ref = changeTree.ref;
     //
     // encode "alias" for dynamic fields (maps)
     //
-    if ((operation & exports.OPERATION.ADD) == exports.OPERATION.ADD) { // ADD or DELETE_AND_ADD
+    if ((operation & exports.OPERATION.ADD) === exports.OPERATION.ADD) { // ADD or DELETE_AND_ADD
         if (typeof (ref['set']) === "function") {
             //
             // MapSchema dynamic key
             //
-            const dynamicIndex = changeTree.ref['$indexes'].get(field);
+            const dynamicIndex = changeTree.ref['$indexes'].get(index);
             string$1(bytes, dynamicIndex, it);
         }
     }
-    const type = changeTree.getType(field);
-    const value = changeTree.getValue(field);
+    const type = ref[$childType];
+    const value = ref[$getByIndex](index);
     // try { throw new Error(); } catch (e) {
     //     // only print if not coming from Reflection.ts
     //     if (!e.stack.includes("src/Reflection.ts")) {
@@ -973,7 +953,7 @@ const encodeKeyValueOperation = function (encoder, bytes, changeTree, field, ope
     //     }
     // }
     // TODO: inline this function call small performance gain
-    encodeValue(encoder, bytes, ref, type, value, field, operation, it);
+    encodeValue(encoder, bytes, type, value, operation, it);
 };
 /**
  * Used for collections (MapSchema, ArraySchema, etc.)
@@ -1017,7 +997,7 @@ const encodeArray = function (encoder, bytes, changeTree, field, operation, it,
     //     items: ref.toJSON(),
     // });
     // TODO: inline this function call small performance gain
-    encodeValue(encoder, bytes, ref, type, value, field, operation, it);
+    encodeValue(encoder, bytes, type, value, operation, it);
 };
 
 /**
@@ -1323,7 +1303,9 @@ function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges
             if (!value) {
                 value = decoder.createInstanceOfType(childType);
             }
-            $root.addRef(refId, value, (value !== previousValue));
+            $root.addRef(refId, value, (value !== previousValue || // increment ref count if value has changed
+                (operation === exports.OPERATION.DELETE_AND_ADD && value === previousValue) // increment ref count if the same instance is being added again
+            ));
         }
     }
     else if (typeof (type) === "string") {
@@ -1374,7 +1356,7 @@ function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges
 }
 const decodeSchemaOperation = function (decoder, bytes, it, ref, allChanges) {
     const first_byte = bytes[it.offset++];
-    const metadata = ref['constructor'][Symbol.metadata];
+    const metadata = ref.constructor[Symbol.metadata];
     // "compressed" index + operation
     const operation = (first_byte >> 6) << 6;
     const index = first_byte % (operation || 255);
@@ -1384,9 +1366,9 @@ const decodeSchemaOperation = function (decoder, bytes, it, ref, allChanges) {
         console.warn("@colyseus/schema: field not defined at", { index, ref: ref.constructor.name, metadata });
         return DEFINITION_MISMATCH;
     }
-    const { value, previousValue } = decodeValue(decoder, operation, ref, index, metadata[field].type, bytes, it, allChanges);
+    const { value, previousValue } = decodeValue(decoder, operation, ref, index, field.type, bytes, it, allChanges);
     if (value !== null && value !== undefined) {
-        ref[field] = value;
+        ref[field.name] = value;
     }
     // add change
     if (previousValue !== value) {
@@ -1394,7 +1376,7 @@ const decodeSchemaOperation = function (decoder, bytes, it, ref, allChanges) {
             ref,
             refId: decoder.currentRefId,
             op: operation,
-            field: field,
+            field: field.name,
             value,
             previousValue,
         });
@@ -1492,7 +1474,6 @@ const decodeArray = function (decoder, bytes, it, ref, allChanges) {
         return;
     }
     else if (operation === exports.OPERATION.ADD_BY_REFID) {
-        // operation = OPERATION.ADD;
         const refId = number(bytes, it);
         const itemByRefId = decoder.root.refs.get(refId);
         // use existing index, or push new value
@@ -1526,6 +1507,47 @@ const decodeArray = function (decoder, bytes, it, ref, allChanges) {
     }
 };
 
+class EncodeSchemaError extends Error {
+}
+function assertType(value, type, klass, field) {
+    let typeofTarget;
+    let allowNull = false;
+    switch (type) {
+        case "number":
+        case "int8":
+        case "uint8":
+        case "int16":
+        case "uint16":
+        case "int32":
+        case "uint32":
+        case "int64":
+        case "uint64":
+        case "float32":
+        case "float64":
+            typeofTarget = "number";
+            if (isNaN(value)) {
+                console.log(`trying to encode "NaN" in ${klass.constructor.name}#${field}`);
+            }
+            break;
+        case "string":
+            typeofTarget = "string";
+            allowNull = true;
+            break;
+        case "boolean":
+            // boolean is always encoded as true/false based on truthiness
+            return;
+    }
+    if (typeof (value) !== typeofTarget && (!allowNull || (allowNull && value !== null))) {
+        let foundValue = `'${JSON.stringify(value)}'${(value && value.constructor && ` (${value.constructor.name})`) || ''}`;
+        throw new EncodeSchemaError(`a '${typeofTarget}' was expected, but ${foundValue} was provided in ${klass.constructor.name}#${field}`);
+    }
+}
+function assertInstanceType(value, type, instance, field) {
+    if (!(value instanceof type)) {
+        throw new EncodeSchemaError(`a '${type.name}' was expected, but '${value && value.constructor.name}' was provided in ${instance.constructor.name}#${field}`);
+    }
+}
+
 var _a$4, _b$4;
 const DEFAULT_SORT = (a, b) => {
     const A = a.toString();
@@ -1591,6 +1613,7 @@ class ArraySchema {
                     }
                     else {
                         if (setValue[$changes]) {
+                            assertInstanceType(setValue, obj[$childType], obj, key);
                             if (obj.items[key] !== undefined) {
                                 if (setValue[$changes][$isNew]) {
                                     this[$changes].indexedOperation(Number(key), exports.OPERATION.MOVE_AND_ADD);
@@ -1637,6 +1660,7 @@ class ArraySchema {
             }
         });
         this[$changes] = new ChangeTree(proxy);
+        this[$changes].indexes = {};
         this.push.apply(this, items);
         return proxy;
     }
@@ -1661,6 +1685,9 @@ class ArraySchema {
             if (value === undefined || value === null) {
                 return;
             }
+            else if (typeof (value) === "object" && this[$childType]) {
+                assertInstanceType(value, this[$childType], this, i);
+            }
             const changeTree = this[$changes];
             changeTree.indexedOperation(length, exports.OPERATION.ADD, this.items.length);
             this.items.push(value);
@@ -2188,6 +2215,7 @@ class MapSchema {
         this.$items = new Map();
         this.$indexes = new Map();
         this[$changes] = new ChangeTree(this);
+        this[$changes].indexes = {};
         if (initialValues) {
             if (initialValues instanceof Map ||
                 initialValues instanceof MapSchema) {
@@ -2214,6 +2242,9 @@ class MapSchema {
         if (value === undefined || value === null) {
             throw new Error(`MapSchema#set('${key}', ${value}): trying to set ${value} value on '${key}'.`);
         }
+        else if (typeof (value) === "object" && this[$childType]) {
+            assertInstanceType(value, this[$childType], this, key);
+        }
         // Force "key" as string
         // See: https://github.com/colyseus/colyseus/issues/561#issuecomment-1646733468
         key = key.toString();
@@ -2419,27 +2450,20 @@ class TypeContext {
         if (parentFieldViewTag !== undefined) {
             this.parentFiltered[`${this.schemas.get(klass)}-${parentIndex}`] = true;
         }
-        for (const field in metadata) {
-            // //
-            // // Modify the field's metadata to include the parent field's view tag
-            // //
-            // if (
-            //     parentFieldViewTag !== undefined &&
-            //     metadata[field].tag === undefined
-            // ) {
-            //     metadata[field].tag = parentFieldViewTag;
-            // }
-            const fieldType = metadata[field].type;
-            const viewTag = metadata[field].tag;
+        for (const fieldIndex in metadata) {
+            const index = fieldIndex;
+            const fieldType = metadata[index].type;
+            const viewTag = metadata[index].tag;
             if (typeof (fieldType) === "string") {
                 continue;
             }
             if (Array.isArray(fieldType)) {
                 const type = fieldType[0];
+                // skip primitive types
                 if (type === "string") {
                     continue;
                 }
-                this.discoverTypes(type, metadata[field].index, viewTag);
+                this.discoverTypes(type, index, viewTag);
             }
             else if (typeof (fieldType) === "function") {
                 this.discoverTypes(fieldType, viewTag);
@@ -2450,7 +2474,7 @@ class TypeContext {
                 if (typeof (type) === "string") {
                     continue;
                 }
-                this.discoverTypes(type, metadata[field].index, viewTag);
+                this.discoverTypes(type, index, viewTag);
             }
         }
     }
@@ -2606,17 +2630,18 @@ function view(tag = DEFAULT_VIEW_TAG) {
         const parentMetadata = parentClass[Symbol.metadata];
         // TODO: use Metadata.initialize()
         const metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
-        if (!metadata[fieldName]) {
-            //
-            // detect index for this field, considering inheritance
-            //
-            metadata[fieldName] = {
-                type: undefined,
-                index: (metadata[-1] // current structure already has fields defined
-                    ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
-                    ?? -1) + 1 // no fields defined
-            };
-        }
+        // const fieldIndex = metadata[fieldName];
+        // if (!metadata[fieldIndex]) {
+        //     //
+        //     // detect index for this field, considering inheritance
+        //     //
+        //     metadata[fieldIndex] = {
+        //         type: undefined,
+        //         index: (metadata[-1] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+        //             ?? -1) + 1 // no fields defined
+        //     }
+        // }
         Metadata.setTag(metadata, fieldName, tag);
     };
 }
@@ -2631,16 +2656,16 @@ function type(type, options) {
         const parentClass = Object.getPrototypeOf(constructor);
         const parentMetadata = parentClass && parentClass[Symbol.metadata];
         const metadata = Metadata.initialize(constructor, parentMetadata);
-        let fieldIndex;
+        let fieldIndex = metadata[field];
         /**
          * skip if descriptor already exists for this field (`@deprecated()`)
          */
-        if (metadata[field]) {
-            if (metadata[field].deprecated) {
+        if (metadata[fieldIndex]) {
+            if (metadata[fieldIndex].deprecated) {
                 // do not create accessors for deprecated properties.
                 return;
             }
-            else if (metadata[field].descriptor !== undefined) {
+            else if (metadata[fieldIndex].type !== undefined) {
                 // trying to define same property multiple times across inheritance.
                 // https://github.com/colyseus/colyseus-unity3d/issues/131#issuecomment-814308572
                 try {
@@ -2651,9 +2676,6 @@ function type(type, options) {
                     throw new Error(`${e.message} ${definitionAtLine}`);
                 }
             }
-            else {
-                fieldIndex = metadata[field].index;
-            }
         }
         else {
             //
@@ -2679,11 +2701,11 @@ function type(type, options) {
             const childType = (complexTypeKlass)
                 ? Object.values(type)[0]
                 : type;
-            Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass, metadata, field));
+            Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass));
         }
     };
 }
-function getPropertyDescriptor(fieldCached, fieldIndex, type, complexTypeKlass, metadata, field) {
+function getPropertyDescriptor(fieldCached, fieldIndex, type, complexTypeKlass) {
     return {
         get: function () { return this[fieldCached]; },
         set: function (value) {
@@ -2705,22 +2727,27 @@ function getPropertyDescriptor(fieldCached, fieldIndex, type, complexTypeKlass,
                     }
                     value[$childType] = type;
                 }
+                else if (typeof (type) !== "string") {
+                    assertInstanceType(value, type, this, fieldCached.substring(1));
+                }
+                else {
+                    assertType(value, type, this, fieldCached.substring(1));
+                }
+                const changeTree = this[$changes];
                 //
                 // Replacing existing "ref", remove it from root.
                 // TODO: if there are other references to this instance, we should not remove it from root.
                 //
                 if (previousValue !== undefined && previousValue[$changes]) {
-                    this[$changes].root?.remove(previousValue[$changes]);
+                    changeTree.root?.remove(previousValue[$changes]);
                 }
                 // flag the change for encoding.
-                this.constructor[$track](this[$changes], fieldIndex, exports.OPERATION.ADD);
+                this.constructor[$track](changeTree, fieldIndex, exports.OPERATION.ADD);
                 //
                 // call setParent() recursively for this and its child
                 // structures.
                 //
-                if (value[$changes]) {
-                    value[$changes].setParent(this, this[$changes].root, metadata[field].index);
-                }
+                value[$changes]?.setParent(this, changeTree.root, fieldIndex);
             }
             else if (previousValue !== undefined) {
                 //
@@ -2747,20 +2774,22 @@ function deprecated(throws = true) {
         const parentClass = Object.getPrototypeOf(constructor);
         const parentMetadata = parentClass[Symbol.metadata];
         const metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
-        if (!metadata[field]) {
-            //
-            // detect index for this field, considering inheritance
-            //
-            metadata[field] = {
-                type: undefined,
-                index: (metadata[-1] // current structure already has fields defined
-                    ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
-                    ?? -1) + 1 // no fields defined
-            };
-        }
-        metadata[field].deprecated = true;
+        const fieldIndex = metadata[field];
+        // if (!metadata[field]) {
+        //     //
+        //     // detect index for this field, considering inheritance
+        //     //
+        //     metadata[field] = {
+        //         type: undefined,
+        //         index: (metadata[-1] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+        //             ?? -1) + 1 // no fields defined
+        //     }
+        // }
+        metadata[fieldIndex].deprecated = true;
         if (throws) {
-            metadata[field].descriptor = {
+            metadata[$descriptors] ??= {};
+            metadata[$descriptors][field] = {
                 get: function () { throw new Error(`${field} is deprecated.`); },
                 set: function (value) { },
                 enumerable: false,
@@ -2768,8 +2797,8 @@ function deprecated(throws = true) {
             };
         }
         // flag metadata[field] as non-enumerable
-        Object.defineProperty(metadata, field, {
-            value: metadata[field],
+        Object.defineProperty(metadata, fieldIndex, {
+            value: metadata[fieldIndex],
             enumerable: false,
             configurable: true
         });
@@ -2835,35 +2864,7 @@ class Schema {
             enumerable: false,
             writable: true
         });
-        const metadata = instance.constructor[Symbol.metadata];
-        // Define property descriptors
-        for (const field in metadata) {
-            if (metadata[field].descriptor) {
-                // for encoder
-                Object.defineProperty(instance, `_${field}`, {
-                    value: undefined,
-                    writable: true,
-                    enumerable: false,
-                    configurable: true,
-                });
-                Object.defineProperty(instance, field, metadata[field].descriptor);
-            }
-            else {
-                // for decoder
-                Object.defineProperty(instance, field, {
-                    value: undefined,
-                    writable: true,
-                    enumerable: true,
-                    configurable: true,
-                });
-            }
-            // Object.defineProperty(instance, field, {
-            //     ...instance.constructor[Symbol.metadata][field].descriptor
-            // });
-            // if (args[0]?.hasOwnProperty(field)) {
-            //     instance[field] = args[0][field];
-            // }
-        }
+        Object.defineProperties(instance, instance.constructor[Symbol.metadata]?.[$descriptors] || {});
     }
     static is(type) {
         return typeof (type[Symbol.metadata]) === "object";
@@ -2887,7 +2888,7 @@ class Schema {
      */
     static [$filter](ref, index, view) {
         const metadata = ref.constructor[Symbol.metadata];
-        const tag = metadata[metadata[index]].tag;
+        const tag = metadata[index]?.tag;
         if (view === undefined) {
             // shared pass/encode: encode if doesn't have a tag
             return tag === undefined;
@@ -2908,12 +2909,21 @@ class Schema {
     }
     // allow inherited classes to have a constructor
     constructor(...args) {
-        Schema.initialize(this);
+        //
+        // inline
+        // Schema.initialize(this);
+        //
+        Object.defineProperty(this, $changes, {
+            value: new ChangeTree(this),
+            enumerable: false,
+            writable: true
+        });
+        Object.defineProperties(this, this.constructor[Symbol.metadata]?.[$descriptors] || {});
         //
         // Assign initial values
         //
         if (args[0]) {
-            this.assign(args[0]);
+            Object.assign(this, args[0]);
         }
     }
     assign(props) {
@@ -2927,7 +2937,8 @@ class Schema {
      * @param operation OPERATION to perform (detected automatically)
      */
     setDirty(property, operation) {
-        this[$changes].change(this.constructor[Symbol.metadata][property].index, operation);
+        const metadata = this.constructor[Symbol.metadata];
+        this[$changes].change(metadata[metadata[property]].index, operation);
     }
     clone() {
         const cloned = new (this.constructor);
@@ -2936,7 +2947,9 @@ class Schema {
         // TODO: clone all properties, not only annotated ones
         //
         // for (const field in this) {
-        for (const field in metadata) {
+        for (const fieldIndex in metadata) {
+            // const field = metadata[metadata[fieldIndex]].name;
+            const field = metadata[fieldIndex].name;
             if (typeof (this[field]) === "object" &&
                 typeof (this[field]?.clone) === "function") {
                 // deep clone
@@ -2950,10 +2963,11 @@ class Schema {
         return cloned;
     }
     toJSON() {
-        const metadata = this.constructor[Symbol.metadata];
         const obj = {};
-        for (const fieldName in metadata) {
-            const field = metadata[fieldName];
+        const metadata = this.constructor[Symbol.metadata];
+        for (const index in metadata) {
+            const field = metadata[index];
+            const fieldName = field.name;
             if (!field.deprecated && this[fieldName] !== null && typeof (this[fieldName]) !== "undefined") {
                 obj[fieldName] = (typeof (this[fieldName]['toJSON']) === "function")
                     ? this[fieldName]['toJSON']()
@@ -2966,10 +2980,12 @@ class Schema {
         this[$changes].discardAll();
     }
     [$getByIndex](index) {
-        return this[this.constructor[Symbol.metadata][index]];
+        const metadata = this.constructor[Symbol.metadata];
+        return this[metadata[index].name];
     }
     [$deleteByIndex](index) {
-        this[this.constructor[Symbol.metadata][index]] = undefined;
+        const metadata = this.constructor[Symbol.metadata];
+        this[metadata[index].name] = undefined;
     }
     static debugRefIds(instance, jsonContents = true, level = 0) {
         const ref = instance;
@@ -3093,6 +3109,7 @@ class CollectionSchema {
         this.$indexes = new Map();
         this.$refId = 0;
         this[$changes] = new ChangeTree(this);
+        this[$changes].indexes = {};
         if (initialValues) {
             initialValues.forEach((v) => this.add(v));
         }
@@ -3248,6 +3265,7 @@ class SetSchema {
         this.$indexes = new Map();
         this.$refId = 0;
         this[$changes] = new ChangeTree(this);
+        this[$changes].indexes = {};
         if (initialValues) {
             initialValues.forEach((v) => this.add(v));
         }
@@ -3434,24 +3452,36 @@ class Root {
         return this.nextUniqueId++;
     }
     add(changeTree) {
-        const refCount = this.refCount.get(changeTree) || 0;
-        this.refCount.set(changeTree, refCount + 1);
+        const previousRefCount = this.refCount.get(changeTree);
+        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 refCount = (previousRefCount || 0) + 1;
+        this.refCount.set(changeTree, refCount);
+        return refCount;
     }
     remove(changeTree) {
-        const refCount = this.refCount.get(changeTree);
-        if (refCount <= 1) {
+        const refCount = (this.refCount.get(changeTree)) - 1;
+        if (refCount <= 0) {
             this.allChanges.delete(changeTree);
             this.changes.delete(changeTree);
             if (changeTree.isFiltered || changeTree.isPartiallyFiltered) {
                 this.allFilteredChanges.delete(changeTree);
                 this.filteredChanges.delete(changeTree);
             }
-            this.refCount.delete(changeTree);
+            this.refCount.set(changeTree, 0);
         }
         else {
-            this.refCount.set(changeTree, refCount - 1);
+            this.refCount.set(changeTree, refCount);
         }
         changeTree.forEachChild((child, _) => this.remove(child));
+        return refCount;
     }
     clear() {
         this.changes.clear();
@@ -3482,10 +3512,10 @@ class Encoder {
     ) {
         const hasView = (view !== undefined);
         const rootChangeTree = this.state[$changes];
-        const changeTreesIterator = changeTrees.entries();
-        for (const [changeTree, changes] of changeTreesIterator) {
+        const shouldClearChanges = !isEncodeAll && !hasView;
+        for (const [changeTree, changes] of changeTrees.entries()) {
             const ref = changeTree.ref;
-            const ctor = ref['constructor'];
+            const ctor = ref.constructor;
             const encoder = ctor[$encoder];
             const filter = ctor[$filter];
             // try { throw new Error(); } catch (e) {
@@ -3509,8 +3539,7 @@ class Encoder {
                 buffer[it.offset++] = SWITCH_TO_STRUCTURE & 255;
                 number$1(buffer, changeTree.refId, it);
             }
-            const changesIterator = changes.entries();
-            for (const [fieldIndex, operation] of changesIterator) {
+            for (const [fieldIndex, operation] of changes.entries()) {
                 //
                 // first pass (encodeAll), identify "filtered" operations without encoding them
                 // they will be encoded per client, based on their view.
@@ -3535,6 +3564,14 @@ class Encoder {
                 // }
                 encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView);
             }
+            // 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);
@@ -3557,7 +3594,7 @@ class Encoder {
             //
             // only clear changes after making sure buffer resize is not required.
             //
-            if (!isEncodeAll && !hasView) {
+            if (shouldClearChanges) {
                 //
                 // FIXME: avoid iterating over change trees twice.
                 //
@@ -3641,6 +3678,11 @@ class Encoder {
         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];
         }
     }
     discardChanges() {
@@ -3756,8 +3798,9 @@ class ReferenceTracker {
             // Ensure child schema instances have their references removed as well.
             //
             if (Metadata.isValidInstance(ref)) {
-                const metadata = ref['constructor'][Symbol.metadata];
-                for (const field in metadata) {
+                const metadata = ref.constructor[Symbol.metadata];
+                for (const index in metadata) {
+                    const field = metadata[index].name;
                     const childRefId = typeof (ref[field]) === "object" && this.refIds.get(ref[field]);
                     if (childRefId) {
                         this.removeRef(childRefId);
@@ -3944,7 +3987,9 @@ class Reflection extends Schema {
         const reflection = new Reflection();
         const encoder = new Encoder(reflection);
         const buildType = (currentType, metadata) => {
-            for (const fieldName in metadata) {
+            for (const fieldIndex in metadata) {
+                const index = Number(fieldIndex);
+                const fieldName = metadata[index].name;
                 // skip fields from parent classes
                 if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
                     continue;
@@ -3952,7 +3997,7 @@ class Reflection extends Schema {
                 const field = new ReflectionField();
                 field.name = fieldName;
                 let fieldType;
-                const type = metadata[fieldName].type;
+                const type = metadata[index].type;
                 if (typeof (type) === "string") {
                     fieldType = type;
                 }
@@ -4018,18 +4063,7 @@ class Reflection extends Schema {
         reflection.types.forEach((reflectionType) => {
             const schemaType = typeContext.get(reflectionType.id);
             const metadata = schemaType[Symbol.metadata];
-            // FIXME: use metadata[-1] to get field count
             const parentFieldIndex = 0;
-            // console.log("--------------------");
-            // // console.log("reflectionType", reflectionType.toJSON());
-            // console.log("reflectionType.fields", reflectionType.fields.toJSON());
-            // console.log("parentFieldIndex", parentFieldIndex);
-            //
-            // FIXME: set fields using parentKlass as well
-            // currently the fields are duplicated on inherited classes
-            //
-            // // const parentKlass = reflection.types[reflectionType.extendsId];
-            // // parentKlass.fields
             reflectionType.fields.forEach((field, i) => {
                 const fieldIndex = parentFieldIndex + i;
                 if (field.referencedType !== undefined) {
@@ -4194,7 +4228,7 @@ function getDecoderStateCallbacks(decoder) {
                 //
                 bindTo: function bindTo(targetObject, properties) {
                     if (!properties) {
-                        properties = Object.keys(metadata);
+                        properties = Object.keys(metadata).map((index) => metadata[index].name);
                     }
                     return $root.addCallback($root.refIds.get(context.instance), exports.OPERATION.REPLACE, () => {
                         properties.forEach((prop) => targetObject[prop] = context.instance[prop]);
@@ -4202,7 +4236,8 @@ function getDecoderStateCallbacks(decoder) {
                 }
             }, {
                 get(target, prop) {
-                    if (metadata[prop]) {
+                    const metadataField = metadata[metadata[prop]];
+                    if (metadataField) {
                         const instance = context.instance?.[prop];
                         const onInstanceAvailable = ((callback) => {
                             const unbind = $(context.instance).listen(prop, (value, _) => {
@@ -4218,7 +4253,7 @@ function getDecoderStateCallbacks(decoder) {
                                 callback(instance, true);
                             }
                         });
-                        return getProxy(metadata[prop].type, {
+                        return getProxy(metadataField.type, {
                             // make sure refId is available, otherwise need to wait for the instance to be available.
                             instance: ($root.refIds.get(instance) && instance),
                             parentInstance: context.instance,
@@ -4331,7 +4366,7 @@ class StateView {
             console.warn("StateView#add(), invalid object:", obj);
             return this;
         }
-        // FIXME: ArraySchema/MapSchema does not have metadata
+        // FIXME: ArraySchema/MapSchema do not have metadata
         const metadata = obj.constructor[Symbol.metadata];
         const changeTree = obj[$changes];
         this.items.add(changeTree);
@@ -4377,7 +4412,7 @@ class StateView {
                 ? changeTree.allFilteredChanges
                 : changeTree.allChanges;
             changeSet.forEach((op, index) => {
-                const tagAtIndex = metadata?.[metadata?.[index]].tag;
+                const tagAtIndex = metadata?.[index].tag;
                 if ((isInvisible || // if "invisible", include all
                     tagAtIndex === undefined || // "all change" with no tag
                     tagAtIndex === tag // tagged property
@@ -4390,7 +4425,7 @@ class StateView {
         // Add children of this ChangeTree to this view
         changeTree.forEachChild((change, index) => {
             // Do not ADD children that don't have the same tag
-            if (metadata && metadata[metadata[index]].tag !== tag) {
+            if (metadata && metadata[index].tag !== tag) {
                 return;
             }
             this.add(change.ref, tag, false);