@colyseus/schema 4.0.23 → 4.0.25

package/package.json

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

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";
 
@@ -403,13 +404,27 @@ export class ChangeTree<T extends Ref = any> {
             return;
         }
 
-        const changeSet = (this.filteredChanges !== undefined)
+        // Mirror `change()`: a field's add/delete must target the same
+        // changeset family (filtered vs non-filtered). Otherwise
+        // `deleteOperationAtIndex` falls through to its "find last
+        // operation" branch and evicts an unrelated sibling field —
+        // surfaced as encodeAll() dropping a non-@view field after a
+        // sibling @view field is set to undefined on a Schema with
+        // mixed @view / non-@view fields (filteredChanges defined,
+        // isFiltered false).
+        const isFiltered = this.isFiltered || (this.metadata?.[index]?.tag !== undefined);
+        const changeSet = (isFiltered)
             ? this.filteredChanges
             : this.changes;
 
         this.indexedOperations[index] = operation ?? OPERATION.DELETE;
         setOperationAtIndex(changeSet, index);
-        deleteOperationAtIndex(this.allChanges, allChangesIndex);
+
+        if (isFiltered) {
+            deleteOperationAtIndex(this.allFilteredChanges, allChangesIndex);
+        } else {
+            deleteOperationAtIndex(this.allChanges, allChangesIndex);
+        }
 
         const previousValue = this.getValue(index);
 
@@ -428,13 +443,8 @@ export class ChangeTree<T extends Ref = any> {
             this.root?.remove(previousValue[$changes]);
         }
 
-        //
-        // FIXME: this is looking a ugly and repeated
-        //
-        if (this.filteredChanges !== undefined) {
-            deleteOperationAtIndex(this.allFilteredChanges, allChangesIndex);
+        if (isFiltered) {
             this.root?.enqueueChangeTree(this, 'filteredChanges');
-
         } else {
             this.root?.enqueueChangeTree(this, 'changes');
         }
@@ -561,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]
@@ -572,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) {