@colyseus/schema 4.0.24 → 4.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/schema",
-  "version": "4.0.24",
+  "version": "4.0.26",
   "description": "Binary state serializer with delta encoding for games",
   "type": "module",
   "bin": {

package/src/Metadata.ts

@@ -161,11 +161,24 @@ export const Metadata = {
 
         metadata[$viewFieldIndexes].push(index);
 
-        if (!metadata[$fieldIndexesByViewTag][tag]) {
-            metadata[$fieldIndexesByViewTag][tag] = [];
+        // Populate $fieldIndexesByViewTag: for a bitmask tag, register the field
+        // index under each individual set bit so that view.add(obj, Tag.ONE) finds
+        // fields tagged @view(Tag.ONE|Tag.TWO).
+        // Negative tags (i.e. DEFAULT_VIEW_TAG = -1) are stored as-is.
+        if (tag < 0) {
+            if (!metadata[$fieldIndexesByViewTag][tag]) {
+                metadata[$fieldIndexesByViewTag][tag] = [];
+            }
+            metadata[$fieldIndexesByViewTag][tag].push(index);
+        } else {
+            for (let bits = tag; bits > 0; bits &= bits - 1) {
+                const bit = bits & (-bits); // isolate lowest set bit
+                if (!metadata[$fieldIndexesByViewTag][bit]) {
+                    metadata[$fieldIndexesByViewTag][bit] = [];
+                }
+                metadata[$fieldIndexesByViewTag][bit].push(index);
+            }
         }
-
-        metadata[$fieldIndexesByViewTag][tag].push(index);
     },
 
     setFields<T extends { new (...args: any[]): InstanceType<T> } = any>(target: T, fields: { [field in keyof InstanceType<T>]?: DefinitionType }) {

package/src/Schema.ts

@@ -85,9 +85,10 @@ export class Schema<C = any> implements IRef {
             return view.isChangeTreeVisible(ref[$changes]);
 
         } else {
-            // view pass: custom tag
+            // view pass: custom tag (bitmask)
+            // tag is the field's stored bitmask; view.tags stores the accumulated bitmask of tags used in view.add().
             const tags = view.tags?.get(ref[$changes]);
-            return tags && tags.has(tag);
+            return tags != null && (tag & tags) !== 0;
         }
     }
 

package/src/decoder/DecodeOperation.ts

@@ -108,18 +108,27 @@ export function decodeValue<T extends Ref>(
             let previousRefId = previousValue[$refId];
 
             if (previousRefId !== undefined && refId !== previousRefId) {
+                // Collection field replaced by a different instance.
                 //
-                // enqueue onRemove if structure has been replaced.
-                //
+                // Don't decrement children here: GC (`garbageCollectDeletedRefs`)
+                // removes them once the previous collection's refId hits zero.
+                // Doing it here too would double-decrement a *shared* child and
+                // drop it while still referenced ("refId not found").
+                if ((operation & OPERATION.DELETE) !== OPERATION.DELETE) {
+                    // Replacement not tagged DELETE (e.g. pending ADD not upgraded
+                    // to DELETE_AND_ADD), so the previous refId wasn't decremented
+                    // above. Release it here, else it never gets GC'd (leak).
+                    $root.removeRef(previousRefId);
+                }
+
+                // enqueue onRemove callbacks for the previous collection's children.
                 const entries: IterableIterator<[any, any]> = (previousValue as any).entries();
                 let iter: IteratorResult<[any, any]>;
                 while ((iter = entries.next()) && !iter.done) {
                     const [key, value] = iter.value;
 
-                    // if value is a schema, remove its reference
                     if (typeof(value) === "object") {
                         previousRefId = value[$refId];
-                        $root.removeRef(previousRefId);
                     }
 
                     allChanges.push({

package/src/encoder/ChangeTree.ts

@@ -1,4 +1,5 @@
 import { OPERATION } from "../encoding/spec.js";
+import { DEFAULT_VIEW_TAG } from "../annotations.js";
 import { Schema } from "../Schema.js";
 import { $changes, $childType, $decoder, $onEncodeEnd, $encoder, $getByIndex, $refId, $refTypeFieldIndexes, $viewFieldIndexes, type $deleteByIndex } from "../types/symbols.js";
 
@@ -570,7 +571,8 @@ export class ChangeTree<T extends Ref = any> {
         }
         key += `-${parentIndex}`;
 
-        const fieldHasViewTag = Metadata.hasViewTagAtIndex(parentConstructor?.[Symbol.metadata], parentIndex);
+        const parentMetadata = parentConstructor?.[Symbol.metadata];
+        const fieldHasViewTag = Metadata.hasViewTagAtIndex(parentMetadata, parentIndex);
 
         this.isFiltered = parent[$changes].isFiltered // in case parent is already filtered
             || this.root.types.parentFiltered[key]
@@ -581,11 +583,23 @@ export class ChangeTree<T extends Ref = any> {
         // when it's available, we need to enqueue the "changes" changeset into the "filteredChanges" changeset.
         //
         if (this.isFiltered) {
-
+            //
+            // Children of a `@view(N)` collection (non-default tag) inherit
+            // visibility from their parent, so items pushed/set after the
+            // initial `view.add(state, N)` show up automatically.
+            //
+            // Default-tag `@view()` collections deliberately keep per-item
+            // gating — `view.add(item)` is required to opt each one in.
+            //
+            // The `parentMetadata[parentIndex].tag` access is safe inside
+            // this branch: the OR's short-circuit means we only reach it
+            // when `fieldHasViewTag` is true, which guarantees the metadata
+            // entry and its `tag` property exist.
+            //
             this.isVisibilitySharedWithParent = (
                 parentChangeTree.isFiltered &&
                 typeof (refType) !== "string" &&
-                !fieldHasViewTag
+                (!fieldHasViewTag || (parentIsCollection && parentMetadata[parentIndex].tag !== DEFAULT_VIEW_TAG))
             );
 
             if (!this.filteredChanges) {

package/src/encoder/StateView.ts

@@ -27,7 +27,7 @@ export class StateView {
      */
     invisible: WeakSet<ChangeTree> = new WeakSet<ChangeTree>();
 
-    tags?: WeakMap<ChangeTree, Set<number>>; // TODO: use bit manipulation instead of Set<number> ()
+    tags?: WeakMap<ChangeTree, number>; // bitmask of tags used to add each ChangeTree
 
     /**
      * Manual "ADD" operations for changes per ChangeTree, specific to this view.
@@ -130,10 +130,18 @@ export class StateView {
             // Do not ADD children that don't have the same tag
             if (
                 metadata &&
-                metadata[index].tag !== undefined &&
-                metadata[index].tag !== tag
+                metadata[index].tag !== undefined
             ) {
-                return;
+                const fieldTag = metadata[index].tag;
+                // DEFAULT_VIEW_TAG fields are visible to all clients.
+                // Custom-tagged fields are only visible when bits overlap,
+                // and never to default-tag clients.
+                const tagMatch = fieldTag === DEFAULT_VIEW_TAG ||
+                    (tag !== DEFAULT_VIEW_TAG && (fieldTag & tag) !== 0);
+                
+                if (!tagMatch) {
+                    return;
+                }
             }
 
             if (this.add(change.ref, tag, false)) {
@@ -144,16 +152,11 @@ export class StateView {
         // set tag
         if (tag !== DEFAULT_VIEW_TAG) {
             if (!this.tags) {
-                this.tags = new WeakMap<ChangeTree, Set<number>>();
-            }
-            let tags: Set<number>;
-            if (!this.tags.has(changeTree)) {
-                tags = new Set<number>();
-                this.tags.set(changeTree, tags);
-            } else {
-                tags = this.tags.get(changeTree);
+                this.tags = new WeakMap<ChangeTree, number>();
             }
-            tags.add(tag);
+            // Add tag bits into the bitmask stored for this ChangeTree.
+            const currentMask = this.tags.get(changeTree) ?? 0;
+            this.tags.set(changeTree, currentMask | tag);
 
             // Ref: add tagged properties
             metadata?.[$fieldIndexesByViewTag]?.[tag]?.forEach((index) => {
@@ -181,7 +184,7 @@ export class StateView {
                     (
                         isInvisible || // if "invisible", include all
                         tagAtIndex === undefined || // "all change" with no tag
-                        tagAtIndex === tag // tagged property
+                        (tagAtIndex === DEFAULT_VIEW_TAG || (tag !== DEFAULT_VIEW_TAG && (tagAtIndex & tag) !== 0)) // tagged property
                     )
                 ) {
                     changes[index] = op;
@@ -215,18 +218,16 @@ export class StateView {
         if (changeTree.getChange(parentIndex) !== OPERATION.DELETE) {
             const changes = this.touchChanges(changeTree.ref[$refId]);
 
-            if (!this.tags) {
-                this.tags = new WeakMap<ChangeTree, Set<number>>();
-            }
-
-            let tags: Set<number>;
-            if (!this.tags.has(changeTree)) {
-                tags = new Set<number>();
-                this.tags.set(changeTree, tags);
-            } else {
-                tags = this.tags.get(changeTree);
+            // Only accumulate positive (custom) tags in the bitmask.
+            // DEFAULT_VIEW_TAG = -1 has all bits set and must not be OR'd in,
+            // as it would make every custom-tagged field appear visible.
+            if (tag !== DEFAULT_VIEW_TAG) {
+                if (!this.tags) {
+                    this.tags = new WeakMap<ChangeTree, number>();
+                }
+                const currentMask = this.tags.has(changeTree) ? this.tags.get(changeTree) : 0;
+                this.tags.set(changeTree, currentMask | tag);
             }
-            tags.add(tag);
 
             changes[parentIndex] = OPERATION.ADD;
         }
@@ -313,17 +314,16 @@ export class StateView {
 
         // remove tag
         if (this.tags && this.tags.has(changeTree)) {
-            const tags = this.tags.get(changeTree);
             if (tag === undefined) {
                 // delete all tags
                 this.tags.delete(changeTree);
             } else {
-                // delete specific tag
-                tags.delete(tag);
-
-                // if tag set is empty, delete it entirely
-                if (tags.size === 0) {
+                // clear the tag's bits from the bitmask
+                const newMask = this.tags.get(changeTree) & ~tag;
+                if (newMask === 0) {
                     this.tags.delete(changeTree);
+                } else {
+                    this.tags.set(changeTree, newMask);
                 }
             }
         }
@@ -337,7 +337,7 @@ export class StateView {
 
     hasTag(ob: Ref, tag: number = DEFAULT_VIEW_TAG) {
         const tags = this.tags?.get(ob[$changes]);
-        return tags?.has(tag) ?? false;
+        return tags != null && (tags & tag) !== 0;
     }
 
     clear() {