@colyseus/schema 3.0.0-alpha.8 → 3.0.0

package/build/umd/index.js

@@ -24,11 +24,10 @@
         /**
          * 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");
@@ -48,11 +47,6 @@
      * (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)
@@ -62,476 +56,303 @@
      * 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
@@ -555,698 +376,1150 @@
      * 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;
-        }
-        // encode operation
-        bytes[it.offset++] = operation & 255;
-        // custom operations
-        if (operation === exports.OPERATION.CLEAR) {
-            return;
+        has(schema) {
+            return this.schemas.has(schema);
         }
-        // encode index
-        number$1(bytes, field, it);
-        // Do not encode value for DELETE operations
-        if (operation === exports.OPERATION.DELETE) {
-            return;
+        get(typeid) {
+            return this.types[typeid];
         }
-        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;
+        add(schema, typeid = this.schemas.size) {
+            // skip if already registered
+            if (this.schemas.has(schema)) {
+                return false;
             }
-            if ((byte & 0xe0) === 0xc0) {
-                string += String.fromCharCode(((byte & 0x1f) << 6) |
-                    (bytes[++i] & 0x3f));
-                continue;
+            this.types[typeid] = schema;
+            //
+            // Workaround to allow using an empty Schema (with no `@type()` fields)
+            //
+            if (schema[Symbol.metadata] === undefined) {
+                Metadata.initialize(schema);
             }
-            if ((byte & 0xf0) === 0xe0) {
-                string += String.fromCharCode(((byte & 0x0f) << 12) |
-                    ((bytes[++i] & 0x3f) << 6) |
-                    ((bytes[++i] & 0x3f) << 0));
-                continue;
+            this.schemas.set(schema, typeid);
+            return true;
+        }
+        getTypeId(klass) {
+            return this.schemas.get(klass);
+        }
+        discoverTypes(klass, parentType, parentIndex, parentHasViewTag) {
+            if (parentHasViewTag) {
+                this.registerFilteredByParent(klass, parentType, parentIndex);
             }
-            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;
+            // skip if already registered
+            if (!this.add(klass)) {
+                return;
+            }
+            // 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;
+            }
+            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 {
+                    const type = Object.values(fieldType)[0];
+                    // skip primitive types
+                    if (typeof (type) === "string") {
+                        continue;
+                    }
+                    this.discoverTypes(type, klass, index, parentHasViewTag || fieldHasViewTag);
+                }
             }
-            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) {
@@ -1282,7 +1555,7 @@
         }
         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);
@@ -1298,7 +1571,9 @@
                 if (!value) {
                     value = decoder.createInstanceOfType(childType);
                 }
-                $root.addRef(refId, value, (value !== previousValue));
+                $root.addRef(refId, value, (value !== previousValue || // increment ref count if value has changed
+                    (operation === exports.OPERATION.DELETE_AND_ADD && value === previousValue) // increment ref count if the same instance is being added again
+                ));
             }
         }
         else if (typeof (type) === "string") {
@@ -1309,7 +1584,7 @@
         }
         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();
@@ -1349,18 +1624,19 @@
     }
     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) {
@@ -1368,7 +1644,7 @@
                 ref,
                 refId: decoder.currentRefId,
                 op: operation,
-                field: field,
+                field: field.name,
                 value,
                 previousValue,
             });
@@ -1387,12 +1663,12 @@
             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 {
@@ -1436,7 +1712,8 @@
     };
     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:
@@ -1447,11 +1724,15 @@
             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,
@@ -1464,7 +1745,17 @@
             });
             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);
@@ -1488,6 +1779,55 @@
         }
     };
 
+    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();
@@ -1538,6 +1878,7 @@
             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];
@@ -1553,8 +1894,9 @@
                         }
                         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 {
@@ -1566,7 +1908,7 @@
                                         }
                                     }
                                 }
-                                else if (setValue[$changes][$isNew]) {
+                                else if (setValue[$changes].isNew) {
                                     this[$changes].indexedOperation(Number(key), exports.OPERATION.ADD);
                                 }
                             }
@@ -1599,7 +1941,10 @@
                 }
             });
             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) {
@@ -1618,14 +1963,19 @@
         }
         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);
                 //
@@ -1633,8 +1983,9 @@
                 // (to avoid encoding "refId" operations before parent's "ADD" operation)
                 //
                 value[$changes]?.setParent(this, changeTree.root, length);
-                length++;
-            });
+            }
+            //     length++;
+            // });
             return length;
         }
         /**
@@ -1655,6 +2006,7 @@
             }
             this[$changes].delete(index, undefined, this.items.length - 1);
             // this.tmpItems[index] = undefined;
+            // this.tmpItems.pop();
             this.deletedIndexes[index] = true;
             return this.items.pop();
         }
@@ -1719,9 +2071,12 @@
                 //
                 // 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);
@@ -1765,6 +2120,7 @@
             const changeTree = this[$changes];
             changeTree.delete(index);
             changeTree.shiftAllChangeIndexes(-1, index);
+            // this.deletedIndexes[index] = true;
             return this.items.shift();
         }
         /**
@@ -1845,10 +2201,12 @@
             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) => {
@@ -1873,14 +2231,6 @@
         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);
         }
@@ -2159,6 +2509,7 @@
             this.$items = new Map();
             this.$indexes = new Map();
             this[$changes] = new ChangeTree(this);
+            this[$changes].indexes = {};
             if (initialValues) {
                 if (initialValues instanceof Map ||
                     initialValues instanceof MapSchema) {
@@ -2185,6 +2536,9 @@
             if (value === undefined || value === null) {
                 throw new Error(`MapSchema#set('${key}', ${value}): trying to set ${value} value on '${key}'.`);
             }
+            else if (typeof (value) === "object" && this[$childType]) {
+                assertInstanceType(value, this[$childType], this, key);
+            }
             // Force "key" as string
             // See: https://github.com/colyseus/colyseus/issues/561#issuecomment-1646733468
             key = key.toString();
@@ -2193,7 +2547,7 @@
             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;
@@ -2205,7 +2559,7 @@
             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) {
@@ -2280,8 +2634,11 @@
         }
         [$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];
@@ -2310,108 +2667,21 @@
             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;
+                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/)
      *
@@ -2438,8 +2708,8 @@
     //         // 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 (
@@ -2559,18 +2829,20 @@
             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);
         };
     }
@@ -2584,17 +2856,17 @@
             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 {
@@ -2605,16 +2877,13 @@
                         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++;
             }
@@ -2633,15 +2902,15 @@
                 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;
@@ -2659,22 +2928,27 @@
                         }
                         value[$childType] = type;
                     }
+                    else if (typeof (type) !== "string") {
+                        assertInstanceType(value, type, this, fieldCached.substring(1));
+                    }
+                    else {
+                        assertType(value, type, this, fieldCached.substring(1));
+                    }
+                    const changeTree = this[$changes];
                     //
                     // Replacing existing "ref", remove it from root.
                     // TODO: if there are other references to this instance, we should not remove it from root.
                     //
                     if (previousValue !== undefined && previousValue[$changes]) {
-                        this[$changes].root?.remove(previousValue[$changes]);
+                        changeTree.root?.remove(previousValue[$changes]);
                     }
                     // flag the change for encoding.
-                    this.constructor[$track](this[$changes], fieldIndex, exports.OPERATION.ADD);
+                    this.constructor[$track](changeTree, fieldIndex, exports.OPERATION.ADD);
                     //
                     // call setParent() recursively for this and its child
                     // structures.
                     //
-                    if (value[$changes]) {
-                        value[$changes].setParent(this, this[$changes].root, metadata[field].index);
-                    }
+                    value[$changes]?.setParent(this, changeTree.root, fieldIndex);
                 }
                 else if (previousValue !== undefined) {
                     //
@@ -2701,20 +2975,22 @@
             const parentClass = Object.getPrototypeOf(constructor);
             const parentMetadata = parentClass[Symbol.metadata];
             const metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
-            if (!metadata[field]) {
-                //
-                // detect index for this field, considering inheritance
-                //
-                metadata[field] = {
-                    type: undefined,
-                    index: (metadata[-1] // current structure already has fields defined
-                        ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
-                        ?? -1) + 1 // no fields defined
-                };
-            }
-            metadata[field].deprecated = true;
+            const fieldIndex = metadata[field];
+            // if (!metadata[field]) {
+            //     //
+            //     // detect index for this field, considering inheritance
+            //     //
+            //     metadata[field] = {
+            //         type: undefined,
+            //         index: (metadata[$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,
@@ -2722,8 +2998,8 @@
                 };
             }
             // flag metadata[field] as non-enumerable
-            Object.defineProperty(metadata, field, {
-                value: metadata[field],
+            Object.defineProperty(metadata, fieldIndex, {
+                value: metadata[fieldIndex],
                 enumerable: false,
                 configurable: true
             });
@@ -2735,6 +3011,37 @@
         }
         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("");
@@ -2745,32 +3052,21 @@
             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;
     /**
@@ -2779,6 +3075,7 @@
     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
@@ -2789,35 +3086,7 @@
                 enumerable: false,
                 writable: true
             });
-            const metadata = instance.constructor[Symbol.metadata];
-            // Define property descriptors
-            for (const field in metadata) {
-                if (metadata[field].descriptor) {
-                    // for encoder
-                    Object.defineProperty(instance, `_${field}`, {
-                        value: undefined,
-                        writable: true,
-                        enumerable: false,
-                        configurable: true,
-                    });
-                    Object.defineProperty(instance, field, metadata[field].descriptor);
-                }
-                else {
-                    // for decoder
-                    Object.defineProperty(instance, field, {
-                        value: undefined,
-                        writable: true,
-                        enumerable: true,
-                        configurable: true,
-                    });
-                }
-                // Object.defineProperty(instance, field, {
-                //     ...instance.constructor[Symbol.metadata][field].descriptor
-                // });
-                // if (args[0]?.hasOwnProperty(field)) {
-                //     instance[field] = args[0][field];
-                // }
-            }
+            Object.defineProperties(instance, instance.constructor[Symbol.metadata]?.[$descriptors] || {});
         }
         static is(type) {
             return typeof (type[Symbol.metadata]) === "object";
@@ -2841,7 +3110,7 @@
          */
         static [$filter](ref, index, view) {
             const metadata = ref.constructor[Symbol.metadata];
-            const tag = metadata[metadata[index]].tag;
+            const tag = metadata[index]?.tag;
             if (view === undefined) {
                 // shared pass/encode: encode if doesn't have a tag
                 return tag === undefined;
@@ -2862,12 +3131,16 @@
         }
         // 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) {
@@ -2881,7 +3154,8 @@
          * @param operation OPERATION to perform (detected automatically)
          */
         setDirty(property, operation) {
-            this[$changes].change(this.constructor[Symbol.metadata][property].index, operation);
+            const metadata = this.constructor[Symbol.metadata];
+            this[$changes].change(metadata[metadata[property]].index, operation);
         }
         clone() {
             const cloned = new (this.constructor);
@@ -2890,7 +3164,9 @@
             // TODO: clone all properties, not only annotated ones
             //
             // for (const field in this) {
-            for (const field in metadata) {
+            for (const fieldIndex in metadata) {
+                // const field = metadata[metadata[fieldIndex]].name;
+                const field = metadata[fieldIndex].name;
                 if (typeof (this[field]) === "object" &&
                     typeof (this[field]?.clone) === "function") {
                     // deep clone
@@ -2904,10 +3180,11 @@
             return cloned;
         }
         toJSON() {
-            const metadata = this.constructor[Symbol.metadata];
             const obj = {};
-            for (const fieldName in metadata) {
-                const field = metadata[fieldName];
+            const metadata = this.constructor[Symbol.metadata];
+            for (const index in metadata) {
+                const field = metadata[index];
+                const fieldName = field.name;
                 if (!field.deprecated && this[fieldName] !== null && typeof (this[fieldName]) !== "undefined") {
                     obj[fieldName] = (typeof (this[fieldName]['toJSON']) === "function")
                         ? this[fieldName]['toJSON']()
@@ -2920,18 +3197,27 @@
             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;
         }
         /**
@@ -2948,30 +3234,40 @@
             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];
@@ -2989,14 +3285,14 @@
                     }
                 }
                 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
@@ -3008,12 +3304,13 @@
                         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`;
                 }
             }
@@ -3047,6 +3344,7 @@
             this.$indexes = new Map();
             this.$refId = 0;
             this[$changes] = new ChangeTree(this);
+            this[$changes].indexes = {};
             if (initialValues) {
                 initialValues.forEach((v) => this.add(v));
             }
@@ -3202,6 +3500,7 @@
             this.$indexes = new Map();
             this.$refId = 0;
             this[$changes] = new ChangeTree(this);
+            this[$changes].indexes = {};
             if (initialValues) {
                 initialValues.forEach((v) => this.add(v));
             }
@@ -3357,6 +3656,8 @@
     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;
@@ -3370,37 +3671,127 @@
         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 = 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);
@@ -3411,12 +3802,18 @@
                     }
                 }
                 // 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.
@@ -3424,97 +3821,113 @@
                     // 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 bytes;
-                return buffer.slice(0, it.offset);
+                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.slice(0, sharedOffset),
-                bytes.slice(viewOffset, it.offset)
+                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);
                 }
             }
             //
@@ -3522,51 +3935,62 @@
             // (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.slice(0, sharedOffset),
-                bytes.slice(viewOffset, it.offset)
+                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 {
@@ -3631,6 +4055,7 @@
         clearRefs() {
             this.refs.clear();
             this.deletedRefs.clear();
+            this.callbacks = {};
             this.refCounts = {};
         }
         // for decoding
@@ -3647,8 +4072,9 @@
                 // Ensure child schema instances have their references removed as well.
                 //
                 if (Metadata.isValidInstance(ref)) {
-                    const metadata = ref['constructor'][Symbol.metadata];
-                    for (const field in metadata) {
+                    const metadata = ref.constructor[Symbol.metadata];
+                    for (const index in metadata) {
+                        const field = metadata[index].name;
                         const childRefId = typeof (ref[field]) === "object" && this.refIds.get(ref[field]);
                         if (childRefId) {
                             this.removeRef(childRefId);
@@ -3695,14 +4121,14 @@
     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);
@@ -3719,7 +4145,7 @@
                 //
                 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.
@@ -3729,7 +4155,7 @@
                     }
                     ref[$onDecodeEnd]?.();
                     ref = nextRef;
-                    decoder = ref['constructor'][$decoder];
+                    decoder = ref.constructor[$decoder];
                     continue;
                 }
                 const result = decoder(this, bytes, it, ref, allChanges);
@@ -3741,9 +4167,9 @@
                     //
                     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;
                             }
                         }
@@ -3764,7 +4190,7 @@
             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;
@@ -3830,14 +4256,27 @@
             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;
@@ -3845,7 +4284,7 @@
                     const field = new ReflectionField();
                     field.name = fieldName;
                     let fieldType;
-                    const type = metadata[fieldName].type;
+                    const type = metadata[index].type;
                     if (typeof (type) === "string") {
                         fieldType = type;
                     }
@@ -3887,65 +4326,335 @@
                 }
                 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() {
@@ -3961,31 +4670,32 @@
              * 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) {
@@ -4001,82 +4711,78 @@
                     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) {
@@ -4088,32 +4794,32 @@
             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)) {
@@ -4165,16 +4871,18 @@
     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;
 
-    Object.defineProperty(exports, '__esModule', { value: true });
-
 }));