@colyseus/schema 3.0.0-alpha.40 → 3.0.0-alpha.42

package/build/umd/index.js

@@ -24,8 +24,6 @@
         /**
          * 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";
@@ -67,1055 +65,1296 @@
     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();
     }
-
-    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;
-            this.parentFiltered = {};
-            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;
-            //
-            // Workaround to allow using an empty Schema (with no `@type()` fields)
-            //
-            if (schema[Symbol.metadata] === undefined) {
-                Metadata.initialize(schema);
-            }
-            this.schemas.set(schema, typeid);
-            return true;
-        }
-        getTypeId(klass) {
-            return this.schemas.get(klass);
-        }
-        discoverTypes(klass, parentIndex, parentFieldViewTag) {
-            if (!this.add(klass)) {
-                return;
-            }
-            // add classes inherited from this base class
-            TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
-                this.discoverTypes(child, parentIndex, parentFieldViewTag);
-            });
-            // add parent classes
-            let parent = klass;
-            while ((parent = Object.getPrototypeOf(parent)) &&
-                parent !== Schema && // stop at root (Schema)
-                parent !== Function.prototype // stop at root (non-Schema)
-            ) {
-                this.discoverTypes(parent);
-            }
-            const metadata = (klass[Symbol.metadata] ??= {});
-            // if any schema/field has filters, mark "context" as having filters.
-            if (metadata[$viewFieldIndexes]) {
-                this.hasFilters = true;
-            }
-            if (parentFieldViewTag !== undefined) {
-                this.parentFiltered[`${this.schemas.get(klass)}-${parentIndex}`] = true;
-            }
-            for (const fieldIndex in metadata) {
-                const index = fieldIndex;
-                const fieldType = metadata[index].type;
-                const viewTag = metadata[index].tag;
-                if (typeof (fieldType) === "string") {
-                    continue;
+    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;
                 }
-                if (Array.isArray(fieldType)) {
-                    const type = fieldType[0];
-                    // skip primitive types
-                    if (type === "string") {
-                        continue;
-                    }
-                    this.discoverTypes(type, index, viewTag);
+                else if (c < 0x800) {
+                    length += 2;
                 }
-                else if (typeof (fieldType) === "function") {
-                    this.discoverTypes(fieldType, viewTag);
+                else if (c < 0xd800 || c >= 0xe000) {
+                    length += 3;
                 }
                 else {
-                    const type = Object.values(fieldType)[0];
-                    // skip primitive types
-                    if (typeof (type) === "string") {
-                        continue;
-                    }
-                    this.discoverTypes(type, index, viewTag);
+                    i++;
+                    length += 4;
                 }
             }
-        }
-    }
-
-    function getNormalizedType(type) {
-        return (Array.isArray(type))
-            ? { array: type[0] }
-            : (typeof (type['type']) !== "undefined")
-                ? type['type']
-                : type;
-    }
-    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.`);
+            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[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 if (c < 0x800) {
+                view[it.offset] = 0xc0 | (c >> 6);
+                view[it.offset + 1] = 0x80 | (c & 0x3f);
+                it.offset += 2;
             }
-            else {
-                // for decoder
-                metadata[$descriptors][name] = {
-                    value: undefined,
-                    writable: true,
-                    enumerable: true,
-                    configurable: true,
-                };
+            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;
             }
-            // 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);
+            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;
             }
-        },
-        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
-                });
+        }
+    }
+    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 = "";
+        }
+        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;
+        }
+        // str 16
+        else if (length < 0x10000) {
+            bytes[it.offset++] = 0xda;
+            uint16$1(bytes, length, it);
+            size = 3;
+        }
+        // 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;
+    }
+    function number$1(bytes, value, it) {
+        if (isNaN(value)) {
+            return number$1(bytes, 0, it);
+        }
+        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;
+                }
             }
-            metadata[$viewFieldIndexes].push(index);
-            if (!metadata[$fieldIndexesByViewTag][tag]) {
-                metadata[$fieldIndexesByViewTag][tag] = [];
+            bytes[it.offset++] = 0xcb;
+            float64$1(bytes, value, it);
+            return 9;
+        }
+        if (value >= 0) {
+            // positive fixnum
+            if (value < 0x80) {
+                bytes[it.offset++] = value & 255; // uint8
+                return 1;
             }
-            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];
+            // uint 8
+            if (value < 0x100) {
+                bytes[it.offset++] = 0xcc;
+                bytes[it.offset++] = value & 255; // uint8
+                return 2;
             }
-            if (!constructor[$encoder]) {
-                constructor[$encoder] = Schema[$encoder];
+            // uint 16
+            if (value < 0x10000) {
+                bytes[it.offset++] = 0xcd;
+                uint16$1(bytes, value, it);
+                return 3;
             }
-            if (!constructor[$decoder]) {
-                constructor[$decoder] = Schema[$decoder];
+            // uint 32
+            if (value < 0x100000000) {
+                bytes[it.offset++] = 0xce;
+                uint32$1(bytes, value, it);
+                return 5;
             }
-            if (!constructor.prototype.toJSON) {
-                constructor.prototype.toJSON = Schema.prototype.toJSON;
+            // uint 64
+            bytes[it.offset++] = 0xcf;
+            uint64$1(bytes, value, it);
+            return 9;
+        }
+        else {
+            // negative fixnum
+            if (value >= -0x20) {
+                bytes[it.offset++] = 0xe0 | (value + 0x20);
+                return 1;
             }
-            //
-            // 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++;
+            // int 8
+            if (value >= -0x80) {
+                bytes[it.offset++] = 0xd0;
+                int8$1(bytes, value, it);
+                return 2;
             }
-            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,
-                    });
-                }
+            // int 16
+            if (value >= -0x8000) {
+                bytes[it.offset++] = 0xd1;
+                int16$1(bytes, value, it);
+                return 3;
             }
-            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;
+            // int 32
+            if (value >= -0x80000000) {
+                bytes[it.offset++] = 0xd2;
+                int32$1(bytes, value, it);
+                return 5;
             }
-            return fields;
+            // 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
+     * 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
+     */
+    // 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;
+            }
+            if ((byte & 0xe0) === 0xc0) {
+                string += String.fromCharCode(((byte & 0x1f) << 6) |
+                    (bytes[++i] & 0x3f));
+                continue;
+            }
+            if ((byte & 0xf0) === 0xe0) {
+                string += String.fromCharCode(((byte & 0x0f) << 12) |
+                    ((bytes[++i] & 0x3f) << 6) |
+                    ((bytes[++i] & 0x3f) << 0));
+                continue;
+            }
+            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(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) {
+        _int32[0] = int32(bytes, it);
+        return _float32[0];
+    }
+    function float64(bytes, it) {
+        _int32[0 ] = int32(bytes, it);
+        _int32[1 ] = int32(bytes, it);
+        return _float64[0];
+    }
+    function int64(bytes, it) {
+        const low = uint32(bytes, it);
+        const high = int32(bytes, it) * Math.pow(2, 32);
+        return high + low;
+    }
+    function uint64(bytes, it) {
+        const low = uint32(bytes, it);
+        const high = uint32(bytes, it) * Math.pow(2, 32);
+        return high + low;
+    }
+    function bigint64(bytes, it) {
+        _int32[0] = int32(bytes, it);
+        _int32[1] = int32(bytes, it);
+        return _int64[0];
+    }
+    function biguint64(bytes, it) {
+        _int32[0] = int32(bytes, it);
+        _int32[1] = int32(bytes, it);
+        return _uint64[0];
+    }
+    function boolean(bytes, it) {
+        return uint8(bytes, it) > 0;
+    }
+    function string(bytes, it) {
+        const prefix = bytes[it.offset++];
+        let length;
+        if (prefix < 0xc0) {
+            // fixstr
+            length = prefix & 0x1f;
+        }
+        else if (prefix === 0xd9) {
+            length = uint8(bytes, it);
+        }
+        else if (prefix === 0xda) {
+            length = uint16(bytes, it);
+        }
+        else if (prefix === 0xdb) {
+            length = uint32(bytes, it);
+        }
+        return utf8Read(bytes, it, length);
+    }
+    function number(bytes, it) {
+        const prefix = bytes[it.offset++];
+        if (prefix < 0x80) {
+            // positive fixint
+            return prefix;
+        }
+        else if (prefix === 0xca) {
+            // float 32
+            return float32(bytes, it);
+        }
+        else if (prefix === 0xcb) {
+            // float 64
+            return float64(bytes, it);
+        }
+        else if (prefix === 0xcc) {
+            // uint 8
+            return uint8(bytes, it);
+        }
+        else if (prefix === 0xcd) {
+            // uint 16
+            return uint16(bytes, it);
+        }
+        else if (prefix === 0xce) {
+            // uint 32
+            return uint32(bytes, it);
+        }
+        else if (prefix === 0xcf) {
+            // uint 64
+            return uint64(bytes, it);
+        }
+        else if (prefix === 0xd0) {
+            // int 8
+            return int8(bytes, it);
+        }
+        else if (prefix === 0xd1) {
+            // int 16
+            return int16(bytes, it);
+        }
+        else if (prefix === 0xd2) {
+            // int 32
+            return int32(bytes, it);
+        }
+        else if (prefix === 0xd3) {
+            // int 64
+            return int64(bytes, it);
+        }
+        else if (prefix > 0xdf) {
+            // negative fixint
+            return (0xff - prefix + 1) * -1;
         }
+    }
+    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 setOperationAtIndex(changeSet, index) {
-        const operationsIndex = changeSet.indexes[index];
-        if (operationsIndex === undefined) {
-            changeSet.indexes[index] = changeSet.operations.push(index) - 1;
+    const registeredTypes = {};
+    const identifiers = new Map();
+    function registerType(identifier, definition) {
+        if (definition.constructor) {
+            identifiers.set(definition.constructor, identifier);
+            registeredTypes[identifier] = definition;
         }
-        else {
-            changeSet.operations[operationsIndex] = index;
+        if (definition.encode) {
+            encode[identifier] = definition.encode;
         }
-    }
-    function deleteOperationAtIndex(changeSet, index) {
-        const operationsIndex = changeSet.indexes[index];
-        if (operationsIndex !== undefined) {
-            changeSet.operations[operationsIndex] = undefined;
+        if (definition.decode) {
+            decode[identifier] = definition.decode;
         }
-        delete changeSet.indexes[index];
     }
-    function enqueueChangeTree(root, changeTree, changeSet, queueRootIndex = changeTree[changeSet].queueRootIndex) {
-        if (root && root[changeSet][queueRootIndex] !== changeTree) {
-            changeTree[changeSet].queueRootIndex = root[changeSet].push(changeTree) - 1;
-        }
+    function getType(identifier) {
+        return registeredTypes[identifier];
     }
-    class ChangeTree {
-        constructor(ref) {
-            this.isFiltered = false;
-            this.isPartiallyFiltered = 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?
-            //
-            if (ref.constructor[Symbol.metadata]?.[$viewFieldIndexes]) {
-                this.allFilteredChanges = { indexes: {}, operations: [] };
-                this.filteredChanges = { indexes: {}, operations: [] };
-            }
+    function defineCustomTypes(types) {
+        for (const identifier in types) {
+            registerType(identifier, types[identifier]);
         }
-        setRoot(root) {
-            this.root = root;
-            const isNewChangeTree = this.root.add(this);
-            const metadata = this.ref.constructor[Symbol.metadata];
-            if (this.root.types.hasFilters) {
-                //
-                // At Schema initialization, the "root" structure might not be available
-                // yet, as it only does once the "Encoder" has been set up.
-                //
-                // So the "parent" may be already set without a "root".
-                //
-                this.checkIsFiltered(metadata, this.parent, this.parentIndex);
-                if (this.isFiltered || this.isPartiallyFiltered) {
-                    enqueueChangeTree(root, this, 'filteredChanges');
-                    if (isNewChangeTree) {
-                        this.root.allFilteredChanges.push(this);
-                    }
-                }
-            }
-            if (!this.isFiltered) {
-                enqueueChangeTree(root, this, 'changes');
-                if (isNewChangeTree) {
-                    this.root.allChanges.push(this);
+        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);
                 }
-            }
-            // Recursively set root on child structures
-            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);
-                });
+                inherits.add(target);
             }
         }
-        setParent(parent, root, parentIndex) {
-            this.parent = parent;
-            this.parentIndex = parentIndex;
-            // avoid setting parents with empty `root`
-            if (!root) {
-                return;
-            }
-            const metadata = this.ref.constructor[Symbol.metadata];
-            // skip if parent is already set
-            if (root !== this.root) {
-                this.root = root;
-                const isNewChangeTree = root.add(this);
-                if (root.types.hasFilters) {
-                    this.checkIsFiltered(metadata, parent, parentIndex);
-                    if (this.isFiltered || this.isPartiallyFiltered) {
-                        enqueueChangeTree(root, this, 'filteredChanges');
-                        if (isNewChangeTree) {
-                            this.root.allFilteredChanges.push(this);
-                        }
-                    }
-                }
-                if (!this.isFiltered) {
-                    enqueueChangeTree(root, this, 'changes');
-                    if (isNewChangeTree) {
-                        this.root.allChanges.push(this);
-                    }
-                }
-            }
-            else {
-                root.add(this);
-            }
-            // assign same parent on child structures
-            if (metadata) {
-                metadata[$refTypeFieldIndexes]?.forEach((index) => {
-                    const field = metadata[index];
-                    const value = this.ref[field.name];
-                    value?.[$changes].setParent(this.ref, root, index);
-                    // try { throw new Error(); } catch (e) {
-                    //     console.log(e.stack);
-                    // }
-                });
-            }
-            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);
-                });
+        constructor(rootClass) {
+            this.types = {};
+            this.schemas = new Map();
+            this.hasFilters = false;
+            this.parentFiltered = {};
+            if (rootClass) {
+                this.discoverTypes(rootClass);
             }
         }
-        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);
-                });
-            }
+        has(schema) {
+            return this.schemas.has(schema);
         }
