@colyseus/schema 4.0.25 → 4.0.27

package/build/index.js

@@ -821,10 +821,25 @@
                 });
             }
             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(target, fields) {
             // for inheritance support
@@ -1680,17 +1695,25 @@
             if (previousValue) {
                 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 & exports.OPERATION.DELETE) !== exports.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 = previousValue.entries();
                     let iter;
                     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({
                             ref: previousValue,
@@ -3768,9 +3791,10 @@
                 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;
             }
         }
         // allow inherited classes to have a constructor
@@ -4380,41 +4404,43 @@
                     encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView, metadata);
                 }
             }
-            if (it.offset > buffer.byteLength) {
-                // 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:
+            if (it.offset <= buffer.byteLength) {
+                return buffer.subarray(0, it.offset);
+            }
+            // Overflowed: grow and re-encode. Reuse the same iterator so `it.offset`
+            // ends accurate — a fresh one strands it at the overflow value and
+            // corrupts the next view's `viewOffset` in a multi-view encode.
+            buffer = this.ensureCapacity(buffer, it.offset);
+            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";
-    Encoder.BUFFER_SIZE = ${Math.round(newSize / 1024)} * 1024; // ${Math.round(newSize / 1024)} KB
+    Encoder.BUFFER_SIZE = ${Math.round(buffer.byteLength / 1024)} * 1024; // ${Math.round(buffer.byteLength / 1024)} KB
 `);
-                //
-                // 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
-                //
-                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;
-                }
-                return this.encode({ offset: initialOffset }, view, buffer, changeSetName, isEncodeAll);
-            }
-            else {
-                return buffer.subarray(0, it.offset);
-            }
+            it.offset = initialOffset;
+            return this.encode(it, view, buffer, changeSetName, isEncodeAll);
         }
         encodeAll(it = { offset: 0 }, buffer = this.sharedBuffer) {
             return this.encode(it, undefined, buffer, "allChanges", true);
         }
         encodeAllView(view, sharedOffset, it, bytes = this.sharedBuffer) {
             const viewOffset = it.offset;
-            // try to encode "filtered" changes
-            this.encode(it, view, bytes, "allFilteredChanges", true, viewOffset);
+            // encode() may reallocate the buffer — keep its return, not the stale `bytes`.
+            bytes = this.encode(it, view, bytes, "allFilteredChanges", true, viewOffset);
             return concatBytes(bytes.subarray(0, sharedOffset), bytes.subarray(viewOffset, it.offset));
         }
+        /** Grow `buffer` to keep BUFFER_SIZE free bytes past `offset`, preserving `[0, offset)`. */
+        ensureCapacity(buffer, offset) {
+            if (offset + Encoder.BUFFER_SIZE <= buffer.byteLength) {
+                return buffer;
+            }
+            const size = Math.ceil((offset + Encoder.BUFFER_SIZE) / Encoder.BUFFER_SIZE) * Encoder.BUFFER_SIZE;
+            const grown = new Uint8Array(size);
+            grown.set(buffer.subarray(0, offset));
+            if (buffer === this.sharedBuffer) {
+                this.sharedBuffer = grown;
+            }
+            return grown;
+        }
         encodeView(view, sharedOffset, it, bytes = this.sharedBuffer) {
             const viewOffset = it.offset;
             //
@@ -4453,6 +4479,9 @@
                 const ctor = ref.constructor;
                 const encoder = ctor[$encoder];
                 const metadata = ctor[Symbol.metadata];
+                // These writes are unguarded and unrecoverable (view.changes is cleared
+                // below), so unlike encode() they can't re-encode on overflow — grow ahead.
+                bytes = this.ensureCapacity(bytes, it.offset);
                 bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
                 encode.number(bytes, ref[$refId], it);
                 for (let i = 0, numChanges = keys.length; i < numChanges; i++) {
@@ -4472,8 +4501,10 @@
             // clear "view" changes after encoding
             view.changes.clear();
             view.changesOutOfOrder = false;
-            // try to encode "filtered" changes
-            this.encode(it, view, bytes, "filteredChanges", false, viewOffset);
+            // encode() may reallocate the buffer — keep its return, not the stale `bytes`.
+            // Anchor the re-encode at the current offset (default), not `viewOffset`: a
+            // resize must not clobber the view.changes already written at [viewOffset, ).
+            bytes = this.encode(it, view, bytes, "filteredChanges", false);
             return concatBytes(bytes.subarray(0, sharedOffset), bytes.subarray(viewOffset, it.offset));
         }
         /**
@@ -5584,7 +5615,7 @@
          * List of ChangeTree's that are invisible to this view
          */
         invisible = new WeakSet();
-        tags; // TODO: use bit manipulation instead of Set<number> ()
+        tags; // bitmask of tags used to add each ChangeTree
         /**
          * 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)
@@ -5672,9 +5703,16 @@
             changeTree.forEachChild((change, index) => {
                 // Do not ADD children that don't have the same tag
                 if (metadata &&
-                    metadata[index].tag !== undefined &&
-                    metadata[index].tag !== tag) {
-                    return;
+                    metadata[index].tag !== undefined) {
+                    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)) {
                     isChildAdded = true;
@@ -5685,15 +5723,9 @@
                 if (!this.tags) {
                     this.tags = new WeakMap();
                 }
-                let tags;
-                if (!this.tags.has(changeTree)) {
-                    tags = new Set();
-                    this.tags.set(changeTree, tags);
-                }
-                else {
-                    tags = this.tags.get(changeTree);
-                }
-                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) => {
                     if (changeTree.getChange(index) !== exports.OPERATION.DELETE) {
@@ -5717,7 +5749,7 @@
                     if (op !== exports.OPERATION.DELETE &&
                         (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;
                         isChildAdded = true; // FIXME: assign only once
@@ -5743,18 +5775,16 @@
             // add parent's tag properties
             if (changeTree.getChange(parentIndex) !== exports.OPERATION.DELETE) {
                 const changes = this.touchChanges(changeTree.ref[$refId]);
-                if (!this.tags) {
-                    this.tags = new WeakMap();
-                }
-                let tags;
-                if (!this.tags.has(changeTree)) {
-                    tags = new Set();
-                    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();
+                    }
+                    const currentMask = this.tags.has(changeTree) ? this.tags.get(changeTree) : 0;
+                    this.tags.set(changeTree, currentMask | tag);
                 }
-                tags.add(tag);
                 changes[parentIndex] = exports.OPERATION.ADD;
             }
         }
@@ -5824,18 +5854,19 @@
             }
             // 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);
+                    }
                 }
             }
             return this;
@@ -5845,7 +5876,7 @@
         }
         hasTag(ob, tag = DEFAULT_VIEW_TAG) {
             const tags = this.tags?.get(ob[$changes]);
-            return tags?.has(tag) ?? false;
+            return tags != null && (tags & tag) !== 0;
         }
         clear() {
             if (!this.iterable) {

package/build/index.mjs

@@ -815,10 +815,25 @@ 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(target, fields) {
         // for inheritance support
@@ -1674,17 +1689,25 @@ function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges
         if (previousValue) {
             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 = previousValue.entries();
                 let iter;
                 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({
                         ref: previousValue,
@@ -3762,9 +3785,10 @@ class Schema {
             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;
         }
     }
     // allow inherited classes to have a constructor
@@ -4374,41 +4398,43 @@ class Encoder {
                 encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView, metadata);
             }
         }
-        if (it.offset > buffer.byteLength) {
-            // 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:
+        if (it.offset <= buffer.byteLength) {
+            return buffer.subarray(0, it.offset);
+        }
+        // Overflowed: grow and re-encode. Reuse the same iterator so `it.offset`
+        // ends accurate — a fresh one strands it at the overflow value and
+        // corrupts the next view's `viewOffset` in a multi-view encode.
+        buffer = this.ensureCapacity(buffer, it.offset);
+        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";
-    Encoder.BUFFER_SIZE = ${Math.round(newSize / 1024)} * 1024; // ${Math.round(newSize / 1024)} KB
+    Encoder.BUFFER_SIZE = ${Math.round(buffer.byteLength / 1024)} * 1024; // ${Math.round(buffer.byteLength / 1024)} KB
 `);
