@colyseus/schema 5.0.2 → 5.0.4

package/build/Metadata.d.ts

@@ -88,6 +88,13 @@ export declare const Metadata: {
      */
     setStreamPriority(metadata: Metadata, fieldName: string, fn: (view: any, element: any) => number): void;
     getStreamPriority(metadata: Metadata | undefined, index: number): (view: any, element: any) => number;
+    /**
+     * 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): void;
     setFields<T extends {
         new (...args: any[]): InstanceType<T>;
     } = any>(target: T, fields: { [field in keyof InstanceType<T>]?: DefinitionType; }): T;

package/build/Reflection.d.ts

@@ -25,6 +25,22 @@ 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;
 }
 /**
  * Reflection

package/build/codegen/cli.cjs

@@ -683,10 +683,33 @@ ${generateClassBody$8(klass, indent)}
 ${namespace ? "}" : ""}
 `;
 }
+/**
+ * Check if all enum members resolve to non-negative integers,
+ * allowing emission as a native C# `enum` (which only supports integral types).
+ */
+function canUseNativeEnum(_enum) {
+    return _enum.properties.every((prop) => {
+        if (!prop.type)
+            return true;
+        const n = Number(prop.type);
+        return Number.isInteger(n) && n >= 0;
+    });
+}
 /**
  * Generate just the enum body (without imports/namespace) for bundling
  */
 function generateEnumBody$1(_enum, indent = "") {
+    if (canUseNativeEnum(_enum)) {
+        const members = _enum.properties
+            .map((prop, i) => {
+            const value = prop.type ? Number(prop.type) : i;
+            return `${indent}\t${prop.name} = ${value},`;
+        })
+            .join("\n");
+        return `${indent}public enum ${_enum.name} : int {
+${members}
+${indent}}`;
+    }
     return `${indent}public struct ${_enum.name} {
 
 ${_enum.properties