@colyseus/schema 4.0.13 → 4.0.15

package/build/codegen/cli.cjs

@@ -3,7 +3,7 @@
 
 var fs = require('fs');
 var path = require('path');
-var ts = require('typescript');
+var ts$1 = require('typescript');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
@@ -25,7 +25,7 @@ function _interopNamespaceDefault(e) {
 
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
-var ts__namespace = /*#__PURE__*/_interopNamespaceDefault(ts);
+var ts__namespace = /*#__PURE__*/_interopNamespaceDefault(ts$1);
 
 /**
  * @author Ethan Davis
@@ -271,9 +271,13 @@ function inspectNode(node, context, decoratorName) {
             break;
         case ts__namespace.SyntaxKind.PropertySignature:
             if (currentStructure instanceof Interface) {
-                const interfaceDeclaration = node.parent;
-                if (currentStructure.name !== interfaceDeclaration.name.escapedText.toString()) {
-                    // skip if property if for a another interface than the one we're interested in.
+                const parent = node.parent;
+                // Only process direct children of InterfaceDeclaration, skip TypeLiterals
+                if (!ts__namespace.isInterfaceDeclaration(parent)) {
+                    break;
+                }
+                // Skip if property if for a another interface than the one we're interested in.
+                if (currentStructure.name !== parent.name.escapedText.toString()) {
                     break;
                 }
                 // define a property of an interface
@@ -538,7 +542,8 @@ function getDecorators(node) {
     return node.modifiers?.filter(ts__namespace.isDecorator);
 }
 
-const typeMaps$6 = {
+const name$8 = "Unity/C#";
+const typeMaps$8 = {
     "string": "string",
     "number": "float",
     "boolean": "bool",
@@ -553,6 +558,10 @@ const typeMaps$6 = {
     "float32": "float",
     "float64": "double",
 };
+const COMMON_IMPORTS$5 = `using Colyseus.Schema;
+#if UNITY_5_3_OR_NEWER
+using UnityEngine.Scripting;
+#endif`;
 /**
  * C# Code Generator
  */
@@ -561,15 +570,18 @@ const capitalize$1 = (s) => {
         return '';
     return s.charAt(0).toUpperCase() + s.slice(1);
 };
-function generate$7(context, options) {
+/**
+ * Generate individual files for each class/interface/enum
+ */
+function generate$9(context, options) {
     // enrich typeMaps with enums
     context.enums.forEach((structure) => {
-        typeMaps$6[structure.name] = structure.name;
+        typeMaps$8[structure.name] = structure.name;
     });
     return [
         ...context.classes.map(structure => ({
             name: `${structure.name}.cs`,
-            content: generateClass$6(structure, options.namespace)
+            content: generateClass$8(structure, options.namespace)
         })),
         ...context.interfaces.map(structure => ({
             name: `${structure.name}.cs`,
@@ -577,34 +589,65 @@ function generate$7(context, options) {
         })),
         ...context.enums.filter(structure => structure.name !== 'OPERATION').map((structure) => ({
             name: `${structure.name}.cs`,
-            content: generateEnum(structure, options.namespace),
+            content: generateEnum$1(structure, options.namespace),
         })),
     ];
 }
-function generateClass$6(klass, namespace) {
-    const indent = (namespace) ? "\t" : "";
-    return `${getCommentHeader()}
+/**
+ * Generate a single bundled file containing all classes, interfaces, and enums
+ */
+function renderBundle$8(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;
+    });
+    // Collect all bodies
+    const classBodies = context.classes.map(klass => generateClassBody$8(klass, indent));
+    const interfaceBodies = context.interfaces.map(iface => generateInterfaceBody$1(iface, indent));
+    const enumBodies = context.enums
+        .filter(structure => structure.name !== 'OPERATION')
+        .map(e => generateEnumBody$1(e, indent));
+    const allBodies = [...classBodies, ...interfaceBodies, ...enumBodies].join("\n\n");
+    const content = `${getCommentHeader()}
 
-using Colyseus.Schema;
-#if UNITY_5_3_OR_NEWER
-using UnityEngine.Scripting;
-#endif
-${namespace ? `\nnamespace ${namespace} {` : ""}
-${indent}public partial class ${klass.name} : ${klass.extends} {
+${COMMON_IMPORTS$5}
+${options.namespace ? `\nnamespace ${options.namespace} {\n` : ""}
+${allBodies}
+${options.namespace ? "}" : ""}`;
+    return { name: fileName, content };
+}
+/**
+ * Generate just the class body (without imports/namespace) for bundling
+ */
+function generateClassBody$8(klass, indent = "") {
+    return `${indent}public partial class ${klass.name} : ${klass.extends} {
 #if UNITY_5_3_OR_NEWER
 [Preserve]
 #endif
 public ${klass.name}() { }
 ${klass.properties.map((prop) => generateProperty$4(prop, indent)).join("\n\n")}
-${indent}}
-${namespace ? "}" : ""}
-`;
+${indent}}`;
 }
-function generateEnum(_enum, namespace) {
-    const indent = namespace ? "\t" : "";
+/**
+ * Generate a complete class file with imports/namespace (for individual file mode)
+ */
+function generateClass$8(klass, namespace) {
+    const indent = (namespace) ? "\t" : "";
     return `${getCommentHeader()}
+
+${COMMON_IMPORTS$5}
 ${namespace ? `\nnamespace ${namespace} {` : ""}
-${indent}public struct ${_enum.name} {
+${generateClassBody$8(klass, indent)}
+${namespace ? "}" : ""}
+`;
+}
+/**
+ * Generate just the enum body (without imports/namespace) for bundling
+ */
+function generateEnumBody$1(_enum, indent = "") {
+    return `${indent}public struct ${_enum.name} {
 
 ${_enum.properties
         .map((prop) => {
@@ -626,7 +669,16 @@ ${_enum.properties
         return `${indent}\tpublic const ${dataType} ${prop.name} = ${value};`;
     })
         .join("\n")}
-${indent}}
+${indent}}`;
+}
+/**
+ * Generate a complete enum file with imports/namespace (for individual file mode)
+ */
+function generateEnum$1(_enum, namespace) {
+    const indent = namespace ? "\t" : "";
+    return `${getCommentHeader()}
+${namespace ? `\nnamespace ${namespace} {` : ""}
+${generateEnumBody$1(_enum, indent)}
 ${namespace ? "}" : ""}`;
 }
 function generateProperty$4(prop, indent = "") {
@@ -652,20 +704,29 @@ function generateProperty$4(prop, indent = "") {
     return ret + `\t${indent}[Type(${prop.index}, ${typeArgs})]
 \t${indent}${property} = ${initializer};`;
 }
+/**
+ * Generate just the interface body (without imports/namespace) for bundling
+ */
+function generateInterfaceBody$1(struct, indent = "") {
+    return `${indent}public class ${struct.name} {
+${struct.properties.map(prop => `\t${indent}public ${getType(prop)} ${prop.name};`).join("\n")}
+${indent}}`;
+}
+/**
+ * Generate a complete interface file with imports/namespace (for individual file mode)
+ */
 function generateInterface$1(struct, namespace) {
     const indent = (namespace) ? "\t" : "";
     return `${getCommentHeader()}
 
 using Colyseus.Schema;
 ${namespace ? `\nnamespace ${namespace} {` : ""}
-${indent}public class ${struct.name} {
-${struct.properties.map(prop => `\t${indent}public ${getType(prop)} ${prop.name};`).join("\n")}
-${indent}}
+${generateInterfaceBody$1(struct, indent)}
 ${namespace ? "}" : ""}
 `;
 }
 function getChildType(prop) {
-    return typeMaps$6[prop.childType];
+    return typeMaps$8[prop.childType];
 }
 function getType(prop) {
     if (prop.childType) {
@@ -686,12 +747,20 @@ function getType(prop) {
     }
     else {
         return (prop.type === "array")
-            ? `${typeMaps$6[prop.childType] || prop.childType}[]`
-            : typeMaps$6[prop.type];
+            ? `${typeMaps$8[prop.childType] || prop.childType}[]`
+            : typeMaps$8[prop.type];
     }
 }
 
-const typeMaps$5 = {
+var csharp = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    generate: generate$9,
+    name: name$8,
+    renderBundle: renderBundle$8
+});
+
+const name$7 = "C++";
+const typeMaps$7 = {
     "string": "string",
     "number": "varint_t",
     "boolean": "bool",
@@ -721,6 +790,11 @@ const typeInitializer$2 = {
     "float32": "0",
     "float64": "0",
 };
+const COMMON_INCLUDES$1 = `#include "schema.h"
+#include <typeinfo>
+#include <typeindex>
+
+using namespace colyseus::schema;`;
 /**
  * C++ Code Generator
  */
@@ -729,14 +803,41 @@ const capitalize = (s) => {
         return '';
     return s.charAt(0).toUpperCase() + s.slice(1);
 };
-const distinct$3 = (value, index, self) => self.indexOf(value) === index;
-function generate$6(context, options) {
+const distinct$5 = (value, index, self) => self.indexOf(value) === index;
+/**
+ * Generate individual files for each class
+ */
+function generate$8(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".hpp",
-        content: generateClass$5(klass, options.namespace, context.classes)
+        content: generateClass$7(klass, options.namespace, context.classes)
     }));
 }
-function generateClass$5(klass, namespace, allClasses) {
+/**
+ * Generate a single bundled header file containing all classes
+ */
+function renderBundle$7(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 content = `${getCommentHeader()}
+#ifndef ${guardName}
+#define ${guardName} 1
+
+${COMMON_INCLUDES$1}
+
+${options.namespace ? `namespace ${options.namespace} {\n` : ""}
+${classBodies.join("\n\n")}
+${options.namespace ? "}" : ""}
+
+#endif
+`;
+    return { name: fileName, content };
+}
+/**
+ * Generate just the class body (without includes/guards) for bundling
+ */
+function generateClassBody$7(klass, allClasses, namespace) {
     const propertiesPerType = {};
     const allRefs = [];
     klass.properties.forEach(property => {
@@ -750,32 +851,13 @@ function generateClass$5(klass, namespace, allClasses) {
             allRefs.push(property);
         }
     });
-    const allProperties = getAllProperties(klass, allClasses);
+    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$5[property.childType] === undefined)}
+\t\t${generateFieldIfElseChain(allRefs, (property) => `type == typeid(${property.childType})`, (property) => `return new ${property.childType}();`, (property) => typeMaps$7[property.childType] === undefined)}
 \t\treturn ${klass.extends}::createInstance(type);
 \t}`;
-    return `${getCommentHeader()}
-#ifndef __SCHEMA_CODEGEN_${klass.name.toUpperCase()}_H__
-#define __SCHEMA_CODEGEN_${klass.name.toUpperCase()}_H__ 1
-
-#include "schema.h"
-#include <typeinfo>
-#include <typeindex>
-
-${allRefs.
-        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).
-        map(childType => `#include "${childType}.hpp"`).
-        join("\n")}
-
-using namespace colyseus::schema;
-
-${namespace ? `namespace ${namespace} {` : ""}
-class ${klass.name} : public ${klass.extends} {
+    return `class ${klass.name} : public ${klass.extends} {
 public:
 ${klass.properties.map(prop => generateProperty$3(prop)).join("\n")}
 
@@ -795,7 +877,36 @@ ${Object.keys(propertiesPerType).map(type => generateGettersAndSetters(klass, ty
         join("\n")}
 
 ${createInstanceMethod}
-};
+};`;
+}
+/**
+ * Generate a complete class file with includes/guards (for individual file mode)
+ */
+function generateClass$7(klass, namespace, allClasses) {
+    const allRefs = [];
+    klass.properties.forEach(property => {
+        let type = property.type;
+        // keep all refs list
+        if ((type === "ref" || type === "array" || type === "map")) {
+            allRefs.push(property);
+        }
+    });
+    const localIncludes = allRefs.
+        filter(ref => ref.childType && typeMaps$7[ref.childType] === undefined).
+        map(ref => ref.childType).
+        concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
+        filter(distinct$5).
+        map(childType => `#include "${childType}.hpp"`).
+        join("\n");
+    return `${getCommentHeader()}
+#ifndef __SCHEMA_CODEGEN_${klass.name.toUpperCase()}_H__
+#define __SCHEMA_CODEGEN_${klass.name.toUpperCase()}_H__ 1
+
+${COMMON_INCLUDES$1}
+${localIncludes}
+
+${namespace ? `namespace ${namespace} {` : ""}
+${generateClassBody$7(klass, allClasses)}
 ${namespace ? "}" : ""}
 
 #endif
@@ -815,26 +926,26 @@ function generateProperty$3(prop) {
         else if (prop.type === "array") {
             langType = (isUpcaseFirst)
                 ? `ArraySchema<${prop.childType}*>`
-                : `ArraySchema<${typeMaps$5[prop.childType]}>`;
+                : `ArraySchema<${typeMaps$7[prop.childType]}>`;
             initializer = `new ${langType}()`;
         }
         else if (prop.type === "map") {
             langType = (isUpcaseFirst)
                 ? `MapSchema<${prop.childType}*>`
-                : `MapSchema<${typeMaps$5[prop.childType]}>`;
+                : `MapSchema<${typeMaps$7[prop.childType]}>`;
             initializer = `new ${langType}()`;
         }
         isPropPointer = "*";
     }
     else {
-        langType = typeMaps$5[prop.type];
+        langType = typeMaps$7[prop.type];
         initializer = typeInitializer$2[prop.type];
     }
     property += ` ${langType} ${isPropPointer}${prop.name}`;
     return `\t${property} = ${initializer};`;
 }
 function generateGettersAndSetters(klass, type, properties) {
-    let langType = typeMaps$5[type];
+    let langType = typeMaps$7[type];
     let typeCast = "";
     const getMethodName = `get${capitalize(type)}`;
     const setMethodName = `set${capitalize(type)}`;
@@ -858,7 +969,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$5[property.childType] === undefined);
+        const isSchemaType = (typeMaps$7[property.childType] === undefined);
         if (type === "ref") {
             langType = `${property.childType}*`;
             typeCast = (isSchemaType)
@@ -868,12 +979,12 @@ function generateGettersAndSetters(klass, type, properties) {
         else if (type === "array") {
             typeCast = (isSchemaType)
                 ? `(ArraySchema<${property.childType}*> *)`
-                : `(ArraySchema<${typeMaps$5[property.childType]}> *)`;
+                : `(ArraySchema<${typeMaps$7[property.childType]}> *)`;
         }
         else if (type === "map") {
             typeCast = (isSchemaType)
                 ? `(MapSchema<${property.childType}*> *)`
-                : `(MapSchema<${typeMaps$5[property.childType]}> *)`;
+                : `(MapSchema<${typeMaps$7[property.childType]}> *)`;
         }
         return `this->${property.name} = ${typeCast}value;\n\t\t\treturn;`;
     })}
@@ -912,7 +1023,7 @@ function generateAllTypes(properties) {
 }
 function generateAllChildSchemaTypes(properties) {
     return `{${properties.map((property, i) => {
-        if (property.childType && typeMaps$5[property.childType] === undefined) {
+        if (property.childType && typeMaps$7[property.childType] === undefined) {
             return `{${i}, typeid(${property.childType})}`;
         }
         else {
@@ -922,7 +1033,7 @@ function generateAllChildSchemaTypes(properties) {
 }
 function generateAllChildPrimitiveTypes(properties) {
     return `{${properties.map((property, i) => {
-        if (typeMaps$5[property.childType] !== undefined) {
+        if (typeMaps$7[property.childType] !== undefined) {
             return `{${i}, "${property.childType}"}`;
         }
         else {
@@ -940,7 +1051,7 @@ function generateDestructors(properties) {
         }
     }).filter(r => r !== null);
 }
-function getAllProperties(klass, allClasses) {
+function getAllProperties$1(klass, allClasses) {
     let properties = [];
     getInheritanceTree(klass, allClasses).reverse().forEach((klass) => {
         properties = properties.concat(klass.properties);
@@ -948,7 +1059,15 @@ function getAllProperties(klass, allClasses) {
     return properties;
 }
 
-const typeMaps$4 = {
+var cpp = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    generate: generate$8,
+    name: name$7,
+    renderBundle: renderBundle$7
+});
+
+const name$6 = "Haxe";
+const typeMaps$6 = {
     "string": "String",
     "number": "Dynamic",
     "boolean": "Bool",
@@ -978,22 +1097,50 @@ const typeInitializer$1 = {
     "float32": "0",
     "float64": "0",
 };
-function generate$5(context, options) {
+const COMMON_IMPORTS$4 = `import io.colyseus.serializer.schema.Schema;
+import io.colyseus.serializer.schema.types.*;`;
+/**
+ * Generate individual files for each class
+ */
+function generate$7(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".hx",
-        content: generateClass$4(klass, options.namespace, context.classes)
+        content: generateClass$6(klass, options.namespace, context.classes)
     }));
 }
-function generateClass$4(klass, namespace, allClasses) {
-    return `${getCommentHeader()}
+/**
+ * Generate a single bundled file containing all classes
+ */
+function renderBundle$6(context, options) {
+    const fileName = options.namespace ? `${options.namespace}.hx` : "Schema.hx";
+    const classBodies = context.classes.map(klass => generateClassBody$6(klass));
+    const content = `${getCommentHeader()}
 
-${namespace ? `package ${namespace};` : ""}
-import io.colyseus.serializer.schema.Schema;
-import io.colyseus.serializer.schema.types.*;
+${options.namespace ? `package ${options.namespace};` : ""}
+${COMMON_IMPORTS$4}
 
-class ${klass.name} extends ${klass.extends} {
+${classBodies.join("\n\n")}
+`;
+    return { name: fileName, content };
+}
+/**
+ * Generate just the class body (without package/imports) for bundling
+ */
+function generateClassBody$6(klass) {
+    return `class ${klass.name} extends ${klass.extends} {
 ${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) {
+    return `${getCommentHeader()}
+
+${namespace ? `package ${namespace};` : ""}
+${COMMON_IMPORTS$4}
+
+${generateClassBody$6(klass)}
 `;
 }
 function generateProperty$2(prop) {
@@ -1015,18 +1162,18 @@ function generateProperty$2(prop) {
         else if (prop.type === "array") {
             langType = (isUpcaseFirst)
                 ? `ArraySchema<${prop.childType}>`
-                : `ArraySchema<${typeMaps$4[prop.childType]}>`;
+                : `ArraySchema<${typeMaps$6[prop.childType]}>`;
             initializer = `new ${langType}()`;
         }
         else if (prop.type === "map") {
             langType = (isUpcaseFirst)
                 ? `MapSchema<${prop.childType}>`
-                : `MapSchema<${typeMaps$4[prop.childType]}>`;
+                : `MapSchema<${typeMaps$6[prop.childType]}>`;
             initializer = `new ${langType}()`;
         }
     }
     else {
-        langType = typeMaps$4[prop.type];
+        langType = typeMaps$6[prop.type];
         initializer = typeInitializer$1[prop.type];
     }
     // TODO: remove initializer. The callbacks at the Haxe decoder side have a
@@ -1035,7 +1182,15 @@ function generateProperty$2(prop) {
     // return `\t@:type(${typeArgs})\n\tpublic var ${prop.name}: ${langType};\n`
 }
 
-const typeMaps$3 = {
+var haxe = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    generate: generate$7,
+    name: name$6,
+    renderBundle: renderBundle$6
+});
+
+const name$5 = "TypeScript";
+const typeMaps$5 = {
     "string": "string",
     "number": "number",
     "boolean": "boolean",
@@ -1050,12 +1205,16 @@ const typeMaps$3 = {
     "float32": "number",
     "float64": "number",
 };
-const distinct$2 = (value, index, self) => self.indexOf(value) === index;
-function generate$4(context, options) {
+const COMMON_IMPORTS$3 = `import { Schema, type, ArraySchema, MapSchema, SetSchema, DataChange } from '@colyseus/schema';`;
+const distinct$4 = (value, index, self) => self.indexOf(value) === index;
+/**
+ * Generate individual files for each class/interface
+ */
+function generate$6(context, options) {
     return [
         ...context.classes.map(structure => ({
             name: structure.name + ".ts",
-            content: generateClass$3(structure, options.namespace, context.classes)
+            content: generateClass$5(structure, options.namespace, context.classes)
         })),
         ...context.interfaces.map(structure => ({
             name: structure.name + ".ts",
@@ -1063,7 +1222,43 @@ function generate$4(context, options) {
         }))
     ];
 }
-function generateClass$3(klass, namespace, allClasses) {
+/**
+ * Generate a single bundled file containing all classes and interfaces
+ */
+function renderBundle$5(context, options) {
+    const fileName = options.namespace ? `${options.namespace}.ts` : "schema.ts";
+    // Collect all class bodies
+    const classBodies = context.classes.map(klass => generateClassBody$5(klass));
+    // Collect all interface bodies
+    const interfaceBodies = context.interfaces.map(iface => generateInterfaceBody(iface));
+    const content = `${getCommentHeader()}
+
+${COMMON_IMPORTS$3}
+
+${classBodies.join("\n\n")}
+${interfaceBodies.length > 0 ? "\n" + interfaceBodies.join("\n\n") : ""}`;
+    return { name: fileName, content };
+}
+/**
+ * Generate just the class body (without imports) for bundling
+ */
+function generateClassBody$5(klass) {
+    return `export class ${klass.name} extends ${klass.extends} {
+${klass.properties.map(prop => `    ${generateProperty$1(prop)}`).join("\n")}
+}`;
+}
+/**
+ * Generate just the interface body (without imports) for bundling
+ */
+function generateInterfaceBody(iface) {
+    return `export interface ${iface.name} {
+${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) {
     const allRefs = [];
     klass.properties.forEach(property => {
         let type = property.type;
@@ -1072,20 +1267,19 @@ function generateClass$3(klass, namespace, allClasses) {
             allRefs.push(property);
         }
     });
-    return `${getCommentHeader()}
-
-import { Schema, type, ArraySchema, MapSchema, SetSchema, DataChange } from '@colyseus/schema';
-${allRefs.
-        filter(ref => ref.childType && typeMaps$3[ref.childType] === undefined).
+    const localImports = allRefs.
+        filter(ref => ref.childType && typeMaps$5[ref.childType] === undefined).
         map(ref => ref.childType).
         concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
-        filter(distinct$2).
+        filter(distinct$4).
         map(childType => `import { ${childType} } from './${childType}'`).
-        join("\n")}
+        join("\n");
+    return `${getCommentHeader()}
 
-export class ${klass.name} extends ${klass.extends} {
-${klass.properties.map(prop => `    ${generateProperty$1(prop)}`).join("\n")}
-}
+${COMMON_IMPORTS$3}
+${localImports}
+
+${generateClassBody$5(klass)}
 `;
 }
 function generateProperty$1(prop) {
@@ -1108,7 +1302,7 @@ function generateProperty$1(prop) {
         else if (prop.type === "array") {
             langType = (isUpcaseFirst)
                 ? `ArraySchema<${prop.childType}>`
-                : `ArraySchema<${typeMaps$3[prop.childType]}>`;
+                : `ArraySchema<${typeMaps$5[prop.childType]}>`;
             initializer = `new ${langType}()`;
             typeArgs = (isUpcaseFirst)
                 ? `[ ${prop.childType} ]`
@@ -1117,7 +1311,7 @@ function generateProperty$1(prop) {
         else if (prop.type === "map") {
             langType = (isUpcaseFirst)
                 ? `MapSchema<${prop.childType}>`
-                : `MapSchema<${typeMaps$3[prop.childType]}>`;
+                : `MapSchema<${typeMaps$5[prop.childType]}>`;
             initializer = `new ${langType}()`;
             typeArgs = (isUpcaseFirst)
                 ? `{ map: ${prop.childType} }`
@@ -1126,7 +1320,7 @@ function generateProperty$1(prop) {
         else if (prop.type === "set") {
             langType = (isUpcaseFirst)
                 ? `SetSchema<${prop.childType}>`
-                : `SetSchema<${typeMaps$3[prop.childType]}>`;
+                : `SetSchema<${typeMaps$5[prop.childType]}>`;
             initializer = `new ${langType}()`;
             typeArgs = (isUpcaseFirst)
                 ? `{ set: ${prop.childType} }`
@@ -1134,23 +1328,32 @@ function generateProperty$1(prop) {
         }
     }
     else {
-        langType = typeMaps$3[prop.type];
+        langType = typeMaps$5[prop.type];
         typeArgs = `"${prop.type}"`;
     }
     // TS1263: "Declarations with initializers cannot also have definite assignment assertions"
     const definiteAssertion = initializer ? "" : "!";
     return `@type(${typeArgs}) public ${prop.name}${definiteAssertion}: ${langType}${(initializer) ? ` = ${initializer}` : ""};`;
 }
+/**
+ * Generate a complete interface file with header (for individual file mode)
+ */
 function generateInterface(structure, namespace, allClasses) {
     return `${getCommentHeader()}
 
-export interface ${structure.name} {
-${structure.properties.map(prop => `    ${prop.name}: ${prop.type};`).join("\n")}
-}
+${generateInterfaceBody(structure)}
 `;
 }
 
-const typeMaps$2 = {
+var ts = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    generate: generate$6,
+    name: name$5,
+    renderBundle: renderBundle$5
+});
+
+const name$4 = "JavaScript";
+const typeMaps$4 = {
     "string": "string",
     "number": "number",
     "boolean": "boolean",
@@ -1165,14 +1368,56 @@ const typeMaps$2 = {
     "float32": "number",
     "float64": "number",
 };
-const distinct$1 = (value, index, self) => self.indexOf(value) === index;
-function generate$3(context, options) {
+const COMMON_IMPORTS$2 = `const schema = require("@colyseus/schema");
+const Schema = schema.Schema;
+const type = schema.type;`;
+const distinct$3 = (value, index, self) => self.indexOf(value) === index;
+/**
+ * Generate individual files for each class
+ */
+function generate$5(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".js",
-        content: generateClass$2(klass, options.namespace, context.classes)
+        content: generateClass$4(klass, options.namespace, context.classes)
     }));
 }
-function generateClass$2(klass, namespace, allClasses) {
+/**
+ * Generate a single bundled file containing all classes
+ */
+function renderBundle$4(context, options) {
+    const fileName = options.namespace ? `${options.namespace}.js` : "schema.js";
+    const classBodies = context.classes.map(klass => generateClassBody$4(klass));
+    const classExports = context.classes.map(klass => `    ${klass.name},`).join("\n");
+    const content = `${getCommentHeader()}
+
+${COMMON_IMPORTS$2}
+
+${classBodies.join("\n\n")}
+
+module.exports = {
+${classExports}
+};
+`;
+    return { name: fileName, content };
+}
+/**
+ * Generate just the class body (without imports) for bundling
+ */
+function generateClassBody$4(klass) {
+    return `class ${klass.name} extends ${klass.extends} {
+    constructor () {
+        super();
+${klass.properties.
+        filter(prop => prop.childType !== undefined).
+        map(prop => "        " + generatePropertyInitializer(prop)).join("\n")}
+    }
+}
+${klass.properties.map(prop => generatePropertyDeclaration$1(klass.name, prop)).join("\n")}`;
+}
+/**
+ * Generate a complete class file with imports (for individual file mode)
+ */
+function generateClass$4(klass, namespace, allClasses) {
     const allRefs = [];
     klass.properties.forEach(property => {
         let type = property.type;
@@ -1181,28 +1426,19 @@ function generateClass$2(klass, namespace, allClasses) {
             allRefs.push(property);
         }
     });
-    return `${getCommentHeader()}
-
-const schema = require("@colyseus/schema");
-const Schema = schema.Schema;
-const type = schema.type;
-${allRefs.
-        filter(ref => ref.childType && typeMaps$2[ref.childType] === undefined).
+    const localImports = allRefs.
+        filter(ref => ref.childType && typeMaps$4[ref.childType] === undefined).
         map(ref => ref.childType).
         concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
-        filter(distinct$1).
+        filter(distinct$3).
         map(childType => `const ${childType} = require("./${childType}");`).
-        join("\n")}
+        join("\n");
+    return `${getCommentHeader()}
 
-class ${klass.name} extends ${klass.extends} {
-    constructor () {
-        super();
-${klass.properties.
-        filter(prop => prop.childType !== undefined).
-        map(prop => "        " + generatePropertyInitializer(prop)).join("\n")}
-    }
-}
-${klass.properties.map(prop => generatePropertyDeclaration$1(klass.name, prop)).join("\n")}
+${COMMON_IMPORTS$2}
+${localImports}
+
+${generateClassBody$4(klass)}
 
 export default ${klass.name};
 `;
@@ -1250,7 +1486,15 @@ function generatePropertyInitializer(prop) {
     return `this.${prop.name} = ${initializer}`;
 }
 
-const typeMaps$1 = {
+var js = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    generate: generate$5,
+    name: name$4,
+    renderBundle: renderBundle$4
+});
+
+const name$3 = "Java";
+const typeMaps$3 = {
     "string": "String",
     "number": "float",
     "boolean": "boolean",
@@ -1280,23 +1524,56 @@ const typeInitializer = {
     "float32": "0",
     "float64": "0",
 };
+const COMMON_IMPORTS$1 = `import io.colyseus.serializer.schema.Schema;
+import io.colyseus.serializer.schema.annotations.SchemaClass;
+import io.colyseus.serializer.schema.annotations.SchemaField;`;
 /**
- * C# Code Generator
+ * Java Code Generator
  */
-function generate$2(context, options) {
+/**
+ * Generate individual files for each class
+ */
+function generate$4(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".java",
-        content: generateClass$1(klass, options.namespace)
+        content: generateClass$3(klass, options.namespace)
     }));
 }
-function generateClass$1(klass, namespace) {
+/**
+ * Generate a single bundled file containing all classes
+ * 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) {
+    const fileName = options.namespace ? `Schema.java` : "Schema.java";
+    const classBodies = context.classes.map(klass => generateClassBody$3(klass));
+    const content = `${getCommentHeader()}
+${options.namespace ? `\npackage ${options.namespace};` : ""}
+
+${COMMON_IMPORTS$1}
+
+${classBodies.join("\n\n")}
+`;
+    return { name: fileName, content };
+}
+/**
+ * Generate just the class body (without package/imports) for bundling
+ */
+function generateClassBody$3(klass) {
+    return `@SchemaClass
+class ${klass.name} extends ${klass.extends} {
+${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) {
     const indent = (namespace) ? "\t" : "";
     return `${getCommentHeader()}
 ${namespace ? `\npackage ${namespace};` : ""}
 
-import io.colyseus.serializer.schema.Schema;
-import io.colyseus.serializer.schema.annotations.SchemaClass;
-import io.colyseus.serializer.schema.annotations.SchemaField;
+${COMMON_IMPORTS$1}
 
 @SchemaClass
 ${indent}public class ${klass.name} extends ${klass.extends} {
@@ -1319,7 +1596,7 @@ function generateProperty(prop, indent = "") {
         if (prop.type === "ref") {
             langType = (isUpcaseFirst)
                 ? prop.childType
-                : typeMaps$1[prop.childType];
+                : typeMaps$3[prop.childType];
             initializer = `new ${langType}${(prop.type !== "ref" && isUpcaseFirst) ? "<>" : ""}(${ctorArgs})`;
         }
         else if (prop.type === "array") {
@@ -1341,7 +1618,7 @@ function generateProperty(prop, indent = "") {
         }
     }
     else {
-        langType = typeMaps$1[prop.type];
+        langType = typeMaps$3[prop.type];
         initializer = typeInitializer[prop.type];
     }
     property += ` ${langType} ${prop.name}`;
@@ -1349,12 +1626,20 @@ function generateProperty(prop, indent = "") {
 \t${indent}${property} = ${initializer};`;
 }
 
+var java = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    generate: generate$4,
+    name: name$3,
+    renderBundle: renderBundle$3
+});
+
+const name$2 = "LUA";
 /**
     TODO:
     - Support inheritance
     - Support importing Schema dependencies
 */
-const typeMaps = {
+const typeMaps$2 = {
     "string": "string",
     "number": "number",
     "boolean": "boolean",
@@ -1369,14 +1654,55 @@ const typeMaps = {
     "float32": "number",
     "float64": "number",
 };
-const distinct = (value, index, self) => self.indexOf(value) === index;
-function generate$1(context, options) {
+const COMMON_IMPORTS = `local schema = require 'colyseus.serializer.schema.schema'`;
+const distinct$2 = (value, index, self) => self.indexOf(value) === index;
+/**
+ * Generate individual files for each class
+ */
+function generate$3(context, options) {
     return context.classes.map(klass => ({
         name: klass.name + ".lua",
-        content: generateClass(klass, options.namespace, context.classes)
+        content: generateClass$2(klass, options.namespace, context.classes)
     }));
 }
-function generateClass(klass, namespace, allClasses) {
+/**
+ * Generate a single bundled file containing all classes
+ */
+function renderBundle$2(context, options) {
+    const fileName = options.namespace ? `${options.namespace}.lua` : "schema.lua";
+    const classBodies = context.classes.map(klass => generateClassBody$2(klass));
+    const classNames = context.classes.map(klass => `    ${klass.name} = ${klass.name},`).join("\n");
+    const content = `${getCommentHeader().replace(/\/\//mg, "--")}
+
+${COMMON_IMPORTS}
+
+${classBodies.join("\n\n")}
+
+return {
+${classNames}
+}
+`;
+    return { name: fileName, content };
+}
+/**
+ * Generate just the class body (without requires) for bundling
+ */
+function generateClassBody$2(klass) {
+    // Inheritance support
+    const inherits = (klass.extends !== "Schema")
+        ? `, ${klass.extends}`
+        : "";
+    return `---@class ${klass.name}: ${klass.extends}
+${klass.properties.map(prop => `---@field ${prop.name} ${getLUATypeAnnotation(prop)}`).join("\n")}
+local ${klass.name} = schema.define({
+${klass.properties.map(prop => generatePropertyDeclaration(prop)).join(",\n")},
+    ["_fields_by_index"] = { ${klass.properties.map(prop => `"${prop.name}"`).join(", ")} },
+}${inherits})`;
+}
+/**
+ * Generate a complete class file with requires (for individual file mode)
+ */
+function generateClass$2(klass, namespace, allClasses) {
     const allRefs = [];
     klass.properties.forEach(property => {
         let type = property.type;
@@ -1385,27 +1711,19 @@ function generateClass(klass, namespace, allClasses) {
             allRefs.push(property);
         }
     });
-    // Inheritance support
-    const inherits = (klass.extends !== "Schema")
-        ? `, ${klass.extends}`
-        : "";
-    return `${getCommentHeader().replace(/\/\//mg, "--")}
-
-local schema = require 'colyseus.serializer.schema.schema'
-${allRefs.
-        filter(ref => ref.childType && typeMaps[ref.childType] === undefined).
+    const localRequires = allRefs.
+        filter(ref => ref.childType && typeMaps$2[ref.childType] === undefined).
         map(ref => ref.childType).
         concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
-        filter(distinct).
+        filter(distinct$2).
         map(childType => `local ${childType} = require '${(namespace ? `${namespace}.` : '')}${childType}'`).
-        join("\n")}
+        join("\n");
+    return `${getCommentHeader().replace(/\/\//mg, "--")}
 
----@class ${klass.name}: ${klass.extends}
-${klass.properties.map(prop => `---@field ${prop.name} ${getLUATypeAnnotation(prop)}`).join("\n")}
-local ${klass.name} = schema.define({
-${klass.properties.map(prop => generatePropertyDeclaration(prop)).join(",\n")},
-    ["_fields_by_index"] = { ${klass.properties.map(prop => `"${prop.name}"`).join(", ")} },
-}${inherits})
+${COMMON_IMPORTS}
+${localRequires}
+
+${generateClassBody$2(klass)}
 
 return ${klass.name}
 `;
@@ -1447,11 +1765,449 @@ function getLUATypeAnnotation(prop) {
         return "MapSchema";
     }
     else {
-        return typeMaps[prop.type];
+        return typeMaps$2[prop.type];
+    }
+}
+
+var lua = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    generate: generate$3,
+    name: name$2,
+    renderBundle: renderBundle$2
+});
+
+const name$1 = "C";
+/**
+ * Type mappings for C
+ */
+const typeMaps$1 = {
+    "string": "char*",
+    "number": "double",
+    "boolean": "bool",
+    "int8": "int8_t",
+    "uint8": "uint8_t",
+    "int16": "int16_t",
+    "uint16": "uint16_t",
+    "int32": "int32_t",
+    "uint32": "uint32_t",
+    "int64": "int64_t",
+    "uint64": "uint64_t",
+    "float32": "float",
+    "float64": "double",
+};
+/**
+ * Colyseus field type enum mappings
+ */
+const fieldTypeMaps = {
+    "string": "COLYSEUS_FIELD_STRING",
+    "number": "COLYSEUS_FIELD_NUMBER",
+    "boolean": "COLYSEUS_FIELD_BOOLEAN",
+    "int8": "COLYSEUS_FIELD_INT8",
+    "uint8": "COLYSEUS_FIELD_UINT8",
+    "int16": "COLYSEUS_FIELD_INT16",
+    "uint16": "COLYSEUS_FIELD_UINT16",
+    "int32": "COLYSEUS_FIELD_INT32",
+    "uint32": "COLYSEUS_FIELD_UINT32",
+    "int64": "COLYSEUS_FIELD_INT64",
+    "uint64": "COLYSEUS_FIELD_UINT64",
+    "float32": "COLYSEUS_FIELD_FLOAT32",
+    "float64": "COLYSEUS_FIELD_FLOAT64",
+    "ref": "COLYSEUS_FIELD_REF",
+    "array": "COLYSEUS_FIELD_ARRAY",
+    "map": "COLYSEUS_FIELD_MAP",
+};
+const COMMON_INCLUDES = `#include "colyseus/schema/types.h"
+#include "colyseus/schema/collections.h"
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdbool.h>`;
+/**
+ * Native C Code Generator
+ */
+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;
+/**
+ * Generate individual files for each class
+ */
+function generate$2(context, options) {
+    return context.classes.map(klass => ({
+        name: toSnakeCase(klass.name) + ".h",
+        content: generateClass$1(klass, options.namespace, context.classes)
+    }));
+}
+/**
+ * Generate a single bundled header file containing all classes
+ */
+function renderBundle$1(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 content = `${getCommentHeader()}
+#ifndef ${guardName}
+#define ${guardName} 1
+
+${COMMON_INCLUDES}
+
+${classBodies}
+
+#endif
+`;
+    return { name: fileName, content };
+}
+/**
+ * Generate just the class body (without guards/includes) for bundling
+ */
+function generateClassBody$1(klass, allClasses) {
+    const snakeName = toSnakeCase(klass.name);
+    const typeName = `${snakeName}_t`;
+    const allProperties = getAllProperties(klass, allClasses);
+    return `${generateTypedef(klass, typeName, allClasses)}
+
+${generateFieldsArray(klass, typeName, snakeName, allProperties)}
+
+${generateCreateFunction(snakeName, typeName)}
+
+${generateDestroyFunction(klass, snakeName, typeName, allProperties)}
+
+${generateVtable(klass, snakeName, typeName, allProperties)}`;
+}
+/**
+ * Generate a complete class file with guards/includes (for individual file mode)
+ */
+function generateClass$1(klass, namespace, allClasses) {
+    toSnakeCase(klass.name);
+    const guardName = `__SCHEMA_CODEGEN_${klass.name.toUpperCase()}_H__`;
+    const allRefs = [];
+    klass.properties.forEach(property => {
+        if (property.type === "ref" || property.type === "array" || property.type === "map") {
+            allRefs.push(property);
+        }
+    });
+    // Generate includes for referenced schema types
+    const refIncludes = allRefs
+        .filter(ref => ref.childType && typeMaps$1[ref.childType] === undefined)
+        .map(ref => ref.childType)
+        .concat(getInheritanceTree(klass, allClasses, false).map(k => k.name))
+        .filter(distinct$1)
+        .map(childType => `#include "${toSnakeCase(childType)}.h"`)
+        .join("\n");
+    return `${getCommentHeader()}
+#ifndef ${guardName}
+#define ${guardName} 1
+
+${COMMON_INCLUDES}
+${refIncludes ? `\n${refIncludes}\n` : ""}
+${generateClassBody$1(klass, allClasses)}
+
+#endif
+`;
+}
+function generateTypedef(klass, typeName, allClasses) {
+    const allProperties = getAllProperties(klass, allClasses);
+    const fields = allProperties.map(prop => {
+        const cType = getCType(prop);
+        return `    ${cType} ${prop.name};`;
+    }).join("\n");
+    return `typedef struct {
+    colyseus_schema_t __base;
+${fields}
+} ${typeName};`;
+}
+function getCType(prop) {
+    if (prop.type === "ref") {
+        return `${toSnakeCase(prop.childType)}_t*`;
+    }
+    else if (prop.type === "array") {
+        if (typeMaps$1[prop.childType]) {
+            return `colyseus_array_schema_t*`;
+        }
+        else {
+            return `colyseus_array_schema_t*`;
+        }
+    }
+    else if (prop.type === "map") {
+        if (typeMaps$1[prop.childType]) {
+            return `colyseus_map_schema_t*`;
+        }
+        else {
+            return `colyseus_map_schema_t*`;
+        }
+    }
+    else {
+        return typeMaps$1[prop.type] || `${toSnakeCase(prop.type)}_t*`;
+    }
+}
+function getFieldType(prop) {
+    return fieldTypeMaps[prop.type] || "COLYSEUS_FIELD_REF";
+}
+function getFieldTypeString(prop) {
+    // Always return the type itself (ref, array, map, string, number, etc.)
+    return prop.type;
+}
+function generateFieldsArray(klass, typeName, snakeName, allProperties) {
+    if (allProperties.length === 0) {
+        return `static const colyseus_field_t ${snakeName}_fields[] = {};`;
     }
+    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]) {
+            const childSnake = toSnakeCase(prop.childType);
+            vtableRef = `&${childSnake}_vtable`;
+        }
+        else if ((prop.type === "array" || prop.type === "map") && prop.childType && !typeMaps$1[prop.childType]) {
+            const childSnake = toSnakeCase(prop.childType);
+            vtableRef = `&${childSnake}_vtable`;
+        }
+        return `    {${prop.index}, "${prop.name}", ${fieldType}, "${typeString}", offsetof(${typeName}, ${prop.name}), ${vtableRef}, NULL}`;
+    }).join(",\n");
+    return `static const colyseus_field_t ${snakeName}_fields[] = {
+${fields}
+};`;
+}
+function generateCreateFunction(snakeName, typeName) {
+    return `static ${typeName}* ${snakeName}_create(void) {
+    ${typeName}* instance = calloc(1, sizeof(${typeName}));
+    return instance;
+}`;
+}
+function generateDestroyFunction(klass, snakeName, typeName, allProperties) {
+    const freeStatements = [];
+    allProperties.forEach(prop => {
+        if (prop.type === "string") {
+            freeStatements.push(`    if (instance->${prop.name}) free(instance->${prop.name});`);
+        }
+        else if (prop.type === "ref") {
+            if (typeMaps$1[prop.childType]) {
+                freeStatements.push(`    if (instance->${prop.name}) free(instance->${prop.name});`);
+            }
+            else {
+                const childSnake = toSnakeCase(prop.childType);
+                freeStatements.push(`    if (instance->${prop.name}) ${childSnake}_destroy((colyseus_schema_t*)instance->${prop.name});`);
+            }
+        }
+        else if (prop.type === "array" || prop.type === "map") ;
+    });
+    const freeCode = freeStatements.length > 0 ? freeStatements.join("\n") + "\n" : "";
+    return `static void ${snakeName}_destroy(colyseus_schema_t* schema) {
+    ${typeName}* instance = (${typeName}*)schema;
+${freeCode}    free(instance);
+}`;
+}
+function generateVtable(klass, snakeName, typeName, allProperties) {
+    const fieldCount = allProperties.length;
+    return `static const colyseus_schema_vtable_t ${snakeName}_vtable = {
+    "${klass.name}",
+    sizeof(${typeName}),
+    (colyseus_schema_t* (*)(void))${snakeName}_create,
+    ${snakeName}_destroy,
+    ${snakeName}_fields,
+    ${fieldCount}
+};`;
+}
+function getAllProperties(klass, allClasses) {
+    let properties = [];
+    getInheritanceTree(klass, allClasses).reverse().forEach((k) => {
+        properties = properties.concat(k.properties);
+    });
+    return properties;
+}
+
+var c = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    generate: generate$2,
+    name: name$1,
+    renderBundle: renderBundle$1
+});
+
+const name = "GDScript";
+/**
+ * Type mappings from schema types to GDScript Colyseus.Schema type constants
+ */
+const typeMaps = {
+    "string": "Colyseus.Schema.STRING",
+    "number": "Colyseus.Schema.NUMBER",
+    "boolean": "Colyseus.Schema.BOOLEAN",
+    "int8": "Colyseus.Schema.INT8",
+    "uint8": "Colyseus.Schema.UINT8",
+    "int16": "Colyseus.Schema.INT16",
+    "uint16": "Colyseus.Schema.UINT16",
+    "int32": "Colyseus.Schema.INT32",
+    "uint32": "Colyseus.Schema.UINT32",
+    "int64": "Colyseus.Schema.INT64",
+    "uint64": "Colyseus.Schema.UINT64",
+    "float32": "Colyseus.Schema.FLOAT32",
+    "float64": "Colyseus.Schema.FLOAT64",
+};
+const containerMaps = {
+    "array": "Colyseus.Schema.ARRAY",
+    "map": "Colyseus.Schema.MAP",
+    "ref": "Colyseus.Schema.REF",
+};
+const distinct = (value, index, self) => self.indexOf(value) === index;
+/**
+ * GDScript Code Generator
+ */
+/**
+ * Generate individual files for each class
+ */
+function generate$1(context, options) {
+    // Enrich typeMaps with enums
+    context.enums.forEach((structure) => {
+        typeMaps[structure.name] = structure.name;
+    });
+    return [
+        ...context.classes.map(klass => ({
+            name: `${klass.name}.gd`,
+            content: generateClass(klass, options.namespace, context.classes)
+        })),
+        ...context.enums.filter(structure => structure.name !== 'OPERATION').map((structure) => ({
+            name: `${structure.name}.gd`,
+            content: generateEnum(structure, options.namespace),
+        })),
+    ];
 }
+/**
+ * Generate a single bundled file containing all classes and enums
+ */
+function renderBundle(context, options) {
+    const fileName = options.namespace ? `${options.namespace}.gd` : "schema.gd";
+    // Enrich typeMaps with enums
+    context.enums.forEach((structure) => {
+        typeMaps[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));
+    const content = `${getCommentHeader("#")}
 
-const generators = { csharp: generate$7, cpp: generate$6, haxe: generate$5, ts: generate$4, js: generate$3, java: generate$2, lua: generate$1, };
+${enumBodies.length > 0 ? enumBodies.join("\n\n") + "\n\n" : ""}${classBodies.join("\n\n")}
+`;
+    return { name: fileName, content };
+}
+/**
+ * Generate just the class body (without preload) for bundling
+ */
+function generateClassBody(klass) {
+    // Determine parent class
+    const parentClass = (klass.extends !== "Schema")
+        ? klass.extends
+        : "Colyseus.Schema";
+    const properties = klass.properties;
+    const fieldsContent = properties.length > 0
+        ? properties.map(prop => generateFieldDefinition(prop)).join(",\n") + ","
+        : "";
+    // Generate _to_string() method
+    const toStringMethod = generateToStringMethod(klass.name, properties);
+    return `class ${klass.name} extends ${parentClass}:
+	static func definition():
+		return [
+${fieldsContent}
+		]
+
+${toStringMethod}`;
+}
+/**
+ * Generate _to_string() method for the class
+ */
+function generateToStringMethod(className, properties) {
+    const fieldNames = properties.map(prop => prop.name);
+    const allFields = ["__ref_id", ...fieldNames];
+    const formatParts = allFields.map(name => `${name}: %s`).join(", ");
+    const formatString = `${className}(${formatParts})`;
+    const selfReferences = allFields.map(name => `self.${name}`).join(", ");
+    return `\tfunc _to_string() -> String:
+		return "${formatString}" % [${selfReferences}]`;
+}
+/**
+ * Generate a complete class file with preload (for individual file mode)
+ */
+function generateClass(klass, namespace, allClasses) {
+    const allRefs = [];
+    klass.properties.forEach(property => {
+        let type = property.type;
+        // Keep all refs list
+        if ((type === "ref" || type === "array" || type === "map")) {
+            allRefs.push(property);
+        }
+    });
+    // Get required preloads for referenced types
+    const preloads = allRefs
+        .filter(ref => ref.childType && typeMaps[ref.childType] === undefined)
+        .map(ref => ref.childType)
+        .concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name))
+        .filter(distinct)
+        .map(childType => `const ${childType} = preload("${childType}.gd")`)
+        .join("\n");
+    return `${getCommentHeader("#")}
+
+${preloads ? preloads + "\n\n" : ""}${generateClassBody(klass)}
+`;
+}
+/**
+ * Generate a field definition for the definition() array
+ */
+function generateFieldDefinition(prop) {
+    let args;
+    if (prop.childType) {
+        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}"`;
+        args = [`"${prop.name}"`, containerType, childTypeRef];
+    }
+    else {
+        // Primitive type
+        const typeRef = typeMaps[prop.type] || `"${prop.type}"`;
+        args = [`"${prop.name}"`, typeRef];
+    }
+    return `\t\t\tColyseus.Schema.Field.new(${args.join(", ")})`;
+}
+/**
+ * Generate just the enum body for bundling
+ */
+function generateEnumBody(_enum) {
+    const enumValues = _enum.properties.map((prop, index) => {
+        let value;
+        if (prop.type) {
+            if (isNaN(Number(prop.type))) {
+                value = `"${prop.type}"`;
+            }
+            else {
+                value = Number(prop.type);
+            }
+        }
+        else {
+            value = index;
+        }
+        return `\t"${prop.name}": ${value},`;
+    }).join("\n");
+    return `const ${_enum.name} = {
+${enumValues}
+}`;
+}
+/**
+ * Generate a complete enum file (for individual file mode)
+ */
+function generateEnum(_enum, _namespace) {
+    return `${getCommentHeader("#")}
+
+${generateEnumBody(_enum)}
+`;
+}
+
+var gdscript = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    generate: generate$1,
+    name: name,
+    renderBundle: renderBundle
+});
+
+const generators = { csharp, cpp, haxe, ts, js, java, lua, c, gdscript, };
 function generate(targetId, options) {
     const generator = generators[targetId];
     if (!generator) {
@@ -1480,12 +2236,22 @@ function generate(targetId, options) {
     const structures = parseFiles(options.files, options.decorator);
     // Post-process classes before generating
     structures.classes.forEach(klass => klass.postProcessing());
-    const files = generator(structures, options);
-    files.forEach((file) => {
-        const outputPath = path__namespace.resolve(options.output, file.name);
-        fs__namespace.writeFileSync(outputPath, file.content);
-        console.log("generated:", file.name);
-    });
+    if (options.bundle && generator.renderBundle) {
+        // Bundle mode: generate all classes/interfaces/enums into a single file
+        const bundled = generator.renderBundle(structures, options);
+        const outputPath = path__namespace.resolve(options.output, bundled.name);
+        fs__namespace.writeFileSync(outputPath, bundled.content);
+        console.log("generated (bundled):", bundled.name);
+    }
+    else {
+        // Standard mode: write individual files
+        const generatedFiles = generator.generate(structures, options);
+        generatedFiles.forEach((file) => {
+            const outputPath = path__namespace.resolve(options.output, file.name);
+            fs__namespace.writeFileSync(outputPath, file.content);
+            console.log("generated:", file.name);
+        });
+    }
 }
 function recursiveFiles(dir) {
     const files = fs__namespace.readdirSync(dir, { withFileTypes: true });
@@ -1497,15 +2263,6 @@ function recursiveFiles(dir) {
     return collect;
 }
 
-const supportedTargets = {
-    csharp: 'generate for C#/Unity',
-    cpp: 'generate for C++',
-    haxe: 'generate for Haxe',
-    ts: 'generate for TypeScript',
-    js: 'generate for JavaScript',
-    java: 'generate for Java',
-    lua: 'generate for LUA',
-};
 function displayHelp() {
     console.log(`\nschema-codegen [path/to/Schema.ts]
 
@@ -1514,9 +2271,12 @@ Usage (C#/Unity)
 
 Valid options:
     --output: the output directory for generated client-side schema files
+    --bundle: bundle all generated files into a single file
+
+Generators:
 ${Object.
-        keys(supportedTargets).
-        map((targetId) => (`    --${targetId}: ${supportedTargets[targetId]}`)).
+        keys(generators).
+        map((targetId) => (`    --${targetId}: generate for ${generators[targetId].name}`)).
         join("\n")}
 
 Optional:
@@ -1529,7 +2289,7 @@ if (args.help) {
     displayHelp();
 }
 let targetId;
-for (let target in supportedTargets) {
+for (let target in generators) {
     if (args[target]) {
         targetId = target;
     }
@@ -1544,7 +2304,8 @@ try {
         files: args._,
         decorator: args.decorator,
         output: args.output,
-        namespace: args.namespace
+        namespace: args.namespace,
+        bundle: args.bundle
     });
 }
 catch (e) {