@colyseus/schema 5.0.13 → 5.0.19

package/src/types/builder.ts

@@ -51,10 +51,11 @@ export type BuilderOf<T> = FieldBuilder<T>;
  *    Schema ref whose `initialize` takes zero args.
  *  - `IsOptional` is a compile-time brand for `.optional()`. Both
  *    `HasDefault` and `IsOptional` make the field omittable in
- *    `BuilderInitProps<T>`. A separate brand (rather than reading
- *    `undefined extends V`) sidesteps a TypeScript quirk where
- *    class-generic-inferred `V` resolves `undefined extends V` as `true`
- *    even for non-undefined types.
+ *    `BuilderInitProps<T>`; `IsOptional` alone marks the instance property
+ *    `?:`. A separate brand (rather than reading `undefined extends V`)
+ *    keeps both correct for consumers compiling with
+ *    `strictNullChecks: false`, where `undefined extends V` is true for
+ *    every V.
  *
  * schema() reads the internal configuration via `toDefinition()` and wires
  * up metadata through the existing pipeline.
@@ -289,8 +290,8 @@ export function isBuilder(value: any): value is FieldBuilder<any> {
  * Two call signatures, NOT a defaulted generic `<T extends TBase = TBase>`: the
  * bare form must return a CONCRETE `FieldBuilder<TBase>` so `schema({ x:
  * t.number() })` still infers `x: number`. A defaulted free type parameter gets
- * captured as `any` during `schema()`'s self-referential field inference (and
- * `undefined extends any` then flips every field optional).
+ * captured as `any` during `schema()`'s self-referential field inference,
+ * degrading every field's value type to `any`.
  *
  * NOTE: the refinement is a TYPE-LEVEL assertion, not a runtime guarantee — the
  * wire still carries the codec's full range and the DECODER writes whatever
@@ -306,16 +307,24 @@ function primitive<TBase>(name: RawPrimitiveType): PrimitiveFactory<TBase> {
     return (() => new FieldBuilder<TBase>(name)) as PrimitiveFactory<TBase>;
 }
 
-// Accepts a Schema class, a primitive string, or another FieldBuilder as a child type.
+// Collection element: a Schema class or a primitive type NAME (`"string"`).
 export type ChildType =
     | RawPrimitiveType
-    | Constructor<Schema>
-    | FieldBuilder<any>;
+    | Constructor<Schema>;
 
+/**
+ * Guard against `t.array(t.string())`. A builder child looks like it should
+ * work — and its bare `_type` would — but every modifier on it (`.view()`,
+ * `.default()`, quantize options) would be silently dropped, since modifiers
+ * describe the FIELD, not the elements. Fail loudly instead.
+ */
 function resolveChild(child: ChildType): DefinitionType {
     if (isBuilder(child)) {
-        // `_type` is private; element access bypasses the visibility check.
-        return child['_type'];
+        const inner = child['_type']; // private; element access bypasses the check
+        const hint = (typeof inner === "string")
+            ? `use the type name instead: t.array("${inner}")`
+            : `collections accept a Schema class or a primitive type name ("string", "number", …)`;
+        throw new Error(`t.array/map/set/collection(): a t.* builder is not a valid element type — ${hint}.`);
     }
     return child as DefinitionType;
 }
@@ -325,28 +334,24 @@ function resolveChild(child: ChildType): DefinitionType {
 // ---------------------------------------------------------------------------
 
 // Overloaded factories for collections. Implementation lives in a single function;
-// overloads narrow the return type for Schema/primitive/builder children.
+// overloads narrow the return type for Schema/primitive children.
 // All collection factories tag `HasDefault = true` because schema() auto-
 // instantiates an empty collection when no explicit default is given.
 interface ArrayFactory {
     <C extends Constructor<Schema>>(child: C): FieldBuilder<ArraySchema<InstanceType<C>>, true, false>;
     <P extends RawPrimitiveType>(child: P): FieldBuilder<ArraySchema<InferValueType<P>>, true, false>;
-    <V>(child: FieldBuilder<V>): FieldBuilder<ArraySchema<V>, true, false>;
 }
 interface MapFactory {
     <C extends Constructor<Schema>>(child: C): FieldBuilder<MapSchema<InstanceType<C>>, true, false>;
     <P extends RawPrimitiveType>(child: P): FieldBuilder<MapSchema<InferValueType<P>>, true, false>;
-    <V>(child: FieldBuilder<V>): FieldBuilder<MapSchema<V>, true, false>;
 }
 interface SetFactory {
     <C extends Constructor<Schema>>(child: C): FieldBuilder<SetSchema<InstanceType<C>>, true, false>;
     <P extends RawPrimitiveType>(child: P): FieldBuilder<SetSchema<InferValueType<P>>, true, false>;
-    <V>(child: FieldBuilder<V>): FieldBuilder<SetSchema<V>, true, false>;
 }
 interface CollectionFactory {
     <C extends Constructor<Schema>>(child: C): FieldBuilder<CollectionSchema<InstanceType<C>>, true, false>;
     <P extends RawPrimitiveType>(child: P): FieldBuilder<CollectionSchema<InferValueType<P>>, true, false>;
-    <V>(child: FieldBuilder<V>): FieldBuilder<CollectionSchema<V>, true, false>;
 }
 // t.stream(Entity) — priority-batched collection of Schema instances.
 // Element type is restricted to Schema subclasses (no primitives) because

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";