@nice2dev/game-engine 1.0.28 → 1.1.6

package/dist/types/build-cloud/UnrealBuildCloud.d.ts

@@ -0,0 +1,523 @@
+/**
+ * @file UnrealBuildCloud.ts
+ * @description Unreal Engine Build Cloud system for remote compilation
+ * PRO-1.7.3: Unreal Engine Build Cloud
+ *
+ * Features:
+ * - UE Docker Image configuration
+ * - Multi-version support (UE5.3, 5.4, 5.5+)
+ * - UnrealBuildTool configured
+ * - Shader compilation daemon
+ * - Derived Data Cache (DDC) sharing
+ * - Build Farm Integration
+ * - REST API for build jobs
+ * - Project conversion (Nice2Dev → UE)
+ * - Plugin generation
+ */
+export type UnrealVersion = '5.3' | '5.4' | '5.5' | 'custom';
+export type UnrealPlatform = 'Win64' | 'Linux' | 'Mac' | 'Android' | 'IOS' | 'HoloLens' | 'TVOS' | 'LinuxServer' | 'WindowsServer';
+export type UnrealConfiguration = 'Debug' | 'DebugGame' | 'Development' | 'Shipping' | 'Test';
+export type UnrealBuildType = 'Game' | 'Client' | 'Server' | 'Editor' | 'Program';
+export type BuildStatus = 'pending' | 'queued' | 'preparing' | 'compiling' | 'cooking' | 'packaging' | 'uploading' | 'completed' | 'failed' | 'cancelled';
+export interface UnrealDockerImage {
+    /** Base image tag */
+    tag: string;
+    /** Unreal Engine version */
+    unrealVersion: UnrealVersion;
+    /** Custom version string */
+    customVersion?: string;
+    /** Has source access */
+    hasSourceAccess: boolean;
+    /** Installed platform support */
+    platforms: UnrealPlatformSupport[];
+    /** Shader compilation enabled */
+    shaderCompilation: boolean;
+    /** DDC configuration */
+    ddcConfig: DDCConfiguration;
+    /** Build tool configuration */
+    buildToolConfig: BuildToolConfiguration;
+    /** Image size in bytes */
+    size: number;
+    /** Last updated timestamp */
+    lastUpdated: number;
+}
+export interface UnrealPlatformSupport {
+    platform: UnrealPlatform;
+    sdkVersion?: string;
+    ndkVersion?: string;
+    hasCodeSigning: boolean;
+}
+export interface DDCConfiguration {
+    /** Local DDC path */
+    localPath: string;
+    /** Shared DDC path (network) */
+    sharedPath?: string;
+    /** S3 bucket for DDC */
+    s3Bucket?: string;
+    /** Enable DDC caching */
+    enabled: boolean;
+    /** Max cache size in GB */
+    maxSizeGB: number;
+}
+export interface BuildToolConfiguration {
+    /** UBT parallel jobs */
+    parallelJobs: number;
+    /** Use UnityBuild */
+    useUnityBuild: boolean;
+    /** Unity file count */
+    unityFileCount: number;
+    /** Use PCH */
+    usePCH: boolean;
+    /** Use incremental linking */
+    incrementalLinking: boolean;
+    /** Enable LTCG */
+    enableLTCG: boolean;
+}
+export declare const UNREAL_DOCKER_IMAGES: Record<UnrealVersion, UnrealDockerImage>;
+export interface UnrealBuildConfig {
+    /** Unique build ID */
+    id: string;
+    /** Project name */
+    projectName: string;
+    /** Unreal version */
+    unrealVersion: UnrealVersion;
+    /** Custom version string */
+    customUnrealVersion?: string;
+    /** Target platform */
+    platform: UnrealPlatform;
+    /** Build configuration */
+    configuration: UnrealConfiguration;
+    /** Build type */
+    buildType: UnrealBuildType;
+    /** Output path */
+    outputPath: string;
+    /** Build options */
+    options: UnrealBuildOptions;
+    /** Project settings overrides */
+    projectSettings?: Partial<UnrealProjectSettings>;
+    /** Cook settings */
+    cookSettings: CookSettings;
+    /** Pak file settings */
+    pakSettings: PakSettings;
+    /** Build farm settings */
+    buildFarmSettings?: BuildFarmSettings;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Pre-build commands */
+    preBuildCommands?: string[];
+    /** Post-build commands */
+    postBuildCommands?: string[];
+}
+export interface UnrealBuildOptions {
+    /** Clean build */
+    cleanBuild: boolean;
+    /** Iterative cooking */
+    iterativeCooking: boolean;
+    /** Compress content */
+    compressContent: boolean;
+    /** Encrypt pak files */
+    encryptPak: boolean;
+    /** Encryption key (base64) */
+    encryptionKey?: string;
+    /** Build editor */
+    buildEditor: boolean;
+    /** Build tools */
+    buildTools: boolean;
+    /** Use distributed build */
+    distributedBuild: boolean;
+    /** Generate debug symbols */
+    debugSymbols: boolean;
+    /** Force monolithic */
+    forceMonolithic: boolean;
+    /** Disable plugins */
+    disablePlugins?: string[];
+    /** Additional arguments */
+    additionalArgs?: string[];
+}
+export interface UnrealProjectSettings {
+    /** Project name */
+    projectName: string;
+    /** Company name */
+    companyName: string;
+    /** Copyright */
+    copyright: string;
+    /** Description */
+    description: string;
+    /** Version */
+    version: string;
+    /** Bundle identifier */
+    bundleIdentifier: string;
+    /** Default map */
+    defaultMap: string;
+    /** Startup movie */
+    startupMovie?: string;
+    /** Splash screen */
+    splashScreen?: string;
+    /** Icon */
+    icon?: string;
+}
+export interface CookSettings {
+    /** Maps to cook */
+    maps: string[];
+    /** Cook in editor mode */
+    cookInEditorMode: boolean;
+    /** Additional cooked assets */
+    additionalAssets: string[];
+    /** Internationalization preset */
+    internationalization: 'English' | 'EFIGS' | 'EFIGSCJK' | 'All';
+    /** Cook cultures */
+    cultures: string[];
+    /** Texture streaming */
+    textureStreaming: boolean;
+    /** Use pak file */
+    usePakFile: boolean;
+    /** Create release version */
+    releaseVersion?: string;
+}
+export interface PakSettings {
+    /** Use I/O store */
+    useIoStore: boolean;
+    /** Compression format */
+    compression: 'None' | 'Zlib' | 'Gzip' | 'Oodle';
+    /** Compression level */
+    compressionLevel: number;
+    /** Split pak by chunk */
+    splitByChunk: boolean;
+    /** Max pak size MB */
+    maxPakSizeMB: number;
+    /** Signing key (base64) */
+    signingKey?: string;
+}
+export interface BuildFarmSettings {
+    /** Use Incredibuild */
+    useIncredibuild: boolean;
+    /** Use FastBuild */
+    useFastBuild: boolean;
+    /** Agent count */
+    agentCount: number;
+    /** Coordinator host */
+    coordinatorHost?: string;
+    /** Distributed shader compilation */
+    distributedShaders: boolean;
+    /** Max shader workers */
+    maxShaderWorkers: number;
+}
+export interface UnrealBuildJob {
+    id: string;
+    config: UnrealBuildConfig;
+    status: BuildStatus;
+    progress: number;
+    logs: BuildLogEntry[];
+    startedAt?: number;
+    completedAt?: number;
+    error?: string;
+    warnings: string[];
+    artifacts?: BuildArtifact[];
+    metrics?: BuildMetrics;
+    workerId?: string;
+    shaderStats?: ShaderCompilationStats;
+}
+export interface BuildLogEntry {
+    timestamp: number;
+    level: 'info' | 'warning' | 'error' | 'debug';
+    message: string;
+    source?: string;
+    category?: string;
+}
+export interface BuildArtifact {
+    name: string;
+    path: string;
+    size: number;
+    checksum: string;
+    downloadUrl?: string;
+    expiresAt?: number;
+    type: 'executable' | 'pak' | 'ucas' | 'utoc' | 'symbols' | 'logs' | 'other';
+}
+export interface BuildMetrics {
+    totalTime: number;
+    compileTime: number;
+    cookTime: number;
+    packagingTime: number;
+    uploadTime: number;
+    shaderCompileTime: number;
+    ddcHits: number;
+    ddcMisses: number;
+    ddcBytesRead: number;
+    ddcBytesWritten: number;
+    peakMemory: number;
+    artifactSize: number;
+    objectFilesBuilt: number;
+    translationUnitsCompiled: number;
+}
+export interface ShaderCompilationStats {
+    totalShaders: number;
+    compiledShaders: number;
+    cachedShaders: number;
+    failedShaders: number;
+    avgCompileTime: number;
+    totalCompileTime: number;
+    peakMemory: number;
+}
+export interface NiceToUnrealConversionConfig {
+    /** Source Nice2Dev project path */
+    sourcePath: string;
+    /** Output Unreal project path */
+    outputPath: string;
+    /** Target Unreal version */
+    targetUnrealVersion: UnrealVersion;
+    /** Generate C++ code */
+    generateCpp: boolean;
+    /** Generate Blueprints */
+    generateBlueprints: boolean;
+    /** Level conversion settings */
+    levelConversion: LevelConversionSettings;
+    /** Blueprint conversion settings */
+    blueprintConversion: BlueprintConversionSettings;
+    /** Material conversion settings */
+    materialConversion: MaterialConversionSettings;
+    /** Animation conversion settings */
+    animationConversion: AnimationConversionSettings;
+    /** Physics asset configuration */
+    physicsAssetConfig: PhysicsAssetConfig;
+    /** GAS mapping (Gameplay Ability System) */
+    gasMapping?: GASMappingSettings;
+    /** Enhanced Input mapping */
+    enhancedInputMapping: EnhancedInputSettings;
+}
+export interface LevelConversionSettings {
+    /** Convert as sublevels */
+    useSublevels: boolean;
+    /** Level streaming method */
+    streamingMethod: 'AlwaysLoaded' | 'Blueprint' | 'WorldPartition';
+    /** World partition cell size */
+    worldPartitionCellSize?: number;
+    /** Generate navmesh */
+    generateNavmesh: boolean;
+    /** Generate lightmaps */
+    generateLightmaps: boolean;
+    /** Lightmap resolution */
+    lightmapResolution: number;
+}
+export interface BlueprintConversionSettings {
+    /** Convert visual scripts to Blueprints */
+    convertVisualScripts: boolean;
+    /** Generate actor Blueprints */
+    generateActorBlueprints: boolean;
+    /** Generate component Blueprints */
+    generateComponentBlueprints: boolean;
+    /** Blueprint class prefix */
+    blueprintPrefix: string;
+    /** Blueprint class suffix */
+    blueprintSuffix: string;
+    /** Generate Data Tables */
+    generateDataTables: boolean;
+}
+export interface MaterialConversionSettings {
+    /** Target material type */
+    targetMaterialType: 'Standard' | 'Nanite' | 'Lumen';
+    /** Generate material instances */
+    generateMaterialInstances: boolean;
+    /** Master material path */
+    masterMaterialPath?: string;
+    /** Texture import settings */
+    textureSettings: TextureImportSettings;
+    /** Use virtual textures */
+    useVirtualTextures: boolean;
+}
+export interface TextureImportSettings {
+    maxSize: 1024 | 2048 | 4096 | 8192 | 16384;
+    compression: 'Default' | 'NormalMap' | 'Masks' | 'HDR' | 'BC7';
+    generateMips: boolean;
+    sRGB: boolean;
+    virtualTextureStreaming: boolean;
+}
+export interface AnimationConversionSettings {
+    /** Import animation clips */
+    importClips: boolean;
+    /** Import animation Blueprints */
+    importAnimBlueprints: boolean;
+    /** Generate blend spaces */
+    generateBlendSpaces: boolean;
+    /** Generate montages */
+    generateMontages: boolean;
+    /** Root motion settings */
+    rootMotion: {
+        enable: boolean;
+        lockZAxis: boolean;
+        forceRootLock: boolean;
+    };
+    /** Retargeting settings */
+    retargeting: {
+        enabled: boolean;
+        sourceRig?: string;
+        targetRig?: string;
+    };
+}
+export interface PhysicsAssetConfig {
+    /** Generate physics assets */
+    generatePhysicsAssets: boolean;
+    /** Collision complexity */
+    collisionComplexity: 'Simple' | 'UseSimpleAndComplex' | 'UseComplexAsSimple';
+    /** Generate ragdoll */
+    generateRagdoll: boolean;
+    /** Body setup defaults */
+    bodySetupDefaults: {
+        collisionTraceFlag: 'Default' | 'NoTrace' | 'Block' | 'Overlap';
+        physicsType: 'Default' | 'Kinematic' | 'Simulated';
+    };
+}
+export interface GASMappingSettings {
+    /** Enable GAS */
+    enabled: boolean;
+    /** Generate ability classes */
+    generateAbilities: boolean;
+    /** Generate attribute sets */
+    generateAttributeSets: boolean;
+    /** Generate gameplay effects */
+    generateGameplayEffects: boolean;
+    /** Ability mapping */
+    abilityMapping: Array<{
+        nice2devAbility: string;
+        unrealAbility: string;
+        tags: string[];
+    }>;
+}
+export interface EnhancedInputSettings {
+    /** Generate input mapping context */
+    generateInputMappingContext: boolean;
+    /** Generate input actions */
+    generateInputActions: boolean;
+    /** Action mappings */
+    actionMappings: Array<{
+        nice2devAction: string;
+        unrealAction: string;
+        triggerType: 'Pressed' | 'Released' | 'Hold' | 'Tap' | 'Pulse';
+    }>;
+    /** Default mapping context name */
+    defaultMappingContextName: string;
+}
+export interface UnrealPluginConfig {
+    /** Plugin name */
+    name: string;
+    /** Friendly name */
+    friendlyName: string;
+    /** Version */
+    version: string;
+    /** Version name */
+    versionName: string;
+    /** Description */
+    description: string;
+    /** Category */
+    category: string;
+    /** Created by */
+    createdBy: string;
+    /** Created by URL */
+    createdByURL?: string;
+    /** Docs URL */
+    docsURL?: string;
+    /** Marketplace URL */
+    marketplaceURL?: string;
+    /** Support URL */
+    supportURL?: string;
+    /** Can contain content */
+    canContainContent: boolean;
+    /** Is beta version */
+    isBetaVersion: boolean;
+    /** Is experimental */
+    isExperimental: boolean;
+    /** Installed */
+    installed: boolean;
+    /** Modules */
+    modules: PluginModule[];
+    /** Plugins this depends on */
+    plugins: PluginDependency[];
+}
+export interface PluginModule {
+    /** Module name */
+    name: string;
+    /** Module type */
+    type: 'Runtime' | 'RuntimeNoCommandlet' | 'Developer' | 'Editor' | 'EditorNoCommandlet' | 'Program';
+    /** Loading phase */
+    loadingPhase: 'Default' | 'PostDefault' | 'PreDefault' | 'PostConfigInit' | 'PostEngineInit' | 'PostSplashScreen' | 'PreEarlyLoadingScreen' | 'PreLoadingScreen';
+    /** Additional dependencies */
+    additionalDependencies?: string[];
+}
+export interface PluginDependency {
+    /** Plugin name */
+    name: string;
+    /** Is enabled by default */
+    enabled: boolean;
+    /** Is optional */
+    optional: boolean;
+}
+export interface UnrealBuildCloudCallbacks {
+    onBuildSubmitted?: (job: UnrealBuildJob) => void;
+    onBuildStarted?: (job: UnrealBuildJob) => void;
+    onBuildProgress?: (job: UnrealBuildJob, progress: number) => void;
+    onBuildLog?: (job: UnrealBuildJob, log: BuildLogEntry) => void;
+    onBuildCompleted?: (job: UnrealBuildJob) => void;
+    onBuildFailed?: (job: UnrealBuildJob, error: string) => void;
+    onBuildCancelled?: (job: UnrealBuildJob) => void;
+    onArtifactReady?: (job: UnrealBuildJob, artifact: BuildArtifact) => void;
+    onShaderProgress?: (job: UnrealBuildJob, stats: ShaderCompilationStats) => void;
+}
+export declare class UnrealBuildCloud {
+    private config;
+    private jobs;
+    private callbacks;
+    constructor(config?: Partial<UnrealBuildCloud['config']>);
+    submitBuild(config: Partial<UnrealBuildConfig>): Promise<UnrealBuildJob>;
+    private createFullBuildConfig;
+    private generateJobId;
+    private startBuildSimulation;
+    private getExecutableExtension;
+    private generateChecksum;
+    private addLog;
+    cancelBuild(jobId: string): Promise<boolean>;
+    getJob(jobId: string): UnrealBuildJob | undefined;
+    getJobs(): UnrealBuildJob[];
+    convertProject(config: NiceToUnrealConversionConfig): Promise<ConversionResult>;
+    private generateUProjectFile;
+    private generateDefaultGameIni;
+    private generateDefaultEngineIni;
+    private generateBuildCs;
+    private generateModuleCpp;
+    private generateModuleHeader;
+    private generateGuid;
+    generatePlugin(config: UnrealPluginConfig): Promise<PluginGenerationResult>;
+    private generateUpluginFile;
+    private generatePluginBuildCs;
+    private generatePluginModuleCpp;
+    private generatePluginModuleHeader;
+    setCallbacks(callbacks: UnrealBuildCloudCallbacks): void;
+    clearJobs(): void;
+}
+export interface ConversionResult {
+    success: boolean;
+    convertedFiles: Array<{
+        path: string;
+        type: string;
+        content?: string;
+    }>;
+    warnings: string[];
+    errors: string[];
+}
+export interface PluginGenerationResult {
+    success: boolean;
+    pluginPath: string;
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+    warnings: string[];
+}
+export declare function createUnrealBuildCloud(config?: Partial<{
+    apiBaseUrl: string;
+    apiKey: string;
+    defaultUnrealVersion: UnrealVersion;
+    maxConcurrentBuilds: number;
+    buildTimeout: number;
+}>): UnrealBuildCloud;
+export declare function createUnrealBuildConfig(projectName: string, platform: UnrealPlatform, configuration: UnrealConfiguration, options?: Partial<UnrealBuildConfig>): Partial<UnrealBuildConfig>;
+export declare function createNiceToUnrealConfig(sourcePath: string, outputPath: string, options?: Partial<NiceToUnrealConversionConfig>): NiceToUnrealConversionConfig;
+export declare function createUnrealPluginConfig(name: string, version: string, options?: Partial<UnrealPluginConfig>): UnrealPluginConfig;