-        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');
+        get(typeid) {
+            return this.types[typeid];
         }
-        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');
+        add(schema, typeid = this.schemas.size) {
+            // skip if already registered
+            if (this.schemas.has(schema)) {
+                return false;
             }
-        }
-        shiftChangeIndexes(shiftIndex) {
-            //
-            // Used only during:
+            this.types[typeid] = schema;
             //
-            // - ArraySchema#unshift()
+            // Workaround to allow using an empty Schema (with no `@type()` fields)
             //
-            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];
+            if (schema[Symbol.metadata] === undefined) {
+                Metadata.initialize(schema);
             }
-            this.indexedOperations = newIndexedOperations;
-            changeSet.indexes = newIndexes;
-            changeSet.operations = changeSet.operations.map((index) => index + shiftIndex);
+            this.schemas.set(schema, typeid);
+            return true;
         }
-        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);
+        getTypeId(klass) {
+            return this.schemas.get(klass);
+        }
+        discoverTypes(klass, parentIndex, parentFieldViewTag) {
+            if (!this.add(klass)) {
+                return;
             }
-            else {
-                this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
+            // add classes inherited from this base class
+            TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
+                this.discoverTypes(child, parentIndex, parentFieldViewTag);
+            });
+            // 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);
             }
-        }
-        _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;
+            const metadata = (klass[Symbol.metadata] ??= {});
+            // if any schema/field has filters, mark "context" as having filters.
+            if (metadata[$viewFieldIndexes]) {
+                this.hasFilters = true;
+            }
+            if (parentFieldViewTag !== undefined) {
+                this.parentFiltered[`${this.schemas.get(klass)}-${parentIndex}`] = true;
+            }
+            for (const fieldIndex in metadata) {
+                const index = fieldIndex;
+                const fieldType = metadata[index].type;
+                const viewTag = metadata[index].tag;
+                if (typeof (fieldType) === "string") {
+                    continue;
                 }
-                else {
-                    newIndexes[key] = index;
+                if (Array.isArray(fieldType)) {
+                    const type = fieldType[0];
+                    // skip primitive types
+                    if (type === "string") {
+                        continue;
+                    }
+                    this.discoverTypes(type, index, viewTag);
                 }
-            }
-            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;
+                else if (typeof (fieldType) === "function") {
+                    this.discoverTypes(fieldType, viewTag);
+                }
+                else {
+                    const type = Object.values(fieldType)[0];
+                    // skip primitive types
+                    if (typeof (type) === "string") {
+                        continue;
+                    }
+                    this.discoverTypes(type, index, viewTag);
                 }
             }
         }
