@colyseus/schema 3.0.0-alpha.9 → 3.0.1

package/build/cjs/index.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 const SWITCH_TO_STRUCTURE = 255; // (decoding collides with DELETE_AND_ADD + fieldIndex = 63)
 const TYPE_ID = 213;
 /**
@@ -22,11 +20,10 @@ exports.OPERATION = void 0;
     /**
      * ArraySchema operations
      */
-    OPERATION[OPERATION["PUSH"] = 11] = "PUSH";
-    OPERATION[OPERATION["UNSHIFT"] = 12] = "UNSHIFT";
     OPERATION[OPERATION["REVERSE"] = 15] = "REVERSE";
     OPERATION[OPERATION["MOVE"] = 32] = "MOVE";
     OPERATION[OPERATION["DELETE_BY_REFID"] = 33] = "DELETE_BY_REFID";
+    OPERATION[OPERATION["ADD_BY_REFID"] = 129] = "ADD_BY_REFID";
 })(exports.OPERATION || (exports.OPERATION = {}));
 
 Symbol.metadata ??= Symbol.for("Symbol.metadata");
@@ -46,11 +43,6 @@ const $changes = Symbol('$changes');
  * (MapSchema, ArraySchema, etc.)
  */
 const $childType = Symbol('$childType');
-/**
- * Special ChangeTree property to identify new instances
- * (Once they're encoded, they're not new anymore)
- */
-const $isNew = Symbol("$isNew");
 /**
  * Optional "discard" method for custom types (ArraySchema)
  * (Discards changes for next serialization)
@@ -60,476 +52,303 @@ const $onEncodeEnd = Symbol('$onEncodeEnd');
  * When decoding, this method is called after the instance is fully decoded
  */
 const $onDecodeEnd = Symbol("$onDecodeEnd");
+/**
+ * Metadata
+ */
+const $descriptors = Symbol("$descriptors");
+const $numFields = "$__numFields";
+const $refTypeFieldIndexes = "$__refTypeFieldIndexes";
+const $viewFieldIndexes = "$__viewFieldIndexes";
+const $fieldIndexesByViewTag = "$__fieldIndexesByViewTag";
 
