@lagless/codegen 0.0.35 → 0.0.38

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -26,7 +26,7 @@ async function generateFromConfig(options) {
     }
     const { schema, projectName } = parseYamlConfig(configContent, configPath);
     // Determine output directory
-    const outputDir = outputPath || path.join(path.dirname(configPath), '..', 'code-gen');
+    const outputDir = outputPath || path.join(path.dirname(configPath), 'code-gen');
     // Determine templates directory
     const templateDir = templatesPath || path.join(DIRNAME, '..', 'files');
     console.log(`Generating ECS code...`);

package/dist/cli.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { program } from 'commander';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { parseYamlConfig } from './parser.js';\nimport { generateCode } from './generator.js';\nimport { FileOperations } from './template-engine.js';\nimport { DIRNAME } from './dirname.js';\n\ninterface CliOptions {\n  config: string;\n  output?: string;\n  templates?: string;\n}\n\nprogram\n  .name('lagless-codegen')\n  .description('Generate ECS code from YAML configuration')\n  .version('1.0.0')\n  .requiredOption('-c, --config <path>', 'Path to YAML configuration file')\n  .option('-o, --output <path>', 'Output directory (default: config_dir/../code-gen)')\n  .option('-t, --templates <path>', 'Templates directory')\n  .action(async (options: CliOptions) => {\n    try {\n      await generateFromConfig(options);\n    } catch (error) {\n      console.error('Error:', error instanceof Error ? error.message : error);\n      process.exit(1);\n    }\n  });\n\nasync function generateFromConfig(options: CliOptions): Promise<void> {\n  const { config: configPath, output: outputPath, templates: templatesPath } = options;\n\n  // Validate config file exists\n  if (!fs.existsSync(configPath)) {\n    throw new Error(`Config file not found: ${configPath}`);\n  }\n\n  // Read and parse config\n  const configContent = fs.readFileSync(configPath, 'utf-8');\n  if (!configContent.trim()) {\n    throw new Error(`Config file is empty: ${configPath}`);\n  }\n\n  const { schema, projectName } = parseYamlConfig(configContent, configPath);\n\n  // Determine output directory\n  const outputDir = outputPath || path.join(path.dirname(configPath), '..', 'code-gen');\n\n  // Determine templates directory\n  const templateDir = templatesPath || path.join(DIRNAME, '..', 'files');\n\n  console.log(`Generating ECS code...`);\n  console.log(`Config: ${configPath}`);\n  console.log(`Output: ${outputDir}`);\n  console.log(`Templates: ${templateDir}`);\n  console.log(`Project: ${projectName}`);\n\n  // Create file operations for Node.js filesystem\n  const fileOperations: FileOperations = {\n    readFile: (filePath: string) => {\n      try {\n        return fs.readFileSync(filePath, 'utf-8');\n      } catch {\n        return '';\n      }\n    },\n    writeFile: (filePath: string, content: string) => {\n      const dir = path.dirname(filePath);\n      if (!fs.existsSync(dir)) {\n        fs.mkdirSync(dir, { recursive: true });\n      }\n      fs.writeFileSync(filePath, content, 'utf-8');\n    },\n    joinPath: (...segments: string[]) => path.join(...segments),\n    exists: (filePath: string) => fs.existsSync(filePath),\n    readDir: (dirPath: string) => {\n      try {\n        return fs.readdirSync(dirPath);\n      } catch {\n        return [];\n      }\n    },\n    isDirectory: (filePath: string) => {\n      try {\n        return fs.statSync(filePath).isDirectory();\n      } catch {\n        return false;\n      }\n    },\n  };\n\n  // Generate code\n  await generateCode({\n    schema,\n    projectName,\n    outputDir,\n    templateDir,\n    fileOperations,\n  });\n\n  console.log('ECS code generation complete!');\n  console.log(`Generated ${schema.components.length} components and ${schema.singletons.length} singletons.`);\n  console.log(`Project name: ${projectName}`);\n  console.log(`Output written to: ${outputDir}`);\n}\n\n// Handle unhandled promise rejections\nprocess.on('unhandledRejection', (reason, promise) => {\n  console.error('Unhandled Rejection at:', promise, 'reason:', reason);\n  process.exit(1);\n});\n\nprogram.parse();\n"],"names":["program","fs","path","parseYamlConfig","generateCode","DIRNAME","name","description","version","requiredOption","option","action","options","generateFromConfig","error","console","Error","message","process","exit","config","configPath","output","outputPath","templates","templatesPath","existsSync","configContent","readFileSync","trim","schema","projectName","outputDir","join","dirname","templateDir","log","fileOperations","readFile","filePath","writeFile","content","dir","mkdirSync","recursive","writeFileSync","joinPath","segments","exists","readDir","dirPath","readdirSync","isDirectory","statSync","components","length","singletons","on","reason","promise","parse"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { program } from 'commander';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { parseYamlConfig } from './parser.js';\nimport { generateCode } from './generator.js';\nimport { FileOperations } from './template-engine.js';\nimport { DIRNAME } from './dirname.js';\n\ninterface CliOptions {\n  config: string;\n  output?: string;\n  templates?: string;\n}\n\nprogram\n  .name('lagless-codegen')\n  .description('Generate ECS code from YAML configuration')\n  .version('1.0.0')\n  .requiredOption('-c, --config <path>', 'Path to YAML configuration file')\n  .option('-o, --output <path>', 'Output directory (default: config_dir/../code-gen)')\n  .option('-t, --templates <path>', 'Templates directory')\n  .action(async (options: CliOptions) => {\n    try {\n      await generateFromConfig(options);\n    } catch (error) {\n      console.error('Error:', error instanceof Error ? error.message : error);\n      process.exit(1);\n    }\n  });\n\nasync function generateFromConfig(options: CliOptions): Promise<void> {\n  const { config: configPath, output: outputPath, templates: templatesPath } = options;\n\n  // Validate config file exists\n  if (!fs.existsSync(configPath)) {\n    throw new Error(`Config file not found: ${configPath}`);\n  }\n\n  // Read and parse config\n  const configContent = fs.readFileSync(configPath, 'utf-8');\n  if (!configContent.trim()) {\n    throw new Error(`Config file is empty: ${configPath}`);\n  }\n\n  const { schema, projectName } = parseYamlConfig(configContent, configPath);\n\n  // Determine output directory\n  const outputDir = outputPath || path.join(path.dirname(configPath), 'code-gen');\n\n  // Determine templates directory\n  const templateDir = templatesPath || path.join(DIRNAME, '..', 'files');\n\n  console.log(`Generating ECS code...`);\n  console.log(`Config: ${configPath}`);\n  console.log(`Output: ${outputDir}`);\n  console.log(`Templates: ${templateDir}`);\n  console.log(`Project: ${projectName}`);\n\n  // Create file operations for Node.js filesystem\n  const fileOperations: FileOperations = {\n    readFile: (filePath: string) => {\n      try {\n        return fs.readFileSync(filePath, 'utf-8');\n      } catch {\n        return '';\n      }\n    },\n    writeFile: (filePath: string, content: string) => {\n      const dir = path.dirname(filePath);\n      if (!fs.existsSync(dir)) {\n        fs.mkdirSync(dir, { recursive: true });\n      }\n      fs.writeFileSync(filePath, content, 'utf-8');\n    },\n    joinPath: (...segments: string[]) => path.join(...segments),\n    exists: (filePath: string) => fs.existsSync(filePath),\n    readDir: (dirPath: string) => {\n      try {\n        return fs.readdirSync(dirPath);\n      } catch {\n        return [];\n      }\n    },\n    isDirectory: (filePath: string) => {\n      try {\n        return fs.statSync(filePath).isDirectory();\n      } catch {\n        return false;\n      }\n    },\n  };\n\n  // Generate code\n  await generateCode({\n    schema,\n    projectName,\n    outputDir,\n    templateDir,\n    fileOperations,\n  });\n\n  console.log('ECS code generation complete!');\n  console.log(`Generated ${schema.components.length} components and ${schema.singletons.length} singletons.`);\n  console.log(`Project name: ${projectName}`);\n  console.log(`Output written to: ${outputDir}`);\n}\n\n// Handle unhandled promise rejections\nprocess.on('unhandledRejection', (reason, promise) => {\n  console.error('Unhandled Rejection at:', promise, 'reason:', reason);\n  process.exit(1);\n});\n\nprogram.parse();\n"],"names":["program","fs","path","parseYamlConfig","generateCode","DIRNAME","name","description","version","requiredOption","option","action","options","generateFromConfig","error","console","Error","message","process","exit","config","configPath","output","outputPath","templates","templatesPath","existsSync","configContent","readFileSync","trim","schema","projectName","outputDir","join","dirname","templateDir","log","fileOperations","readFile","filePath","writeFile","content","dir","mkdirSync","recursive","writeFileSync","joinPath","segments","exists","readDir","dirPath","readdirSync","isDirectory","statSync","components","length","singletons","on","reason","promise","parse"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/dirname.d.ts

@@ -0,0 +1,2 @@
+export declare const DIRNAME: string;
+//# sourceMappingURL=dirname.d.ts.map

package/dist/dirname.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dirname.d.ts","sourceRoot":"","sources":["../src/dirname.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,OAAO,QAI8B,CAAC"}

package/dist/generator.d.ts

@@ -0,0 +1,14 @@
+import { ECSSchema } from '@lagless/core';
+import { FileOperations } from './template-engine.js';
+import { SimulationType } from './parser.js';
+export interface GenerateCodeOptions {
+    schema: ECSSchema;
+    projectName: string;
+    outputDir: string;
+    templateDir: string;
+    fileOperations: FileOperations;
+    simulationType?: SimulationType;
+}
+export declare function generateBarrelFileContent(schema: ECSSchema, projectName: string): string;
+export declare function generateCode(options: GenerateCodeOptions): Promise<void>;
+//# sourceMappingURL=generator.d.ts.map

package/dist/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAmB,MAAM,eAAe,CAAC;AAC3D,OAAO,EAA2C,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE/F,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,SAAS,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,cAAc,CAAC;IAC/B,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAsCxF;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqJ9E"}

package/dist/generator.js

@@ -81,21 +81,31 @@ export async function generateCode(options) {
             fileOperations
         });
     }