-        indexedOperation(index, operation, allChangesIndex = index) {
-            this.indexedOperations[index] = operation;
-            if (this.filteredChanges) {
-                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');
+    }
+
+    function getNormalizedType(type) {
+        return (Array.isArray(type))
+            ? { array: type[0] }
+            : (typeof (type['type']) !== "undefined")
+                ? type['type']
+                : type;
+    }
+    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.`);
             }
-        }
-        getType(index) {
-            if (Metadata.isValidInstance(this.ref)) {
-                const metadata = this.ref.constructor[Symbol.metadata];
-                return metadata[index].type;
+            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 {
-                //
-                // Get the child type from parent structure.
-                // - ["string"] => "string"
-                // - { map: "string" } => "string"
-                // - { set: "string" } => "string"
-                //
-                return this.ref[$childType];
+                // for decoder
+                metadata[$descriptors][name] = {
+                    value: undefined,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true,
+                };
             }
-        }
-        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);
+            // 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,
+                    });
                 }
-                return;
+                metadata[$refTypeFieldIndexes].push(index);
             }
-            const changeSet = (this.filteredChanges)
-                ? 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]);
+        },
+        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];
             }
-            //
-            // FIXME: this is looking a ugly and repeated
-            //
-            if (this.filteredChanges) {
-                deleteOperationAtIndex(this.allFilteredChanges, allChangesIndex);
-                enqueueChangeTree(this.root, this, 'filteredChanges');
+            if (!constructor[$decoder]) {
+                constructor[$decoder] = Schema[$decoder];
             }
-            else {
-                deleteOperationAtIndex(this.allChanges, allChangesIndex);
-                enqueueChangeTree(this.root, this, 'changes');
+            if (!constructor.prototype.toJSON) {
+                constructor.prototype.toJSON = Schema.prototype.toJSON;
             }
-        }
-        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.
+            // detect index for this field, considering inheritance
             //
-            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;
+            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++;
             }
-            if (discardAll) {
-                this.allChanges.indexes = {};
-                this.allChanges.operations.length = 0;
-                if (this.allFilteredChanges !== undefined) {
-                    this.allFilteredChanges.indexes = {};
-                    this.allFilteredChanges.operations.length = 0;
+            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,
+                    });
                 }
-                // 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();
-                }
+            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;
             }
-            this.discard();
+            return fields;
         }
-        ensureRefId() {
-            // skip if refId is already set.
-            if (this.refId !== undefined) {
-                return;
-            }
-            this.refId = this.root.getNextUniqueId();
+    };
+
+    function setOperationAtIndex(changeSet, index) {
+        const operationsIndex = changeSet.indexes[index];
+        if (operationsIndex === undefined) {
+            changeSet.indexes[index] = changeSet.operations.push(index) - 1;
         }
-        get changed() {
-            return (Object.entries(this.indexedOperations).length > 0);
+        else {
+            changeSet.operations[operationsIndex] = index;
         }
-        checkIsFiltered(metadata, parent, parentIndex) {
-            // Detect if current structure has "filters" declared
-            this.isPartiallyFiltered = metadata?.[$viewFieldIndexes] !== undefined;
-            if (this.isPartiallyFiltered) {
-                this.filteredChanges = this.filteredChanges || { indexes: {}, operations: [] };
-                this.allFilteredChanges = this.allFilteredChanges || { indexes: {}, operations: [] };
-            }
-            // skip if parent is not set
-            if (!parent) {
-                return;
-            }
-            if (!Metadata.isValidInstance(parent)) {
-                const parentChangeTree = parent[$changes];
-                parent = parentChangeTree.parent;
-                parentIndex = parentChangeTree.parentIndex;
-            }
-            const parentMetadata = parent.constructor?.[Symbol.metadata];
-            this.isFiltered = parentMetadata?.[$viewFieldIndexes]?.includes(parentIndex);
+    }
+    function deleteOperationAtIndex(changeSet, index) {
+        const operationsIndex = changeSet.indexes[index];
+        if (operationsIndex !== undefined) {
+            changeSet.operations[operationsIndex] = undefined;
+        }
+        delete changeSet.indexes[index];
+    }
+    function enqueueChangeTree(root, changeTree, changeSet, queueRootIndex = changeTree[changeSet].queueRootIndex) {
+        if (root && root[changeSet][queueRootIndex] !== changeTree) {
+            changeTree[changeSet].queueRootIndex = root[changeSet].push(changeTree) - 1;
+        }
+    }
+    class ChangeTree {
+        constructor(ref) {
+            this.isFiltered = false;
+            this.isPartiallyFiltered = false;
+            this.indexedOperations = {};
             //
-            // TODO: refactor this!
+            // TODO:
+            //   try storing the index + operation per item.
+            //   example: 1024 & 1025 => ADD, 1026 => DELETE
             //
-            //      swapping `changes` and `filteredChanges` is required here
-            //      because "isFiltered" may not be imedialely available on `change()`
+            // => https://chatgpt.com/share/67107d0c-bc20-8004-8583-83b17dd7c196
             //
-            if (this.isFiltered) {
-                this.filteredChanges = { indexes: {}, operations: [] };
+            this.changes = { indexes: {}, operations: [] };
+            this.allChanges = { indexes: {}, operations: [] };
+            /**
+             * Is this a new instance? Used on ArraySchema to determine OPERATION.MOVE_AND_ADD operation.
+             */
+            this.isNew = true;
+            this.ref = ref;
+            //
+            // Does this structure have "filters" declared?
+            //
+            if (ref.constructor[Symbol.metadata]?.[$viewFieldIndexes]) {
                 this.allFilteredChanges = { indexes: {}, operations: [] };
-                if (this.changes.operations.length > 0) {
-                    // swap changes reference
-                    const changes = this.changes;
-                    this.changes = this.filteredChanges;
-                    this.filteredChanges = changes;
-                    // swap "all changes" reference
-                    const allFilteredChanges = this.allFilteredChanges;
-                    this.allFilteredChanges = this.allChanges;
-                    this.allChanges = allFilteredChanges;
-                    // console.log("SWAP =>", {
-                    //     "this.allFilteredChanges": this.allFilteredChanges,
-                    //     "this.allChanges": this.allChanges
-                    // })
+                this.filteredChanges = { indexes: {}, operations: [] };
+            }
+        }
+        setRoot(root) {
+            this.root = root;
+            const isNewChangeTree = this.root.add(this);
+            const metadata = this.ref.constructor[Symbol.metadata];
+            if (this.root.types.hasFilters) {
+                //
+                // At Schema initialization, the "root" structure might not be available
+                // yet, as it only does once the "Encoder" has been set up.
+                //
+                // So the "parent" may be already set without a "root".
+                //
+                this.checkIsFiltered(metadata, this.parent, this.parentIndex);
+                if (this.isFiltered || this.isPartiallyFiltered) {
+                    enqueueChangeTree(root, this, 'filteredChanges');
+                    if (isNewChangeTree) {
+                        this.root.allFilteredChanges.push(this);
+                    }
                 }
             }
-        }
-    }
-
-    /**
-     * 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();
-    }
-    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;
+            if (!this.isFiltered) {
+                enqueueChangeTree(root, this, 'changes');
+                if (isNewChangeTree) {
+                    this.root.allChanges.push(this);
                 }
-                else if (c < 0xd800 || c >= 0xe000) {
-                    length += 3;
+            }
+            // Recursively set root on child structures
+            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);
+                });
+            }
+        }
+        setParent(parent, root, parentIndex) {
+            this.parent = parent;
+            this.parentIndex = parentIndex;
+            // avoid setting parents with empty `root`
+            if (!root) {
+                return;
+            }
+            const metadata = this.ref.constructor[Symbol.metadata];
+            // skip if parent is already set
+            if (root !== this.root) {
+                this.root = root;
+                const isNewChangeTree = root.add(this);
+                if (root.types.hasFilters) {
+                    this.checkIsFiltered(metadata, parent, parentIndex);
+                    if (this.isFiltered || this.isPartiallyFiltered) {
+                        enqueueChangeTree(root, this, 'filteredChanges');
+                        if (isNewChangeTree) {
+                            this.root.allFilteredChanges.push(this);
+                        }
+                    }
                 }
-                else {
-                    i++;
-                    length += 4;
+                if (!this.isFiltered) {
+                    enqueueChangeTree(root, this, 'changes');
+                    if (isNewChangeTree) {
+                        this.root.allChanges.push(this);
+                    }
                 }
             }
-            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;
+            else {
+                root.add(this);
             }
-            else if (c < 0x800) {
-                view[it.offset] = 0xc0 | (c >> 6);
-                view[it.offset + 1] = 0x80 | (c & 0x3f);
-                it.offset += 2;
+            // assign same parent on child structures
+            if (metadata) {
+                metadata[$refTypeFieldIndexes]?.forEach((index) => {
+                    const field = metadata[index];
+                    const value = this.ref[field.name];
+                    value?.[$changes].setParent(this.ref, root, index);
+                    // try { throw new Error(); } catch (e) {
+                    //     console.log(e.stack);
+                    // }
+                });
             }
-            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;
+            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 {
-                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;
+        }
+        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);
+                });
             }
         }
-    }
-    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 float32$1(bytes, value, it) {
-        writeFloat32(bytes, value, it);
-    }
-    function float64$1(bytes, value, it) {
-        writeFloat64(bytes, value, it);
-    }
-    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 writeFloat64(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 = "";
+        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');
         }
-        let length = utf8Length(value, "utf8");
-        let size = 0;
-        // fixstr
-        if (length < 0x20) {
-            bytes[it.offset++] = length | 0xa0;
-            size = 1;
+        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');
+            }
         }
-        // str 8
-        else if (length < 0x100) {
-            bytes[it.offset++] = 0xd9;
-            bytes[it.offset++] = length % 255;
-            size = 2;
+        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);
         }
-        // str 16
-        else if (length < 0x10000) {
-            bytes[it.offset++] = 0xda;
-            uint16$1(bytes, length, it);
-            size = 3;
+        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);
+            }
         }
-        // str 32
-        else if (length < 0x100000000) {
-            bytes[it.offset++] = 0xdb;
-            uint32$1(bytes, length, it);
-            size = 5;
+        _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;
+                }
+            }
         }
-        else {
-            throw new Error('String too long');
+        indexedOperation(index, operation, allChangesIndex = index) {
+            this.indexedOperations[index] = operation;
+            if (this.filteredChanges) {
+                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');
+            }
         }
-        utf8Write(bytes, value, it);
-        return size + length;
-    }
-    function number$1(bytes, value, it) {
-        if (isNaN(value)) {
-            return number$1(bytes, 0, it);
+        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];
+            }
         }
-        else if (!isFinite(value)) {
-            return number$1(bytes, (value > 0) ? Number.MAX_SAFE_INTEGER : -Number.MAX_SAFE_INTEGER, it);
+        getChange(index) {
+            return this.indexedOperations[index];
         }
-        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;
+        //
+        // used during `.encode()`
+        //
+        getValue(index, isEncodeAll = false) {
+            //
+            // `isEncodeAll` param is only used by ArraySchema
+            //
+            return this.ref[$getByIndex](index, isEncodeAll);
         }
-        if (value >= 0) {
-            // positive fixnum
-            if (value < 0x80) {
-                bytes[it.offset++] = value & 255; // uint8
-                return 1;
+        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;
             }
-            // uint 8
-            if (value < 0x100) {
-                bytes[it.offset++] = 0xcc;
-                bytes[it.offset++] = value & 255; // uint8
-                return 2;
+            const changeSet = (this.filteredChanges)
+                ? 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]);
             }
-            // uint 16
-            if (value < 0x10000) {
-                bytes[it.offset++] = 0xcd;
-                uint16$1(bytes, value, it);
-                return 3;
+            //
+            // FIXME: this is looking a ugly and repeated
+            //
+            if (this.filteredChanges) {
+                deleteOperationAtIndex(this.allFilteredChanges, allChangesIndex);
+                enqueueChangeTree(this.root, this, 'filteredChanges');
             }
-            // uint 32
-            if (value < 0x100000000) {
-                bytes[it.offset++] = 0xce;
-                uint32$1(bytes, value, it);
-                return 5;
+            else {
+                deleteOperationAtIndex(this.allChanges, allChangesIndex);
+                enqueueChangeTree(this.root, this, 'changes');
             }
-            // uint 64
-            bytes[it.offset++] = 0xcf;
-            uint64$1(bytes, value, it);
-            return 9;
         }
-        else {
-            // negative fixnum
-            if (value >= -0x20) {
-                bytes[it.offset++] = 0xe0 | (value + 0x20);
-                return 1;
+        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;
             }
-            // int 8
-            if (value >= -0x80) {
-                bytes[it.offset++] = 0xd0;
-                int8$1(bytes, value, it);
-                return 2;
+            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(metadata, parent, parentIndex) {
+            // Detect if current structure has "filters" declared
+            this.isPartiallyFiltered = metadata?.[$viewFieldIndexes] !== undefined;
+            if (this.isPartiallyFiltered) {
+                this.filteredChanges = this.filteredChanges || { indexes: {}, operations: [] };
+                this.allFilteredChanges = this.allFilteredChanges || { indexes: {}, operations: [] };
             }
-            // int 16
-            if (value >= -0x8000) {
-                bytes[it.offset++] = 0xd1;
-                int16$1(bytes, value, it);
-                return 3;
+            // skip if parent is not set
+            if (!parent) {
+                return;
             }
-            // int 32
-            if (value >= -0x80000000) {
-                bytes[it.offset++] = 0xd2;
-                int32$1(bytes, value, it);
-                return 5;
+            if (!Metadata.isValidInstance(parent)) {
+                const parentChangeTree = parent[$changes];
+                parent = parentChangeTree.parent;
+                parentIndex = parentChangeTree.parentIndex;
+            }
+            const parentMetadata = parent.constructor?.[Symbol.metadata];
+            this.isFiltered = parentMetadata?.[$viewFieldIndexes]?.includes(parentIndex);
+            //
+            // TODO: refactor this!
+            //
+            //      swapping `changes` and `filteredChanges` is required here
+            //      because "isFiltered" may not be imedialely available on `change()`
+            //
+            if (this.isFiltered) {
+                this.filteredChanges = { indexes: {}, operations: [] };
+                this.allFilteredChanges = { indexes: {}, operations: [] };
+                if (this.changes.operations.length > 0) {
+                    // swap changes reference
+                    const changes = this.changes;
+                    this.changes = this.filteredChanges;
+                    this.filteredChanges = changes;
+                    // swap "all changes" reference
+                    const allFilteredChanges = this.allFilteredChanges;
+                    this.allFilteredChanges = this.allChanges;
+                    this.allChanges = allFilteredChanges;
+                    // console.log("SWAP =>", {
+                    //     "this.allFilteredChanges": this.allFilteredChanges,
+                    //     "this.allChanges": this.allChanges
+                    // })
+                }
             }
-            // int 64
-            bytes[it.offset++] = 0xd3;
-            int64$1(bytes, value, it);
-            return 9;
         }
     }
 
-    var encode = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        boolean: boolean$1,
-        float32: float32$1,
-        float64: float64$1,
-        int16: int16$1,
-        int32: int32$1,
-        int64: int64$1,
-        int8: int8$1,
-        number: number$1,
-        string: string$1,
-        uint16: uint16$1,
-        uint32: uint32$1,
-        uint64: uint64$1,
-        uint8: uint8$1,
-        utf8Length: utf8Length,
-        utf8Write: utf8Write,
-        writeFloat32: writeFloat32,
-        writeFloat64: writeFloat64
-    });
-
     function encodeValue(encoder, bytes, type, value, operation, it) {
         if (typeof (type) === "string") {
             encode[type]?.(bytes, value, it);
@@ -1125,7 +1364,7 @@
             // Encode refId for this instance.
             // The actual instance is going to be encoded on next `changeTree` iteration.
             //
-            number$1(bytes, value[$changes].refId, it);
+            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);
@@ -1136,7 +1375,7 @@
             // Encode refId for this instance.
             // The actual instance is going to be encoded on next `changeTree` iteration.
             //
-            number$1(bytes, value[$changes].refId, it);
+            encode.number(bytes, value[$changes].refId, it);
         }
     }
     /**
@@ -1167,7 +1406,7 @@
             return;
         }
         // encode index
-        number$1(bytes, index, it);
+        encode.number(bytes, index, it);
         // Do not encode value for DELETE operations
         if (operation === exports.OPERATION.DELETE) {
             return;
@@ -1182,7 +1421,7 @@
                 // MapSchema dynamic key
                 //
                 const dynamicIndex = changeTree.ref['$indexes'].get(index);
-                string$1(bytes, dynamicIndex, it);
+                encode.string(bytes, dynamicIndex, it);
             }
         }
         const type = ref[$childType];
@@ -1230,7 +1469,7 @@
             return;
         }
         // encode index
-        number$1(bytes, refOrIndex, it);
+        encode.number(bytes, refOrIndex, it);
         // Do not encode value for DELETE operations
         if (operation === exports.OPERATION.DELETE) {
             return;
@@ -1248,259 +1487,6 @@
         encodeValue(encoder, bytes, type, value, 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;
-            }
-            if ((byte & 0xe0) === 0xc0) {
-                string += String.fromCharCode(((byte & 0x1f) << 6) |
-                    (bytes[++i] & 0x3f));
-                continue;
-            }
-            if ((byte & 0xf0) === 0xe0) {
-                string += String.fromCharCode(((byte & 0x0f) << 12) |
-                    ((bytes[++i] & 0x3f) << 6) |
-                    ((bytes[++i] & 0x3f) << 0));
-                continue;
-            }
-            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(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;
-    }
-    function uint64(bytes, it) {
-        const low = uint32(bytes, it);
-        const high = uint32(bytes, it) * Math.pow(2, 32);
-        return high + low;
-    }
-    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];
-    }
-    function readFloat64(bytes, it) {
-        _int32[0 ] = int32(bytes, it);
-        _int32[1 ] = int32(bytes, it);
-        return _float64[0];
-    }
-    function boolean(bytes, it) {
-        return uint8(bytes, it) > 0;
-    }
-    function string(bytes, it) {
-        const prefix = bytes[it.offset++];
-        let length;
-        if (prefix < 0xc0) {
-            // fixstr
-            length = prefix & 0x1f;
-        }
-        else if (prefix === 0xd9) {
-            length = uint8(bytes, it);
-        }
-        else if (prefix === 0xda) {
-            length = uint16(bytes, it);
-        }
-        else if (prefix === 0xdb) {
-            length = uint32(bytes, it);
-        }
-        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;
-        }
-        else if (prefix === 0xca) {
-            // float 32
-            return readFloat32(bytes, it);
-        }
-        else if (prefix === 0xcb) {
-            // float 64
-            return readFloat64(bytes, it);
-        }
-        else if (prefix === 0xcc) {
-            // uint 8
-            return uint8(bytes, it);
-        }
-        else if (prefix === 0xcd) {
-            // uint 16
-            return uint16(bytes, it);
-        }
-        else if (prefix === 0xce) {
-            // uint 32
-            return uint32(bytes, it);
-        }
-        else if (prefix === 0xcf) {
-            // uint 64
-            return uint64(bytes, it);
-        }
-        else if (prefix === 0xd0) {
-            // int 8
-            return int8(bytes, it);
-        }
-        else if (prefix === 0xd1) {
-            // int 16
-            return int16(bytes, it);
-        }
-        else if (prefix === 0xd2) {
-            // int 32
-            return int32(bytes, it);
-        }
-        else if (prefix === 0xd3) {
-            // int 64
-            return int64(bytes, it);
-        }
-        else if (prefix > 0xdf) {
-            // negative fixint
-            return (0xff - prefix + 1) * -1;
-        }
-    }
-    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,
-        arrayCheck: arrayCheck,
-        boolean: boolean,
-        float32: float32,
-        float64: float64,
-        int16: int16,
-        int32: int32,
-        int64: int64,
-        int8: int8,
-        number: number,
-        numberCheck: numberCheck,
-        readFloat32: readFloat32,
-        readFloat64: readFloat64,
-        string: string,
-        stringCheck: stringCheck,
-        switchStructureCheck: switchStructureCheck,
-        uint16: uint16,
-        uint32: uint32,
-        uint64: uint64,
-        uint8: uint8,
-        utf8Read: utf8Read
-    });
-
     const DEFINITION_MISMATCH = -1;
     function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges) {
         const $root = decoder.root;
@@ -1535,7 +1521,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);
@@ -1564,7 +1550,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();
@@ -1643,12 +1629,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 {
@@ -1710,7 +1696,7 @@
         }
         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);
             index = ref.findIndex((value) => value === previousValue);
             ref[$deleteByIndex](index);
@@ -1726,7 +1712,7 @@
             return;
         }
         else if (operation === exports.OPERATION.ADD_BY_REFID) {
-            const refId = number(bytes, it);
+            const refId = decode.number(bytes, it);
             const itemByRefId = decoder.root.refs.get(refId);
             // use existing index, or push new value
             index = (itemByRefId)
@@ -1734,7 +1720,7 @@
                 : ref.length;
         }
         else {
-            index = number(bytes, it);
+            index = decode.number(bytes, it);
         }
         const type = ref[$childType];
         let dynamicIndex = index;
@@ -1781,6 +1767,10 @@
                     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;
@@ -1788,6 +1778,10 @@
             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})`) || ''}`;
@@ -3792,7 +3786,7 @@
                 // (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);
                 }
                 for (let j = 0, numChanges = operations.operations.length; j < numChanges; j++) {
                     const fieldIndex = operations.operations[j];
@@ -3921,7 +3915,7 @@
                 const encoder = ctor[$encoder];
                 const metadata = ctor[Symbol.metadata];
                 bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
-                number$1(bytes, changeTree.refId, it);
+                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];
@@ -3987,7 +3981,7 @@
             }
             if (baseTypeId !== targetTypeId) {
                 bytes[it.offset++] = TYPE_ID & 255;
-                number$1(bytes, targetTypeId, it);
+                encode.number(bytes, targetTypeId, it);
             }
         }
         get hasChanges() {
@@ -4147,7 +4141,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.
@@ -4169,9 +4163,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;
                             }
                         }
@@ -4192,7 +4186,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;
@@ -4871,6 +4865,7 @@
     exports.decode = decode;
     exports.decodeKeyValueOperation = decodeKeyValueOperation;
     exports.decodeSchemaOperation = decodeSchemaOperation;
+    exports.defineCustomTypes = defineCustomTypes;
     exports.defineTypes = defineTypes;
     exports.deprecated = deprecated;
     exports.dumpChanges = dumpChanges;