@colyseus/schema 5.0.2 → 5.0.3

package/package.json

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

package/src/Metadata.ts

@@ -329,6 +329,49 @@ export const Metadata = {
         return metadata?.[$streamPriorities]?.[index];
     },
 
+    /**
+     * Install a single field with full encoder wiring: accessor descriptor
+     * on the prototype + `metadata[$encoders]` slot for primitives. Shared
+     * between `Metadata.setFields` (build path) and
+     * `Reflection.makeEncodable` (Reflection upgrade path).
+     */
+    defineField(
+        target: any,
+        metadata: any,
+        fieldIndex: number,
+        fieldName: string,
+        type: DefinitionType,
+    ) {
+        const normalized = getNormalizedType(type);
+        const { complexTypeKlass, childType } = resolveFieldType(normalized);
+
+        Metadata.addField(
+            metadata,
+            fieldIndex,
+            fieldName,
+            normalized,
+            getPropertyDescriptor(fieldName, fieldIndex, childType, complexTypeKlass),
+        );
+
+        // Install accessor descriptor on the prototype (once per class field).
+        if (metadata[$descriptors][fieldName]) {
+            Object.defineProperty(target.prototype, fieldName, metadata[$descriptors][fieldName]);
+        }
+
+        // Pre-compute encoder function for primitive types.
+        if (typeof normalized === "string") {
+            if (!metadata[$encoders]) {
+                Object.defineProperty(metadata, $encoders, {
+                    value: [],
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
+            }
+            metadata[$encoders][fieldIndex] = (encode as any)[normalized];
+        }
+    },
+
     setFields<T extends { new (...args: any[]): InstanceType<T> } = any>(target: T, fields: { [field in keyof InstanceType<T>]?: DefinitionType }) {
         // for inheritance support
         const constructor = target.prototype.constructor;
@@ -364,28 +407,7 @@ export const Metadata = {
         }
 
         for (const field in fields) {
-            const type = getNormalizedType(fields[field]);
-
-            const { complexTypeKlass, childType } = resolveFieldType(type);
-
-            Metadata.addField(
-                metadata,
-                fieldIndex,
-                field,
-                type,
-                getPropertyDescriptor(field, fieldIndex, childType, complexTypeKlass)
-            );
-
-            // Install accessor descriptor on the prototype (once per class field).
-            if (metadata[$descriptors][field]) {
-                Object.defineProperty(target.prototype, field, metadata[$descriptors][field]);
-            }
-
-            // Pre-compute encoder function for primitive types.
-            if (typeof type === "string") {
-                metadata[$encoders][fieldIndex] = (encode as any)[type];
-            }
-
+            Metadata.defineField(constructor, metadata, fieldIndex, field, fields[field] as DefinitionType);
             fieldIndex++;
         }
 

package/src/Reflection.ts

@@ -7,6 +7,7 @@ import { Decoder } from "./decoder/Decoder.js";
 import { Schema } from "./Schema.js";
 import { t, FieldBuilder } from "./types/builder.js";
 import { ArraySchema } from "./types/custom/ArraySchema.js";
+import { $encodeDescriptor, $numFields } from "./types/symbols.js";
 
 /**
  * Static methods available on Reflection
@@ -29,6 +30,23 @@ interface ReflectionStatic {
      * @returns Decoder instance
      */
     decode: <T extends Schema = Schema>(bytes: Uint8Array, it?: Iterator) => Decoder<T>;
+
+    /**
+     * Upgrade a class produced by `Reflection.decode` so its instances
+     * can be used as encode sources (for `InputEncoder` or `Encoder`).
+     *
+     * `Reflection.decode` reconstructs classes with decoder-only field
+     * slots — `inst.x = 7` lands as a direct own property and bypasses
+     * the change-tracking + `$values` plumbing that encoders rely on.
+     * Calling `makeEncodable(ctor)` installs the same prototype accessor
+     * descriptors and `metadata[$encoders]` lookup table that the
+     * `schema(...)` / `@type` builders install at class-definition time.
+     *
+     * Idempotent. Pay-as-you-go: callers that only decode never invoke
+     * this and pay nothing extra. Must be called BEFORE any instance of
+     * the class is constructed and assigned to.
+     */
+    makeEncodable: (ctor: typeof Schema) => typeof Schema;
 }
 
 /**
@@ -249,4 +267,31 @@ Reflection.decode = function <T extends Schema = Schema>(bytes: Uint8Array, it?:
     const state: T = new (typeContext.get(reflection.rootType || 0) as unknown as any)();
 
     return new Decoder<T>(state, typeContext);
-}
+}
+
+Reflection.makeEncodable = function (ctor: typeof Schema): typeof Schema {
+    const metadata: any = (ctor as any)[Symbol.metadata];
+    if (!metadata) return ctor;
+
+    const numFields = metadata[$numFields];
+    if (numFields === undefined) return ctor;
+
+    // Walk every field index across the inheritance chain. Repeat calls
+    // are cheap: defineField overwrites the same descriptor and re-stamps
+    // the same `metadata[$encoders]` slot (idempotent).
+    for (let i = 0; i <= numFields; i++) {
+        const field = metadata[i];
+        if (!field) continue;
+        Metadata.defineField(ctor, metadata, i, field.name, field.type);
+    }
+
+    // Invalidate any cached encode descriptor — `getEncodeDescriptor`
+    // memoizes on the constructor. If something already constructed it
+    // (e.g. a prior `InputEncoder(...)` call that threw), drop the stale
+    // entry so the next read sees the upgraded metadata.
+    if (Object.prototype.hasOwnProperty.call(ctor, $encodeDescriptor)) {
+        delete (ctor as any)[$encodeDescriptor];
+    }
+
+    return ctor;
+};