@nice2dev/game-engine 1.0.28 → 1.1.6

package/dist/types/godot-integration/GodotLiveLink.d.ts

@@ -0,0 +1,202 @@
+/**
+ * @file GodotLiveLink.ts
+ * @description Godot Engine Live Link for Nice2Dev Game Engine
+ * PRO-1.9.2: Godot Live Link
+ *
+ * Features:
+ * - Godot Editor Plugin (GDScript)
+ * - Scene tree synchronization
+ * - Debug protocol integration
+ * - Remote scene editing
+ * - Live game viewport
+ */
+export type GodotLiveLinkMessageType = 'handshake' | 'handshake_ack' | 'scene_tree' | 'node_selected' | 'node_property_changed' | 'node_added' | 'node_removed' | 'node_reparented' | 'resource_changed' | 'script_changed' | 'play_state_changed' | 'breakpoint_hit' | 'stack_frame' | 'variable_value' | 'console_output' | 'error' | 'ping' | 'pong';
+export interface GodotLiveLinkMessage {
+    type: GodotLiveLinkMessageType;
+    timestamp: number;
+    payload: unknown;
+}
+export interface HandshakePayload {
+    version: string;
+    projectName: string;
+    godotVersion: string;
+    editorId: string;
+    capabilities: GodotEditorCapabilities;
+}
+export interface GodotEditorCapabilities {
+    remoteDebug: boolean;
+    liveEdit: boolean;
+    profiler: boolean;
+    visualProfiler: boolean;
+    networkProfiler: boolean;
+}
+export interface SceneTreePayload {
+    rootPath: string;
+    nodes: GodotRemoteNode[];
+    editedScenePath?: string;
+}
+export interface GodotRemoteNode {
+    id: number;
+    name: string;
+    type: string;
+    path: string;
+    parentId?: number;
+    instancePath?: string;
+    script?: string;
+    groups: string[];
+    children: GodotRemoteNode[];
+    isEditable: boolean;
+}
+export interface NodeSelectedPayload {
+    paths: string[];
+    nodeIds: number[];
+}
+export interface NodePropertyPayload {
+    nodePath: string;
+    nodeId: number;
+    property: string;
+    value: unknown;
+    oldValue?: unknown;
+}
+export interface NodeAddedPayload {
+    parentPath: string;
+    parentId: number;
+    node: GodotRemoteNode;
+    index?: number;
+}
+export interface NodeRemovedPayload {
+    nodePath: string;
+    nodeId: number;
+}
+export interface NodeReparentedPayload {
+    nodePath: string;
+    nodeId: number;
+    oldParentPath: string;
+    newParentPath: string;
+    newParentId: number;
+    index?: number;
+}
+export interface PlayStatePayload {
+    isPlaying: boolean;
+    isPaused: boolean;
+    isDebugging: boolean;
+    currentScene?: string;
+    frameNumber?: number;
+}
+export interface BreakpointHitPayload {
+    scriptPath: string;
+    line: number;
+    stackFrames: StackFrame[];
+}
+export interface StackFrame {
+    id: number;
+    file: string;
+    function: string;
+    line: number;
+    locals: DebugVariable[];
+}
+export interface DebugVariable {
+    name: string;
+    type: string;
+    value: string;
+    children?: DebugVariable[];
+}
+export interface ConsoleOutputPayload {
+    level: 'info' | 'warning' | 'error' | 'debug';
+    message: string;
+    source?: string;
+    line?: number;
+}
+export interface GodotLiveLinkConfig {
+    /** WebSocket server URL */
+    url: string;
+    /** Auto reconnect on disconnect */
+    autoReconnect: boolean;
+    /** Reconnect interval in ms */
+    reconnectInterval: number;
+    /** Max reconnect attempts */
+    maxReconnectAttempts: number;
+    /** Heartbeat interval in ms */
+    heartbeatInterval: number;
+    /** Client identifier */
+    clientId: string;
+    /** Enable debug protocol */
+    enableDebug: boolean;
+}
+export interface GodotLiveLinkCallbacks {
+    onConnected?: (handshake: HandshakePayload) => void;
+    onDisconnected?: (reason?: string) => void;
+    onSceneTree?: (tree: SceneTreePayload) => void;
+    onNodeSelected?: (selection: NodeSelectedPayload) => void;
+    onNodePropertyChanged?: (change: NodePropertyPayload) => void;
+    onNodeAdded?: (added: NodeAddedPayload) => void;
+    onNodeRemoved?: (removed: NodeRemovedPayload) => void;
+    onPlayStateChanged?: (state: PlayStatePayload) => void;
+    onBreakpointHit?: (breakpoint: BreakpointHitPayload) => void;
+    onConsoleOutput?: (output: ConsoleOutputPayload) => void;
+    onError?: (error: Error) => void;
+}
+export interface GodotLiveLinkState {
+    isConnected: boolean;
+    isReconnecting: boolean;
+    reconnectAttempts: number;
+    editorInfo?: HandshakePayload;
+    currentSceneTree?: SceneTreePayload;
+    selectedNodes: string[];
+    playState: PlayStatePayload;
+    breakpoints: Map<string, number[]>;
+}
+export declare class GodotLiveLinkClient {
+    private config;
+    private callbacks;
+    private ws;
+    private heartbeatTimer;
+    private reconnectTimer;
+    private state;
+    constructor(config?: Partial<GodotLiveLinkConfig>);
+    connect(): void;
+    disconnect(): void;
+    private scheduleReconnect;
+    private clearReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private sendHandshake;
+    private send;
+    private handleMessage;
+    requestSceneTree(): void;
+    selectNode(nodePath: string): void;
+    selectNodes(nodePaths: string[]): void;
+    setNodeProperty(nodePath: string, property: string, value: unknown): void;
+    addNode(parentPath: string, nodeType: string, name: string): void;
+    removeNode(nodePath: string): void;
+    reparentNode(nodePath: string, newParentPath: string, index?: number): void;
+    duplicateNode(nodePath: string): void;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    stepFrame(): void;
+    setBreakpoint(scriptPath: string, line: number): void;
+    removeBreakpoint(scriptPath: string, line: number): void;
+    clearBreakpoints(scriptPath?: string): void;
+    continueExecution(): void;
+    stepInto(): void;
+    stepOver(): void;
+    stepOut(): void;
+    getVariableValue(frameId: number, variable: string): void;
+    evaluateExpression(expression: string, frameId?: number): void;
+    getState(): GodotLiveLinkState;
+    isConnected(): boolean;
+    getCurrentSceneTree(): SceneTreePayload | undefined;
+    getSelectedNodes(): string[];
+    getPlayState(): PlayStatePayload;
+    setCallbacks(callbacks: GodotLiveLinkCallbacks): void;
+}
+/**
+ * Generates GDScript code for the Nice2Dev Live Link Godot editor plugin
+ */
+export declare function generateGodotLiveLinkPlugin(): GodotEditorPlugin;
+export interface GodotEditorPlugin {
+    files: Record<string, string>;
+    readme: string;
+}
+export declare function createGodotLiveLinkClient(config?: Partial<GodotLiveLinkConfig>): GodotLiveLinkClient;

