@colyseus/schema 4.0.20 → 4.0.22

package/build/encoder/Encoder.d.ts

@@ -16,6 +16,23 @@ export declare class Encoder<T extends Schema = any> {
     encodeAll(it?: Iterator, buffer?: Uint8Array): Uint8Array<ArrayBufferLike>;
     encodeAllView(view: StateView, sharedOffset: number, it: Iterator, bytes?: Uint8Array): Uint8Array<ArrayBufferLike>;
     encodeView(view: StateView, sharedOffset: number, it: Iterator, bytes?: Uint8Array): Uint8Array<ArrayBufferLike>;
+    /**
+     * Produce a topological ordering of `view.changes` keys so each refId
+     * is preceded by any ancestor that's also in the same view's changeset.
+     *
+     * The wire stream uses SWITCH_TO_STRUCTURE pointers; if a child is
+     * encoded before any earlier op has introduced its refId on the
+     * decoder, decode fails with "refId not found". An entry's refId can
+     * only be introduced by an ADD on one of its ancestors — so any
+     * ancestor that itself appears in this view's pending changes must
+     * be encoded first.
+     *
+     * Implementation: DFS post-order over the parent chain. The `visited`
+     * Set guards against duplicates; cycles are not expected in a
+     * well-formed parent chain but the visited check is a cheap safety
+     * net. Cost is O(n × d) for n entries with parent-chain depth d.
+     */
+    protected topoOrderViewChanges(view: StateView): number[];
     discardChanges(): void;
     tryEncodeTypeId(bytes: Uint8Array, baseType: typeof Schema, targetType: typeof Schema, it: Iterator): void;
     get hasChanges(): boolean;

package/build/encoder/StateView.d.ts

@@ -21,7 +21,33 @@ export declare class StateView {
      * (This is used to force encoding a property, even if it was not changed)
      */
     changes: Map<number, IndexedOperations>;
+    /**
+     * Set when an operation may have left `changes` out of topological
+     * order (a parent that needs to be encoded before its descendants is
+     * positioned after them in the Map). `Encoder.encodeView` consults
+     * this flag and only runs the topo-ordering pass when it's true,
+     * skipping the work in the common case where insertion order already
+     * coincides with topo order.
+     *
+     * Only `remove()` can break the invariant: it writes entries that
+     * bypass `addParentOf`'s deepest-ancestor-first ordering. Everything
+     * else (including multi-parent re-adds) preserves order by
+     * construction. Reset to false at the end of each encodeView pass
+     * (when `changes` is cleared).
+     */
+    changesOutOfOrder: boolean;
     constructor(iterable?: boolean);
+    /**
+     * Get the IndexedOperations entry for `refId`, creating one if missing.
+     *
+     * Map insertion order alone doesn't guarantee parent-before-child
+     * iteration in all cases (a `view.remove()` followed by `view.add()`
+     * can put a child entry into the Map before its newly-visible
+     * ancestor). The wire-order invariant (parent SWITCH_TO_STRUCTURE
+     * before any of its children's) is enforced at encode time by
+     * `Encoder.encodeView` via a topological pass over `view.changes`.
+     */
+    protected touchChanges(refId: number): IndexedOperations;
     add(obj: Ref, tag?: number, checkIncludeParent?: boolean): boolean;
     protected addParentOf(childChangeTree: ChangeTree, tag: number): void;
     remove(obj: Ref, tag?: number): this;

package/build/index.cjs

@@ -1366,14 +1366,13 @@ class ChangeTree {
             || this.root.types.parentFiltered[key]
             || fieldHasViewTag;
         //
-        // "isFiltered" may not be imedialely available during `change()` due to the instance not being attached to the root yet.
+        // "isFiltered" may not be immediately available during `change()` due to the instance not being attached to the root yet.
         // when it's available, we need to enqueue the "changes" changeset into the "filteredChanges" changeset.
         //
         if (this.isFiltered) {
             this.isVisibilitySharedWithParent = (parentChangeTree.isFiltered &&
                 typeof (refType) !== "string" &&
-                !fieldHasViewTag &&
-                parentIsCollection);
+                !fieldHasViewTag);
             if (!this.filteredChanges) {
                 this.filteredChanges = createChangeSet();
                 this.allFilteredChanges = createChangeSet();
@@ -4390,8 +4389,25 @@ class Encoder {
     }
     encodeView(view, sharedOffset, it, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;
-        // encode visibility changes (add/remove for this view)
-        for (const [refId, changes] of view.changes) {
+        //
+        // Iterate `view.changes` in topological order so a refId is never
+        // SWITCH_TO_STRUCTURE'd before an earlier op has introduced it on
+        // the decoder. Map insertion order alone isn't sufficient: a
+        // sequence like view.remove(child) → view.add(child) on a child
+        // whose ancestor wasn't yet visible can put the child entry into
+        // the Map before its newly-visible ancestor.
+        //
+        // Hot-path optimization: `view.add` preserves topo order by
+        // construction (addParentOf walks deepest-ancestor-first before
+        // touching the obj's own entry). Only `view.remove` can leave the
+        // Map dirty. `StateView.changesOutOfOrder` tracks this so most
+        // encodes can iterate `view.changes` directly, paying nothing.
+        //
+        const orderedRefIds = view.changesOutOfOrder
+            ? this.topoOrderViewChanges(view)
+            : view.changes.keys();
+        for (const refId of orderedRefIds) {
+            const changes = view.changes.get(refId);
             const changeTree = this.root.changeTrees[refId];
             if (changeTree === undefined) {
                 // detached instance, remove from view and skip.
@@ -4427,10 +4443,53 @@ 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);
         return concatBytes(bytes.subarray(0, sharedOffset), bytes.subarray(viewOffset, it.offset));
     }
+    /**
+     * Produce a topological ordering of `view.changes` keys so each refId
+     * is preceded by any ancestor that's also in the same view's changeset.
+     *
+     * The wire stream uses SWITCH_TO_STRUCTURE pointers; if a child is
+     * encoded before any earlier op has introduced its refId on the
+     * decoder, decode fails with "refId not found". An entry's refId can
+     * only be introduced by an ADD on one of its ancestors — so any
+     * ancestor that itself appears in this view's pending changes must
+     * be encoded first.
+     *
+     * Implementation: DFS post-order over the parent chain. The `visited`
+     * Set guards against duplicates; cycles are not expected in a
+     * well-formed parent chain but the visited check is a cheap safety
+     * net. Cost is O(n × d) for n entries with parent-chain depth d.
+     */
+    topoOrderViewChanges(view) {
+        const result = [];
+        const visited = new Set();
+        const visit = (refId) => {
+            if (visited.has(refId)) {
+                return;
+            }
+            visited.add(refId);
+            const changeTree = this.root.changeTrees[refId];
+            if (changeTree !== undefined) {
+                let chain = changeTree.parentChain;
+                while (chain) {
+                    const parentRefId = chain.ref[$refId];
+                    if (parentRefId !== undefined && view.changes.has(parentRefId)) {
+                        visit(parentRefId);
+                    }
+                    chain = chain.next;
+                }
+            }
+            result.push(refId);
+        };
+        for (const refId of view.changes.keys()) {
+            visit(refId);
+        }
+        return result;
+    }
     discardChanges() {
         // discard shared changes
         let current = this.root.changes.next;
@@ -5502,12 +5561,45 @@ class StateView {
      * (This is used to force encoding a property, even if it was not changed)
      */
     changes = new Map();
+    /**
+     * Set when an operation may have left `changes` out of topological
+     * order (a parent that needs to be encoded before its descendants is
+     * positioned after them in the Map). `Encoder.encodeView` consults
+     * this flag and only runs the topo-ordering pass when it's true,
+     * skipping the work in the common case where insertion order already
+     * coincides with topo order.
+     *
+     * Only `remove()` can break the invariant: it writes entries that
+     * bypass `addParentOf`'s deepest-ancestor-first ordering. Everything
+     * else (including multi-parent re-adds) preserves order by
+     * construction. Reset to false at the end of each encodeView pass
+     * (when `changes` is cleared).
+     */
+    changesOutOfOrder = false;
     constructor(iterable = false) {
         this.iterable = iterable;
         if (iterable) {
             this.items = [];
         }
     }
+    /**
+     * Get the IndexedOperations entry for `refId`, creating one if missing.
+     *
+     * Map insertion order alone doesn't guarantee parent-before-child
+     * iteration in all cases (a `view.remove()` followed by `view.add()`
+     * can put a child entry into the Map before its newly-visible
+     * ancestor). The wire-order invariant (parent SWITCH_TO_STRUCTURE
+     * before any of its children's) is enforced at encode time by
+     * `Encoder.encodeView` via a topological pass over `view.changes`.
+     */
+    touchChanges(refId) {
+        let entry = this.changes.get(refId);
+        if (entry === undefined) {
+            entry = {};
+            this.changes.set(refId, entry);
+        }
+        return entry;
+    }
     // TODO: allow to set multiple tags at once
     add(obj, tag = DEFAULT_VIEW_TAG, checkIncludeParent = true) {
         const changeTree = obj?.[$changes];
@@ -5541,12 +5633,8 @@ class StateView {
         if (checkIncludeParent && parentChangeTree) {
             this.addParentOf(changeTree, tag);
         }
-        let changes = this.changes.get(obj[$refId]);
-        if (changes === undefined) {
-            changes = {};
-            // FIXME / OPTIMIZE: do not add if no changes are needed
-            this.changes.set(obj[$refId], changes);
-        }
+        // FIXME / OPTIMIZE: do not add if no changes are needed
+        const changes = this.touchChanges(obj[$refId]);
         let isChildAdded = false;
         //
         // Add children of this ChangeTree first.
@@ -5625,11 +5713,7 @@ class StateView {
         }
         // add parent's tag properties
         if (changeTree.getChange(parentIndex) !== exports.OPERATION.DELETE) {
-            let changes = this.changes.get(changeTree.ref[$refId]);
-            if (changes === undefined) {
-                changes = {};
-                this.changes.set(changeTree.ref[$refId], changes);
-            }
+            const changes = this.touchChanges(changeTree.ref[$refId]);
             if (!this.tags) {
                 this.tags = new WeakMap();
             }
@@ -5651,6 +5735,9 @@ class StateView {
             console.warn("StateView#remove(), invalid object:", obj);
             return this;
         }
+        // remove() bypasses addParentOf's ordering guarantee — flag the
+        // changeset as potentially out of topological order.
+        this.changesOutOfOrder = true;
         this.visible.delete(changeTree);
         // remove from iterable list
         if (this.iterable &&
@@ -5661,22 +5748,12 @@ class StateView {
         const ref = changeTree.ref;
         const metadata = ref.constructor[Symbol.metadata]; // ArraySchema/MapSchema do not have metadata
         const refId = ref[$refId];
-        let changes = this.changes.get(refId);
-        if (changes === undefined) {
-            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 parentRefId = parent[$refId];
-                let changes = this.changes.get(parentRefId);
-                if (changes === undefined) {
-                    changes = {};
-                    this.changes.set(parentRefId, changes);
-                }
-                else if (changes[changeTree.parentIndex] === exports.OPERATION.ADD) {
+                const parentChanges = this.touchChanges(parent[$refId]);
+                if (parentChanges[changeTree.parentIndex] === exports.OPERATION.ADD) {
                     //
                     // SAME PATCH ADD + REMOVE:
                     // The 'changes' of deleted structure should be ignored.
@@ -5684,12 +5761,13 @@ class StateView {
                     this.changes.delete(refId);
                 }
                 // DELETE / DELETE BY REF ID
-                changes[changeTree.parentIndex] = exports.OPERATION.DELETE;
+                parentChanges[changeTree.parentIndex] = exports.OPERATION.DELETE;
                 // Remove child schema from visible set
                 this._recursiveDeleteVisibleChangeTree(changeTree);
             }
             else {
                 // delete all "tagged" properties.
+                const changes = this.touchChanges(refId);
                 metadata?.[$viewFieldIndexes]?.forEach((index) => {
                     changes[index] = exports.OPERATION.DELETE;
                     // Remove child structures of @view() fields from visible set.
@@ -5704,6 +5782,7 @@ class StateView {
         }
         else {
             // delete only tagged properties
+            const changes = this.touchChanges(refId);
             metadata?.[$fieldIndexesByViewTag][tag].forEach((index) => {
                 changes[index] = exports.OPERATION.DELETE;
                 // Remove child structures from visible set