-    // Generate Filter classes
+    // Determine mask word count from component count
+    const maskWords = Math.max(1, Math.ceil(schema.components.length / 32));
+    // Generate Filter classes (masks are number[] with one element per Uint32 word)
     for (const filter of schema.filters){
         const componentsImports = [
             ...filter.include,
             ...filter.exclude
         ].map((c)=>c.name);
-        const includeMask = filter.include.reduce((acc, component)=>acc | component.id, 0);
-        const excludeMask = filter.exclude.reduce((acc, component)=>acc | component.id, 0);
+        const includeMaskWords = new Array(maskWords).fill(0);
+        for (const component of filter.include){
+            const w = component.id >>> 5;
+            includeMaskWords[w] |= 1 << (component.id & 31);
+        }
+        const excludeMaskWords = new Array(maskWords).fill(0);
+        for (const component of filter.exclude){
+            const w = component.id >>> 5;
+            excludeMaskWords[w] |= 1 << (component.id & 31);
+        }
         await processTemplate({
             templateDir: joinPath(templateDir, 'filter'),
             outputDir,
             data: {
                 filter,
-                includeMask,
-                excludeMask,
+                includeMaskWords,
+                excludeMaskWords,
                 componentsImports,
                 name: filter.name,
                 projectName
@@ -138,9 +148,12 @@ export async function generateCode(options) {
         },
         fileOperations
     });
-    // Generate Runner class
+    var _options_simulationType;
+    // Generate Runner class (template varies by simulationType)
+    const simulationType = (_options_simulationType = options.simulationType) != null ? _options_simulationType : 'raw';
+    const runnerTemplateDir = simulationType === 'physics3d' ? 'runner-physics3d' : simulationType === 'physics2d' ? 'runner-physics2d' : 'runner';
     await processTemplate({
-        templateDir: joinPath(templateDir, 'runner'),
+        templateDir: joinPath(templateDir, runnerTemplateDir),
         outputDir,
         data: {
             projectName,

package/dist/generator.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/generator.ts"],"sourcesContent":["import { ECSSchema, FieldDefinition } from '@lagless/core';\nimport { generateFromTemplate as processTemplate, FileOperations } from './template-engine.js';\nimport { FieldTypeReverse, getTypeSizeBytes, typedArrayConstructors, typeToArrayConstructor } from '@lagless/binary';\n\nexport interface GenerateCodeOptions {\n  schema: ECSSchema;\n  projectName: string;\n  outputDir: string;\n  templateDir: string;\n  fileOperations: FileOperations;\n}\n\nexport function generateBarrelFileContent(schema: ECSSchema, projectName: string): string {\n  let content = '// Generated by @lagless/codegen. Do not edit manually.\\n\\n';\n\n  // Export components\n  schema.components.forEach((component) => {\n    content += `export * from './${component.name}.js';\\n`;\n  });\n\n  // Export singletons\n  schema.singletons.forEach((singleton) => {\n    content += `export * from './${singleton.name}.js';\\n`;\n  });\n\n  // Export player resources\n  schema.playerResources.forEach((playerResource) => {\n    content += `export * from './${playerResource.name}.js';\\n`;\n  });\n\n  // Export filters\n  schema.filters.forEach((filter) => {\n    content += `export * from './${filter.name}.js';\\n`;\n  });\n\n  // Export inputs\n  schema.inputs.forEach((input) => {\n    content += `export * from './${input.name}.js';\\n`;\n  });\n\n  // Export input registry\n  content += `export * from './${projectName}InputRegistry.js';\\n`;\n\n  // Export core\n  content += `export * from './${projectName}.core.js';\\n`;\n\n  // Export runner\n  content += `export * from './${projectName}.runner.js';\\n`;\n\n  return content;\n}\n\nexport async function generateCode(options: GenerateCodeOptions): Promise<void> {\n  const { schema, projectName, outputDir, templateDir, fileOperations } = options;\n  const { writeFile, joinPath, exists } = fileOperations;\n\n  // Ensure output directory exists\n  if (!exists(outputDir)) {\n    writeFile(joinPath(outputDir, '.gitkeep'), '');\n  }\n\n  // Generate component classes\n  for (const component of schema.components) {\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'component'),\n      outputDir,\n      data: {\n        ...component,\n        component,\n        projectName,\n        typeToArrayConstructor,\n        getFieldByteSize: (field: FieldDefinition) => {\n          const baseSize = getTypeSizeBytes(field.type);\n          return field.isArray ? baseSize * field.arrayLength! : baseSize;\n        },\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate singleton classes\n  for (const singleton of schema.singletons) {\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'singleton'),\n      outputDir,\n      data: {\n        ...singleton,\n        singleton,\n        projectName,\n        typeToArrayConstructor,\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate playerResource classes\n  for (const playerResource of schema.playerResources) {\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'playerResource'),\n      outputDir,\n      data: {\n        ...playerResource,\n        playerResource,\n        projectName,\n        typeToArrayConstructor,\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate Filter classes\n  for (const filter of schema.filters) {\n    const componentsImports = [...filter.include, ...filter.exclude].map((c) => c.name);\n    const includeMask = filter.include.reduce((acc, component) => acc | component.id, 0);\n    const excludeMask = filter.exclude.reduce((acc, component) => acc | component.id, 0);\n\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'filter'),\n      outputDir,\n      data: {\n        filter,\n        includeMask,\n        excludeMask,\n        componentsImports,\n        name: filter.name,\n        projectName,\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate Input classes\n  for (const input of schema.inputs) {\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'input'),\n      outputDir,\n      data: {\n        ...input,\n        input,\n        projectName,\n        FieldTypeReverse,\n        typedArrayConstructors,\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate input registry\n  await processTemplate({\n    templateDir: joinPath(templateDir, 'input-registry'),\n    outputDir,\n    data: {\n      projectName,\n      inputs: schema.inputs,\n      schema,\n    },\n    fileOperations,\n  });\n\n  // Generate ECSCore class\n  await processTemplate({\n    templateDir: joinPath(templateDir, 'core'),\n    outputDir,\n    data: {\n      projectName,\n      schema,\n    },\n    fileOperations,\n  });\n\n  // Generate Runner class\n  await processTemplate({\n    templateDir: joinPath(templateDir, 'runner'),\n    outputDir,\n    data: {\n      projectName,\n      schema,\n    },\n    fileOperations,\n  });\n\n  // Generate barrel file\n  const barrelContent = generateBarrelFileContent(schema, projectName);\n  writeFile(joinPath(outputDir, 'index.ts'), barrelContent);\n}\n"],"names":["generateFromTemplate","processTemplate","FieldTypeReverse","getTypeSizeBytes","typedArrayConstructors","typeToArrayConstructor","generateBarrelFileContent","schema","projectName","content","components","forEach","component","name","singletons","singleton","playerResources","playerResource","filters","filter","inputs","input","generateCode","options","outputDir","templateDir","fileOperations","writeFile","joinPath","exists","data","getFieldByteSize","field","baseSize","type","isArray","arrayLength","componentsImports","include","exclude","map","c","includeMask","reduce","acc","id","excludeMask","barrelContent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../src/generator.ts"],"sourcesContent":["import { ECSSchema, FieldDefinition } from '@lagless/core';\nimport { generateFromTemplate as processTemplate, FileOperations } from './template-engine.js';\nimport { FieldTypeReverse, getTypeSizeBytes, typedArrayConstructors, typeToArrayConstructor } from '@lagless/binary';\nimport { SimulationType } from './parser.js';\n\nexport interface GenerateCodeOptions {\n  schema: ECSSchema;\n  projectName: string;\n  outputDir: string;\n  templateDir: string;\n  fileOperations: FileOperations;\n  simulationType?: SimulationType;\n}\n\nexport function generateBarrelFileContent(schema: ECSSchema, projectName: string): string {\n  let content = '// Generated by @lagless/codegen. Do not edit manually.\\n\\n';\n\n  // Export components\n  schema.components.forEach((component) => {\n    content += `export * from './${component.name}.js';\\n`;\n  });\n\n  // Export singletons\n  schema.singletons.forEach((singleton) => {\n    content += `export * from './${singleton.name}.js';\\n`;\n  });\n\n  // Export player resources\n  schema.playerResources.forEach((playerResource) => {\n    content += `export * from './${playerResource.name}.js';\\n`;\n  });\n\n  // Export filters\n  schema.filters.forEach((filter) => {\n    content += `export * from './${filter.name}.js';\\n`;\n  });\n\n  // Export inputs\n  schema.inputs.forEach((input) => {\n    content += `export * from './${input.name}.js';\\n`;\n  });\n\n  // Export input registry\n  content += `export * from './${projectName}InputRegistry.js';\\n`;\n\n  // Export core\n  content += `export * from './${projectName}.core.js';\\n`;\n\n  // Export runner\n  content += `export * from './${projectName}.runner.js';\\n`;\n\n  return content;\n}\n\nexport async function generateCode(options: GenerateCodeOptions): Promise<void> {\n  const { schema, projectName, outputDir, templateDir, fileOperations } = options;\n  const { writeFile, joinPath, exists } = fileOperations;\n\n  // Ensure output directory exists\n  if (!exists(outputDir)) {\n    writeFile(joinPath(outputDir, '.gitkeep'), '');\n  }\n\n  // Generate component classes\n  for (const component of schema.components) {\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'component'),\n      outputDir,\n      data: {\n        ...component,\n        component,\n        projectName,\n        typeToArrayConstructor,\n        getFieldByteSize: (field: FieldDefinition) => {\n          const baseSize = getTypeSizeBytes(field.type);\n          return field.isArray ? baseSize * field.arrayLength! : baseSize;\n        },\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate singleton classes\n  for (const singleton of schema.singletons) {\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'singleton'),\n      outputDir,\n      data: {\n        ...singleton,\n        singleton,\n        projectName,\n        typeToArrayConstructor,\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate playerResource classes\n  for (const playerResource of schema.playerResources) {\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'playerResource'),\n      outputDir,\n      data: {\n        ...playerResource,\n        playerResource,\n        projectName,\n        typeToArrayConstructor,\n      },\n      fileOperations,\n    });\n  }\n\n  // Determine mask word count from component count\n  const maskWords = Math.max(1, Math.ceil(schema.components.length / 32));\n\n  // Generate Filter classes (masks are number[] with one element per Uint32 word)\n  for (const filter of schema.filters) {\n    const componentsImports = [...filter.include, ...filter.exclude].map((c) => c.name);\n\n    const includeMaskWords = new Array<number>(maskWords).fill(0);\n    for (const component of filter.include) {\n      const w = component.id >>> 5;\n      includeMaskWords[w] |= 1 << (component.id & 31);\n    }\n\n    const excludeMaskWords = new Array<number>(maskWords).fill(0);\n    for (const component of filter.exclude) {\n      const w = component.id >>> 5;\n      excludeMaskWords[w] |= 1 << (component.id & 31);\n    }\n\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'filter'),\n      outputDir,\n      data: {\n        filter,\n        includeMaskWords,\n        excludeMaskWords,\n        componentsImports,\n        name: filter.name,\n        projectName,\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate Input classes\n  for (const input of schema.inputs) {\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'input'),\n      outputDir,\n      data: {\n        ...input,\n        input,\n        projectName,\n        FieldTypeReverse,\n        typedArrayConstructors,\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate input registry\n  await processTemplate({\n    templateDir: joinPath(templateDir, 'input-registry'),\n    outputDir,\n    data: {\n      projectName,\n      inputs: schema.inputs,\n      schema,\n    },\n    fileOperations,\n  });\n\n  // Generate ECSCore class\n  await processTemplate({\n    templateDir: joinPath(templateDir, 'core'),\n    outputDir,\n    data: {\n      projectName,\n      schema,\n    },\n    fileOperations,\n  });\n\n  // Generate Runner class (template varies by simulationType)\n  const simulationType = options.simulationType ?? 'raw';\n  const runnerTemplateDir =\n    simulationType === 'physics3d' ? 'runner-physics3d' : simulationType === 'physics2d' ? 'runner-physics2d' : 'runner';\n\n  await processTemplate({\n    templateDir: joinPath(templateDir, runnerTemplateDir),\n    outputDir,\n    data: {\n      projectName,\n      schema,\n    },\n    fileOperations,\n  });\n\n  // Generate barrel file\n  const barrelContent = generateBarrelFileContent(schema, projectName);\n  writeFile(joinPath(outputDir, 'index.ts'), barrelContent);\n}\n"],"names":["generateFromTemplate","processTemplate","FieldTypeReverse","getTypeSizeBytes","typedArrayConstructors","typeToArrayConstructor","generateBarrelFileContent","schema","projectName","content","components","forEach","component","name","singletons","singleton","playerResources","playerResource","filters","filter","inputs","input","generateCode","options","outputDir","templateDir","fileOperations","writeFile","joinPath","exists","data","getFieldByteSize","field","baseSize","type","isArray","arrayLength","maskWords","Math","max","ceil","length","componentsImports","include","exclude","map","c","includeMaskWords","Array","fill","w","id","excludeMaskWords","simulationType","runnerTemplateDir","barrelContent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './parser.js';
+export * from './generator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC"}

package/dist/nx-generator.d.ts

@@ -0,0 +1,7 @@
+import { Tree } from '@nx/devkit';
+interface GeneratorOptions {
+    configPath: string;
+}
+export default function (tree: Tree, options: GeneratorOptions): Promise<() => void>;
+export {};
+//# sourceMappingURL=nx-generator.d.ts.map

package/dist/nx-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nx-generator.d.ts","sourceRoot":"","sources":["../src/nx-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAkC,MAAM,YAAY,CAAC;AAOlE,UAAU,gBAAgB;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,yBAA+B,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,gBAAgB,uBAmEnE"}

package/dist/nx-generator.js

@@ -11,7 +11,7 @@ export default async function(tree, options) {
     }
     const configContent = tree.read(configPath, 'utf-8');
     if (!configContent) throw new Error(`Config file is empty: ${configPath}`);
-    const { schema, projectName } = parseYamlConfig(configContent, configPath);
+    const { schema, projectName, simulationType } = parseYamlConfig(configContent, configPath);
     // Generate output directory from config path (../code-gen)
     const outputDir = joinPathFragments(configPath, '../code-gen');
     const templateDir = joinPathFragments(DIRNAME, '..', 'files');
@@ -53,7 +53,8 @@ export default async function(tree, options) {
         projectName,
         outputDir,
         templateDir,
-        fileOperations
+        fileOperations,
+        simulationType
     });
     await formatFiles(tree);
     return ()=>{

package/dist/nx-generator.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/nx-generator.ts"],"sourcesContent":["import { Tree, formatFiles, joinPathFragments } from '@nx/devkit';\nimport { parseYamlConfig } from './parser.js';\nimport { generateCode } from './generator.js';\nimport { FileOperations } from './template-engine.js';\nimport * as fs from 'fs';\nimport { DIRNAME } from './dirname.js';\n\ninterface GeneratorOptions {\n  configPath: string;\n}\n\nexport default async function (tree: Tree, options: GeneratorOptions) {\n  // Read and parse YAML config\n  const configPath = options.configPath;\n  if (!tree.exists(configPath)) {\n    throw new Error(`Config file not found: ${configPath}`);\n  }\n\n  const configContent = tree.read(configPath, 'utf-8');\n  if (!configContent) throw new Error(`Config file is empty: ${configPath}`);\n\n  const { schema, projectName } = parseYamlConfig(configContent, configPath);\n\n  // Generate output directory from config path (../code-gen)\n  const outputDir = joinPathFragments(configPath, '../code-gen');\n  const templateDir = joinPathFragments(DIRNAME, '..', 'files');\n\n  // Create file operations adapter for NX Tree\n  const fileOperations: FileOperations = {\n    writeFile: (path: string, content: string) => tree.write(path, content),\n    // Only writeFile uses tree, other methods use fs\n    readFile: (path: string) => fs.readFileSync(path, 'utf-8'),\n    joinPath: (...segments: string[]) => joinPathFragments(...segments),\n    exists: (path: string) => {\n      try {\n        fs.accessSync(path, fs.constants.F_OK);\n        return true;\n      } catch {\n        return false;\n      }\n    },\n    readDir: (path: string) => {\n      try {\n        return fs.readdirSync(path);\n      } catch {\n        return [];\n      }\n    },\n    isDirectory: (path: string) => {\n      try {\n        return fs.statSync(path).isDirectory();\n      } catch {\n        return false;\n      }\n    },\n  };\n\n  if (!tree.exists(outputDir)) {\n    tree.write(joinPathFragments(outputDir, '.gitkeep'), '');\n  }\n\n  // Generate code using the unified template engine\n  await generateCode({\n    schema,\n    projectName,\n    outputDir,\n    templateDir,\n    fileOperations,\n  });\n\n  await formatFiles(tree);\n\n  return () => {\n    console.log('ECS code generation complete!');\n    console.log(`Generated ${schema.components.length} components and ${schema.singletons.length} singletons.`);\n    console.log(`Project name: ${projectName}`);\n  };\n}\n"],"names":["formatFiles","joinPathFragments","parseYamlConfig","generateCode","fs","DIRNAME","tree","options","configPath","exists","Error","configContent","read","schema","projectName","outputDir","templateDir","fileOperations","writeFile","path","content","write","readFile","readFileSync","joinPath","segments","accessSync","constants","F_OK","readDir","readdirSync","isDirectory","statSync","console","log","components","length","singletons"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAAeA,WAAW,EAAEC,iBAAiB,QAAQ,aAAa;AAClE,SAASC,eAAe,QAAQ,cAAc;AAC9C,SAASC,YAAY,QAAQ,iBAAiB;AAE9C,YAAYC,QAAQ,KAAK;AACzB,SAASC,OAAO,QAAQ,eAAe;AAMvC,eAAe,eAAgBC,IAAU,EAAEC,OAAyB;IAClE,6BAA6B;IAC7B,MAAMC,aAAaD,QAAQC,UAAU;IACrC,IAAI,CAACF,KAAKG,MAAM,CAACD,aAAa;QAC5B,MAAM,IAAIE,MAAM,CAAC,uBAAuB,EAAEF,WAAW,CAAC;IACxD;IAEA,MAAMG,gBAAgBL,KAAKM,IAAI,CAACJ,YAAY;IAC5C,IAAI,CAACG,eAAe,MAAM,IAAID,MAAM,CAAC,sBAAsB,EAAEF,WAAW,CAAC;IAEzE,MAAM,EAAEK,MAAM,EAAEC,WAAW,EAAE,GAAGZ,gBAAgBS,eAAeH;IAE/D,2DAA2D;IAC3D,MAAMO,YAAYd,kBAAkBO,YAAY;IAChD,MAAMQ,cAAcf,kBAAkBI,SAAS,MAAM;IAErD,6CAA6C;IAC7C,MAAMY,iBAAiC;QACrCC,WAAW,CAACC,MAAcC,UAAoBd,KAAKe,KAAK,CAACF,MAAMC;QAC/D,iDAAiD;QACjDE,UAAU,CAACH,OAAiBf,GAAGmB,YAAY,CAACJ,MAAM;QAClDK,UAAU,CAAC,GAAGC,WAAuBxB,qBAAqBwB;QAC1DhB,QAAQ,CAACU;YACP,IAAI;gBACFf,GAAGsB,UAAU,CAACP,MAAMf,GAAGuB,SAAS,CAACC,IAAI;gBACrC,OAAO;YACT,EAAE,UAAM;gBACN,OAAO;YACT;QACF;QACAC,SAAS,CAACV;YACR,IAAI;gBACF,OAAOf,GAAG0B,WAAW,CAACX;YACxB,EAAE,UAAM;gBACN,OAAO,EAAE;YACX;QACF;QACAY,aAAa,CAACZ;YACZ,IAAI;gBACF,OAAOf,GAAG4B,QAAQ,CAACb,MAAMY,WAAW;YACtC,EAAE,UAAM;gBACN,OAAO;YACT;QACF;IACF;IAEA,IAAI,CAACzB,KAAKG,MAAM,CAACM,YAAY;QAC3BT,KAAKe,KAAK,CAACpB,kBAAkBc,WAAW,aAAa;IACvD;IAEA,kDAAkD;IAClD,MAAMZ,aAAa;QACjBU;QACAC;QACAC;QACAC;QACAC;IACF;IAEA,MAAMjB,YAAYM;IAElB,OAAO;QACL2B,QAAQC,GAAG,CAAC;QACZD,QAAQC,GAAG,CAAC,CAAC,UAAU,EAAErB,OAAOsB,UAAU,CAACC,MAAM,CAAC,gBAAgB,EAAEvB,OAAOwB,UAAU,CAACD,MAAM,CAAC,YAAY,CAAC;QAC1GH,QAAQC,GAAG,CAAC,CAAC,cAAc,EAAEpB,YAAY,CAAC;IAC5C;AACF"}
+{"version":3,"sources":["../src/nx-generator.ts"],"sourcesContent":["import { Tree, formatFiles, joinPathFragments } from '@nx/devkit';\nimport { parseYamlConfig } from './parser.js';\nimport { generateCode } from './generator.js';\nimport { FileOperations } from './template-engine.js';\nimport * as fs from 'fs';\nimport { DIRNAME } from './dirname.js';\n\ninterface GeneratorOptions {\n  configPath: string;\n}\n\nexport default async function (tree: Tree, options: GeneratorOptions) {\n  // Read and parse YAML config\n  const configPath = options.configPath;\n  if (!tree.exists(configPath)) {\n    throw new Error(`Config file not found: ${configPath}`);\n  }\n\n  const configContent = tree.read(configPath, 'utf-8');\n  if (!configContent) throw new Error(`Config file is empty: ${configPath}`);\n\n  const { schema, projectName, simulationType } = parseYamlConfig(configContent, configPath);\n\n  // Generate output directory from config path (../code-gen)\n  const outputDir = joinPathFragments(configPath, '../code-gen');\n  const templateDir = joinPathFragments(DIRNAME, '..', 'files');\n\n  // Create file operations adapter for NX Tree\n  const fileOperations: FileOperations = {\n    writeFile: (path: string, content: string) => tree.write(path, content),\n    // Only writeFile uses tree, other methods use fs\n    readFile: (path: string) => fs.readFileSync(path, 'utf-8'),\n    joinPath: (...segments: string[]) => joinPathFragments(...segments),\n    exists: (path: string) => {\n      try {\n        fs.accessSync(path, fs.constants.F_OK);\n        return true;\n      } catch {\n        return false;\n      }\n    },\n    readDir: (path: string) => {\n      try {\n        return fs.readdirSync(path);\n      } catch {\n        return [];\n      }\n    },\n    isDirectory: (path: string) => {\n      try {\n        return fs.statSync(path).isDirectory();\n      } catch {\n        return false;\n      }\n    },\n  };\n\n  if (!tree.exists(outputDir)) {\n    tree.write(joinPathFragments(outputDir, '.gitkeep'), '');\n  }\n\n  // Generate code using the unified template engine\n  await generateCode({\n    schema,\n    projectName,\n    outputDir,\n    templateDir,\n    fileOperations,\n    simulationType,\n  });\n\n  await formatFiles(tree);\n\n  return () => {\n    console.log('ECS code generation complete!');\n    console.log(`Generated ${schema.components.length} components and ${schema.singletons.length} singletons.`);\n    console.log(`Project name: ${projectName}`);\n  };\n}\n"],"names":["formatFiles","joinPathFragments","parseYamlConfig","generateCode","fs","DIRNAME","tree","options","configPath","exists","Error","configContent","read","schema","projectName","simulationType","outputDir","templateDir","fileOperations","writeFile","path","content","write","readFile","readFileSync","joinPath","segments","accessSync","constants","F_OK","readDir","readdirSync","isDirectory","statSync","console","log","components","length","singletons"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAAeA,WAAW,EAAEC,iBAAiB,QAAQ,aAAa;AAClE,SAASC,eAAe,QAAQ,cAAc;AAC9C,SAASC,YAAY,QAAQ,iBAAiB;AAE9C,YAAYC,QAAQ,KAAK;AACzB,SAASC,OAAO,QAAQ,eAAe;AAMvC,eAAe,eAAgBC,IAAU,EAAEC,OAAyB;IAClE,6BAA6B;IAC7B,MAAMC,aAAaD,QAAQC,UAAU;IACrC,IAAI,CAACF,KAAKG,MAAM,CAACD,aAAa;QAC5B,MAAM,IAAIE,MAAM,CAAC,uBAAuB,EAAEF,WAAW,CAAC;IACxD;IAEA,MAAMG,gBAAgBL,KAAKM,IAAI,CAACJ,YAAY;IAC5C,IAAI,CAACG,eAAe,MAAM,IAAID,MAAM,CAAC,sBAAsB,EAAEF,WAAW,CAAC;IAEzE,MAAM,EAAEK,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAE,GAAGb,gBAAgBS,eAAeH;IAE/E,2DAA2D;IAC3D,MAAMQ,YAAYf,kBAAkBO,YAAY;IAChD,MAAMS,cAAchB,kBAAkBI,SAAS,MAAM;IAErD,6CAA6C;IAC7C,MAAMa,iBAAiC;QACrCC,WAAW,CAACC,MAAcC,UAAoBf,KAAKgB,KAAK,CAACF,MAAMC;QAC/D,iDAAiD;QACjDE,UAAU,CAACH,OAAiBhB,GAAGoB,YAAY,CAACJ,MAAM;QAClDK,UAAU,CAAC,GAAGC,WAAuBzB,qBAAqByB;QAC1DjB,QAAQ,CAACW;YACP,IAAI;gBACFhB,GAAGuB,UAAU,CAACP,MAAMhB,GAAGwB,SAAS,CAACC,IAAI;gBACrC,OAAO;YACT,EAAE,UAAM;gBACN,OAAO;YACT;QACF;QACAC,SAAS,CAACV;YACR,IAAI;gBACF,OAAOhB,GAAG2B,WAAW,CAACX;YACxB,EAAE,UAAM;gBACN,OAAO,EAAE;YACX;QACF;QACAY,aAAa,CAACZ;YACZ,IAAI;gBACF,OAAOhB,GAAG6B,QAAQ,CAACb,MAAMY,WAAW;YACtC,EAAE,UAAM;gBACN,OAAO;YACT;QACF;IACF;IAEA,IAAI,CAAC1B,KAAKG,MAAM,CAACO,YAAY;QAC3BV,KAAKgB,KAAK,CAACrB,kBAAkBe,WAAW,aAAa;IACvD;IAEA,kDAAkD;IAClD,MAAMb,aAAa;QACjBU;QACAC;QACAE;QACAC;QACAC;QACAH;IACF;IAEA,MAAMf,YAAYM;IAElB,OAAO;QACL4B,QAAQC,GAAG,CAAC;QACZD,QAAQC,GAAG,CAAC,CAAC,UAAU,EAAEtB,OAAOuB,UAAU,CAACC,MAAM,CAAC,gBAAgB,EAAExB,OAAOyB,UAAU,CAACD,MAAM,CAAC,YAAY,CAAC;QAC1GH,QAAQC,GAAG,CAAC,CAAC,cAAc,EAAErB,YAAY,CAAC;IAC5C;AACF"}

package/dist/parser.d.ts

@@ -0,0 +1,24 @@
+import { InputFieldDefinition } from '@lagless/binary';
+import { ECSSchema, FieldDefinition } from '@lagless/core';
+export type SimulationType = 'raw' | 'physics2d' | 'physics3d';
+export interface ECSConfig {
+    projectName?: string;
+    simulationType?: SimulationType;
+    components?: Record<string, Record<string, string> | null>;
+    singletons?: Record<string, Record<string, string>>;
+    playerResources?: Record<string, Record<string, string>>;
+    filters?: Record<string, {
+        include?: string[];
+        exclude?: string[];
+    }>;
+    inputs?: Record<string, Record<string, string>>;
+}
+export declare function parseInputFieldType(fieldName: string, fieldType: string): InputFieldDefinition;
+export declare function parseFieldType(typeStr: string): FieldDefinition;
+export declare function getProjectNameFromConfigPath(configPath: string): string;
+export declare function parseYamlConfig(configContent: string, configPath?: string): {
+    schema: ECSSchema;
+    projectName: string;
+    simulationType: SimulationType;
+};
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,oBAAoB,EAGrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAEL,SAAS,EACT,eAAe,EAKhB,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,WAAW,GAAG,WAAW,CAAC;AAE/D,MAAM,WAAW,SAAS;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACjD;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,oBAAoB,CAS9F;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CA6B/D;AAED,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAMvE;AAED,wBAAgB,eAAe,CAC7B,aAAa,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GAClB;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,cAAc,CAAA;CAAE,CAsP5E"}

package/dist/parser.js

@@ -48,6 +48,8 @@ export function parseYamlConfig(configContent, configPath) {
     if (!rawConfig.components && !rawConfig.singletons) {
         throw new Error('Config must contain at least one of: components, singletons');
     }
+    var _rawConfig_simulationType;
+    const simulationType = (_rawConfig_simulationType = rawConfig.simulationType) != null ? _rawConfig_simulationType : 'raw';
     // Determine project name: from config or from path
     let projectName;
     if (rawConfig.projectName) {
@@ -57,23 +59,102 @@ export function parseYamlConfig(configContent, configPath) {
     } else {
         throw new Error('projectName must be specified in config or configPath must be provided');
     }
+    // Auto-prepend physics components if needed
+    if (simulationType === 'physics3d') {
+        if (!rawConfig.components) rawConfig.components = {};
+        if (!rawConfig.components['Transform3d']) {
+            rawConfig.components = _extends({
+                Transform3d: {
+                    positionX: 'float32',
+                    positionY: 'float32',
+                    positionZ: 'float32',
+                    rotationX: 'float32',
+                    rotationY: 'float32',
+                    rotationZ: 'float32',
+                    rotationW: 'float32',
+                    prevPositionX: 'float32',
+                    prevPositionY: 'float32',
+                    prevPositionZ: 'float32',
+                    prevRotationX: 'float32',
+                    prevRotationY: 'float32',
+                    prevRotationZ: 'float32',
+                    prevRotationW: 'float32'
+                }
+            }, rawConfig.components);
+        }
+        if (!rawConfig.components['PhysicsRefs']) {
+            // Insert after Transform3d
+            const entries = Object.entries(rawConfig.components);
+            const transform3dIdx = entries.findIndex(([name])=>name === 'Transform3d');
+            const insertIdx = transform3dIdx >= 0 ? transform3dIdx + 1 : 0;
+            entries.splice(insertIdx, 0, [
+                'PhysicsRefs',
+                {
+                    bodyHandle: 'float64',
+                    colliderHandle: 'float64',
+                    bodyType: 'uint8',
+                    collisionLayer: 'uint16'
+                }
+            ]);
+            rawConfig.components = Object.fromEntries(entries);
+        }
+    }
+    // Auto-prepend physics2d components if needed
+    if (simulationType === 'physics2d') {
+        if (!rawConfig.components) rawConfig.components = {};
+        if (!rawConfig.components['Transform2d']) {
+            rawConfig.components = _extends({
+                Transform2d: {
+                    positionX: 'float32',
+                    positionY: 'float32',
+                    rotation: 'float32',
+                    prevPositionX: 'float32',
+                    prevPositionY: 'float32',
+                    prevRotation: 'float32'
+                }
+            }, rawConfig.components);
+        }
+        if (!rawConfig.components['PhysicsRefs']) {
+            // Insert after Transform2d
+            const entries = Object.entries(rawConfig.components);
+            const transform2dIdx = entries.findIndex(([name])=>name === 'Transform2d');
+            const insertIdx = transform2dIdx >= 0 ? transform2dIdx + 1 : 0;
+            entries.splice(insertIdx, 0, [
+                'PhysicsRefs',
+                {
+                    bodyHandle: 'float64',
+                    colliderHandle: 'float64',
+                    bodyType: 'uint8',
+                    collisionLayer: 'uint16'
+                }
+            ]);
+            rawConfig.components = Object.fromEntries(entries);
+        }
+    }
     const components = [];
     const singletons = [];
-    // Parse components
+    // Parse components (ID is now a bit index: 0, 1, 2, ... instead of bitmask value)
     let componentIdx = 0;
     if (rawConfig.components) {
-        for (const [componentName, componentFields] of Object.entries(rawConfig.components)){
+        for (const [componentName, rawComponentFields] of Object.entries(rawConfig.components)){
+            const componentFields = rawComponentFields != null ? rawComponentFields : {};
             const fields = {};
             for (const [fieldName, fieldType] of Object.entries(componentFields)){
                 fields[fieldName] = parseFieldType(fieldType);
             }
+            const isTag = Object.keys(fields).length === 0;
             components.push({
                 name: componentName,
-                id: Math.pow(2, componentIdx++),
-                fields
+                id: componentIdx++,
+                fields,
+                isTag
             });
         }
     }
+    // Validate component count (max 64 supported with two Uint32 mask words)
+    if (components.length > 64) {
+        throw new Error(`Too many components (${components.length}). Maximum supported is 64.`);
+    }
     // Parse singletons
     if (rawConfig.singletons) {
         for (const [singletonName, singletonFields] of Object.entries(rawConfig.singletons)){
@@ -128,6 +209,42 @@ export function parseYamlConfig(configContent, configPath) {
             });
         }
     }
+    // Auto-add PhysicsRefsFilter for physics3d
+    if (simulationType === 'physics3d') {
+        const hasPhysicsFilter = filters.some((f)=>f.name === 'PhysicsRefsFilter');
+        if (!hasPhysicsFilter) {
+            const physicsRefs = components.find((c)=>c.name === 'PhysicsRefs');
+            const transform3d = components.find((c)=>c.name === 'Transform3d');
+            if (physicsRefs && transform3d) {
+                filters.push({
+                    name: 'PhysicsRefsFilter',
+                    include: [
+                        physicsRefs,
+                        transform3d
+                    ],
+                    exclude: []
+                });
+            }
+        }
+    }
+    // Auto-add PhysicsRefsFilter for physics2d
+    if (simulationType === 'physics2d') {
+        const hasPhysicsFilter = filters.some((f)=>f.name === 'PhysicsRefsFilter');
+        if (!hasPhysicsFilter) {
+            const physicsRefs = components.find((c)=>c.name === 'PhysicsRefs');
+            const transform2d = components.find((c)=>c.name === 'Transform2d');
+            if (physicsRefs && transform2d) {
+                filters.push({
+                    name: 'PhysicsRefsFilter',
+                    include: [
+                        physicsRefs,
+                        transform2d
+                    ],
+                    exclude: []
+                });
+            }
+        }
+    }
     const inputs = new Array();
     // Parse inputs
     if (rawConfig.inputs) {
@@ -153,7 +270,8 @@ export function parseYamlConfig(configContent, configPath) {
     };
     return {
         schema,
-        projectName
+        projectName,
+        simulationType
     };
 }
 

package/dist/parser.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/parser.ts"],"sourcesContent":["import {\n  getTypeSizeBytes,\n  InputFieldDefinition,\n  typeStringToFieldType,\n  typeToArrayConstructor,\n} from '@lagless/binary';\nimport {\n  ComponentDefinition,\n  ECSSchema,\n  FieldDefinition,\n  FilterDefinition,\n  IInputDefinition,\n  PlayerResourceDefinition,\n  SingletonDefinition,\n} from '@lagless/core';\nimport { parse } from 'yaml';\n\nexport interface ECSConfig {\n  projectName?: string;\n  components?: Record<string, Record<string, string>>;\n  singletons?: Record<string, Record<string, string>>;\n  playerResources?: Record<string, Record<string, string>>;\n  filters?: Record<string, { include?: string[]; exclude?: string[] }>;\n  inputs?: Record<string, Record<string, string>>;\n}\n\nexport function parseInputFieldType(fieldName: string, fieldType: string): InputFieldDefinition {\n  const res = parseFieldType(fieldType);\n\n  return {\n    name: fieldName,\n    ...res,\n    type: typeStringToFieldType[res.type],\n    byteLength: res.isArray && res.arrayLength ? getTypeSizeBytes(res.type) * res.arrayLength : getTypeSizeBytes(res.type),\n  };\n}\n\nexport function parseFieldType(typeStr: string): FieldDefinition {\n  const arrayMatch = typeStr.match(/^(\\w+)\\[(\\d+)]$/);\n  if (arrayMatch) {\n    const baseType = arrayMatch[1];\n    const arrayLength = parseInt(arrayMatch[2], 10);\n\n    if (!Object.keys(typeToArrayConstructor).includes(baseType)) {\n      throw new Error(`Unsupported array base type: ${baseType}`);\n    }\n\n    if (arrayLength <= 0) {\n      throw new Error(`Array length must be positive: ${arrayLength}`);\n    }\n\n    return {\n      type: baseType,\n      isArray: true,\n      arrayLength,\n    };\n  } else {\n    if (!Object.keys(typeToArrayConstructor).includes(typeStr)) {\n      throw new Error(`Unsupported type: ${typeStr}`);\n    }\n\n    return {\n      type: typeStr,\n      isArray: false,\n    };\n  }\n}\n\nexport function getProjectNameFromConfigPath(configPath: string): string {\n  let projectName = configPath.split('/').slice(-5)[0];\n  projectName = projectName.slice(0, 1).toUpperCase() + projectName.slice(1);\n  // kebab to PascalCase\n  projectName = projectName.replace(/-([a-z])/g, (match, letter) => letter.toUpperCase());\n  return projectName;\n}\n\nexport function parseYamlConfig(configContent: string, configPath?: string): { schema: ECSSchema; projectName: string } {\n  const rawConfig = parse(configContent) as ECSConfig;\n\n  if (!rawConfig.components && !rawConfig.singletons) {\n    throw new Error('Config must contain at least one of: components, singletons');\n  }\n\n  // Determine project name: from config or from path\n  let projectName: string;\n  if (rawConfig.projectName) {\n    projectName = rawConfig.projectName;\n  } else if (configPath) {\n    projectName = getProjectNameFromConfigPath(configPath);\n  } else {\n    throw new Error('projectName must be specified in config or configPath must be provided');\n  }\n\n  const components: ComponentDefinition[] = [];\n  const singletons: SingletonDefinition[] = [];\n\n  // Parse components\n  let componentIdx = 0;\n  if (rawConfig.components) {\n    for (const [componentName, componentFields] of Object.entries<Record<string, string>>(rawConfig.components)) {\n      const fields: Record<string, FieldDefinition> = {};\n\n      for (const [fieldName, fieldType] of Object.entries<string>(componentFields)) {\n        fields[fieldName] = parseFieldType(fieldType);\n      }\n\n      components.push({\n        name: componentName,\n        id: Math.pow(2, componentIdx++),\n        fields,\n      });\n    }\n  }\n\n  // Parse singletons\n  if (rawConfig.singletons) {\n    for (const [singletonName, singletonFields] of Object.entries<Record<string, string>>(rawConfig.singletons)) {\n      const fields: Record<string, FieldDefinition> = {};\n\n      for (const [fieldName, fieldType] of Object.entries<string>(singletonFields)) {\n        fields[fieldName] = parseFieldType(fieldType);\n      }\n\n      singletons.push({\n        name: singletonName,\n        fields,\n      });\n    }\n  }\n\n  const playerResources = new Array<PlayerResourceDefinition>();\n  // Parse player resources\n  if (rawConfig.playerResources) {\n    for (const [resourceName, resourceFields] of Object.entries<Record<string, string>>(rawConfig.playerResources)) {\n      const fields: Record<string, FieldDefinition> = {};\n\n      for (const [fieldName, fieldType] of Object.entries<string>(resourceFields)) {\n        fields[fieldName] = parseFieldType(fieldType);\n      }\n\n      playerResources.push({\n        name: resourceName,\n        fields,\n      });\n    }\n  }\n\n  const filters = new Array<FilterDefinition>();\n  // Parse filters\n  if (rawConfig.filters) {\n    for (const [filterName, filterComponents] of Object.entries(rawConfig.filters)) {\n      const include: ComponentDefinition[] = [];\n      const exclude: ComponentDefinition[] = [];\n\n      for (const componentName of filterComponents.include || []) {\n        const component = components.find(c => c.name === componentName);\n        if (!component) {\n          throw new Error(`Component not found in schema: ${componentName}`);\n        }\n        include.push(component);\n      }\n\n      for (const componentName of filterComponents.exclude || []) {\n        const component = components.find(c => c.name === componentName);\n        if (!component) {\n          throw new Error(`Component not found in schema: ${componentName}`);\n        }\n        exclude.push(component);\n      }\n\n      filters.push({\n        name: filterName,\n        include,\n        exclude,\n      });\n    }\n  }\n\n  const inputs = new Array<IInputDefinition>();\n  // Parse inputs\n  if (rawConfig.inputs) {\n    let inputIdx = 1;\n    for (const [inputName, inputFields] of Object.entries<Record<string, string>>(rawConfig.inputs)) {\n      const fields = new Array<InputFieldDefinition>();\n\n      for (const [fieldName, fieldType] of Object.entries<string>(inputFields)) {\n        fields.push(parseInputFieldType(fieldName, fieldType));\n      }\n\n      inputs.push({\n        name: inputName,\n        id: inputIdx++,\n        fields,\n      });\n    }\n  }\n\n  const schema = { components, singletons, filters, playerResources, inputs };\n  return { schema, projectName };\n}\n"],"names":["getTypeSizeBytes","typeStringToFieldType","typeToArrayConstructor","parse","parseInputFieldType","fieldName","fieldType","res","parseFieldType","name","type","byteLength","isArray","arrayLength","typeStr","arrayMatch","match","baseType","parseInt","Object","keys","includes","Error","getProjectNameFromConfigPath","configPath","projectName","split","slice","toUpperCase","replace","letter","parseYamlConfig","configContent","rawConfig","components","singletons","componentIdx","componentName","componentFields","entries","fields","push","id","Math","pow","singletonName","singletonFields","playerResources","Array","resourceName","resourceFields","filters","filterName","filterComponents","include","exclude","component","find","c","inputs","inputIdx","inputName","inputFields","schema"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../src/parser.ts"],"sourcesContent":["import {\n  getTypeSizeBytes,\n  InputFieldDefinition,\n  typeStringToFieldType,\n  typeToArrayConstructor,\n} from '@lagless/binary';\nimport {\n  ComponentDefinition,\n  ECSSchema,\n  FieldDefinition,\n  FilterDefinition,\n  IInputDefinition,\n  PlayerResourceDefinition,\n  SingletonDefinition,\n} from '@lagless/core';\nimport { parse } from 'yaml';\n\nexport type SimulationType = 'raw' | 'physics2d' | 'physics3d';\n\nexport interface ECSConfig {\n  projectName?: string;\n  simulationType?: SimulationType;\n  components?: Record<string, Record<string, string> | null>;\n  singletons?: Record<string, Record<string, string>>;\n  playerResources?: Record<string, Record<string, string>>;\n  filters?: Record<string, { include?: string[]; exclude?: string[] }>;\n  inputs?: Record<string, Record<string, string>>;\n}\n\nexport function parseInputFieldType(fieldName: string, fieldType: string): InputFieldDefinition {\n  const res = parseFieldType(fieldType);\n\n  return {\n    name: fieldName,\n    ...res,\n    type: typeStringToFieldType[res.type as keyof typeof typeStringToFieldType],\n    byteLength: res.isArray && res.arrayLength ? getTypeSizeBytes(res.type) * res.arrayLength : getTypeSizeBytes(res.type),\n  };\n}\n\nexport function parseFieldType(typeStr: string): FieldDefinition {\n  const arrayMatch = typeStr.match(/^(\\w+)\\[(\\d+)]$/);\n  if (arrayMatch) {\n    const baseType = arrayMatch[1];\n    const arrayLength = parseInt(arrayMatch[2], 10);\n\n    if (!Object.keys(typeToArrayConstructor).includes(baseType)) {\n      throw new Error(`Unsupported array base type: ${baseType}`);\n    }\n\n    if (arrayLength <= 0) {\n      throw new Error(`Array length must be positive: ${arrayLength}`);\n    }\n\n    return {\n      type: baseType,\n      isArray: true,\n      arrayLength,\n    };\n  } else {\n    if (!Object.keys(typeToArrayConstructor).includes(typeStr)) {\n      throw new Error(`Unsupported type: ${typeStr}`);\n    }\n\n    return {\n      type: typeStr,\n      isArray: false,\n    };\n  }\n}\n\nexport function getProjectNameFromConfigPath(configPath: string): string {\n  let projectName = configPath.split('/').slice(-5)[0];\n  projectName = projectName.slice(0, 1).toUpperCase() + projectName.slice(1);\n  // kebab to PascalCase\n  projectName = projectName.replace(/-([a-z])/g, (match, letter) => letter.toUpperCase());\n  return projectName;\n}\n\nexport function parseYamlConfig(\n  configContent: string,\n  configPath?: string,\n): { schema: ECSSchema; projectName: string; simulationType: SimulationType } {\n  const rawConfig = parse(configContent) as ECSConfig;\n\n  if (!rawConfig.components && !rawConfig.singletons) {\n    throw new Error('Config must contain at least one of: components, singletons');\n  }\n\n  const simulationType: SimulationType = rawConfig.simulationType ?? 'raw';\n\n  // Determine project name: from config or from path\n  let projectName: string;\n  if (rawConfig.projectName) {\n    projectName = rawConfig.projectName;\n  } else if (configPath) {\n    projectName = getProjectNameFromConfigPath(configPath);\n  } else {\n    throw new Error('projectName must be specified in config or configPath must be provided');\n  }\n\n  // Auto-prepend physics components if needed\n  if (simulationType === 'physics3d') {\n    if (!rawConfig.components) rawConfig.components = {};\n\n    if (!rawConfig.components['Transform3d']) {\n      rawConfig.components = {\n        Transform3d: {\n          positionX: 'float32',\n          positionY: 'float32',\n          positionZ: 'float32',\n          rotationX: 'float32',\n          rotationY: 'float32',\n          rotationZ: 'float32',\n          rotationW: 'float32',\n          prevPositionX: 'float32',\n          prevPositionY: 'float32',\n          prevPositionZ: 'float32',\n          prevRotationX: 'float32',\n          prevRotationY: 'float32',\n          prevRotationZ: 'float32',\n          prevRotationW: 'float32',\n        },\n        ...rawConfig.components,\n      };\n    }\n\n    if (!rawConfig.components['PhysicsRefs']) {\n      // Insert after Transform3d\n      const entries = Object.entries(rawConfig.components);\n      const transform3dIdx = entries.findIndex(([name]) => name === 'Transform3d');\n      const insertIdx = transform3dIdx >= 0 ? transform3dIdx + 1 : 0;\n      entries.splice(insertIdx, 0, [\n        'PhysicsRefs',\n        {\n          bodyHandle: 'float64',\n          colliderHandle: 'float64',\n          bodyType: 'uint8',\n          collisionLayer: 'uint16',\n        },\n      ]);\n      rawConfig.components = Object.fromEntries(entries);\n    }\n  }\n\n  // Auto-prepend physics2d components if needed\n  if (simulationType === 'physics2d') {\n    if (!rawConfig.components) rawConfig.components = {};\n\n    if (!rawConfig.components['Transform2d']) {\n      rawConfig.components = {\n        Transform2d: {\n          positionX: 'float32',\n          positionY: 'float32',\n          rotation: 'float32',\n          prevPositionX: 'float32',\n          prevPositionY: 'float32',\n          prevRotation: 'float32',\n        },\n        ...rawConfig.components,\n      };\n    }\n\n    if (!rawConfig.components['PhysicsRefs']) {\n      // Insert after Transform2d\n      const entries = Object.entries(rawConfig.components);\n      const transform2dIdx = entries.findIndex(([name]) => name === 'Transform2d');\n      const insertIdx = transform2dIdx >= 0 ? transform2dIdx + 1 : 0;\n      entries.splice(insertIdx, 0, [\n        'PhysicsRefs',\n        {\n          bodyHandle: 'float64',\n          colliderHandle: 'float64',\n          bodyType: 'uint8',\n          collisionLayer: 'uint16',\n        },\n      ]);\n      rawConfig.components = Object.fromEntries(entries);\n    }\n  }\n\n  const components: ComponentDefinition[] = [];\n  const singletons: SingletonDefinition[] = [];\n\n  // Parse components (ID is now a bit index: 0, 1, 2, ... instead of bitmask value)\n  let componentIdx = 0;\n  if (rawConfig.components) {\n    for (const [componentName, rawComponentFields] of Object.entries(rawConfig.components)) {\n      const componentFields = (rawComponentFields ?? {}) as Record<string, string>;\n      const fields: Record<string, FieldDefinition> = {};\n\n      for (const [fieldName, fieldType] of Object.entries<string>(componentFields)) {\n        fields[fieldName] = parseFieldType(fieldType);\n      }\n\n      const isTag = Object.keys(fields).length === 0;\n\n      components.push({\n        name: componentName,\n        id: componentIdx++,\n        fields,\n        isTag,\n      });\n    }\n  }\n\n  // Validate component count (max 64 supported with two Uint32 mask words)\n  if (components.length > 64) {\n    throw new Error(`Too many components (${components.length}). Maximum supported is 64.`);\n  }\n\n  // Parse singletons\n  if (rawConfig.singletons) {\n    for (const [singletonName, singletonFields] of Object.entries<Record<string, string>>(rawConfig.singletons)) {\n      const fields: Record<string, FieldDefinition> = {};\n\n      for (const [fieldName, fieldType] of Object.entries<string>(singletonFields)) {\n        fields[fieldName] = parseFieldType(fieldType);\n      }\n\n      singletons.push({\n        name: singletonName,\n        fields,\n      });\n    }\n  }\n\n  const playerResources = new Array<PlayerResourceDefinition>();\n  // Parse player resources\n  if (rawConfig.playerResources) {\n    for (const [resourceName, resourceFields] of Object.entries<Record<string, string>>(rawConfig.playerResources)) {\n      const fields: Record<string, FieldDefinition> = {};\n\n      for (const [fieldName, fieldType] of Object.entries<string>(resourceFields)) {\n        fields[fieldName] = parseFieldType(fieldType);\n      }\n\n      playerResources.push({\n        name: resourceName,\n        fields,\n      });\n    }\n  }\n\n  const filters = new Array<FilterDefinition>();\n  // Parse filters\n  if (rawConfig.filters) {\n    for (const [filterName, filterComponents] of Object.entries(rawConfig.filters)) {\n      const include: ComponentDefinition[] = [];\n      const exclude: ComponentDefinition[] = [];\n\n      for (const componentName of filterComponents.include || []) {\n        const component = components.find(c => c.name === componentName);\n        if (!component) {\n          throw new Error(`Component not found in schema: ${componentName}`);\n        }\n        include.push(component);\n      }\n\n      for (const componentName of filterComponents.exclude || []) {\n        const component = components.find(c => c.name === componentName);\n        if (!component) {\n          throw new Error(`Component not found in schema: ${componentName}`);\n        }\n        exclude.push(component);\n      }\n\n      filters.push({\n        name: filterName,\n        include,\n        exclude,\n      });\n    }\n  }\n\n  // Auto-add PhysicsRefsFilter for physics3d\n  if (simulationType === 'physics3d') {\n    const hasPhysicsFilter = filters.some((f) => f.name === 'PhysicsRefsFilter');\n    if (!hasPhysicsFilter) {\n      const physicsRefs = components.find((c) => c.name === 'PhysicsRefs');\n      const transform3d = components.find((c) => c.name === 'Transform3d');\n      if (physicsRefs && transform3d) {\n        filters.push({\n          name: 'PhysicsRefsFilter',\n          include: [physicsRefs, transform3d],\n          exclude: [],\n        });\n      }\n    }\n  }\n\n  // Auto-add PhysicsRefsFilter for physics2d\n  if (simulationType === 'physics2d') {\n    const hasPhysicsFilter = filters.some((f) => f.name === 'PhysicsRefsFilter');\n    if (!hasPhysicsFilter) {\n      const physicsRefs = components.find((c) => c.name === 'PhysicsRefs');\n      const transform2d = components.find((c) => c.name === 'Transform2d');\n      if (physicsRefs && transform2d) {\n        filters.push({\n          name: 'PhysicsRefsFilter',\n          include: [physicsRefs, transform2d],\n          exclude: [],\n        });\n      }\n    }\n  }\n\n  const inputs = new Array<IInputDefinition>();\n  // Parse inputs\n  if (rawConfig.inputs) {\n    let inputIdx = 1;\n    for (const [inputName, inputFields] of Object.entries<Record<string, string>>(rawConfig.inputs)) {\n      const fields = new Array<InputFieldDefinition>();\n\n      for (const [fieldName, fieldType] of Object.entries<string>(inputFields)) {\n        fields.push(parseInputFieldType(fieldName, fieldType));\n      }\n\n      inputs.push({\n        name: inputName,\n        id: inputIdx++,\n        fields,\n      });\n    }\n  }\n\n  const schema = { components, singletons, filters, playerResources, inputs };\n  return { schema, projectName, simulationType };\n}\n"],"names":["getTypeSizeBytes","typeStringToFieldType","typeToArrayConstructor","parse","parseInputFieldType","fieldName","fieldType","res","parseFieldType","name","type","byteLength","isArray","arrayLength","typeStr","arrayMatch","match","baseType","parseInt","Object","keys","includes","Error","getProjectNameFromConfigPath","configPath","projectName","split","slice","toUpperCase","replace","letter","parseYamlConfig","configContent","rawConfig","components","singletons","simulationType","Transform3d","positionX","positionY","positionZ","rotationX","rotationY","rotationZ","rotationW","prevPositionX","prevPositionY","prevPositionZ","prevRotationX","prevRotationY","prevRotationZ","prevRotationW","entries","transform3dIdx","findIndex","insertIdx","splice","bodyHandle","colliderHandle","bodyType","collisionLayer","fromEntries","Transform2d","rotation","prevRotation","transform2dIdx","componentIdx","componentName","rawComponentFields","componentFields","fields","isTag","length","push","id","singletonName","singletonFields","playerResources","Array","resourceName","resourceFields","filters","filterName","filterComponents","include","exclude","component","find","c","hasPhysicsFilter","some","f","physicsRefs","transform3d","transform2d","inputs","inputIdx","inputName","inputFields","schema"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/template-engine.d.ts

@@ -0,0 +1,31 @@
+export interface FileOperations {
+    readFile: (path: string) => string;
+    writeFile: (path: string, content: string) => void;
+    joinPath: (...segments: string[]) => string;
+    exists: (path: string) => boolean;
+    readDir?: (path: string) => string[];
+    isDirectory?: (path: string) => boolean;
+}
+export interface TemplateOptions {
+    templateDir: string;
+    outputDir: string;
+    data: any;
+    fileOperations: FileOperations;
+}
+export interface TemplateFile {
+    fullPath: string;
+    relativePath: string;
+    outputPath: string;
+}
+export declare class TemplateEngine {
+    private fileOps;
+    constructor(fileOperations: FileOperations);
+    generateFromTemplate(options: TemplateOptions): Promise<void>;
+    private findTemplateFiles;
+    private isTemplateFile;
+    private getOutputPath;
+    private processTemplateFile;
+    private processFileName;
+}
+export declare function generateFromTemplate(options: TemplateOptions): Promise<void>;
+//# sourceMappingURL=template-engine.d.ts.map

package/dist/template-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-engine.d.ts","sourceRoot":"","sources":["../src/template-engine.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACnC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,QAAQ,EAAE,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;IAC5C,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAClC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;IACrC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CACzC;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,GAAG,CAAC;IACV,cAAc,EAAE,cAAc,CAAC;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAAiB;gBAEpB,cAAc,EAAE,cAAc;IAIpC,oBAAoB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBnE,OAAO,CAAC,iBAAiB;IA4DzB,OAAO,CAAC,cAAc;IAYtB,OAAO,CAAC,aAAa;YAaP,mBAAmB;IA6BjC,OAAO,CAAC,eAAe;CAmBxB;AAGD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAG5E"}

package/files/component/__name__.ts.template

@@ -1,6 +1,19 @@
 // Generated by @lagless/codegen. Do not edit manually.
 import { MemoryTracker } from '@lagless/binary';
+<% if (component.isTag) { %>
+/* eslint-disable @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars */
+export class <%= component.name %> {
+  public static readonly ID = <%= component.id %>;
+  public static readonly IS_TAG = true;
+  public static readonly schema = {};
+
+  public readonly unsafe = {} as Record<string, never>;
 
+  constructor(_maxEntities: number, _buffer: ArrayBuffer, _memTracker: MemoryTracker) {}
+
+  public static calculateSize(_maxEntities: number, _memTracker: MemoryTracker): void {}
+}
+<% } else { %>
 export class <%= component.name %> {
   public static readonly ID = <%= component.id %>;
   public static readonly schema = {
@@ -29,11 +42,10 @@ export class <%= component.name %> {
   }
 
   constructor(maxEntities: number, buffer: ArrayBuffer, memTracker: MemoryTracker) {
-    for (const [fieldName, TypedArrayConstructor] of Object.entries(<%= component.name %>.schema)) {
-      const typedArray = new TypedArrayConstructor(buffer, memTracker.ptr, maxEntities);
-      this.unsafe[fieldName as keyof typeof <%= component.name %>.schema] = typedArray as <%= component.name %>['unsafe'][keyof <%= component.name %>['unsafe']];
-      memTracker.add(typedArray.byteLength);
-    }
+  <% for (const [fieldName, field] of Object.entries(fields)) { %>
+    this.unsafe.<%= fieldName %> = new <%= typeToArrayConstructor[field.type].name %>(buffer, memTracker.ptr, maxEntities);
+    memTracker.add(this.unsafe.<%= fieldName %>.byteLength);
+  <% } %>
 
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
@@ -61,5 +73,5 @@ export class <%= component.name %> {
     }
   }
 }
-
+<% } %>
 Object.defineProperty(<%= component.name %>, 'name', { value: '<%= component.name %>' });

package/files/filter/__name__.ts.template

@@ -6,8 +6,8 @@ export class <%= filter.name %> extends AbstractFilter {
   public static readonly include: Array<IComponentConstructor> = [<%= filter.include.map(({ name }) => name).join(',') %>];
   public static readonly exclude: Array<IComponentConstructor> = [<%= filter.exclude.map(({ name }) => name).join(',') %>];
 
-  public readonly includeMask: number = <%= includeMask %>;
-  public readonly excludeMask: number = <%= excludeMask %>;
+  public readonly includeMask: number[] = [<%= includeMaskWords.join(', ') %>];
+  public readonly excludeMask: number[] = [<%= excludeMaskWords.join(', ') %>];
 }
 
 Object.defineProperty(<%= filter.name %>, 'name', { value: '<%= filter.name %>' });

package/files/runner-physics2d/__projectName__.runner.ts.template

@@ -0,0 +1,19 @@
+// Generated by @lagless/codegen. Do not edit manually.
+import { AbstractInputProvider, ECSConfig } from '@lagless/core';
+import { IECSSystemConstructor, ISignalConstructor } from '@lagless/core';
+import { PhysicsRunner2d, PhysicsConfig2d, RapierModule2d } from '@lagless/physics2d';
+
+import { <%= projectName %>Core } from './<%= projectName %>.core.js';
+
+export class <%= projectName %>Runner extends PhysicsRunner2d {
+  constructor(
+    Config: ECSConfig,
+    InputProviderInstance: AbstractInputProvider,
+    Systems: Array<IECSSystemConstructor>,
+    Signals: Array<ISignalConstructor> = [],
+    rapier: RapierModule2d,
+    physicsConfig?: PhysicsConfig2d,
+  ) {
+    super(Config, InputProviderInstance, Systems, Signals, <%= projectName %>Core, rapier, physicsConfig);
+  }
+}

package/files/runner-physics3d/__projectName__.runner.ts.template

@@ -0,0 +1,22 @@
+// Generated by @lagless/codegen. Do not edit manually.
+import { AbstractInputProvider, ECSConfig } from '@lagless/core';
+import { IECSSystemConstructor, ISignalConstructor } from '@lagless/core';
+import { PhysicsRunner3d, PhysicsConfig3d, RapierModule3d } from '@lagless/physics3d';
+import { CollisionLayers } from '@lagless/physics-shared';
+
+import { <%= projectName %>Core } from './<%= projectName %>.core.js';
+
+export class <%= projectName %>Runner extends PhysicsRunner3d {
+  constructor(
+    Config: ECSConfig,
+    InputProviderInstance: AbstractInputProvider,
+    Systems: Array<IECSSystemConstructor>,
+    Signals: Array<ISignalConstructor> = [],
+    rapier: RapierModule3d,
+    physicsConfig?: PhysicsConfig3d,
+    collisionLayers?: CollisionLayers,
+    extraRegistrations?: Array<[unknown, unknown]>,
+  ) {
+    super(Config, InputProviderInstance, Systems, Signals, <%= projectName %>Core, rapier, physicsConfig, collisionLayers, extraRegistrations);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lagless/codegen",
-  "version": "0.0.35",
+  "version": "0.0.38",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -43,20 +43,19 @@
           "outputPath": "tools/codegen/dist",
           "main": "tools/codegen/src/index.ts",
           "tsConfig": "tools/codegen/tsconfig.lib.json",
-          "skipTypeCheck": true,
           "stripLeadingPaths": true
         }
       }
     }
   },
   "dependencies": {
-    "tslib": "^2.3.0",
+    "@nx/devkit": "^21.6.4",
     "commander": "^14.0.1",
     "yaml": "^2.8.1",
     "ejs": "^3.1.10",
     "@swc/helpers": "~0.5.11",
-    "@lagless/binary": "0.0.35",
-    "@lagless/core": "0.0.35"
+    "@lagless/binary": "0.0.38",
+    "@lagless/core": "0.0.38"
   },
   "devDependencies": {
     "@types/ejs": "^3.1.5"