-            //
-            // 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
-            //
-            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;
-            }
-            return this.encode({ offset: initialOffset }, view, buffer, changeSetName, isEncodeAll);
-        }
-        else {
-            return buffer.subarray(0, it.offset);
-        }
+        it.offset = initialOffset;
+        return this.encode(it, view, buffer, changeSetName, isEncodeAll);
     }
     encodeAll(it = { offset: 0 }, buffer = this.sharedBuffer) {
         return this.encode(it, undefined, buffer, "allChanges", true);
     }
     encodeAllView(view, sharedOffset, it, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;
-        // try to encode "filtered" changes
-        this.encode(it, view, bytes, "allFilteredChanges", true, viewOffset);
+        // encode() may reallocate the buffer — keep its return, not the stale `bytes`.
+        bytes = this.encode(it, view, bytes, "allFilteredChanges", true, viewOffset);
         return concatBytes(bytes.subarray(0, sharedOffset), bytes.subarray(viewOffset, it.offset));
     }
+    /** Grow `buffer` to keep BUFFER_SIZE free bytes past `offset`, preserving `[0, offset)`. */
+    ensureCapacity(buffer, offset) {
+        if (offset + Encoder.BUFFER_SIZE <= buffer.byteLength) {
+            return buffer;
+        }
+        const size = Math.ceil((offset + Encoder.BUFFER_SIZE) / Encoder.BUFFER_SIZE) * Encoder.BUFFER_SIZE;
+        const grown = new Uint8Array(size);
+        grown.set(buffer.subarray(0, offset));
+        if (buffer === this.sharedBuffer) {
+            this.sharedBuffer = grown;
+        }
+        return grown;
+    }
     encodeView(view, sharedOffset, it, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;
         //
@@ -4447,6 +4473,9 @@ class Encoder {
             const ctor = ref.constructor;
             const encoder = ctor[$encoder];
             const metadata = ctor[Symbol.metadata];
+            // These writes are unguarded and unrecoverable (view.changes is cleared
+            // below), so unlike encode() they can't re-encode on overflow — grow ahead.
+            bytes = this.ensureCapacity(bytes, it.offset);
             bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
             encode.number(bytes, ref[$refId], it);
             for (let i = 0, numChanges = keys.length; i < numChanges; i++) {
@@ -4466,8 +4495,10 @@ class Encoder {
         // clear "view" changes after encoding
         view.changes.clear();
         view.changesOutOfOrder = false;
-        // try to encode "filtered" changes
-        this.encode(it, view, bytes, "filteredChanges", false, viewOffset);
+        // encode() may reallocate the buffer — keep its return, not the stale `bytes`.
+        // Anchor the re-encode at the current offset (default), not `viewOffset`: a
+        // resize must not clobber the view.changes already written at [viewOffset, ).
+        bytes = this.encode(it, view, bytes, "filteredChanges", false);
         return concatBytes(bytes.subarray(0, sharedOffset), bytes.subarray(viewOffset, it.offset));
     }
     /**
@@ -5578,7 +5609,7 @@ class StateView {
      * List of ChangeTree's that are invisible to this view
      */
     invisible = new WeakSet();
-    tags; // TODO: use bit manipulation instead of Set<number> ()
+    tags; // bitmask of tags used to add each ChangeTree
     /**
      * 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)
@@ -5666,9 +5697,16 @@ class StateView {
         changeTree.forEachChild((change, index) => {
             // Do not ADD children that don't have the same tag
             if (metadata &&
-                metadata[index].tag !== undefined &&
-                metadata[index].tag !== tag) {
-                return;
+                metadata[index].tag !== undefined) {
+                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)) {
                 isChildAdded = true;
@@ -5679,15 +5717,9 @@ class StateView {
             if (!this.tags) {
                 this.tags = new WeakMap();
             }
-            let tags;
-            if (!this.tags.has(changeTree)) {
-                tags = new Set();
-                this.tags.set(changeTree, tags);
-            }
-            else {
-                tags = this.tags.get(changeTree);
-            }
-            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) => {
                 if (changeTree.getChange(index) !== OPERATION.DELETE) {
@@ -5711,7 +5743,7 @@ class StateView {
                 if (op !== OPERATION.DELETE &&
                     (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;
                     isChildAdded = true; // FIXME: assign only once
@@ -5737,18 +5769,16 @@ class StateView {
         // add parent's tag properties
         if (changeTree.getChange(parentIndex) !== OPERATION.DELETE) {
             const changes = this.touchChanges(changeTree.ref[$refId]);
-            if (!this.tags) {
-                this.tags = new WeakMap();
-            }
-            let tags;
-            if (!this.tags.has(changeTree)) {
-                tags = new Set();
-                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();
+                }
+                const currentMask = this.tags.has(changeTree) ? this.tags.get(changeTree) : 0;
+                this.tags.set(changeTree, currentMask | tag);
             }
-            tags.add(tag);
             changes[parentIndex] = OPERATION.ADD;
         }
     }
@@ -5818,18 +5848,19 @@ 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);
+                }
             }
         }
         return this;
@@ -5839,7 +5870,7 @@ class StateView {
     }
     hasTag(ob, tag = DEFAULT_VIEW_TAG) {
         const tags = this.tags?.get(ob[$changes]);
-        return tags?.has(tag) ?? false;
+        return tags != null && (tags & tag) !== 0;
     }
     clear() {
         if (!this.iterable) {