@colyseus/schema 5.0.14 → 5.0.19

package/src/types/custom/ArraySchema.ts

@@ -178,7 +178,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V>, IR
         const proxy = new Proxy(this, ARRAY_PROXY_HANDLER);
 
         Object.defineProperty(this, $changes, {
-            value: new ChangeTree(proxy),
+            value: new ChangeTree(proxy, this),
             enumerable: false,
             writable: true,
         });
@@ -486,7 +486,22 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V>, IR
     // @ts-ignore
     reverse(): ArraySchema<V> {
         const self = this[$proxyTarget];
-        self[$changes].operation(OPERATION.REVERSE);
+        const changeTree = self[$changes];
+
+        if (changeTree.has() || self.deletedIndexes.length > 0) {
+            //
+            // Ops recorded earlier this tick address the staged (pre-reverse)
+            // layout, and the encoder only resolves their values at encode
+            // time — a pure REVERSE would move that layout under them.
+            // Degrade to a full re-state: CLEAR + re-ADD in reversed order.
+            //
+            const reversed = self.items.slice().reverse();
+            this.clear(); // also drops staged holes (discard → $onEncodeEnd)
+            this.push(...reversed);
+            return this;
+        }
+
+        changeTree.operation(OPERATION.REVERSE);
         self.items.reverse();
         self.tmpItems.reverse();
         self.$reindexChildren(0);
@@ -602,13 +617,13 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V>, IR
 
         // insert operations
         if (insertCount > 0) {
-            if (insertCount > deleteCount) {
-                console.error("Inserting more elements than deleting during ArraySchema#splice()");
-                throw new Error("ArraySchema#splice(): insertCount must be equal or lower than deleteCount.");
-            }
+            const base = indexes[start] ?? itemsLength;
 
-            for (let i = 0; i < insertCount; i++) {
-                const addIndex = (indexes[start] ?? itemsLength) + i;
+            // the first `reuse` items take over the wire slots just deleted
+            const reuse = Math.min(insertCount, deleteCount);
+
+            for (let i = 0; i < reuse; i++) {
+                const addIndex = base + i;
 
                 changeTree.indexedOperation(
                     addIndex,
@@ -617,9 +632,36 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V>, IR
                         : OPERATION.ADD
                 );
 
+                // the slot is live again — the staged snapshot must carry the
+                // new value, or `$getByIndex` falls back to `items[addIndex]`
+                // and resolves an unrelated element once tmp/items diverge.
+                tmpItems[addIndex] = insertItems[i];
+                deletedIndexes[addIndex] = false;
+
                 // set value's parent/root — use `this` (Proxy) as parent.
                 insertItems[i][$changes]?.setParent(this, changeTree.root, addIndex);
             }
+
+            // ...the rest have no slot to take: widen the wire layout, same as
+            // unshift() but at `at` instead of 0.
+            const extra = insertCount - reuse;
+            if (extra > 0) {
+                const at = base + reuse;
+
+                changeTree.insertAt(at, extra);
+
+                for (let i = 0; i < extra; i++) {
+                    insertItems[reuse + i][$changes]?.setParent(this, changeTree.root, at + i);
+                }
+
+                // keep staged-delete flags aligned with the inserted tmp slots
+                if (deletedIndexes.length > 0) {
+                    deletedIndexes.splice(at, 0, ...new Array(extra).fill(false));
+                }
+
+                tmpItems.splice(at, 0, ...insertItems.slice(reuse));
+                self.$reindexChildren(at + extra); // survivors only — the loop above placed the new items
+            }
         }
 
         changeTree.root?.enqueueChangeTree(changeTree);
@@ -969,15 +1011,16 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V>, IR
     }
 
     protected [$onEncodeEnd]() {
-        const self = this[$proxyTarget] ?? this;
-        const staged = self.tmpItems;
-        self.tmpItems = self.items.slice();
+        // No unwrap: ChangeTree's gated sites are the only callers and they
+        // invoke on `refTarget` (the raw target) already.
+        const staged = this.tmpItems;
+        this.tmpItems = this.items.slice();
 
-        if (self.deletedIndexes.length > 0) {
+        if (this.deletedIndexes.length > 0) {
             // compaction just closed the staged holes — everything above the
             // lowest one slid down a slot
-            self.$reindexChildren(0, staged);
-            self.deletedIndexes.length = 0;
+            this.$reindexChildren(0, staged);
+            this.deletedIndexes.length = 0;
         }
     }
 

package/src/types/symbols.ts

@@ -131,6 +131,9 @@ export const $viewFieldIndexes = "~__viewFieldIndexes";
 export const $fieldIndexesByViewTag = "$__fieldIndexesByViewTag";
 export const $unreliableFieldIndexes = "~__unreliableFieldIndexes";
 export const $patchOnlyFieldIndexes = "~__patchOnlyFieldIndexes";
+// @patchOnly ∪ @deprecated() — indexes the full-sync walk must not read (the
+// deprecated accessor may throw). Maintained at decoration time.
+export const $fullSyncSkipIndexes = "~__fullSyncSkipIndexes";
 export const $fullStateOnlyFieldIndexes = "~__fullStateOnlyFieldIndexes";
 export const $streamFieldIndexes = "~__streamFieldIndexes";
 export const $streamPriorities = "~__streamPriorities";