package/dist/types/build-cloud/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @file index.ts
+ * @description Build Cloud module exports
+ * PRO-1.7: Docker/Edge Build Infrastructure
+ */
+export { type UnityVersion, type UnityPlatform, type LicenseType as UnityLicenseType, type BuildStatus as UnityBuildStatus, type UnityScriptingBackend, type UnityRenderPipeline, type UnityDockerImage, type UnityLicense, type UnityBuildConfig, type UnityBuildJob, type NiceToUnityConversionConfig, type UnityPackageConfig, type AssemblyDefinition, UnityBuildCloud, createUnityBuildCloud, createUnityBuildConfig, createUnityPackageConfig, createNiceToUnityConfig, generateUnityDockerfile, generateBuildScript, } from './UnityBuildCloud';
+export { type GodotVersion, type GodotPlatform, type BuildStatus as GodotBuildStatus, type GodotRenderMode, type GodotScriptLanguage, type GodotDockerImage, type GodotExportTemplate, type GodotBuildConfig, type GodotBuildJob, type NiceToGodotConversionConfig, type GodotAddonConfig, type GodotProjectSettings, GodotBuildCloud, createGodotBuildCloud, createGodotBuildConfig, createNiceToGodotConfig, createGodotAddonConfig, generateGodotDockerfile, } from './GodotBuildCloud';
+export { type UnrealVersion, type UnrealPlatform, type BuildStatus as UnrealBuildStatus, type UnrealConfiguration, type UnrealBuildType, type UnrealDockerImage, type DDCConfiguration, type BuildToolConfiguration, type UnrealBuildConfig, type UnrealBuildJob, type ShaderCompilationStats, type NiceToUnrealConversionConfig, type UnrealPluginConfig, type BuildFarmSettings, UnrealBuildCloud, createUnrealBuildCloud, createUnrealBuildConfig, createNiceToUnrealConfig, createUnrealPluginConfig, } from './UnrealBuildCloud';
+export { type BuildEngine, type AgentOS, type AgentStatus, type QueuePriority, type InstanceType, type BuildJobStatus, type NotificationType, type NotificationEvent, type BuildQueueConfig, type QueuedBuildJob, type ArtifactReference, type QueueStats, type BuildQueueCallbacks, BuildQueueManager, type BuildAgent, type AgentPoolConfig, type ScalingDecision, type PoolStats, type AgentPoolCallbacks, BuildAgentPool, type ArtifactStorageConfig, type StoredArtifact, type StorageStats, ArtifactStorage, type NotificationConfig, type NotificationPayload, type NotificationResult, BuildNotifications, type BuildAnalyticsData, BuildAnalytics, BuildOrchestrator, createBuildQueueManager, createBuildAgentPool, createArtifactStorage, createBuildNotifications, createBuildAnalytics, createBuildOrchestrator, } from './BuildOrchestration';

