@nice2dev/game-engine 0.1.0

package/dist/types/index.d.ts

@@ -0,0 +1,127 @@
+export type { Vec2, Vec3, Rect, Color, GameState, EntityId, ComponentType, Component, UpdateFn, InputDevice, InputAction, AudioChannel, SceneData, SerializedEntity, SerializedComponent, GameProject, GameSettings, PhysicsSettings, AudioSettings, RenderingSettings, AssetType, AssetEntry, AssetManifest, GameEventType, GameEvent, ScreenMode, PlayerConfig, DeepPartial, Constructor, } from './core/types';
+export { GameLoop } from './core/GameLoop';
+export { GameClock } from './core/GameClock';
+export { GameConfig } from './core/GameConfig';
+export { EventBus } from './core/EventBus';
+export { ServiceLocator, SERVICE_KEYS } from './core/ServiceLocator';
+export { v2 } from './core/math';
+export { World, System, createDefaultComponent, } from './ecs/World';
+export type { Entity, ComponentMap, BuiltInComponent, TransformComponent, SpriteComponent, ShapeComponent, Collider2DComponent, RigidBody2DComponent, TextComponent, AnimatorComponent, ScriptComponent, AudioSourceComponent, ParticleEmitterComponent, CameraTargetComponent, SpriteAnimation, AnimationFrame, } from './ecs/World';
+export { InputManager, PRESET_PLATFORMER, PRESET_TOPDOWN, PRESET_TWIN_STICK } from './input/InputManager';
+export { GamepadNavigationProvider, useGamepadNavigation } from './input/GamepadNavigation';
+export type { FocusableMeta, GamepadNavigationContextType } from './input/GamepadNavigation';
+export { useGamepads, useGamepadEdges } from './input/useGamepads';
+export type { GamepadSnapshot } from './input/useGamepads';
+export { AudioManager } from './audio/AudioManager';
+export { Camera2D } from './rendering/Camera2D';
+export { Renderer2D, RenderSystem } from './rendering/Renderer2D';
+export { PhysicsEngine2D, PhysicsSystem } from './physics/PhysicsEngine2D';
+export { SceneManager } from './scene/SceneManager';
+export type { SceneConfig, SceneTransition, TransitionType, PrefabDef } from './scene/SceneManager';
+export { GameUI } from './ui/GameUI';
+export type { UIElement, UIStyle, UITheme, UIAnchor, UIElementType } from './ui/GameUI';
+export { PlayerManager, SplitScreenManager, PLAYER_COLORS } from './multiplayer/LocalMultiplayer';
+export type { Player, Viewport } from './multiplayer/LocalMultiplayer';
+export { GameRegistry, gameRegistry, MINI_PLAYER_COLORS, MINI_PLAYER_NAMES, KEYBOARD_GROUPS, DIR_UP, DIR_DOWN, DIR_LEFT, DIR_RIGHT, } from './multiplayer/MiniGameTypes';
+export type { PlayerSlot, InputSource, Dir, KeyboardGroup, MiniGameMeta, MiniGameConfig, } from './multiplayer/MiniGameTypes';
+export { SeededRandom, PerlinNoise, WaveGenerator, LootTable, ProceduralSprite } from './procedural/Procedural';
+export type { WaveEntry, WaveConfig, LootDrop } from './procedural/Procedural';
+export { NiceGameEngine } from './engine/NiceGameEngine';
+export type { EngineOptions } from './engine/NiceGameEngine';
+export { WaveDefenseTemplate, DEFAULT_WAVE_DEFENSE_CONFIG } from './templates/WaveDefense';
+export type { WaveDefenseConfig, WaveDefenseState, UpgradeDef, UpgradeEffect } from './templates/WaveDefense';
+export { NiceGameEditor, UndoStack, useEditor, serializeProject, deserializeProject } from './editor/NiceGameEditor';
+export type { NiceGameEditorProps, EditorContextValue, EditorState, EditorTool, EditorMode, EditorPanel, UndoEntry } from './editor/NiceGameEditor';
+export { createGizmoState, getSelectionRect, entitiesInRect, snapToGrid, snapVec2ToGrid, renderGrid, renderTranslateGizmo, renderRotateGizmo, renderScaleGizmo, hitTestGizmoAxis, pickEntityAt, copyEntities, pasteEntities, } from './editor/SceneEditor';
+export type { GizmoMode, GizmoAxis, GizmoState, SelectionBox, ClipboardEntry } from './editor/SceneEditor';
+export { AssetManager } from './editor/AssetManager';
+export type { AssetMetadata, AssetFolder } from './editor/AssetManager';
+export { Profiler, FPSCounter, ConsoleLogger, snapshotEntity, snapshotWorld, renderCollisionDebug, getMemoryStats } from './editor/DebugTools';
+export type { ProfilerSample, ProfilerFrame, LogLevel, LogEntry, EntitySnapshot, MemoryStats } from './editor/DebugTools';
+export { NodeLibrary, GraphExecutor, registerBuiltInNodes, createDefaultNodeLibrary, } from './scripting/NodeGraph';
+export type { PortDataType, PortDef, NodeDef, NodeInstance, Connection, ScriptGraph, GraphVariable, } from './scripting/NodeGraph';
+export { Tilemap, computeAutoTileMask } from './tilemap/Tilemap';
+export type { TileDef, TilesetDef, TilemapLayer, TilemapData } from './tilemap/Tilemap';
+export { SpriteAnimator, TweenManager, AnimationStateMachine, Easing, createClipFromSheet, } from './animation/Animation';
+export type { AnimationClip, AnimationEventCallback, EasingFn, TweenConfig, AnimState, AnimTransition, } from './animation/Animation';
+export { findPath, smoothPath, FlowField, findContainingPolygon } from './pathfinding/Pathfinding';
+export type { PathGrid, PathfinderOptions, NavPolygon, NavMesh } from './pathfinding/Pathfinding';
+export { PeerManager, createWebSocketSignaling, NetworkManager, SnapshotBuffer, ClientPrediction, interpolateState, LobbyManager, } from './network/Networking';
+export type { ConnectionState, PeerInfo, SignalingMessage, SignalingTransport, RTCConfig, NetworkMode, NetworkIdentity, RPCDef, SyncVarDef, NetworkMessage, Snapshot, EntityState, PredictionInput, LobbyRoom, LobbyPlayer, } from './network/Networking';
+export { LocalTransport, SignalRTransport } from './network/MultiplayerTransport';
+export type { IMultiplayerTransport, TransportState, TransportMessage } from './network/MultiplayerTransport';
+export { v3, quat, World3D, PhysicsWorld3D, Renderer3D, createDefaultCamera3DSettings, updateOrbitCamera, updateCharacterController, DEFAULT_CHARACTER_CONFIG, } from './runtime3d/Runtime3D';
+export type { Vec3 as Vec3_3D, Quaternion, Transform3D, MeshPrimitive, MeshComponent, LightType, LightComponent, CameraMode3D, Camera3DComponent, Material3D, CameraController, Camera3DSettings, ColliderShape3D, RigidBodyType3D, Collider3DDef, RigidBody3DDef, PhysicsWorld3DConfig, PhysicsBackend3D, RaycastHit3D, RendererBackend3D, CharacterControllerConfig, CharacterState, } from './runtime3d/Runtime3D';
+export { createGizmo3DState, snapToGrid3D, placeObject, Terrain3D, MaterialLibrary, createBlendTree, addBlendTreeChild, evaluateBlendTree, DEFAULT_PLACEMENT_CONFIG, DEFAULT_TERRAIN_CONFIG, DEFAULT_SKYBOX, DEFAULT_FPS_CONFIG, DEFAULT_THIRD_PERSON_CONFIG, DEFAULT_RACING_3D_CONFIG, DEFAULT_FLIGHT_SIM_CONFIG, DEFAULT_HORROR_CONFIG, } from './runtime3d/SceneEditor3D';
+export type { Gizmo3DMode, Gizmo3DAxis, Gizmo3DSpace, Gizmo3DState, PlacementConfig, TerrainConfig, SkyboxConfig, ModelAsset, AnimationRetargetMap, IKChain, BlendTreeNode, ShaderUniform, ShaderDef, DecalDef, FPSTemplateConfig, ThirdPersonTemplateConfig, RacingTemplate3DConfig, FlightSimConfig, HorrorTemplateConfig, } from './runtime3d/SceneEditor3D';
+export { DEFAULT_PLATFORMER_CONFIG, createPlatformerState, updatePlatformer, DEFAULT_RUN_AND_GUN_CONFIG, PRESET_WEAPONS, DEFAULT_BEAT_EM_UP_CONFIG, createBeatEmUpState, DEFAULT_HACK_AND_SLASH_CONFIG, DEFAULT_TWIN_STICK_CONFIG, createTwinStickState, ProjectilePool, } from './templates/ActionTemplates';
+export type { PlatformerConfig, PlatformerState, RunAndGunConfig, WeaponType, WeaponDef, BeatEmUpConfig, ComboChain, BeatEmUpState, HackAndSlashConfig, SkillDef, TwinStickConfig, TwinStickState, Projectile, } from './templates/ActionTemplates';
+export { DEFAULT_MATCH3_CONFIG, createMatch3Board, findMatches, removeMatches, applyGravity, swapGems, DEFAULT_BLOCK_PUZZLE_CONFIG, TETROMINOES, createBlockPuzzleState, checkLines, clearLines, DEFAULT_PHYSICS_PUZZLE_CONFIG, DEFAULT_HIDDEN_OBJECT_CONFIG, Deck, createStandardDeck, } from './templates/PuzzleTemplates';
+export type { Match3Config, GemType, Match3Board, BlockPuzzleConfig, BlockPuzzleState, PhysicsPuzzleConfig, PuzzleLevelDef, HiddenObjectConfig, HiddenObjectDef, HiddenObjectLevel, CardDef, DeckConfig, } from './templates/PuzzleTemplates';
+export { DEFAULT_RPG_CONFIG, xpForLevel, createInventory, addItem, DEFAULT_VISUAL_NOVEL_CONFIG, parseVNLabels, createVNState, DEFAULT_POINT_AND_CLICK_CONFIG, DEFAULT_ROGUELIKE_CONFIG, generateDungeon, computeFOV, DEFAULT_DUNGEON_CRAWLER_CONFIG, } from './templates/RPGTemplates';
+export type { RPGConfig, RPGStats, RPGCharacter, StatusEffect, ItemDef, Inventory, VisualNovelConfig, VNCommandType, VNCommand, VNChoice, VNScript, VNState, PointAndClickConfig, Hotspot, RoomDef, RoguelikeConfig, TileType, DungeonRoom, DungeonCrawlerConfig, DungeonFloorDef, } from './templates/RPGTemplates';
+export { DEFAULT_TOP_DOWN_RACING_CONFIG, createRacerState, updateRacer, DEFAULT_SIDE_SCROLLER_RACING_CONFIG, DEFAULT_SOCCER_CONFIG, DEFAULT_BASKETBALL_CONFIG, createSportsState, DEFAULT_GOLF_CONFIG, DEFAULT_BILLIARDS_CONFIG, updateBilliardsBalls, DEFAULT_RHYTHM_CONFIG, createRhythmState, judgeHit, applyHitResult, } from './templates/SportsTemplates';
+export type { TopDownRacingConfig, RacerState, TrackCheckpoint, SideScrollerRacingConfig, SportType, SportsConfig, SportsState, GolfConfig, BilliardsConfig, BilliardsBall, RhythmConfig, NoteType, RhythmNote, RhythmChart, RhythmState, } from './templates/SportsTemplates';
+export { DEFAULT_TOWER_DEFENSE_CONFIG, createTDState, DEFAULT_RTS_CONFIG, createRTSState, DEFAULT_TACTICS_CONFIG, createTurnOrder, nextUnit, DEFAULT_CITY_BUILDER_CONFIG, createCityState, updateCity, DEFAULT_IDLE_CONFIG, createIdleState, getGeneratorCost, getIdleIncome, formatNumber, } from './templates/StrategyTemplates';
+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 { 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';
+export type { ColorblindMode, AccessibilityConfig, DifficultyPreset, DifficultySettings, SubtitleEntry, SubtitleTrack, ControlMapping, } from './accessibility/Accessibility';
+export { ENGINE_MODULES, ENGINE_VERSION, ENGINE_NAME, CHANGELOG, runBenchmark, formatBenchmark, detectCapabilities, DEFAULT_EXPORT_CONFIG, generatePWAManifest, } from './release/Release';
+export type { APIDocEntry, APIDocModule, MigrationGuide, MigrationChange, BenchmarkResult, EngineCapabilities, ExportConfig, } from './release/Release';
+export { BTAction, BTCondition, BTSequence, BTSelector, BTParallel, BTDecorator, BTRepeat, btInvert, steerSeek, steerFlee, steerArrive, steerWander, steerSeparation, FiniteStateMachine, selectBestAction, planGOAP, createDialogTree, getAvailableResponses, } from './ai/AI';
+export type { BTStatus, BTContext, BTNode, SteeringAgent, FSMState, UtilityAction, GOAPAction, GOAPGoal, DialogNode, DialogResponse, DialogTree, } from './ai/AI';
+export { VR_SESSION_DEFAULT, AR_SESSION_DEFAULT, detectXRCapabilities, STANDARD_CONTROLLER_MAPPING, createPinchGesture, createGrabGesture, DEFAULT_AR_PLACEMENT, snapPlacement, createSpatialPanel, billboardToward, DEFAULT_PANO_CONFIG, DEFAULT_VR_COMFORT, DEFAULT_VR_TELEPORT, DEFAULT_VR_INTERACTION, } from './xr/ARVR';
+export type { XRSessionMode, XRSessionConfig, XRCapabilities, XRInputState, XRButtonState, XRControllerMapping, XRHandedness, HandJointName, HandJointPose, HandGesture, ARHitResult, ARAnchor, ARPlacementConfig, LightEstimate, SpatialPanel, PanoVideoConfig, VRGameConfig, VRLocomotion, VRComfort, VRTeleportConfig, VRInteractionConfig, } from './xr/ARVR';
+export { createMarketplaceQuery, computeRatingAggregate, computeJamPhase, computeJamResults, recommendGames, } from './social/Social';
+export type { UserProfile, Badge, UserStats, SocialLink, PrivacySettings, AssetCategory, AssetLicense, MarketplaceAsset, MarketplaceQuery, MarketplaceResult, GameVisibility, ContentRating, PublishedGame, PublishConfig, GameFeature, Comment, Rating, RatingAggregate, JamPhase, GameJam, JamSubmission, JamScore, FeaturedCollection, DiscoveryFeed, GameRecommendation, NotificationType, UserNotification, } from './social/Social';
+export { DEFAULT_ASSET_OPTIMIZATION, generateServiceWorkerConfig, createCapacitorConfig, createElectronConfig, createDefaultMobileLayout, MOBILE_PERF_PROFILES, } from './release/MobileExport';
+export type { ExportPlatform, ExportStep, ExportPipelineConfig, AssetOptimizationConfig, SigningConfig, ExportResult, PWAConfig, PWAIcon, CapacitorConfig, CapacitorPluginConfig, ElectronConfig, ElectronWebPrefs, VirtualControlType, VirtualControl, VirtualJoystickConfig, VirtualButtonConfig, TouchControlLayout, AdProvider, AdType, AdConfig, AdPlacement, AdEvent, MobilePerformanceProfile, } from './release/MobileExport';
+export { mergeVersionVectors, happensBefore, DEFAULT_GIT_CONFIG, PluginRegistry, createCustomNode, DEFAULT_KEYBINDINGS, DEFAULT_EDITOR_LAYOUT, } from './editor/AdvancedEditor';
+export type { CollabOperation, CollabCursor, CollabPresence, CollabSession, CollabPermissions, CollabMessage, VersionVector, GitIntegrationConfig, GitStatus, GitFileChange, GitCommitInfo, PluginManifest, PluginPermission, PluginContributions, PluginCommand, PluginPanel, PluginNodeType, PluginState, PluginInstance, CustomNodeDefinition, NodePinType, NodePinDef, NodePropertyDef, Keybinding, EditorLayout, EditorPanelLayout, EditorToolbarLayout, } from './editor/AdvancedEditor';
+export { DEFAULT_FLUID_CONFIG, createFluidParticles, stepFluid, DEFAULT_SOFT_BODY, createSoftBodyCircle, stepSoftBody, DEFAULT_DESTRUCTION, shatterObject, DEFAULT_ROPE_CONFIG, createRope, stepRope, DEFAULT_CLOTH, createCloth, stepCloth, } from './physics/PhysicsAdvanced';
+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 { 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';
+export type { BrandingConfig, AuthProvider, AuthConfig, AuthProviderConfig, MFAConfig, PasswordPolicy, Permission, RoleDef, AuditAction, AuditEntry, AuditQuery, Organization, OrgMember, OrgPlan, OrgSettings, APIKey, RateLimitConfig, DeploymentConfig, DatabaseConfig, StorageConfig, CacheConfig, ScalingConfig, } from './enterprise/Enterprise';
+export { I18nManager, getI18n, initI18n, t, registerEngineTranslations, ENGINE_TRANSLATIONS_EN, ENGINE_TRANSLATIONS_PL, ENGINE_TRANSLATIONS_DE, SUPPORTED_LOCALES, LOCALE_NAMES, RTL_LOCALES, } from './i18n/I18n';
+export type { Locale, TranslationDict, TranslationNamespace, InterpolationValues, PluralCategory, PluralRule, I18nConfig, } from './i18n/I18n';
+export { useTranslation, I18nProvider, TranslatedText, LocaleSelect, } from './i18n/useTranslation';
+export type { UseTranslationResult } from './i18n/useTranslation';
+export { TutorialEngine, getBuiltInTutorials, TUTORIAL_FIRST_GAME, TUTORIAL_SPACE_SHOOTER, TUTORIAL_DATAGRID_BASICS, } from './tutorials/TutorialEngine';
+export type { TutorialStepType, TutorialDifficulty, TutorialCategory, QuizOption, CodeValidation, TutorialStep, TutorialDefinition, TutorialProgress, TutorialEvents, CodeValidatorFn, } from './tutorials/TutorialEngine';
+export { KidModeManager, DEFAULT_KID_MODE_CONFIG, KID_DIFFICULTY_PRESETS, VISUAL_BLOCKS, KID_BADGES, KID_SPRITES, } from './kids/KidMode';
+export type { AgeGroup, KidDifficulty, BlockCategory, VisualBlock, BlockParam, KidSprite, KidBadge, BadgeCondition, KidProfile, ParentConfig, ClassroomConfig, KidModeConfig, KidDifficultySettings, } from './kids/KidMode';
+export { getEngineError, formatEngineError, throwEngineError, warnEngine, searchAPIHints, API_HINTS, createPerfDashboard, recordPerfSnapshot, getAverageFPS, getPerfSummary, runHealthCheck, renderDebugOverlay, DEFAULT_DEBUG_OVERLAY, QUICK_START_TEMPLATES, } from './devtools/DeveloperExperience';
+export type { EngineError, APIHint, PerfSnapshot, PerfDashboard, HealthCheckResult, DebugOverlayConfig, QuickStartTemplate, } from './devtools/DeveloperExperience';
+export { TUTORIAL_ANIMATIONS, TUTORIAL_TILEMAPS, TUTORIAL_VISUAL_SCRIPTING, TUTORIAL_LOCAL_MULTIPLAYER, getTutorials_T05_T08, } from './tutorials/content/Tutorials_T05_T08';
+export { clamp, clampPositive, assertFinite, assertPositive, assertNonNegative, assertInRange, assertNonEmpty, assertCanvasElement, validateGameSettings, validatePhysicsSettings, } from './core/Validation';
+export type { ValidationResult } from './core/Validation';
+export { PluginManager, PluginMarketplace, PLUGIN_TEMPLATES, } from './plugins/PluginSDK';
+export type { PluginState as SDKPluginState, PluginType, PluginManifest as SDKPluginManifest, PluginContext, PluginDefinition, ExtensionPoint, PluginStorage, PluginInstance as SDKPluginInstance, PluginTemplate, MarketplaceEntry, MarketplaceSearchResult, } from './plugins/PluginSDK';
+export { TestPluginStorage, TestPluginContext, PluginAssertionError, pluginAssert, PluginTestRunner, createTestManifest, testPluginLifecycle, formatTestResults, } from './plugins/PluginTestKit';
+export type { TestStatus, TestResult, TestSuiteResult, PluginTestCase, } from './plugins/PluginTestKit';
+export { TUTORIAL_MULTIPLAYER_ONLINE, TUTORIAL_PROCEDURAL_WORLD, TUTORIAL_PLATFORMER, getTutorials_T09_T11, } from './tutorials/content/Tutorials_T09_T11';
+export { TUTORIAL_RPG, TUTORIAL_TOWER_DEFENSE, TUTORIAL_3D_GAME, TUTORIAL_PUBLISHING, getTutorials_T12_T15, } from './tutorials/content/Tutorials_T12_T15';
+export { FrameBudgetManager, MemoryLeakDetector, AutoLODManager, WorkerPool, PerfTimer, ObjectPool as LegendaryObjectPool, QUALITY_PRESETS, } from './performance/PerformanceAdvanced';
+export type { FrameBudgetConfig, BudgetReport, FrameBudgetSnapshot, MemoryTracker, MemorySnapshot, LeakSuspect, QualityLevel, AutoLODConfig, QualitySettings, WorkerTaskStatus, WorkerTask, WorkerPoolConfig, } from './performance/PerformanceAdvanced';
+export { TutorialOverlay } from './tutorials/TutorialOverlay';
+export type { OverlayConfig, TooltipPosition, OverlayAction, } from './tutorials/TutorialOverlay';
+export { DocRegistry, DOCS_ECS, DOCS_RENDERING, } from './docs/DocGenerator';
+export type { DocCategory, DocMemberKind, DocParam, DocMember, DocModule, DocSearchResult, } from './docs/DocGenerator';
+export { BranchingEngine, AchievementEngine, BUILT_IN_ACHIEVEMENTS, } from './tutorials/TutorialBranching';
+export type { BranchConditionType, BranchCondition, BranchRule, BranchingStep, BranchingConfig, BranchContext, AchievementTier, AchievementCondition, AchievementDefinition, AchievementProgress as LegendaryAchievementProgress, } from './tutorials/TutorialBranching';
+export { HotModuleReplacer, AssetPipeline, DeployManager, CollaborationManager, } from './devtools/DevTools';
+export type { HMRModule, HMRUpdate, AssetType as PipelineAssetType, AssetMeta, AssetProcessorOptions, DeployTarget, DeployConfig, DeployResult, CollaboratorCursor, } from './devtools/DevTools';
+export { GuidedWizard, BlockEditor, KID_BLOCK_PALETTES, } from './kids/KidTools';
+export type { WizardChoice, WizardStep, WizardResult, BlockShape, DragBlock, BlockPalette, DragDropState, } from './kids/KidTools';
+export { BenchmarkRunner, BUILTIN_BENCHMARKS, } from './performance/BenchmarkSuite';
+export type { BenchmarkScenario, BenchmarkTimings, BenchmarkMemory, BenchmarkResult as BenchmarkScenarioResult, BenchmarkReport, RegressionResult, } from './performance/BenchmarkSuite';

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

@@ -0,0 +1,34 @@
+/**
+ * GamepadNavigationContext — React context for UI-level spatial
+ * gamepad/keyboard navigation (focus management, focus traps, game-mode lock).
+ *
+ * For in-game input, use InputManager from `./input`.
+ * This context is for navigating UI elements (menus, buttons, selects)
+ * with a gamepad d-pad or analog stick.
+ */
+import React, { type ReactNode } from "react";
+export interface FocusableMeta {
+    id: string;
+    ref: React.RefObject<HTMLElement>;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    isDropdown?: boolean;
+}
+export interface GamepadNavigationContextType {
+    register: (meta: FocusableMeta) => void;
+    unregister: (id: string) => void;
+    moveFocus: (dx: number, dy: number) => void;
+    setActive: (id: string) => void;
+    activeId: string | null;
+    focusables: FocusableMeta[];
+    pushFocusTrap: (prefix: string, onDismiss?: () => void) => void;
+    popFocusTrap: () => void;
+    enterGameMode: () => void;
+    exitGameMode: () => void;
+}
+export declare function GamepadNavigationProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useGamepadNavigation(): GamepadNavigationContextType;

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

@@ -0,0 +1,77 @@
+import type { Vec2 } from '../core/types';
+import { EventBus } from '../core/EventBus';
+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 {
+    pressed: boolean;
+    justPressed: boolean;
+    justReleased: boolean;
+    value: number;
+}
+export interface ActionBinding {
+    /** Keyboard keys */
+    keys?: string[];
+    /** Gamepad buttons */
+    gamepadButtons?: GamepadButton[];
+    /** Gamepad axis + direction */
+    gamepadAxis?: {
+        axis: GamepadAxis;
+        direction: 'positive' | 'negative';
+    };
+    /** Mouse buttons (0=left, 1=middle, 2=right) */
+    mouseButtons?: number[];
+}
+export interface InputPreset {
+    name: string;
+    actions: Record<string, ActionBinding>;
+}
+export declare class InputManager {
+    deadzone: number;
+    readonly events: EventBus;
+    private _deadzone;
+    private _actions;
+    private _keys;
+    private _keysJustPressed;
+    private _keysJustReleased;
+    private _mousePos;
+    private _mouseButtons;
+    private _mouseButtonsJustPressed;
+    private _mouseButtonsJustReleased;
+    private _mouseWheel;
+    private _gamepads;
+    private _touches;
+    private _cleanup;
+    constructor(deadzone?: number);
+    /**
+     * Attach DOM event listeners. Call once when engine starts.
+     * Pass the target element (usually the canvas container).
+     */
+    attach(target?: HTMLElement | Window): void;
+    detach(): void;
+    /** Define an action binding. */
+    defineAction(name: string, binding: ActionBinding): void;
+    /** Define multiple action bindings at once. */
+    defineActions(actions: Record<string, ActionBinding>): void;
+    /** Load a preset (e.g. platformer, fps, rpg). */
+    loadPreset(preset: InputPreset): void;
+    /** Query an action state for a specific player. */
+    getAction(name: string, playerIndex?: number): ActionState;
+    isKeyDown(code: string): boolean;
+    isKeyJustPressed(code: string): boolean;
+    get mousePosition(): Vec2;
+    get mouseWheelDelta(): number;
+    isMouseDown(button?: number): boolean;
+    getGamepadAxis(playerIndex: number, axis: GamepadAxis): number;
+    getGamepadButton(playerIndex: number, button: GamepadButton): boolean;
+    isGamepadConnected(index: number): boolean;
+    get connectedGamepads(): number;
+    /** Vibrate a gamepad. */
+    vibrate(playerIndex: number, duration: number, weak?: number, strong?: number): void;
+    update(): void;
+    /** Clear frame-edge states. Call AFTER game logic. */
+    lateUpdate(): void;
+    private pollGamepads;
+}
+export declare const PRESET_PLATFORMER: InputPreset;
+export declare const PRESET_TOPDOWN: InputPreset;
+export declare const PRESET_TWIN_STICK: InputPreset;

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

@@ -0,0 +1,3 @@
+export { InputManager, PRESET_PLATFORMER, PRESET_TOPDOWN, PRESET_TWIN_STICK, type GamepadButton, type GamepadAxis, type ActionState, type ActionBinding, type InputPreset, } from './InputManager';
+export { GamepadNavigationProvider, useGamepadNavigation, type FocusableMeta, type GamepadNavigationContextType, } from './GamepadNavigation';
+export { useGamepads, useGamepadEdges, type GamepadSnapshot, } from './useGamepads';

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

@@ -0,0 +1,39 @@
+/**
+ * useGamepads — polls connected gamepads every frame.
+ * Returns an array of GamepadSnapshot objects (0-8 pads).
+ * Designed for couch mini-games (higher level than InputManager).
+ */
+export interface GamepadSnapshot {
+    index: number;
+    up: boolean;
+    down: boolean;
+    left: boolean;
+    right: boolean;
+    dpUp: boolean;
+    dpDown: boolean;
+    dpLeft: boolean;
+    dpRight: boolean;
+    lx: number;
+    ly: number;
+    rx: number;
+    ry: number;
+    a: boolean;
+    b: boolean;
+    x: boolean;
+    y: boolean;
+    lb: boolean;
+    rb: boolean;
+    lt: boolean;
+    rt: boolean;
+    start: boolean;
+    select: boolean;
+}
+export declare function useGamepads(): GamepadSnapshot[];
+/**
+ * useGamepadEdges — returns snapshots + edge detection (justPressed).
+ * Compares current frame to previous frame for each button.
+ */
+export declare function useGamepadEdges(): {
+    pads: GamepadSnapshot[];
+    justPressed: (padIndex: number, button: keyof GamepadSnapshot) => boolean;
+};

package/dist/types/kids/KidMode.d.ts

@@ -0,0 +1,207 @@
+import type { Locale } from '../i18n/I18n';
+/** Age group brackets */
+export type AgeGroup = '6-8' | '9-11' | '12-14' | '15+';
+/** Kid-mode difficulty presets */
+export type KidDifficulty = 'explorer' | 'creator' | 'inventor' | 'master';
+/** Visual block categories (Scratch-inspired) */
+export type BlockCategory = 'motion' | 'looks' | 'events' | 'control' | 'sensing' | 'operators' | 'variables' | 'sounds';
+/** A visual programming block */
+export interface VisualBlock {
+    id: string;
+    category: BlockCategory;
+    /** Emoji icon for the block */
+    emoji: string;
+    /** Block label per locale */
+    label: Partial<Record<Locale, string>>;
+    /** Description per locale */
+    description: Partial<Record<Locale, string>>;
+    /** Parameters this block accepts */
+    params: BlockParam[];
+    /** What this block generates (engine code concept) */
+    generatesAction: string;
+    /** Minimum age group */
+    minAge: AgeGroup;
+}
+/** Parameter on a visual block */
+export interface BlockParam {
+    name: string;
+    type: 'number' | 'string' | 'dropdown' | 'color' | 'entity' | 'boolean';
+    /** Label per locale */
+    label: Partial<Record<Locale, string>>;
+    defaultValue: string | number | boolean;
+    /** For dropdown: available options */
+    options?: Array<{
+        value: string;
+        label: Partial<Record<Locale, string>>;
+    }>;
+    /** Min/max for number params */
+    min?: number;
+    max?: number;
+}
+/** Sprite library item for kids */
+export interface KidSprite {
+    id: string;
+    name: Partial<Record<Locale, string>>;
+    /** Category for browsing */
+    category: 'animals' | 'people' | 'vehicles' | 'nature' | 'food' | 'fantasy' | 'space' | 'sports' | 'buildings' | 'effects';
+    /** Emoji preview */
+    emoji: string;
+    /** Asset URL pattern */
+    assetPath: string;
+    /** Number of animation frames */
+    frameCount: number;
+    /** Safe for all ages */
+    ageAppropriate: AgeGroup;
+    /** Tags for search */
+    tags: string[];
+}
+/** Gamification badge */
+export interface KidBadge {
+    id: string;
+    emoji: string;
+    name: Partial<Record<Locale, string>>;
+    description: Partial<Record<Locale, string>>;
+    /** Condition to earn */
+    condition: BadgeCondition;
+}
+export type BadgeCondition = {
+    type: 'tutorials_completed';
+    count: number;
+} | {
+    type: 'games_created';
+    count: number;
+} | {
+    type: 'blocks_used';
+    count: number;
+} | {
+    type: 'days_active';
+    count: number;
+} | {
+    type: 'quiz_score';
+    minPercent: number;
+} | {
+    type: 'custom';
+    id: string;
+};
+/** Kid profile / progress */
+export interface KidProfile {
+    name: string;
+    avatarEmoji: string;
+    ageGroup: AgeGroup;
+    locale: Locale;
+    stars: number;
+    streak: number;
+    lastActiveDate: string;
+    earnedBadges: string[];
+    completedTutorials: string[];
+    createdProjects: string[];
+    totalBlocksUsed: number;
+    totalPlayTime: number;
+}
+/** Parent dashboard settings */
+export interface ParentConfig {
+    /** Maximum play time per day (minutes). 0 = unlimited */
+    dailyTimeLimitMinutes: number;
+    /** Allow sharing creations online */
+    allowSharing: boolean;
+    /** Content filter level */
+    contentFilter: 'strict' | 'moderate' | 'off';
+    /** Enable chat in classroom mode */
+    allowChat: boolean;
+    /** Required password for settings access */
+    settingsPin: string;
+    /** Allowed categories for sprites */
+    allowedSpriteCategories: KidSprite['category'][];
+    /** Enable sound effects */
+    enableSounds: boolean;
+}
+/** Classroom mode config */
+export interface ClassroomConfig {
+    /** Class name */
+    className: string;
+    /** Teacher name */
+    teacherName: string;
+    /** Students in the class */
+    students: KidProfile[];
+    /** Currently assigned tutorial */
+    currentAssignment?: string;
+    /** Due date for assignment */
+    dueDate?: string;
+    /** Show leaderboard */
+    showLeaderboard: boolean;
+    /** Allow peer collaboration */
+    allowCollaboration: boolean;
+}
+export interface KidModeConfig {
+    enabled: boolean;
+    ageGroup: AgeGroup;
+    parentConfig: ParentConfig;
+    classroom?: ClassroomConfig;
+}
+export declare const DEFAULT_KID_MODE_CONFIG: KidModeConfig;
+export declare class KidModeManager {
+    private config;
+    private profile;
+    private sessionStartTime;
+    private sessionPlayTime;
+    private readonly storageKey;
+    constructor(config?: Partial<KidModeConfig>);
+    isEnabled(): boolean;
+    enable(ageGroup?: AgeGroup): void;
+    disable(): void;
+    getAgeGroup(): AgeGroup;
+    setAgeGroup(age: AgeGroup): void;
+    getProfile(): KidProfile | null;
+    createProfile(name: string, avatarEmoji: string, ageGroup: AgeGroup, locale: Locale): KidProfile;
+    /** Award stars (gamification) */
+    awardStars(count: number): number;
+    /** Check and update streak */
+    updateStreak(): number;
+    /** Mark tutorial as completed, award stars */
+    completeTutorial(tutorialId: string): number;
+    /** Check if a badge is earned */
+    checkBadge(badge: KidBadge): boolean;
+    /** Get remaining play time in minutes. -1 = unlimited. */
+    getRemainingTime(): number;
+    /** Check if time limit is exceeded */
+    isTimeLimitExceeded(): boolean;
+    /** Check if a sprite is appropriate for current settings */
+    isSpriteAllowed(sprite: KidSprite): boolean;
+    /** Filter blocks by age group */
+    getAvailableBlocks(allBlocks: VisualBlock[]): VisualBlock[];
+    /** Map kid difficulty to engine concepts */
+    getDifficultySettings(difficulty: KidDifficulty): KidDifficultySettings;
+    getParentConfig(): ParentConfig;
+    updateParentConfig(updates: Partial<ParentConfig>): void;
+    getClassroom(): ClassroomConfig | undefined;
+    setClassroom(classroom: ClassroomConfig): void;
+    /** Get leaderboard sorted by stars */
+    getLeaderboard(): Array<{
+        name: string;
+        emoji: string;
+        stars: number;
+    }>;
+    private saveProfile;
+    private loadProfile;
+    dispose(): void;
+}
+export interface KidDifficultySettings {
+    label: Partial<Record<Locale, string>>;
+    emoji: string;
+    /** Which block categories are available */
+    enabledCategories: BlockCategory[];
+    /** Max entities in scene */
+    maxEntities: number;
+    /** Show code view (advanced toggle) */
+    showCodeView: boolean;
+    /** Show property inspector */
+    showInspector: boolean;
+    /** Enable physics */
+    enablePhysics: boolean;
+    /** Enable scripting */
+    enableScripting: boolean;
+}
+export declare const KID_DIFFICULTY_PRESETS: Record<KidDifficulty, KidDifficultySettings>;
+export declare const VISUAL_BLOCKS: VisualBlock[];
+export declare const KID_BADGES: KidBadge[];
+export declare const KID_SPRITES: KidSprite[];

package/dist/types/kids/KidTools.d.ts

@@ -0,0 +1,135 @@
+import { EventBus } from '../core/EventBus';
+import type { Locale } from '../i18n/I18n';
+export interface WizardChoice {
+    id: string;
+    /** Emoji icon shown to the child. */
+    icon: string;
+    /** Localized label. */
+    label: Record<string, string>;
+    /** Localized description (shown on hover / under the button). */
+    description: Record<string, string>;
+    /** Where this choice leads: 'template' applies a game template, 'wizard-step' goes to another step. */
+    action: 'template' | 'wizard-step' | 'tutorial' | 'open-project';
+    /** For 'template': template ID to apply. */
+    templateId?: string;
+    /** For 'wizard-step': next step ID. */
+    nextStepId?: string;
+    /** For 'tutorial': tutorial ID. */
+    tutorialId?: string;
+    /** Age group filter (show only for this age range). */
+    minAge?: number;
+    maxAge?: number;
+}
+export interface WizardStep {
+    id: string;
+    /** Localized question/prompt. */
+    question: Record<string, string>;
+    /** Available choices. */
+    choices: WizardChoice[];
+    /** Whether to show a "back" button. */
+    showBack?: boolean;
+}
+export interface WizardResult {
+    /** All choices made, in order. */
+    choicePath: string[];
+    /** Final action. */
+    finalAction: 'template' | 'tutorial' | 'open-project';
+    /** Template ID (if applicable). */
+    templateId?: string;
+    /** Tutorial ID (if applicable). */
+    tutorialId?: string;
+}
+export declare class GuidedWizard {
+    readonly events: EventBus;
+    private steps;
+    private startStepId;
+    private currentStepId;
+    private choicePath;
+    private locale;
+    constructor(locale?: Locale);
+    /** Set display locale. */
+    setLocale(locale: Locale): void;
+    /** Get the current step. */
+    getCurrentStep(): WizardStep | undefined;
+    /** Get choices for the current step, filtered by age. */
+    getChoices(playerAge?: number): WizardChoice[];
+    /** Select a choice. Returns a WizardResult if the wizard is complete, null otherwise. */
+    select(choiceId: string): WizardResult | null;
+    /** Go back to the previous step. */
+    back(): void;
+    /** Reset wizard to initial state. */
+    reset(): void;
+    /** Register a custom wizard step. */
+    registerStep(step: WizardStep): void;
+    /** Get the localized question for the current step. */
+    getQuestion(): string;
+}
+export type BlockShape = 'statement' | 'expression' | 'condition' | 'event' | 'loop';
+export interface DragBlock {
+    id: string;
+    /** The visual block this represents (from KidMode.VISUAL_BLOCKS). */
+    blockType: string;
+    /** Instance values (filled in by the child). */
+    values: Record<string, string | number | boolean>;
+    /** Position on the canvas. */
+    x: number;
+    y: number;
+    /** Connected blocks (snap below). */
+    nextBlockId?: string;
+    /** For conditions/loops: inner blocks. */
+    innerBlockId?: string;
+    /** Parent block that contains this one. */
+    parentBlockId?: string;
+}
+export interface BlockPalette {
+    category: string;
+    icon: string;
+    label: Record<string, string>;
+    blocks: string[];
+}
+export interface DragDropState {
+    /** All blocks on the canvas. */
+    blocks: Map<string, DragBlock>;
+    /** Currently dragged block ID (or null). */
+    dragging: string | null;
+    /** Snap preview target (if hovering near a snap point). */
+    snapPreview: {
+        targetBlockId: string;
+        position: 'below' | 'inside';
+    } | null;
+    /** Currently selected block (for value editing). */
+    selected: string | null;
+}
+export declare class BlockEditor {
+    readonly events: EventBus;
+    private state;
+    private nextBlockId;
+    private snapDistance;
+    /** Add a new block to the canvas at position (x, y). */
+    addBlock(blockType: string, x: number, y: number, values?: Record<string, string | number | boolean>): string;
+    /** Remove a block (and unsnap from neighbors). */
+    removeBlock(id: string): void;
+    /** Start dragging a block. */
+    startDrag(id: string): void;
+    /** Move the dragged block. */
+    moveDrag(x: number, y: number): void;
+    /** End dragging — snap if near a target. */
+    endDrag(): void;
+    /** Select a block for value editing. */
+    selectBlock(id: string): void;
+    /** Update a block's value. */
+    setBlockValue(id: string, key: string, value: string | number | boolean): void;
+    /** Get all blocks. */
+    getAllBlocks(): DragBlock[];
+    /** Get the block chain starting from a root block. */
+    getChain(startId: string): DragBlock[];
+    /** Get all root blocks (blocks with no parent). */
+    getRootBlocks(): DragBlock[];
+    /** Convert the block program to a simple code representation. */
+    toCode(startId: string, indent?: number): string;
+    /** Clear all blocks. */
+    clear(): void;
+    private findSnapTarget;
+    private snapBlock;
+}
+export declare const KID_BLOCK_PALETTES: BlockPalette[];

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

@@ -0,0 +1,2 @@
+export * from './KidMode';
+export * from './KidTools';