refactor: 代码规范化与依赖清理 (#317)

* refactor(deps): 统一编辑器包依赖配置 & 优化分层架构

- 将 ecs-engine-bindgen 提升为 Layer 1 核心包
- 统一 9 个编辑器包的依赖声明模式
- 清理废弃的包目录 (ui, ui-editor, network-*)

* refactor(tokens): 修复 PrefabService 令牌冲突 & 补充 module.json

- 将 editor-core 的 PrefabServiceToken 改名为 EditorPrefabServiceToken
  避免与 asset-system 的 PrefabServiceToken 冲突 (Symbol.for 冲突)
- 为 mesh-3d 添加 module.json
- 为 world-streaming 添加 module.json

* refactor(editor-core): 整理导出结构 & 添加 blueprint tokens.ts

- 按功能分组整理 editor-core 的 65 行导出
- 添加清晰的分组注释 (中英双语)
- 为 blueprint 添加占位符 tokens.ts

* chore(editor): 为 14 个编辑器插件包添加 module.json

统一编辑器包的模块配置，包含：
- isEditorPlugin 标识
- runtimeModule 关联
- exports 导出清单 (inspectors, panels, gizmos)

* refactor(core): 改进类型安全 - 减少 as any 使用

- 添加 GlobalTypes.ts 定义小游戏平台和 Chrome API 类型
- SoAStorage 使用 IComponentTypeMetadata 替代 as any
- PlatformDetector 使用类型安全的平台检测
- 添加 ISoAStorageStats/ISoAFieldStats 接口

* feat(editor): 添加 EditorServicesContext 解决 prop drilling

- 新增 contexts/EditorServicesContext.tsx 提供统一服务访问
- App.tsx 包裹 EditorServicesProvider
- 提供 useEditorServices/useMessageHub 等便捷 hooks
- SceneHierarchy 添加迁移注释，后续可移除 props

* docs(editor): 澄清 inspector 目录架构关系

- inspector/ 标记为内部实现，添加 @deprecated 警告
- inspectors/ 标记为公共 API 入口点
- 添加架构说明文档

* refactor(editor): 添加全局类型声明消除 window as any

- 创建 editor-app/src/global.d.ts 声明 Window 接口扩展
- 创建 editor-core/src/global.d.ts 声明 Window 接口扩展
- 更新 App.tsx 使用类型安全的 window 属性访问
- 更新 PluginLoader.ts 使用 window.__ESENGINE_PLUGINS__
- 更新 PluginSDKRegistry.ts 使用 window.__ESENGINE_SDK__
- 更新 UserCodeService.ts 使用类型安全的全局变量访问

* refactor(editor): 提取项目和场景操作到独立 hooks

- 创建 useProjectActions hook 封装项目操作
- 创建 useSceneActions hook 封装场景操作
- 为渐进式重构 App.tsx 做准备

* refactor(editor): 清理冗余代码和未使用文件

删除的目录和文件：
- application/state/ - 重复的状态管理（与 stores/ 重复）
- 8 个孤立 CSS 文件（对应组件不存在）
- AssetBrowser.tsx - 仅为 ContentBrowser 的向后兼容包装
- AssetPicker.tsx - 未被使用
- AssetPickerDialog.tsx (顶级) - 已被 dialogs/ 版本取代
- EntityInspector.tsx (顶级) - 已被 inspectors/views/ 版本取代

修复：
- 移除 App.tsx 中未使用的导入
- 更新 application/index.ts 移除已删除模块
- 修复 useProjectActions.ts 的 MutableRefObject 类型

* refactor(editor): 统一 inspectors 模块导出结构

- 在 inspectors/index.ts 重新导出 PropertyInspector
- 创建 inspectors/fields/index.ts barrel export
- 导出 views、fields、common 子模块
- 更新 EntityInspector 使用统一入口导入

* refactor(editor): 删除废弃的 Profiler 组件

删除未使用的组件（共 1059 行）：
- ProfilerPanel.tsx (229 行)
- ProfilerWindow.tsx (589 行)
- ProfilerDockPanel.tsx (241 行)
- ProfilerPanel.css
- ProfilerDockPanel.css

保留：AdvancedProfiler + AdvancedProfilerWindow（正在使用）

* refactor(runtime-core): 统一依赖处理与插件状态管理

- 新增 DependencyUtils 统一拓扑排序和依赖验证
- 新增 PluginState 定义插件生命周期状态机
- 合并 UnifiedPluginLoader 到 PluginLoader
- 清理 index.ts 移除不必要的 Token re-exports
- 新增 RuntimeMode/UserCodeRealm/ImportMapGenerator

* refactor(editor-core): 使用统一的 ImportMapGenerator

- WebBuildPipeline 使用 runtime-core 的 generateImportMap
- UserCodeService 添加 ImportMap 相关接口

* feat(compiler): 增强 esbuild 查找策略

- 支持本地 node_modules、pnpm exec、npx、全局多种来源
- EngineService 使用 RuntimeMode

* refactor(runtime-core): 简化 GameRuntime 代码

- 合并 _disableGameLogicSystems/_enableGameLogicSystems 为 _setGameLogicSystemsEnabled
- 精简本地 Token 定义的注释

* refactor(editor-core): 引入 BaseRegistry 基类消除代码重复

- 新增 BaseRegistry 和 PrioritizedRegistry 基类
- 重构 CompilerRegistry, InspectorRegistry, FieldEditorRegistry
- 统一注册表的日志记录和错误处理

* refactor(editor-core): 扩展 BaseRegistry 重构

- ComponentInspectorRegistry 继承 PrioritizedRegistry
- EditorComponentRegistry 继承 BaseRegistry
- EntityCreationRegistry 继承 BaseRegistry
- PropertyRendererRegistry 继承 PrioritizedRegistry
- 导出 BaseRegistry 基类供外部使用
- 统一双语注释格式

* refactor(editor-core): 代码优雅性优化

CommandManager:
- 提取 tryMergeWithLast() 和 pushToUndoStack() 消除重复代码
- 统一双语注释格式

FileActionRegistry:
- 提取 normalizeExtension() 消除扩展名规范化重复
- 统一私有属性命名风格（_前缀）
- 使用 createRegistryToken 统一 Token 创建

BaseRegistry:
- 添加 IOrdered 接口
- 添加 sortByOrder() 排序辅助方法

EntityCreationRegistry:
- 使用 sortByOrder() 简化排序逻辑

* refactor(editor-core): 统一日志系统 & 代码规范优化

- GizmoRegistry: 使用 createLogger 替代 console.warn
- VirtualNodeRegistry: 使用 createLogger 替代 console.warn
- WindowRegistry: 使用 logger、添加 _ 前缀、导出 IWindowRegistry token
- EditorViewportService: 使用 createLogger 替代 console.warn
- ComponentActionRegistry: 使用 logger、添加 _ 前缀、返回值改进
- SettingsRegistry: 使用 logger、提取 ensureCategory/ensureSection 方法
- 添加 WindowRegistry 到主导出

* refactor(editor-core): ModuleRegistry 使用 logger 替代 console

* refactor(editor-core): SerializerRegistry/UIRegistry 添加 token 和 _ 前缀

* refactor(editor-core): UIRegistry 代码优雅性 & Token 命名统一

- UIRegistry: 提取 _sortByOrder 消除 6 处重复排序逻辑
- UIRegistry: 添加分节注释和双语文档
- FieldEditorRegistry: Token 重命名为 FieldEditorRegistryToken
- PropertyRendererRegistry: Token 重命名为 PropertyRendererRegistryToken

* refactor(core): 统一日志系统 - console 替换为 logger

- ComponentSerializer: 使用 logger 替代 console.warn
- ComponentRegistry: console.warn → logger.warn (已有 logger)
- SceneSerializer: 添加 logger，替换 console.warn/error
- SystemScheduler: 添加 logger，替换 console.warn
- VersionMigration: 添加 logger，替换所有 console.warn
- RuntimeModeService: console.error → logger.error
- Core.ts: _logger 改为 readonly，双语错误消息
- SceneSerializer 修复：使用 getComponentTypeName 替代 constructor.name

* fix(core): 修复 constructor.name 压缩后失效问题

- Scene.ts: 使用 system.systemName 替代 system.constructor.name
- CommandBuffer.ts: 使用 getComponentTypeName() 替代 constructor.name

* refactor(editor-core): 代码规范优化 - 私有方法命名 & 日志统一

- BuildService: console → logger
- FileActionRegistry: 添加 logger, 私有方法 _ 前缀
- SettingsRegistry: 私有方法 _ 前缀 (ensureCategory → _ensureCategory)

* refactor(core): Scene.ts 私有变量命名规范化

- logger → _logger (遵循私有变量 _ 前缀规范)

* refactor(editor-core): 服务类私有成员命名规范化

- CommandManager: 私有变量/方法添加 _ 前缀
  - undoStack/redoStack/config/isExecuting
  - tryMergeWithLast/pushToUndoStack
- LocaleService: 私有变量/方法添加 _ 前缀
  - currentLocale/translations/changeListeners
  - deepMerge/getNestedValue/loadSavedLocale/saveLocale

* refactor(core): 私有成员命名规范化 & 单例模式优化

- Component.ts: _idGenerator 私有静态变量规范化
- PlatformManager.ts: _instance, _adapter, _logger 规范化
- AutoProfiler.ts: _instance, _config 及所有私有方法规范化
- ProfilerSDK.ts: _instance, _config 及所有私有方法规范化
- ComponentPoolManager: _instance, _pools, _usageTracker 规范化
- GlobalEventBus: _instance 规范化
- 添加中英双语 JSDoc 注释

* refactor(editor-app,behavior-tree-editor): 私有成员 & 单例模式命名规范化

editor-app:
- EngineService: private static instance → _instance
- EditorEngineSync: 所有私有成员添加 _ 前缀
- RuntimeResolver: 所有私有成员和方法添加 _ 前缀
- SettingsService: 所有私有成员和方法添加 _ 前缀

behavior-tree-editor:
- GlobalBlackboardService: 所有私有成员和方法添加 _ 前缀
- NotificationService: private static instance → _instance
- NodeRegistryService: 所有私有成员和方法添加 _ 前缀
- TreeStateAdapter: private static instance → _instance

* fix(editor-runtime): 添加 editor-core 到 external 避免传递依赖问题

将 @esengine/editor-core 添加到 vite external 配置，
避免 editor-core → runtime-core → ecs-engine-bindgen 的传递依赖
被错误地打包进 editor-runtime.js，导致 CI 构建失败。

* fix(core): 修复空接口 lint 错误

将 IByteDanceMiniGameAPI、IAlipayMiniGameAPI、IBaiduMiniGameAPI 从空接口改为类型别名，修复 no-empty-object-type 规则报错

packages/runtime-core/src/GameRuntime.ts

@@ -29,19 +29,10 @@ import {
 import { AssetManager, EngineIntegration, AssetManagerToken, setGlobalAssetDatabase } from '@esengine/asset-system';
 
 // ============================================================================
-// 本地服务令牌定义 | Local Service Token Definitions
+// 本地服务令牌（松耦合设计）| Local Service Tokens (Loose Coupling)
 // ============================================================================
-// 这些令牌使用 createServiceToken() 本地定义，而不是从源模块导入。
-// 这是有意为之：
-// 1. runtime-core 应保持与 ui/sprite/behavior-tree 等模块的松耦合
-// 2. createServiceToken() 使用 Symbol.for()，确保相同名称在运行时匹配
-// 3. 本地接口提供类型安全，无需引入模块依赖
-//
-// These tokens are defined locally using createServiceToken() instead of
-// importing from source modules. This is intentional:
-// 1. runtime-core should remain loosely coupled to ui/sprite/behavior-tree etc.
-// 2. createServiceToken() uses Symbol.for(), ensuring same names match at runtime
-// 3. Local interfaces provide type safety without introducing module dependencies
+// 使用 Symbol.for() 确保与源模块的 Token 在运行时匹配
+// Uses Symbol.for() to match source module tokens at runtime
 // ============================================================================
 
 /**
@@ -97,16 +88,23 @@ import {
     type IRuntimeModule
 } from './PluginManager';
 import {
-    loadEnabledPlugins,
-    type PluginPackageInfo,
-    type ProjectPluginConfig
+    PluginLoader,
+    type PluginLoadConfig
 } from './PluginLoader';
 import {
     BUILTIN_PLUGIN_PACKAGES,
     mergeProjectConfig,
+    convertToPluginLoadConfigs,
     type ProjectConfig
 } from './ProjectConfig';
 import type { IPlatformAdapter, PlatformAdapterConfig } from './IPlatformAdapter';
+import {
+    RuntimeMode,
+    getRuntimeModeConfig,
+    isEditorMode as checkIsEditorMode,
+    shouldEnableGameLogic,
+    type RuntimeModeConfig
+} from './RuntimeMode';
 
 /**
  * 运行时配置
@@ -143,6 +141,7 @@ export interface RuntimeState {
     initialized: boolean;
     running: boolean;
     paused: boolean;
+    mode: RuntimeMode;
 }
 
 /**
@@ -166,7 +165,8 @@ export class GameRuntime {
     private _state: RuntimeState = {
         initialized: false,
         running: false,
-        paused: false
+        paused: false,
+        mode: RuntimeMode.EditorStatic
     };
 
     private _animationFrameId: number | null = null;
@@ -196,6 +196,14 @@ export class GameRuntime {
         return { ...this._state };
     }
 
+    /**
+     * @zh 获取当前运行模式
+     * @en Get current runtime mode
+     */
+    get mode(): RuntimeMode {
+        return this._state.mode;
+    }
+
     /**
      * 获取场景
      */
@@ -253,6 +261,95 @@ export class GameRuntime {
         return this._platform;
     }
 
+    /**
+     * @zh 设置运行模式
+     * @en Set runtime mode
+     *
+     * @zh 根据模式自动配置系统启用状态、UI 显示等
+     * @en Automatically configures system enabling, UI visibility, etc. based on mode
+     *
+     * @param mode - @zh 目标模式 @en Target mode
+     * @param options - @zh 可选覆盖配置 @en Optional override configuration
+     */
+    setMode(mode: RuntimeMode, options?: Partial<RuntimeModeConfig>): void {
+        if (!this._state.initialized) {
+            console.warn('[GameRuntime] Cannot set mode before initialization');
+            return;
+        }
+
+        const previousMode = this._state.mode;
+        this._state.mode = mode;
+
+        // 获取模式配置并应用覆盖
+        const config = { ...getRuntimeModeConfig(mode), ...options };
+
+        console.log(`[GameRuntime] Mode: ${previousMode} → ${mode}`);
+
+        // 1. 配置场景编辑器模式
+        if (this._scene) {
+            this._scene.isEditorMode = !config.triggerLifecycle;
+        }
+
+        // 2. 配置渲染系统
+        if (this._renderSystem) {
+            this._renderSystem.setPreviewMode(mode !== RuntimeMode.EditorStatic);
+            this._renderSystem.setShowGizmos(config.showGizmos);
+        }
+
+        // 3. 配置引擎桥接
+        if (this._bridge) {
+            this._bridge.setShowGrid(config.showGrid);
+            this._bridge.setEditorMode(config.isEditorEnvironment);
+        }
+
+        // 4. 配置输入系统
+        if (this._inputSystem) {
+            this._inputSystem.enabled = config.enableInput;
+        }
+
+        // 5. 配置游戏逻辑系统
+        this._applySystemConfig(config);
+
+        // 6. 触发生命周期（从静态模式进入其他模式时）
+        if (previousMode === RuntimeMode.EditorStatic && config.triggerLifecycle) {
+            this._scene?.begin();
+        }
+
+        // 7. 更新运行状态
+        this._state.running = shouldEnableGameLogic(mode);
+        this._state.paused = false;
+    }
+
+    /**
+     * @zh 应用系统配置
+     * @en Apply system configuration
+     */
+    private _applySystemConfig(config: RuntimeModeConfig): void {
+        const services = this._systemContext?.services;
+        if (!services) return;
+
+        // 物理系统
+        const physicsSystem = services.get(Physics2DSystemToken);
+        if (physicsSystem) {
+            physicsSystem.enabled = config.enablePhysics;
+        }
+
+        // 行为树系统
+        const behaviorTreeSystem = services.get(BehaviorTreeSystemToken);
+        if (behaviorTreeSystem) {
+            behaviorTreeSystem.enabled = config.enableBehaviorTree;
+            if (config.enableBehaviorTree) {
+                behaviorTreeSystem.startAllAutoStartTrees?.();
+            }
+        }
+
+        // 动画系统
+        const animatorSystem = services.get(SpriteAnimatorSystemToken);
+        if (animatorSystem) {
+            animatorSystem.enabled = config.enableAnimation;
+        }
+    }
+
     /**
      * 初始化运行时
      * Initialize runtime
@@ -395,14 +492,18 @@ export class GameRuntime {
                 defaultWorld.start();
             }
 
-            // 14. 编辑器模式下的特殊处理
-            if (this._platform.isEditorMode()) {
-                // 禁用游戏逻辑系统
-                this._disableGameLogicSystems();
-            }
-
             this._state.initialized = true;
 
+            // 14. 设置初始模式
+            const initialMode = this._platform.isEditorMode()
+                ? RuntimeMode.EditorStatic
+                : RuntimeMode.Standalone;
+            this._state.mode = initialMode;
+
+            // 应用初始模式配置（不触发 setMode 的完整流程，因为刚初始化）
+            const modeConfig = getRuntimeModeConfig(initialMode);
+            this._applySystemConfig(modeConfig);
+
             // 15. 自动启动渲染循环
             if (this._config.autoStartRenderLoop !== false) {
                 this._startRenderLoop();
@@ -414,72 +515,53 @@ export class GameRuntime {
     }
 
     /**
-     * 加载并初始化插件
+     * @zh 加载并初始化插件
+     * @en Load and initialize plugins
      */
     private async _initializePlugins(): Promise<void> {
-        // 检查是否已有插件注册（静态导入场景）
-        // Check if plugins are already registered (static import scenario)
         const hasPlugins = runtimePluginManager.getPlugins().length > 0;
 
         if (!hasPlugins) {
-            // 没有预注册的插件，尝试动态加载
-            // No pre-registered plugins, try dynamic loading
-            await loadEnabledPlugins(
-                { plugins: this._projectConfig.plugins },
-                BUILTIN_PLUGIN_PACKAGES
-            );
+            const configs = convertToPluginLoadConfigs(this._projectConfig, BUILTIN_PLUGIN_PACKAGES);
+            const loader = new PluginLoader({ plugins: configs });
+
+            await loader.loadAll();
+
+            const loaded = loader.getLoaded();
+            const failed = loader.getFailed();
+
+            if (loaded.length > 0) {
+                console.log(`[GameRuntime] Loaded: ${loaded.map(p => p.packageId).join(', ')}`);
+            }
+            if (failed.length > 0) {
+                for (const p of failed) {
+                    console.warn(`[GameRuntime] Failed: ${p.packageId} - ${p.error}`);
+                }
+            }
         }
 
-        // 初始化插件（注册组件和服务）
         await runtimePluginManager.initializeRuntime(Core.services);
     }
 
     /**
-     * 禁用游戏逻辑系统（编辑器模式）
+     * @zh 设置游戏逻辑系统启用状态
+     * @en Set game logic systems enabled state
      */
-    private _disableGameLogicSystems(): void {
-        const services = this._systemContext?.services;
-        if (!services) return;
-
-        // 这些系统由插件创建，通过服务注册表获取引用
-        const animatorSystem = services.get(SpriteAnimatorSystemToken);
-        if (animatorSystem) {
-            animatorSystem.enabled = false;
-        }
-
-        const behaviorTreeSystem = services.get(BehaviorTreeSystemToken);
-        if (behaviorTreeSystem) {
-            behaviorTreeSystem.enabled = false;
-        }
-
-        const physicsSystem = services.get(Physics2DSystemToken);
-        if (physicsSystem) {
-            physicsSystem.enabled = false;
-        }
-    }
-
-    /**
-     * 启用游戏逻辑系统（预览/运行模式）
-     */
-    private _enableGameLogicSystems(): void {
+    private _setGameLogicSystemsEnabled(enabled: boolean): void {
         const services = this._systemContext?.services;
         if (!services) return;
 
         const animatorSystem = services.get(SpriteAnimatorSystemToken);
-        if (animatorSystem) {
-            animatorSystem.enabled = true;
-        }
+        if (animatorSystem) animatorSystem.enabled = enabled;
 
         const behaviorTreeSystem = services.get(BehaviorTreeSystemToken);
         if (behaviorTreeSystem) {
-            behaviorTreeSystem.enabled = true;
-            behaviorTreeSystem.startAllAutoStartTrees?.();
+            behaviorTreeSystem.enabled = enabled;
+            if (enabled) behaviorTreeSystem.startAllAutoStartTrees?.();
         }
 
         const physicsSystem = services.get(Physics2DSystemToken);
-        if (physicsSystem) {
-            physicsSystem.enabled = true;
-        }
+        if (physicsSystem) physicsSystem.enabled = enabled;
     }
 
     /**
@@ -518,36 +600,23 @@ export class GameRuntime {
     }
 
     /**
-     * 开始运行（启用游戏逻辑）
-     * Start running (enable game logic)
+     * @zh 开始运行（切换到预览模式）
+     * @en Start running (switch to preview mode)
+     *
+     * @zh 在编辑器中，从 EditorStatic 切换到 EditorPreview
+     * @en In editor, switches from EditorStatic to EditorPreview
      */
     start(): void {
         if (!this._state.initialized || this._state.running) {
             return;
         }
 
-        this._state.running = true;
-        this._state.paused = false;
+        // 根据平台选择目标模式
+        const targetMode = this._platform.isEditorMode()
+            ? RuntimeMode.EditorPreview
+            : RuntimeMode.Standalone;
 
-        // 启用预览模式
-        if (this._renderSystem) {
-            this._renderSystem.setPreviewMode(true);
-        }
-
-        // 禁用编辑器模式，启用 InputSystem 和组件生命周期回调
-        // Disable editor mode to enable InputSystem and component lifecycle callbacks
-        if (this._scene) {
-            this._scene.isEditorMode = false;
-        }
-
-        // 调用场景 begin() 触发延迟的组件生命周期回调
-        // Call scene begin() to trigger deferred component lifecycle callbacks
-        if (this._scene) {
-            this._scene.begin();
-        }
-
-        // 启用游戏逻辑系统
-        this._enableGameLogicSystems();
+        this.setMode(targetMode);
 
         // 确保渲染循环在运行
         this._startRenderLoop();
@@ -576,32 +645,23 @@ export class GameRuntime {
     }
 
     /**
-     * 停止运行（禁用游戏逻辑）
-     * Stop running (disable game logic)
+     * @zh 停止运行（切换回静态模式）
+     * @en Stop running (switch back to static mode)
+     *
+     * @zh 在编辑器中，从 EditorPreview 切换回 EditorStatic
+     * @en In editor, switches from EditorPreview back to EditorStatic
      */
     stop(): void {
         if (!this._state.running) {
             return;
         }
 
-        this._state.running = false;
-        this._state.paused = false;
-
-        // 禁用预览模式
-        if (this._renderSystem) {
-            this._renderSystem.setPreviewMode(false);
+        // 在编辑器中切换回静态模式（setMode 会处理系统禁用）
+        if (this._platform.isEditorMode()) {
+            this.setMode(RuntimeMode.EditorStatic);
         }
 
-        // 恢复编辑器模式（如果是编辑器平台）
-        // Restore editor mode (if editor platform)
-        if (this._scene && this._platform.isEditorMode()) {
-            this._scene.isEditorMode = true;
-        }
-
-        // 禁用游戏逻辑系统
-        this._disableGameLogicSystems();
-
-        // 重置物理系统
+        // 重置物理系统状态
         const physicsSystem = this._systemContext?.services.get(Physics2DSystemToken);
         if (physicsSystem) {
             physicsSystem.reset?.();
@@ -618,9 +678,9 @@ export class GameRuntime {
         }
 
         // 启用系统执行一帧
-        this._enableGameLogicSystems();
+        this._setGameLogicSystemsEnabled(true);
         Core.update(1 / 60);
-        this._disableGameLogicSystems();
+        this._setGameLogicSystemsEnabled(false);
     }
 
     /**