-const registeredTypes = {};
-const identifiers = new Map();
-function registerType(identifier, definition) {
-    identifiers.set(definition.constructor, identifier);
-    registeredTypes[identifier] = definition;
-}
-function getType(identifier) {
-    return registeredTypes[identifier];
+/**
+ * Copyright (c) 2018 Endel Dreyer
+ * Copyright (c) 2014 Ion Drive Software Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE
+ */
+/**
+ * msgpack implementation highly based on notepack.io
+ * https://github.com/darrachequesne/notepack
+ */
+let textEncoder;
+// @ts-ignore
+try {
+    textEncoder = new TextEncoder();
 }
-
-const Metadata = {
-    addField(metadata, index, field, type, descriptor) {
-        if (index > 64) {
-            throw new Error(`Can't define field '${field}'.\nSchema instances may only have up to 64 fields.`);
+catch (e) { }
+const _convoBuffer$1 = new ArrayBuffer(8);
+const _int32$1 = new Int32Array(_convoBuffer$1);
+const _float32$1 = new Float32Array(_convoBuffer$1);
+const _float64$1 = new Float64Array(_convoBuffer$1);
+const _int64$1 = new BigInt64Array(_convoBuffer$1);
+const hasBufferByteLength = (typeof Buffer !== 'undefined' && Buffer.byteLength);
+const utf8Length = (hasBufferByteLength)
+    ? Buffer.byteLength // node
+    : function (str, _) {
+        var c = 0, length = 0;
+        for (var i = 0, l = str.length; i < l; i++) {
+            c = str.charCodeAt(i);
+            if (c < 0x80) {
+                length += 1;
+            }
+            else if (c < 0x800) {
+                length += 2;
+            }
+            else if (c < 0xd800 || c >= 0xe000) {
+                length += 3;
+            }
+            else {
+                i++;
+                length += 4;
+            }
         }
-        metadata[field] = Object.assign(metadata[field] || {}, // avoid overwriting previous field metadata (@owned / @deprecated)
-        {
-            type: (Array.isArray(type))
-                ? { array: type[0] }
-                : type,
-            index,
-            descriptor,
-        });
-        // 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,
-            enumerable: false,
-            configurable: true,
-        });
-    },
-    setTag(metadata, fieldName, tag) {
-        // add 'tag' to the field
-        const field = metadata[fieldName];
-        field.tag = tag;
-        if (!metadata[-2]) {
-            // -2: all field indexes with "view" tag
-            Object.defineProperty(metadata, -2, {
-                value: [],
-                enumerable: false,
-                configurable: true
-            });
-            // -3: field indexes by "view" tag
-            Object.defineProperty(metadata, -3, {
-                value: {},
-                enumerable: false,
-                configurable: true
-            });
+        return length;
+    };
+function utf8Write(view, str, it) {
+    var c = 0;
+    for (var i = 0, l = str.length; i < l; i++) {
+        c = str.charCodeAt(i);
+        if (c < 0x80) {
+            view[it.offset++] = c;
         }
-        metadata[-2].push(field.index);
-        if (!metadata[-3][tag]) {
-            metadata[-3][tag] = [];
+        else if (c < 0x800) {
+            view[it.offset] = 0xc0 | (c >> 6);
+            view[it.offset + 1] = 0x80 | (c & 0x3f);
+            it.offset += 2;
         }
-        metadata[-3][tag].push(field.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];
-            // FIXME: this code is duplicated from @type() annotation
-            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));
-            index++;
+        else if (c < 0xd800 || c >= 0xe000) {
+            view[it.offset] = 0xe0 | (c >> 12);
+            view[it.offset + 1] = 0x80 | (c >> 6 & 0x3f);
+            view[it.offset + 2] = 0x80 | (c & 0x3f);
+            it.offset += 3;
         }
-    },
-    isDeprecated(metadata, field) {
-        return metadata[field].deprecated === true;
-    },
-    isValidInstance(klass) {
-        return (klass.constructor[Symbol.metadata] &&
-            Object.prototype.hasOwnProperty.call(klass.constructor[Symbol.metadata], -1));
-    },
-    getFields(klass) {
-        const metadata = klass[Symbol.metadata];
-        const fields = {};
-        for (let i = 0; i <= metadata[-1]; i++) {
-            fields[metadata[i]] = metadata[metadata[i]].type;
+        else {
+            i++;
+            c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
+            view[it.offset] = 0xf0 | (c >> 18);
+            view[it.offset + 1] = 0x80 | (c >> 12 & 0x3f);
+            view[it.offset + 2] = 0x80 | (c >> 6 & 0x3f);
+            view[it.offset + 3] = 0x80 | (c & 0x3f);
+            it.offset += 4;
         }
-        return fields;
     }
-};
-
-var _a$5;
-class Root {
-    constructor() {
-        this.nextUniqueId = 0;
-        this.refCount = new WeakMap();
-        // all changes
-        this.allChanges = new Map();
-        this.allFilteredChanges = new Map();
-        // pending changes to be encoded
-        this.changes = new Map();
-        this.filteredChanges = new Map();
+}
+function int8$1(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
+}
+function uint8$1(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
+}
+function int16$1(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
+    bytes[it.offset++] = (value >> 8) & 255;
+}
+function uint16$1(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
+    bytes[it.offset++] = (value >> 8) & 255;
+}
+function int32$1(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
+    bytes[it.offset++] = (value >> 8) & 255;
+    bytes[it.offset++] = (value >> 16) & 255;
+    bytes[it.offset++] = (value >> 24) & 255;
+}
+function uint32$1(bytes, value, it) {
+    const b4 = value >> 24;
+    const b3 = value >> 16;
+    const b2 = value >> 8;
+    const b1 = value;
+    bytes[it.offset++] = b1 & 255;
+    bytes[it.offset++] = b2 & 255;
+    bytes[it.offset++] = b3 & 255;
+    bytes[it.offset++] = b4 & 255;
+}
+function int64$1(bytes, value, it) {
+    const high = Math.floor(value / Math.pow(2, 32));
+    const low = value >>> 0;
+    uint32$1(bytes, low, it);
+    uint32$1(bytes, high, it);
+}
+function uint64$1(bytes, value, it) {
+    const high = (value / Math.pow(2, 32)) >> 0;
+    const low = value >>> 0;
+    uint32$1(bytes, low, it);
+    uint32$1(bytes, high, it);
+}
+function bigint64$1(bytes, value, it) {
+    _int64$1[0] = BigInt.asIntN(64, value);
+    int32$1(bytes, _int32$1[0], it);
+    int32$1(bytes, _int32$1[1], it);
+}
+function biguint64$1(bytes, value, it) {
+    _int64$1[0] = BigInt.asIntN(64, value);
+    int32$1(bytes, _int32$1[0], it);
+    int32$1(bytes, _int32$1[1], it);
+}
+function float32$1(bytes, value, it) {
+    _float32$1[0] = value;
+    int32$1(bytes, _int32$1[0], it);
+}
+function float64$1(bytes, value, it) {
+    _float64$1[0] = value;
+    int32$1(bytes, _int32$1[0 ], it);
+    int32$1(bytes, _int32$1[1 ], it);
+}
+function boolean$1(bytes, value, it) {
+    bytes[it.offset++] = value ? 1 : 0; // uint8
+}
+function string$1(bytes, value, it) {
+    // encode `null` strings as empty.
+    if (!value) {
+        value = "";
     }
-    getNextUniqueId() {
-        return this.nextUniqueId++;
+    let length = utf8Length(value, "utf8");
+    let size = 0;
+    // fixstr
+    if (length < 0x20) {
+        bytes[it.offset++] = length | 0xa0;
+        size = 1;
     }
-    add(changeTree) {
-        const refCount = this.refCount.get(changeTree) || 0;
-        this.refCount.set(changeTree, refCount + 1);
+    // str 8
+    else if (length < 0x100) {
+        bytes[it.offset++] = 0xd9;
+        bytes[it.offset++] = length % 255;
+        size = 2;
     }
-    remove(changeTree) {
-        const refCount = this.refCount.get(changeTree);
-        if (refCount <= 1) {
-            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);
-        }
-        else {
-            this.refCount.set(changeTree, refCount - 1);
-        }
-        changeTree.forEachChild((child, _) => this.remove(child));
+    // str 16
+    else if (length < 0x10000) {
+        bytes[it.offset++] = 0xda;
+        uint16$1(bytes, length, it);
+        size = 3;
     }
-    clear() {
-        this.changes.clear();
+    // str 32
+    else if (length < 0x100000000) {
+        bytes[it.offset++] = 0xdb;
+        uint32$1(bytes, length, it);
+        size = 5;
+    }
+    else {
+        throw new Error('String too long');
     }
+    utf8Write(bytes, value, it);
+    return size + length;
 }
-class ChangeTree {
-    static { _a$5 = $isNew; }
-    ;
-    constructor(ref) {
-        this.indexes = {}; // TODO: remove this, only used by MapSchema/SetSchema/CollectionSchema (`encodeKeyValueOperation`)
-        this.currentOperationIndex = 0;
-        this.allChanges = new Map();
-        this.allFilteredChanges = new Map();
-        this.changes = new Map();
-        this.filteredChanges = new Map();
-        this[_a$5] = true;
-        this.ref = ref;
+function number$1(bytes, value, it) {
+    if (isNaN(value)) {
+        return number$1(bytes, 0, it);
     }
-    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();
-        if (!this.isFiltered) {
-            this.root.changes.set(this, this.changes);
-        }
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this.root.allFilteredChanges.set(this, this.allFilteredChanges);
-            this.root.filteredChanges.set(this, this.filteredChanges);
-            // } else {
-            //     this.root.allChanges.set(this, this.allChanges);
-        }
-        if (!this.isFiltered) {
-            this.root.allChanges.set(this, this.allChanges);
+    else if (!isFinite(value)) {
+        return number$1(bytes, (value > 0) ? Number.MAX_SAFE_INTEGER : -Number.MAX_SAFE_INTEGER, it);
+    }
+    else if (value !== (value | 0)) {
+        if (Math.abs(value) <= 3.4028235e+38) { // range check
+            _float32$1[0] = value;
+            if (Math.abs(Math.abs(_float32$1[0]) - Math.abs(value)) < 1e-4) { // precision check; adjust 1e-n (n = precision) to in-/decrease acceptable precision loss
+                // now we know value is in range for f32 and has acceptable precision for f32
+                bytes[it.offset++] = 0xca;
+                float32$1(bytes, value, it);
+                return 5;
+            }
         }
-        this.forEachChild((changeTree, _) => {
-            changeTree.setRoot(root);
-        });
-        // this.allChanges.forEach((_, index) => {
-        //     const childRef = this.ref[$getByIndex](index);
-        //     if (childRef && childRef[$changes]) {
-        //         childRef[$changes].setRoot(root);
-        //     }
-        // });
+        bytes[it.offset++] = 0xcb;
+        float64$1(bytes, value, it);
+        return 9;
     }
-    setParent(parent, root, parentIndex) {
-        this.parent = parent;
-        this.parentIndex = parentIndex;
-        // avoid setting parents with empty `root`
-        if (!root) {
-            return;
-        }
-        root.add(this);
-        // skip if parent is already set
-        if (root === this.root) {
-            this.forEachChild((changeTree, atIndex) => {
-                changeTree.setParent(this.ref, root, atIndex);
-            });
-            return;
-        }
-        this.root = root;
-        this.checkIsFiltered(parent, parentIndex);
-        if (!this.isFiltered) {
-            this.root.changes.set(this, this.changes);
-        }
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this.root.filteredChanges.set(this, this.filteredChanges);
-            this.root.allFilteredChanges.set(this, this.filteredChanges);
-        }
-        else {
-            this.root.allChanges.set(this, this.allChanges);
-        }
-        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);
-                }
-            }
-        }
-        else if (typeof (this.ref) === "object") {
-            // MapSchema / ArraySchema, etc.
-            this.ref.forEach((value, key) => {
-                if (Metadata.isValidInstance(value)) {
-                    callback(value[$changes], this.ref[$changes].indexes[key]);
-                }
-            });
-        }
-    }
-    operation(op) {
-        this.changes.set(--this.currentOperationIndex, op);
-        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 changeSet = (isFiltered)
-            ? this.filteredChanges
-            : this.changes;
-        const previousOperation = changeSet.get(index);
-        if (!previousOperation || previousOperation === exports.OPERATION.DELETE) {
-            const op = (!previousOperation)
-                ? operation
-                : (previousOperation === exports.OPERATION.DELETE)
-                    ? exports.OPERATION.DELETE_AND_ADD
-                    : operation;
-            changeSet.set(index, op);
-        }
-        //
-        // TODO: are DELETE operations being encoded as ADD here ??
-        //
-        if (isFiltered) {
-            this.allFilteredChanges.set(index, exports.OPERATION.ADD);
-            this.root?.filteredChanges.set(this, this.filteredChanges);
-        }
-        else {
-            this.allChanges.set(index, exports.OPERATION.ADD);
-            this.root?.changes.set(this, this.changes);
-        }
-    }
-    shiftChangeIndexes(shiftIndex) {
-        //
-        // Used only during:
-        //
-        // - ArraySchema#unshift()
-        //
-        const changeSet = (this.isFiltered)
-            ? this.filteredChanges
-            : this.changes;
-        const changeSetEntries = Array.from(changeSet.entries());
-        changeSet.clear();
-        // Re-insert each entry with the shifted index
-        for (const [index, op] of changeSetEntries) {
-            changeSet.set(index + shiftIndex, op);
-        }
-    }
-    shiftAllChangeIndexes(shiftIndex, startIndex = 0) {
-        //
-        // Used only during:
-        //
-        // - ArraySchema#splice()
-        //
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allFilteredChanges);
-            this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
-        }
-        else {
-            this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
-        }
-    }
-    _shiftAllChangeIndexes(shiftIndex, startIndex = 0, allChangeSet) {
-        Array.from(allChangeSet.entries()).forEach(([index, op]) => {
-            // console.log('shiftAllChangeIndexes', index >= startIndex, { index, op, shiftIndex, startIndex })
-            if (index >= startIndex) {
-                allChangeSet.delete(index);
-                allChangeSet.set(index + shiftIndex, op);
-            }
-        });
-    }
-    indexedOperation(index, operation, allChangesIndex = index) {
-        const metadata = this.ref['constructor'][Symbol.metadata];
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
-        if (isFiltered) {
-            this.allFilteredChanges.set(allChangesIndex, exports.OPERATION.ADD);
-            this.filteredChanges.set(index, operation);
-            this.root?.filteredChanges.set(this, this.filteredChanges);
-        }
-        else {
-            this.allChanges.set(allChangesIndex, exports.OPERATION.ADD);
-            this.changes.set(index, operation);
-            this.root?.changes.set(this, this.changes);
-        }
-    }
-    getType(index) {
-        if (Metadata.isValidInstance(this.ref)) {
-            const metadata = this.ref['constructor'][Symbol.metadata];
-            return metadata[metadata[index]].type;
-        }
-        else {
-            //
-            // Get the child type from parent structure.
-            // - ["string"] => "string"
-            // - { map: "string" } => "string"
-            // - { set: "string" } => "string"
-            //
-            return this.ref[$childType];
-        }
-    }
-    getChange(index) {
-        // TODO: optimize this. avoid checking against multiple instances
-        return this.changes.get(index) ?? this.filteredChanges.get(index);
-    }
-    //
-    // used during `.encode()`
-    //
-    getValue(index, isEncodeAll = false) {
-        //
-        // `isEncodeAll` param is only used by ArraySchema
-        //
-        return this.ref[$getByIndex](index, isEncodeAll);
-    }
-    delete(index, operation, allChangesIndex = index) {
-        if (index === undefined) {
-            try {
-                throw new Error(`@colyseus/schema ${this.ref.constructor.name}: trying to delete non-existing index '${index}'`);
-            }
-            catch (e) {
-                console.warn(e);
-            }
-            return;
+    if (value >= 0) {
+        // positive fixnum
+        if (value < 0x80) {
+            bytes[it.offset++] = value & 255; // uint8
+            return 1;
         }
-        const metadata = this.ref['constructor'][Symbol.metadata];
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
-        const changeSet = (isFiltered)
-            ? 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"
-            //
-            // This method is being called at decoding time when a DELETE operation is found.
-            //
-            // - This is due to using the concrete Schema class at decoding time.
-            // - "Reflected" structures do not have this problem.
-            //
-            // (the property descriptors should NOT be used at decoding time. only at encoding time.)
-            //
-            this.root?.remove(previousValue[$changes]);
+        // uint 8
+        if (value < 0x100) {
+            bytes[it.offset++] = 0xcc;
+            bytes[it.offset++] = value & 255; // uint8
+            return 2;
         }
-        //
-        // FIXME: this is looking a bit ugly (and repeated from `.change()`)
-        //
-        if (isFiltered) {
-            this.root?.filteredChanges.set(this, this.filteredChanges);
-            this.allFilteredChanges.delete(allChangesIndex);
+        // uint 16
+        if (value < 0x10000) {
+            bytes[it.offset++] = 0xcd;
+            uint16$1(bytes, value, it);
+            return 3;
         }
-        else {
-            this.root?.changes.set(this, this.changes);
-            this.allChanges.delete(allChangesIndex);
+        // uint 32
+        if (value < 0x100000000) {
+            bytes[it.offset++] = 0xce;
+            uint32$1(bytes, value, it);
+            return 5;
         }
+        // uint 64
+        bytes[it.offset++] = 0xcf;
+        uint64$1(bytes, value, it);
+        return 9;
     }
-    endEncode() {
-        this.changes.clear();
-        this.ref[$onEncodeEnd]?.();
-        // Not a new instance anymore
-        delete this[$isNew];
-    }
-    discard(discardAll = false) {
-        //
-        // > MapSchema:
-        //      Remove cached key to ensure ADD operations is unsed instead of
-        //      REPLACE in case same key is used on next patches.
-        //
-        this.ref[$onEncodeEnd]?.();
-        this.changes.clear();
-        this.filteredChanges.clear();
-        // reset operation index
-        this.currentOperationIndex = 0;
-        if (discardAll) {
-            this.allChanges.clear();
-            this.allFilteredChanges.clear();
-            // remove children references
-            this.forEachChild((changeTree, _) => this.root?.remove(changeTree));
+    else {
+        // negative fixnum
+        if (value >= -32) {
+            bytes[it.offset++] = 0xe0 | (value + 0x20);
+            return 1;
         }
-    }
-    /**
-     * Recursively discard all changes from this, and child structures.
-     */
-    discardAll() {
-        this.changes.forEach((_, fieldIndex) => {
-            const value = this.getValue(fieldIndex);
-            if (value && value[$changes]) {
-                value[$changes].discardAll();
-            }
-        });
-        this.discard();
-    }
-    ensureRefId() {
-        // skip if refId is already set.
-        if (this.refId !== undefined) {
-            return;
+        // int 8
+        if (value >= -128) {
+            bytes[it.offset++] = 0xd0;
+            int8$1(bytes, value, it);
+            return 2;
         }
-        this.refId = this.root.getNextUniqueId();
-    }
-    get changed() {
-        return this.changes.size > 0;
-    }
-    checkIsFiltered(parent, parentIndex) {
-        // Detect if current structure has "filters" declared
-        this.isPartiallyFiltered = this.ref['constructor']?.[Symbol.metadata]?.[-2];
-        // TODO: support "partially filtered", where the instance is visible, but only a field is not.
-        // Detect if parent has "filters" declared
-        while (parent && !this.isFiltered) {
-            const metadata = parent['constructor'][Symbol.metadata];
-            const fieldName = metadata?.[parentIndex];
-            const isParentOwned = metadata?.[fieldName]?.tag !== undefined;
-            this.isFiltered = isParentOwned || parent[$changes].isFiltered; // metadata?.[-2]
-            parent = parent[$changes].parent;
+        // int 16
+        if (value >= -32768) {
+            bytes[it.offset++] = 0xd1;
+            int16$1(bytes, value, it);
+            return 3;
         }
-        //
-        // 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;
+        // int 32
+        if (value >= -2147483648) {
+            bytes[it.offset++] = 0xd2;
+            int32$1(bytes, value, it);
+            return 5;
         }
+        // int 64
+        bytes[it.offset++] = 0xd3;
+        int64$1(bytes, value, it);
+        return 9;
     }
 }
+const encode = {
+    int8: int8$1,
+    uint8: uint8$1,
+    int16: int16$1,
+    uint16: uint16$1,
+    int32: int32$1,
+    uint32: uint32$1,
+    int64: int64$1,
+    uint64: uint64$1,
+    bigint64: bigint64$1,
+    biguint64: biguint64$1,
+    float32: float32$1,
+    float64: float64$1,
+    boolean: boolean$1,
+    string: string$1,
+    number: number$1,
+    utf8Write,
+    utf8Length,
+};
 
 /**
  * Copyright (c) 2018 Endel Dreyer
@@ -553,698 +372,1150 @@ class ChangeTree {
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE
  */
-/**
- * msgpack implementation highly based on notepack.io
- * https://github.com/darrachequesne/notepack
- */
-let textEncoder;
-// @ts-ignore
-try {
-    textEncoder = new TextEncoder();
-}
-catch (e) { }
-const hasBufferByteLength = (typeof Buffer !== 'undefined' && Buffer.byteLength);
-const utf8Length = (hasBufferByteLength)
-    ? Buffer.byteLength // node
-    : function (str, _) {
-        var c = 0, length = 0;
-        for (var i = 0, l = str.length; i < l; i++) {
-            c = str.charCodeAt(i);
-            if (c < 0x80) {
-                length += 1;
-            }
-            else if (c < 0x800) {
-                length += 2;
-            }
-            else if (c < 0xd800 || c >= 0xe000) {
-                length += 3;
-            }
-            else {
-                i++;
-                length += 4;
-            }
-        }
-        return length;
-    };
-function utf8Write(view, str, it) {
-    var c = 0;
-    for (var i = 0, l = str.length; i < l; i++) {
-        c = str.charCodeAt(i);
-        if (c < 0x80) {
-            view[it.offset++] = c;
+// force little endian to facilitate decoding on multiple implementations
+const _convoBuffer = new ArrayBuffer(8);
+const _int32 = new Int32Array(_convoBuffer);
+const _float32 = new Float32Array(_convoBuffer);
+const _float64 = new Float64Array(_convoBuffer);
+const _uint64 = new BigUint64Array(_convoBuffer);
+const _int64 = new BigInt64Array(_convoBuffer);
+function utf8Read(bytes, it, length) {
+    var string = '', chr = 0;
+    for (var i = it.offset, end = it.offset + length; i < end; i++) {
+        var byte = bytes[i];
+        if ((byte & 0x80) === 0x00) {
+            string += String.fromCharCode(byte);
+            continue;
         }
-        else if (c < 0x800) {
-            view[it.offset++] = 0xc0 | (c >> 6);
-            view[it.offset++] = 0x80 | (c & 0x3f);
+        if ((byte & 0xe0) === 0xc0) {
+            string += String.fromCharCode(((byte & 0x1f) << 6) |
+                (bytes[++i] & 0x3f));
+            continue;
         }
-        else if (c < 0xd800 || c >= 0xe000) {
-            view[it.offset++] = 0xe0 | (c >> 12);
-            view[it.offset++] = 0x80 | (c >> 6 & 0x3f);
-            view[it.offset++] = 0x80 | (c & 0x3f);
+        if ((byte & 0xf0) === 0xe0) {
+            string += String.fromCharCode(((byte & 0x0f) << 12) |
+                ((bytes[++i] & 0x3f) << 6) |
+                ((bytes[++i] & 0x3f) << 0));
+            continue;
         }
-        else {
-            i++;
-            c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
-            view[it.offset++] = 0xf0 | (c >> 18);
-            view[it.offset++] = 0x80 | (c >> 12 & 0x3f);
-            view[it.offset++] = 0x80 | (c >> 6 & 0x3f);
-            view[it.offset++] = 0x80 | (c & 0x3f);
+        if ((byte & 0xf8) === 0xf0) {
+            chr = ((byte & 0x07) << 18) |
+                ((bytes[++i] & 0x3f) << 12) |
+                ((bytes[++i] & 0x3f) << 6) |
+                ((bytes[++i] & 0x3f) << 0);
+            if (chr >= 0x010000) { // surrogate pair
+                chr -= 0x010000;
+                string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
+            }
+            else {
+                string += String.fromCharCode(chr);
+            }
+            continue;
         }
+        console.error('Invalid byte ' + byte.toString(16));
+        // (do not throw error to avoid server/client from crashing due to hack attemps)
+        // throw new Error('Invalid byte ' + byte.toString(16));
     }
+    it.offset += length;
+    return string;
 }
-function int8$1(bytes, value, it) {
-    bytes[it.offset++] = value & 255;
+function int8(bytes, it) {
+    return uint8(bytes, it) << 24 >> 24;
 }
-function uint8$1(bytes, value, it) {
-    bytes[it.offset++] = value & 255;
+function uint8(bytes, it) {
+    return bytes[it.offset++];
 }
-function int16$1(bytes, value, it) {
-    bytes[it.offset++] = value & 255;
-    bytes[it.offset++] = (value >> 8) & 255;
+function int16(bytes, it) {
+    return uint16(bytes, it) << 16 >> 16;
 }
-function uint16$1(bytes, value, it) {
-    bytes[it.offset++] = value & 255;
-    bytes[it.offset++] = (value >> 8) & 255;
+function uint16(bytes, it) {
+    return bytes[it.offset++] | bytes[it.offset++] << 8;
 }
-function int32$1(bytes, value, it) {
-    bytes[it.offset++] = value & 255;
-    bytes[it.offset++] = (value >> 8) & 255;
-    bytes[it.offset++] = (value >> 16) & 255;
-    bytes[it.offset++] = (value >> 24) & 255;
+function int32(bytes, it) {
+    return bytes[it.offset++] | bytes[it.offset++] << 8 | bytes[it.offset++] << 16 | bytes[it.offset++] << 24;
 }
-function uint32$1(bytes, value, it) {
-    const b4 = value >> 24;
-    const b3 = value >> 16;
-    const b2 = value >> 8;
-    const b1 = value;
-    bytes[it.offset++] = b1 & 255;
-    bytes[it.offset++] = b2 & 255;
-    bytes[it.offset++] = b3 & 255;
-    bytes[it.offset++] = b4 & 255;
+function uint32(bytes, it) {
+    return int32(bytes, it) >>> 0;
 }
-function int64$1(bytes, value, it) {
-    const high = Math.floor(value / Math.pow(2, 32));
-    const low = value >>> 0;
-    uint32$1(bytes, low, it);
-    uint32$1(bytes, high, it);
+function float32(bytes, it) {
+    _int32[0] = int32(bytes, it);
+    return _float32[0];
 }
-function uint64$1(bytes, value, it) {
-    const high = (value / Math.pow(2, 32)) >> 0;
-    const low = value >>> 0;
-    uint32$1(bytes, low, it);
-    uint32$1(bytes, high, it);
+function float64(bytes, it) {
+    _int32[0 ] = int32(bytes, it);
+    _int32[1 ] = int32(bytes, it);
+    return _float64[0];
 }
-function float32$1(bytes, value, it) {
-    writeFloat32(bytes, value, it);
+function int64(bytes, it) {
+    const low = uint32(bytes, it);
+    const high = int32(bytes, it) * Math.pow(2, 32);
+    return high + low;
 }
-function float64$1(bytes, value, it) {
-    writeFloat64(bytes, value, it);
+function uint64(bytes, it) {
+    const low = uint32(bytes, it);
+    const high = uint32(bytes, it) * Math.pow(2, 32);
+    return high + low;
 }
-const _int32$1 = new Int32Array(2);
-const _float32$1 = new Float32Array(_int32$1.buffer);
-const _float64$1 = new Float64Array(_int32$1.buffer);
-function writeFloat32(bytes, value, it) {
-    _float32$1[0] = value;
-    int32$1(bytes, _int32$1[0], it);
+function bigint64(bytes, it) {
+    _int32[0] = int32(bytes, it);
+    _int32[1] = int32(bytes, it);
+    return _int64[0];
 }
-function writeFloat64(bytes, value, it) {
-    _float64$1[0] = value;
-    int32$1(bytes, _int32$1[0 ], it);
-    int32$1(bytes, _int32$1[1 ], it);
+function biguint64(bytes, it) {
+    _int32[0] = int32(bytes, it);
+    _int32[1] = int32(bytes, it);
+    return _uint64[0];
 }
-function boolean$1(bytes, value, it) {
-    bytes[it.offset++] = value ? 1 : 0; // uint8
+function boolean(bytes, it) {
+    return uint8(bytes, it) > 0;
 }
-function string$1(bytes, value, it) {
-    // encode `null` strings as empty.
-    if (!value) {
-        value = "";
-    }
-    let length = utf8Length(value, "utf8");
-    let size = 0;
-    // fixstr
-    if (length < 0x20) {
-        bytes[it.offset++] = length | 0xa0;
-        size = 1;
-    }
-    // str 8
-    else if (length < 0x100) {
-        bytes[it.offset++] = 0xd9;
-        bytes[it.offset++] = length % 255;
-        size = 2;
+function string(bytes, it) {
+    const prefix = bytes[it.offset++];
+    let length;
+    if (prefix < 0xc0) {
+        // fixstr
+        length = prefix & 0x1f;
     }
-    // str 16
-    else if (length < 0x10000) {
-        bytes[it.offset++] = 0xda;
-        uint16$1(bytes, length, it);
-        size = 3;
+    else if (prefix === 0xd9) {
+        length = uint8(bytes, it);
     }
-    // str 32
-    else if (length < 0x100000000) {
-        bytes[it.offset++] = 0xdb;
-        uint32$1(bytes, length, it);
-        size = 5;
+    else if (prefix === 0xda) {
+        length = uint16(bytes, it);
     }
-    else {
-        throw new Error('String too long');
+    else if (prefix === 0xdb) {
+        length = uint32(bytes, it);
     }
-    utf8Write(bytes, value, it);
-    return size + length;
+    return utf8Read(bytes, it, length);
 }
-function number$1(bytes, value, it) {
-    if (isNaN(value)) {
-        return number$1(bytes, 0, it);
+function number(bytes, it) {
+    const prefix = bytes[it.offset++];
+    if (prefix < 0x80) {
+        // positive fixint
+        return prefix;
     }
-    else if (!isFinite(value)) {
-        return number$1(bytes, (value > 0) ? Number.MAX_SAFE_INTEGER : -Number.MAX_SAFE_INTEGER, it);
+    else if (prefix === 0xca) {
+        // float 32
+        return float32(bytes, it);
     }
-    else if (value !== (value | 0)) {
-        bytes[it.offset++] = 0xcb;
-        writeFloat64(bytes, value, it);
-        return 9;
-        // TODO: encode float 32?
-        // is it possible to differentiate between float32 / float64 here?
-        // // float 32
-        // bytes.push(0xca);
-        // writeFloat32(bytes, value);
-        // return 5;
+    else if (prefix === 0xcb) {
+        // float 64
+        return float64(bytes, it);
     }
-    if (value >= 0) {
-        // positive fixnum
-        if (value < 0x80) {
-            bytes[it.offset++] = value & 255; // uint8
-            return 1;
-        }
+    else if (prefix === 0xcc) {
         // uint 8
-        if (value < 0x100) {
-            bytes[it.offset++] = 0xcc;
-            bytes[it.offset++] = value & 255; // uint8
-            return 2;
-        }
+        return uint8(bytes, it);
+    }
+    else if (prefix === 0xcd) {
         // uint 16
-        if (value < 0x10000) {
-            bytes[it.offset++] = 0xcd;
-            uint16$1(bytes, value, it);
-            return 3;
-        }
+        return uint16(bytes, it);
+    }
+    else if (prefix === 0xce) {
         // uint 32
-        if (value < 0x100000000) {
-            bytes[it.offset++] = 0xce;
-            uint32$1(bytes, value, it);
-            return 5;
-        }
+        return uint32(bytes, it);
+    }
+    else if (prefix === 0xcf) {
         // uint 64
-        bytes[it.offset++] = 0xcf;
-        uint64$1(bytes, value, it);
-        return 9;
+        return uint64(bytes, it);
     }
-    else {
-        // negative fixnum
-        if (value >= -0x20) {
-            bytes[it.offset++] = 0xe0 | (value + 0x20);
-            return 1;
-        }
+    else if (prefix === 0xd0) {
         // int 8
-        if (value >= -0x80) {
-            bytes[it.offset++] = 0xd0;
-            int8$1(bytes, value, it);
-            return 2;
-        }
+        return int8(bytes, it);
+    }
+    else if (prefix === 0xd1) {
         // int 16
-        if (value >= -0x8000) {
-            bytes[it.offset++] = 0xd1;
-            int16$1(bytes, value, it);
-            return 3;
-        }
+        return int16(bytes, it);
+    }
+    else if (prefix === 0xd2) {
         // int 32
-        if (value >= -0x80000000) {
-            bytes[it.offset++] = 0xd2;
-            int32$1(bytes, value, it);
-            return 5;
-        }
-        // int 64
-        bytes[it.offset++] = 0xd3;
-        int64$1(bytes, value, it);
-        return 9;
+        return int32(bytes, it);
     }
-}
-
-var encode = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    utf8Length: utf8Length,
-    utf8Write: utf8Write,
-    int8: int8$1,
-    uint8: uint8$1,
-    int16: int16$1,
-    uint16: uint16$1,
-    int32: int32$1,
-    uint32: uint32$1,
-    int64: int64$1,
-    uint64: uint64$1,
-    float32: float32$1,
-    float64: float64$1,
-    writeFloat32: writeFloat32,
-    writeFloat64: writeFloat64,
-    boolean: boolean$1,
-    string: string$1,
-    number: number$1
-});
-
-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;
+    else if (prefix === 0xd3) {
+        // int 64
+        return int64(bytes, it);
     }
-    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}`);
+    else if (prefix > 0xdf) {
+        // negative fixint
+        return (0xff - prefix + 1) * -1;
     }
 }
-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 stringCheck(bytes, it) {
+    const prefix = bytes[it.offset];
+    return (
+    // fixstr
+    (prefix < 0xc0 && prefix > 0xa0) ||
+        // str 8
+        prefix === 0xd9 ||
+        // str 16
+        prefix === 0xda ||
+        // str 32
+        prefix === 0xdb);
 }
+const decode = {
+    utf8Read,
+    int8,
+    uint8,
+    int16,
+    uint16,
+    int32,
+    uint32,
+    float32,
+    float64,
+    int64,
+    uint64,
+    bigint64,
+    biguint64,
+    boolean,
+    string,
+    number,
+    stringCheck,
+};
 
-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, ref, type, value, field, operation, it) {
-    if (type[Symbol.metadata] !== undefined) {
-        // TODO: move this to the `@type()` annotation
-        assertInstanceType(value, type, ref, field);
-        //
-        // Encode refId for this instance.
-        // The actual instance is going to be encoded on next `changeTree` iteration.
-        //
-        number$1(bytes, value[$changes].refId, it);
-        // Try to encode inherited TYPE_ID if it's an ADD operation.
-        if ((operation & exports.OPERATION.ADD) === exports.OPERATION.ADD) {
-            encoder.tryEncodeTypeId(bytes, type, value.constructor, it);
-        }
+const registeredTypes = {};
+const identifiers = new Map();
+function registerType(identifier, definition) {
+    if (definition.constructor) {
+        identifiers.set(definition.constructor, identifier);
+        registeredTypes[identifier] = definition;
     }
-    else if (typeof (type) === "string") {
-        //
-        // Primitive values
-        //
-        encodePrimitiveType(type, bytes, value, ref, field, it);
+    if (definition.encode) {
+        encode[identifier] = definition.encode;
     }
-    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.
-        //
-        number$1(bytes, value[$changes].refId, it);
+    if (definition.decode) {
+        decode[identifier] = definition.decode;
     }
 }
-/**
- * Used for Schema instances.
- * @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;
-    }
-    // TODO: inline this function call small performance gain
-    encodeValue(encoder, bytes, ref, type, value, field, operation, it);
-};
-/**
- * Used for collections (MapSchema, CollectionSchema, SetSchema)
- * @private
- */
-const encodeKeyValueOperation = function (encoder, bytes, changeTree, field, operation, it) {
-    const ref = changeTree.ref;
-    // encode operation
-    bytes[it.offset++] = operation & 255;
-    // custom operations
-    if (operation === exports.OPERATION.CLEAR) {
-        return;
+function getType(identifier) {
+    return registeredTypes[identifier];
+}
+function defineCustomTypes(types) {
+    for (const identifier in types) {
+        registerType(identifier, types[identifier]);
     }
-    // encode index
-    number$1(bytes, field, it);
-    // Do not encode value for DELETE operations
-    if (operation === exports.OPERATION.DELETE) {
-        return;
+    return (t) => type(t);
+}
+
+class TypeContext {
+    /**
+     * For inheritance support
+     * Keeps track of which classes extends which. (parent -> children)
+     */
+    static { this.inheritedTypes = new Map(); }
+    static register(target) {
+        const parent = Object.getPrototypeOf(target);
+        if (parent !== Schema) {
+            let inherits = TypeContext.inheritedTypes.get(parent);
+            if (!inherits) {
+                inherits = new Set();
+                TypeContext.inheritedTypes.set(parent, inherits);
+            }
+            inherits.add(target);
+        }
     }
-    //
-    // encode "alias" for dynamic fields (maps)
-    //
-    if ((operation & exports.OPERATION.ADD) == exports.OPERATION.ADD) { // ADD or DELETE_AND_ADD
-        if (typeof (ref['set']) === "function") {
+    constructor(rootClass) {
+        this.types = {};
+        this.schemas = new Map();
+        this.hasFilters = false;
+        this.parentFiltered = {};
+        if (rootClass) {
             //
-            // MapSchema dynamic key
+            // TODO:
+            //      cache "discoverTypes" results for each rootClass
+            //      to avoid re-discovering types for each new context/room
             //
-            const dynamicIndex = changeTree.ref['$indexes'].get(field);
-            string$1(bytes, dynamicIndex, it);
+            this.discoverTypes(rootClass);
         }
     }
-    const type = changeTree.getType(field);
-    const value = changeTree.getValue(field);
-    // TODO: inline this function call small performance gain
-    encodeValue(encoder, bytes, ref, type, value, field, operation, it);
-};
-/**
- * Used for collections (MapSchema, ArraySchema, etc.)
- * @private
- */
-const encodeArray = function (encoder, bytes, changeTree, field, operation, it, isEncodeAll, hasView) {
-    const ref = changeTree.ref;
-    if (hasView &&
-        operation === exports.OPERATION.DELETE &&
-        typeof (changeTree.getType(field)) !== "string") {
-        // encode delete by refId (array of schemas)
-        bytes[it.offset++] = exports.OPERATION.DELETE_BY_REFID;
-        const value = ref['tmpItems'][field];
-        const refId = value[$changes].refId;
-        number$1(bytes, refId, it);
-        return;
+    has(schema) {
+        return this.schemas.has(schema);
     }
-    // encode operation
-    bytes[it.offset++] = operation & 255;
-    // custom operations
-    if (operation === exports.OPERATION.CLEAR) {
-        return;
+    get(typeid) {
+        return this.types[typeid];
     }
-    // encode index
-    number$1(bytes, field, it);
-    // Do not encode value for DELETE operations
-    if (operation === exports.OPERATION.DELETE) {
-        return;
+    add(schema, typeid = this.schemas.size) {
+        // skip if already registered
+        if (this.schemas.has(schema)) {
+            return false;
+        }
+        this.types[typeid] = schema;
+        //
+        // Workaround to allow using an empty Schema (with no `@type()` fields)
+        //
+        if (schema[Symbol.metadata] === undefined) {
+            Metadata.initialize(schema);
+        }
+        this.schemas.set(schema, typeid);
+        return true;
     }
-    const type = changeTree.getType(field);
-    const value = changeTree.getValue(field, isEncodeAll);
-    // console.log("encodeArray -> ", {
-    //     ref: changeTree.ref.constructor.name,
-    //     field,
-    //     operation: OPERATION[operation],
-    //     value: value?.toJSON(),
-    //     items: ref.toJSON(),
-    // });
-    // TODO: inline this function call small performance gain
-    encodeValue(encoder, bytes, ref, type, value, field, operation, it);
-};
-
-/**
- * Copyright (c) 2018 Endel Dreyer
- * Copyright (c) 2014 Ion Drive Software Ltd.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE
- */
-function utf8Read(bytes, it, length) {
-    var string = '', chr = 0;
-    for (var i = it.offset, end = it.offset + length; i < end; i++) {
-        var byte = bytes[i];
-        if ((byte & 0x80) === 0x00) {
-            string += String.fromCharCode(byte);
-            continue;
+    getTypeId(klass) {
+        return this.schemas.get(klass);
+    }
+    discoverTypes(klass, parentType, parentIndex, parentHasViewTag) {
+        if (parentHasViewTag) {
+            this.registerFilteredByParent(klass, parentType, parentIndex);
         }
-        if ((byte & 0xe0) === 0xc0) {
-            string += String.fromCharCode(((byte & 0x1f) << 6) |
-                (bytes[++i] & 0x3f));
-            continue;
+        // skip if already registered
+        if (!this.add(klass)) {
+            return;
         }
-        if ((byte & 0xf0) === 0xe0) {
-            string += String.fromCharCode(((byte & 0x0f) << 12) |
-                ((bytes[++i] & 0x3f) << 6) |
-                ((bytes[++i] & 0x3f) << 0));
-            continue;
+        // add classes inherited from this base class
+        TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
+            this.discoverTypes(child, parentType, parentIndex, parentHasViewTag);
+        });
+        // add parent classes
+        let parent = klass;
+        while ((parent = Object.getPrototypeOf(parent)) &&
+            parent !== Schema && // stop at root (Schema)
+            parent !== Function.prototype // stop at root (non-Schema)
+        ) {
+            this.discoverTypes(parent);
+        }
+        const metadata = (klass[Symbol.metadata] ??= {});
+        // if any schema/field has filters, mark "context" as having filters.
+        if (metadata[$viewFieldIndexes]) {
+            this.hasFilters = true;
         }
-        if ((byte & 0xf8) === 0xf0) {
-            chr = ((byte & 0x07) << 18) |
-                ((bytes[++i] & 0x3f) << 12) |
-                ((bytes[++i] & 0x3f) << 6) |
-                ((bytes[++i] & 0x3f) << 0);
-            if (chr >= 0x010000) { // surrogate pair
-                chr -= 0x010000;
-                string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
+        for (const fieldIndex in metadata) {
+            const index = fieldIndex;
+            const fieldType = metadata[index].type;
+            const fieldHasViewTag = (metadata[index].tag !== undefined);
+            if (typeof (fieldType) === "string") {
+                continue;
+            }
+            if (Array.isArray(fieldType)) {
+                const type = fieldType[0];
+                // skip primitive types
+                if (type === "string") {
+                    continue;
+                }
+                this.discoverTypes(type, klass, index, parentHasViewTag || fieldHasViewTag);
+            }
+            else if (typeof (fieldType) === "function") {
+                this.discoverTypes(fieldType, klass, index, parentHasViewTag || fieldHasViewTag);
             }
             else {
-                string += String.fromCharCode(chr);
+                const type = Object.values(fieldType)[0];
+                // skip primitive types
+                if (typeof (type) === "string") {
+                    continue;
+                }
+                this.discoverTypes(type, klass, index, parentHasViewTag || fieldHasViewTag);
             }
-            continue;
         }
-        console.error('Invalid byte ' + byte.toString(16));
-        // (do not throw error to avoid server/client from crashing due to hack attemps)
-        // throw new Error('Invalid byte ' + byte.toString(16));
     }
-    it.offset += length;
-    return string;
-}
-function int8(bytes, it) {
-    return uint8(bytes, it) << 24 >> 24;
-}
-function uint8(bytes, it) {
-    return bytes[it.offset++];
-}
-function int16(bytes, it) {
-    return uint16(bytes, it) << 16 >> 16;
-}
-function uint16(bytes, it) {
-    return bytes[it.offset++] | bytes[it.offset++] << 8;
-}
-function int32(bytes, it) {
-    return bytes[it.offset++] | bytes[it.offset++] << 8 | bytes[it.offset++] << 16 | bytes[it.offset++] << 24;
-}
-function uint32(bytes, it) {
-    return int32(bytes, it) >>> 0;
-}
-function float32(bytes, it) {
-    return readFloat32(bytes, it);
-}
-function float64(bytes, it) {
-    return readFloat64(bytes, it);
-}
-function int64(bytes, it) {
-    const low = uint32(bytes, it);
-    const high = int32(bytes, it) * Math.pow(2, 32);
-    return high + low;
+    /**
+     * Keep track of which classes have filters applied.
+     * Format: `${typeid}-${parentTypeid}-${parentIndex}`
+     */
+    registerFilteredByParent(schema, parentType, parentIndex) {
+        const typeid = this.schemas.get(schema) ?? this.schemas.size;
+        let key = `${typeid}`;
+        if (parentType) {
+            key += `-${this.schemas.get(parentType)}`;
+        }
+        key += `-${parentIndex}`;
+        this.parentFiltered[key] = true;
+    }
+    debug() {
+        let parentFiltered = "";
+        for (const key in this.parentFiltered) {
+            const keys = key.split("-").map(Number);
+            const fieldIndex = keys.pop();
+            parentFiltered += `\n\t\t`;
+            parentFiltered += `${key}: ${keys.reverse().map((id, i) => {
+                const klass = this.types[id];
+                const metadata = klass[Symbol.metadata];
+                let txt = klass.name;
+                if (i === 0) {
+                    txt += `[${metadata[fieldIndex].name}]`;
+                }
+                return `${txt}`;
+            }).join(" -> ")}`;
+        }
+        return `TypeContext ->\n` +
+            `\tSchema types: ${this.schemas.size}\n` +
+            `\thasFilters: ${this.hasFilters}\n` +
+            `\tparentFiltered:${parentFiltered}`;
+    }
 }
-function uint64(bytes, it) {
-    const low = uint32(bytes, it);
-    const high = uint32(bytes, it) * Math.pow(2, 32);
-    return high + low;
+
+function getNormalizedType(type) {
+    return (Array.isArray(type))
+        ? { array: type[0] }
+        : (typeof (type['type']) !== "undefined")
+            ? type['type']
+            : type;
 }
-const _int32 = new Int32Array(2);
-const _float32 = new Float32Array(_int32.buffer);
-const _float64 = new Float64Array(_int32.buffer);
-function readFloat32(bytes, it) {
-    _int32[0] = int32(bytes, it);
-    return _float32[0];
+const Metadata = {
+    addField(metadata, index, name, type, descriptor) {
+        if (index > 64) {
+            throw new Error(`Can't define field '${name}'.\nSchema instances may only have up to 64 fields.`);
+        }
+        metadata[index] = Object.assign(metadata[index] || {}, // avoid overwriting previous field metadata (@owned / @deprecated)
+        {
+            type: getNormalizedType(type),
+            index,
+            name,
+        });
+        // create "descriptors" map
+        Object.defineProperty(metadata, $descriptors, {
+            value: metadata[$descriptors] || {},
+            enumerable: false,
+            configurable: true,
+        });
+        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, $numFields, {
+            value: index,
+            enumerable: false,
+            configurable: true
+        });
+        // 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[$refTypeFieldIndexes] === undefined) {
+                Object.defineProperty(metadata, $refTypeFieldIndexes, {
+                    value: [],
+                    enumerable: false,
+                    configurable: true,
+                });
+            }
+            metadata[$refTypeFieldIndexes].push(index);
+        }
+    },
+    setTag(metadata, fieldName, tag) {
+        const index = metadata[fieldName];
+        const field = metadata[index];
+        // add 'tag' to the field
+        field.tag = tag;
+        if (!metadata[$viewFieldIndexes]) {
+            // -2: all field indexes with "view" tag
+            Object.defineProperty(metadata, $viewFieldIndexes, {
+                value: [],
+                enumerable: false,
+                configurable: true
+            });
+            // -3: field indexes by "view" tag
+            Object.defineProperty(metadata, $fieldIndexesByViewTag, {
+                value: {},
+                enumerable: false,
+                configurable: true
+            });
+        }
+        metadata[$viewFieldIndexes].push(index);
+        if (!metadata[$fieldIndexesByViewTag][tag]) {
+            metadata[$fieldIndexesByViewTag][tag] = [];
+        }
+        metadata[$fieldIndexesByViewTag][tag].push(index);
+    },
+    setFields(target, fields) {
+        // for inheritance support
+        const constructor = target.prototype.constructor;
+        TypeContext.register(constructor);
+        const parentClass = Object.getPrototypeOf(constructor);
+        const parentMetadata = parentClass && parentClass[Symbol.metadata];
+        const metadata = Metadata.initialize(constructor);
+        // Use Schema's methods if not defined in the class
+        if (!constructor[$track]) {
+            constructor[$track] = Schema[$track];
+        }
+        if (!constructor[$encoder]) {
+            constructor[$encoder] = Schema[$encoder];
+        }
+        if (!constructor[$decoder]) {
+            constructor[$decoder] = Schema[$decoder];
+        }
+        if (!constructor.prototype.toJSON) {
+            constructor.prototype.toJSON = Schema.prototype.toJSON;
+        }
+        //
+        // detect index for this field, considering inheritance
+        //
+        let fieldIndex = metadata[$numFields] // current structure already has fields defined
+            ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
+            ?? -1; // no fields defined
+        fieldIndex++;
+        for (const field in fields) {
+            const type = fields[field];
+            const normalizedType = getNormalizedType(type);
+            // FIXME: this code is duplicated from @type() annotation
+            const complexTypeKlass = (Array.isArray(type))
+                ? getType("array")
+                : (typeof (Object.keys(type)[0]) === "string") && getType(Object.keys(type)[0]);
+            const childType = (complexTypeKlass)
+                ? Object.values(type)[0]
+                : normalizedType;
+            Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass));
+            fieldIndex++;
+        }
+        return target;
+    },
+    isDeprecated(metadata, field) {
+        return metadata[field].deprecated === true;
+    },
+    init(klass) {
+        //
+        // Used only to initialize an empty Schema (Encoder#constructor)
+        // TODO: remove/refactor this...
+        //
+        const metadata = {};
+        klass[Symbol.metadata] = metadata;
+        Object.defineProperty(metadata, $numFields, {
+            value: 0,
+            enumerable: false,
+            configurable: true,
+        });
+    },
+    initialize(constructor) {
+        const parentClass = Object.getPrototypeOf(constructor);
+        const parentMetadata = parentClass[Symbol.metadata];
+        let metadata = constructor[Symbol.metadata] ?? Object.create(null);
+        // make sure inherited classes have their own metadata object.
+        if (parentClass !== Schema && metadata === parentMetadata) {
+            metadata = Object.create(null);
+            if (parentMetadata) {
+                //
+                // assign parent metadata to current
+                //
+                Object.setPrototypeOf(metadata, parentMetadata);
+                // $numFields
+                Object.defineProperty(metadata, $numFields, {
+                    value: parentMetadata[$numFields],
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
+                // $viewFieldIndexes / $fieldIndexesByViewTag
+                if (parentMetadata[$viewFieldIndexes] !== undefined) {
+                    Object.defineProperty(metadata, $viewFieldIndexes, {
+                        value: [...parentMetadata[$viewFieldIndexes]],
+                        enumerable: false,
+                        configurable: true,
+                        writable: true,
+                    });
+                    Object.defineProperty(metadata, $fieldIndexesByViewTag, {
+                        value: { ...parentMetadata[$fieldIndexesByViewTag] },
+                        enumerable: false,
+                        configurable: true,
+                        writable: true,
+                    });
+                }
+                // $refTypeFieldIndexes
+                if (parentMetadata[$refTypeFieldIndexes] !== undefined) {
+                    Object.defineProperty(metadata, $refTypeFieldIndexes, {
+                        value: [...parentMetadata[$refTypeFieldIndexes]],
+                        enumerable: false,
+                        configurable: true,
+                        writable: true,
+                    });
+                }
+                // $descriptors
+                Object.defineProperty(metadata, $descriptors, {
+                    value: { ...parentMetadata[$descriptors] },
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
+            }
+        }
+        constructor[Symbol.metadata] = metadata;
+        return metadata;
+    },
+    isValidInstance(klass) {
+        return (klass.constructor[Symbol.metadata] &&
+            Object.prototype.hasOwnProperty.call(klass.constructor[Symbol.metadata], $numFields));
+    },
+    getFields(klass) {
+        const metadata = klass[Symbol.metadata];
+        const fields = {};
+        for (let i = 0; i <= metadata[$numFields]; i++) {
+            fields[metadata[i].name] = metadata[i].type;
+        }
+        return fields;
+    }
+};
+
+function setOperationAtIndex(changeSet, index) {
+    const operationsIndex = changeSet.indexes[index];
+    if (operationsIndex === undefined) {
+        changeSet.indexes[index] = changeSet.operations.push(index) - 1;
+    }
+    else {
+        changeSet.operations[operationsIndex] = index;
+    }
 }
-function readFloat64(bytes, it) {
-    _int32[0 ] = int32(bytes, it);
-    _int32[1 ] = int32(bytes, it);
-    return _float64[0];
+function deleteOperationAtIndex(changeSet, index) {
+    const operationsIndex = changeSet.indexes[index];
+    if (operationsIndex !== undefined) {
+        changeSet.operations[operationsIndex] = undefined;
+    }
+    delete changeSet.indexes[index];
 }
-function boolean(bytes, it) {
-    return uint8(bytes, it) > 0;
+function enqueueChangeTree(root, changeTree, changeSet, queueRootIndex = changeTree[changeSet].queueRootIndex) {
+    if (root && root[changeSet][queueRootIndex] !== changeTree) {
+        changeTree[changeSet].queueRootIndex = root[changeSet].push(changeTree) - 1;
+    }
 }
-function string(bytes, it) {
-    const prefix = bytes[it.offset++];
-    let length;
-    if (prefix < 0xc0) {
-        // fixstr
-        length = prefix & 0x1f;
+class ChangeTree {
+    constructor(ref) {
+        /**
+         * Whether this structure is parent of a filtered structure.
+         */
+        this.isFiltered = false;
+        this.indexedOperations = {};
+        //
+        // TODO:
+        //   try storing the index + operation per item.
+        //   example: 1024 & 1025 => ADD, 1026 => DELETE
+        //
+        // => https://chatgpt.com/share/67107d0c-bc20-8004-8583-83b17dd7c196
+        //
+        this.changes = { indexes: {}, operations: [] };
+        this.allChanges = { indexes: {}, operations: [] };
+        /**
+         * Is this a new instance? Used on ArraySchema to determine OPERATION.MOVE_AND_ADD operation.
+         */
+        this.isNew = true;
+        this.ref = ref;
+        //
+        // Does this structure have "filters" declared?
+        //
+        const metadata = ref.constructor[Symbol.metadata];
+        if (metadata?.[$viewFieldIndexes]) {
+            this.allFilteredChanges = { indexes: {}, operations: [] };
+            this.filteredChanges = { indexes: {}, operations: [] };
+        }
     }
-    else if (prefix === 0xd9) {
-        length = uint8(bytes, it);
+    setRoot(root) {
+        this.root = root;
+        this.checkIsFiltered(this.parent, this.parentIndex);
+        // Recursively set root on child structures
+        const metadata = this.ref.constructor[Symbol.metadata];
+        if (metadata) {
+            metadata[$refTypeFieldIndexes]?.forEach((index) => {
+                const field = metadata[index];
+                const value = this.ref[field.name];
+                value?.[$changes].setRoot(root);
+            });
+        }
+        else if (this.ref[$childType] && typeof (this.ref[$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            this.ref.forEach((value, key) => {
+                value[$changes].setRoot(root);
+            });
+        }
     }
-    else if (prefix === 0xda) {
-        length = uint16(bytes, it);
+    setParent(parent, root, parentIndex) {
+        this.parent = parent;
+        this.parentIndex = parentIndex;
+        // avoid setting parents with empty `root`
+        if (!root) {
+            return;
+        }
+        // skip if parent is already set
+        if (root !== this.root) {
+            this.root = root;
+            this.checkIsFiltered(parent, parentIndex);
+        }
+        else {
+            root.add(this);
+        }
+        // assign same parent on child structures
+        const metadata = this.ref.constructor[Symbol.metadata];
+        if (metadata) {
+            metadata[$refTypeFieldIndexes]?.forEach((index) => {
+                const field = metadata[index];
+                const value = this.ref[field.name];
+                value?.[$changes].setParent(this.ref, root, index);
+            });
+        }
+        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);
+            });
+        }
     }
-    else if (prefix === 0xdb) {
-        length = uint32(bytes, it);
+    forEachChild(callback) {
+        //
+        // assign same parent on child structures
+        //
+        const metadata = this.ref.constructor[Symbol.metadata];
+        if (metadata) {
+            metadata[$refTypeFieldIndexes]?.forEach((index) => {
+                const field = metadata[index];
+                const value = this.ref[field.name];
+                if (value) {
+                    callback(value[$changes], index);
+                }
+            });
+        }
+        else if (this.ref[$childType] && typeof (this.ref[$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            this.ref.forEach((value, key) => {
+                callback(value[$changes], this.indexes[key] ?? key);
+            });
+        }
     }
-    return utf8Read(bytes, it, length);
-}
-function stringCheck(bytes, it) {
-    const prefix = bytes[it.offset];
-    return (
-    // fixstr
-    (prefix < 0xc0 && prefix > 0xa0) ||
-        // str 8
-        prefix === 0xd9 ||
-        // str 16
-        prefix === 0xda ||
-        // str 32
-        prefix === 0xdb);
-}
-function number(bytes, it) {
-    const prefix = bytes[it.offset++];
-    if (prefix < 0x80) {
-        // positive fixint
-        return prefix;
+    operation(op) {
+        // operations without index use negative values to represent them
+        // this is checked during .encode() time.
+        this.changes.operations.push(-op);
+        enqueueChangeTree(this.root, this, 'changes');
     }
-    else if (prefix === 0xca) {
-        // float 32
-        return readFloat32(bytes, it);
+    change(index, operation = exports.OPERATION.ADD) {
+        const metadata = this.ref.constructor[Symbol.metadata];
+        const isFiltered = this.isFiltered || (metadata?.[index]?.tag !== undefined);
+        const changeSet = (isFiltered)
+            ? this.filteredChanges
+            : this.changes;
+        const previousOperation = this.indexedOperations[index];
+        if (!previousOperation || previousOperation === exports.OPERATION.DELETE) {
+            const op = (!previousOperation)
+                ? operation
+                : (previousOperation === exports.OPERATION.DELETE)
+                    ? exports.OPERATION.DELETE_AND_ADD
+                    : operation;
+            //
+            // TODO: are DELETE operations being encoded as ADD here ??
+            //
+            this.indexedOperations[index] = op;
+        }
+        setOperationAtIndex(changeSet, index);
+        if (isFiltered) {
+            setOperationAtIndex(this.allFilteredChanges, index);
+            if (this.root) {
+                enqueueChangeTree(this.root, this, 'filteredChanges');
+                enqueueChangeTree(this.root, this, 'allFilteredChanges');
+            }
+        }
+        else {
+            setOperationAtIndex(this.allChanges, index);
+            enqueueChangeTree(this.root, this, 'changes');
+        }
+    }
+    shiftChangeIndexes(shiftIndex) {
+        //
+        // Used only during:
+        //
+        // - ArraySchema#unshift()
+        //
+        const changeSet = (this.isFiltered)
+            ? this.filteredChanges
+            : this.changes;
+        const newIndexedOperations = {};
+        const newIndexes = {};
+        for (const index in this.indexedOperations) {
+            newIndexedOperations[Number(index) + shiftIndex] = this.indexedOperations[index];
+            newIndexes[Number(index) + shiftIndex] = changeSet[index];
+        }
+        this.indexedOperations = newIndexedOperations;
+        changeSet.indexes = newIndexes;
+        changeSet.operations = changeSet.operations.map((index) => index + shiftIndex);
+    }
+    shiftAllChangeIndexes(shiftIndex, startIndex = 0) {
+        //
+        // Used only during:
+        //
+        // - ArraySchema#splice()
+        //
+        if (this.filteredChanges !== undefined) {
+            this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allFilteredChanges);
+            this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
+        }
+        else {
+            this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
+        }
+    }
+    _shiftAllChangeIndexes(shiftIndex, startIndex = 0, changeSet) {
+        const newIndexes = {};
+        for (const key in changeSet.indexes) {
+            const index = changeSet.indexes[key];
+            if (index > startIndex) {
+                newIndexes[Number(key) + shiftIndex] = index;
+            }
+            else {
+                newIndexes[key] = index;
+            }
+        }
+        changeSet.indexes = newIndexes;
+        for (let i = 0; i < changeSet.operations.length; i++) {
+            const index = changeSet.operations[i];
+            if (index > startIndex) {
+                changeSet.operations[i] = index + shiftIndex;
+            }
+        }
+    }
+    indexedOperation(index, operation, allChangesIndex = index) {
+        this.indexedOperations[index] = operation;
+        if (this.filteredChanges !== undefined) {
+            setOperationAtIndex(this.allFilteredChanges, allChangesIndex);
+            setOperationAtIndex(this.filteredChanges, index);
+            enqueueChangeTree(this.root, this, 'filteredChanges');
+        }
+        else {
+            setOperationAtIndex(this.allChanges, allChangesIndex);
+            setOperationAtIndex(this.changes, index);
+            enqueueChangeTree(this.root, this, 'changes');
+        }
+    }
+    getType(index) {
+        if (Metadata.isValidInstance(this.ref)) {
+            const metadata = this.ref.constructor[Symbol.metadata];
+            return metadata[index].type;
+        }
+        else {
+            //
+            // Get the child type from parent structure.
+            // - ["string"] => "string"
+            // - { map: "string" } => "string"
+            // - { set: "string" } => "string"
+            //
+            return this.ref[$childType];
+        }
+    }
+    getChange(index) {
+        return this.indexedOperations[index];
+    }
+    //
+    // used during `.encode()`
+    //
+    getValue(index, isEncodeAll = false) {
+        //
+        // `isEncodeAll` param is only used by ArraySchema
+        //
+        return this.ref[$getByIndex](index, isEncodeAll);
+    }
+    delete(index, operation, allChangesIndex = index) {
+        if (index === undefined) {
+            try {
+                throw new Error(`@colyseus/schema ${this.ref.constructor.name}: trying to delete non-existing index '${index}'`);
+            }
+            catch (e) {
+                console.warn(e);
+            }
+            return;
+        }
+        const changeSet = (this.filteredChanges !== undefined)
+            ? this.filteredChanges
+            : this.changes;
+        this.indexedOperations[index] = operation ?? exports.OPERATION.DELETE;
+        setOperationAtIndex(changeSet, index);
+        const previousValue = this.getValue(index);
+        // remove `root` reference
+        if (previousValue && previousValue[$changes]) {
+            //
+            // FIXME: this.root is "undefined"
+            //
+            // This method is being called at decoding time when a DELETE operation is found.
+            //
+            // - This is due to using the concrete Schema class at decoding time.
+            // - "Reflected" structures do not have this problem.
+            //
+            // (The property descriptors should NOT be used at decoding time. only at encoding time.)
+            //
+            this.root?.remove(previousValue[$changes]);
+        }
+        //
+        // FIXME: this is looking a ugly and repeated
+        //
+        if (this.filteredChanges !== undefined) {
+            deleteOperationAtIndex(this.allFilteredChanges, allChangesIndex);
+            enqueueChangeTree(this.root, this, 'filteredChanges');
+        }
+        else {
+            deleteOperationAtIndex(this.allChanges, allChangesIndex);
+            enqueueChangeTree(this.root, this, 'changes');
+        }
+    }
+    endEncode() {
+        this.indexedOperations = {};
+        // // clear changes
+        // this.changes.indexes = {};
+        // this.changes.operations.length = 0;
+        // ArraySchema and MapSchema have a custom "encode end" method
+        this.ref[$onEncodeEnd]?.();
+        // Not a new instance anymore
+        this.isNew = false;
+    }
+    discard(discardAll = false) {
+        //
+        // > MapSchema:
+        //      Remove cached key to ensure ADD operations is unsed instead of
+        //      REPLACE in case same key is used on next patches.
+        //
+        this.ref[$onEncodeEnd]?.();
+        this.indexedOperations = {};
+        this.changes.indexes = {};
+        this.changes.operations.length = 0;
+        this.changes.queueRootIndex = undefined;
+        if (this.filteredChanges !== undefined) {
+            this.filteredChanges.indexes = {};
+            this.filteredChanges.operations.length = 0;
+            this.filteredChanges.queueRootIndex = undefined;
+        }
+        if (discardAll) {
+            this.allChanges.indexes = {};
+            this.allChanges.operations.length = 0;
+            if (this.allFilteredChanges !== undefined) {
+                this.allFilteredChanges.indexes = {};
+                this.allFilteredChanges.operations.length = 0;
+            }
+            // remove children references
+            this.forEachChild((changeTree, _) => this.root?.remove(changeTree));
+        }
+    }
+    /**
+     * Recursively discard all changes from this, and child structures.
+     */
+    discardAll() {
+        const keys = Object.keys(this.indexedOperations);
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const value = this.getValue(Number(keys[i]));
+            if (value && value[$changes]) {
+                value[$changes].discardAll();
+            }
+        }
+        this.discard();
+    }
+    ensureRefId() {
+        // skip if refId is already set.
+        if (this.refId !== undefined) {
+            return;
+        }
+        this.refId = this.root.getNextUniqueId();
+    }
+    get changed() {
+        return (Object.entries(this.indexedOperations).length > 0);
+    }
+    checkIsFiltered(parent, parentIndex) {
+        const isNewChangeTree = this.root.add(this);
+        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._checkFilteredByParent(parent, parentIndex);
+            if (this.filteredChanges !== undefined) {
+                enqueueChangeTree(this.root, this, 'filteredChanges');
+                if (isNewChangeTree) {
+                    this.root.allFilteredChanges.push(this);
+                }
+            }
+        }
+        if (!this.isFiltered) {
+            enqueueChangeTree(this.root, this, 'changes');
+            if (isNewChangeTree) {
+                this.root.allChanges.push(this);
+            }
+        }
+    }
+    _checkFilteredByParent(parent, parentIndex) {
+        // skip if parent is not set
+        if (!parent) {
+            return;
+        }
+        //
+        // ArraySchema | MapSchema - get the child type
+        // (if refType is typeof string, the parentFiltered[key] below will always be invalid)
+        //
+        const refType = Metadata.isValidInstance(this.ref)
+            ? this.ref.constructor
+            : this.ref[$childType];
+        if (!Metadata.isValidInstance(parent)) {
+            const parentChangeTree = parent[$changes];
+            parent = parentChangeTree.parent;
+            parentIndex = parentChangeTree.parentIndex;
+        }
+        const parentConstructor = parent.constructor;
+        let key = `${this.root.types.getTypeId(refType)}`;
+        if (parentConstructor) {
+            key += `-${this.root.types.schemas.get(parentConstructor)}`;
+        }
+        key += `-${parentIndex}`;
+        this.isFiltered = parent[$changes].isFiltered // in case parent is already filtered
+            || this.root.types.parentFiltered[key];
+        // const parentMetadata = parentConstructor?.[Symbol.metadata];
+        // this.isFiltered = parentMetadata?.[$viewFieldIndexes]?.includes(parentIndex) || this.root.types.parentFiltered[key];
+        //
+        // TODO: refactor this!
+        //
+        //      swapping `changes` and `filteredChanges` is required here
+        //      because "isFiltered" may not be imedialely available on `change()`
+        //      (this happens when instance is detached from root or parent)
+        //
+        if (this.isFiltered) {
+            this.filteredChanges = { indexes: {}, operations: [] };
+            this.allFilteredChanges = { indexes: {}, operations: [] };
+            if (this.changes.operations.length > 0) {
+                // swap changes reference
+                const changes = this.changes;
+                this.changes = this.filteredChanges;
+                this.filteredChanges = changes;
+                // swap "all changes" reference
+                const allFilteredChanges = this.allFilteredChanges;
+                this.allFilteredChanges = this.allChanges;
+                this.allChanges = allFilteredChanges;
+            }
+        }
+    }
+}
+
+function encodeValue(encoder, bytes, type, value, operation, it) {
+    if (typeof (type) === "string") {
+        encode[type]?.(bytes, value, it);
     }
-    else if (prefix === 0xcb) {
-        // float 64
-        return readFloat64(bytes, it);
+    else if (type[Symbol.metadata] !== undefined) {
+        //
+        // Encode refId for this instance.
+        // The actual instance is going to be encoded on next `changeTree` iteration.
+        //
+        encode.number(bytes, value[$changes].refId, it);
+        // Try to encode inherited TYPE_ID if it's an ADD operation.
+        if ((operation & exports.OPERATION.ADD) === exports.OPERATION.ADD) {
+            encoder.tryEncodeTypeId(bytes, type, value.constructor, it);
+        }
     }
-    else if (prefix === 0xcc) {
-        // uint 8
-        return uint8(bytes, it);
+    else {
+        //
+        // Encode refId for this instance.
+        // The actual instance is going to be encoded on next `changeTree` iteration.
+        //
+        encode.number(bytes, value[$changes].refId, it);
     }
-    else if (prefix === 0xcd) {
-        // uint 16
-        return uint16(bytes, it);
+}
+/**
+ * Used for Schema instances.
+ * @private
+ */
+const encodeSchemaOperation = function (encoder, bytes, changeTree, index, operation, it, _, __, metadata) {
+    // "compress" field index + operation
+    bytes[it.offset++] = (index | operation) & 255;
+    // Do not encode value for DELETE operations
+    if (operation === exports.OPERATION.DELETE) {
+        return;
     }
-    else if (prefix === 0xce) {
-        // uint 32
-        return uint32(bytes, it);
+    const ref = changeTree.ref;
+    const field = metadata[index];
+    // TODO: inline this function call small performance gain
+    encodeValue(encoder, bytes, metadata[index].type, ref[field.name], operation, it);
+};
+/**
+ * Used for collections (MapSchema, CollectionSchema, SetSchema)
+ * @private
+ */
+const encodeKeyValueOperation = function (encoder, bytes, changeTree, index, operation, it) {
+    // encode operation
+    bytes[it.offset++] = operation & 255;
+    // custom operations
+    if (operation === exports.OPERATION.CLEAR) {
+        return;
     }
-    else if (prefix === 0xcf) {
-        // uint 64
-        return uint64(bytes, it);
+    // encode index
+    encode.number(bytes, index, it);
+    // Do not encode value for DELETE operations
+    if (operation === exports.OPERATION.DELETE) {
+        return;
     }
-    else if (prefix === 0xd0) {
-        // int 8
-        return int8(bytes, it);
+    const ref = changeTree.ref;
+    //
+    // encode "alias" for dynamic fields (maps)
+    //
+    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(index);
+            encode.string(bytes, dynamicIndex, it);
+        }
     }
-    else if (prefix === 0xd1) {
-        // int 16
-        return int16(bytes, it);
+    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")) {
+    //         console.log("encodeKeyValueOperation -> ", {
+    //             ref: changeTree.ref.constructor.name,
+    //             field,
+    //             operation: OPERATION[operation],
+    //             value: value?.toJSON(),
+    //             items: ref.toJSON(),
+    //         });
+    //     }
+    // }
+    // TODO: inline this function call small performance gain
+    encodeValue(encoder, bytes, type, value, operation, it);
+};
+/**
+ * Used for collections (MapSchema, ArraySchema, etc.)
+ * @private
+ */
+const encodeArray = function (encoder, bytes, changeTree, field, operation, it, isEncodeAll, hasView) {
+    const ref = changeTree.ref;
+    const useOperationByRefId = hasView && changeTree.isFiltered && (typeof (changeTree.getType(field)) !== "string");
+    let refOrIndex;
+    if (useOperationByRefId) {
+        refOrIndex = ref['tmpItems'][field][$changes].refId;
+        if (operation === exports.OPERATION.DELETE) {
+            operation = exports.OPERATION.DELETE_BY_REFID;
+        }
+        else if (operation === exports.OPERATION.ADD) {
+            operation = exports.OPERATION.ADD_BY_REFID;
+        }
     }
-    else if (prefix === 0xd2) {
-        // int 32
-        return int32(bytes, it);
+    else {
+        refOrIndex = field;
     }
-    else if (prefix === 0xd3) {
-        // int 64
-        return int64(bytes, it);
+    // encode operation
+    bytes[it.offset++] = operation & 255;
+    // custom operations
+    if (operation === exports.OPERATION.CLEAR ||
+        operation === exports.OPERATION.REVERSE) {
+        return;
     }
-    else if (prefix > 0xdf) {
-        // negative fixint
-        return (0xff - prefix + 1) * -1;
+    // encode index
+    encode.number(bytes, refOrIndex, it);
+    // Do not encode value for DELETE operations
+    if (operation === exports.OPERATION.DELETE) {
+        return;
     }
-}
-function numberCheck(bytes, it) {
-    const prefix = bytes[it.offset];
-    // positive fixint - 0x00 - 0x7f
-    // float 32        - 0xca
-    // float 64        - 0xcb
-    // uint 8          - 0xcc
-    // uint 16         - 0xcd
-    // uint 32         - 0xce
-    // uint 64         - 0xcf
-    // int 8           - 0xd0
-    // int 16          - 0xd1
-    // int 32          - 0xd2
-    // int 64          - 0xd3
-    return (prefix < 0x80 ||
-        (prefix >= 0xca && prefix <= 0xd3));
-}
-function arrayCheck(bytes, it) {
-    return bytes[it.offset] < 0xa0;
-    // const prefix = bytes[it.offset] ;
-    // if (prefix < 0xa0) {
-    //   return prefix;
-    // // array
-    // } else if (prefix === 0xdc) {
-    //   it.offset += 2;
-    // } else if (0xdd) {
-    //   it.offset += 4;
-    // }
-    // return prefix;
-}
-function switchStructureCheck(bytes, it) {
-    return (
-    // previous byte should be `SWITCH_TO_STRUCTURE`
-    bytes[it.offset - 1] === SWITCH_TO_STRUCTURE &&
-        // next byte should be a number
-        (bytes[it.offset] < 0x80 || (bytes[it.offset] >= 0xca && bytes[it.offset] <= 0xd3)));
-}
-
-var decode = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    utf8Read: utf8Read,
-    int8: int8,
-    uint8: uint8,
-    int16: int16,
-    uint16: uint16,
-    int32: int32,
-    uint32: uint32,
-    float32: float32,
-    float64: float64,
-    int64: int64,
-    uint64: uint64,
-    readFloat32: readFloat32,
-    readFloat64: readFloat64,
-    boolean: boolean,
-    string: string,
-    stringCheck: stringCheck,
-    number: number,
-    numberCheck: numberCheck,
-    arrayCheck: arrayCheck,
-    switchStructureCheck: switchStructureCheck
-});
+    const type = changeTree.getType(field);
+    const value = changeTree.getValue(field, isEncodeAll);
+    // console.log("encodeArray -> ", {
+    //     ref: changeTree.ref.constructor.name,
+    //     field,
+    //     operation: OPERATION[operation],
+    //     value: value?.toJSON(),
+    //     items: ref.toJSON(),
+    // });
+    // TODO: inline this function call small performance gain
+    encodeValue(encoder, bytes, type, value, operation, it);
+};
 
 const DEFINITION_MISMATCH = -1;
 function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges) {
@@ -1280,7 +1551,7 @@ function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges
     }
     if (operation === exports.OPERATION.DELETE) ;
     else if (Schema.is(type)) {
-        const refId = number(bytes, it);
+        const refId = decode.number(bytes, it);
         value = $root.refs.get(refId);
         if (previousValue) {
             const previousRefId = $root.refIds.get(previousValue);
@@ -1296,7 +1567,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") {
@@ -1307,7 +1580,7 @@ function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges
     }
     else {
         const typeDef = getType(Object.keys(type)[0]);
-        const refId = number(bytes, it);
+        const refId = decode.number(bytes, it);
         const valueRef = ($root.refs.has(refId))
             ? previousValue || $root.refs.get(refId)
             : new typeDef.constructor();
@@ -1347,18 +1620,19 @@ 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);
     // skip early if field is not defined
     const field = metadata[index];
     if (field === undefined) {
+        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) {
@@ -1366,7 +1640,7 @@ const decodeSchemaOperation = function (decoder, bytes, it, ref, allChanges) {
             ref,
             refId: decoder.currentRefId,
             op: operation,
-            field: field,
+            field: field.name,
             value,
             previousValue,
         });
@@ -1385,12 +1659,12 @@ const decodeKeyValueOperation = function (decoder, bytes, it, ref, allChanges) {
         ref.clear();
         return;
     }
-    const index = number(bytes, it);
+    const index = decode.number(bytes, it);
     const type = ref[$childType];
     let dynamicIndex;
     if ((operation & exports.OPERATION.ADD) === exports.OPERATION.ADD) { // ADD or DELETE_AND_ADD
         if (typeof (ref['set']) === "function") {
-            dynamicIndex = string(bytes, it); // MapSchema
+            dynamicIndex = decode.string(bytes, it); // MapSchema
             ref['setIndex'](index, dynamicIndex);
         }
         else {
@@ -1434,7 +1708,8 @@ const decodeKeyValueOperation = function (decoder, bytes, it, ref, allChanges) {
 };
 const decodeArray = function (decoder, bytes, it, ref, allChanges) {
     // "uncompressed" index + operation (array/map items)
-    const operation = bytes[it.offset++];
+    let operation = bytes[it.offset++];
+    let index;
     if (operation === exports.OPERATION.CLEAR) {
         //
         // When decoding:
@@ -1445,11 +1720,15 @@ const decodeArray = function (decoder, bytes, it, ref, allChanges) {
         ref.clear();
         return;
     }
+    else if (operation === exports.OPERATION.REVERSE) {
+        ref.reverse();
+        return;
+    }
     else if (operation === exports.OPERATION.DELETE_BY_REFID) {
         // TODO: refactor here, try to follow same flow as below
-        const refId = number(bytes, it);
+        const refId = decode.number(bytes, it);
         const previousValue = decoder.root.refs.get(refId);
-        const index = ref.findIndex((value) => value === previousValue);
+        index = ref.findIndex((value) => value === previousValue);
         ref[$deleteByIndex](index);
         allChanges.push({
             ref,
@@ -1462,7 +1741,17 @@ const decodeArray = function (decoder, bytes, it, ref, allChanges) {
         });
         return;
     }
-    const index = number(bytes, it);
+    else if (operation === exports.OPERATION.ADD_BY_REFID) {
+        const refId = decode.number(bytes, it);
+        const itemByRefId = decoder.root.refs.get(refId);
+        // use existing index, or push new value
+        index = (itemByRefId)
+            ? ref.findIndex((value) => value === itemByRefId)
+            : ref.length;
+    }
+    else {
+        index = decode.number(bytes, it);
+    }
     const type = ref[$childType];
     let dynamicIndex = index;
     const { value, previousValue } = decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges);
@@ -1486,6 +1775,55 @@ 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 "bigint64":
+        case "biguint64":
+            typeofTarget = "bigint";
+            break;
+        case "string":
+            typeofTarget = "string";
+            allowNull = true;
+            break;
+        case "boolean":
+            // boolean is always encoded as true/false based on truthiness
+            return;
+        default:
+            // skip assertion for custom types
+            // TODO: allow custom types to define their own assertions
+            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();
@@ -1536,6 +1874,7 @@ class ArraySchema {
         const proxy = new Proxy(this, {
             get: (obj, prop) => {
                 if (typeof (prop) !== "symbol" &&
+                    // FIXME: d8 accuses this as low performance
                     !isNaN(prop) // https://stackoverflow.com/a/175787/892698
                 ) {
                     return this.items[prop];
@@ -1551,8 +1890,9 @@ class ArraySchema {
                     }
                     else {
                         if (setValue[$changes]) {
+                            assertInstanceType(setValue, obj[$childType], obj, key);
                             if (obj.items[key] !== undefined) {
-                                if (setValue[$changes][$isNew]) {
+                                if (setValue[$changes].isNew) {
                                     this[$changes].indexedOperation(Number(key), exports.OPERATION.MOVE_AND_ADD);
                                 }
                                 else {
@@ -1564,7 +1904,7 @@ class ArraySchema {
                                     }
                                 }
                             }
-                            else if (setValue[$changes][$isNew]) {
+                            else if (setValue[$changes].isNew) {
                                 this[$changes].indexedOperation(Number(key), exports.OPERATION.ADD);
                             }
                         }
@@ -1597,7 +1937,10 @@ class ArraySchema {
             }
         });
         this[$changes] = new ChangeTree(proxy);
-        this.push.apply(this, items);
+        this[$changes].indexes = {};
+        if (items.length > 0) {
+            this.push(...items);
+        }
         return proxy;
     }
     set length(newLength) {
@@ -1616,14 +1959,19 @@ class ArraySchema {
     }
     push(...values) {
         let length = this.tmpItems.length;
-        values.forEach((value, i) => {
-            // skip null values
+        const changeTree = this[$changes];
+        // values.forEach((value, i) => {
+        for (let i = 0, l = values.length; i < values.length; i++, length++) {
+            const value = values[i];
             if (value === undefined || value === null) {
+                // skip null values
                 return;
             }
-            const changeTree = this[$changes];
+            else if (typeof (value) === "object" && this[$childType]) {
+                assertInstanceType(value, this[$childType], this, i);
+                // TODO: move value[$changes]?.setParent() to this block.
+            }
             changeTree.indexedOperation(length, exports.OPERATION.ADD, this.items.length);
-            // changeTree.indexes[length] = length;
             this.items.push(value);
             this.tmpItems.push(value);
             //
@@ -1631,8 +1979,9 @@ class ArraySchema {
             // (to avoid encoding "refId" operations before parent's "ADD" operation)
             //
             value[$changes]?.setParent(this, changeTree.root, length);
-            length++;
-        });
+        }
+        //     length++;
+        // });
         return length;
     }
     /**
@@ -1653,6 +2002,7 @@ class ArraySchema {
         }
         this[$changes].delete(index, undefined, this.items.length - 1);
         // this.tmpItems[index] = undefined;
+        // this.tmpItems.pop();
         this.deletedIndexes[index] = true;
         return this.items.pop();
     }
@@ -1717,9 +2067,12 @@ class ArraySchema {
             //
             // TODO: do not use [$changes] at decoding time.
             //
-            changeTree.root?.changes.delete(changeTree);
-            changeTree.root?.allChanges.delete(changeTree);
-            changeTree.root?.allFilteredChanges.delete(changeTree);
+            const root = changeTree.root;
+            if (root !== undefined) {
+                root.removeChangeFromChangeSet("changes", changeTree);
+                root.removeChangeFromChangeSet("allChanges", changeTree);
+                root.removeChangeFromChangeSet("allFilteredChanges", changeTree);
+            }
         });
         changeTree.discard(true);
         changeTree.operation(exports.OPERATION.CLEAR);
@@ -1763,6 +2116,7 @@ class ArraySchema {
         const changeTree = this[$changes];
         changeTree.delete(index);
         changeTree.shiftAllChangeIndexes(-1, index);
+        // this.deletedIndexes[index] = true;
         return this.items.shift();
     }
     /**
@@ -1843,10 +2197,12 @@ class ArraySchema {
         changeTree.shiftChangeIndexes(items.length);
         // new index
         if (changeTree.isFiltered) {
-            changeTree.filteredChanges.set(this.items.length, exports.OPERATION.ADD);
+            setOperationAtIndex(changeTree.filteredChanges, this.items.length);
+            // changeTree.filteredChanges[this.items.length] = OPERATION.ADD;
         }
         else {
-            changeTree.allChanges.set(this.items.length, exports.OPERATION.ADD);
+            setOperationAtIndex(changeTree.allChanges, this.items.length);
+            // changeTree.allChanges[this.items.length] = OPERATION.ADD;
         }
         // FIXME: should we use OPERATION.MOVE here instead?
         items.forEach((_, index) => {
@@ -1871,14 +2227,6 @@ class ArraySchema {
     lastIndexOf(searchElement, fromIndex = this.length - 1) {
         return this.items.lastIndexOf(searchElement, fromIndex);
     }
-    /**
-     * Determines whether all the members of an array satisfy the specified test.
-     * @param callbackfn A function that accepts up to three arguments. The every method calls
-     * the callbackfn function for each element in the array until the callbackfn returns a value
-     * which is coercible to the Boolean value false, or until the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
     every(callbackfn, thisArg) {
         return this.items.every(callbackfn, thisArg);
     }
@@ -2157,6 +2505,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) {
@@ -2183,6 +2532,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();
@@ -2191,7 +2543,7 @@ class MapSchema {
         const isReplace = typeof (changeTree.indexes[key]) !== "undefined";
         const index = (isReplace)
             ? changeTree.indexes[key]
-            : changeTree.indexes[-1] ?? 0;
+            : changeTree.indexes[$numFields] ?? 0;
         let operation = (isReplace)
             ? exports.OPERATION.REPLACE
             : exports.OPERATION.ADD;
@@ -2203,7 +2555,7 @@ class MapSchema {
         if (!isReplace) {
             this.$indexes.set(index, key);
             changeTree.indexes[key] = index;
-            changeTree.indexes[-1] = index + 1;
+            changeTree.indexes[$numFields] = index + 1;
         }
         else if (!isRef &&
             this.$items.get(key) === value) {
@@ -2278,8 +2630,11 @@ class MapSchema {
     }
     [$onEncodeEnd]() {
         const changeTree = this[$changes];
-        const changes = changeTree.changes.entries();
-        for (const [fieldIndex, operation] of changes) {
+        const keys = Object.keys(changeTree.indexedOperations);
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const fieldIndex = Number(key);
+            const operation = changeTree.indexedOperations[key];
             if (operation === exports.OPERATION.DELETE) {
                 const index = this[$getByIndex](fieldIndex);
                 delete changeTree.indexes[index];
@@ -2307,109 +2662,22 @@ class MapSchema {
         }
         else {
             // server-side
-            cloned = new MapSchema();
-            this.forEach((value, key) => {
-                if (value[$changes]) {
-                    cloned.set(key, value['clone']());
-                }
-                else {
-                    cloned.set(key, value);
-                }
-            });
-        }
-        return cloned;
-    }
-}
-registerType("map", { constructor: MapSchema });
-
-const DEFAULT_VIEW_TAG = -1;
-class TypeContext {
-    /**
-     * For inheritance support
-     * Keeps track of which classes extends which. (parent -> children)
-     */
-    static { this.inheritedTypes = new Map(); }
-    static register(target) {
-        const parent = Object.getPrototypeOf(target);
-        if (parent !== Schema) {
-            let inherits = TypeContext.inheritedTypes.get(parent);
-            if (!inherits) {
-                inherits = new Set();
-                TypeContext.inheritedTypes.set(parent, inherits);
-            }
-            inherits.add(target);
-        }
-    }
-    constructor(rootClass) {
-        this.types = {};
-        this.schemas = new Map();
-        this.hasFilters = false;
-        if (rootClass) {
-            this.discoverTypes(rootClass);
-        }
-    }
-    has(schema) {
-        return this.schemas.has(schema);
-    }
-    get(typeid) {
-        return this.types[typeid];
-    }
-    add(schema, typeid = this.schemas.size) {
-        // skip if already registered
-        if (this.schemas.has(schema)) {
-            return false;
-        }
-        this.types[typeid] = schema;
-        this.schemas.set(schema, typeid);
-        return true;
-    }
-    getTypeId(klass) {
-        return this.schemas.get(klass);
-    }
-    discoverTypes(klass) {
-        if (!this.add(klass)) {
-            return;
-        }
-        // add classes inherited from this base class
-        TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
-            this.discoverTypes(child);
-        });
-        // skip if no fields are defined for this class.
-        if (klass[Symbol.metadata] === undefined) {
-            klass[Symbol.metadata] = {};
-        }
-        // const metadata = Metadata.getFor(klass);
-        const metadata = klass[Symbol.metadata];
-        // if any schema/field has filters, mark "context" as having filters.
-        if (metadata[-2]) {
-            this.hasFilters = true;
-        }
-        for (const field in metadata) {
-            const fieldType = metadata[field].type;
-            if (typeof (fieldType) === "string") {
-                continue;
-            }
-            if (Array.isArray(fieldType)) {
-                const type = fieldType[0];
-                if (type === "string") {
-                    continue;
+            cloned = new MapSchema();
+            this.forEach((value, key) => {
+                if (value[$changes]) {
+                    cloned.set(key, value['clone']());
                 }
-                this.discoverTypes(type);
-            }
-            else if (typeof (fieldType) === "function") {
-                this.discoverTypes(fieldType);
-            }
-            else {
-                const type = Object.values(fieldType)[0];
-                // skip primitive types
-                if (typeof (type) === "string") {
-                    continue;
+                else {
+                    cloned.set(key, value);
                 }
-                this.discoverTypes(type);
-            }
+            });
         }
+        return cloned;
     }
 }
+registerType("map", { constructor: MapSchema });
+
+const DEFAULT_VIEW_TAG = -1;
 /**
  * [See documentation](https://docs.colyseus.io/state/schema/)
  *
@@ -2436,8 +2704,8 @@ class TypeContext {
 //         // detect index for this field, considering inheritance
 //         //
 //         const parent = Object.getPrototypeOf(context.metadata);
-//         let fieldIndex: number = context.metadata[-1] // current structure already has fields defined
-//             ?? (parent && parent[-1]) // parent structure has fields defined
+//         let fieldIndex: number = context.metadata[$numFields] // current structure already has fields defined
+//             ?? (parent && parent[$numFields]) // parent structure has fields defined
 //             ?? -1; // no fields defined
 //         fieldIndex++;
 //         if (
@@ -2557,18 +2825,20 @@ function view(tag = DEFAULT_VIEW_TAG) {
         const constructor = target.constructor;
         const parentClass = Object.getPrototypeOf(constructor);
         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[$numFields] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
+        //             ?? -1) + 1 // no fields defined
+        //     }
+        // }
         Metadata.setTag(metadata, fieldName, tag);
     };
 }
@@ -2582,17 +2852,17 @@ function type(type, options) {
         TypeContext.register(constructor);
         const parentClass = Object.getPrototypeOf(constructor);
         const parentMetadata = parentClass[Symbol.metadata];
-        const metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
-        let fieldIndex;
+        const metadata = Metadata.initialize(constructor);
+        let fieldIndex = metadata[field];
         /**
          * skip if descriptor already exists for this field (`@deprecated()`)
          */
-        if (metadata[field]) {
-            if (metadata[field].deprecated) {
+        if (metadata[fieldIndex] !== undefined) {
+            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 {
@@ -2603,16 +2873,13 @@ function type(type, options) {
                     throw new Error(`${e.message} ${definitionAtLine}`);
                 }
             }
-            else {
-                fieldIndex = metadata[field].index;
-            }
         }
         else {
             //
             // detect index for this field, considering inheritance
             //
-            fieldIndex = metadata[-1] // current structure already has fields defined
-                ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+            fieldIndex = metadata[$numFields] // current structure already has fields defined
+                ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
                 ?? -1; // no fields defined
             fieldIndex++;
         }
@@ -2631,15 +2898,15 @@ 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) {
-            const previousValue = this[fieldCached] || undefined;
+            const previousValue = this[fieldCached] ?? undefined;
             // skip if value is the same as cached.
             if (value === previousValue) {
                 return;
@@ -2657,22 +2924,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) {
                 //
@@ -2699,20 +2971,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[$numFields] // current structure already has fields defined
+        //             ?? (parentMetadata && parentMetadata[$numFields]) // 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,
@@ -2720,8 +2994,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
         });
@@ -2733,6 +3007,37 @@ function defineTypes(target, fields, options) {
     }
     return target;
 }
+function schema(fields, name, inherits = Schema) {
+    const defaultValues = {};
+    const viewTagFields = {};
+    for (let fieldName in fields) {
+        const field = fields[fieldName];
+        if (typeof (field) === "object") {
+            if (field['default'] !== undefined) {
+                defaultValues[fieldName] = field['default'];
+            }
+            if (field['view'] !== undefined) {
+                viewTagFields[fieldName] = (typeof (field['view']) === "boolean")
+                    ? DEFAULT_VIEW_TAG
+                    : field['view'];
+            }
+        }
+    }
+    const klass = Metadata.setFields(class extends inherits {
+        constructor(...args) {
+            args[0] = Object.assign({}, defaultValues, args[0]);
+            super(...args);
+        }
+    }, fields);
+    for (let fieldName in viewTagFields) {
+        view(viewTagFields[fieldName])(klass.prototype, fieldName);
+    }
+    if (name) {
+        Object.defineProperty(klass, "name", { value: name });
+    }
+    klass.extends = (fields, name) => schema(fields, name, klass);
+    return klass;
+}
 
 function getIndent(level) {
     return (new Array(level).fill(0)).map((_, i) => (i === level - 1) ? `└─ ` : `   `).join("");
@@ -2743,32 +3048,21 @@ function dumpChanges(schema) {
         ops: {},
         refs: []
     };
-    $root.changes.forEach((operations, changeTree) => {
+    // for (const refId in $root.changes) {
+    $root.changes.forEach(changeTree => {
+        const changes = changeTree.indexedOperations;
         dump.refs.push(`refId#${changeTree.refId}`);
-        operations.forEach((op, index) => {
+        for (const index in changes) {
+            const op = changes[index];
             const opName = exports.OPERATION[op];
             if (!dump.ops[opName]) {
                 dump.ops[opName] = 0;
             }
             dump.ops[exports.OPERATION[op]]++;
-        });
+        }
     });
     return dump;
 }
-function getNextPowerOf2(number) {
-    // If number is already a power of 2, return it
-    if ((number & (number - 1)) === 0) {
-        return number;
-    }
-    // Find the position of the most significant bit
-    let msbPosition = 0;
-    while (number > 0) {
-        number >>= 1;
-        msbPosition++;
-    }
-    // Return the next power of 2
-    return 1 << msbPosition;
-}
 
 var _a$2, _b$2;
 /**
@@ -2777,6 +3071,7 @@ var _a$2, _b$2;
 class Schema {
     static { this[_a$2] = encodeSchemaOperation; }
     static { this[_b$2] = decodeSchemaOperation; }
+    // public [$changes]: ChangeTree;
     /**
      * Assign the property descriptors required to track changes on this instance.
      * @param instance
@@ -2787,35 +3082,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";
@@ -2839,7 +3106,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;
@@ -2860,12 +3127,16 @@ class Schema {
     }
     // allow inherited classes to have a constructor
     constructor(...args) {
+        //
+        // inline
+        // Schema.initialize(this);
+        //
         Schema.initialize(this);
         //
         // Assign initial values
         //
         if (args[0]) {
-            this.assign(args[0]);
+            Object.assign(this, args[0]);
         }
     }
     assign(props) {
@@ -2879,7 +3150,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);
@@ -2888,7 +3160,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
@@ -2902,10 +3176,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']()
@@ -2918,18 +3193,27 @@ 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) {
+    /**
+     * Inspect the `refId` of all Schema instances in the tree. Optionally display the contents of the instance.
+     *
+     * @param instance Schema instance
+     * @param showContents display JSON contents of the instance
+     * @returns
+     */
+    static debugRefIds(instance, showContents = false, level = 0) {
         const ref = instance;
         const changeTree = ref[$changes];
-        const contents = (jsonContents) ? ` - ${JSON.stringify(ref.toJSON())}` : "";
+        const contents = (showContents) ? ` - ${JSON.stringify(ref.toJSON())}` : "";
         let output = "";
-        output += `${getIndent(level)}${ref.constructor.name} (${ref[$changes].refId})${contents}\n`;
-        changeTree.forEachChild((childChangeTree) => output += this.debugRefIds(childChangeTree.ref, jsonContents, level + 1));
+        output += `${getIndent(level)}${ref.constructor.name} (refId: ${ref[$changes].refId})${contents}\n`;
+        changeTree.forEachChild((childChangeTree) => output += this.debugRefIds(childChangeTree.ref, showContents, level + 1));
         return output;
     }
     /**
@@ -2946,30 +3230,40 @@ class Schema {
         const changeSetName = (isEncodeAll) ? "allChanges" : "changes";
         let output = `${instance.constructor.name} (${changeTree.refId}) -> .${changeSetName}:\n`;
         function dumpChangeSet(changeSet) {
-            Array.from(changeSet)
-                .sort((a, b) => a[0] - b[0])
-                .forEach(([index, operation]) => output += `- [${index}]: ${exports.OPERATION[operation]} (${JSON.stringify(changeTree.getValue(index, isEncodeAll))})\n`);
+            changeSet.operations
+                .filter(op => op)
+                .forEach((index) => {
+                const operation = changeTree.indexedOperations[index];
+                console.log({ index, operation });
+                output += `- [${index}]: ${exports.OPERATION[operation]} (${JSON.stringify(changeTree.getValue(Number(index), isEncodeAll))})\n`;
+            });
         }
         dumpChangeSet(changeSet);
         // display filtered changes
-        if (!isEncodeAll && changeTree.filteredChanges?.size > 0) {
+        if (!isEncodeAll &&
+            changeTree.filteredChanges &&
+            (changeTree.filteredChanges.operations).filter(op => op).length > 0) {
             output += `${instance.constructor.name} (${changeTree.refId}) -> .filteredChanges:\n`;
             dumpChangeSet(changeTree.filteredChanges);
         }
         // display filtered changes
-        if (isEncodeAll && changeTree.allFilteredChanges?.size > 0) {
+        if (isEncodeAll &&
+            changeTree.allFilteredChanges &&
+            (changeTree.allFilteredChanges.operations).filter(op => op).length > 0) {
             output += `${instance.constructor.name} (${changeTree.refId}) -> .allFilteredChanges:\n`;
             dumpChangeSet(changeTree.allFilteredChanges);
         }
         return output;
     }
-    static debugChangesDeep(ref) {
+    static debugChangesDeep(ref, changeSetName = "changes") {
         let output = "";
         const rootChangeTree = ref[$changes];
+        const root = rootChangeTree.root;
         const changeTrees = new Map();
-        let totalInstances = 0;
+        const instanceRefIds = [];
         let totalOperations = 0;
-        for (const [changeTree, changes] of (rootChangeTree.root.changes.entries())) {
+        for (const [refId, changes] of Object.entries(root[changeSetName])) {
+            const changeTree = root.changeTrees[refId];
             let includeChangeTree = false;
             let parentChangeTrees = [];
             let parentChangeTree = changeTree.parent?.[$changes];
@@ -2987,14 +3281,14 @@ class Schema {
                 }
             }
             if (includeChangeTree) {
-                totalInstances += 1;
-                totalOperations += changes.size;
+                instanceRefIds.push(changeTree.refId);
+                totalOperations += Object.keys(changes).length;
                 changeTrees.set(changeTree, parentChangeTrees.reverse());
             }
         }
         output += "---\n";
         output += `root refId: ${rootChangeTree.refId}\n`;
-        output += `Total instances: ${totalInstances}\n`;
+        output += `Total instances: ${instanceRefIds.length} (refIds: ${instanceRefIds.join(", ")})\n`;
         output += `Total changes: ${totalOperations}\n`;
         output += "---\n";
         // based on root.changes, display a tree of changes that has the "ref" instance as parent
@@ -3006,12 +3300,13 @@ class Schema {
                     visitedParents.add(parentChangeTree);
                 }
             });
-            const changes = changeTree.changes;
+            const changes = changeTree.indexedOperations;
             const level = parentChangeTrees.length;
             const indent = getIndent(level);
             const parentIndex = (level > 0) ? `(${changeTree.parentIndex}) ` : "";
-            output += `${indent}${parentIndex}${changeTree.ref.constructor.name} (refId: ${changeTree.refId}) - changes: ${changes.size}\n`;
-            for (const [index, operation] of changes) {
+            output += `${indent}${parentIndex}${changeTree.ref.constructor.name} (refId: ${changeTree.refId}) - changes: ${Object.keys(changes).length}\n`;
+            for (const index in changes) {
+                const operation = changes[index];
                 output += `${getIndent(level + 1)}${exports.OPERATION[operation]}: ${index}\n`;
             }
         }
@@ -3045,6 +3340,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));
         }
@@ -3200,6 +3496,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));
         }
@@ -3355,6 +3652,8 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
 
 function __decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -3368,37 +3667,127 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+function spliceOne(arr, index) {
+    // manually splice an array
+    if (index === -1 || index >= arr.length) {
+        return false;
+    }
+    const len = arr.length - 1;
+    for (let i = index; i < len; i++) {
+        arr[i] = arr[i + 1];
+    }
+    arr.length = len;
+    return true;
+}
+
+class Root {
+    constructor(types) {
+        this.types = types;
+        this.nextUniqueId = 0;
+        this.refCount = {};
+        this.changeTrees = {};
+        // all changes
+        this.allChanges = [];
+        this.allFilteredChanges = []; // TODO: do not initialize it if filters are not used
+        // pending changes to be encoded
+        this.changes = [];
+        this.filteredChanges = []; // TODO: do not initialize it if filters are not used
+    }
+    getNextUniqueId() {
+        return this.nextUniqueId++;
+    }
+    add(changeTree) {
+        // FIXME: move implementation of `ensureRefId` to `Root` class
+        changeTree.ensureRefId();
+        const isNewChangeTree = (this.changeTrees[changeTree.refId] === undefined);
+        if (isNewChangeTree) {
+            this.changeTrees[changeTree.refId] = changeTree;
+        }
+        const previousRefCount = this.refCount[changeTree.refId];
+        if (previousRefCount === 0) {
+            //
+            // When a ChangeTree is re-added, it means that it was previously removed.
+            // We need to re-add all changes to the `changes` map.
+            //
+            const ops = changeTree.allChanges.operations;
+            let len = ops.length;
+            while (len--) {
+                changeTree.indexedOperations[ops[len]] = exports.OPERATION.ADD;
+                setOperationAtIndex(changeTree.changes, len);
+            }
+        }
+        this.refCount[changeTree.refId] = (previousRefCount || 0) + 1;
+        return isNewChangeTree;
+    }
+    remove(changeTree) {
+        const refCount = (this.refCount[changeTree.refId]) - 1;
+        if (refCount <= 0) {
+            //
+            // Only remove "root" reference if it's the last reference
+            //
+            changeTree.root = undefined;
+            delete this.changeTrees[changeTree.refId];
+            this.removeChangeFromChangeSet("allChanges", changeTree);
+            this.removeChangeFromChangeSet("changes", changeTree);
+            if (changeTree.filteredChanges) {
+                this.removeChangeFromChangeSet("allFilteredChanges", changeTree);
+                this.removeChangeFromChangeSet("filteredChanges", changeTree);
+            }
+            this.refCount[changeTree.refId] = 0;
+        }
+        else {
+            this.refCount[changeTree.refId] = refCount;
+        }
+        changeTree.forEachChild((child, _) => this.remove(child));
+        return refCount;
+    }
+    removeChangeFromChangeSet(changeSetName, changeTree) {
+        const changeSet = this[changeSetName];
+        const index = changeSet.indexOf(changeTree);
+        if (index !== -1) {
+            spliceOne(changeSet, index);
+            // changeSet[index] = undefined;
+        }
+    }
+    clear() {
+        this.changes.length = 0;
+    }
+}
+
 class Encoder {
-    static { this.BUFFER_SIZE = 8 * 1024; } // 8KB
-    constructor(root) {
-        this.sharedBuffer = Buffer.allocUnsafeSlow(Encoder.BUFFER_SIZE);
-        this.setRoot(root);
+    static { this.BUFFER_SIZE = (typeof (Buffer) !== "undefined") && Buffer.poolSize || 8 * 1024; } // 8KB
+    constructor(state) {
+        this.sharedBuffer = Buffer.allocUnsafe(Encoder.BUFFER_SIZE);
         //
         // TODO: cache and restore "Context" based on root schema
         // (to avoid creating a new context for every new room)
         //
-        this.context = new TypeContext(root.constructor);
+        this.context = new TypeContext(state.constructor);
+        this.root = new Root(this.context);
+        this.setState(state);
         // console.log(">>>>>>>>>>>>>>>> Encoder types");
         // this.context.schemas.forEach((id, schema) => {
         //     console.log("type:", id, schema.name, Object.keys(schema[Symbol.metadata]));
         // });
     }
-    setRoot(state) {
-        this.root = new Root();
+    setState(state) {
         this.state = state;
-        state[$changes].setRoot(this.root);
+        this.state[$changes].setRoot(this.root);
     }
-    encode(it = { offset: 0 }, view, buffer = this.sharedBuffer, changeTrees = this.root.changes) {
-        const initialOffset = it.offset; // cache current offset in case we need to resize the buffer
-        const isEncodeAll = this.root.allChanges === changeTrees;
+    encode(it = { offset: 0 }, view, buffer = this.sharedBuffer, changeSetName = "changes", isEncodeAll = changeSetName === "allChanges", initialOffset = it.offset // cache current offset in case we need to resize the buffer
+    ) {
         const hasView = (view !== undefined);
         const rootChangeTree = this.state[$changes];
-        const changeTreesIterator = changeTrees.entries();
-        for (const [changeTree, changes] of changeTreesIterator) {
+        const shouldDiscardChanges = !isEncodeAll && !hasView;
+        const changeTrees = this.root[changeSetName];
+        for (let i = 0, numChangeTrees = changeTrees.length; i < numChangeTrees; i++) {
+            const changeTree = changeTrees[i];
+            const operations = changeTree[changeSetName];
             const ref = changeTree.ref;
-            const ctor = ref['constructor'];
+            const ctor = ref.constructor;
             const encoder = ctor[$encoder];
             const filter = ctor[$filter];
+            const metadata = ctor[Symbol.metadata];
             if (hasView) {
                 if (!view.items.has(changeTree)) {
                     view.invisible.add(changeTree);
@@ -3409,12 +3798,18 @@ class Encoder {
                 }
             }
             // skip root `refId` if it's the first change tree
-            if (it.offset !== initialOffset || changeTree !== rootChangeTree) {
+            // (unless it "hasView", which will need to revisit the root)
+            if (hasView || it.offset > initialOffset || changeTree !== rootChangeTree) {
                 buffer[it.offset++] = SWITCH_TO_STRUCTURE & 255;
-                number$1(buffer, changeTree.refId, it);
+                encode.number(buffer, changeTree.refId, it);
             }
-            const changesIterator = changes.entries();
-            for (const [fieldIndex, operation] of changesIterator) {
+            for (let j = 0, numChanges = operations.operations.length; j < numChanges; j++) {
+                const fieldIndex = operations.operations[j];
+                const operation = (fieldIndex < 0)
+                    ? Math.abs(fieldIndex) // "pure" operation without fieldIndex (e.g. CLEAR, REVERSE, etc.)
+                    : (isEncodeAll)
+                        ? exports.OPERATION.ADD
+                        : changeTree.indexedOperations[fieldIndex];
                 //
                 // first pass (encodeAll), identify "filtered" operations without encoding them
                 // they will be encoded per client, based on their view.
@@ -3422,96 +3817,113 @@ class Encoder {
                 // TODO: how can we optimize filtering out "encode all" operations?
                 // TODO: avoid checking if no view tags were defined
                 //
-                if (filter && !filter(ref, fieldIndex, view)) {
-                    // console.log("SKIP FIELD:", { ref: changeTree.ref.constructor.name, fieldIndex, })
+                if (fieldIndex === undefined || operation === undefined || (filter && !filter(ref, fieldIndex, view))) {
                     // console.log("ADD AS INVISIBLE:", fieldIndex, changeTree.ref.constructor.name)
                     // view?.invisible.add(changeTree);
                     continue;
                 }
-                // console.log("WILL ENCODE", {
-                //     ref: changeTree.ref.constructor.name,
-                //     fieldIndex,
-                //     operation: OPERATION[operation],
-                // });
-                encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView);
+                encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView, metadata);
             }
+            // if (shouldDiscardChanges) {
+            //     changeTree.discard();
+            //     changeTree.isNew = false; // Not a new instance anymore
+            // }
         }
         if (it.offset > buffer.byteLength) {
-            const newSize = getNextPowerOf2(buffer.byteLength * 2);
-            console.warn("@colyseus/schema encode buffer overflow. Current buffer size: " + buffer.byteLength + ", encoding offset: " + it.offset + ", new size: " + newSize);
+            // we can assume that n + 1 poolSize will suffice given that we are likely done with encoding at this point
+            // multiples of poolSize are faster to allocate than arbitrary sizes
+            // if we are on an older platform that doesn't implement pooling use 8kb as poolSize (that's the default for node)
+            const newSize = Math.ceil(it.offset / (Buffer.poolSize ?? 8 * 1024)) * (Buffer.poolSize ?? 8 * 1024);
+            console.warn(`@colyseus/schema buffer overflow. Encoded state is higher than default BUFFER_SIZE. Use the following to increase default BUFFER_SIZE:
+
+    import { Encoder } from "@colyseus/schema";
+    Encoder.BUFFER_SIZE = ${Math.round(newSize / 1024)} * 1024; // ${Math.round(newSize / 1024)} KB
+`);
             //
             // resize buffer and re-encode (TODO: can we avoid re-encoding here?)
+            // -> No we probably can't unless we catch the need for resize before encoding which is likely more computationally expensive than resizing on demand
             //
-            buffer = Buffer.allocUnsafeSlow(newSize);
+            buffer = Buffer.alloc(newSize, buffer); // fill with buffer here to memcpy previous encoding steps beyond the initialOffset
             // assign resized buffer to local sharedBuffer
             if (buffer === this.sharedBuffer) {
                 this.sharedBuffer = buffer;
             }
-            return this.encode({ offset: initialOffset }, view, buffer);
+            return this.encode({ offset: initialOffset }, view, buffer, changeSetName, isEncodeAll);
         }
         else {
             //
             // only clear changes after making sure buffer resize is not required.
             //
-            if (!isEncodeAll && !hasView) {
+            if (shouldDiscardChanges) {
                 //
-                // FIXME: avoid iterating over change trees twice.
+                // TODO: avoid iterating over change trees twice.
                 //
-                this.onEndEncode(changeTrees);
+                for (let i = 0, numChangeTrees = changeTrees.length; i < numChangeTrees; i++) {
+                    const changeTree = changeTrees[i];
+                    changeTree.discard();
+                    changeTree.isNew = false; // Not a new instance anymore
+                }
             }
             return buffer.subarray(0, it.offset);
         }
     }
     encodeAll(it = { offset: 0 }, buffer = this.sharedBuffer) {
-        // console.log(`encodeAll(), this.root.allChanges (${this.root.allChanges.size})`);
-        // Array.from(this.root.allChanges.entries()).map((item) => {
-        //     console.log("->", item[0].refId, item[0].ref.toJSON());
-        // });
-        return this.encode(it, undefined, buffer, this.root.allChanges);
+        return this.encode(it, undefined, buffer, "allChanges", true);
     }
     encodeAllView(view, sharedOffset, it, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;
-        // console.log(`encodeAllView(), this.root.allFilteredChanges (${this.root.allFilteredChanges.size})`);
-        // this.debugAllFilteredChanges();
         // try to encode "filtered" changes
-        this.encode(it, view, bytes, this.root.allFilteredChanges);
+        this.encode(it, view, bytes, "allFilteredChanges", true, viewOffset);
         return Buffer.concat([
             bytes.subarray(0, sharedOffset),
             bytes.subarray(viewOffset, it.offset)
         ]);
     }
-    // debugAllFilteredChanges() {
-    //     Array.from(this.root.allFilteredChanges.entries()).map((item) => {
-    //         console.log("->", { refId: item[0].refId }, item[0].ref.toJSON());
-    //         if (Array.isArray(item[0].ref.toJSON())) {
-    //             item[1].forEach((op, key) => {
-    //                 console.log("  ->", { key, op: OPERATION[op] });
-    //             })
-    //         }
-    //     });
-    // }
+    debugChanges(field) {
+        const rootChangeSet = (typeof (field) === "string")
+            ? this.root[field]
+            : field;
+        rootChangeSet.forEach((changeTree) => {
+            const changeSet = changeTree[field];
+            const metadata = changeTree.ref.constructor[Symbol.metadata];
+            console.log("->", { ref: changeTree.ref.constructor.name, refId: changeTree.refId, changes: Object.keys(changeSet).length });
+            for (const index in changeSet) {
+                const op = changeSet[index];
+                console.log("  ->", {
+                    index,
+                    field: metadata?.[index],
+                    op: exports.OPERATION[op],
+                });
+            }
+        });
+    }
     encodeView(view, sharedOffset, it, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;
-        // try to encode "filtered" changes
-        this.encode(it, view, bytes, this.root.filteredChanges);
         // encode visibility changes (add/remove for this view)
-        const viewChangesIterator = view.changes.entries();
-        for (const [changeTree, changes] of viewChangesIterator) {
-            if (changes.size === 0) {
-                // FIXME: avoid having empty changes if no changes were made
-                // console.log("changes.size === 0", changeTree.ref.constructor.name);
+        const refIds = Object.keys(view.changes);
+        for (let i = 0, numRefIds = refIds.length; i < numRefIds; i++) {
+            const refId = refIds[i];
+            const changes = view.changes[refId];
+            const changeTree = this.root.changeTrees[refId];
+            if (changeTree === undefined ||
+                Object.keys(changes).length === 0 // FIXME: avoid having empty changes if no changes were made
+            ) {
+                // console.log("changes.size === 0, skip", changeTree.ref.constructor.name);
                 continue;
             }
             const ref = changeTree.ref;
-            const ctor = ref['constructor'];
+            const ctor = ref.constructor;
             const encoder = ctor[$encoder];
+            const metadata = ctor[Symbol.metadata];
             bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
-            number$1(bytes, changeTree.refId, it);
-            const changesIterator = changes.entries();
-            for (const [fieldIndex, operation] of changesIterator) {
+            encode.number(bytes, changeTree.refId, it);
+            const keys = Object.keys(changes);
+            for (let i = 0, numChanges = keys.length; i < numChanges; i++) {
+                const key = keys[i];
+                const operation = changes[key];
                 // isEncodeAll = false
                 // hasView = true
-                encoder(this, bytes, changeTree, fieldIndex, operation, it, false, true);
+                encoder(this, bytes, changeTree, Number(key), operation, it, false, true, metadata);
             }
         }
         //
@@ -3519,51 +3931,62 @@ class Encoder {
         // (to allow re-using StateView's for multiple clients)
         //
         // clear "view" changes after encoding
-        view.changes.clear();
+        view.changes = {};
+        // try to encode "filtered" changes
+        this.encode(it, view, bytes, "filteredChanges", false, viewOffset);
         return Buffer.concat([
             bytes.subarray(0, sharedOffset),
             bytes.subarray(viewOffset, it.offset)
         ]);
     }
     onEndEncode(changeTrees = this.root.changes) {
-        const changeTreesIterator = changeTrees.entries();
-        for (const [changeTree, _] of changeTreesIterator) {
-            changeTree.endEncode();
-        }
+        // changeTrees.forEach(function(changeTree) {
+        //     changeTree.endEncode();
+        // });
+        // for (const refId in changeTrees) {
+        //     const changeTree = this.root.changeTrees[refId];
+        //     changeTree.endEncode();
+        //     // changeTree.changes.clear();
+        //     // // ArraySchema and MapSchema have a custom "encode end" method
+        //     // changeTree.ref[$onEncodeEnd]?.();
+        //     // // Not a new instance anymore
+        //     // delete changeTree[$isNew];
+        // }
     }
     discardChanges() {
         // discard shared changes
-        if (this.root.changes.size > 0) {
-            this.onEndEncode(this.root.changes);
-            this.root.changes.clear();
+        let length = this.root.changes.length;
+        if (length > 0) {
+            while (length--) {
+                this.root.changes[length]?.endEncode();
+            }
+            this.root.changes.length = 0;
         }
         // discard filtered changes
-        if (this.root.filteredChanges.size > 0) {
-            this.onEndEncode(this.root.filteredChanges);
-            this.root.filteredChanges.clear();
+        length = this.root.filteredChanges.length;
+        if (length > 0) {
+            while (length--) {
+                this.root.filteredChanges[length]?.endEncode();
+            }
+            this.root.filteredChanges.length = 0;
         }
     }
     tryEncodeTypeId(bytes, baseType, targetType, it) {
         const baseTypeId = this.context.getTypeId(baseType);
         const targetTypeId = this.context.getTypeId(targetType);
+        if (targetTypeId === undefined) {
+            console.warn(`@colyseus/schema WARNING: Class "${targetType.name}" is not registered on TypeRegistry - Please either tag the class with @entity or define a @type() field.`);
+            return;
+        }
         if (baseTypeId !== targetTypeId) {
             bytes[it.offset++] = TYPE_ID & 255;
-            number$1(bytes, targetTypeId, it);
+            encode.number(bytes, targetTypeId, it);
         }
     }
-}
-
-function spliceOne(arr, index) {
-    // manually splice an array
-    if (index === -1 || index >= arr.length) {
-        return false;
-    }
-    const len = arr.length - 1;
-    for (let i = index; i < len; i++) {
-        arr[i] = arr[i + 1];
+    get hasChanges() {
+        return (this.root.changes.length > 0 ||
+            this.root.filteredChanges.length > 0);
     }
-    arr.length = len;
-    return true;
 }
 
 class DecodingWarning extends Error {
@@ -3628,6 +4051,7 @@ class ReferenceTracker {
     clearRefs() {
         this.refs.clear();
         this.deletedRefs.clear();
+        this.callbacks = {};
         this.refCounts = {};
     }
     // for decoding
@@ -3644,8 +4068,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);
@@ -3692,14 +4117,14 @@ class ReferenceTracker {
 class Decoder {
     constructor(root, context) {
         this.currentRefId = 0;
-        this.setRoot(root);
+        this.setState(root);
         this.context = context || new TypeContext(root.constructor);
         // console.log(">>>>>>>>>>>>>>>> Decoder types");
         // this.context.schemas.forEach((id, schema) => {
         //     console.log("type:", id, schema.name, Object.keys(schema[Symbol.metadata]));
         // });
     }
-    setRoot(root) {
+    setState(root) {
         this.state = root;
         this.root = new ReferenceTracker();
         this.root.addRef(0, root);
@@ -3716,7 +4141,7 @@ class Decoder {
             //
             if (bytes[it.offset] == SWITCH_TO_STRUCTURE) {
                 it.offset++;
-                this.currentRefId = number(bytes, it);
+                this.currentRefId = decode.number(bytes, it);
                 const nextRef = $root.refs.get(this.currentRefId);
                 //
                 // Trying to access a reference that haven't been decoded yet.
@@ -3726,7 +4151,7 @@ class Decoder {
                 }
                 ref[$onDecodeEnd]?.();
                 ref = nextRef;
-                decoder = ref['constructor'][$decoder];
+                decoder = ref.constructor[$decoder];
                 continue;
             }
             const result = decoder(this, bytes, it, ref, allChanges);
@@ -3738,9 +4163,9 @@ class Decoder {
                 //
                 const nextIterator = { offset: it.offset };
                 while (it.offset < totalBytes) {
-                    if (switchStructureCheck(bytes, it)) {
+                    if (bytes[it.offset] === SWITCH_TO_STRUCTURE) {
                         nextIterator.offset = it.offset + 1;
-                        if ($root.refs.has(number(bytes, nextIterator))) {
+                        if ($root.refs.has(decode.number(bytes, nextIterator))) {
                             break;
                         }
                     }
@@ -3761,7 +4186,7 @@ class Decoder {
         let type;
         if (bytes[it.offset] === TYPE_ID) {
             it.offset++;
-            const type_id = number(bytes, it);
+            const type_id = decode.number(bytes, it);
             type = this.context.get(type_id);
         }
         return type || defaultType;
@@ -3827,14 +4252,27 @@ class Reflection extends Schema {
         super(...arguments);
         this.types = new ArraySchema();
     }
-    static encode(instance, context, it = { offset: 0 }) {
-        if (!context) {
-            context = new TypeContext(instance.constructor);
-        }
+    /**
+     * Encodes the TypeContext of an Encoder into a buffer.
+     *
+     * @param encoder Encoder instance
+     * @param it
+     * @returns
+     */
+    static encode(encoder, it = { offset: 0 }) {
+        const context = encoder.context;
         const reflection = new Reflection();
-        const encoder = new Encoder(reflection);
+        const reflectionEncoder = new Encoder(reflection);
+        // rootType is usually the first schema passed to the Encoder
+        // (unless it inherits from another schema)
+        const rootType = context.schemas.get(encoder.state.constructor);
+        if (rootType > 0) {
+            reflection.rootType = rootType;
+        }
         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;
@@ -3842,7 +4280,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;
                 }
@@ -3884,65 +4322,335 @@ class Reflection extends Schema {
             }
             buildType(type, klass[Symbol.metadata]);
         }
-        const buf = encoder.encodeAll(it);
+        const buf = reflectionEncoder.encodeAll(it);
         return Buffer.from(buf, 0, it.offset);
     }
+    /**
+     * Decodes the TypeContext from a buffer into a Decoder instance.
+     *
+     * @param bytes Reflection.encode() output
+     * @param it
+     * @returns Decoder instance
+     */
     static decode(bytes, it) {
         const reflection = new Reflection();
         const reflectionDecoder = new Decoder(reflection);
         reflectionDecoder.decode(bytes, it);
-        const context = new TypeContext();
-        const schemaTypes = reflection.types.reduce((types, reflectionType) => {
-            const parentKlass = types[reflectionType.extendsId] || Schema;
-            const schema = class _ extends parentKlass {
+        const typeContext = new TypeContext();
+        // 1st pass, initialize metadata + inheritance
+        reflection.types.forEach((reflectionType) => {
+            const parentClass = typeContext.get(reflectionType.extendsId) ?? Schema;
+            const schema = class _ extends parentClass {
             };
-            // const _metadata = Object.create(_classSuper[Symbol.metadata] ?? null);
-            const _metadata = parentKlass && parentKlass[Symbol.metadata] || Object.create(null);
-            Object.defineProperty(schema, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             // register for inheritance support
             TypeContext.register(schema);
-            const typeid = reflectionType.id;
-            types[typeid] = schema;
-            context.add(schema, typeid);
-            return types;
+            // // for inheritance support
+            // Metadata.initialize(schema);
+            typeContext.add(schema, reflectionType.id);
         }, {});
-        reflection.types.forEach((reflectionType) => {
-            const schemaType = schemaTypes[reflectionType.id];
-            const metadata = schemaType[Symbol.metadata];
-            const parentKlass = reflection.types[reflectionType.extendsId];
-            const parentFieldIndex = parentKlass && parentKlass.fields.length || 0;
+        // define fields
+        const addFields = (metadata, reflectionType, parentFieldIndex) => {
             reflectionType.fields.forEach((field, i) => {
                 const fieldIndex = parentFieldIndex + i;
                 if (field.referencedType !== undefined) {
                     let fieldType = field.type;
-                    let refType = schemaTypes[field.referencedType];
+                    let refType = typeContext.get(field.referencedType);
                     // map or array of primitive type (-1)
                     if (!refType) {
                         const typeInfo = field.type.split(":");
                         fieldType = typeInfo[0];
-                        refType = typeInfo[1];
+                        refType = typeInfo[1]; // string
                     }
                     if (fieldType === "ref") {
-                        // type(refType)(schemaType.prototype, field.name);
                         Metadata.addField(metadata, fieldIndex, field.name, refType);
                     }
                     else {
-                        // type({ [fieldType]: refType } as DefinitionType)(schemaType.prototype, field.name);
                         Metadata.addField(metadata, fieldIndex, field.name, { [fieldType]: refType });
                     }
                 }
                 else {
-                    // type(field.type as PrimitiveType)(schemaType.prototype, field.name);
                     Metadata.addField(metadata, fieldIndex, field.name, field.type);
                 }
             });
+        };
+        // 2nd pass, set fields
+        reflection.types.forEach((reflectionType) => {
+            const schema = typeContext.get(reflectionType.id);
+            // for inheritance support
+            const metadata = Metadata.initialize(schema);
+            const inheritedTypes = [];
+            let parentType = reflectionType;
+            do {
+                inheritedTypes.push(parentType);
+                parentType = reflection.types.find((t) => t.id === parentType.extendsId);
+            } while (parentType);
+            let parentFieldIndex = 0;
+            inheritedTypes.reverse().forEach((reflectionType) => {
+                // add fields from all inherited classes
+                // TODO: refactor this to avoid adding fields from parent classes
+                addFields(metadata, reflectionType, parentFieldIndex);
+                parentFieldIndex += reflectionType.fields.length;
+            });
         });
-        return new (schemaTypes[0])();
+        const state = new (typeContext.get(reflection.rootType || 0))();
+        return new Decoder(state, typeContext);
     }
 }
 __decorate([
     type([ReflectionType])
 ], Reflection.prototype, "types", void 0);
+__decorate([
+    type("number")
+], Reflection.prototype, "rootType", void 0);
+
+function getDecoderStateCallbacks(decoder) {
+    const $root = decoder.root;
+    const callbacks = $root.callbacks;
+    const onAddCalls = new WeakMap();
+    let currentOnAddCallback;
+    decoder.triggerChanges = function (allChanges) {
+        const uniqueRefIds = new Set();
+        for (let i = 0, l = allChanges.length; i < l; i++) {
+            const change = allChanges[i];
+            const refId = change.refId;
+            const ref = change.ref;
+            const $callbacks = callbacks[refId];
+            if (!$callbacks) {
+                continue;
+            }
+            //
+            // trigger onRemove on child structure.
+            //
+            if ((change.op & exports.OPERATION.DELETE) === exports.OPERATION.DELETE &&
+                change.previousValue instanceof Schema) {
+                const deleteCallbacks = callbacks[$root.refIds.get(change.previousValue)]?.[exports.OPERATION.DELETE];
+                for (let i = deleteCallbacks?.length - 1; i >= 0; i--) {
+                    deleteCallbacks[i]();
+                }
+            }
+            if (ref instanceof Schema) {
+                //
+                // Handle schema instance
+                //
+                if (!uniqueRefIds.has(refId)) {
+                    // trigger onChange
+                    const replaceCallbacks = $callbacks?.[exports.OPERATION.REPLACE];
+                    for (let i = replaceCallbacks?.length - 1; i >= 0; i--) {
+                        replaceCallbacks[i]();
+                        // try {
+                        // } catch (e) {
+                        //     console.error(e);
+                        // }
+                    }
+                }
+                if ($callbacks.hasOwnProperty(change.field)) {
+                    const fieldCallbacks = $callbacks[change.field];
+                    for (let i = fieldCallbacks?.length - 1; i >= 0; i--) {
+                        fieldCallbacks[i](change.value, change.previousValue);
+                        // try {
+                        // } catch (e) {
+                        //     console.error(e);
+                        // }
+                    }
+                }
+            }
+            else {
+                //
+                // Handle collection of items
+                //
+                if ((change.op & exports.OPERATION.DELETE) === exports.OPERATION.DELETE) {
+                    //
+                    // FIXME: `previousValue` should always be available.
+                    //
+                    if (change.previousValue !== undefined) {
+                        // triger onRemove
+                        const deleteCallbacks = $callbacks[exports.OPERATION.DELETE];
+                        for (let i = deleteCallbacks?.length - 1; i >= 0; i--) {
+                            deleteCallbacks[i](change.previousValue, change.dynamicIndex ?? change.field);
+                        }
+                    }
+                    // Handle DELETE_AND_ADD operations
+                    if ((change.op & exports.OPERATION.ADD) === exports.OPERATION.ADD) {
+                        const addCallbacks = $callbacks[exports.OPERATION.ADD];
+                        for (let i = addCallbacks?.length - 1; i >= 0; i--) {
+                            addCallbacks[i](change.value, change.dynamicIndex ?? change.field);
+                        }
+                    }
+                }
+                else if ((change.op & exports.OPERATION.ADD) === exports.OPERATION.ADD && change.previousValue === undefined) {
+                    // triger onAdd
+                    const addCallbacks = $callbacks[exports.OPERATION.ADD];
+                    for (let i = addCallbacks?.length - 1; i >= 0; i--) {
+                        addCallbacks[i](change.value, change.dynamicIndex ?? change.field);
+                    }
+                }
+                // trigger onChange
+                if (change.value !== change.previousValue) {
+                    const replaceCallbacks = $callbacks[exports.OPERATION.REPLACE];
+                    for (let i = replaceCallbacks?.length - 1; i >= 0; i--) {
+                        replaceCallbacks[i](change.value, change.dynamicIndex ?? change.field);
+                    }
+                }
+            }
+            uniqueRefIds.add(refId);
+        }
+    };
+    function getProxy(metadataOrType, context) {
+        let metadata = context.instance?.constructor[Symbol.metadata] || metadataOrType;
+        let isCollection = ((context.instance && typeof (context.instance['forEach']) === "function") ||
+            (metadataOrType && typeof (metadataOrType[Symbol.metadata]) === "undefined"));
+        if (metadata && !isCollection) {
+            const onAddListen = function (ref, prop, callback, immediate) {
+                // immediate trigger
+                if (immediate &&
+                    context.instance[prop] !== undefined &&
+                    !onAddCalls.has(currentOnAddCallback) // Workaround for https://github.com/colyseus/schema/issues/147
+                ) {
+                    callback(context.instance[prop], undefined);
+                }
+                return $root.addCallback($root.refIds.get(ref), prop, callback);
+            };
+            /**
+             * Schema instances
+             */
+            return new Proxy({
+                listen: function listen(prop, callback, immediate = true) {
+                    if (context.instance) {
+                        return onAddListen(context.instance, prop, callback, immediate);
+                    }
+                    else {
+                        // collection instance not received yet
+                        let detachCallback = () => { };
+                        context.onInstanceAvailable((ref, existing) => {
+                            detachCallback = onAddListen(ref, prop, callback, immediate && existing && !onAddCalls.has(currentOnAddCallback));
+                        });
+                        return () => detachCallback();
+                    }
+                },
+                onChange: function onChange(callback) {
+                    return $root.addCallback($root.refIds.get(context.instance), exports.OPERATION.REPLACE, callback);
+                },
+                //
+                // TODO: refactor `bindTo()` implementation.
+                // There is room for improvement.
+                //
+                bindTo: function bindTo(targetObject, properties) {
+                    if (!properties) {
+                        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]);
+                    });
+                }
+            }, {
+                get(target, prop) {
+                    const metadataField = metadata[metadata[prop]];
+                    if (metadataField) {
+                        const instance = context.instance?.[prop];
+                        const onInstanceAvailable = ((callback) => {
+                            const unbind = $(context.instance).listen(prop, (value, _) => {
+                                callback(value, false);
+                                // FIXME: by "unbinding" the callback here,
+                                // it will not support when the server
+                                // re-instantiates the instance.
+                                //
+                                unbind?.();
+                            }, false);
+                            // has existing value
+                            if ($root.refIds.get(instance) !== undefined) {
+                                callback(instance, true);
+                            }
+                        });
+                        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,
+                            onInstanceAvailable,
+                        });
+                    }
+                    else {
+                        // accessing the function
+                        return target[prop];
+                    }
+                },
+                has(target, prop) { return metadata[prop] !== undefined; },
+                set(_, _1, _2) { throw new Error("not allowed"); },
+                deleteProperty(_, _1) { throw new Error("not allowed"); },
+            });
+        }
+        else {
+            /**
+             * Collection instances
+             */
+            const onAdd = function (ref, callback, immediate) {
+                // Trigger callback on existing items
+                if (immediate) {
+                    ref.forEach((v, k) => callback(v, k));
+                }
+                return $root.addCallback($root.refIds.get(ref), exports.OPERATION.ADD, (value, key) => {
+                    onAddCalls.set(callback, true);
+                    currentOnAddCallback = callback;
+                    callback(value, key);
+                    onAddCalls.delete(callback);
+                    currentOnAddCallback = undefined;
+                });
+            };
+            const onRemove = function (ref, callback) {
+                return $root.addCallback($root.refIds.get(ref), exports.OPERATION.DELETE, callback);
+            };
+            return new Proxy({
+                onAdd: function (callback, immediate = true) {
+                    //
+                    // https://github.com/colyseus/schema/issues/147
+                    // If parent instance has "onAdd" registered, avoid triggering immediate callback.
+                    //
+                    if (context.instance) {
+                        return onAdd(context.instance, callback, immediate && !onAddCalls.has(currentOnAddCallback));
+                    }
+                    else if (context.onInstanceAvailable) {
+                        // collection instance not received yet
+                        let detachCallback = () => { };
+                        context.onInstanceAvailable((ref, existing) => {
+                            detachCallback = onAdd(ref, callback, immediate && existing && !onAddCalls.has(currentOnAddCallback));
+                        });
+                        return () => detachCallback();
+                    }
+                },
+                onRemove: function (callback) {
+                    if (context.onInstanceAvailable) {
+                        // collection instance not received yet
+                        let detachCallback = () => { };
+                        context.onInstanceAvailable((ref) => {
+                            detachCallback = onRemove(ref, callback);
+                        });
+                        return () => detachCallback();
+                    }
+                    else if (context.instance) {
+                        return onRemove(context.instance, callback);
+                    }
+                },
+            }, {
+                get(target, prop) {
+                    if (!target[prop]) {
+                        throw new Error(`Can't access '${prop}' through callback proxy. access the instance directly.`);
+                    }
+                    return target[prop];
+                },
+                has(target, prop) { return target[prop] !== undefined; },
+                set(_, _1, _2) { throw new Error("not allowed"); },
+                deleteProperty(_, _1) { throw new Error("not allowed"); },
+            });
+        }
+    }
+    function $(instance) {
+        return getProxy(undefined, { instance });
+    }
+    return $;
+}
+
+function getRawChangesCallback(decoder, callback) {
+    decoder.triggerChanges = callback;
+}
 
 class StateView {
     constructor() {
@@ -3958,31 +4666,32 @@ class StateView {
          * Manual "ADD" operations for changes per ChangeTree, specific to this view.
          * (This is used to force encoding a property, even if it was not changed)
          */
-        this.changes = new Map();
+        this.changes = {};
     }
     // TODO: allow to set multiple tags at once
-    add(obj, tag = DEFAULT_VIEW_TAG) {
+    add(obj, tag = DEFAULT_VIEW_TAG, checkIncludeParent = true) {
         if (!obj[$changes]) {
             console.warn("StateView#add(), invalid object:", obj);
             return this;
         }
-        let changeTree = obj[$changes];
-        this.items.add(changeTree);
-        // Add children of this ChangeTree to this view
-        changeTree.forEachChild((change, _) => this.add(change.ref, tag));
-        // FIXME: ArraySchema/MapSchema does not have metadata
+        // FIXME: ArraySchema/MapSchema do not have metadata
         const metadata = obj.constructor[Symbol.metadata];
-        // add parent ChangeTree's, if they are invisible to this view
-        // TODO: REFACTOR addParent()
-        this.addParent(changeTree, tag);
+        const changeTree = obj[$changes];
+        this.items.add(changeTree);
+        // add parent ChangeTree's
+        // - if it was invisible to this view
+        // - if it were previously filtered out
+        if (checkIncludeParent && changeTree.parent) {
+            this.addParent(changeTree.parent[$changes], changeTree.parentIndex, tag);
+        }
         //
         // TODO: when adding an item of a MapSchema, the changes may not
         // be set (only the parent's changes are set)
         //
-        let changes = this.changes.get(changeTree);
+        let changes = this.changes[changeTree.refId];
         if (changes === undefined) {
-            changes = new Map();
-            this.changes.set(changeTree, changes);
+            changes = {};
+            this.changes[changeTree.refId] = changes;
         }
         // set tag
         if (tag !== DEFAULT_VIEW_TAG) {
@@ -3998,82 +4707,78 @@ class StateView {
                 tags = this.tags.get(changeTree);
             }
             tags.add(tag);
-            // console.log("BY TAG:", tag);
             // Ref: add tagged properties
-            metadata?.[-3]?.[tag]?.forEach((index) => {
+            metadata?.[$fieldIndexesByViewTag]?.[tag]?.forEach((index) => {
                 if (changeTree.getChange(index) !== exports.OPERATION.DELETE) {
-                    changes.set(index, exports.OPERATION.ADD);
+                    changes[index] = exports.OPERATION.ADD;
                 }
             });
         }
         else {
-            // console.log("DEFAULT TAG", changeTree.allChanges);
-            // // add default tag properties
-            // metadata?.[-3]?.[DEFAULT_VIEW_TAG]?.forEach((index) => {
-            //     if (changeTree.getChange(index) !== OPERATION.DELETE) {
-            //         changes.set(index, OPERATION.ADD);
-            //     }
-            // });
-            const allChangesSet = (changeTree.isFiltered || changeTree.isPartiallyFiltered)
+            const isInvisible = this.invisible.has(changeTree);
+            const changeSet = (changeTree.filteredChanges !== undefined)
                 ? changeTree.allFilteredChanges
                 : changeTree.allChanges;
-            const it = allChangesSet.keys();
-            const isInvisible = this.invisible.has(changeTree);
-            for (const index of it) {
-                if ((isInvisible || metadata?.[metadata?.[index]].tag === tag) &&
-                    changeTree.getChange(index) !== exports.OPERATION.DELETE) {
-                    changes.set(index, exports.OPERATION.ADD);
+            for (let i = 0, len = changeSet.operations.length; i < len; i++) {
+                const index = changeSet.operations[i];
+                if (index === undefined) {
+                    continue;
+                } // skip "undefined" indexes
+                const op = changeTree.indexedOperations[index] ?? exports.OPERATION.ADD;
+                const tagAtIndex = metadata?.[index].tag;
+                if ((isInvisible || // if "invisible", include all
+                    tagAtIndex === undefined || // "all change" with no tag
+                    tagAtIndex === tag // tagged property
+                ) &&
+                    op !== exports.OPERATION.DELETE) {
+                    changes[index] = op;
                 }
             }
         }
-        // TODO: avoid unnecessary iteration here
-        while (changeTree.parent &&
-            (changeTree = changeTree.parent[$changes]) &&
-            (changeTree.isFiltered || changeTree.isPartiallyFiltered)) {
-            this.items.add(changeTree);
-        }
+        // 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[index].tag !== undefined &&
+                metadata[index].tag !== tag) {
+                return;
+            }
+            this.add(change.ref, tag, false);
+        });
         return this;
     }
-    addParent(changeTree, tag) {
-        const parentRef = changeTree.parent;
-        if (!parentRef) {
-            return;
+    addParent(changeTree, parentIndex, tag) {
+        // view must have all "changeTree" parent tree
+        this.items.add(changeTree);
+        // add parent's parent
+        const parentChangeTree = changeTree.parent?.[$changes];
+        if (parentChangeTree && (parentChangeTree.filteredChanges !== undefined)) {
+            this.addParent(parentChangeTree, changeTree.parentIndex, tag);
         }
-        const parentChangeTree = parentRef[$changes];
-        const parentIndex = changeTree.parentIndex;
-        if (!this.invisible.has(parentChangeTree)) {
-            // parent is already available, no need to add it!
+        // parent is already available, no need to add it!
+        if (!this.invisible.has(changeTree)) {
             return;
         }
-        this.addParent(parentChangeTree, tag);
         // add parent's tag properties
-        if (parentChangeTree.getChange(parentIndex) !== exports.OPERATION.DELETE) {
-            let parentChanges = this.changes.get(parentChangeTree);
-            if (parentChanges === undefined) {
-                parentChanges = new Map();
-                this.changes.set(parentChangeTree, parentChanges);
+        if (changeTree.getChange(parentIndex) !== exports.OPERATION.DELETE) {
+            let changes = this.changes[changeTree.refId];
+            if (changes === undefined) {
+                changes = {};
+                this.changes[changeTree.refId] = changes;
             }
-            // console.log("add parent change", {
-            //     parentIndex,
-            //     parentChanges,
-            //     parentChange: (
-            //         parentChangeTree.getChange(parentIndex) &&
-            //         OPERATION[parentChangeTree.getChange(parentIndex)]
-            //     ),
-            // })
             if (!this.tags) {
                 this.tags = new WeakMap();
             }
             let tags;
-            if (!this.tags.has(parentChangeTree)) {
+            if (!this.tags.has(changeTree)) {
                 tags = new Set();
-                this.tags.set(parentChangeTree, tags);
+                this.tags.set(changeTree, tags);
             }
             else {
-                tags = this.tags.get(parentChangeTree);
+                tags = this.tags.get(changeTree);
             }
             tags.add(tag);
-            parentChanges.set(parentIndex, exports.OPERATION.ADD);
+            changes[parentIndex] = exports.OPERATION.ADD;
         }
     }
     remove(obj, tag = DEFAULT_VIEW_TAG) {
@@ -4085,32 +4790,32 @@ class StateView {
         this.items.delete(changeTree);
         const ref = changeTree.ref;
         const metadata = ref.constructor[Symbol.metadata];
-        let changes = this.changes.get(changeTree);
+        let changes = this.changes[changeTree.refId];
         if (changes === undefined) {
-            changes = new Map();
-            this.changes.set(changeTree, changes);
+            changes = {};
+            this.changes[changeTree.refId] = changes;
         }
         if (tag === DEFAULT_VIEW_TAG) {
             // parent is collection (Map/Array)
             const parent = changeTree.parent;
             if (!Metadata.isValidInstance(parent)) {
                 const parentChangeTree = parent[$changes];
-                let changes = this.changes.get(parentChangeTree);
+                let changes = this.changes[parentChangeTree.refId];
                 if (changes === undefined) {
-                    changes = new Map();
-                    this.changes.set(parentChangeTree, changes);
+                    changes = {};
+                    this.changes[parentChangeTree.refId] = changes;
                 }
                 // DELETE / DELETE BY REF ID
-                changes.set(changeTree.parentIndex, exports.OPERATION.DELETE);
+                changes[changeTree.parentIndex] = exports.OPERATION.DELETE;
             }
             else {
                 // delete all "tagged" properties.
-                metadata[-2].forEach((index) => changes.set(index, exports.OPERATION.DELETE));
+                metadata[$viewFieldIndexes].forEach((index) => changes[index] = exports.OPERATION.DELETE);
             }
         }
         else {
             // delete only tagged properties
-            metadata[-3][tag].forEach((index) => changes.set(index, exports.OPERATION.DELETE));
+            metadata[$fieldIndexesByViewTag][tag].forEach((index) => changes[index] = exports.OPERATION.DELETE);
         }
         // remove tag
         if (this.tags && this.tags.has(changeTree)) {
@@ -4162,13 +4867,17 @@ exports.TypeContext = TypeContext;
 exports.decode = decode;
 exports.decodeKeyValueOperation = decodeKeyValueOperation;
 exports.decodeSchemaOperation = decodeSchemaOperation;
+exports.defineCustomTypes = defineCustomTypes;
 exports.defineTypes = defineTypes;
 exports.deprecated = deprecated;
 exports.dumpChanges = dumpChanges;
 exports.encode = encode;
 exports.encodeKeyValueOperation = encodeArray;
 exports.encodeSchemaOperation = encodeSchemaOperation;
+exports.getDecoderStateCallbacks = getDecoderStateCallbacks;
+exports.getRawChangesCallback = getRawChangesCallback;
 exports.registerType = registerType;
+exports.schema = schema;
 exports.type = type;
 exports.view = view;
 //# sourceMappingURL=index.js.map