package/dist/types/community/Community.d.ts

@@ -100,7 +100,7 @@ export declare function runSecurityAudit(checks: SecurityCheckItem[]): {
     criticalFailures: SecurityCheckItem[];
     score: number;
 };
-export declare function generateGitHubActionsCI(config: CommunityConfig): string;
+export declare function generateGitHubActionsCI(_config: CommunityConfig): string;
 export declare const V2_ROADMAP: RoadmapItem[];
 export declare function getRoadmapByMilestone(milestone: string): RoadmapItem[];
 export declare function getRoadmapProgress(): {

package/dist/types/devtools/GameplayAnalytics.d.ts

@@ -1,5 +1,5 @@
-import { EventBus } from '../core/EventBus';
 import React from 'react';
+import { EventBus } from '../core/EventBus';
 export type TelemetryEventCategory = 'gameplay' | 'combat' | 'navigation' | 'interaction' | 'economy' | 'social' | 'progression' | 'performance' | 'ui' | 'error' | 'custom';
 export type HeatmapType = 'death' | 'traversal' | 'interaction' | 'combat' | 'loot' | 'custom';
 export type SessionEventType = 'position' | 'action' | 'input' | 'state-change' | 'camera' | 'dialogue' | 'inventory' | 'quest';

package/dist/types/dialogue/DialogueSystem.d.ts

@@ -1,6 +1,6 @@
-import type { Vec2 } from '../core/types';
-import { EventBus } from '../core/EventBus';
 import React from 'react';
+import { EventBus } from '../core/EventBus';
+import type { Vec2 } from '../core/types';
 /** Dialogue node types */
 export type DialogueNodeType = 'start' | 'text' | 'choice' | 'branch' | 'set_variable' | 'check_variable' | 'event' | 'random' | 'end';
 /** Variable types supported in dialogues */

package/dist/types/ecs/ECSOptimized.d.ts

@@ -0,0 +1,131 @@
+export type EntityId = number;
+export type ComponentTypeId = number;
+export type ArchetypeId = number;
+/** Component schema for SoA layout */
+export interface ComponentSchema {
+    /** Component type identifier */
+    typeId: ComponentTypeId;
+    /** Component name */
+    name: string;
+    /** Fields with their types */
+    fields: ComponentField[];
+    /** Total byte size per component */
+    byteSize: number;
+}
+export interface ComponentField {
+    name: string;
+    type: 'f32' | 'i32' | 'u32' | 'f64' | 'i16' | 'u16' | 'i8' | 'u8' | 'bool' | 'vec2' | 'vec3' | 'vec4' | 'mat4';
+    offset: number;
+    size: number;
+    count?: number;
+}
+export declare class SoAStorage {
+    private buffers;
+    private views;
+    private schemas;
+    private capacity;
+    private count;
+    constructor(capacity?: number);
+    /** Register a component type */
+    registerComponent(schema: ComponentSchema): void;
+    private createTypedView;
+    /** Get a field view for batch operations */
+    getFieldView<T extends TypedArray>(typeId: ComponentTypeId, fieldName: string): T | undefined;
+    /** Set component field value */
+    setField(typeId: ComponentTypeId, entityIndex: number, fieldName: string, value: number | number[]): void;
+    /** Get component field value */
+    getField(typeId: ComponentTypeId, entityIndex: number, fieldName: string): number | number[] | undefined;
+    private getElementCount;
+    /** Grow storage if needed */
+    grow(newCapacity: number): void;
+    get entityCount(): number;
+    set entityCount(value: number);
+    get storageCapacity(): number;
+}
+type TypedArray = Float32Array | Float64Array | Int32Array | Uint32Array | Int16Array | Uint16Array | Int8Array | Uint8Array;
+export interface Archetype {
+    id: ArchetypeId;
+    /** Bitmask of component types in this archetype */
+    componentMask: bigint;
+    /** Component type IDs in this archetype */
+    componentTypes: ComponentTypeId[];
+    /** SoA storage for this archetype */
+    storage: SoAStorage;
+    /** Entity IDs in this archetype */
+    entities: EntityId[];
+    /** Map from entity ID to index in storage */
+    entityToIndex: Map<EntityId, number>;
+}
+export declare class ArchetypeRegistry {
+    private archetypes;
+    private archetypeById;
+    private nextArchetypeId;
+    private componentSchemas;
+    /** Register a component schema */
+    registerComponentSchema(schema: ComponentSchema): void;
+    /** Get or create archetype for a set of components */
+    getOrCreateArchetype(componentTypes: ComponentTypeId[]): Archetype;
+    /** Find archetypes matching a query */
+    findArchetypes(requiredComponents: ComponentTypeId[], excludedComponents?: ComponentTypeId[]): Archetype[];
+    /** Get archetype by ID */
+    getArchetype(id: ArchetypeId): Archetype | undefined;
+}
+export declare class OptimizedWorld {
+    private registry;
+    private entityArchetype;
+    private nextEntityId;
+    private freeEntityIds;
+    private systems;
+    private systemGroups;
+    constructor();
+    /** Register a component schema */
+    registerComponent(schema: ComponentSchema): void;
+    /** Create a new entity with components */
+    createEntity(componentTypes: ComponentTypeId[]): EntityId;
+    /** Destroy an entity */
+    destroyEntity(id: EntityId): void;
+    /** Set component field */
+    setComponent(entityId: EntityId, componentTypeId: ComponentTypeId, fieldName: string, value: number | number[]): void;
+    /** Get component field */
+    getComponent(entityId: EntityId, componentTypeId: ComponentTypeId, fieldName: string): number | number[] | undefined;
+    /** Register a system */
+    addSystem(system: ECSSystem, group?: string): void;
+    /** Query entities */
+    query(requiredComponents: ComponentTypeId[], excludedComponents?: ComponentTypeId[]): QueryIterator;
+    /** Update all systems */
+    update(dt: number): void;
+    /** Update a specific system group */
+    updateGroup(group: string, dt: number): void;
+}
+export declare class QueryIterator implements Iterable<QueryResult> {
+    private archetypes;
+    private componentTypes;
+    constructor(archetypes: Archetype[], componentTypes: ComponentTypeId[]);
+    [Symbol.iterator](): Iterator<QueryResult>;
+    /** Get total entity count across all archetypes */
+    count(): number;
+    /** Batch iterate over archetypes for SIMD-friendly operations */
+    forEachArchetype(callback: (archetype: Archetype, count: number) => void): void;
+    /** Get raw field views for direct manipulation */
+    getFieldViews<T extends TypedArray>(componentTypeId: ComponentTypeId, fieldName: string): {
+        view: T;
+        count: number;
+    }[];
+}
+export interface QueryResult {
+    entityId: EntityId;
+    archetype: Archetype;
+    index: number;
+}
+export interface ECSSystem {
+    name: string;
+    requiredComponents: ComponentTypeId[];
+    excludedComponents?: ComponentTypeId[];
+    priority?: number;
+    update(world: OptimizedWorld, dt: number): void;
+}
+export declare const TRANSFORM_SCHEMA: ComponentSchema;
+export declare const VELOCITY_SCHEMA: ComponentSchema;
+export declare const RENDERABLE_SCHEMA: ComponentSchema;
+export declare const MovementSystem: ECSSystem;
+export {};