@colyseus/schema 3.0.76 → 4.0.1

package/build/umd/index.js

@@ -32,6 +32,7 @@
 
     Symbol.metadata ??= Symbol.for("Symbol.metadata");
 
+    const $refId = "~refId";
     const $track = "~track";
     const $encoder = "~encoder";
     const $decoder = "~decoder";
@@ -562,12 +563,16 @@
     }
 
     class TypeContext {
+        types = {};
+        schemas = new Map();
+        hasFilters = false;
+        parentFiltered = {};
         /**
          * For inheritance support
          * Keeps track of which classes extends which. (parent -> children)
          */
-        static { this.inheritedTypes = new Map(); }
-        static { this.cachedContexts = new Map(); }
+        static inheritedTypes = new Map();
+        static cachedContexts = new Map();
         static register(target) {
             const parent = Object.getPrototypeOf(target);
             if (parent !== Schema) {
@@ -588,10 +593,6 @@
             return context;
         }
         constructor(rootClass) {
-            this.types = {};
-            this.schemas = new Map();
-            this.hasFilters = false;
-            this.parentFiltered = {};
             if (rootClass) {
                 this.discoverTypes(rootClass);
             }
@@ -932,11 +933,7 @@
                     });
                 }
             }
-            Object.defineProperty(constructor, Symbol.metadata, {
-                value: metadata,
-                writable: false,
-                configurable: true
-            });
+            constructor[Symbol.metadata] = metadata;
             return metadata;
         },
         isValidInstance(klass) {
@@ -988,25 +985,33 @@
         delete changeSet.indexes[index];
     }
     class ChangeTree {
+        ref;
+        metadata;
+        root;
+        parentChain; // Linked list for tracking parents
+        /**
+         * Whether this structure is parent of a filtered structure.
+         */
+        isFiltered = false;
+        isVisibilitySharedWithParent; // See test case: 'should not be required to manually call view.add() items to child arrays without @view() tag'
+        indexedOperations = {};
+        //
+        // TODO:
+        //   try storing the index + operation per item.
+        //   example: 1024 & 1025 => ADD, 1026 => DELETE
+        //
+        // => https://chatgpt.com/share/67107d0c-bc20-8004-8583-83b17dd7c196
+        //
+        changes = { indexes: {}, operations: [] };
+        allChanges = { indexes: {}, operations: [] };
+        filteredChanges;
+        allFilteredChanges;
+        indexes; // TODO: remove this, only used by MapSchema/SetSchema/CollectionSchema (`encodeKeyValueOperation`)
+        /**
+         * Is this a new instance? Used on ArraySchema to determine OPERATION.MOVE_AND_ADD operation.
+         */
+        isNew = true;
         constructor(ref) {
-            /**
-             * Whether this structure is parent of a filtered structure.
-             */
-            this.isFiltered = false;
-            this.indexedOperations = {};
-            //
-            // TODO:
-            //   try storing the index + operation per item.
-            //   example: 1024 & 1025 => ADD, 1026 => DELETE
-            //
-            // => https://chatgpt.com/share/67107d0c-bc20-8004-8583-83b17dd7c196
-            //
-            this.changes = { indexes: {}, operations: [] };
-            this.allChanges = { indexes: {}, operations: [] };
-            /**
-             * Is this a new instance? Used on ArraySchema to determine OPERATION.MOVE_AND_ADD operation.
-             */
-            this.isNew = true;
             this.ref = ref;
             this.metadata = ref.constructor[Symbol.metadata];
             //
@@ -1478,7 +1483,7 @@
             // Encode refId for this instance.
             // The actual instance is going to be encoded on next `changeTree` iteration.
             //
-            encode.number(bytes, value[$changes].refId, it);
+            encode.number(bytes, value[$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);
@@ -1489,7 +1494,7 @@
             // Encode refId for this instance.
             // The actual instance is going to be encoded on next `changeTree` iteration.
             //
-            encode.number(bytes, value[$changes].refId, it);
+            encode.number(bytes, value[$refId], it);
         }
     }
     /**
@@ -1565,7 +1570,7 @@
             if (!item) {
                 return;
             }
-            refOrIndex = item[$changes].refId;
+            refOrIndex = item[$refId];
             if (operation === exports.OPERATION.DELETE) {
                 operation = exports.OPERATION.DELETE_BY_REFID;
             }
@@ -1605,7 +1610,7 @@
         let value;
         if ((operation & exports.OPERATION.DELETE) === exports.OPERATION.DELETE) {
             // Flag `refId` for garbage collection.
-            const previousRefId = $root.refIds.get(previousValue);
+            const previousRefId = previousValue?.[$refId];
             if (previousRefId !== undefined) {
                 $root.removeRef(previousRefId);
             }
@@ -1646,7 +1651,7 @@
             value = valueRef.clone(true);
             value[$childType] = Object.values(type)[0]; // cache childType for ArraySchema and MapSchema
             if (previousValue) {
-                let previousRefId = $root.refIds.get(previousValue);
+                let previousRefId = previousValue[$refId];
                 if (previousRefId !== undefined && refId !== previousRefId) {
                     //
                     // enqueue onRemove if structure has been replaced.
@@ -1657,7 +1662,7 @@
                         const [key, value] = iter.value;
                         // if value is a schema, remove its reference
                         if (typeof (value) === "object") {
-                            previousRefId = $root.refIds.get(value);
+                            previousRefId = value[$refId];
                             $root.removeRef(previousRefId);
                         }
                         allChanges.push({
@@ -1886,7 +1891,6 @@
         }
     }
 
-    var _a$4, _b$4;
     const DEFAULT_SORT = (a, b) => {
         const A = a.toString();
         const B = b.toString();
@@ -1898,8 +1902,15 @@
             return 0;
     };
     class ArraySchema {
-        static { this[_a$4] = encodeArray; }
-        static { this[_b$4] = decodeArray; }
+        [$changes];
+        [$refId];
+        [$childType];
+        items = [];
+        tmpItems = [];
+        deletedIndexes = {};
+        isMovingItems = false;
+        static [$encoder] = encodeArray;
+        static [$decoder] = decodeArray;
         /**
          * Determine if a property must be filtered.
          * - If returns false, the property is NOT going to be encoded.
@@ -1909,7 +1920,7 @@
          * - First, the encoder iterates over all "not owned" properties and encodes them.
          * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
          */
-        static [(_a$4 = $encoder, _b$4 = $decoder, $filter)](ref, index, view) {
+        static [$filter](ref, index, view) {
             return (!view ||
                 typeof (ref[$childType]) === "string" ||
                 view.isChangeTreeVisible(ref['tmpItems'][index]?.[$changes]));
@@ -1925,10 +1936,6 @@
             return new ArraySchema(...Array.from(iterable));
         }
         constructor(...items) {
-            this.items = [];
-            this.tmpItems = [];
-            this.deletedIndexes = {};
-            this.isMovingItems = false;
             Object.defineProperty(this, $childType, {
                 value: undefined,
                 enumerable: false,
@@ -2445,6 +2452,10 @@
         static get [Symbol.species]() {
             return ArraySchema;
         }
+        // WORKAROUND for compatibility
+        // - TypeScript 4 defines @@unscopables as a function
+        // - TypeScript 5 defines @@unscopables as an object
+        [Symbol.unscopables];
         /**
          * Returns an iterable of key, value pairs for every entry in the array
          */
@@ -2554,7 +2565,7 @@
             this.isMovingItems = false;
             return this;
         }
-        [($getByIndex)](index, isEncodeAll = false) {
+        [$getByIndex](index, isEncodeAll = false) {
             //
             // TODO: avoid unecessary `this.tmpItems` check during decoding.
             //
@@ -2609,10 +2620,16 @@
     }
     registerType("array", { constructor: ArraySchema });
 
-    var _a$3, _b$3;
     class MapSchema {
-        static { this[_a$3] = encodeKeyValueOperation; }
-        static { this[_b$3] = decodeKeyValueOperation; }
+        [$changes];
+        [$refId];
+        childType;
+        [$childType];
+        $items = new Map();
+        $indexes = new Map();
+        deletedItems = {};
+        static [$encoder] = encodeKeyValueOperation;
+        static [$decoder] = decodeKeyValueOperation;
         /**
          * Determine if a property must be filtered.
          * - If returns false, the property is NOT going to be encoded.
@@ -2622,7 +2639,7 @@
          * - First, the encoder iterates over all "not owned" properties and encodes them.
          * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
          */
-        static [(_a$3 = $encoder, _b$3 = $decoder, $filter)](ref, index, view) {
+        static [$filter](ref, index, view) {
             return (!view ||
                 typeof (ref[$childType]) === "string" ||
                 view.isChangeTreeVisible((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes]));
@@ -2631,9 +2648,6 @@
             return type['map'] !== undefined;
         }
         constructor(initialValues) {
-            this.$items = new Map();
-            this.$indexes = new Map();
-            this.deletedItems = {};
             const changeTree = new ChangeTree(this);
             changeTree.indexes = {};
             Object.defineProperty(this, $changes, {
@@ -2824,10 +2838,16 @@
     }
     registerType("map", { constructor: MapSchema });
 
-    var _a$2, _b$2;
     class CollectionSchema {
-        static { this[_a$2] = encodeKeyValueOperation; }
-        static { this[_b$2] = decodeKeyValueOperation; }
+        [$changes];
+        [$refId];
+        [$childType];
+        $items = new Map();
+        $indexes = new Map();
+        deletedItems = {};
+        $refId = 0;
+        static [$encoder] = encodeKeyValueOperation;
+        static [$decoder] = decodeKeyValueOperation;
         /**
          * Determine if a property must be filtered.
          * - If returns false, the property is NOT going to be encoded.
@@ -2837,7 +2857,7 @@
          * - First, the encoder iterates over all "not owned" properties and encodes them.
          * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
          */
-        static [(_a$2 = $encoder, _b$2 = $decoder, $filter)](ref, index, view) {
+        static [$filter](ref, index, view) {
             return (!view ||
                 typeof (ref[$childType]) === "string" ||
                 view.isChangeTreeVisible((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes]));
@@ -2846,10 +2866,6 @@
             return type['collection'] !== undefined;
         }
         constructor(initialValues) {
-            this.$items = new Map();
-            this.$indexes = new Map();
-            this.deletedItems = {};
-            this.$refId = 0;
             this[$changes] = new ChangeTree(this);
             this[$changes].indexes = {};
             if (initialValues) {
@@ -2988,10 +3004,16 @@
     }
     registerType("collection", { constructor: CollectionSchema, });
 
-    var _a$1, _b$1;
     class SetSchema {
-        static { this[_a$1] = encodeKeyValueOperation; }
-        static { this[_b$1] = decodeKeyValueOperation; }
+        [$changes];
+        [$refId];
+        [$childType];
+        $items = new Map();
+        $indexes = new Map();
+        deletedItems = {};
+        $refId = 0;
+        static [$encoder] = encodeKeyValueOperation;
+        static [$decoder] = decodeKeyValueOperation;
         /**
          * Determine if a property must be filtered.
          * - If returns false, the property is NOT going to be encoded.
@@ -3001,7 +3023,7 @@
          * - First, the encoder iterates over all "not owned" properties and encodes them.
          * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
          */
-        static [(_a$1 = $encoder, _b$1 = $decoder, $filter)](ref, index, view) {
+        static [$filter](ref, index, view) {
             return (!view ||
                 typeof (ref[$childType]) === "string" ||
                 view.visible.has((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes]));
@@ -3010,10 +3032,6 @@
             return type['set'] !== undefined;
         }
         constructor(initialValues) {
-            this.$items = new Map();
-            this.$indexes = new Map();
-            this.deletedItems = {};
-            this.$refId = 0;
             this[$changes] = new ChangeTree(this);
             this[$changes].indexes = {};
             if (initialValues) {
@@ -3512,7 +3530,10 @@
                         ? DEFAULT_VIEW_TAG
                         : value['view'];
                 }
-                fields[fieldName] = getNormalizedType(value);
+                // allow to define a field as not synced
+                if (value['sync'] !== false) {
+                    fields[fieldName] = getNormalizedType(value);
+                }
                 // If no explicit default provided, handle automatic instantiation for collection types
                 if (!Object.prototype.hasOwnProperty.call(value, 'default')) {
                     // TODO: remove Array.isArray() check. Use ['array'] !== undefined only.
@@ -3534,12 +3555,7 @@
                     }
                     else if (value['type'] !== undefined && Schema.is(value['type'])) {
                         // Direct Schema type: Type → new Type()
-                        if (!value['type'].prototype.initialize || value['type'].prototype.initialize.length === 0) {
-                            // only auto-initialize Schema instances if:
-                            // - they don't have an initialize method
-                            // - or initialize method doesn't accept any parameters
-                            defaultValues[fieldName] = new value['type']();
-                        }
+                        defaultValues[fieldName] = new value['type']();
                     }
                 }
                 else {
@@ -3549,12 +3565,7 @@
             else if (typeof (value) === "function") {
                 if (Schema.is(value)) {
                     // Direct Schema type: Type → new Type()
-                    if (!value.prototype.initialize || value.prototype.initialize.length === 0) {
-                        // only auto-initialize Schema instances if:
-                        // - they don't have an initialize method
-                        // - or initialize method doesn't accept any parameters
-                        defaultValues[fieldName] = new value();
-                    }
+                    defaultValues[fieldName] = new value();
                     fields[fieldName] = getNormalizedType(value);
                 }
                 else {
@@ -3581,32 +3592,13 @@
             }
             return defaults;
         };
-        const getParentProps = (props) => {
-            const fieldNames = Object.keys(fields);
-            const parentProps = {};
-            for (const key in props) {
-                if (!fieldNames.includes(key)) {
-                    parentProps[key] = props[key];
-                }
-            }
-            return parentProps;
-        };
         /** @codegen-ignore */
         const klass = Metadata.setFields(class extends inherits {
             constructor(...args) {
+                super(Object.assign({}, getDefaultValues(), args[0] || {}));
                 // call initialize method
                 if (methods.initialize && typeof methods.initialize === 'function') {
-                    super(Object.assign({}, getDefaultValues(), getParentProps(args[0] || {})));
-                    /**
-                     * only call initialize() in the current class, not the parent ones.
-                     * see "should not call initialize automatically when creating an instance of inherited Schema"
-                     */
-                    if (new.target === klass) {
-                        methods.initialize.apply(this, args);
-                    }
-                }
-                else {
-                    super(Object.assign({}, getDefaultValues(), args[0] || {}));
+                    methods.initialize.apply(this, args);
                 }
             }
         }, fields);
@@ -3643,7 +3635,7 @@
                 continue;
             }
             const changes = changeTree.indexedOperations;
-            dump.refs.push(`refId#${changeTree.refId}`);
+            dump.refs.push(`refId#${changeTree.ref[$refId]}`);
             for (const index in changes) {
                 const op = changes[index];
                 const opName = exports.OPERATION[op];
@@ -3657,13 +3649,14 @@
         return dump;
     }
 
-    var _a, _b;
     /**
      * Schema encoder / decoder
      */
     class Schema {
-        static { this[_a] = encodeSchemaOperation; }
-        static { this[_b] = decodeSchemaOperation; }
+        static [Symbol.metadata];
+        static [$encoder] = encodeSchemaOperation;
+        static [$decoder] = decodeSchemaOperation;
+        [$refId];
         /**
          * Assign the property descriptors required to track changes on this instance.
          * @param instance
@@ -3682,7 +3675,7 @@
         /**
          * Track property changes
          */
-        static [(_a = $encoder, _b = $decoder, $track)](changeTree, index, operation = exports.OPERATION.ADD) {
+        static [$track](changeTree, index, operation = exports.OPERATION.ADD) {
             changeTree.change(index, operation);
         }
         /**
@@ -3729,10 +3722,74 @@
                 Object.assign(this, arg);
             }
         }
+        /**
+         * Assign properties to the instance.
+         * @param props Properties to assign to the instance
+         * @returns
+         */
         assign(props) {
             Object.assign(this, props);
             return this;
         }
+        /**
+         * Restore the instance from JSON data.
+         * @param jsonData JSON data to restore the instance from
+         * @returns
+         */
+        restore(jsonData) {
+            const metadata = this.constructor[Symbol.metadata];
+            for (const fieldIndex in metadata) {
+                const field = metadata[fieldIndex];
+                const fieldName = field.name;
+                const fieldType = field.type;
+                const value = jsonData[fieldName];
+                if (value === undefined || value === null) {
+                    continue;
+                }
+                if (typeof fieldType === "string") {
+                    // Primitive type: assign directly
+                    this[fieldName] = value;
+                }
+                else if (Schema.is(fieldType)) {
+                    // Schema type: create instance and restore
+                    const instance = new fieldType();
+                    instance.restore(value);
+                    this[fieldName] = instance;
+                }
+                else if (typeof fieldType === "object") {
+                    // Collection types: { map: ... }, { array: ... }, etc.
+                    const collectionType = Object.keys(fieldType)[0];
+                    const childType = fieldType[collectionType];
+                    if (collectionType === "map") {
+                        const mapSchema = this[fieldName];
+                        for (const key in value) {
+                            if (Schema.is(childType)) {
+                                const childInstance = new childType();
+                                childInstance.restore(value[key]);
+                                mapSchema.set(key, childInstance);
+                            }
+                            else {
+                                mapSchema.set(key, value[key]);
+                            }
+                        }
+                    }
+                    else if (collectionType === "array") {
+                        const arraySchema = this[fieldName];
+                        for (let i = 0; i < value.length; i++) {
+                            if (Schema.is(childType)) {
+                                const childInstance = new childType();
+                                childInstance.restore(value[i]);
+                                arraySchema.push(childInstance);
+                            }
+                            else {
+                                arraySchema.push(value[i]);
+                            }
+                        }
+                    }
+                }
+            }
+            return this;
+        }
         /**
          * (Server-side): Flag a property to be encoded for the next patch.
          * @param instance Schema instance
@@ -3805,7 +3862,7 @@
         static debugRefIds(ref, showContents = false, level = 0, decoder, keyPrefix = "") {
             const contents = (showContents) ? ` - ${JSON.stringify(ref.toJSON())}` : "";
             const changeTree = ref[$changes];
-            const refId = (decoder) ? decoder.root.refIds.get(ref) : changeTree.refId;
+            const refId = ref[$refId];
             const root = (decoder) ? decoder.root : changeTree.root;
             // log reference count if > 1
             const refCount = (root?.refCount?.[refId] > 1)
@@ -3828,7 +3885,7 @@
             let current = ref[$changes].root[changeSet].next;
             while (current) {
                 if (current.changeTree) {
-                    encodeOrder.push(current.changeTree.refId);
+                    encodeOrder.push(current.changeTree.ref[$refId]);
                 }
                 current = current.next;
             }
@@ -3849,7 +3906,7 @@
             const changeTree = instance[$changes];
             const changeSet = (isEncodeAll) ? changeTree.allChanges : changeTree.changes;
             const changeSetName = (isEncodeAll) ? "allChanges" : "changes";
-            let output = `${instance.constructor.name} (${changeTree.refId}) -> .${changeSetName}:\n`;
+            let output = `${instance.constructor.name} (${instance[$refId]}) -> .${changeSetName}:\n`;
             function dumpChangeSet(changeSet) {
                 changeSet.operations
                     .filter(op => op)
@@ -3863,14 +3920,14 @@
             if (!isEncodeAll &&
                 changeTree.filteredChanges &&
                 (changeTree.filteredChanges.operations).filter(op => op).length > 0) {
-                output += `${instance.constructor.name} (${changeTree.refId}) -> .filteredChanges:\n`;
+                output += `${instance.constructor.name} (${instance[$refId]}) -> .filteredChanges:\n`;
                 dumpChangeSet(changeTree.filteredChanges);
             }
             // display filtered changes
             if (isEncodeAll &&
                 changeTree.allFilteredChanges &&
                 (changeTree.allFilteredChanges.operations).filter(op => op).length > 0) {
-                output += `${instance.constructor.name} (${changeTree.refId}) -> .allFilteredChanges:\n`;
+                output += `${instance.constructor.name} (${instance[$refId]}) -> .allFilteredChanges:\n`;
                 dumpChangeSet(changeTree.allFilteredChanges);
             }
             return output;
@@ -3905,13 +3962,13 @@
                     }
                 }
                 if (includeChangeTree) {
-                    instanceRefIds.push(changeTree.refId);
+                    instanceRefIds.push(changeTree.ref[$refId]);
                     totalOperations += Object.keys(changes).length;
                     changeTrees.set(changeTree, parentChangeTrees.reverse());
                 }
             }
             output += "---\n";
-            output += `root refId: ${rootChangeTree.refId}\n`;
+            output += `root refId: ${rootChangeTree.ref[$refId]}\n`;
             output += `Total instances: ${instanceRefIds.length} (refIds: ${instanceRefIds.join(", ")})\n`;
             output += `Total changes: ${totalOperations}\n`;
             output += "---\n";
@@ -3920,7 +3977,7 @@
             for (const [changeTree, parentChangeTrees] of changeTrees.entries()) {
                 parentChangeTrees.forEach((parentChangeTree, level) => {
                     if (!visitedParents.has(parentChangeTree)) {
-                        output += `${getIndent(level)}${parentChangeTree.ref.constructor.name} (refId: ${parentChangeTree.refId})\n`;
+                        output += `${getIndent(level)}${parentChangeTree.ref.constructor.name} (refId: ${parentChangeTree.ref[$refId]})\n`;
                         visitedParents.add(parentChangeTree);
                     }
                 });
@@ -3928,7 +3985,7 @@
                 const level = parentChangeTrees.length;
                 const indent = getIndent(level);
                 const parentIndex = (level > 0) ? `(${changeTree.parentIndex}) ` : "";
-                output += `${indent}${parentIndex}${changeTree.ref.constructor.name} (refId: ${changeTree.refId}) - changes: ${Object.keys(changes).length}\n`;
+                output += `${indent}${parentIndex}${changeTree.ref.constructor.name} (refId: ${changeTree.ref[$refId]}) - changes: ${Object.keys(changes).length}\n`;
                 for (const index in changes) {
                     const operation = changes[index];
                     output += `${getIndent(level + 1)}${exports.OPERATION[operation]}: ${index}\n`;
@@ -3938,61 +3995,35 @@
         }
     }
 
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-    function __decorate(decorators, target, key, desc) {
-        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-        return c > 3 && r && Object.defineProperty(target, key, r), r;
-    }
-
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-        var e = new Error(message);
-        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
     class Root {
+        types;
+        nextUniqueId = 0;
+        refCount = {};
+        changeTrees = {};
+        // all changes
+        allChanges = createChangeTreeList();
+        allFilteredChanges = createChangeTreeList(); // TODO: do not initialize it if filters are not used
+        // pending changes to be encoded
+        changes = createChangeTreeList();
+        filteredChanges = createChangeTreeList(); // TODO: do not initialize it if filters are not used
         constructor(types) {
             this.types = types;
-            this.nextUniqueId = 0;
-            this.refCount = {};
-            this.changeTrees = {};
-            // all changes
-            this.allChanges = createChangeTreeList();
-            this.allFilteredChanges = createChangeTreeList(); // TODO: do not initialize it if filters are not used
-            // pending changes to be encoded
-            this.changes = createChangeTreeList();
-            this.filteredChanges = createChangeTreeList(); // TODO: do not initialize it if filters are not used
         }
         getNextUniqueId() {
             return this.nextUniqueId++;
         }
         add(changeTree) {
-            // Assign unique `refId` to changeTree if it doesn't have one yet.
-            if (changeTree.refId === undefined) {
-                changeTree.refId = this.getNextUniqueId();
+            const ref = changeTree.ref;
+            // Assign unique `refId` to ref if it doesn't have one yet.
+            if (ref[$refId] === undefined) {
+                ref[$refId] = this.getNextUniqueId();
             }
-            const isNewChangeTree = (this.changeTrees[changeTree.refId] === undefined);
+            const refId = ref[$refId];
+            const isNewChangeTree = (this.changeTrees[refId] === undefined);
             if (isNewChangeTree) {
-                this.changeTrees[changeTree.refId] = changeTree;
+                this.changeTrees[refId] = changeTree;
             }
-            const previousRefCount = this.refCount[changeTree.refId];
+            const previousRefCount = this.refCount[refId];
             if (previousRefCount === 0) {
                 //
                 // When a ChangeTree is re-added, it means that it was previously removed.
@@ -4005,30 +4036,31 @@
                     setOperationAtIndex(changeTree.changes, len);
                 }
             }
-            this.refCount[changeTree.refId] = (previousRefCount || 0) + 1;
-            // console.log("ADD", { refId: changeTree.refId, ref: changeTree.ref.constructor.name, refCount: this.refCount[changeTree.refId], isNewChangeTree });
+            this.refCount[refId] = (previousRefCount || 0) + 1;
+            // console.log("ADD", { refId, ref: ref.constructor.name, refCount: this.refCount[refId], isNewChangeTree });
             return isNewChangeTree;
         }
         remove(changeTree) {
-            const refCount = (this.refCount[changeTree.refId]) - 1;
-            // console.log("REMOVE", { refId: changeTree.refId, ref: changeTree.ref.constructor.name, refCount, needRemove: refCount <= 0 });
+            const refId = changeTree.ref[$refId];
+            const refCount = (this.refCount[refId]) - 1;
+            // console.log("REMOVE", { refId, ref: changeTree.ref.constructor.name, refCount, needRemove: refCount <= 0 });
             if (refCount <= 0) {
                 //
                 // Only remove "root" reference if it's the last reference
                 //
                 changeTree.root = undefined;
-                delete this.changeTrees[changeTree.refId];
+                delete this.changeTrees[refId];
                 this.removeChangeFromChangeSet("allChanges", changeTree);
                 this.removeChangeFromChangeSet("changes", changeTree);
                 if (changeTree.filteredChanges) {
                     this.removeChangeFromChangeSet("allFilteredChanges", changeTree);
                     this.removeChangeFromChangeSet("filteredChanges", changeTree);
                 }
-                this.refCount[changeTree.refId] = 0;
+                this.refCount[refId] = 0;
                 changeTree.forEachChild((child, _) => {
                     if (child.removeParent(changeTree.ref)) {
                         if ((child.parentChain === undefined || // no parent, remove it
-                            (child.parentChain && this.refCount[child.refId] > 0) // parent is still in use, but has more than one reference, remove it
+                            (child.parentChain && this.refCount[child.ref[$refId]] > 0) // parent is still in use, but has more than one reference, remove it
                         )) {
                             this.remove(child);
                         }
@@ -4040,7 +4072,7 @@
                 });
             }
             else {
-                this.refCount[changeTree.refId] = refCount;
+                this.refCount[refId] = refCount;
                 //
                 // When losing a reference to an instance, it is best to move the
                 // ChangeTree next to its parent in the encoding queue.
@@ -4190,10 +4222,19 @@
         }
     }
 
+    function concatBytes(a, b) {
+        const result = new Uint8Array(a.length + b.length);
+        result.set(a, 0);
+        result.set(b, a.length);
+        return result;
+    }
     class Encoder {
-        static { this.BUFFER_SIZE = (typeof (Buffer) !== "undefined") && Buffer.poolSize || 8 * 1024; } // 8KB
+        static BUFFER_SIZE = 8 * 1024; // 8KB
+        sharedBuffer = new Uint8Array(Encoder.BUFFER_SIZE);
+        context;
+        state;
+        root;
         constructor(state) {
-            this.sharedBuffer = Buffer.allocUnsafe(Encoder.BUFFER_SIZE);
             //
             // Use .cache() here to avoid re-creating a new context for every new room instance.
             //
@@ -4221,7 +4262,7 @@
                 const changeTree = current.changeTree;
                 if (hasView) {
                     if (!view.isChangeTreeVisible(changeTree)) {
-                        // console.log("MARK AS INVISIBLE:", { ref: changeTree.ref.constructor.name, refId: changeTree.refId, raw: changeTree.ref.toJSON() });
+                        // console.log("MARK AS INVISIBLE:", { ref: changeTree.ref.constructor.name, refId: changeTree.ref[$refId], raw: changeTree.ref.toJSON() });
                         view.invisible.add(changeTree);
                         continue; // skip this change tree
                     }
@@ -4242,7 +4283,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;
-                    encode.number(buffer, changeTree.refId, it);
+                    encode.number(buffer, ref[$refId], it);
                 }
                 for (let j = 0; j < numChanges; j++) {
                     const fieldIndex = changeSet.operations[j];
@@ -4271,10 +4312,9 @@
                 }
             }
             if (it.offset > buffer.byteLength) {
-                // we can assume that n + 1 poolSize will suffice given that we are likely done with encoding at this point
-                // multiples of poolSize are faster to allocate than arbitrary sizes
-                // if we are on an older platform that doesn't implement pooling use 8kb as poolSize (that's the default for node)
-                const newSize = Math.ceil(it.offset / (Buffer.poolSize ?? 8 * 1024)) * (Buffer.poolSize ?? 8 * 1024);
+                // we can assume that n + 1 BUFFER_SIZE will suffice given that we are likely done with encoding at this point
+                // multiples of BUFFER_SIZE are faster to allocate than arbitrary sizes
+                const newSize = Math.ceil(it.offset / Encoder.BUFFER_SIZE) * Encoder.BUFFER_SIZE;
                 console.warn(`@colyseus/schema buffer overflow. Encoded state is higher than default BUFFER_SIZE. Use the following to increase default BUFFER_SIZE:
 
     import { Encoder } from "@colyseus/schema";
@@ -4284,7 +4324,9 @@
                 // resize buffer and re-encode (TODO: can we avoid re-encoding here?)
                 // -> No we probably can't unless we catch the need for resize before encoding which is likely more computationally expensive than resizing on demand
                 //
-                buffer = Buffer.alloc(newSize, buffer); // fill with buffer here to memcpy previous encoding steps beyond the initialOffset
+                const newBuffer = new Uint8Array(newSize);
+                newBuffer.set(buffer); // copy previous encoding steps beyond the initialOffset
+                buffer = newBuffer;
                 // assign resized buffer to local sharedBuffer
                 if (buffer === this.sharedBuffer) {
                     this.sharedBuffer = buffer;
@@ -4302,10 +4344,7 @@
             const viewOffset = it.offset;
             // try to encode "filtered" changes
             this.encode(it, view, bytes, "allFilteredChanges", true, viewOffset);
-            return Buffer.concat([
-                bytes.subarray(0, sharedOffset),
-                bytes.subarray(viewOffset, it.offset)
-            ]);
+            return concatBytes(bytes.subarray(0, sharedOffset), bytes.subarray(viewOffset, it.offset));
         }
         encodeView(view, sharedOffset, it, bytes = this.sharedBuffer) {
             const viewOffset = it.offset;
@@ -4329,7 +4368,7 @@
                 const encoder = ctor[$encoder];
                 const metadata = ctor[Symbol.metadata];
                 bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
-                encode.number(bytes, changeTree.refId, it);
+                encode.number(bytes, ref[$refId], it);
                 for (let i = 0, numChanges = keys.length; i < numChanges; i++) {
                     const index = Number(keys[i]);
                     // workaround when using view.add() on item that has been deleted from state (see test "adding to view item that has been removed from state")
@@ -4348,10 +4387,7 @@
             view.changes.clear();
             // try to encode "filtered" changes
             this.encode(it, view, bytes, "filteredChanges", false, viewOffset);
-            return Buffer.concat([
-                bytes.subarray(0, sharedOffset),
-                bytes.subarray(viewOffset, it.offset)
-            ]);
+            return concatBytes(bytes.subarray(0, sharedOffset), bytes.subarray(viewOffset, it.offset));
         }
         discardChanges() {
             // discard shared changes
@@ -4407,25 +4443,22 @@
         }
     }
     class ReferenceTracker {
-        constructor() {
-            //
-            // Relation of refId => Schema structure
-            // For direct access of structures during decoding time.
-            //
-            this.refs = new Map();
-            this.refIds = new WeakMap();
-            this.refCount = {};
-            this.deletedRefs = new Set();
-            this.callbacks = {};
-            this.nextUniqueId = 0;
-        }
+        //
+        // Relation of refId => Schema structure
+        // For direct access of structures during decoding time.
+        //
+        refs = new Map();
+        refCount = {};
+        deletedRefs = new Set();
+        callbacks = {};
+        nextUniqueId = 0;
         getNextUniqueId() {
             return this.nextUniqueId++;
         }
         // for decoding
         addRef(refId, ref, incrementCount = true) {
             this.refs.set(refId, ref);
-            this.refIds.set(ref, refId);
+            ref[$refId] = refId;
             if (incrementCount) {
                 this.refCount[refId] = (this.refCount[refId] || 0) + 1;
             }
@@ -4482,9 +4515,12 @@
                     const metadata = ref.constructor[Symbol.metadata];
                     for (const index in metadata) {
                         const field = metadata[index].name;
-                        const childRefId = typeof (ref[field]) === "object" && this.refIds.get(ref[field]);
-                        if (childRefId && !this.deletedRefs.has(childRefId)) {
-                            this.removeRef(childRefId);
+                        const child = ref[field];
+                        if (typeof (child) === "object" && child) {
+                            const childRefId = child[$refId];
+                            if (childRefId !== undefined && !this.deletedRefs.has(childRefId)) {
+                                this.removeRef(childRefId);
+                            }
                         }
                     }
                 }
@@ -4492,8 +4528,8 @@
                     if (typeof (ref[$childType]) === "function") {
                         Array.from(ref.values())
                             .forEach((child) => {
-                            const childRefId = this.refIds.get(child);
-                            if (!this.deletedRefs.has(childRefId)) {
+                            const childRefId = child[$refId];
+                            if (childRefId !== undefined && !this.deletedRefs.has(childRefId)) {
                                 this.removeRef(childRefId);
                             }
                         });
@@ -4531,8 +4567,12 @@
     }
 
     class Decoder {
+        context;
+        state;
+        root;
+        currentRefId = 0;
+        triggerChanges;
         constructor(root, context) {
-            this.currentRefId = 0;
             this.setState(root);
             this.context = context || new TypeContext(root.constructor);
             // console.log(">>>>>>>>>>>>>>>> Decoder types");
@@ -4621,7 +4661,7 @@
         }
         removeChildRefs(ref, allChanges) {
             const needRemoveRef = typeof (ref[$childType]) !== "string";
-            const refId = this.root.refIds.get(ref);
+            const refId = ref[$refId];
             ref.forEach((value, key) => {
                 allChanges.push({
                     ref: ref,
@@ -4632,7 +4672,7 @@
                     previousValue: value
                 });
                 if (needRemoveRef) {
-                    this.root.removeRef(this.root.refIds.get(value));
+                    this.root.removeRef(value[$refId]);
                 }
             });
         }
@@ -4641,217 +4681,182 @@
     /**
      * Reflection
      */
-    class ReflectionField extends Schema {
-    }
-    __decorate([
-        type("string")
-    ], ReflectionField.prototype, "name", void 0);
-    __decorate([
-        type("string")
-    ], ReflectionField.prototype, "type", void 0);
-    __decorate([
-        type("number")
-    ], ReflectionField.prototype, "referencedType", void 0);
-    class ReflectionType extends Schema {
-        constructor() {
-            super(...arguments);
-            this.fields = new ArraySchema();
-        }
-    }
-    __decorate([
-        type("number")
-    ], ReflectionType.prototype, "id", void 0);
-    __decorate([
-        type("number")
-    ], ReflectionType.prototype, "extendsId", void 0);
-    __decorate([
-        type([ReflectionField])
-    ], ReflectionType.prototype, "fields", void 0);
-    class Reflection extends Schema {
-        constructor() {
-            super(...arguments);
-            this.types = new ArraySchema();
-        }
-        /**
-         * Encodes the TypeContext of an Encoder into a buffer.
-         *
-         * @param encoder Encoder instance
-         * @param it
-         * @returns
-         */
-        static encode(encoder, it = { offset: 0 }) {
-            const context = encoder.context;
-            const reflection = new Reflection();
-            const reflectionEncoder = new Encoder(reflection);
-            // rootType is usually the first schema passed to the Encoder
-            // (unless it inherits from another schema)
-            const rootType = context.schemas.get(encoder.state.constructor);
-            if (rootType > 0) {
-                reflection.rootType = rootType;
-            }
-            const includedTypeIds = new Set();
-            const pendingReflectionTypes = {};
-            // add type to reflection in a way that respects inheritance
-            // (parent types should be added before their children)
-            const addType = (type) => {
-                if (type.extendsId === undefined || includedTypeIds.has(type.extendsId)) {
-                    includedTypeIds.add(type.id);
-                    reflection.types.push(type);
-                    const deps = pendingReflectionTypes[type.id];
-                    if (deps !== undefined) {
-                        delete pendingReflectionTypes[type.id];
-                        deps.forEach((childType) => addType(childType));
-                    }
+    const ReflectionField = schema({
+        name: "string",
+        type: "string",
+        referencedType: "number",
+    });
+    const ReflectionType = schema({
+        id: "number",
+        extendsId: "number",
+        fields: [ReflectionField],
+    });
+    const Reflection = schema({
+        types: [ReflectionType],
+        rootType: "number",
+    });
+    Reflection.encode = function (encoder, it = { offset: 0 }) {
+        const context = encoder.context;
+        const reflection = new Reflection();
+        const reflectionEncoder = new Encoder(reflection);
+        // rootType is usually the first schema passed to the Encoder
+        // (unless it inherits from another schema)
+        const rootType = context.schemas.get(encoder.state.constructor);
+        if (rootType > 0) {
+            reflection.rootType = rootType;
+        }
+        const includedTypeIds = new Set();
+        const pendingReflectionTypes = {};
+        // add type to reflection in a way that respects inheritance
+        // (parent types should be added before their children)
+        const addType = (type) => {
+            if (type.extendsId === undefined || includedTypeIds.has(type.extendsId)) {
+                includedTypeIds.add(type.id);
+                reflection.types.push(type);
+                const deps = pendingReflectionTypes[type.id];
+                if (deps !== undefined) {
+                    delete pendingReflectionTypes[type.id];
+                    deps.forEach((childType) => addType(childType));
                 }
-                else {
-                    if (pendingReflectionTypes[type.extendsId] === undefined) {
-                        pendingReflectionTypes[type.extendsId] = [];
-                    }
-                    pendingReflectionTypes[type.extendsId].push(type);
-                }
-            };
-            context.schemas.forEach((typeid, klass) => {
-                const type = new ReflectionType();
-                type.id = Number(typeid);
-                // support inheritance
-                const inheritFrom = Object.getPrototypeOf(klass);
-                if (inheritFrom !== Schema) {
-                    type.extendsId = context.schemas.get(inheritFrom);
+            }
+            else {
+                if (pendingReflectionTypes[type.extendsId] === undefined) {
+                    pendingReflectionTypes[type.extendsId] = [];
                 }
-                const metadata = klass[Symbol.metadata];
-                //
-                // FIXME: this is a workaround for inherited types without additional fields
-                // if metadata is the same reference as the parent class - it means the class has no own metadata
-                //
-                if (metadata !== inheritFrom[Symbol.metadata]) {
-                    for (const fieldIndex in metadata) {
-                        const index = Number(fieldIndex);
-                        const fieldName = metadata[index].name;
-                        // skip fields from parent classes
-                        if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
-                            continue;
-                        }
-                        const reflectionField = new ReflectionField();
-                        reflectionField.name = fieldName;
-                        let fieldType;
-                        const field = metadata[index];
-                        if (typeof (field.type) === "string") {
-                            fieldType = field.type;
+                pendingReflectionTypes[type.extendsId].push(type);
+            }
+        };
+        context.schemas.forEach((typeid, klass) => {
+            const type = new ReflectionType();
+            type.id = Number(typeid);
+            // support inheritance
+            const inheritFrom = Object.getPrototypeOf(klass);
+            if (inheritFrom !== Schema) {
+                type.extendsId = context.schemas.get(inheritFrom);
+            }
+            const metadata = klass[Symbol.metadata];
+            //
+            // FIXME: this is a workaround for inherited types without additional fields
+            // if metadata is the same reference as the parent class - it means the class has no own metadata
+            //
+            if (metadata !== inheritFrom[Symbol.metadata]) {
+                for (const fieldIndex in metadata) {
+                    const index = Number(fieldIndex);
+                    const fieldName = metadata[index].name;
+                    // skip fields from parent classes
+                    if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
+                        continue;
+                    }
+                    const reflectionField = new ReflectionField();
+                    reflectionField.name = fieldName;
+                    let fieldType;
+                    const field = metadata[index];
+                    if (typeof (field.type) === "string") {
+                        fieldType = field.type;
+                    }
+                    else {
+                        let childTypeSchema;
+                        //
+                        // TODO: refactor below.
+                        //
+                        if (Schema.is(field.type)) {
+                            fieldType = "ref";
+                            childTypeSchema = field.type;
                         }
                         else {
-                            let childTypeSchema;
-                            //
-                            // TODO: refactor below.
-                            //
-                            if (Schema.is(field.type)) {
-                                fieldType = "ref";
-                                childTypeSchema = field.type;
+                            fieldType = Object.keys(field.type)[0];
+                            if (typeof (field.type[fieldType]) === "string") {
+                                fieldType += ":" + field.type[fieldType]; // array:string
                             }
                             else {
-                                fieldType = Object.keys(field.type)[0];
-                                if (typeof (field.type[fieldType]) === "string") {
-                                    fieldType += ":" + field.type[fieldType]; // array:string
-                                }
-                                else {
-                                    childTypeSchema = field.type[fieldType];
-                                }
+                                childTypeSchema = field.type[fieldType];
                             }
-                            reflectionField.referencedType = (childTypeSchema)
-                                ? context.getTypeId(childTypeSchema)
-                                : -1;
                         }
-                        reflectionField.type = fieldType;
-                        type.fields.push(reflectionField);
+                        reflectionField.referencedType = (childTypeSchema)
+                            ? context.getTypeId(childTypeSchema)
+                            : -1;
                     }
+                    reflectionField.type = fieldType;
+                    type.fields.push(reflectionField);
                 }
-                addType(type);
-            });
-            // in case there are types that were not added due to inheritance
-            for (const typeid in pendingReflectionTypes) {
-                pendingReflectionTypes[typeid].forEach((type) => reflection.types.push(type));
             }
-            const buf = reflectionEncoder.encodeAll(it);
-            return buf.slice(0, it.offset);
-            // return Buffer.from(buf, 0, it.offset);
+            addType(type);
+        });
+        // in case there are types that were not added due to inheritance
+        for (const typeid in pendingReflectionTypes) {
+            pendingReflectionTypes[typeid].forEach((type) => reflection.types.push(type));
         }
-        /**
-         * Decodes the TypeContext from a buffer into a Decoder instance.
-         *
-         * @param bytes Reflection.encode() output
-         * @param it
-         * @returns Decoder instance
-         */
-        static decode(bytes, it) {
-            const reflection = new Reflection();
-            const reflectionDecoder = new Decoder(reflection);
-            reflectionDecoder.decode(bytes, it);
-            const typeContext = new TypeContext();
-            // 1st pass, initialize metadata + inheritance
-            reflection.types.forEach((reflectionType) => {
-                const parentClass = typeContext.get(reflectionType.extendsId) ?? Schema;
-                const schema = class _ extends parentClass {
-                };
-                // register for inheritance support
-                TypeContext.register(schema);
-                // // for inheritance support
-                // Metadata.initialize(schema);
-                typeContext.add(schema, reflectionType.id);
-            }, {});
-            // define fields
-            const addFields = (metadata, reflectionType, parentFieldIndex) => {
-                reflectionType.fields.forEach((field, i) => {
-                    const fieldIndex = parentFieldIndex + i;
-                    if (field.referencedType !== undefined) {
-                        let fieldType = field.type;
-                        let refType = typeContext.get(field.referencedType);
-                        // map or array of primitive type (-1)
-                        if (!refType) {
-                            const typeInfo = field.type.split(":");
-                            fieldType = typeInfo[0];
-                            refType = typeInfo[1]; // string
-                        }
-                        if (fieldType === "ref") {
-                            Metadata.addField(metadata, fieldIndex, field.name, refType);
-                        }
-                        else {
-                            Metadata.addField(metadata, fieldIndex, field.name, { [fieldType]: refType });
-                        }
+        const buf = reflectionEncoder.encodeAll(it);
+        return buf.slice(0, it.offset);
+    };
+    Reflection.decode = function (bytes, it) {
+        const reflection = new Reflection();
+        const reflectionDecoder = new Decoder(reflection);
+        reflectionDecoder.decode(bytes, it);
+        const typeContext = new TypeContext();
+        // 1st pass, initialize metadata + inheritance
+        reflection.types.forEach((reflectionType) => {
+            const parentClass = typeContext.get(reflectionType.extendsId) ?? Schema;
+            const schema = class _ extends parentClass {
+            };
+            // register for inheritance support
+            TypeContext.register(schema);
+            typeContext.add(schema, reflectionType.id);
+        }, {});
+        // define fields
+        const addFields = (metadata, reflectionType, parentFieldIndex) => {
+            reflectionType.fields.forEach((field, i) => {
+                const fieldIndex = parentFieldIndex + i;
+                if (field.referencedType !== undefined) {
+                    let fieldType = field.type;
+                    let refType = typeContext.get(field.referencedType);
+                    // map or array of primitive type (-1)
+                    if (!refType) {
+                        const typeInfo = field.type.split(":");
+                        fieldType = typeInfo[0];
+                        refType = typeInfo[1]; // string
+                    }
+                    if (fieldType === "ref") {
+                        Metadata.addField(metadata, fieldIndex, field.name, refType);
                     }
                     else {
-                        Metadata.addField(metadata, fieldIndex, field.name, field.type);
+                        Metadata.addField(metadata, fieldIndex, field.name, { [fieldType]: refType });
                     }
-                });
-            };
-            // 2nd pass, set fields
-            reflection.types.forEach((reflectionType) => {
-                const schema = typeContext.get(reflectionType.id);
-                // for inheritance support
-                const metadata = Metadata.initialize(schema);
-                const inheritedTypes = [];
-                let parentType = reflectionType;
-                do {
-                    inheritedTypes.push(parentType);
-                    parentType = reflection.types.find((t) => t.id === parentType.extendsId);
-                } while (parentType);
-                let parentFieldIndex = 0;
-                inheritedTypes.reverse().forEach((reflectionType) => {
-                    // add fields from all inherited classes
-                    // TODO: refactor this to avoid adding fields from parent classes
-                    addFields(metadata, reflectionType, parentFieldIndex);
-                    parentFieldIndex += reflectionType.fields.length;
-                });
+                }
+                else {
+                    Metadata.addField(metadata, fieldIndex, field.name, field.type);
+                }
             });
-            const state = new (typeContext.get(reflection.rootType || 0))();
-            return new Decoder(state, typeContext);
-        }
-    }
-    __decorate([
-        type([ReflectionType])
-    ], Reflection.prototype, "types", void 0);
-    __decorate([
-        type("number")
-    ], Reflection.prototype, "rootType", void 0);
+        };
+        // 2nd pass, set fields
+        reflection.types.forEach((reflectionType) => {
+            const schema = typeContext.get(reflectionType.id);
+            // for inheritance support
+            const metadata = Metadata.initialize(schema);
+            const inheritedTypes = [];
+            let parentType = reflectionType;
+            do {
+                inheritedTypes.push(parentType);
+                parentType = reflection.types.find((t) => t.id === parentType.extendsId);
+            } while (parentType);
+            let parentFieldIndex = 0;
+            inheritedTypes.reverse().forEach((reflectionType) => {
+                // add fields from all inherited classes
+                // TODO: refactor this to avoid adding fields from parent classes
+                addFields(metadata, reflectionType, parentFieldIndex);
+                parentFieldIndex += reflectionType.fields.length;
+            });
+        });
+        const state = new (typeContext.get(reflection.rootType || 0))();
+        return new Decoder(state, typeContext);
+    };
 
+    /**
+     * Legacy callback system
+     *
+     * @param decoder
+     * @returns
+     */
     function getDecoderStateCallbacks(decoder) {
         const $root = decoder.root;
         const callbacks = $root.callbacks;
@@ -4872,7 +4877,7 @@
                 //
                 if ((change.op & exports.OPERATION.DELETE) === exports.OPERATION.DELETE &&
                     change.previousValue instanceof Schema) {
-                    const deleteCallbacks = callbacks[$root.refIds.get(change.previousValue)]?.[exports.OPERATION.DELETE];
+                    const deleteCallbacks = callbacks[change.previousValue[$refId]]?.[exports.OPERATION.DELETE];
                     for (let i = deleteCallbacks?.length - 1; i >= 0; i--) {
                         deleteCallbacks[i]();
                     }
@@ -4961,7 +4966,7 @@
                     ) {
                         callback(context.instance[prop], undefined);
                     }
-                    return $root.addCallback($root.refIds.get(ref), prop, callback);
+                    return $root.addCallback(ref[$refId], prop, callback);
                 };
                 /**
                  * Schema instances
@@ -4981,7 +4986,7 @@
                         }
                     },
                     onChange: function onChange(callback) {
-                        return $root.addCallback($root.refIds.get(context.instance), exports.OPERATION.REPLACE, callback);
+                        return $root.addCallback(context.instance[$refId], exports.OPERATION.REPLACE, callback);
                     },
                     //
                     // TODO: refactor `bindTo()` implementation.
@@ -4991,7 +4996,7 @@
                         if (!properties) {
                             properties = Object.keys(metadata).map((index) => metadata[index].name);
                         }
-                        return $root.addCallback($root.refIds.get(context.instance), exports.OPERATION.REPLACE, () => {
+                        return $root.addCallback(context.instance[$refId], exports.OPERATION.REPLACE, () => {
                             properties.forEach((prop) => targetObject[prop] = context.instance[prop]);
                         });
                     }
@@ -5010,13 +5015,13 @@
                                     unbind?.();
                                 }, false);
                                 // has existing value
-                                if ($root.refIds.get(instance) !== undefined) {
+                                if (instance?.[$refId] !== undefined) {
                                     callback(instance, true);
                                 }
                             });
                             return getProxy(metadataField.type, {
                                 // make sure refId is available, otherwise need to wait for the instance to be available.
-                                instance: ($root.refIds.get(instance) && instance),
+                                instance: (instance?.[$refId] !== undefined && instance),
                                 parentInstance: context.instance,
                                 onInstanceAvailable,
                             });
@@ -5040,7 +5045,7 @@
                     if (immediate) {
                         ref.forEach((v, k) => callback(v, k));
                     }
-                    return $root.addCallback($root.refIds.get(ref), exports.OPERATION.ADD, (value, key) => {
+                    return $root.addCallback(ref[$refId], exports.OPERATION.ADD, (value, key) => {
                         onAddCalls.set(callback, true);
                         currentOnAddCallback = callback;
                         callback(value, key);
@@ -5049,10 +5054,10 @@
                     });
                 };
                 const onRemove = function (ref, callback) {
-                    return $root.addCallback($root.refIds.get(ref), exports.OPERATION.DELETE, callback);
+                    return $root.addCallback(ref[$refId], exports.OPERATION.DELETE, callback);
                 };
                 const onChange = function (ref, callback) {
-                    return $root.addCallback($root.refIds.get(ref), exports.OPERATION.REPLACE, callback);
+                    return $root.addCallback(ref[$refId], exports.OPERATION.REPLACE, callback);
                 };
                 return new Proxy({
                     onAdd: function (callback, immediate = true) {
@@ -5121,22 +5126,360 @@
         decoder.triggerChanges = callback;
     }
 
+    /**
+     * State Callbacks handler
+     *
+     * Usage:
+     * ```ts
+     * const $ = Callbacks.get(decoder);
+     *
+     * // Listen to property changes
+     * $.listen("currentTurn", (currentValue, previousValue) => { ... });
+     *
+     * // Listen to collection additions
+     * $.onAdd("entities", (sessionId, entity) => {
+     *     // Nested property listening
+     *     $.listen(entity, "hp", (currentHp, previousHp) => { ... });
+     * });
+     *
+     * // Listen to collection removals
+     * $.onRemove("entities", (sessionId, entity) => { ... });
+     *
+     * // Listen to any property change on an instance
+     * $.onChange(entity, () => { ... });
+     *
+     * // Bind properties to another object
+     * $.bindTo(player, playerVisual);
+     * ```
+     */
+    class StateCallbackStrategy {
+        decoder;
+        uniqueRefIds = new Set();
+        isTriggering = false;
+        constructor(decoder) {
+            this.decoder = decoder;
+            this.decoder.triggerChanges = this.triggerChanges.bind(this);
+        }
+        get callbacks() {
+            return this.decoder.root.callbacks;
+        }
+        get state() {
+            return this.decoder.state;
+        }
+        addCallback(refId, operationOrProperty, handler) {
+            const $root = this.decoder.root;
+            return $root.addCallback(refId, operationOrProperty, handler);
+        }
+        addCallbackOrWaitCollectionAvailable(instance, propertyName, operation, handler, immediate = true) {
+            let removeHandler = () => { };
+            const removeOnAdd = () => removeHandler();
+            const collection = instance[propertyName];
+            // Collection not available yet. Listen for its availability before attaching the handler.
+            if (collection === null || collection === undefined) {
+                removeHandler = this.addCallback(instance[$refId], propertyName, (value, _) => {
+                    if (value !== null && value !== undefined) {
+                        removeHandler = this.addCallback(value[$refId], operation, handler);
+                    }
+                });
+                return removeOnAdd;
+            }
+            else {
+                //
+                // Call immediately if collection is already available, if it's an ADD operation.
+                //
+                immediate = immediate && this.isTriggering === false;
+                if (operation === exports.OPERATION.ADD && immediate) {
+                    collection.forEach((value, key) => {
+                        handler(key, value);
+                    });
+                }
+                return this.addCallback(collection[$refId], operation, handler);
+            }
+        }
+        listen(...args) {
+            if (typeof args[0] === 'string') {
+                // listen(property, handler, immediate?)
+                return this.listenInstance(this.state, args[0], args[1], args[2]);
+            }
+            else {
+                // listen(instance, property, handler, immediate?)
+                return this.listenInstance(args[0], args[1], args[2], args[3]);
+            }
+        }
+        listenInstance(instance, propertyName, handler, immediate = true) {
+            immediate = immediate && this.isTriggering === false;
+            //
+            // Call handler immediately if property is already available.
+            //
+            const currentValue = instance[propertyName];
+            if (immediate && currentValue !== null && currentValue !== undefined) {
+                handler(currentValue, undefined);
+            }
+            return this.addCallback(instance[$refId], propertyName, handler);
+        }
+        onChange(...args) {
+            if (args.length === 2 && typeof args[0] !== 'string') {
+                // onChange(instance, handler) - instance change
+                const instance = args[0];
+                const handler = args[1];
+                return this.addCallback(instance[$refId], exports.OPERATION.REPLACE, handler);
+            }
+            if (typeof args[0] === 'string') {
+                // onChange(property, handler) - collection on root state
+                return this.addCallbackOrWaitCollectionAvailable(this.state, args[0], exports.OPERATION.REPLACE, args[1]);
+            }
+            else {
+                // onChange(instance, property, handler) - nested collection
+                return this.addCallbackOrWaitCollectionAvailable(args[0], args[1], exports.OPERATION.REPLACE, args[2]);
+            }
+        }
+        onAdd(...args) {
+            if (typeof args[0] === 'string') {
+                // onAdd(property, handler, immediate?) - collection on root state
+                return this.addCallbackOrWaitCollectionAvailable(this.state, args[0], exports.OPERATION.ADD, args[1], args[2] !== false);
+            }
+            else {
+                // onAdd(instance, property, handler, immediate?) - nested collection
+                return this.addCallbackOrWaitCollectionAvailable(args[0], args[1], exports.OPERATION.ADD, args[2], args[3] !== false);
+            }
+        }
+        onRemove(...args) {
+            if (typeof args[0] === 'string') {
+                // onRemove(property, handler) - collection on root state
+                return this.addCallbackOrWaitCollectionAvailable(this.state, args[0], exports.OPERATION.DELETE, args[1]);
+            }
+            else {
+                // onRemove(instance, property, handler) - nested collection
+                return this.addCallbackOrWaitCollectionAvailable(args[0], args[1], exports.OPERATION.DELETE, args[2]);
+            }
+        }
+        /**
+         * Bind properties from a Schema instance to a target object.
+         * Changes will be automatically reflected on the target object.
+         */
+        bindTo(from, to, properties, immediate = true) {
+            const metadata = from.constructor[Symbol.metadata];
+            // If no properties specified, bind all properties
+            if (!properties) {
+                properties = Object.keys(metadata)
+                    .filter(key => !isNaN(Number(key)))
+                    .map((index) => metadata[index].name);
+            }
+            const action = () => {
+                for (const prop of properties) {
+                    const fromValue = from[prop];
+                    if (fromValue !== undefined) {
+                        to[prop] = fromValue;
+                    }
+                }
+            };
+            if (immediate) {
+                action();
+            }
+            return this.addCallback(from[$refId], exports.OPERATION.REPLACE, action);
+        }
+        triggerChanges(allChanges) {
+            this.uniqueRefIds.clear();
+            for (let i = 0, l = allChanges.length; i < l; i++) {
+                const change = allChanges[i];
+                const refId = change.refId;
+                const ref = change.ref;
+                const $callbacks = this.callbacks[refId];
+                if (!$callbacks) {
+                    continue;
+                }
+                //
+                // trigger onRemove on child structure.
+                //
+                if ((change.op & exports.OPERATION.DELETE) === exports.OPERATION.DELETE &&
+                    change.previousValue instanceof Schema) {
+                    const childRefId = change.previousValue[$refId];
+                    const deleteCallbacks = this.callbacks[childRefId]?.[exports.OPERATION.DELETE];
+                    if (deleteCallbacks) {
+                        for (let j = deleteCallbacks.length - 1; j >= 0; j--) {
+                            deleteCallbacks[j]();
+                        }
+                    }
+                }
+                if (ref instanceof Schema) {
+                    //
+                    // Handle Schema instance
+                    //
+                    if (!this.uniqueRefIds.has(refId)) {
+                        // trigger onChange
+                        const replaceCallbacks = $callbacks[exports.OPERATION.REPLACE];
+                        if (replaceCallbacks) {
+                            for (let j = replaceCallbacks.length - 1; j >= 0; j--) {
+                                try {
+                                    replaceCallbacks[j]();
+                                }
+                                catch (e) {
+                                    console.error(e);
+                                }
+                            }
+                        }
+                    }
+                    // trigger field callbacks
+                    const fieldCallbacks = $callbacks[change.field];
+                    if (fieldCallbacks) {
+                        for (let j = fieldCallbacks.length - 1; j >= 0; j--) {
+                            try {
+                                this.isTriggering = true;
+                                fieldCallbacks[j](change.value, change.previousValue);
+                            }
+                            catch (e) {
+                                console.error(e);
+                            }
+                            finally {
+                                this.isTriggering = false;
+                            }
+                        }
+                    }
+                }
+                else {
+                    //
+                    // Handle collection of items
+                    //
+                    const dynamicIndex = change.dynamicIndex ?? change.field;
+                    if ((change.op & exports.OPERATION.DELETE) === exports.OPERATION.DELETE) {
+                        //
+                        // FIXME: `previousValue` should always be available.
+                        //
+                        if (change.previousValue !== undefined) {
+                            // trigger onRemove (key, value)
+                            const deleteCallbacks = $callbacks[exports.OPERATION.DELETE];
+                            if (deleteCallbacks) {
+                                for (let j = deleteCallbacks.length - 1; j >= 0; j--) {
+                                    deleteCallbacks[j](dynamicIndex, change.previousValue);
+                                }
+                            }
+                        }
+                        // Handle DELETE_AND_ADD operation
+                        if ((change.op & exports.OPERATION.ADD) === exports.OPERATION.ADD) {
+                            const addCallbacks = $callbacks[exports.OPERATION.ADD];
+                            if (addCallbacks) {
+                                this.isTriggering = true;
+                                for (let j = addCallbacks.length - 1; j >= 0; j--) {
+                                    addCallbacks[j](dynamicIndex, change.value);
+                                }
+                                this.isTriggering = false;
+                            }
+                        }
+                    }
+                    else if ((change.op & exports.OPERATION.ADD) === exports.OPERATION.ADD &&
+                        change.previousValue !== change.value) {
+                        // trigger onAdd (key, value)
+                        const addCallbacks = $callbacks[exports.OPERATION.ADD];
+                        if (addCallbacks) {
+                            this.isTriggering = true;
+                            for (let j = addCallbacks.length - 1; j >= 0; j--) {
+                                addCallbacks[j](dynamicIndex, change.value);
+                            }
+                            this.isTriggering = false;
+                        }
+                    }
+                    // trigger onChange (key, value)
+                    if (change.value !== change.previousValue) {
+                        const replaceCallbacks = $callbacks[exports.OPERATION.REPLACE];
+                        if (replaceCallbacks) {
+                            for (let j = replaceCallbacks.length - 1; j >= 0; j--) {
+                                replaceCallbacks[j](dynamicIndex, change.value);
+                            }
+                        }
+                    }
+                }
+                this.uniqueRefIds.add(refId);
+            }
+        }
+    }
+    /**
+     * Factory class for retrieving the callbacks API.
+     */
+    const Callbacks = {
+        /**
+         * Get the new callbacks standard API.
+         *
+         * Usage:
+         * ```ts
+         * const callbacks = Callbacks.get(roomOrDecoder);
+         *
+         * // Listen to property changes
+         * callbacks.listen("currentTurn", (currentValue, previousValue) => { ... });
+         *
+         * // Listen to collection additions
+         * callbacks.onAdd("entities", (sessionId, entity) => {
+         *     // Nested property listening
+         *     callbacks.listen(entity, "hp", (currentHp, previousHp) => { ... });
+         * });
+         *
+         * // Listen to collection removals
+         * callbacks.onRemove("entities", (sessionId, entity) => { ... });
+         *
+         * // Listen to any property change on an instance
+         * callbacks.onChange(entity, () => { ... });
+         *
+         * // Bind properties to another object
+         * callbacks.bindTo(player, playerVisual);
+         * ```
+         *
+         * @param roomOrDecoder - Room or Decoder instance to get the callbacks for.
+         * @returns the new callbacks standard API.
+         */
+        get(roomOrDecoder) {
+            if (roomOrDecoder instanceof Decoder) {
+                return new StateCallbackStrategy(roomOrDecoder);
+            }
+            else if (roomOrDecoder.serializer.decoder) {
+                return new StateCallbackStrategy(roomOrDecoder.serializer.decoder);
+            }
+            else {
+                throw new Error('Invalid room or decoder');
+            }
+        },
+        /**
+         * Get the legacy callbacks API.
+         *
+         * We aim to deprecate this API on 1.0, and iterate on improving Callbacks.get() API.
+         *
+         * @param roomOrDecoder - Room or Decoder instance to get the legacy callbacks for.
+         * @returns the legacy callbacks API.
+         */
+        getLegacy(roomOrDecoder) {
+            if (roomOrDecoder instanceof Decoder) {
+                return getDecoderStateCallbacks(roomOrDecoder);
+            }
+            else if (roomOrDecoder.serializer.decoder) {
+                return getDecoderStateCallbacks(roomOrDecoder.serializer.decoder);
+            }
+        },
+        getRawChanges(decoder, callback) {
+            return getRawChangesCallback(decoder, callback);
+        }
+    };
+
     class StateView {
+        iterable;
+        /**
+         * Iterable list of items that are visible to this view
+         * (Available only if constructed with `iterable: true`)
+         */
+        items;
+        /**
+         * List of ChangeTree's that are visible to this view
+         */
+        visible = new WeakSet();
+        /**
+         * List of ChangeTree's that are invisible to this view
+         */
+        invisible = new WeakSet();
+        tags; // TODO: use bit manipulation instead of Set<number> ()
+        /**
+         * Manual "ADD" operations for changes per ChangeTree, specific to this view.
+         * (This is used to force encoding a property, even if it was not changed)
+         */
+        changes = new Map();
         constructor(iterable = false) {
             this.iterable = iterable;
-            /**
-             * List of ChangeTree's that are visible to this view
-             */
-            this.visible = new WeakSet();
-            /**
-             * List of ChangeTree's that are invisible to this view
-             */
-            this.invisible = new WeakSet();
-            /**
-             * Manual "ADD" operations for changes per ChangeTree, specific to this view.
-             * (This is used to force encoding a property, even if it was not changed)
-             */
-            this.changes = new Map();
             if (iterable) {
                 this.items = [];
             }
@@ -5150,7 +5493,7 @@
                 return false;
             }
             else if (!parentChangeTree &&
-                changeTree.refId !== 0 // allow root object
+                obj[$refId] !== 0 // allow root object
             ) {
                 /**
                  * TODO: can we avoid this?
@@ -5174,11 +5517,11 @@
             if (checkIncludeParent && parentChangeTree) {
                 this.addParentOf(changeTree, tag);
             }
-            let changes = this.changes.get(changeTree.refId);
+            let changes = this.changes.get(obj[$refId]);
             if (changes === undefined) {
                 changes = {};
                 // FIXME / OPTIMIZE: do not add if no changes are needed
-                this.changes.set(changeTree.refId, changes);
+                this.changes.set(obj[$refId], changes);
             }
             let isChildAdded = false;
             //
@@ -5258,10 +5601,10 @@
             }
             // add parent's tag properties
             if (changeTree.getChange(parentIndex) !== exports.OPERATION.DELETE) {
-                let changes = this.changes.get(changeTree.refId);
+                let changes = this.changes.get(changeTree.ref[$refId]);
                 if (changes === undefined) {
                     changes = {};
-                    this.changes.set(changeTree.refId, changes);
+                    this.changes.set(changeTree.ref[$refId], changes);
                 }
                 if (!this.tags) {
                     this.tags = new WeakMap();
@@ -5293,27 +5636,28 @@
             }
             const ref = changeTree.ref;
             const metadata = ref.constructor[Symbol.metadata]; // ArraySchema/MapSchema do not have metadata
-            let changes = this.changes.get(changeTree.refId);
+            const refId = ref[$refId];
+            let changes = this.changes.get(refId);
             if (changes === undefined) {
                 changes = {};
-                this.changes.set(changeTree.refId, changes);
+                this.changes.set(refId, changes);
             }
             if (tag === DEFAULT_VIEW_TAG) {
                 // parent is collection (Map/Array)
                 const parent = changeTree.parent;
                 if (parent && !Metadata.isValidInstance(parent) && changeTree.isFiltered) {
-                    const parentChangeTree = parent[$changes];
-                    let changes = this.changes.get(parentChangeTree.refId);
+                    const parentRefId = parent[$refId];
+                    let changes = this.changes.get(parentRefId);
                     if (changes === undefined) {
                         changes = {};
-                        this.changes.set(parentChangeTree.refId, changes);
+                        this.changes.set(parentRefId, changes);
                     }
                     else if (changes[changeTree.parentIndex] === exports.OPERATION.ADD) {
                         //
                         // SAME PATCH ADD + REMOVE:
                         // The 'changes' of deleted structure should be ignored.
                         //
-                        this.changes.delete(changeTree.refId);
+                        this.changes.delete(refId);
                     }
                     // DELETE / DELETE BY REF ID
                     changes[changeTree.parentIndex] = exports.OPERATION.DELETE;
@@ -5373,7 +5717,7 @@
             if (!isVisible && changeTree.isVisibilitySharedWithParent) {
                 // console.log("CHECK AGAINST PARENT...", {
                 //     ref: changeTree.ref.constructor.name,
-                //     refId: changeTree.refId,
+                //     refId: changeTree.ref[$refId],
                 //     parent: changeTree.parent.constructor.name,
                 // });
                 if (this.visible.has(changeTree.parent[$changes])) {
@@ -5403,8 +5747,10 @@
     exports.$encoder = $encoder;
     exports.$filter = $filter;
     exports.$getByIndex = $getByIndex;
+    exports.$refId = $refId;
     exports.$track = $track;
     exports.ArraySchema = ArraySchema;
+    exports.Callbacks = Callbacks;
     exports.ChangeTree = ChangeTree;
     exports.CollectionSchema = CollectionSchema;
     exports.Decoder = Decoder;
@@ -5416,6 +5762,7 @@
     exports.ReflectionType = ReflectionType;
     exports.Schema = Schema;
     exports.SetSchema = SetSchema;
+    exports.StateCallbackStrategy = StateCallbackStrategy;
     exports.StateView = StateView;
     exports.TypeContext = TypeContext;
     exports.decode = decode;