@colyseus/schema 3.0.76 → 4.0.1

package/src/encoder/EncodeOperation.ts

@@ -1,5 +1,5 @@
 import { OPERATION } from "../encoding/spec";
-import { $changes, $childType, $getByIndex } from "../types/symbols";
+import { $changes, $childType, $getByIndex, $refId } from "../types/symbols";
 
 import { encode } from "../encoding/encode";
 
@@ -13,7 +13,7 @@ import type { Metadata } from "../Metadata";
 
 export type EncodeOperation<T extends Ref = any> = (
     encoder: Encoder,
-    bytes: Buffer,
+    bytes: Uint8Array,
     changeTree: ChangeTree<T>,
     index: number,
     operation: OPERATION,
@@ -25,7 +25,7 @@ export type EncodeOperation<T extends Ref = any> = (
 
 export function encodeValue(
     encoder: Encoder,
-    bytes: Buffer,
+    bytes: Uint8Array,
     type: any,
     value: any,
     operation: OPERATION,
@@ -39,7 +39,7 @@ export function encodeValue(
         // 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 & OPERATION.ADD) === OPERATION.ADD) {
@@ -51,7 +51,7 @@ export function encodeValue(
         // 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);
     }
 }
 
@@ -61,7 +61,7 @@ export function encodeValue(
  */
 export const encodeSchemaOperation: EncodeOperation = function <T extends Schema> (
     encoder: Encoder,
-    bytes: Buffer,
+    bytes: Uint8Array,
     changeTree: ChangeTree<T>,
     index: number,
     operation: OPERATION,
@@ -98,7 +98,7 @@ export const encodeSchemaOperation: EncodeOperation = function <T extends Schema
  */
 export const encodeKeyValueOperation: EncodeOperation = function (
     encoder: Encoder,
-    bytes: Buffer,
+    bytes: Uint8Array,
     changeTree: ChangeTree,
     index: number,
     operation: OPERATION,
@@ -163,7 +163,7 @@ export const encodeKeyValueOperation: EncodeOperation = function (
  */
 export const encodeArray: EncodeOperation = function (
     encoder: Encoder,
-    bytes: Buffer,
+    bytes: Uint8Array,
     changeTree: ChangeTree<ArraySchema>,
     field: number,
     operation: OPERATION,
@@ -182,7 +182,7 @@ export const encodeArray: EncodeOperation = function (
         // Skip encoding if item is undefined (e.g. when clear() is called)
         if (!item) { return; }
 
-        refOrIndex = item[$changes].refId;
+        refOrIndex = item[$refId];
 
         if (operation === OPERATION.DELETE) {
             operation = OPERATION.DELETE_BY_REFID;

package/src/encoder/Encoder.ts

@@ -1,6 +1,6 @@
 import type { Schema } from "../Schema";
 import { TypeContext } from "../types/TypeContext";
-import { $changes, $encoder, $filter, $getByIndex } from "../types/symbols";
+import { $changes, $encoder, $filter, $getByIndex, $refId } from "../types/symbols";
 
 import { encode } from "../encoding/encode";
 import type { Iterator } from "../encoding/decode";
@@ -9,13 +9,19 @@ import { OPERATION, SWITCH_TO_STRUCTURE, TYPE_ID } from '../encoding/spec';
 import { Root } from "./Root";
 
 import type { StateView } from "./StateView";
-import type { Metadata } from "../Metadata";
 import type { ChangeSetName, ChangeTree, ChangeTreeList, ChangeTreeNode } from "./ChangeTree";
 import { createChangeTreeList } from "./ChangeTree";
 
+function concatBytes(a: Uint8Array, b: Uint8Array): Uint8Array {
+    const result = new Uint8Array(a.length + b.length);
+    result.set(a, 0);
+    result.set(b, a.length);
+    return result;
+}
+
 export class Encoder<T extends Schema = any> {
-    static BUFFER_SIZE = (typeof(Buffer) !== "undefined") && Buffer.poolSize || 8 * 1024; // 8KB
-    sharedBuffer = Buffer.allocUnsafe(Encoder.BUFFER_SIZE);
+    static BUFFER_SIZE = 8 * 1024; // 8KB
+    sharedBuffer: Uint8Array = new Uint8Array(Encoder.BUFFER_SIZE);
 
     context: TypeContext;
     state: T;
@@ -48,11 +54,11 @@ export class Encoder<T extends Schema = any> {
     encode(
         it: Iterator = { offset: 0 },
         view?: StateView,
-        buffer = this.sharedBuffer,
+        buffer: Uint8Array = this.sharedBuffer,
         changeSetName: ChangeSetName = "changes",
         isEncodeAll = changeSetName === "allChanges",
         initialOffset = it.offset // cache current offset in case we need to resize the buffer
-    ): Buffer {
+    ): Uint8Array {
         const hasView = (view !== undefined);
         const rootChangeTree = this.state[$changes];
 
@@ -63,7 +69,7 @@ export class Encoder<T extends Schema = any> {
 
             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
                 }
@@ -86,7 +92,7 @@ export class Encoder<T extends Schema = any> {
             // (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++) {
@@ -121,10 +127,9 @@ export class Encoder<T extends Schema = any> {
         }
 
         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:
 
@@ -136,7 +141,9 @@ export class Encoder<T extends Schema = any> {
             // 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) {
@@ -151,23 +158,36 @@ export class Encoder<T extends Schema = any> {
         }
     }
 
-    encodeAll(it: Iterator = { offset: 0 }, buffer: Buffer = this.sharedBuffer) {
+    encodeAll(
+        it: Iterator = { offset: 0 },
+        buffer: Uint8Array = this.sharedBuffer
+    ) {
         return this.encode(it, undefined, buffer, "allChanges", true);
     }
 
-    encodeAllView(view: StateView, sharedOffset: number, it: Iterator, bytes = this.sharedBuffer) {
+    encodeAllView(
+        view: StateView,
+        sharedOffset: number,
+        it: Iterator,
+        bytes: Uint8Array = this.sharedBuffer
+    ) {
         const viewOffset = it.offset;
 
         // try to encode "filtered" changes
         this.encode(it, view, bytes, "allFilteredChanges", true, viewOffset);
 
-        return Buffer.concat([
+        return concatBytes(
             bytes.subarray(0, sharedOffset),
             bytes.subarray(viewOffset, it.offset)
-        ]);
+        );
     }
 
-    encodeView(view: StateView, sharedOffset: number, it: Iterator, bytes = this.sharedBuffer) {
+    encodeView(
+        view: StateView,
+        sharedOffset: number,
+        it: Iterator,
+        bytes: Uint8Array = this.sharedBuffer
+    ) {
         const viewOffset = it.offset;
 
         // encode visibility changes (add/remove for this view)
@@ -195,7 +215,7 @@ export class Encoder<T extends Schema = any> {
             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]);
@@ -219,10 +239,10 @@ export class Encoder<T extends Schema = any> {
         // try to encode "filtered" changes
         this.encode(it, view, bytes, "filteredChanges", false, viewOffset);
 
-        return Buffer.concat([
+        return concatBytes(
             bytes.subarray(0, sharedOffset),
             bytes.subarray(viewOffset, it.offset)
-        ]);
+        );
     }
 
     discardChanges() {
@@ -243,7 +263,12 @@ export class Encoder<T extends Schema = any> {
         this.root.filteredChanges = createChangeTreeList();
     }
 
-    tryEncodeTypeId (bytes: Buffer, baseType: typeof Schema, targetType: typeof Schema, it: Iterator) {
+    tryEncodeTypeId(
+        bytes: Uint8Array,
+        baseType: typeof Schema,
+        targetType: typeof Schema,
+        it: Iterator
+    ) {
         const baseTypeId = this.context.getTypeId(baseType);
         const targetTypeId = this.context.getTypeId(targetType);
 

package/src/encoder/Root.ts

@@ -1,7 +1,7 @@
 import { OPERATION } from "../encoding/spec";
 import { TypeContext } from "../types/TypeContext";
 import { ChangeTree, setOperationAtIndex, ChangeTreeList, createChangeTreeList, ChangeSetName, type ChangeTreeNode } from "./ChangeTree";
-import { $changes } from "../types/symbols";
+import { $changes, $refId } from "../types/symbols";
 
 export class Root {
     protected nextUniqueId: number = 0;
@@ -24,15 +24,19 @@ export class Root {
     }
 
     add(changeTree: 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);
-        if (isNewChangeTree) { this.changeTrees[changeTree.refId] = changeTree; }
+        const refId = ref[$refId];
+
+        const isNewChangeTree = (this.changeTrees[refId] === undefined);
+        if (isNewChangeTree) { 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.
@@ -46,24 +50,25 @@ export class Root {
             }
         }
 
-        this.refCount[changeTree.refId] = (previousRefCount || 0) + 1;
+        this.refCount[refId] = (previousRefCount || 0) + 1;
 
-        // console.log("ADD", { refId: changeTree.refId, ref: changeTree.ref.constructor.name, refCount: this.refCount[changeTree.refId], isNewChangeTree });
+        // console.log("ADD", { refId, ref: ref.constructor.name, refCount: this.refCount[refId], isNewChangeTree });
 
         return isNewChangeTree;
     }
 
     remove(changeTree: ChangeTree) {
-        const refCount = (this.refCount[changeTree.refId]) - 1;
+        const refId = changeTree.ref[$refId];
+        const refCount = (this.refCount[refId]) - 1;
 
-        // console.log("REMOVE", { refId: changeTree.refId, ref: changeTree.ref.constructor.name, refCount, needRemove: refCount <= 0 });
+        // 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);
@@ -73,13 +78,13 @@ export class Root {
                 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);
 
@@ -91,7 +96,7 @@ export 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

package/src/encoder/StateView.ts

@@ -1,5 +1,5 @@
 import { ChangeTree, IndexedOperations, Ref } from "./ChangeTree";
-import { $changes, $fieldIndexesByViewTag, $viewFieldIndexes } from "../types/symbols";
+import { $changes, $fieldIndexesByViewTag, $refId, $viewFieldIndexes } from "../types/symbols";
 import { DEFAULT_VIEW_TAG } from "../annotations";
 import { OPERATION } from "../encoding/spec";
 import { Metadata } from "../Metadata";
@@ -52,7 +52,7 @@ export class StateView {
 
         } else if (
             !parentChangeTree &&
-            changeTree.refId !== 0 // allow root object
+            obj[$refId] !== 0 // allow root object
         ) {
             /**
              * TODO: can we avoid this?
@@ -82,11 +82,11 @@ export class StateView {
             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;
@@ -182,10 +182,10 @@ export class StateView {
 
         // add parent's tag properties
         if (changeTree.getChange(parentIndex) !== 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) {
@@ -227,28 +227,30 @@ export class StateView {
         const ref = changeTree.ref;
         const metadata: 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] === 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
@@ -322,7 +324,7 @@ export class StateView {
 
             // console.log("CHECK AGAINST PARENT...", {
             //     ref: changeTree.ref.constructor.name,
-            //     refId: changeTree.refId,
+            //     refId: changeTree.ref[$refId],
             //     parent: changeTree.parent.constructor.name,
             // });
 

package/src/encoding/encode.ts

@@ -26,7 +26,7 @@
 import type { TextEncoder } from "util";
 import type { Iterator } from "./decode";
 
-export type BufferLike = number[] | ArrayBufferLike | Buffer;
+export type BufferLike = ArrayLike<number> & { [index: number]: number };
 
 /**
  * msgpack implementation highly based on notepack.io

package/src/index.ts

@@ -26,7 +26,7 @@ registerType("collection", { constructor: CollectionSchema, });
 export { dumpChanges } from "./utils";
 
 // Encoder / Decoder
-export { $track, $encoder, $decoder, $filter, $getByIndex, $deleteByIndex, $changes, $childType } from "./types/symbols";
+export { $track, $encoder, $decoder, $filter, $getByIndex, $deleteByIndex, $changes, $childType, $refId } from "./types/symbols";
 export { encode } from "./encoding/encode";
 export { decode, type Iterator } from "./encoding/decode";
 
@@ -62,7 +62,8 @@ export { TypeContext } from "./types/TypeContext";
 // Helper types for type inference
 export type { InferValueType, InferSchemaInstanceType, AssignableProps } from "./types/HelperTypes";
 
-export { getDecoderStateCallbacks, CallbackProxy, SchemaCallback, CollectionCallback, SchemaCallbackProxy } from "./decoder/strategy/StateCallbacks";
+export { getDecoderStateCallbacks, CallbackProxy, SchemaCallback, CollectionCallback, SchemaCallbackProxy } from "./decoder/strategy/getDecoderStateCallbacks";
+export { Callbacks, StateCallbackStrategy } from "./decoder/strategy/Callbacks";
 export { getRawChangesCallback } from "./decoder/strategy/RawChanges";
 
 export { Encoder } from "./encoder/Encoder";

package/src/types/HelperTypes.ts

@@ -7,6 +7,13 @@ import type { SetSchema } from "./custom/SetSchema";
 
 export type Constructor<T = {}> = new (...args: any[]) => T;
 
+// Helper to convert primitive type literals to actual runtime types
+type PrimitiveStringToType<T> =
+    T extends "string" ? string
+    : T extends "number" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32" | "int64" | "uint64" | "float32" | "float64" ? number
+    : T extends "boolean" ? boolean
+    : T;
+
 export interface Collection<K = any, V = any, IT = V> {
     [Symbol.iterator](): IterableIterator<IT>;
     forEach(callback: Function): void;
@@ -38,25 +45,20 @@ export type InferValueType<T extends DefinitionType> =
     : T extends { type: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? ChildType[keyof ChildType] : ChildType) // TS ENUM
 
     // Handle direct array patterns
-    : T extends Array<infer ChildType extends Constructor> ? InstanceType<ChildType>[]
-    : T extends Array<infer ChildType extends RawPrimitiveType> ? InferValueType<ChildType>[] // primitive types
-    : T extends Array<infer ChildType> ? (ChildType extends Record<string | number, string | number> ? ChildType[keyof ChildType][] : ChildType[]) // TS ENUM
+    : T extends Array<infer ChildType extends Constructor> ? ArraySchema<InstanceType<ChildType>>
+    : T extends Array<infer ChildType> ? (ChildType extends Record<string | number, string | number> ? ArraySchema<ChildType[keyof ChildType]> : ArraySchema<PrimitiveStringToType<ChildType>>) // TS ENUM
 
     // Handle collection object patterns
-    : T extends { array: infer ChildType extends Constructor } ? InstanceType<ChildType>[]
-    : T extends { array: infer ChildType extends RawPrimitiveType } ? InferValueType<ChildType>[] // primitive types
-    : T extends { array: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? ChildType[keyof ChildType][] : ChildType[]) // TS ENUM
+    : T extends { array: infer ChildType extends Constructor } ? ArraySchema<InstanceType<ChildType>>
+    : T extends { array: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? ArraySchema<ChildType[keyof ChildType]> : ArraySchema<PrimitiveStringToType<ChildType>>) // TS ENUM
 
     : T extends { map: infer ChildType extends Constructor } ? MapSchema<InstanceType<ChildType>>
-    : T extends { map: infer ChildType extends RawPrimitiveType } ? MapSchema<InferValueType<ChildType>> // primitive types
-    : T extends { map: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? MapSchema<ChildType[keyof ChildType]> : MapSchema<ChildType>) // TS ENUM
+    : T extends { map: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? MapSchema<ChildType[keyof ChildType]> : MapSchema<PrimitiveStringToType<ChildType>>) // TS ENUM
 
     : T extends { set: infer ChildType extends Constructor } ? SetSchema<InstanceType<ChildType>>
-    : T extends { set: infer ChildType extends RawPrimitiveType } ? SetSchema<InferValueType<ChildType>> // primitive types
     : T extends { set: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? SetSchema<ChildType[keyof ChildType]> : SetSchema<ChildType>) // TS ENUM
 
     : T extends { collection: infer ChildType extends Constructor } ? CollectionSchema<InstanceType<ChildType>>
-    : T extends { collection: infer ChildType extends RawPrimitiveType } ? CollectionSchema<InferValueType<ChildType>> // primitive types
     : T extends { collection: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? CollectionSchema<ChildType[keyof ChildType]> : CollectionSchema<ChildType>) // TS ENUM
 
     // Handle direct types
@@ -89,7 +91,7 @@ export type NonFunctionNonPrimitivePropNames<T> = {
 }[keyof T];
 
 // Helper to recursively convert Schema instances to their JSON representation
-type ToJSONValue<U> = U extends Schema ? ToJSON<U> : U;
+type ToJSONValue<U> = U extends Schema ? ToJSON<U> : PrimitiveStringToType<U>;
 
 export type ToJSON<T> = NonFunctionProps<{
     [K in keyof T]:

package/src/types/custom/ArraySchema.ts

@@ -1,4 +1,4 @@
-import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $onDecodeEnd } from "../symbols";
+import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $onDecodeEnd, $refId } from "../symbols";
 import type { Schema } from "../../Schema";
 import { type IRef, ChangeTree, setOperationAtIndex } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
@@ -21,6 +21,7 @@ const DEFAULT_SORT = (a: any, b: any) => {
 export class ArraySchema<V = any> implements Array<V>, Collection<number, V>, IRef {
     [n: number]: V;
     [$changes]: ChangeTree;
+    [$refId]?: number;
 
     protected [$childType]: string | typeof Schema;
 

package/src/types/custom/CollectionSchema.ts

@@ -1,4 +1,4 @@
-import { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex, $onEncodeEnd } from "../symbols";
+import { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex, $onEncodeEnd, $refId } from "../symbols";
 import { ChangeTree, type IRef } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
@@ -11,7 +11,9 @@ import type { Schema } from "../../Schema";
 type K = number; // TODO: allow to specify K generic on MapSchema.
 
 export class CollectionSchema<V=any> implements Collection<K, V>, IRef {
-    public [$changes]: ChangeTree;
+    [$changes]: ChangeTree;
+    [$refId]?: number;
+
     protected [$childType]: string | typeof Schema;
 
     protected $items: Map<number, V> = new Map<number, V>();

package/src/types/custom/MapSchema.ts

@@ -1,4 +1,4 @@
-import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $numFields } from "../symbols";
+import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $numFields, $refId } from "../symbols";
 import { ChangeTree, IRef } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
@@ -10,8 +10,10 @@ import type { Schema } from "../../Schema";
 import { assertInstanceType } from "../../encoding/assert";
 
 export class MapSchema<V=any, K extends string = string> implements Map<K, V>, Collection<K, V, [K, V]>, IRef {
-    protected childType: new () => V;
     [$changes]: ChangeTree;
+    [$refId]?: number;
+
+    protected childType: new () => V;
     protected [$childType]: string | typeof Schema;
 
     protected $items: Map<K, V> = new Map<K, V>();

package/src/types/custom/SetSchema.ts

@@ -1,6 +1,6 @@
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
-import { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex, $onEncodeEnd } from "../symbols";
+import { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex, $onEncodeEnd, $refId } from "../symbols";
 import { Collection } from "../HelperTypes";
 import { ChangeTree, type IRef } from "../../encoder/ChangeTree";
 import { encodeKeyValueOperation } from "../../encoder/EncodeOperation";
@@ -10,6 +10,8 @@ import type { Schema } from "../../Schema";
 
 export class SetSchema<V=any> implements Collection<number, V>, IRef {
     [$changes]: ChangeTree;
+    [$refId]?: number;
+
     protected [$childType]: string | typeof Schema;
 
     protected $items: Map<number, V> = new Map<number, V>();

package/src/types/symbols.ts

@@ -1,3 +1,4 @@
+export const $refId = "~refId";
 export const $track = "~track";
 export const $encoder = "~encoder";
 export const $decoder = "~decoder";

package/src/utils.ts

@@ -1,6 +1,6 @@
 import type { Schema } from "./Schema";
 import { OPERATION } from "./encoding/spec";
-import { $changes } from "./types/symbols";
+import { $changes, $refId } from "./types/symbols";
 
 interface ChangeDump {
     ops: {
@@ -37,7 +37,7 @@ export function dumpChanges(schema: Schema) {
 
         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 = OPERATION[op];

package/lib/Decoder.d.ts

@@ -1,16 +0,0 @@
-import { TypeContext } from "./annotations";
-import { DataChange, Schema } from "./Schema";
-import { Ref } from "./changes/ChangeTree";
-import { Iterator } from "./encoding/decode";
-import { ReferenceTracker } from "./changes/ReferenceTracker";
-export declare class Decoder<T extends Schema = any> {
-    context: TypeContext;
-    root: T;
-    refs: ReferenceTracker;
-    currentRefId: number;
-    constructor(root: T, context?: TypeContext);
-    protected setRoot(root: T): void;
-    decode(bytes: number[], it?: Iterator, ref?: Ref): DataChange<any, string>[];
-    getInstanceType(bytes: number[], it: Iterator, defaultType: typeof Schema): typeof Schema;
-    createInstanceOfType(type: typeof Schema): Schema;
-}