package/dist/types/godot-integration/components/GodotProjectBrowser.d.ts

@@ -0,0 +1,86 @@
+import React from 'react';
+export interface GodotResource {
+    id: string;
+    name: string;
+    path: string;
+    type: 'scene' | 'script' | 'resource' | 'texture' | 'audio' | 'mesh' | 'material' | 'animation' | 'shader' | 'theme' | 'other';
+    uid?: string;
+    size: number;
+    lastModified: string;
+    dependencies?: string[];
+    thumbnail?: string;
+    selected: boolean;
+}
+export interface GodotFolder {
+    path: string;
+    name: string;
+    children: (GodotFolder | GodotResource)[];
+    expanded: boolean;
+}
+export interface GodotProjectInfo {
+    name: string;
+    path: string;
+    godotVersion: string;
+    renderer: 'forward_plus' | 'mobile' | 'gl_compatibility';
+    dotnetEnabled: boolean;
+    features: string[];
+    resources: GodotResource[];
+    rootFolder: GodotFolder;
+    autoloads: Array<{
+        name: string;
+        path: string;
+        enabled: boolean;
+    }>;
+    plugins: Array<{
+        name: string;
+        enabled: boolean;
+    }>;
+    exportPresets: Array<{
+        name: string;
+        platform: string;
+    }>;
+}
+export interface GodotSyncStatus {
+    connected: boolean;
+    godotVersion?: string;
+    projectName?: string;
+    isRunning: boolean;
+    lastSync?: string;
+    debuggerConnected: boolean;
+}
+export interface GodotProjectBrowserTheme {
+    background: string;
+    panelBackground: string;
+    headerBackground: string;
+    itemBackground: string;
+    itemHover: string;
+    itemSelected: string;
+    textPrimary: string;
+    textSecondary: string;
+    accent: string;
+    success: string;
+    warning: string;
+    danger: string;
+    border: string;
+    godotBlue: string;
+    sceneColor: string;
+    scriptColor: string;
+    resourceColor: string;
+}
+export interface GodotProjectBrowserProps {
+    projectPath?: string;
+    theme?: Partial<GodotProjectBrowserTheme>;
+    onProjectLoad?: (info: GodotProjectInfo) => void;
+    onImport?: (resources: GodotResource[]) => Promise<void>;
+    onSyncConnect?: () => Promise<GodotSyncStatus>;
+    onSyncDisconnect?: () => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface GodotProjectBrowserRef {
+    loadProject: (path: string) => Promise<void>;
+    getSelectedResources: () => GodotResource[];
+    importSelected: () => Promise<void>;
+}
+export declare const GodotProjectBrowser: React.ForwardRefExoticComponent<GodotProjectBrowserProps & React.RefAttributes<GodotProjectBrowserRef>>;
+export default GodotProjectBrowser;

package/dist/types/godot-integration/components/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Godot Integration UI Components
+ * PRO-1.9: Godot Engine Deep Integration
+ */
+export { GodotProjectBrowser } from './GodotProjectBrowser';
+export type { GodotProjectBrowserProps, GodotProjectBrowserRef, GodotProjectBrowserTheme, GodotResource, GodotFolder, GodotProjectInfo, GodotSyncStatus, } from './GodotProjectBrowser';

package/dist/types/godot-integration/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @file index.ts
+ * @description Godot Integration Module Exports
+ * PRO-1.9: Godot Engine Deep Integration
+ */
+export { type GodotNodeType, type GodotResourceType, type GDScriptType, type GodotSceneHeader, type GodotExtResource, type GodotSubResource, type GodotNode, type GodotSignalConnection, type GodotConnection, type GodotScene, type GodotResource, type GodotResourceHeader, type GDScriptFile, type GDScriptSignal, type GDScriptEnum, type GDScriptConstant, type GDScriptExportVar, type GDScriptVariable, type GDScriptFunction, type GDScriptParameter, type GDScriptInnerClass, type GDScriptAnnotation, type ImportedGodotScene, type ImportedGodotNode, type ImportProgress, type ImportCallbacks, type GodotProjectConfig, type GodotInputAction, type GodotInputEvent, GODOT_NODE_MAPPING, parseGodotScene, parseGodotResource, parseGDScript, GodotProjectImporter, createGodotProjectImporter, } from './GodotImport';
+export { type GodotLiveLinkMessageType, type GodotLiveLinkMessage, type HandshakePayload, type GodotEditorCapabilities, type SceneTreePayload, type GodotRemoteNode, type NodeSelectedPayload, type NodePropertyPayload, type NodeAddedPayload, type NodeRemovedPayload, type NodeReparentedPayload, type PlayStatePayload, type BreakpointHitPayload, type StackFrame, type DebugVariable, type ConsoleOutputPayload, type GodotLiveLinkConfig, type GodotLiveLinkCallbacks, type GodotLiveLinkState, type GodotEditorPlugin, GodotLiveLinkClient, generateGodotLiveLinkPlugin, createGodotLiveLinkClient, } from './GodotLiveLink';
+export { type AssetLibraryCategory, type AssetLibrarySortBy, type AssetLibrarySortOrder, type AssetSupportLevel, type GodotVersion, type GDExtensionPlatform, type AssetLibraryAsset, type AssetPreview, type AssetLibrarySearchQuery, type AssetLibrarySearchResult, type AssetLibraryConfig, type GDExtensionManifest, type GDExtensionInfo, type GDExtensionBinding, type GDExtensionType, type GDExtensionProperty, type GDExtensionMethod, type GDExtensionSignal, type AssetDownloadInfo, type InstallResult, type CompatibilityResult, type AssetLibraryCallbacks, type GDExtensionCallbacks, GodotAssetLibraryBrowser, GDExtensionManager, createGodotAssetLibraryBrowser, createGDExtensionManager, } from './GodotAssetLibrary';
+export * from './components';

package/dist/types/i18n/useTranslation.d.ts

@@ -56,7 +56,7 @@ export declare function TranslatedText({ tKey, values, ns, as: Tag, className, s
     tKey: string;
     values?: InterpolationValues;
     ns?: string;
-    as?: keyof JSX.IntrinsicElements;
+    as?: keyof React.JSX.IntrinsicElements;
     className?: string;
     style?: React.CSSProperties;
 }): React.ReactElement;

package/dist/types/import/GameMakerImporter.d.ts

@@ -352,7 +352,7 @@ export declare class GameMakerImporter extends SceneImporter {
     constructor();
     canHandle(filePath: string): boolean;
     import(options: ImportOptions): Promise<ImportResult>;
-    parseFile(content: string | ArrayBuffer, filePath: string): Promise<ParsedScene | null>;
+    parseFile(content: string | ArrayBuffer, _filePath: string): Promise<ParsedScene | null>;
     validate(sourcePath: string): Promise<ImportError[]>;
     private isRoomFile;
     private isSpriteFile;

package/dist/types/import/LDtkImporter.d.ts

@@ -150,7 +150,7 @@ export declare class LDtkImporter extends SceneImporter {
     private enums;
     constructor();
     import(options: ImportOptions): Promise<ImportResult>;
-    parseFile(content: string | ArrayBuffer, filePath: string): Promise<ParsedScene | ParsedAsset | null>;
+    parseFile(content: string | ArrayBuffer, _filePath: string): Promise<ParsedScene | ParsedAsset | null>;
     validate(sourcePath: string): Promise<ImportError[]>;
     private indexDefinitions;
     private getAllLevels;

package/dist/types/import/NdgFormat.d.ts

@@ -15,8 +15,8 @@
  * - .ndgp - Project with multiple scenes
  * - .ndga - Asset bundle
  */
-import { SceneImporter, ImportOptions, ImportResult, ParsedScene, ParsedAsset, ImportError, ImportSourceType } from './SceneImporter';
 import type { NiceProject, NiceScene, NiceAsset } from '../export/PlatformExporter';
+import { SceneImporter, ImportOptions, ImportResult, ParsedScene, ParsedAsset, ImportError, ImportSourceType } from './SceneImporter';
 declare const NDG_MAGIC = "NDG1";
 export interface NdgFile {
     /** Format magic identifier */
@@ -306,7 +306,7 @@ export declare class NdgImporter extends SceneImporter {
     constructor();
     canHandle(filePath: string): boolean;
     import(options: ImportOptions): Promise<ImportResult>;
-    parseFile(content: string | ArrayBuffer, filePath: string): Promise<ParsedScene | ParsedAsset | null>;
+    parseFile(content: string | ArrayBuffer, _filePath: string): Promise<ParsedScene | ParsedAsset | null>;
     validate(sourcePath: string): Promise<ImportError[]>;
     private convertNdgSceneToNice;
     private convertNdgEntityToNice;

package/dist/types/import/OgmoImporter.d.ts

@@ -216,7 +216,7 @@ export declare class OgmoImporter extends SceneImporter {
     constructor();
     canHandle(filePath: string): boolean;
     import(options: ImportOptions): Promise<ImportResult>;
-    parseFile(content: string | ArrayBuffer, filePath: string): Promise<ParsedScene | null>;
+    parseFile(content: string | ArrayBuffer, _filePath: string): Promise<ParsedScene | null>;
     validate(sourcePath: string): Promise<ImportError[]>;
     private isProjectFile;
     private isLevelFile;

package/dist/types/import/index.d.ts

@@ -26,8 +26,8 @@ export { SpriterImporter, createSpriterImporter } from './SpriterImporter';
 export type { SpriterProject, SpriterData, SpriterFolder, SpriterFile, SpriterEntity, SpriterAnimation, SpriterMainline, SpriterTimeline, SpriterTimelineKey, SpriterBone, SpriterObject, SpriterCharacterMap, } from './SpriterImporter';
 export { NdgImporter, NdgExporter, NdgBidirectionalSync, createNdgImporter, createNdgExporter, createBidirectionalSync, sceneToNdg, ndgToScene, } from './NdgFormat';
 export type { NdgFile, NdgGenerator, NdgSource, NdgProject, NdgProjectSettings, NdgPhysicsSettings, NdgAudioSettings, NdgRenderingSettings, NdgInputSettings, NdgInputAction, NdgScene, NdgSceneSettings, NdgCameraSettings, NdgLightingSettings, NdgLayerDef, NdgEntity, NdgTransform, NdgComponent, NdgPrefabRef, NdgPrefabOverride, NdgScript, NdgScriptRef, NdgTilemap, NdgTilemapLayer, NdgAsset, NdgAssetImportSettings, NdgAssetBundle, } from './NdgFormat';
-import { SceneImporter, ImportSourceType } from './SceneImporter';
 import { NdgImporter } from './NdgFormat';
+import { SceneImporter, ImportSourceType } from './SceneImporter';
 /**
  * Create an importer for the specified source type
  */

package/dist/types/index.d.ts

@@ -68,6 +68,12 @@ export { DEFAULT_TOWER_DEFENSE_CONFIG, createTDState, DEFAULT_RTS_CONFIG, create
 export type { TowerDefenseConfig, TowerTargeting, TowerDef, EnemyWaveDef, TDEnemyDef, TDState, RTSConfig, RTSResources, UnitCommand, RTSUnitDef, RTSBuildingDef, RTSState, TacticsConfig, TacticsUnitDef, TacticsSkillDef, TacticsTile, TacticsTurnOrder, CityBuilderConfig, CityBuildingDef, CityState, IdleConfig, IdleGeneratorDef, IdleUpgradeDef, IdleState, } from './templates/StrategyTemplates';
 export { DEFAULT_MINIGAME_COLLECTION_CONFIG, createMinigameCollectionState, awardPoints, DEFAULT_QUIZ_CONFIG, createQuizState, scoreQuizAnswer, DEFAULT_BOARD_GAME_CONFIG, rollDice, createBoardGameState, DEFAULT_REACTION_CONFIG, createReactionState, getAverageReactionTime, DEFAULT_DRAWING_CONFIG, createDrawingState, generateHint, checkGuess, } from './templates/PartyTemplates';
 export type { MinigameCollectionConfig, MinigameType, MinigameDef, MinigameCollectionState, MinigamePlayer, QuizConfig, QuizLifeline, QuizQuestion, QuizState, BoardGameConfig, BoardSpaceType, BoardSpace, BoardGameState, ReactionGameConfig, ReactionState, DrawingGameConfig, DrawingStroke, DrawingGameState, } from './templates/PartyTemplates';
+export { DEFAULT_FIGHTING_CONFIG, parseDirection, getInputNotation, checkMotionInput, hitboxesOverlap, checkHit, canBlock, applyHit, resetCombo, createFighterState, createFightingGameState, serializeFighterState, deserializeFighterState, advanceFrame, createMove, createCharacter, createComboRoute, createHitbox, PRESET_JABS, PRESET_HEAVY_PUNCH, PRESET_SWEEP, PRESET_SHORYUKEN, } from './templates/FightingTemplate';
+export type { FighterState, AttackType, AttackLevel, BlockType, Hitbox, Hurtbox, MoveFrame, Move, ComboRoute, CharacterDef, FighterInput, InputBufferEntry, FighterState2, FightingGameConfig, FightingGameState, } from './templates/FightingTemplate';
+export { DEFAULT_SURVIVAL_CONFIG, DEFAULT_DAY_NIGHT, WEATHER_CLEAR, WEATHER_RAIN, WEATHER_STORM, WEATHER_SNOW, WEATHER_HEATWAVE, RECIPE_WORKBENCH, RECIPE_CAMPFIRE, RECIPE_STONE_AXE, RECIPE_STONE_PICKAXE, RECIPE_COOKED_MEAT, RECIPE_WOODEN_WALL, RECIPE_IRON_AXE, createSurvivalNeeds, createSurvivalState, updateSurvivalNeeds, updateDayNight, isNight, getDaylightLevel, canCraft, craft, harvestResource, respawnResources, canPlaceBuilding, placeBuilding, damageBuilding, createResourceNode, createCraftingRecipe, createBuildingBlueprint, createEnvironmentalHazard, } from './templates/SurvivalTemplate';
+export type { SurvivalNeeds, ResourceType, ResourceNode, CraftingStation, BuildingBlueprint, PlacementRule, PlacedBuilding, WeatherType, WeatherEffect, DayNightCycle, EnvironmentalHazard, SurvivalConfig, SurvivalState, } from './templates/SurvivalTemplate';
+export { DEFAULT_METROIDVANIA_CONFIG, createMetroidvaniaState, hasAbility, grantAbility, canUseAbility, useAbility, hasWeapon, grantWeapon, getDefaultMaxAmmo, canFire, fireWeapon, getWeaponDamage, canDoubleJump, canWallJump, canDash, canGrapple, canSwim, canDive, canMorph, canEnterRoom, canUseConnection, discoverRoom, clearRoom, revealSecretWall, collectItem, applyUpgrade, isBossDefeated, defeatBoss, saveGame, respawn, updateCompletion, getMapCompletion, createMapRoom, createZone, createMapItem, createRoomEnemy, createConnection, createSecretWall, } from './templates/MetroidvaniaTemplate';
+export type { Ability, Weapon, UpgradeType, MapRoom, RoomConnection, SecretWall, MapItem, RoomEnemy, Zone, PlayerStats, MetroidvaniaState, MetroidvaniaConfig, } from './templates/MetroidvaniaTemplate';
 export { ObjectPool, AssetStreamer, selectLODLevel, updateLODGroups, aabbInFrustum, rectInView, measureMemory, formatBytes, } from './performance/Performance';
 export type { Poolable, AssetPriority, StreamRequest, LODLevel, LODGroup, AABB, FrustumPlane, } from './performance/Performance';
 export { DEFAULT_ACCESSIBILITY_CONFIG, DIFFICULTY_PRESETS, COLORBLIND_MATRICES, applyColorblindFilter, getColorblindCSSFilter, ScreenReaderAnnouncer, getActiveSubtitles, ControlMapper, } from './accessibility/Accessibility';
@@ -88,8 +94,8 @@ export { DEFAULT_FLUID_CONFIG, createFluidParticles, stepFluid, DEFAULT_SOFT_BOD
 export type { FluidConfig, FluidParticle, SoftBodyConfig, SoftBodyNode, SoftBodySpring, SoftBody, DestructionConfig, DestructibleObject, Fragment, RopeConfig, RopePoint, Rope, ClothConfig, ClothNode, ClothLink, ClothMesh, } from './physics/PhysicsAdvanced';
 export { DEFAULT_ADSR, oscillatorSample, adsrValue, SYNTH_PRESETS, createReverb, createDelay, createDistortion, createCompressor, createEffectsChain, evaluateMusicConditions, findNextMusicState, beatDuration, barDuration, currentBeat, nextBarTime, DEFAULT_ANALYSIS_CONFIG, extractBands, DEFAULT_VOICE_CONFIG, } from './audio/AudioAdvanced';
 export type { WaveformType, OscillatorConfig, EnvelopeADSR, SynthPatch, LFOConfig, EffectType, AudioEffect, AudioEffectsChain, ReverbParams, DelayParams, DistortionParams, ChorusParams, CompressorParams, EQBand, MusicLayerState, MusicLayer, MusicCondition, MusicTransition, AdaptiveMusicConfig, MusicState, AudioAnalysisConfig, AudioBands, AudioReactiveBinding, VoiceChatConfig, VoiceParticipant, } from './audio/AudioAdvanced';
-export { DEFAULT_STREAMING, getChunkCoord, getChunksInRadius, chunkKey, valueNoise2D, fbm, selectBiome, DEFAULT_BIOMES, WEATHER_PRESETS, lerpWeather, DEFAULT_DAY_NIGHT, getTimeOfDay, getGameHour, getSunAngle, getCurrentScheduleEntry, canStartQuest, startQuest, updateObjective, isQuestComplete, completeQuest, } from './procedural/WorldBuilding';
-export type { WorldStreamingConfig, WorldChunk, ChunkTerrain, TerrainDecoration, TerrainGenConfig, BiomeDef, VegetationRule, WeatherType, WeatherConfig, WeatherSchedule, WeatherScheduleEntry, DayNightConfig, TimeOfDay, NPCSchedule, ScheduleEntry, QuestState, ObjectiveType, QuestDef, QuestObjective, QuestReward, QuestJournal, QuestInstance, } from './procedural/WorldBuilding';
+export { DEFAULT_STREAMING, getChunkCoord, getChunksInRadius, chunkKey, valueNoise2D, fbm, selectBiome, DEFAULT_BIOMES, WEATHER_PRESETS, lerpWeather, getTimeOfDay, getGameHour, getSunAngle, getCurrentScheduleEntry, canStartQuest, startQuest, updateObjective, isQuestComplete, completeQuest, } from './procedural/WorldBuilding';
+export type { WorldStreamingConfig, WorldChunk, ChunkTerrain, TerrainDecoration, TerrainGenConfig, BiomeDef, VegetationRule, WeatherConfig, WeatherSchedule, WeatherScheduleEntry, DayNightConfig, TimeOfDay, NPCSchedule, ScheduleEntry, QuestState, ObjectiveType, QuestDef, QuestObjective, QuestReward, QuestJournal, QuestInstance, } from './procedural/WorldBuilding';
 export { getActiveSubscriptions, hasProduct, getBalance, modifyBalance, AnalyticsBuffer, assignVariant, insertScore, formatLeaderboardScore, computeChecksum, AchievementTracker, } from './monetization/Monetization';
 export type { ProductType, IAPProduct, IAPContent, PurchaseState, PurchaseRecord, IAPStore, VirtualCurrency, WalletEntry, Wallet, AnalyticsEventType, AnalyticsEvent, AnalyticsConfig, AnalyticsProvider, ABTest, ABVariant, ABAssignment, LeaderboardSort, LeaderboardPeriod, LeaderboardDef, LeaderboardEntry, LeaderboardPage, LeaderboardAntiCheat, CloudSaveConfig, CloudSaveSlot, CloudSyncResult, AchievementDef, AchievementProgress, } from './monetization/Monetization';
 export { DEFAULT_BRANDING, generateCSSVariables, DEFAULT_PASSWORD_POLICY, validatePassword, SYSTEM_ROLES, hasPermission, resolveRolePermissions, AuditLog, PLAN_LIMITS, DEFAULT_RATE_LIMITS, RateLimiter, } from './enterprise/Enterprise';
@@ -137,8 +143,8 @@ export { DialogueEngine, DialogueTreeBuilder, useTypewriter, DialogueBox, Choice
 export type { DialogueNodeType, DialogueVarType, ComparisonOp, EmotionType, TextEffectType, DialogueVariable, VariableCondition, DialogueCharacter, DialogueNodeBase, StartNode, TextNode, ChoiceOption, ChoiceNode, BranchNode, SetVariableNode, CheckVariableNode, EventNode, RandomNode, EndNode, DialogueNode, DialogueTree, } from './dialogue/DialogueSystem';
 export { QuestManager, QuestBuilder, QuestList, QuestTracker, createEmptyQuest, DIFFICULTY_COLORS, DIFFICULTY_XP_MULTIPLIERS, } from './quest/QuestSystem';
 export type { QuestType, QuestStatus, QuestDifficulty, QuestPrerequisite, Quest, QuestState as QuestSystemState, QuestJournal as QuestSystemJournal, QuestEventType, QuestEvent, QuestListProps, QuestTrackerProps, RewardType as QuestRewardType, } from './quest/QuestSystem';
-export { compressSaveData, decompressSaveData, crc32, MigrationEngine, SaveSystemV2, DEFAULT_SAVE_CONFIG, } from './engine/SaveSystemV2';
-export type { SaveSlotType, SaveConflictStrategy, SaveStorageBackend, MigrationDirection, SaveSlotMeta, SaveData, SaveMigration, CloudSyncConfig, AutoSaveConfig, SaveSystemConfig, SaveConflict, SaveResult, } from './engine/SaveSystemV2';
+export { compressSaveData, decompressSaveData, crc32, MigrationEngine, SaveSystem, DEFAULT_SAVE_CONFIG, } from './engine/SaveSystem';
+export type { SaveSlotType, SaveConflictStrategy, SaveStorageBackend, MigrationDirection, SaveSlotMeta, SaveData, SaveMigration, CloudSyncConfig, AutoSaveConfig, SaveSystemConfig, SaveConflict, SaveResult, } from './engine/SaveSystem';
 export { TelemetryPipeline, HeatmapGenerator, SessionRecorder, SessionPlayer, FunnelTracker, GameplayAnalytics, useGameplayAnalytics, AnalyticsDashboard, DEFAULT_TELEMETRY_CONFIG, DEFAULT_HEATMAP_CONFIG, DEFAULT_RECORDING_CONFIG, } from './devtools/GameplayAnalytics';
 export type { TelemetryEventCategory, HeatmapType, SessionEventType, TelemetryEvent, TelemetryConfig, HeatmapConfig, HeatmapCell, SessionFrame, SessionRecordedEvent, SessionRecording, SessionRecordingConfig, FunnelStep, FunnelDefinition, AnalyticsDashboardProps, } from './devtools/GameplayAnalytics';
 export * from './scripting/ScriptAST';
@@ -149,7 +155,44 @@ export * from './export';
 export * from './import';
 export * from './editor/TimelineEditor';
 export * from './editor/ShaderGraph';
+export * from './editor/ProfilerPanel';
+export * from './editor/ConsolePro';
+export * from './editor/AssetBrowser';
+export * from './editor/PrefabSystem';
+export * from './editor/UndoRedoPro';
+export * from './editor/AnimationRetargeting';
+export * from './editor/DialogueSystem';
+export * from './editor/QuestEditor';
+export * from './editor/CraftingEditor';
+export * from './editor/AchievementEditor';
+export * from './editor/LeaderboardSystem';
+export * from './editor/ReplaySystem';
+export * from './editor/ScreenshotMode';
+export * from './editor/VRARMode';
+export * from './performance/ECSOptimization';
+export * from './performance/AssetStreaming';
+export * from './performance/ObjectPooling';
+export * from './performance/MemoryManagement';
+export * from './performance/WebGPURenderer';
+export * from './performance/GameSaveSystem';
+export * from './performance/HotReload';
+export * from './performance/LocalizationRuntime';
+export * from './performance/ModSupport';
+export * from './performance/NetworkPrediction';
+export * from './performance/InputRecording';
+export * from './performance/DeltaCompression';
+export * from './performance/InterestManagement';
+export * from './performance/DeterministicPhysics';
+export * from './performance/MultiThreadedPhysics';
 export * from './systems/ParticleSystem2';
+export * from './systems/TerrainSystem';
+export * from './systems/LightingSystem';
+export * from './systems/PhysicsDebugSystem';
 export * from './ai/BehaviorTree';
 export * from './ai/StateMachine';
 export * from './scripting/VisualScripting2';
+export * from './build-cloud';
+export * from './unity-integration';
+export * from './godot-integration';
+export * from './unreal-integration';
+export * from './native-engine';

package/dist/types/input/GamepadNavigation.d.ts

@@ -6,10 +6,10 @@
  * This context is for navigating UI elements (menus, buttons, selects)
  * with a gamepad d-pad or analog stick.
  */
-import React, { type ReactNode } from "react";
+import React, { type ReactNode } from 'react';
 export interface FocusableMeta {
     id: string;
-    ref: React.RefObject<HTMLElement>;
+    ref: React.RefObject<HTMLElement | null>;
     x: number;
     y: number;
     width: number;
@@ -30,5 +30,5 @@ export interface GamepadNavigationContextType {
 }
 export declare function GamepadNavigationProvider({ children }: {
     children: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;
 export declare function useGamepadNavigation(): GamepadNavigationContextType;

package/dist/types/input/InputManager.d.ts

@@ -1,5 +1,5 @@
-import type { Vec2 } from '../core/types';
 import { EventBus } from '../core/EventBus';
+import type { Vec2 } from '../core/types';
 export type GamepadButton = 'A' | 'B' | 'X' | 'Y' | 'LB' | 'RB' | 'LT' | 'RT' | 'Back' | 'Start' | 'LS' | 'RS' | 'DpadUp' | 'DpadDown' | 'DpadLeft' | 'DpadRight' | 'Home';
 export type GamepadAxis = 'LeftX' | 'LeftY' | 'RightX' | 'RightY';
 export interface ActionState {

package/dist/types/inventory/InventorySystem.d.ts

@@ -1,6 +1,6 @@
-import type { EntityId } from '../core/types';
-import { EventBus } from '../core/EventBus';
 import React from 'react';
+import { EventBus } from '../core/EventBus';
+import type { EntityId } from '../core/types';
 /** Item rarity levels */
 export type ItemRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary' | 'mythic' | 'unique';
 /** Item categories */

package/dist/types/multiplayer/LocalMultiplayer.d.ts

@@ -1,5 +1,5 @@
-import type { Color, ScreenMode, PlayerConfig, Rect } from '../core/types';
 import { EventBus } from '../core/EventBus';
+import type { Color, ScreenMode, PlayerConfig, Rect } from '../core/types';
 export interface Player {
     index: number;
     name: string;

package/dist/types/multiplayer/MiniGameTypes.d.ts

@@ -11,13 +11,13 @@ export interface PlayerSlot {
     profilePlayerId?: number;
 }
 export type InputSource = {
-    type: "keyboard";
+    type: 'keyboard';
     group: number;
 } | {
-    type: "gamepad";
+    type: 'gamepad';
     padIndex: number;
 } | {
-    type: "remote";
+    type: 'remote';
     windowId: string;
 };
 export declare const MINI_PLAYER_COLORS: readonly ["#e74c3c", "#3498db", "#2ecc71", "#f1c40f", "#9b59b6", "#e67e22", "#1abc9c", "#e91e63"];