@colyseus/schema 3.0.0-alpha.34 → 3.0.0-alpha.36

package/src/encoder/Encoder.ts

@@ -1,6 +1,6 @@
 import type { Schema } from "../Schema";
 import { TypeContext } from "../types/TypeContext";
-import { $changes, $encoder, $filter, $isNew, $onEncodeEnd } from "../types/symbols";
+import { $changes, $encoder, $filter, $onEncodeEnd } from "../types/symbols";
 
 import * as encode from "../encoding/encode";
 import type { Iterator } from "../encoding/decode";
@@ -11,7 +11,6 @@ import { getNextPowerOf2 } from "../utils";
 
 import type { StateView } from "./StateView";
 import type { Metadata } from "../Metadata";
-import type { ChangeTree } from "./ChangeTree";
 
 export class Encoder<T extends Schema = any> {
     static BUFFER_SIZE = 8 * 1024;// 8KB
@@ -48,26 +47,34 @@ export class Encoder<T extends Schema = any> {
         it: Iterator = { offset: 0 },
         view?: StateView,
         buffer = this.sharedBuffer,
-        changeTrees = this.root.changes,
-        isEncodeAll = this.root.allChanges === changeTrees,
+        changeSetName: "changes" | "allChanges" | "filteredChanges" | "allFilteredChanges" = "changes",
+        isEncodeAll = changeSetName === "allChanges",
         initialOffset = it.offset // cache current offset in case we need to resize the buffer
     ): Buffer {
         const hasView = (view !== undefined);
         const rootChangeTree = this.state[$changes];
 
-        const shouldClearChanges = !isEncodeAll && !hasView;
+        const shouldDiscardChanges = !isEncodeAll && !hasView;
+        const changeTrees = this.root[changeSetName];
 
-        for (const [changeTree, changes] of changeTrees.entries()) {
+        for (let i = 0, numChangeTrees = changeTrees.length; i < numChangeTrees; i++) {
+            const changeTree = changeTrees[i];
+
+            // // Root#removeChangeFromChangeSet() is now removing instead of setting to "undefined"
+            // if (changeTree === undefined) { continue; }
+
+            const operations = changeTree[changeSetName];
             const ref = changeTree.ref;
 
             const ctor = ref.constructor;
             const encoder = ctor[$encoder];
             const filter = ctor[$filter];
+            const metadata = ctor[Symbol.metadata];
 
             // try { throw new Error(); } catch (e) {
             //     // only print if not coming from Reflection.ts
             //     if (!e.stack.includes("src/Reflection.ts")) {
-            //         console.log("ChangeTree:", { ref: ref.constructor.name, });
+            //         console.log("ChangeTree:", { refId: changeTree.refId, ref: ref.constructor.name });
             //     }
             // }
 
@@ -88,7 +95,15 @@ export class Encoder<T extends Schema = any> {
                 encode.number(buffer, changeTree.refId, it);
             }
 
-            for (const [fieldIndex, operation] of changes.entries()) {
+            for (let j = 0, numChanges = operations.operations.length; j < numChanges; j++) {
+                const fieldIndex = operations.operations[j];
+
+                const operation = (fieldIndex < 0)
+                    ? Math.abs(fieldIndex) // "pure" operation without fieldIndex (e.g. CLEAR, REVERSE, etc.)
+                    : (isEncodeAll)
+                        ? OPERATION.ADD
+                        : changeTree.indexedOperations[fieldIndex];
+
                 //
                 // first pass (encodeAll), identify "filtered" operations without encoding them
                 // they will be encoded per client, based on their view.
@@ -96,7 +111,7 @@ export class Encoder<T extends Schema = any> {
                 // TODO: how can we optimize filtering out "encode all" operations?
                 // TODO: avoid checking if no view tags were defined
                 //
-                if (filter && !filter(ref, fieldIndex, view)) {
+                if (fieldIndex === undefined || operation === undefined || (filter && !filter(ref, fieldIndex, view))) {
                     // console.log("ADD AS INVISIBLE:", fieldIndex, changeTree.ref.constructor.name)
                     // view?.invisible.add(changeTree);
                     continue;
@@ -113,19 +128,17 @@ export class Encoder<T extends Schema = any> {
                 //     }
                 // }
 
-                encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView);
-            }
+                // console.log("encode...", { ref: changeTree.ref.constructor.name, refId: changeTree.refId, fieldIndex, operation });
 
-            // if (shouldClearChanges) {
-            //     // changeTree.endEncode();
-            //     changeTree.changes.clear();
+                encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView, metadata);
+            }
 
-            //     // ArraySchema and MapSchema have a custom "encode end" method
-            //     changeTree.ref[$onEncodeEnd]?.();
+            if (shouldDiscardChanges) {
+                changeTree.discard();
 
-            //     // Not a new instance anymore
-            //     delete changeTree[$isNew];
-            // }
+                // Not a new instance anymore
+                changeTree.isNew = false;
+            }
         }
 
         if (it.offset > buffer.byteLength) {
@@ -146,38 +159,40 @@ export class Encoder<T extends Schema = any> {
                 this.sharedBuffer = buffer;
             }
 
-            return this.encode({ offset: initialOffset }, view, buffer, changeTrees, isEncodeAll);
+            return this.encode({ offset: initialOffset }, view, buffer, changeSetName, isEncodeAll);
 
         } else {
-            //
-            // only clear changes after making sure buffer resize is not required.
-            //
-            if (shouldClearChanges) {
-                //
-                // FIXME: avoid iterating over change trees twice.
-                //
-                this.onEndEncode(changeTrees);
-            }
+            // //
+            // // only clear changes after making sure buffer resize is not required.
+            // //
+            // if (shouldClearChanges) {
+            //     //
+            //     // FIXME: avoid iterating over change trees twice.
+            //     //
+            //     this.onEndEncode(changeTrees);
+            // }
 
             return buffer.subarray(0, it.offset);
         }
     }
 
     encodeAll(it: Iterator = { offset: 0 }, buffer: Buffer = this.sharedBuffer) {
-        // console.log(`\nencodeAll(), this.root.allChanges (${this.root.allChanges.size})`);
+        // console.log(`\nencodeAll(), this.root.allChanges (${(Object.keys(this.root.allChanges).length)})`);
         // this.debugChanges("allChanges");
 
-        return this.encode(it, undefined, buffer, this.root.allChanges, true);
+        return this.encode(it, undefined, buffer, "allChanges", true);
     }
 
     encodeAllView(view: StateView, sharedOffset: number, it: Iterator, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;
 
-        // console.log(`\nencodeAllView(), this.root.allFilteredChanges (${this.root.allFilteredChanges.size})`);
+        // console.log(`\nencodeAllView(), this.root.allFilteredChanges (${(Object.keys(this.root.allFilteredChanges).length)})`);
         // this.debugChanges("allFilteredChanges");
 
+        // console.log("\n\nENCODE ALL FOR VIEW...\n\n")
+
         // try to encode "filtered" changes
-        this.encode(it, view, bytes, this.root.allFilteredChanges, true, viewOffset);
+        this.encode(it, view, bytes, "allFilteredChanges", true, viewOffset);
 
         return Buffer.concat([
             bytes.subarray(0, sharedOffset),
@@ -185,23 +200,24 @@ export class Encoder<T extends Schema = any> {
         ]);
     }
 
-    debugChanges(
-        field:  "changes" | "allFilteredChanges" | "allChanges" | "filteredChanges" | Map<ChangeTree, Map<number, OPERATION>>
-    ) {
-        const changeSet = (typeof (field) === "string")
+    debugChanges(field: "changes" | "allFilteredChanges" | "allChanges" | "filteredChanges") {
+        const rootChangeSet = (typeof (field) === "string")
             ? this.root[field]
             : field;
 
-        Array.from(changeSet.entries()).map((item) => {
-            const metadata: Metadata = item[0].ref.constructor[Symbol.metadata];
-            console.log("->", { ref: item[0].ref.constructor.name, refId: item[0].refId, changes: item[1].size });
-            item[1].forEach((op, index) => {
+        rootChangeSet.forEach((changeTree) => {
+            const changeSet = changeTree[field];
+
+            const metadata: Metadata = changeTree.ref.constructor[Symbol.metadata];
+            console.log("->", { ref: changeTree.ref.constructor.name, refId: changeTree.refId, changes: Object.keys(changeSet).length });
+            for (const index in changeSet) {
+                const op = changeSet[index];
                 console.log("  ->", {
                     index,
                     field: metadata?.[index],
                     op: OPERATION[op],
                 });
-            });
+            }
         });
     }
 
@@ -215,28 +231,38 @@ export class Encoder<T extends Schema = any> {
         // this.debugChanges("filteredChanges");
 
         // encode visibility changes (add/remove for this view)
-        const viewChangesIterator = view.changes.entries();
-        for (const [changeTree, changes] of viewChangesIterator) {
-            if (changes.size === 0) {
-                // FIXME: avoid having empty changes if no changes were made
-                // console.log("changes.size === 0", changeTree.ref.constructor.name);
+        const refIds = Object.keys(view.changes);
+        // console.log("ENCODE VIEW:", refIds);
+        for (let i = 0, numRefIds = refIds.length; i < numRefIds; i++) {
+            const refId = refIds[i];
+            const changes = view.changes[refId];
+            const changeTree = this.root.changeTrees[refId];
+
+            if (
+                changeTree === undefined ||
+                Object.keys(changes).length === 0 // FIXME: avoid having empty changes if no changes were made
+            ) {
+                // console.log("changes.size === 0, skip", changeTree.ref.constructor.name);
                 continue;
             }
 
             const ref = changeTree.ref;
 
-            const ctor = ref['constructor'];
+            const ctor = ref.constructor;
             const encoder = ctor[$encoder];
+            const metadata = ctor[Symbol.metadata];
 
             bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
             encode.number(bytes, changeTree.refId, it);
 
-            const changesIterator = changes.entries();
+            const keys = Object.keys(changes);
+            for (let i = 0, numChanges = keys.length; i < numChanges; i++) {
+                const key = keys[i];
+                const operation = changes[key];
 
-            for (const [fieldIndex, operation] of changesIterator) {
                 // isEncodeAll = false
                 // hasView = true
-                encoder(this, bytes, changeTree, fieldIndex, operation, it, false, true);
+                encoder(this, bytes, changeTree, Number(key), operation, it, false, true, metadata);
             }
         }
 
@@ -245,10 +271,12 @@ export class Encoder<T extends Schema = any> {
         // (to allow re-using StateView's for multiple clients)
         //
         // clear "view" changes after encoding
-        view.changes.clear();
+        view.changes = {};
+
+        // console.log("FILTERED CHANGES:", this.root.filteredChanges);
 
         // try to encode "filtered" changes
-        this.encode(it, view, bytes, this.root.filteredChanges, false, viewOffset);
+        this.encode(it, view, bytes, "filteredChanges", false, viewOffset);
 
         return Buffer.concat([
             bytes.subarray(0, sharedOffset),
@@ -257,30 +285,44 @@ export class Encoder<T extends Schema = any> {
     }
 
     onEndEncode(changeTrees = this.root.changes) {
-        const changeTreesIterator = changeTrees.entries();
-        for (const [changeTree, _] of changeTreesIterator) {
-            changeTree.endEncode();
-            // changeTree.changes.clear();
+        // changeTrees.forEach(function(changeTree) {
+        //     changeTree.endEncode();
+        // });
 
-            // // ArraySchema and MapSchema have a custom "encode end" method
-            // changeTree.ref[$onEncodeEnd]?.();
 
-            // // Not a new instance anymore
-            // delete changeTree[$isNew];
+        // for (const refId in changeTrees) {
+        //     const changeTree = this.root.changeTrees[refId];
+        //     changeTree.endEncode();
 
-        }
+        //     // changeTree.changes.clear();
+
+        //     // // ArraySchema and MapSchema have a custom "encode end" method
+        //     // changeTree.ref[$onEncodeEnd]?.();
+
+        //     // // Not a new instance anymore
+        //     // delete changeTree[$isNew];
+        // }
     }
 
     discardChanges() {
+        // console.log("DISCARD CHANGES!");
+
         // discard shared changes
-        if (this.root.changes.size > 0) {
-            this.onEndEncode(this.root.changes);
-            this.root.changes.clear();
+        let length = this.root.changes.length;
+        if (length > 0) {
+            while (length--) {
+                this.root.changes[length]?.endEncode();
+            }
+            this.root.changes.length = 0;
         }
+
         // discard filtered changes
-        if (this.root.filteredChanges.size > 0) {
-            this.onEndEncode(this.root.filteredChanges);
-            this.root.filteredChanges.clear();
+        length = this.root.filteredChanges.length;
+        if (length > 0) {
+            while (length--) {
+                this.root.filteredChanges[length]?.endEncode();
+            }
+            this.root.filteredChanges.length = 0;
         }
     }
 
@@ -288,6 +330,11 @@ export class Encoder<T extends Schema = any> {
         const baseTypeId = this.context.getTypeId(baseType);
         const targetTypeId = this.context.getTypeId(targetType);
 
+        if (targetTypeId === undefined) {
+            console.warn(`@colyseus/schema WARNING: Class "${targetType.name}" is not registered on TypeRegistry - Please either tag the class with @entity or define a @type() field.`);
+            return;
+        }
+
         if (baseTypeId !== targetTypeId) {
             bytes[it.offset++] = TYPE_ID & 255;
             encode.number(bytes, targetTypeId, it);

package/src/encoder/Root.ts

@@ -1,18 +1,21 @@
 import { OPERATION } from "../encoding/spec";
 import { TypeContext } from "../types/TypeContext";
-import { ChangeTree } from "./ChangeTree";
+import { spliceOne } from "../types/utils";
+import { ChangeTree, setOperationAtIndex } from "./ChangeTree";
 
 export class Root {
     protected nextUniqueId: number = 0;
-    refCount = new WeakMap<ChangeTree, number>();
+
+    refCount: {[id: number]: number} = {};
+    changeTrees: {[refId: number]: ChangeTree} = {};
 
     // all changes
-    allChanges = new Map<ChangeTree, Map<number, OPERATION>>();
-    allFilteredChanges = new Map<ChangeTree, Map<number, OPERATION>>();
+    allChanges: ChangeTree[] = [];
+    allFilteredChanges: ChangeTree[] = [];// TODO: do not initialize it if filters are not used
 
     // pending changes to be encoded
-    changes = new Map<ChangeTree, Map<number, OPERATION>>();
-    filteredChanges = new Map<ChangeTree, Map<number, OPERATION>>();
+    changes: ChangeTree[] = [];
+    filteredChanges: ChangeTree[] = [];// TODO: do not initialize it if filters are not used
 
     constructor(public types: TypeContext) { }
 
@@ -21,45 +24,53 @@ export class Root {
     }
 
     add(changeTree: ChangeTree) {
-        const previousRefCount = this.refCount.get(changeTree);
+        // FIXME: move implementation of `ensureRefId` to `Root` class
+        changeTree.ensureRefId();
+
+        const isNewChangeTree = (this.changeTrees[changeTree.refId] === undefined);
+        if (isNewChangeTree) { this.changeTrees[changeTree.refId] = changeTree; }
 
+        const previousRefCount = this.refCount[changeTree.refId];
         if (previousRefCount === 0) {
             //
             // When a ChangeTree is re-added, it means that it was previously removed.
             // We need to re-add all changes to the `changes` map.
             //
-            changeTree.allChanges.forEach((operation, index) => {
-                changeTree.changes.set(index, operation);
-            });
+            const ops = changeTree.allChanges.operations;
+            let len = ops.length;
+            while (len--) {
+                changeTree.indexedOperations[ops[len]] = OPERATION.ADD;
+                setOperationAtIndex(changeTree.changes, len);
+            }
         }
 
-        const refCount = (previousRefCount || 0) + 1;
-        this.refCount.set(changeTree, refCount);
+        this.refCount[changeTree.refId] = (previousRefCount || 0) + 1;
 
-        return refCount;
+        return isNewChangeTree;
     }
 
     remove(changeTree: ChangeTree) {
-        const refCount = (this.refCount.get(changeTree)) - 1;
+        const refCount = (this.refCount[changeTree.refId]) - 1;
 
         if (refCount <= 0) {
             //
             // Only remove "root" reference if it's the last reference
             //
             changeTree.root = undefined;
+            delete this.changeTrees[changeTree.refId];
 
-            this.allChanges.delete(changeTree);
-            this.changes.delete(changeTree);
+            this.removeChangeFromChangeSet("allChanges", changeTree);
+            this.removeChangeFromChangeSet("changes", changeTree);
 
             if (changeTree.isFiltered || changeTree.isPartiallyFiltered) {
-                this.allFilteredChanges.delete(changeTree);
-                this.filteredChanges.delete(changeTree);
+                this.removeChangeFromChangeSet("allFilteredChanges", changeTree);
+                this.removeChangeFromChangeSet("filteredChanges", changeTree);
             }
 
-            this.refCount.set(changeTree, 0);
+            this.refCount[changeTree.refId] = 0;
 
         } else {
-            this.refCount.set(changeTree, refCount);
+            this.refCount[changeTree.refId] = refCount;
         }
 
         changeTree.forEachChild((child, _) => this.remove(child));
@@ -67,7 +78,16 @@ export class Root {
         return refCount;
     }
 
+    removeChangeFromChangeSet(changeSetName: "allChanges" | "changes" | "filteredChanges" | "allFilteredChanges", changeTree: ChangeTree) {
+        const changeSet = this[changeSetName];
+        const index = changeSet.indexOf(changeTree);
+        if (index !== -1) {
+            spliceOne(changeSet, index);
+            // changeSet[index] = undefined;
+        }
+    }
+
     clear() {
-        this.changes.clear();
+        this.changes.length = 0;
     }
 }

package/src/encoder/StateView.ts

@@ -1,11 +1,11 @@
-import { ChangeTree, Ref } from "./ChangeTree";
-import { $changes } from "../types/symbols";
+import { ChangeSet, ChangeTree, IndexedOperations, Ref } from "./ChangeTree";
+import { $changes, $fieldIndexesByViewTag, $viewFieldIndexes } from "../types/symbols";
 import { DEFAULT_VIEW_TAG } from "../annotations";
 import { OPERATION } from "../encoding/spec";
 import { Metadata } from "../Metadata";
-import type { Schema } from "../Schema";
 
-export function createView(root: Schema) {
+export function createView() {
+    return new StateView();
 }
 
 export class StateView {
@@ -25,7 +25,7 @@ export class StateView {
      * 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<ChangeTree, Map<number, OPERATION>>();
+    changes: { [refId: number]: IndexedOperations } = {};
 
     // TODO: allow to set multiple tags at once
     add(obj: Ref, tag: number = DEFAULT_VIEW_TAG, checkIncludeParent: boolean = true) {
@@ -50,10 +50,10 @@ export class StateView {
         // TODO: when adding an item of a MapSchema, the changes may not
         // be set (only the parent's changes are set)
         //
-        let changes = this.changes.get(changeTree);
+        let changes = this.changes[changeTree.refId];
         if (changes === undefined) {
-            changes = new Map<number, OPERATION>();
-            this.changes.set(changeTree, changes)
+            changes = {};
+            this.changes[changeTree.refId] = changes;
         }
 
         // set tag
@@ -71,9 +71,9 @@ export class StateView {
             tags.add(tag);
 
             // Ref: add tagged properties
-            metadata?.[-3]?.[tag]?.forEach((index) => {
+            metadata?.[$fieldIndexesByViewTag]?.[tag]?.forEach((index) => {
                 if (changeTree.getChange(index) !== OPERATION.DELETE) {
-                    changes.set(index, OPERATION.ADD)
+                    changes[index] = OPERATION.ADD;
                 }
             });
 
@@ -83,7 +83,11 @@ export class StateView {
                 ? changeTree.allFilteredChanges
                 : changeTree.allChanges;
 
-            changeSet.forEach((op, index) => {
+            for (let i = 0, len = changeSet.operations.length; i < len; i++) {
+                const index = changeSet.operations[i];
+                if (index === undefined) { continue; } // skip "undefined" indexes
+
+                const op = changeTree.indexedOperations[index];
                 const tagAtIndex = metadata?.[index].tag;
                 if (
                     (
@@ -93,9 +97,9 @@ export class StateView {
                     ) &&
                     op !== OPERATION.DELETE
                 ) {
-                    changes.set(index, op);
+                    changes[index] = op;
                 }
-            });
+            }
         }
 
         // Add children of this ChangeTree to this view
@@ -128,10 +132,10 @@ export class StateView {
         // add parent's tag properties
         if (changeTree.getChange(parentIndex) !== OPERATION.DELETE) {
 
-            let changes = this.changes.get(changeTree);
+            let changes = this.changes[changeTree.refId];
             if (changes === undefined) {
-                changes = new Map<number, OPERATION>();
-                this.changes.set(changeTree, changes);
+                changes = {};
+                this.changes[changeTree.refId] = changes;
             }
 
             if (!this.tags) {
@@ -147,7 +151,7 @@ export class StateView {
             }
             tags.add(tag);
 
-            changes.set(parentIndex, OPERATION.ADD);
+            changes[parentIndex] = OPERATION.ADD;
         }
     }
 
@@ -163,10 +167,10 @@ export class StateView {
         const ref = changeTree.ref;
         const metadata: Metadata = ref.constructor[Symbol.metadata];
 
-        let changes = this.changes.get(changeTree);
+        let changes = this.changes[changeTree.refId];
         if (changes === undefined) {
-            changes = new Map<number, OPERATION>();
-            this.changes.set(changeTree, changes);
+            changes = {};
+            this.changes[changeTree.refId] = changes;
         }
 
         if (tag === DEFAULT_VIEW_TAG) {
@@ -174,25 +178,25 @@ export class StateView {
             const parent = changeTree.parent;
             if (!Metadata.isValidInstance(parent)) {
                 const parentChangeTree = parent[$changes];
-                let changes = this.changes.get(parentChangeTree);
+                let changes = this.changes[parentChangeTree.refId];
                 if (changes === undefined) {
-                    changes = new Map<number, OPERATION>();
-                    this.changes.set(parentChangeTree, changes)
+                    changes = {};
+                    this.changes[parentChangeTree.refId] = changes;
                 }
                 // DELETE / DELETE BY REF ID
-                changes.set(changeTree.parentIndex, OPERATION.DELETE);
+                changes[changeTree.parentIndex] = OPERATION.DELETE;
 
             } else {
                 // delete all "tagged" properties.
-                metadata[-2].forEach((index) =>
-                    changes.set(index, OPERATION.DELETE));
+                metadata[$viewFieldIndexes].forEach((index) =>
+                    changes[index] = OPERATION.DELETE);
             }
 
 
         } else {
             // delete only tagged properties
-            metadata[-3][tag].forEach((index) =>
-                changes.set(index, OPERATION.DELETE));
+            metadata[$fieldIndexesByViewTag][tag].forEach((index) =>
+                changes[index] = OPERATION.DELETE);
         }
 
         // remove tag

package/src/encoding/encode.ts

@@ -68,21 +68,24 @@ export function utf8Write(view: BufferLike, str: string, it: Iterator) {
       view[it.offset++] = c;
     }
     else if (c < 0x800) {
-      view[it.offset++] = 0xc0 | (c >> 6);
-      view[it.offset++] = 0x80 | (c & 0x3f);
+      view[it.offset] = 0xc0 | (c >> 6);
+      view[it.offset + 1] = 0x80 | (c & 0x3f);
+      it.offset += 2;
     }
     else if (c < 0xd800 || c >= 0xe000) {
-      view[it.offset++] = 0xe0 | (c >> 12);
-      view[it.offset++] = 0x80 | (c >> 6 & 0x3f);
-      view[it.offset++] = 0x80 | (c & 0x3f);
+      view[it.offset] = 0xe0 | (c >> 12);
+      view[it.offset+1] = 0x80 | (c >> 6 & 0x3f);
+      view[it.offset+2] = 0x80 | (c & 0x3f);
+      it.offset += 3;
     }
     else {
       i++;
       c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
-      view[it.offset++] = 0xf0 | (c >> 18);
-      view[it.offset++] = 0x80 | (c >> 12 & 0x3f);
-      view[it.offset++] = 0x80 | (c >> 6 & 0x3f);
-      view[it.offset++] = 0x80 | (c & 0x3f);
+      view[it.offset] = 0xf0 | (c >> 18);
+      view[it.offset+1] = 0x80 | (c >> 12 & 0x3f);
+      view[it.offset+2] = 0x80 | (c >> 6 & 0x3f);
+      view[it.offset+3] = 0x80 | (c & 0x3f);
+      it.offset += 4;
     }
   }
 }

package/src/types/TypeContext.ts

@@ -1,5 +1,6 @@
 import { Metadata } from "../Metadata";
 import { Schema } from "../Schema";
+import { $viewFieldIndexes } from "./symbols";
 
 export class TypeContext {
     types: { [id: number]: typeof Schema; } = {};
@@ -76,7 +77,7 @@ export class TypeContext {
         const metadata: Metadata = (klass[Symbol.metadata] ??= {});
 
         // if any schema/field has filters, mark "context" as having filters.
-        if (metadata[-2]) {
+        if (metadata[$viewFieldIndexes]) {
             this.hasFilters = true;
         }