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

package/build/umd/index.js

@@ -40,6 +40,7 @@
     const $filter = Symbol("$filter");
     const $getByIndex = Symbol("$getByIndex");
     const $deleteByIndex = Symbol("$deleteByIndex");
+    const $descriptors = Symbol("$descriptors");
     /**
      * Used to hold ChangeTree instances whitin the structures
      */
@@ -75,34 +76,67 @@
     }
 
     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
@@ -118,20 +152,14 @@
                     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];
@@ -139,7 +167,7 @@
                 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++;
             }
         },
@@ -168,8 +196,9 @@
                     // 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,
                         });
@@ -193,7 +222,7 @@
             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;
         }
@@ -202,48 +231,59 @@
     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;
@@ -253,48 +293,60 @@
                 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);
                 });
             }
         }
@@ -303,8 +355,8 @@
             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;
@@ -315,14 +367,14 @@
                     : (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 {
@@ -369,9 +421,7 @@
             });
         }
         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);
@@ -384,8 +434,8 @@
         }
         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 {
                 //
@@ -399,7 +449,7 @@
         }
         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()`
@@ -420,16 +470,13 @@
                 }
                 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"
                 //
@@ -440,12 +487,18 @@
                 //
                 // (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);
             }
@@ -456,6 +509,7 @@
         }
         endEncode() {
             this.changes.clear();
+            // ArraySchema and MapSchema have a custom "encode end" method
             this.ref[$onEncodeEnd]?.();
             // Not a new instance anymore
             delete this[$isNew];
@@ -468,12 +522,12 @@
             //
             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));
             }
@@ -500,48 +554,41 @@
         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;
+                    }
+                }
             }
         }
     }
@@ -825,62 +872,11 @@
         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.
@@ -891,21 +887,7 @@
                 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.
@@ -918,26 +900,23 @@
      * @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
@@ -945,25 +924,26 @@
             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")) {
@@ -977,7 +957,7 @@
         //     }
         // }
         // 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.)
@@ -1021,7 +1001,7 @@
         //     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);
     };
 
     /**
@@ -1327,7 +1307,9 @@
                 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") {
@@ -1378,7 +1360,7 @@
     }
     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);
@@ -1388,9 +1370,9 @@
             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) {
@@ -1398,7 +1380,7 @@
                 ref,
                 refId: decoder.currentRefId,
                 op: operation,
-                field: field,
+                field: field.name,
                 value,
                 previousValue,
             });
@@ -1496,7 +1478,6 @@
             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
@@ -1530,6 +1511,47 @@
         }
     };
 
+    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();
@@ -1595,6 +1617,7 @@
                         }
                         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);
@@ -1641,6 +1664,7 @@
                 }
             });
             this[$changes] = new ChangeTree(proxy);
+            this[$changes].indexes = {};
             this.push.apply(this, items);
             return proxy;
         }
@@ -1665,6 +1689,9 @@
                 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);
@@ -2192,6 +2219,7 @@
             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) {
@@ -2218,6 +2246,9 @@
             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();
@@ -2423,27 +2454,20 @@
             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);
@@ -2454,7 +2478,7 @@
                     if (typeof (type) === "string") {
                         continue;
                     }
-                    this.discoverTypes(type, metadata[field].index, viewTag);
+                    this.discoverTypes(type, index, viewTag);
                 }
             }
         }
@@ -2610,17 +2634,18 @@
             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);
         };
     }
@@ -2635,16 +2660,16 @@
             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 {
@@ -2655,9 +2680,6 @@
                         throw new Error(`${e.message} ${definitionAtLine}`);
                     }
                 }
-                else {
-                    fieldIndex = metadata[field].index;
-                }
             }
             else {
                 //
@@ -2683,11 +2705,11 @@
                 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) {
@@ -2709,22 +2731,27 @@
                         }
                         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) {
                     //
@@ -2751,20 +2778,22 @@
             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,
@@ -2772,8 +2801,8 @@
                 };
             }
             // flag metadata[field] as non-enumerable
-            Object.defineProperty(metadata, field, {
-                value: metadata[field],
+            Object.defineProperty(metadata, fieldIndex, {
+                value: metadata[fieldIndex],
                 enumerable: false,
                 configurable: true
             });
@@ -2839,35 +2868,7 @@
                 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";
@@ -2891,7 +2892,7 @@
          */
         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;
@@ -2912,12 +2913,21 @@
         }
         // 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) {
@@ -2931,7 +2941,8 @@
          * @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);
@@ -2940,7 +2951,9 @@
             // 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
@@ -2954,10 +2967,11 @@
             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']()
@@ -2970,10 +2984,12 @@
             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;
@@ -3097,6 +3113,7 @@
             this.$indexes = new Map();
             this.$refId = 0;
             this[$changes] = new ChangeTree(this);
+            this[$changes].indexes = {};
             if (initialValues) {
                 initialValues.forEach((v) => this.add(v));
             }
@@ -3252,6 +3269,7 @@
             this.$indexes = new Map();
             this.$refId = 0;
             this[$changes] = new ChangeTree(this);
+            this[$changes].indexes = {};
             if (initialValues) {
                 initialValues.forEach((v) => this.add(v));
             }
@@ -3438,24 +3456,36 @@
             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();
@@ -3486,10 +3516,10 @@
         ) {
             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) {
@@ -3513,8 +3543,7 @@
                     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.
@@ -3539,6 +3568,14 @@
                     // }
                     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);
@@ -3561,7 +3598,7 @@
                 //
                 // only clear changes after making sure buffer resize is not required.
                 //
-                if (!isEncodeAll && !hasView) {
+                if (shouldClearChanges) {
                     //
                     // FIXME: avoid iterating over change trees twice.
                     //
@@ -3645,6 +3682,11 @@
             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() {
@@ -3760,8 +3802,9 @@
                 // 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);
@@ -3948,7 +3991,9 @@
             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;
@@ -3956,7 +4001,7 @@
                     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;
                     }
@@ -4022,18 +4067,7 @@
             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) {
@@ -4198,7 +4232,7 @@
                     //
                     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]);
@@ -4206,7 +4240,8 @@
                     }
                 }, {
                     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, _) => {
@@ -4222,7 +4257,7 @@
                                     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,
@@ -4335,7 +4370,7 @@
                 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);
@@ -4381,7 +4416,7 @@
                     ? 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
@@ -4394,7 +4429,7 @@
             // 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);