@colyseus/schema 3.0.75 → 4.0.0

package/build/cjs/index.js

@@ -28,6 +28,7 @@ exports.OPERATION = void 0;
 
 Symbol.metadata ??= Symbol.for("Symbol.metadata");
 
+const $refId = "~refId";
 const $track = "~track";
 const $encoder = "~encoder";
 const $decoder = "~decoder";
@@ -558,12 +559,16 @@ function defineCustomTypes(types) {
 }
 
 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) {
@@ -584,10 +589,6 @@ class TypeContext {
         return context;
     }
     constructor(rootClass) {
-        this.types = {};
-        this.schemas = new Map();
-        this.hasFilters = false;
-        this.parentFiltered = {};
         if (rootClass) {
             this.discoverTypes(rootClass);
         }
@@ -980,25 +981,33 @@ function deleteOperationAtIndex(changeSet, index) {
     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];
         //
@@ -1470,7 +1479,7 @@ function encodeValue(encoder, bytes, type, value, operation, it) {
         // 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);
@@ -1481,7 +1490,7 @@ function encodeValue(encoder, bytes, type, value, operation, it) {
         // 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);
     }
 }
 /**
@@ -1557,7 +1566,7 @@ const encodeArray = function (encoder, bytes, changeTree, field, operation, it,
         if (!item) {
             return;
         }
-        refOrIndex = item[$changes].refId;
+        refOrIndex = item[$refId];
         if (operation === exports.OPERATION.DELETE) {
             operation = exports.OPERATION.DELETE_BY_REFID;
         }
@@ -1597,7 +1606,7 @@ function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges
     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);
         }
@@ -1638,7 +1647,7 @@ function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges
         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.
@@ -1649,7 +1658,7 @@ function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges
                     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({
@@ -1878,7 +1887,6 @@ function assertInstanceType(value, type, instance, field) {
     }
 }
 
-var _a$4, _b$4;
 const DEFAULT_SORT = (a, b) => {
     const A = a.toString();
     const B = b.toString();
@@ -1890,8 +1898,15 @@ const DEFAULT_SORT = (a, b) => {
         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.
@@ -1901,7 +1916,7 @@ class ArraySchema {
      * - 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]));
@@ -1917,10 +1932,6 @@ class ArraySchema {
         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,
@@ -2437,6 +2448,10 @@ class ArraySchema {
     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
      */
@@ -2546,7 +2561,7 @@ class ArraySchema {
         this.isMovingItems = false;
         return this;
     }
-    [($getByIndex)](index, isEncodeAll = false) {
+    [$getByIndex](index, isEncodeAll = false) {
         //
         // TODO: avoid unecessary `this.tmpItems` check during decoding.
         //
@@ -2601,10 +2616,16 @@ class ArraySchema {
 }
 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.
@@ -2614,7 +2635,7 @@ class MapSchema {
      * - 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]));
@@ -2623,9 +2644,6 @@ class MapSchema {
         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, {
@@ -2816,10 +2834,16 @@ class MapSchema {
 }
 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.
@@ -2829,7 +2853,7 @@ class CollectionSchema {
      * - 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]));
@@ -2838,10 +2862,6 @@ class CollectionSchema {
         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) {
@@ -2980,10 +3000,16 @@ class CollectionSchema {
 }
 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.
@@ -2993,7 +3019,7 @@ class SetSchema {
      * - 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]));
@@ -3002,10 +3028,6 @@ class SetSchema {
         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) {
@@ -3504,7 +3526,10 @@ function schema(fieldsAndMethods, name, inherits = Schema) {
                     ? 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.
@@ -3526,12 +3551,7 @@ function schema(fieldsAndMethods, name, inherits = Schema) {
                 }
                 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 {
@@ -3541,12 +3561,7 @@ function schema(fieldsAndMethods, name, inherits = Schema) {
         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 {
@@ -3573,32 +3588,13 @@ function schema(fieldsAndMethods, name, inherits = Schema) {
         }
         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);
@@ -3635,7 +3631,7 @@ function dumpChanges(schema) {
             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];
@@ -3649,13 +3645,14 @@ function dumpChanges(schema) {
     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
@@ -3674,7 +3671,7 @@ class Schema {
     /**
      * 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);
     }
     /**
@@ -3721,10 +3718,74 @@ class Schema {
             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
@@ -3797,7 +3858,7 @@ class Schema {
     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)
@@ -3820,7 +3881,7 @@ class Schema {
         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;
         }
@@ -3841,7 +3902,7 @@ class Schema {
         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)
@@ -3855,14 +3916,14 @@ class Schema {
         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;
@@ -3897,13 +3958,13 @@ class Schema {
                 }
             }
             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";
@@ -3912,7 +3973,7 @@ class Schema {
         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);
                 }
             });
@@ -3920,7 +3981,7 @@ class Schema {
             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`;
@@ -3930,61 +3991,35 @@ class Schema {
     }
 }
 
-/******************************************************************************
-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.
@@ -3997,30 +4032,31 @@ class Root {
                 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);
                     }
@@ -4032,7 +4068,7 @@ class Root {
             });
         }
         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.
@@ -4182,10 +4218,19 @@ class Root {
     }
 }
 
+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.
         //
@@ -4213,7 +4258,7 @@ class Encoder {
             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
                 }
@@ -4234,7 +4279,7 @@ class Encoder {
             // (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];
@@ -4263,10 +4308,9 @@ class Encoder {
             }
         }
         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";
@@ -4276,7 +4320,9 @@ class Encoder {
             // 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;
@@ -4294,10 +4340,7 @@ class Encoder {
         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;
@@ -4321,7 +4364,7 @@ class Encoder {
             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")
@@ -4340,10 +4383,7 @@ class Encoder {
         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
@@ -4399,25 +4439,22 @@ class DecodingWarning extends Error {
     }
 }
 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;
         }
@@ -4474,9 +4511,12 @@ class ReferenceTracker {
                 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);
+                        }
                     }
                 }
             }
@@ -4484,8 +4524,8 @@ class ReferenceTracker {
                 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);
                         }
                     });
@@ -4523,8 +4563,12 @@ class ReferenceTracker {
 }
 
 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");
@@ -4613,7 +4657,7 @@ class Decoder {
     }
     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,
@@ -4624,7 +4668,7 @@ class Decoder {
                 previousValue: value
             });
             if (needRemoveRef) {
-                this.root.removeRef(this.root.refIds.get(value));
+                this.root.removeRef(value[$refId]);
             }
         });
     }
@@ -4633,217 +4677,182 @@ class Decoder {
 /**
  * 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);
+        }
+        else {
+            if (pendingReflectionTypes[type.extendsId] === undefined) {
+                pendingReflectionTypes[type.extendsId] = [];
             }
-        };
-        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;
+            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;
@@ -4864,7 +4873,7 @@ function getDecoderStateCallbacks(decoder) {
             //
             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]();
                 }
@@ -4953,7 +4962,7 @@ function getDecoderStateCallbacks(decoder) {
                 ) {
                     callback(context.instance[prop], undefined);
                 }
-                return $root.addCallback($root.refIds.get(ref), prop, callback);
+                return $root.addCallback(ref[$refId], prop, callback);
             };
             /**
              * Schema instances
@@ -4973,7 +4982,7 @@ function getDecoderStateCallbacks(decoder) {
                     }
                 },
                 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.
@@ -4983,7 +4992,7 @@ function getDecoderStateCallbacks(decoder) {
                     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]);
                     });
                 }
@@ -5002,13 +5011,13 @@ function getDecoderStateCallbacks(decoder) {
                                 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,
                         });
@@ -5032,7 +5041,7 @@ function getDecoderStateCallbacks(decoder) {
                 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);
@@ -5041,10 +5050,10 @@ function getDecoderStateCallbacks(decoder) {
                 });
             };
             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) {
@@ -5113,22 +5122,360 @@ function getRawChangesCallback(decoder, callback) {
     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 = [];
         }
@@ -5142,7 +5489,7 @@ class StateView {
             return false;
         }
         else if (!parentChangeTree &&
-            changeTree.refId !== 0 // allow root object
+            obj[$refId] !== 0 // allow root object
         ) {
             /**
              * TODO: can we avoid this?
@@ -5166,11 +5513,11 @@ class StateView {
         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;
         //
@@ -5250,10 +5597,10 @@ class StateView {
         }
         // 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();
@@ -5285,27 +5632,28 @@ class StateView {
         }
         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;
@@ -5365,7 +5713,7 @@ class StateView {
         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])) {
@@ -5395,8 +5743,10 @@ exports.$deleteByIndex = $deleteByIndex;
 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;
@@ -5408,6 +5758,7 @@ exports.ReflectionField = ReflectionField;
 exports.ReflectionType = ReflectionType;
 exports.Schema = Schema;
 exports.SetSchema = SetSchema;
+exports.StateCallbackStrategy = StateCallbackStrategy;
 exports.StateView = StateView;
 exports.TypeContext = TypeContext;
 exports.decode = decode;