@colyseus/schema 5.0.11 → 5.0.13

package/build/codegen/cli.cjs

@@ -172,11 +172,22 @@ class Enum {
         this.properties.push(property);
     }
 }
+/**
+ * Mirror of the runtime's `resolveQuantize()` scale math (wrap spreads 2^bits
+ * steps across [min,max); clamp maps the endpoints onto 0 and 2^bits-1).
+ */
+function resolveQuantized(q) {
+    return {
+        range: q.max - q.min,
+        span: q.wrap ? 2 ** q.bits : 2 ** q.bits - 1,
+    };
+}
 class Property {
     index;
     name;
     type;
     childType;
+    quantized;
     deprecated;
 }
 /**
@@ -234,6 +245,96 @@ function extractBuilderBase(node) {
         };
     }
 }
+/**
+ * Statically evaluate a numeric option expression. Codegen has no runtime, so
+ * only constant arithmetic is supported: literals, unary +/-, `Math.PI`-style
+ * constants and add/sub/mul/div combinations of those (e.g. `Math.PI * 2`).
+ * Returns
+ * undefined for anything it cannot resolve (a `const` reference, a call).
+ */
+function evalNumericExpression(node) {
+    if (ts__namespace.isNumericLiteral(node)) {
+        return Number(node.text);
+    }
+    if (ts__namespace.isParenthesizedExpression(node)) {
+        return evalNumericExpression(node.expression);
+    }
+    if (ts__namespace.isPrefixUnaryExpression(node)) {
+        const operand = evalNumericExpression(node.operand);
+        if (operand === undefined) {
+            return undefined;
+        }
+        if (node.operator === ts__namespace.SyntaxKind.MinusToken) {
+            return -operand;
+        }
+        if (node.operator === ts__namespace.SyntaxKind.PlusToken) {
+            return operand;
+        }
+        return undefined;
+    }
+    if (ts__namespace.isPropertyAccessExpression(node) && node.expression.getText() === "Math") {
+        const constant = Math[node.name.text];
+        return (typeof constant === "number") ? constant : undefined;
+    }
+    if (ts__namespace.isBinaryExpression(node)) {
+        const left = evalNumericExpression(node.left);
+        const right = evalNumericExpression(node.right);
+        if (left === undefined || right === undefined) {
+            return undefined;
+        }
+        switch (node.operatorToken.kind) {
+            case ts__namespace.SyntaxKind.PlusToken: return left + right;
+            case ts__namespace.SyntaxKind.MinusToken: return left - right;
+            case ts__namespace.SyntaxKind.AsteriskToken: return left * right;
+            case ts__namespace.SyntaxKind.SlashToken: return left / right;
+            default: return undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract `{ min, max, bits?, mode? }` from a `t.quantized({...})` /
+ * `@type({ quantized: {...} })` object literal. Throws on anything codegen
+ * cannot statically resolve — silently dropping an option would generate a
+ * client that decodes every value of that field wrong.
+ */
+function parseQuantizedOptions(node, propertyName) {
+    const fail = (reason) => {
+        throw new Error(`schema-codegen: cannot statically resolve t.quantized() options of field '${propertyName}' — ${reason}. ` +
+            `Use literal numbers or constant Math expressions (e.g. \`Math.PI * 2\`).`);
+    };
+    if (!node || !ts__namespace.isObjectLiteralExpression(node)) {
+        return fail("expected an inline `{ min, max, ... }` object literal");
+    }
+    const result = {};
+    for (const prop of node.properties) {
+        if (!ts__namespace.isPropertyAssignment(prop) || !prop.name) {
+            continue;
+        }
+        const key = prop.name.text;
+        if (key === "mode") {
+            if (!ts__namespace.isStringLiteral(prop.initializer)) {
+                return fail("`mode` must be a string literal");
+            }
+            result.mode = prop.initializer.text;
+        }
+        else if (key === "min" || key === "max" || key === "bits") {
+            const value = evalNumericExpression(prop.initializer);
+            if (value === undefined) {
+                return fail(`\`${key}\` is not a constant expression`);
+            }
+            result[key] = value;
+        }
+    }
+    if (typeof result.min !== "number" || typeof result.max !== "number") {
+        return fail("`min` and `max` are required");
+    }
+    const bits = result.bits ?? 16;
+    if (bits !== 8 && bits !== 16 && bits !== 32) {
+        return fail("`bits` must be 8, 16 or 32");
+    }
+    return { min: result.min, max: result.max, bits, wrap: result.mode === "wrap" };
+}
 function defineProperty(property, initializer) {
     // Builder-style: t.number(), t.array(Item), t.map(Item).view(), etc.
     if (ts__namespace.isCallExpression(initializer)) {
@@ -251,6 +352,10 @@ function defineProperty(property, initializer) {
                     property.childType = base.firstArg.text ?? base.firstArg.getText();
                 }
             }
+            else if (base.methodName === "quantized") {
+                property.type = "quantized";
+                property.quantized = parseQuantizedOptions(base.firstArg, property.name);
+            }
             else {
                 property.type = base.methodName;
             }
@@ -262,8 +367,15 @@ function defineProperty(property, initializer) {
         property.childType = initializer.text;
     }
     else if (initializer.kind == ts__namespace.SyntaxKind.ObjectLiteralExpression) {
-        property.type = initializer.properties[0].name.text;
-        property.childType = initializer.properties[0].initializer.text;
+        if (initializer.properties[0].name.text === "quantized") {
+            // decorator-style: @type({ quantized: { min, max, ... } })
+            property.type = "quantized";
+            property.quantized = parseQuantizedOptions(initializer.properties[0].initializer, property.name);
+        }
+        else {
+            property.type = initializer.properties[0].name.text;
+            property.childType = initializer.properties[0].initializer.text;
+        }
     }
     else if (initializer.kind == ts__namespace.SyntaxKind.ArrayLiteralExpression) {
         property.type = "array";
@@ -629,8 +741,8 @@ function getDecorators(node) {
     return node.modifiers?.filter(ts__namespace.isDecorator);
 }
 
-const name$8 = "Unity/C#";
-const typeMaps$8 = {
+const name$9 = "Unity/C#";
+const typeMaps$9 = {
     "string": "string",
     "number": "float",
     "boolean": "bool",
@@ -645,7 +757,7 @@ const typeMaps$8 = {
     "float32": "float",
     "float64": "double",
 };
-const COMMON_IMPORTS$5 = `using Colyseus.Schema;
+const COMMON_IMPORTS$6 = `using Colyseus.Schema;
 #if UNITY_5_3_OR_NEWER
 using UnityEngine.Scripting;
 #endif`;
@@ -660,46 +772,46 @@ const capitalize$1 = (s) => {
 /**
  * Generate individual files for each class/interface/enum
  */
-function generate$9(context, options) {
+function generate$a(context, options) {
     // enrich typeMaps with enums
     context.enums.forEach((structure) => {
-        typeMaps$8[structure.name] = structure.name;
+        typeMaps$9[structure.name] = structure.name;
     });
     return [
         ...context.classes.map(structure => ({
             name: `${structure.name}.cs`,
-            content: generateClass$8(structure, options.namespace)
+            content: generateClass$9(structure, options.namespace)
         })),
         ...context.interfaces.map(structure => ({
             name: `${structure.name}.cs`,
-            content: generateInterface$1(structure, options.namespace),
+            content: generateInterface$2(structure, options.namespace),
         })),
         ...context.enums.filter(structure => structure.name !== 'OPERATION').map((structure) => ({
             name: `${structure.name}.cs`,
-            content: generateEnum$1(structure, options.namespace),
+            content: generateEnum$2(structure, options.namespace),
         })),
     ];
 }
 /**
  * Generate a single bundled file containing all classes, interfaces, and enums
  */
-function renderBundle$8(context, options) {
+function renderBundle$9(context, options) {
     const fileName = options.namespace ? `${options.namespace}.cs` : "Schema.cs";
     const indent = options.namespace ? "\t" : "";
     // enrich typeMaps with enums
     context.enums.forEach((structure) => {
-        typeMaps$8[structure.name] = structure.name;
+        typeMaps$9[structure.name] = structure.name;
     });
     // Collect all bodies
-    const classBodies = context.classes.map(klass => generateClassBody$8(klass, indent));
-    const interfaceBodies = context.interfaces.map(iface => generateInterfaceBody$1(iface, indent));
+    const classBodies = context.classes.map(klass => generateClassBody$9(klass, indent));
+    const interfaceBodies = context.interfaces.map(iface => generateInterfaceBody$2(iface, indent));
     const enumBodies = context.enums
         .filter(structure => structure.name !== 'OPERATION')
-        .map(e => generateEnumBody$1(e, indent));
+        .map(e => generateEnumBody$2(e, indent));
     const allBodies = [...classBodies, ...interfaceBodies, ...enumBodies].join("\n\n");
     const content = `${getCommentHeader()}
 
-${COMMON_IMPORTS$5}
+${COMMON_IMPORTS$6}
 ${options.namespace ? `\nnamespace ${options.namespace} {\n` : ""}
 ${allBodies}
 ${options.namespace ? "}" : ""}`;
@@ -708,7 +820,7 @@ ${options.namespace ? "}" : ""}`;
 /**
  * Generate just the class body (without imports/namespace) for bundling
  */
-function generateClassBody$8(klass, indent = "") {
+function generateClassBody$9(klass, indent = "") {
     return `${indent}public partial class ${klass.name} : ${klass.extends} {
 #if UNITY_5_3_OR_NEWER
 [Preserve]
@@ -720,13 +832,13 @@ ${indent}}`;
 /**
  * Generate a complete class file with imports/namespace (for individual file mode)
  */
-function generateClass$8(klass, namespace) {
+function generateClass$9(klass, namespace) {
     const indent = (namespace) ? "\t" : "";
     return `${getCommentHeader()}
 
-${COMMON_IMPORTS$5}
+${COMMON_IMPORTS$6}
 ${namespace ? `\nnamespace ${namespace} {` : ""}
-${generateClassBody$8(klass, indent)}
+${generateClassBody$9(klass, indent)}
 ${namespace ? "}" : ""}
 `;
 }
@@ -745,7 +857,7 @@ function canUseNativeEnum(_enum) {
 /**
  * Generate just the enum body (without imports/namespace) for bundling
  */
-function generateEnumBody$1(_enum, indent = "") {
+function generateEnumBody$2(_enum, indent = "") {
     if (canUseNativeEnum(_enum)) {
         const members = _enum.properties
             .map((prop, i) => {
@@ -784,11 +896,11 @@ ${indent}}`;
 /**
  * Generate a complete enum file with imports/namespace (for individual file mode)
  */
-function generateEnum$1(_enum, namespace) {
+function generateEnum$2(_enum, namespace) {
     const indent = namespace ? "\t" : "";
     return `${getCommentHeader()}
 ${namespace ? `\nnamespace ${namespace} {` : ""}
-${generateEnumBody$1(_enum, indent)}
+${generateEnumBody$2(_enum, indent)}
 ${namespace ? "}" : ""}`;
 }
 function generateProperty$4(prop, indent = "") {
@@ -796,7 +908,13 @@ function generateProperty$4(prop, indent = "") {
     let property = "public";
     let langType;
     let initializer = "";
-    if (prop.childType) {
+    if (prop.quantized) {
+        const q = prop.quantized;
+        typeArgs += `, QuantizeMin = ${q.min}, QuantizeMax = ${q.max}, QuantizeBits = ${q.bits}, QuantizeWrap = ${q.wrap}`;
+        langType = "double";
+        initializer = "default(double)";
+    }
+    else if (prop.childType) {
         const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
         langType = getType(prop);
         typeArgs += `, typeof(${langType})`;
@@ -817,7 +935,7 @@ function generateProperty$4(prop, indent = "") {
 /**
  * Generate just the interface body (without imports/namespace) for bundling
  */
-function generateInterfaceBody$1(struct, indent = "") {
+function generateInterfaceBody$2(struct, indent = "") {
     return `${indent}public class ${struct.name} {
 ${struct.properties.map(prop => `\t${indent}public ${getType(prop)} ${prop.name};`).join("\n")}
 ${indent}}`;
@@ -825,18 +943,18 @@ ${indent}}`;
 /**
  * Generate a complete interface file with imports/namespace (for individual file mode)
  */
-function generateInterface$1(struct, namespace) {
+function generateInterface$2(struct, namespace) {
     const indent = (namespace) ? "\t" : "";
     return `${getCommentHeader()}
 
 using Colyseus.Schema;
 ${namespace ? `\nnamespace ${namespace} {` : ""}
-${generateInterfaceBody$1(struct, indent)}
+${generateInterfaceBody$2(struct, indent)}
 ${namespace ? "}" : ""}
 `;
 }
 function getChildType(prop) {
-    return typeMaps$8[prop.childType];
+    return typeMaps$9[prop.childType];
 }
 function getType(prop) {
     if (prop.childType) {
@@ -857,20 +975,20 @@ function getType(prop) {
     }
     else {
         return (prop.type === "array")
-            ? `${typeMaps$8[prop.childType] || prop.childType}[]`
-            : typeMaps$8[prop.type];
+            ? `${typeMaps$9[prop.childType] || prop.childType}[]`
+            : typeMaps$9[prop.type];
     }
 }
 
 var csharp = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$9,
-    name: name$8,
-    renderBundle: renderBundle$8
+    generate: generate$a,
+    name: name$9,
+    renderBundle: renderBundle$9
 });
 
-const name$7 = "C++";
-const typeMaps$7 = {
+const name$8 = "C++";
+const typeMaps$8 = {
     "string": "string",
     "number": "varint_t",
     "boolean": "bool",
@@ -913,23 +1031,23 @@ const capitalize = (s) => {
         return '';
     return s.charAt(0).toUpperCase() + s.slice(1);
 };
-const distinct$5 = (value, index, self) => self.indexOf(value) === index;
+const distinct$6 = (value, index, self) => self.indexOf(value) === index;
 /**
  * Generate individual files for each class
  */
-function generate$8(context, options) {
+function generate$9(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".hpp",
-        content: generateClass$7(klass, options.namespace, context.classes)
+        content: generateClass$8(klass, options.namespace, context.classes)
     }));
 }
 /**
  * Generate a single bundled header file containing all classes
  */
-function renderBundle$7(context, options) {
+function renderBundle$8(context, options) {
     const fileName = options.namespace ? `${options.namespace}.hpp` : "schema.hpp";
     const guardName = `__SCHEMA_CODEGEN_${(options.namespace || "SCHEMA").toUpperCase()}_H__`;
-    const classBodies = context.classes.map(klass => generateClassBody$7(klass, context.classes, options.namespace));
+    const classBodies = context.classes.map(klass => generateClassBody$8(klass, context.classes, options.namespace));
     const content = `${getCommentHeader()}
 #ifndef ${guardName}
 #define ${guardName} 1
@@ -947,7 +1065,7 @@ ${options.namespace ? "}" : ""}
 /**
  * Generate just the class body (without includes/guards) for bundling
  */
-function generateClassBody$7(klass, allClasses, namespace) {
+function generateClassBody$8(klass, allClasses, namespace) {
     const propertiesPerType = {};
     const allRefs = [];
     klass.properties.forEach(property => {
@@ -964,7 +1082,7 @@ function generateClassBody$7(klass, allClasses, namespace) {
     const allProperties = getAllProperties$1(klass, allClasses);
     const createInstanceMethod = (allRefs.length === 0) ? "" :
         `\tinline Schema* createInstance(std::type_index type) {
-\t\t${generateFieldIfElseChain(allRefs, (property) => `type == typeid(${property.childType})`, (property) => `return new ${property.childType}();`, (property) => typeMaps$7[property.childType] === undefined)}
+\t\t${generateFieldIfElseChain(allRefs, (property) => `type == typeid(${property.childType})`, (property) => `return new ${property.childType}();`, (property) => typeMaps$8[property.childType] === undefined)}
 \t\treturn ${klass.extends}::createInstance(type);
 \t}`;
     return `class ${klass.name} : public ${klass.extends} {
@@ -992,7 +1110,7 @@ ${createInstanceMethod}
 /**
  * Generate a complete class file with includes/guards (for individual file mode)
  */
-function generateClass$7(klass, namespace, allClasses) {
+function generateClass$8(klass, namespace, allClasses) {
     const allRefs = [];
     klass.properties.forEach(property => {
         let type = property.type;
@@ -1002,10 +1120,10 @@ function generateClass$7(klass, namespace, allClasses) {
         }
     });
     const localIncludes = allRefs.
-        filter(ref => ref.childType && typeMaps$7[ref.childType] === undefined).
+        filter(ref => ref.childType && typeMaps$8[ref.childType] === undefined).
         map(ref => ref.childType).
         concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
-        filter(distinct$5).
+        filter(distinct$6).
         map(childType => `#include "${childType}.hpp"`).
         join("\n");
     return `${getCommentHeader()}
@@ -1016,7 +1134,7 @@ ${COMMON_INCLUDES$1}
 ${localIncludes}
 
 ${namespace ? `namespace ${namespace} {` : ""}
-${generateClassBody$7(klass, allClasses)}
+${generateClassBody$8(klass, allClasses)}
 ${namespace ? "}" : ""}
 
 #endif
@@ -1036,26 +1154,26 @@ function generateProperty$3(prop) {
         else if (prop.type === "array") {
             langType = (isUpcaseFirst)
                 ? `ArraySchema<${prop.childType}*>`
-                : `ArraySchema<${typeMaps$7[prop.childType]}>`;
+                : `ArraySchema<${typeMaps$8[prop.childType]}>`;
             initializer = `new ${langType}()`;
         }
         else if (prop.type === "map") {
             langType = (isUpcaseFirst)
                 ? `MapSchema<${prop.childType}*>`
-                : `MapSchema<${typeMaps$7[prop.childType]}>`;
+                : `MapSchema<${typeMaps$8[prop.childType]}>`;
             initializer = `new ${langType}()`;
         }
         isPropPointer = "*";
     }
     else {
-        langType = typeMaps$7[prop.type];
+        langType = typeMaps$8[prop.type];
         initializer = typeInitializer$2[prop.type];
     }
     property += ` ${langType} ${isPropPointer}${prop.name}`;
     return `\t${property} = ${initializer};`;
 }
 function generateGettersAndSetters(klass, type, properties) {
-    let langType = typeMaps$7[type];
+    let langType = typeMaps$8[type];
     let typeCast = "";
     const getMethodName = `get${capitalize(type)}`;
     const setMethodName = `set${capitalize(type)}`;
@@ -1079,7 +1197,7 @@ function generateGettersAndSetters(klass, type, properties) {
 \tinline void ${setMethodName}(const string &field, ${langType} value)
 \t{
 \t\t${generateFieldIfElseChain(properties, (property) => `field == "${property.name}"`, (property) => {
-        const isSchemaType = (typeMaps$7[property.childType] === undefined);
+        const isSchemaType = (typeMaps$8[property.childType] === undefined);
         if (type === "ref") {
             langType = `${property.childType}*`;
             typeCast = (isSchemaType)
@@ -1089,12 +1207,12 @@ function generateGettersAndSetters(klass, type, properties) {
         else if (type === "array") {
             typeCast = (isSchemaType)
                 ? `(ArraySchema<${property.childType}*> *)`
-                : `(ArraySchema<${typeMaps$7[property.childType]}> *)`;
+                : `(ArraySchema<${typeMaps$8[property.childType]}> *)`;
         }
         else if (type === "map") {
             typeCast = (isSchemaType)
                 ? `(MapSchema<${property.childType}*> *)`
-                : `(MapSchema<${typeMaps$7[property.childType]}> *)`;
+                : `(MapSchema<${typeMaps$8[property.childType]}> *)`;
         }
         return `this->${property.name} = ${typeCast}value;\n\t\t\treturn;`;
     })}
@@ -1133,7 +1251,7 @@ function generateAllTypes(properties) {
 }
 function generateAllChildSchemaTypes(properties) {
     return `{${properties.map((property, i) => {
-        if (property.childType && typeMaps$7[property.childType] === undefined) {
+        if (property.childType && typeMaps$8[property.childType] === undefined) {
             return `{${i}, typeid(${property.childType})}`;
         }
         else {
@@ -1143,7 +1261,7 @@ function generateAllChildSchemaTypes(properties) {
 }
 function generateAllChildPrimitiveTypes(properties) {
     return `{${properties.map((property, i) => {
-        if (typeMaps$7[property.childType] !== undefined) {
+        if (typeMaps$8[property.childType] !== undefined) {
             return `{${i}, "${property.childType}"}`;
         }
         else {
@@ -1171,13 +1289,13 @@ function getAllProperties$1(klass, allClasses) {
 
 var cpp = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$8,
-    name: name$7,
-    renderBundle: renderBundle$7
+    generate: generate$9,
+    name: name$8,
+    renderBundle: renderBundle$8
 });
 
-const name$6 = "Haxe";
-const typeMaps$6 = {
+const name$7 = "Haxe";
+const typeMaps$7 = {
     "string": "String",
     "number": "Dynamic",
     "boolean": "Bool",
@@ -1207,27 +1325,27 @@ const typeInitializer$1 = {
     "float32": "0",
     "float64": "0",
 };
-const COMMON_IMPORTS$4 = `import io.colyseus.serializer.schema.Schema;
+const COMMON_IMPORTS$5 = `import io.colyseus.serializer.schema.Schema;
 import io.colyseus.serializer.schema.types.*;`;
 /**
  * Generate individual files for each class
  */
-function generate$7(context, options) {
+function generate$8(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".hx",
-        content: generateClass$6(klass, options.namespace, context.classes)
+        content: generateClass$7(klass, options.namespace, context.classes)
     }));
 }
 /**
  * Generate a single bundled file containing all classes
  */
-function renderBundle$6(context, options) {
+function renderBundle$7(context, options) {
     const fileName = options.namespace ? `${options.namespace}.hx` : "Schema.hx";
-    const classBodies = context.classes.map(klass => generateClassBody$6(klass));
+    const classBodies = context.classes.map(klass => generateClassBody$7(klass));
     const content = `${getCommentHeader()}
 
 ${options.namespace ? `package ${options.namespace};` : ""}
-${COMMON_IMPORTS$4}
+${COMMON_IMPORTS$5}
 
 ${classBodies.join("\n\n")}
 `;
@@ -1236,7 +1354,7 @@ ${classBodies.join("\n\n")}
 /**
  * Generate just the class body (without package/imports) for bundling
  */
-function generateClassBody$6(klass) {
+function generateClassBody$7(klass) {
     return `class ${klass.name} extends ${klass.extends} {
 ${klass.properties.map(prop => generateProperty$2(prop)).join("\n")}
 }`;
@@ -1244,20 +1362,26 @@ ${klass.properties.map(prop => generateProperty$2(prop)).join("\n")}
 /**
  * Generate a complete class file with package/imports (for individual file mode)
  */
-function generateClass$6(klass, namespace, allClasses) {
+function generateClass$7(klass, namespace, allClasses) {
     return `${getCommentHeader()}
 
 ${namespace ? `package ${namespace};` : ""}
-${COMMON_IMPORTS$4}
+${COMMON_IMPORTS$5}
 
-${generateClassBody$6(klass)}
+${generateClassBody$7(klass)}
 `;
 }
 function generateProperty$2(prop) {
     let langType;
     let initializer = "";
     let typeArgs = `"${prop.type}"`;
-    if (prop.childType) {
+    if (prop.quantized) {
+        const q = prop.quantized;
+        typeArgs += `, {min: ${q.min}, max: ${q.max}, bits: ${q.bits}, mode: ${q.wrap ? 1 : 0}}`;
+        langType = "Float";
+        initializer = "0";
+    }
+    else if (prop.childType) {
         const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
         if (isUpcaseFirst) {
             typeArgs += `, ${prop.childType}`;
@@ -1272,18 +1396,18 @@ function generateProperty$2(prop) {
         else if (prop.type === "array") {
             langType = (isUpcaseFirst)
                 ? `ArraySchema<${prop.childType}>`
-                : `ArraySchema<${typeMaps$6[prop.childType]}>`;
+                : `ArraySchema<${typeMaps$7[prop.childType]}>`;
             initializer = `new ${langType}()`;
         }
         else if (prop.type === "map") {
             langType = (isUpcaseFirst)
                 ? `MapSchema<${prop.childType}>`
-                : `MapSchema<${typeMaps$6[prop.childType]}>`;
+                : `MapSchema<${typeMaps$7[prop.childType]}>`;
             initializer = `new ${langType}()`;
         }
     }
     else {
-        langType = typeMaps$6[prop.type];
+        langType = typeMaps$7[prop.type];
         initializer = typeInitializer$1[prop.type];
     }
     // TODO: remove initializer. The callbacks at the Haxe decoder side have a
@@ -1294,13 +1418,13 @@ function generateProperty$2(prop) {
 
 var haxe = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$7,
-    name: name$6,
-    renderBundle: renderBundle$6
+    generate: generate$8,
+    name: name$7,
+    renderBundle: renderBundle$7
 });
 
-const name$5 = "TypeScript";
-const typeMaps$5 = {
+const name$6 = "TypeScript";
+const typeMaps$6 = {
     "string": "string",
     "number": "number",
     "boolean": "boolean",
@@ -1315,35 +1439,35 @@ const typeMaps$5 = {
     "float32": "number",
     "float64": "number",
 };
-const COMMON_IMPORTS$3 = `import { Schema, type, ArraySchema, MapSchema, SetSchema, DataChange } from '@colyseus/schema';`;
-const distinct$4 = (value, index, self) => self.indexOf(value) === index;
+const COMMON_IMPORTS$4 = `import { Schema, type, ArraySchema, MapSchema, SetSchema, DataChange } from '@colyseus/schema';`;
+const distinct$5 = (value, index, self) => self.indexOf(value) === index;
 /**
  * Generate individual files for each class/interface
  */
-function generate$6(context, options) {
+function generate$7(context, options) {
     return [
         ...context.classes.map(structure => ({
             name: structure.name + ".ts",
-            content: generateClass$5(structure, options.namespace, context.classes)
+            content: generateClass$6(structure, options.namespace, context.classes)
         })),
         ...context.interfaces.map(structure => ({
             name: structure.name + ".ts",
-            content: generateInterface(structure, options.namespace, context.classes),
+            content: generateInterface$1(structure, options.namespace, context.classes),
         }))
     ];
 }
 /**
  * Generate a single bundled file containing all classes and interfaces
  */
-function renderBundle$5(context, options) {
+function renderBundle$6(context, options) {
     const fileName = options.namespace ? `${options.namespace}.ts` : "schema.ts";
     // Collect all class bodies
-    const classBodies = context.classes.map(klass => generateClassBody$5(klass));
+    const classBodies = context.classes.map(klass => generateClassBody$6(klass));
     // Collect all interface bodies
-    const interfaceBodies = context.interfaces.map(iface => generateInterfaceBody(iface));
+    const interfaceBodies = context.interfaces.map(iface => generateInterfaceBody$1(iface));
     const content = `${getCommentHeader()}
 
-${COMMON_IMPORTS$3}
+${COMMON_IMPORTS$4}
 
 ${classBodies.join("\n\n")}
 ${interfaceBodies.length > 0 ? "\n" + interfaceBodies.join("\n\n") : ""}`;
@@ -1352,7 +1476,7 @@ ${interfaceBodies.length > 0 ? "\n" + interfaceBodies.join("\n\n") : ""}`;
 /**
  * Generate just the class body (without imports) for bundling
  */
-function generateClassBody$5(klass) {
+function generateClassBody$6(klass) {
     return `export class ${klass.name} extends ${klass.extends} {
 ${klass.properties.map(prop => `    ${generateProperty$1(prop)}`).join("\n")}
 }`;
@@ -1360,7 +1484,7 @@ ${klass.properties.map(prop => `    ${generateProperty$1(prop)}`).join("\n")}
 /**
  * Generate just the interface body (without imports) for bundling
  */
-function generateInterfaceBody(iface) {
+function generateInterfaceBody$1(iface) {
     return `export interface ${iface.name} {
 ${iface.properties.map(prop => `    ${prop.name}: ${prop.type};`).join("\n")}
 }`;
@@ -1368,7 +1492,7 @@ ${iface.properties.map(prop => `    ${prop.name}: ${prop.type};`).join("\n")}
 /**
  * Generate a complete class file with imports (for individual file mode)
  */
-function generateClass$5(klass, namespace, allClasses) {
+function generateClass$6(klass, namespace, allClasses) {
     const allRefs = [];
     klass.properties.forEach(property => {
         let type = property.type;
@@ -1378,18 +1502,18 @@ function generateClass$5(klass, namespace, allClasses) {
         }
     });
     const localImports = allRefs.
-        filter(ref => ref.childType && typeMaps$5[ref.childType] === undefined).
+        filter(ref => ref.childType && typeMaps$6[ref.childType] === undefined).
         map(ref => ref.childType).
         concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
-        filter(distinct$4).
+        filter(distinct$5).
         map(childType => `import { ${childType} } from './${childType}'`).
         join("\n");
     return `${getCommentHeader()}
 
-${COMMON_IMPORTS$3}
+${COMMON_IMPORTS$4}
 ${localImports}
 
-${generateClassBody$5(klass)}
+${generateClassBody$6(klass)}
 `;
 }
 function generateProperty$1(prop) {
@@ -1412,7 +1536,7 @@ function generateProperty$1(prop) {
         else if (prop.type === "array") {
             langType = (isUpcaseFirst)
                 ? `ArraySchema<${prop.childType}>`
-                : `ArraySchema<${typeMaps$5[prop.childType]}>`;
+                : `ArraySchema<${typeMaps$6[prop.childType]}>`;
             initializer = `new ${langType}()`;
             typeArgs = (isUpcaseFirst)
                 ? `[ ${prop.childType} ]`
@@ -1421,7 +1545,7 @@ function generateProperty$1(prop) {
         else if (prop.type === "map") {
             langType = (isUpcaseFirst)
                 ? `MapSchema<${prop.childType}>`
-                : `MapSchema<${typeMaps$5[prop.childType]}>`;
+                : `MapSchema<${typeMaps$6[prop.childType]}>`;
             initializer = `new ${langType}()`;
             typeArgs = (isUpcaseFirst)
                 ? `{ map: ${prop.childType} }`
@@ -1430,15 +1554,20 @@ function generateProperty$1(prop) {
         else if (prop.type === "set") {
             langType = (isUpcaseFirst)
                 ? `SetSchema<${prop.childType}>`
-                : `SetSchema<${typeMaps$5[prop.childType]}>`;
+                : `SetSchema<${typeMaps$6[prop.childType]}>`;
             initializer = `new ${langType}()`;
             typeArgs = (isUpcaseFirst)
                 ? `{ set: ${prop.childType} }`
                 : `{ set: "${prop.childType}" }`;
         }
     }
+    else if (prop.quantized) {
+        const q = prop.quantized;
+        langType = "number";
+        typeArgs = `{ quantized: { min: ${q.min}, max: ${q.max}, bits: ${q.bits}${q.wrap ? `, mode: "wrap"` : ""} } }`;
+    }
     else {
-        langType = typeMaps$5[prop.type];
+        langType = typeMaps$6[prop.type];
         typeArgs = `"${prop.type}"`;
     }
     // TS1263: "Declarations with initializers cannot also have definite assignment assertions"
@@ -1448,22 +1577,22 @@ function generateProperty$1(prop) {
 /**
  * Generate a complete interface file with header (for individual file mode)
  */
-function generateInterface(structure, namespace, allClasses) {
+function generateInterface$1(structure, namespace, allClasses) {
     return `${getCommentHeader()}
 
-${generateInterfaceBody(structure)}
+${generateInterfaceBody$1(structure)}
 `;
 }
 
 var ts = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$6,
-    name: name$5,
-    renderBundle: renderBundle$5
+    generate: generate$7,
+    name: name$6,
+    renderBundle: renderBundle$6
 });
 
-const name$4 = "JavaScript";
-const typeMaps$4 = {
+const name$5 = "JavaScript";
+const typeMaps$5 = {
     "string": "string",
     "number": "number",
     "boolean": "boolean",
@@ -1478,29 +1607,29 @@ const typeMaps$4 = {
     "float32": "number",
     "float64": "number",
 };
-const COMMON_IMPORTS$2 = `const schema = require("@colyseus/schema");
+const COMMON_IMPORTS$3 = `const schema = require("@colyseus/schema");
 const Schema = schema.Schema;
 const type = schema.type;`;
-const distinct$3 = (value, index, self) => self.indexOf(value) === index;
+const distinct$4 = (value, index, self) => self.indexOf(value) === index;
 /**
  * Generate individual files for each class
  */
-function generate$5(context, options) {
+function generate$6(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".js",
-        content: generateClass$4(klass, options.namespace, context.classes)
+        content: generateClass$5(klass, options.namespace, context.classes)
     }));
 }
 /**
  * Generate a single bundled file containing all classes
  */
-function renderBundle$4(context, options) {
+function renderBundle$5(context, options) {
     const fileName = options.namespace ? `${options.namespace}.js` : "schema.js";
-    const classBodies = context.classes.map(klass => generateClassBody$4(klass));
+    const classBodies = context.classes.map(klass => generateClassBody$5(klass));
     const classExports = context.classes.map(klass => `    ${klass.name},`).join("\n");
     const content = `${getCommentHeader()}
 
-${COMMON_IMPORTS$2}
+${COMMON_IMPORTS$3}
 
 ${classBodies.join("\n\n")}
 
@@ -1513,7 +1642,7 @@ ${classExports}
 /**
  * Generate just the class body (without imports) for bundling
  */
-function generateClassBody$4(klass) {
+function generateClassBody$5(klass) {
     return `class ${klass.name} extends ${klass.extends} {
     constructor () {
         super();
@@ -1527,7 +1656,7 @@ ${klass.properties.map(prop => generatePropertyDeclaration$1(klass.name, prop)).
 /**
  * Generate a complete class file with imports (for individual file mode)
  */
-function generateClass$4(klass, namespace, allClasses) {
+function generateClass$5(klass, namespace, allClasses) {
     const allRefs = [];
     klass.properties.forEach(property => {
         let type = property.type;
@@ -1537,18 +1666,18 @@ function generateClass$4(klass, namespace, allClasses) {
         }
     });
     const localImports = allRefs.
-        filter(ref => ref.childType && typeMaps$4[ref.childType] === undefined).
+        filter(ref => ref.childType && typeMaps$5[ref.childType] === undefined).
         map(ref => ref.childType).
         concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
-        filter(distinct$3).
+        filter(distinct$4).
         map(childType => `const ${childType} = require("./${childType}");`).
         join("\n");
     return `${getCommentHeader()}
 
-${COMMON_IMPORTS$2}
+${COMMON_IMPORTS$3}
 ${localImports}
 
-${generateClassBody$4(klass)}
+${generateClassBody$5(klass)}
 
 export default ${klass.name};
 `;
@@ -1598,13 +1727,13 @@ function generatePropertyInitializer(prop) {
 
 var js = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$5,
-    name: name$4,
-    renderBundle: renderBundle$4
+    generate: generate$6,
+    name: name$5,
+    renderBundle: renderBundle$5
 });
 
-const name$3 = "Java";
-const typeMaps$3 = {
+const name$4 = "Java";
+const typeMaps$4 = {
     "string": "String",
     "number": "float",
     "boolean": "boolean",
@@ -1634,7 +1763,7 @@ const typeInitializer = {
     "float32": "0",
     "float64": "0",
 };
-const COMMON_IMPORTS$1 = `import io.colyseus.serializer.schema.Schema;
+const COMMON_IMPORTS$2 = `import io.colyseus.serializer.schema.Schema;
 import io.colyseus.serializer.schema.annotations.SchemaClass;
 import io.colyseus.serializer.schema.annotations.SchemaField;`;
 /**
@@ -1643,10 +1772,10 @@ import io.colyseus.serializer.schema.annotations.SchemaField;`;
 /**
  * Generate individual files for each class
  */
-function generate$4(context, options) {
+function generate$5(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".java",
-        content: generateClass$3(klass, options.namespace)
+        content: generateClass$4(klass, options.namespace)
     }));
 }
 /**
@@ -1654,13 +1783,13 @@ function generate$4(context, options) {
  * Note: Java typically requires one public class per file, so bundled mode
  * generates all classes in a single file with package-private visibility
  */
-function renderBundle$3(context, options) {
+function renderBundle$4(context, options) {
     const fileName = options.namespace ? `Schema.java` : "Schema.java";
-    const classBodies = context.classes.map(klass => generateClassBody$3(klass));
+    const classBodies = context.classes.map(klass => generateClassBody$4(klass));
     const content = `${getCommentHeader()}
 ${options.namespace ? `\npackage ${options.namespace};` : ""}
 
-${COMMON_IMPORTS$1}
+${COMMON_IMPORTS$2}
 
 ${classBodies.join("\n\n")}
 `;
@@ -1669,7 +1798,7 @@ ${classBodies.join("\n\n")}
 /**
  * Generate just the class body (without package/imports) for bundling
  */
-function generateClassBody$3(klass) {
+function generateClassBody$4(klass) {
     return `@SchemaClass
 class ${klass.name} extends ${klass.extends} {
 ${klass.properties.map(prop => generateProperty(prop, "")).join("\n\n")}
@@ -1678,12 +1807,12 @@ ${klass.properties.map(prop => generateProperty(prop, "")).join("\n\n")}
 /**
  * Generate a complete class file with package/imports (for individual file mode)
  */
-function generateClass$3(klass, namespace) {
+function generateClass$4(klass, namespace) {
     const indent = (namespace) ? "\t" : "";
     return `${getCommentHeader()}
 ${namespace ? `\npackage ${namespace};` : ""}
 
-${COMMON_IMPORTS$1}
+${COMMON_IMPORTS$2}
 
 @SchemaClass
 ${indent}public class ${klass.name} extends ${klass.extends} {
@@ -1706,7 +1835,7 @@ function generateProperty(prop, indent = "") {
         if (prop.type === "ref") {
             langType = (isUpcaseFirst)
                 ? prop.childType
-                : typeMaps$3[prop.childType];
+                : typeMaps$4[prop.childType];
             initializer = `new ${langType}${(prop.type !== "ref" && isUpcaseFirst) ? "<>" : ""}(${ctorArgs})`;
         }
         else if (prop.type === "array") {
@@ -1728,7 +1857,7 @@ function generateProperty(prop, indent = "") {
         }
     }
     else {
-        langType = typeMaps$3[prop.type];
+        langType = typeMaps$4[prop.type];
         initializer = typeInitializer[prop.type];
     }
     property += ` ${langType} ${prop.name}`;
@@ -1738,18 +1867,18 @@ function generateProperty(prop, indent = "") {
 
 var java = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$4,
-    name: name$3,
-    renderBundle: renderBundle$3
+    generate: generate$5,
+    name: name$4,
+    renderBundle: renderBundle$4
 });
 
-const name$2 = "LUA";
+const name$3 = "LUA";
 /**
     TODO:
     - Support inheritance
     - Support importing Schema dependencies
 */
-const typeMaps$2 = {
+const typeMaps$3 = {
     "string": "string",
     "number": "number",
     "boolean": "boolean",
@@ -1764,27 +1893,29 @@ const typeMaps$2 = {
     "float32": "number",
     "float64": "number",
 };
-const COMMON_IMPORTS = `local schema = require 'colyseus.serializer.schema.schema'`;
-const distinct$2 = (value, index, self) => self.indexOf(value) === index;
+const COMMON_IMPORTS$1 = `local schema = require 'colyseus.serializer.schema.schema'`;
+const QUANTIZE_IMPORT = `local quantize = require 'colyseus.serializer.schema.quantize'`;
+const distinct$3 = (value, index, self) => self.indexOf(value) === index;
+const hasQuantized = (classes) => classes.some(klass => klass.properties.some(prop => prop.quantized));
 /**
  * Generate individual files for each class
  */
-function generate$3(context, options) {
+function generate$4(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".lua",
-        content: generateClass$2(klass, options.namespace, context.classes)
+        content: generateClass$3(klass, options.namespace, context.classes)
     }));
 }
 /**
  * Generate a single bundled file containing all classes
  */
-function renderBundle$2(context, options) {
+function renderBundle$3(context, options) {
     const fileName = options.namespace ? `${options.namespace}.lua` : "schema.lua";
-    const classBodies = context.classes.map(klass => generateClassBody$2(klass));
+    const classBodies = context.classes.map(klass => generateClassBody$3(klass));
     const classNames = context.classes.map(klass => `    ${klass.name} = ${klass.name},`).join("\n");
     const content = `${getCommentHeader().replace(/\/\//mg, "--")}
 
-${COMMON_IMPORTS}
+${COMMON_IMPORTS$1}${hasQuantized(context.classes) ? `\n${QUANTIZE_IMPORT}` : ""}
 
 ${classBodies.join("\n\n")}
 
@@ -1797,7 +1928,7 @@ ${classNames}
 /**
  * Generate just the class body (without requires) for bundling
  */
-function generateClassBody$2(klass) {
+function generateClassBody$3(klass) {
     // Inheritance support
     const inherits = (klass.extends !== "Schema")
         ? `, ${klass.extends}`
@@ -1812,7 +1943,7 @@ ${klass.properties.map(prop => generatePropertyDeclaration(prop)).join(",\n")},
 /**
  * Generate a complete class file with requires (for individual file mode)
  */
-function generateClass$2(klass, namespace, allClasses) {
+function generateClass$3(klass, namespace, allClasses) {
     const allRefs = [];
     klass.properties.forEach(property => {
         let type = property.type;
@@ -1822,25 +1953,30 @@ function generateClass$2(klass, namespace, allClasses) {
         }
     });
     const localRequires = allRefs.
-        filter(ref => ref.childType && typeMaps$2[ref.childType] === undefined).
+        filter(ref => ref.childType && typeMaps$3[ref.childType] === undefined).
         map(ref => ref.childType).
         concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
-        filter(distinct$2).
+        filter(distinct$3).
         map(childType => `local ${childType} = require '${(namespace ? `${namespace}.` : '')}${childType}'`).
         join("\n");
     return `${getCommentHeader().replace(/\/\//mg, "--")}
 
-${COMMON_IMPORTS}
+${COMMON_IMPORTS$1}${hasQuantized([klass]) ? `\n${QUANTIZE_IMPORT}` : ""}
 ${localRequires}
 
-${generateClassBody$2(klass)}
+${generateClassBody$3(klass)}
 
 return ${klass.name}
 `;
 }
 function generatePropertyDeclaration(prop) {
     let typeArgs;
-    if (prop.childType) {
+    if (prop.quantized) {
+        // resolve at class-definition time — the decoder expects `.wire`/`.span`
+        const q = prop.quantized;
+        typeArgs = `{ quantized = quantize.resolve({ min = ${q.min}, max = ${q.max}, bits = ${q.bits}, mode = ${q.wrap ? 1 : 0} }) }`;
+    }
+    else if (prop.childType) {
         const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
         if (isUpcaseFirst) {
             typeArgs += `${prop.childType}`;
@@ -1865,7 +2001,10 @@ function generatePropertyDeclaration(prop) {
     return `    ["${prop.name}"] = ${typeArgs}`;
 }
 function getLUATypeAnnotation(prop) {
-    if (prop.type === "ref") {
+    if (prop.type === "quantized") {
+        return "number";
+    }
+    else if (prop.type === "ref") {
         return prop.childType;
     }
     else if (prop.type === "array") {
@@ -1875,22 +2014,22 @@ function getLUATypeAnnotation(prop) {
         return "MapSchema";
     }
     else {
-        return typeMaps$2[prop.type];
+        return typeMaps$3[prop.type];
     }
 }
 
 var lua = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$3,
-    name: name$2,
-    renderBundle: renderBundle$2
+    generate: generate$4,
+    name: name$3,
+    renderBundle: renderBundle$3
 });
 
-const name$1 = "C";
+const name$2 = "C";
 /**
  * Type mappings for C
  */
-const typeMaps$1 = {
+const typeMaps$2 = {
     "string": "char*",
     "number": "double",
     "boolean": "bool",
@@ -1904,6 +2043,7 @@ const typeMaps$1 = {
     "uint64": "uint64_t",
     "float32": "float",
     "float64": "double",
+    "quantized": "double",
 };
 /**
  * Colyseus field type enum mappings
@@ -1925,6 +2065,7 @@ const fieldTypeMaps = {
     "ref": "COLYSEUS_FIELD_REF",
     "array": "COLYSEUS_FIELD_ARRAY",
     "map": "COLYSEUS_FIELD_MAP",
+    "quantized": "COLYSEUS_FIELD_QUANTIZED",
 };
 const COMMON_INCLUDES = `#include "colyseus/schema/types.h"
 #include "colyseus/schema/collections.h"
@@ -1937,23 +2078,23 @@ const COMMON_INCLUDES = `#include "colyseus/schema/types.h"
 const toSnakeCase = (s) => {
     return s.replace(/([A-Z])/g, (match, p1, offset) => (offset > 0 ? '_' : '') + p1.toLowerCase());
 };
-const distinct$1 = (value, index, self) => self.indexOf(value) === index;
+const distinct$2 = (value, index, self) => self.indexOf(value) === index;
 /**
  * Generate individual files for each class
  */
-function generate$2(context, options) {
+function generate$3(context, options) {
     return context.classes.map(klass => ({
         name: toSnakeCase(klass.name) + ".h",
-        content: generateClass$1(klass, options.namespace, context.classes)
+        content: generateClass$2(klass, options.namespace, context.classes)
     }));
 }
 /**
  * Generate a single bundled header file containing all classes
  */
-function renderBundle$1(context, options) {
+function renderBundle$2(context, options) {
     const fileName = options.namespace ? `${toSnakeCase(options.namespace)}.h` : "schema.h";
     const guardName = `__SCHEMA_CODEGEN_${(options.namespace || "SCHEMA").toUpperCase()}_H__`;
-    const classBodies = context.classes.map(klass => generateClassBody$1(klass, context.classes)).join("\n\n");
+    const classBodies = context.classes.map(klass => generateClassBody$2(klass, context.classes)).join("\n\n");
     const content = `${getCommentHeader()}
 #ifndef ${guardName}
 #define ${guardName} 1
@@ -1969,7 +2110,7 @@ ${classBodies}
 /**
  * Generate just the class body (without guards/includes) for bundling
  */
-function generateClassBody$1(klass, allClasses) {
+function generateClassBody$2(klass, allClasses) {
     const snakeName = toSnakeCase(klass.name);
     const typeName = `${snakeName}_t`;
     const allProperties = getAllProperties(klass, allClasses);
@@ -1986,7 +2127,7 @@ ${generateVtable(klass, snakeName, typeName, allProperties)}`;
 /**
  * Generate a complete class file with guards/includes (for individual file mode)
  */
-function generateClass$1(klass, namespace, allClasses) {
+function generateClass$2(klass, namespace, allClasses) {
     toSnakeCase(klass.name);
     const guardName = `__SCHEMA_CODEGEN_${klass.name.toUpperCase()}_H__`;
     const allRefs = [];
@@ -1997,10 +2138,10 @@ function generateClass$1(klass, namespace, allClasses) {
     });
     // Generate includes for referenced schema types
     const refIncludes = allRefs
-        .filter(ref => ref.childType && typeMaps$1[ref.childType] === undefined)
+        .filter(ref => ref.childType && typeMaps$2[ref.childType] === undefined)
         .map(ref => ref.childType)
         .concat(getInheritanceTree(klass, allClasses, false).map(k => k.name))
-        .filter(distinct$1)
+        .filter(distinct$2)
         .map(childType => `#include "${toSnakeCase(childType)}.h"`)
         .join("\n");
     return `${getCommentHeader()}
@@ -2009,7 +2150,7 @@ function generateClass$1(klass, namespace, allClasses) {
 
 ${COMMON_INCLUDES}
 ${refIncludes ? `\n${refIncludes}\n` : ""}
-${generateClassBody$1(klass, allClasses)}
+${generateClassBody$2(klass, allClasses)}
 
 #endif
 `;
@@ -2030,7 +2171,7 @@ function getCType(prop) {
         return `${toSnakeCase(prop.childType)}_t*`;
     }
     else if (prop.type === "array") {
-        if (typeMaps$1[prop.childType]) {
+        if (typeMaps$2[prop.childType]) {
             return `colyseus_array_schema_t*`;
         }
         else {
@@ -2038,7 +2179,7 @@ function getCType(prop) {
         }
     }
     else if (prop.type === "map") {
-        if (typeMaps$1[prop.childType]) {
+        if (typeMaps$2[prop.childType]) {
             return `colyseus_map_schema_t*`;
         }
         else {
@@ -2046,7 +2187,7 @@ function getCType(prop) {
         }
     }
     else {
-        return typeMaps$1[prop.type] || `${toSnakeCase(prop.type)}_t*`;
+        return typeMaps$2[prop.type] || `${toSnakeCase(prop.type)}_t*`;
     }
 }
 function getFieldType(prop) {
@@ -2060,21 +2201,38 @@ function generateFieldsArray(klass, typeName, snakeName, allProperties) {
     if (allProperties.length === 0) {
         return `static const colyseus_field_t ${snakeName}_fields[] = {};`;
     }
+    // one pre-resolved static descriptor per quantized field
+    const descriptors = allProperties
+        .filter(prop => prop.quantized)
+        .map(prop => {
+        const q = prop.quantized;
+        const { range, span } = resolveQuantized(q);
+        return `static const colyseus_quantized_descriptor_t ${snakeName}_${prop.name}_quantized = {${q.min}, ${q.max}, ${range}, ${span}, ${q.bits}, ${q.wrap}};`;
+    });
     const fields = allProperties.map((prop, i) => {
         const fieldType = getFieldType(prop);
         const typeString = getFieldTypeString(prop);
         let vtableRef = "NULL";
-        if (prop.type === "ref" && prop.childType && !typeMaps$1[prop.childType]) {
+        let childPrimitiveRef = "NULL";
+        let quantizedRef = "NULL";
+        if (prop.type === "ref" && prop.childType && !typeMaps$2[prop.childType]) {
             const childSnake = toSnakeCase(prop.childType);
             vtableRef = `&${childSnake}_vtable`;
         }
-        else if ((prop.type === "array" || prop.type === "map") && prop.childType && !typeMaps$1[prop.childType]) {
+        else if ((prop.type === "array" || prop.type === "map") && prop.childType && !typeMaps$2[prop.childType]) {
             const childSnake = toSnakeCase(prop.childType);
             vtableRef = `&${childSnake}_vtable`;
         }
-        return `    {${prop.index}, "${prop.name}", ${fieldType}, "${typeString}", offsetof(${typeName}, ${prop.name}), ${vtableRef}, NULL}`;
+        else if ((prop.type === "array" || prop.type === "map") && prop.childType) {
+            // collection of primitives — the decoder strcmp()s this to pick the reader
+            childPrimitiveRef = `"${prop.childType}"`;
+        }
+        else if (prop.quantized) {
+            quantizedRef = `&${snakeName}_${prop.name}_quantized`;
+        }
+        return `    {${prop.index}, "${prop.name}", ${fieldType}, "${typeString}", offsetof(${typeName}, ${prop.name}), ${vtableRef}, ${childPrimitiveRef}, ${quantizedRef}}`;
     }).join(",\n");
-    return `static const colyseus_field_t ${snakeName}_fields[] = {
+    return `${descriptors.length ? descriptors.join("\n") + "\n\n" : ""}static const colyseus_field_t ${snakeName}_fields[] = {
 ${fields}
 };`;
 }
@@ -2091,7 +2249,7 @@ function generateDestroyFunction(klass, snakeName, typeName, allProperties) {
             freeStatements.push(`    if (instance->${prop.name}) free(instance->${prop.name});`);
         }
         else if (prop.type === "ref") {
-            if (typeMaps$1[prop.childType]) {
+            if (typeMaps$2[prop.childType]) {
                 freeStatements.push(`    if (instance->${prop.name}) free(instance->${prop.name});`);
             }
             else {
@@ -2128,16 +2286,16 @@ function getAllProperties(klass, allClasses) {
 
 var c = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    generate: generate$2,
-    name: name$1,
-    renderBundle: renderBundle$1
+    generate: generate$3,
+    name: name$2,
+    renderBundle: renderBundle$2
 });
 
-const name = "GDScript";
+const name$1 = "GDScript";
 /**
  * Type mappings from schema types to GDScript Colyseus.Schema type constants
  */
-const typeMaps = {
+const typeMaps$1 = {
     "string": "Colyseus.Schema.STRING",
     "number": "Colyseus.Schema.NUMBER",
     "boolean": "Colyseus.Schema.BOOLEAN",
@@ -2157,42 +2315,42 @@ const containerMaps = {
     "map": "Colyseus.Schema.MAP",
     "ref": "Colyseus.Schema.REF",
 };
-const distinct = (value, index, self) => self.indexOf(value) === index;
+const distinct$1 = (value, index, self) => self.indexOf(value) === index;
 /**
  * GDScript Code Generator
  */
 /**
  * Generate individual files for each class
  */
-function generate$1(context, options) {
+function generate$2(context, options) {
     // Enrich typeMaps with enums
     context.enums.forEach((structure) => {
-        typeMaps[structure.name] = structure.name;
+        typeMaps$1[structure.name] = structure.name;
     });
     return [
         ...context.classes.map(klass => ({
             name: `${klass.name}.gd`,
-            content: generateClass(klass, options.namespace, context.classes)
+            content: generateClass$1(klass, options.namespace, context.classes)
         })),
         ...context.enums.filter(structure => structure.name !== 'OPERATION').map((structure) => ({
             name: `${structure.name}.gd`,
-            content: generateEnum(structure, options.namespace),
+            content: generateEnum$1(structure, options.namespace),
         })),
     ];
 }
 /**
  * Generate a single bundled file containing all classes and enums
  */
-function renderBundle(context, options) {
+function renderBundle$1(context, options) {
     const fileName = options.namespace ? `${options.namespace}.gd` : "schema.gd";
     // Enrich typeMaps with enums
     context.enums.forEach((structure) => {
-        typeMaps[structure.name] = structure.name;
+        typeMaps$1[structure.name] = structure.name;
     });
     const enumBodies = context.enums
         .filter(structure => structure.name !== 'OPERATION')
-        .map(e => generateEnumBody(e));
-    const classBodies = context.classes.map(klass => generateClassBody(klass));
+        .map(e => generateEnumBody$1(e));
+    const classBodies = context.classes.map(klass => generateClassBody$1(klass));
     const content = `${getCommentHeader("#")}
 
 ${enumBodies.length > 0 ? enumBodies.join("\n\n") + "\n\n" : ""}${classBodies.join("\n\n")}
@@ -2202,7 +2360,7 @@ ${enumBodies.length > 0 ? enumBodies.join("\n\n") + "\n\n" : ""}${classBodies.jo
 /**
  * Generate just the class body (without preload) for bundling
  */
-function generateClassBody(klass) {
+function generateClassBody$1(klass) {
     // Determine parent class
     const parentClass = (klass.extends !== "Schema")
         ? klass.extends
@@ -2236,7 +2394,7 @@ function generateToStringMethod(className, properties) {
 /**
  * Generate a complete class file with preload (for individual file mode)
  */
-function generateClass(klass, namespace, allClasses) {
+function generateClass$1(klass, namespace, allClasses) {
     const allRefs = [];
     klass.properties.forEach(property => {
         let type = property.type;
@@ -2247,15 +2405,15 @@ function generateClass(klass, namespace, allClasses) {
     });
     // Get required preloads for referenced types
     const preloads = allRefs
-        .filter(ref => ref.childType && typeMaps[ref.childType] === undefined)
+        .filter(ref => ref.childType && typeMaps$1[ref.childType] === undefined)
         .map(ref => ref.childType)
         .concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name))
-        .filter(distinct)
+        .filter(distinct$1)
         .map(childType => `const ${childType} = preload("${childType}.gd")`)
         .join("\n");
     return `${getCommentHeader("#")}
 
-${preloads ? preloads + "\n\n" : ""}${generateClassBody(klass)}
+${preloads ? preloads + "\n\n" : ""}${generateClassBody$1(klass)}
 `;
 }
 /**
@@ -2267,12 +2425,12 @@ function generateFieldDefinition(prop) {
         const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
         // Array or Map container
         const containerType = containerMaps[prop.type];
-        const childTypeRef = isUpcaseFirst ? prop.childType : typeMaps[prop.childType] || `"${prop.childType}"`;
+        const childTypeRef = isUpcaseFirst ? prop.childType : typeMaps$1[prop.childType] || `"${prop.childType}"`;
         args = [`"${prop.name}"`, containerType, childTypeRef];
     }
     else {
         // Primitive type
-        const typeRef = typeMaps[prop.type] || `"${prop.type}"`;
+        const typeRef = typeMaps$1[prop.type] || `"${prop.type}"`;
         args = [`"${prop.name}"`, typeRef];
     }
     return `\t\t\tColyseus.Schema.Field.new(${args.join(", ")})`;
@@ -2280,7 +2438,7 @@ function generateFieldDefinition(prop) {
 /**
  * Generate just the enum body for bundling
  */
-function generateEnumBody(_enum) {
+function generateEnumBody$1(_enum) {
     const enumValues = _enum.properties.map((prop, index) => {
         let value;
         if (prop.type) {
@@ -2303,21 +2461,274 @@ ${enumValues}
 /**
  * Generate a complete enum file (for individual file mode)
  */
-function generateEnum(_enum, _namespace) {
+function generateEnum$1(_enum, _namespace) {
     return `${getCommentHeader("#")}
 
-${generateEnumBody(_enum)}
+${generateEnumBody$1(_enum)}
 `;
 }
 
 var gdscript = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    generate: generate$2,
+    name: name$1,
+    renderBundle: renderBundle$1
+});
+
+const name = "Dart/Flutter";
+/**
+ * Dart types for interface (plain message) properties. Schema scalar getters
+ * don't use this table: the `colyseus` package reads every numeric field as
+ * `double` through `SchemaView`, so all numeric schema types collapse there.
+ */
+const typeMaps = {
+    "string": "String",
+    "number": "double",
+    "boolean": "bool",
+    "int8": "double",
+    "uint8": "double",
+    "int16": "double",
+    "uint16": "double",
+    "int32": "double",
+    "uint32": "double",
+    "int64": "double",
+    "uint64": "double",
+    "float32": "double",
+    "float64": "double",
+};
+const enumNames = new Set();
+const COMMON_IMPORTS = `import 'package:colyseus/colyseus.dart';`;
+// Field names come from the server schema and may not be lowerCamelCase.
+const LINT_HEADER = `// ignore_for_file: non_constant_identifier_names, constant_identifier_names`;
+const distinct = (value, index, self) => self.indexOf(value) === index;
+const isSchemaType = (childType) => childType !== undefined && /^[A-Z]/.test(childType) && !enumNames.has(childType);
+/**
+ * Dart Code Generator
+ *
+ * Emits typed façades over the `colyseus` Flutter package's runtime: one
+ * `SchemaRef` subclass per schema, with typed getters over the shared native
+ * handle. Collection getters return `MapSchema<T>` / `ArraySchema<T>`, which
+ * also carry the field they came from — that is what
+ * `callbacks.onAdd(state.players, ...)` registers against.
+ */
+/**
+ * Generate individual files for each class/interface/enum
+ */
+function generate$1(context, options) {
+    context.enums.forEach((structure) => enumNames.add(structure.name));
+    return [
+        ...context.classes.map(klass => ({
+            name: `${klass.name}.dart`,
+            content: generateClass(klass, context.classes)
+        })),
+        ...context.interfaces.map(structure => ({
+            name: `${structure.name}.dart`,
+            content: generateInterface(structure),
+        })),
+        ...context.enums.filter(structure => structure.name !== 'OPERATION').map((structure) => ({
+            name: `${structure.name}.dart`,
+            content: generateEnum(structure),
+        })),
+    ];
+}
+/**
+ * Generate a single bundled file containing all classes, interfaces, and enums
+ */
+function renderBundle(context, options) {
+    const fileName = options.namespace ? `${options.namespace}.dart` : "schema.dart";
+    context.enums.forEach((structure) => enumNames.add(structure.name));
+    const bodies = [
+        ...context.classes.map(klass => generateClassBody(klass, context.classes)),
+        ...context.interfaces.map(iface => generateInterfaceBody(iface)),
+        ...context.enums
+            .filter(structure => structure.name !== 'OPERATION')
+            .map(e => generateEnumBody(e)),
+    ].join("\n\n");
+    const content = `${getCommentHeader()}
+${LINT_HEADER}
+
+${COMMON_IMPORTS}
+
+${bodies}
+`;
+    return { name: fileName, content };
+}
+/**
+ * Generate just the class body (without imports) for bundling
+ */
+function generateClassBody(klass, allClasses) {
+    // `SchemaRef` is a `base` class, so subclasses carry a modifier: `base`
+    // when the class is itself extended (extendable from any file), `final`
+    // otherwise.
+    const isExtended = allClasses.some(other => other.extends === klass.name);
+    const modifier = isExtended ? "base" : "final";
+    const parent = (klass.extends === "Schema") ? "SchemaRef" : klass.extends;
+    const getters = klass.properties
+        .map(prop => generateGetter(prop))
+        .filter(Boolean)
+        .join("\n");
+    return `${modifier} class ${klass.name} extends ${parent} {
+  ${klass.name}(super.handle);
+
+${getters}
+}`;
+}
+/**
+ * Generate a complete class file with imports (for individual file mode)
+ */
+function generateClass(klass, allClasses) {
+    const localRefs = klass.properties
+        .filter(prop => isSchemaType(prop.childType))
+        .map(prop => prop.childType)
+        .concat(klass.extends !== "Schema" ? [klass.extends] : [])
+        .filter(distinct)
+        .filter(ref => ref !== klass.name)
+        .map(ref => `import '${ref}.dart';`)
+        .join("\n");
+    return `${getCommentHeader()}
+${LINT_HEADER}
+
+${COMMON_IMPORTS}
+${localRefs ? localRefs + "\n" : ""}
+${generateClassBody(klass, allClasses)}
+`;
+}
+/**
+ * The Dart type a scalar schema field reads as, or undefined when the field
+ * can only be read dynamically (enum-typed and unknown types).
+ */
+function scalarDartType(type) {
+    if (type === "string") {
+        return "String";
+    }
+    if (type === "boolean") {
+        return "bool";
+    }
+    if (typeMaps[type] === "double" || type === "quantized" || type === "number") {
+        return "double";
+    }
+    return undefined;
+}
+function generateGetter(prop) {
+    const deprecation = (prop.deprecated)
+        ? `  @Deprecated("field '${prop.name}' is deprecated.")\n`
+        : '';
+    let body;
+    if (prop.childType && isSchemaType(prop.childType)) {
+        if (prop.type === "ref") {
+            body = `  ${prop.childType}? get ${prop.name} => refOf('${prop.name}', ${prop.childType}.new);`;
+        }
+        else if (prop.type === "map") {
+            body = `  MapSchema<${prop.childType}> get ${prop.name} => mapOf('${prop.name}', ${prop.childType}.new);`;
+        }
+        else {
+            body = `  ArraySchema<${prop.childType}> get ${prop.name} => arrayOf('${prop.name}', ${prop.childType}.new);`;
+        }
+    }
+    else if (prop.childType) {
+        const child = typeMaps[prop.childType] ?? "dynamic";
+        if (prop.type === "map") {
+            body = `  MapSchema<${child}> get ${prop.name} => primitiveMapOf('${prop.name}');`;
+        }
+        else if (prop.type === "array") {
+            body = `  ArraySchema<${child}> get ${prop.name} => primitiveArrayOf('${prop.name}');`;
+        }
+        else {
+            // A "ref" with a primitive child has no typed shape to offer.
+            body = `  dynamic get ${prop.name} => this['${prop.name}'];`;
+        }
+    }
+    else {
+        const dartType = scalarDartType(prop.type);
+        if (dartType === "String") {
+            body = `  String get ${prop.name} => view.getString('${prop.name}') ?? '';`;
+        }
+        else if (dartType === "bool") {
+            body = `  bool get ${prop.name} => view.getBool('${prop.name}');`;
+        }
+        else if (dartType === "double") {
+            body = `  double get ${prop.name} => view['${prop.name}'];`;
+        }
+        else {
+            // Enum-typed or unknown: read through the untyped accessor.
+            body = `  dynamic get ${prop.name} => this['${prop.name}'];`;
+        }
+    }
+    return deprecation + body;
+}
+/**
+ * Generate just the interface body for bundling
+ */
+function generateInterfaceBody(struct) {
+    const fields = struct.properties
+        .map(prop => `  ${getInterfaceType(prop)}? ${prop.name};`)
+        .join("\n");
+    return `class ${struct.name} {
+${fields}
+}`;
+}
+/**
+ * Generate a complete interface file (for individual file mode)
+ */
+function generateInterface(struct) {
+    const localRefs = struct.properties
+        .filter(prop => isSchemaType(prop.childType ?? (typeMaps[prop.type] ? undefined : prop.type)))
+        .map(prop => prop.childType ?? prop.type)
+        .filter(distinct)
+        .map(ref => `import '${ref}.dart';`)
+        .join("\n");
+    return `${getCommentHeader()}
+${LINT_HEADER}
+${localRefs ? "\n" + localRefs + "\n" : ""}
+${generateInterfaceBody(struct)}
+`;
+}
+function getInterfaceType(prop) {
+    if (prop.type === "array") {
+        return `List<${typeMaps[prop.childType] ?? prop.childType ?? "dynamic"}>`;
+    }
+    return typeMaps[prop.type] ?? prop.type ?? "dynamic";
+}
+/**
+ * Generate just the enum body for bundling: a namespace of consts, since
+ * Colyseus enums may carry string or float values Dart enums can't.
+ */
+function generateEnumBody(_enum) {
+    const members = _enum.properties
+        .map((prop, i) => {
+        let value;
+        if (prop.type) {
+            value = isNaN(Number(prop.type)) ? `"${prop.type}"` : `${Number(prop.type)}`;
+        }
+        else {
+            value = `${i}`;
+        }
+        return `  static const ${prop.name} = ${value};`;
+    })
+        .join("\n");
+    return `abstract final class ${_enum.name} {
+${members}
+}`;
+}
+/**
+ * Generate a complete enum file (for individual file mode)
+ */
+function generateEnum(_enum) {
+    return `${getCommentHeader()}
+${LINT_HEADER}
+
+${generateEnumBody(_enum)}
+`;
+}
+
+var dart = /*#__PURE__*/Object.freeze({
     __proto__: null,
     generate: generate$1,
     name: name,
     renderBundle: renderBundle
 });
 
-const generators = { csharp, cpp, haxe, ts, js, java, lua, c, gdscript, };
+const generators = { csharp, cpp, haxe, ts, js, java, lua, c, gdscript, dart, };
 function generate(targetId, options) {
     const generator = generators[targetId];
     if (!generator) {