@vlian/framework 1.2.37 → 1.2.38

package/dist/index.umd.js

@@ -1,14 +1,33 @@
 /*!
- * @vlian/framework v1.2.36
+ * @vlian/framework v1.2.37
  * Secra Framework - 一个现代化的低代码框架
  * (c) 2026 Secra Framework Contributors
  * Licensed under Apache-2.0
  */
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@vlian/utils'), require('@vlian/monitoring'), require('@vlian/logger'), require('react/jsx-runtime'), require('react-dom/client'), require('react'), require('react-router-dom'), require('zod'), require('i18next'), require('react-i18next'), require('@vlian/request'), require('@vlian/csrf')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@vlian/utils', '@vlian/monitoring', '@vlian/logger', 'react/jsx-runtime', 'react-dom/client', 'react', 'react-router-dom', 'zod', 'i18next', 'react-i18next', '@vlian/request', '@vlian/csrf'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vlianFramework = {}, global.utils, global.monitoring, global.logger, global.jsxRuntime, global.ReactDOMClient, global.React, global.ReactRouterDOM, global.z, global.i18next, global.ReactI18next, global.request, global.csrf));
-})(this, (function (exports, utils, monitoring, logger, jsxRuntime, client, React, reactRouterDom, zod, i18n, reactI18next, request, csrf) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@vlian/utils'), require('@vlian/logger'), require('@vlian/monitoring'), require('react/jsx-runtime'), require('react-dom/client'), require('react'), require('react-router-dom'), require('zod'), require('i18next'), require('react-i18next'), require('@vlian/request'), require('@vlian/csrf')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@vlian/utils', '@vlian/logger', '@vlian/monitoring', 'react/jsx-runtime', 'react-dom/client', 'react', 'react-router-dom', 'zod', 'i18next', 'react-i18next', '@vlian/request', '@vlian/csrf'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vlianFramework = {}, global.vlianUtils, global.logger, global.monitoring, global.jsxRuntime, global.ReactDOMClient, global.React, global.ReactRouterDOM, global.z, global.i18next, global.ReactI18next, global.request, global.csrf));
+})(this, (function (exports, vlianUtils, logger, monitoring, jsxRuntime, client, React, reactRouterDom, zod, i18n, reactI18next, request, csrf) { 'use strict';
+
+    function _interopNamespaceDefault(e) {
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n.default = e;
+        return Object.freeze(n);
+    }
+
+    var vlianUtils__namespace = /*#__PURE__*/_interopNamespaceDefault(vlianUtils);
 
     const local$1 = {
         notfound: {
@@ -359,17 +378,17 @@
             return Storage.instance;
         }
         initialize(options) {
-            const local = utils.createStorage({
+            const local = vlianUtils.createStorage({
                 type: 'local',
                 prefix: options?.prefix || 'vlian',
                 defaultExpire: options?.defaultExpire || 24 * 60 * 60 * 1000
             });
-            const session = utils.createStorage({
+            const session = vlianUtils.createStorage({
                 type: 'session',
                 prefix: options?.prefix || 'vlian',
                 defaultExpire: options?.defaultExpire || 24 * 60 * 60 * 1000
             });
-            const indexedDB = utils.createStorage({
+            const indexedDB = vlianUtils.createStorage({
                 type: 'indexedDB',
                 prefix: options?.prefix || 'vlian',
                 defaultExpire: options?.defaultExpire || 24 * 60 * 60 * 1000,
@@ -417,183 +436,115 @@
     const storage = Storage.getInstance();
 
     /**
-     * 配置安全工具类
-     */ class ConfigSecurity {
+     * 插件沙箱
+     * 用于插件隔离和权限控制
+     */ function _define_property$I(obj, key, value) {
+        if (key in obj) {
+            Object.defineProperty(obj, key, {
+                value: value,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        } else {
+            obj[key] = value;
+        }
+        return obj;
+    }
+    /**
+     * 插件沙箱
+     */ class PluginSandbox {
         /**
-       * 验证配置签名
-       */ static async verifySignature(config, signature, options) {
-            if (!options.enabled) {
-                return true;
-            }
-            if (!options.publicKey) {
-                throw new utils.SecurityError('签名验证需要提供公钥');
-            }
-            if (!signature || signature.length === 0) {
-                throw new utils.SecurityError('签名不能为空');
-            }
-            try {
-                // 使用 Web Crypto API 验证签名
-                if (typeof window === 'undefined' || !window.crypto || !window.crypto.subtle) {
-                    throw new utils.SecurityError('签名验证需要浏览器支持 Web Crypto API');
-                }
-                // 将配置转换为字符串（用于签名验证）
-                // 使用稳定的 JSON 序列化（按键排序）
-                const configString = JSON.stringify(config, Object.keys(config).sort());
-                const encoder = new TextEncoder();
-                const data = encoder.encode(configString);
-                // 将签名从 Base64 解码
-                const signatureBuffer = Uint8Array.from(atob(signature), (c)=>c.charCodeAt(0));
-                // 导入公钥（支持 PEM 格式）
-                const algorithm = options.algorithm || 'RSASSA-PKCS1-v1_5';
-                let publicKey;
-                try {
-                    // 尝试导入 PEM 格式的公钥
-                    const pemHeader = '-----BEGIN PUBLIC KEY-----';
-                    const pemFooter = '-----END PUBLIC KEY-----';
-                    let pemKey = options.publicKey;
-                    if (!pemKey.includes(pemHeader)) {
-                        pemKey = `${pemHeader}\n${pemKey}\n${pemFooter}`;
-                    }
-                    // 将 PEM 转换为 ArrayBuffer
-                    const pemContents = pemKey.replace(pemHeader, '').replace(pemFooter, '').replace(/\s/g, '');
-                    const binaryDer = Uint8Array.from(atob(pemContents), (c)=>c.charCodeAt(0));
-                    publicKey = await window.crypto.subtle.importKey('spki', binaryDer.buffer, {
-                        name: algorithm,
-                        hash: 'SHA-256'
-                    }, false, [
-                        'verify'
-                    ]);
-                } catch (importError) {
-                    throw new utils.SecurityError('公钥导入失败', importError instanceof Error ? importError : undefined);
-                }
-                // 验证签名
-                const isValid = await window.crypto.subtle.verify({
-                    name: algorithm
-                }, publicKey, signatureBuffer, data);
-                return isValid;
-            } catch (error) {
-                if (error instanceof utils.SecurityError) {
-                    throw error;
-                }
-                throw new utils.SecurityError('签名验证失败', error instanceof Error ? error : undefined);
+       * 检查权限
+       * 
+       * @param permission - 权限
+       * @returns 是否有权限
+       */ hasPermission(permission) {
+            if (!this.config.strictMode) {
+                return true; // 非严格模式，允许所有权限
             }
+            return this.permissions.has(permission);
         }
         /**
-       * 验证配置来源
-       */ static verifyOrigin(options) {
-            if (!options.allowedOrigins || options.allowedOrigins.length === 0) {
-                return true; // 如果没有配置白名单，允许所有来源
+       * 检查是否可以访问配置键
+       * 
+       * @param key - 配置键
+       * @returns 是否可以访问
+       */ canAccessConfig(key) {
+            if (!this.hasPermission("access_config")) {
+                return false;
             }
-            if (typeof window === 'undefined') {
-                return true; // 非浏览器环境，跳过验证
+            if (this.config.configWhitelist && this.config.configWhitelist.length > 0) {
+                return this.config.configWhitelist.includes(key);
             }
-            const currentOrigin = window.location.origin;
-            const referer = document.referrer;
-            // 验证当前来源
-            if (options.allowedOrigins.includes(currentOrigin)) {
-                return true;
+            return true;
+        }
+        /**
+       * 检查是否可以访问状态作用域
+       * 
+       * @param scope - 状态作用域
+       * @returns 是否可以访问
+       */ canAccessStateScope(scope) {
+            if (!this.hasPermission("access_state_manager")) {
+                return false;
             }
-            // 验证 Referer
-            if (options.verifyReferer && referer) {
-                try {
-                    const refererOrigin = new URL(referer).origin;
-                    if (options.allowedOrigins.includes(refererOrigin)) {
-                        return true;
-                    }
-                } catch  {
-                // Referer 解析失败
-                }
+            if (this.config.stateScopeWhitelist && this.config.stateScopeWhitelist.length > 0) {
+                return this.config.stateScopeWhitelist.includes(scope);
             }
-            return false;
+            return true;
         }
         /**
-       * 验证配置白名单
-       */ static verifyWhitelist(config, options) {
-            const errors = [];
-            // 检查允许的键
-            if (options.allowedKeys && options.allowedKeys.length > 0) {
-                const configKeys = Object.keys(config);
-                const invalidKeys = configKeys.filter((key)=>!options.allowedKeys.includes(key));
-                if (invalidKeys.length > 0) {
-                    errors.push(`配置包含不允许的键: ${invalidKeys.join(', ')}`);
-                }
+       * 过滤配置（根据白名单）
+       * 
+       * @param config - 完整配置
+       * @returns 过滤后的配置
+       */ filterConfig(config) {
+            if (!this.hasPermission("access_config")) {
+                return {};
             }
-            // 检查禁止的键
-            if (options.forbiddenKeys && options.forbiddenKeys.length > 0) {
-                const configKeys = Object.keys(config);
-                const forbiddenFound = configKeys.filter((key)=>options.forbiddenKeys.includes(key));
-                if (forbiddenFound.length > 0) {
-                    errors.push(`配置包含禁止的键: ${forbiddenFound.join(', ')}`);
-                }
+            if (!this.config.configWhitelist || this.config.configWhitelist.length === 0) {
+                return config;
             }
-            // 验证配置值
-            if (options.valueSchema) {
-                const result = utils.Validator.validateObject(options.valueSchema, config);
-                if (!result.valid) {
-                    errors.push(...result.errors);
+            const filtered = {};
+            for (const key of this.config.configWhitelist){
+                if (key in config) {
+                    filtered[key] = config[key];
                 }
             }
+            return filtered;
+        }
+        /**
+       * 获取沙箱配置
+       */ getConfig() {
             return {
-                valid: errors.length === 0,
-                errors
+                ...this.config
             };
         }
         /**
-       * 清理配置中的危险内容
-       */ static sanitizeConfig(config) {
-            const sanitized = {};
-            for (const [key, value] of Object.entries(config)){
-                if (typeof value === 'string') {
-                    // 检查是否包含危险内容
-                    const validation = utils.SecurityUtils.validateInput(value);
-                    if (validation.safe && validation.sanitized) {
-                        sanitized[key] = validation.sanitized;
-                    } else {
-                        // 包含危险内容，跳过或记录警告
-                        console.warn(`配置项 ${key} 包含潜在危险内容，已跳过`);
-                    }
-                } else if (value && typeof value === 'object' && !Array.isArray(value)) {
-                    // 递归清理对象
-                    sanitized[key] = this.sanitizeConfig(value);
-                } else {
-                    sanitized[key] = value;
-                }
-            }
-            return sanitized;
+       * 更新权限
+       * 
+       * @param permissions - 权限列表
+       */ updatePermissions(permissions) {
+            this.permissions = new Set(permissions);
+            this.config.permissions = permissions;
         }
-        /**
-       * 验证配置安全性
-       */ static async validateConfigSecurity(config, options) {
-            const errors = [];
-            // 验证来源
-            if (options.origin) {
-                const originValid = this.verifyOrigin(options.origin);
-                if (!originValid) {
-                    errors.push('配置来源验证失败');
-                }
-            }
-            // 验证白名单
-            if (options.whitelist) {
-                const whitelistResult = this.verifyWhitelist(config, options.whitelist);
-                if (!whitelistResult.valid) {
-                    errors.push(...whitelistResult.errors);
-                }
-            }
-            // 清理配置（已实现但暂不使用返回值）
-            // const sanitizedConfig = this.sanitizeConfig(config);
-            return {
-                valid: errors.length === 0,
-                errors
+        constructor(config){
+            _define_property$I(this, "config", void 0);
+            _define_property$I(this, "permissions", void 0);
+            this.config = {
+                strictMode: true,
+                ...config
             };
+            this.permissions = new Set(config.permissions || []);
         }
     }
 
-    var runtimeSecurity = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        RuntimeSecurity: RuntimeSecurity
-    });
-
-    function _define_property$I(obj, key, value) {
+    /**
+     * 插件事件总线
+     * 用于插件间通信
+     */ /**
+     * 事件监听器类型
+     */ function _define_property$H(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -607,227 +558,273 @@
         return obj;
     }
     /**
-     * 分析服务类
-     */ class AnalyticsService {
+     * 事件总线
+     */ class PluginEventBus {
         /**
-       * 启动批量上报定时器
-       */ startBatchTimer() {
-            if (this.batchTimer) {
-                return;
-            }
-            this.batchTimer = setInterval(()=>{
-                this.flush();
-            }, this.config.batchInterval);
-        }
-        /**
-       * 停止批量上报定时器
-       */ stopBatchTimer() {
-            if (this.batchTimer) {
-                clearInterval(this.batchTimer);
-                this.batchTimer = null;
+       * 订阅事件
+       * 
+       * @param event - 事件名称
+       * @param listener - 事件监听器（可以接收 EventWrapper 或直接数据）
+       * @returns 取消订阅函数
+       */ on(event, listener) {
+            if (!this.listeners.has(event)) {
+                this.listeners.set(event, new Set());
             }
+            const listeners = this.listeners.get(event);
+            listeners.add(listener);
+            // 返回取消订阅函数
+            return ()=>{
+                listeners.delete(listener);
+                if (listeners.size === 0) {
+                    this.listeners.delete(event);
+                }
+            };
         }
         /**
-       * 记录事件
-       */ track(event) {
-            if (!this.config.enabled) {
-                return;
+       * 取消订阅事件
+       * 
+       * @param event - 事件名称
+       * @param listener - 事件监听器
+       */ off(event, listener) {
+            const listeners = this.listeners.get(event);
+            if (listeners) {
+                listeners.delete(listener);
+                if (listeners.size === 0) {
+                    this.listeners.delete(event);
+                }
             }
-            // 采样检查
-            if (Math.random() > this.config.sampleRate) {
+        }
+        /**
+       * 发布事件
+       * 
+       * @param event - 事件名称
+       * @param data - 事件数据
+       * @param metadata - 事件元数据（可选）
+       */ async emit(event, data, metadata) {
+            // 事件验证
+            if (this.config.enableValidation && !this.config.validator(event, data)) {
+                console.warn(`事件 ${event} 验证失败，已忽略`);
                 return;
             }
-            // 匿名化处理
-            const anonymizedEvent = {
-                ...event,
-                timestamp: Date.now(),
-                properties: this.anonymizeProperties(event.properties)
+            // 构建事件元数据
+            const eventMetadata = {
+                source: metadata?.source,
+                timestamp: metadata?.timestamp ?? Date.now(),
+                eventId: metadata?.eventId ?? `event_${++this.eventCounter}`,
+                priority: metadata?.priority ?? 0
             };
-            // 添加到队列
-            this.eventQueue.push(anonymizedEvent);
-            // 立即上报单个事件
-            if (this.config.onEvent) {
-                this.config.onEvent(anonymizedEvent);
+            // 记录事件历史
+            if (this.config.enableTracking) {
+                this.eventHistory.push({
+                    event,
+                    data,
+                    metadata: eventMetadata
+                });
+                // 限制历史记录大小
+                if (this.eventHistory.length > this.config.maxHistorySize) {
+                    this.eventHistory.shift();
+                }
             }
-            // 检查是否需要批量上报
-            if (this.eventQueue.length >= this.config.batchSize) {
-                this.flush();
+            const listeners = this.listeners.get(event);
+            if (!listeners || listeners.size === 0) {
+                return;
             }
-        }
-        /**
-       * 记录页面浏览
-       */ trackPageView(page, properties) {
-            this.track({
-                type: 'pageview',
-                name: 'page_view',
-                properties: {
-                    page,
-                    ...properties
+            // 创建事件包装器
+            const eventWrapper = {
+                data: data,
+                metadata: eventMetadata
+            };
+            // 按优先级排序监听器（如果有优先级）
+            const sortedListeners = Array.from(listeners);
+            // 并行执行所有监听器
+            const promises = sortedListeners.map((listener)=>{
+                try {
+                    return Promise.resolve(listener(eventWrapper));
+                } catch (error) {
+                    console.error(`事件 ${event} 的监听器执行失败:`, error);
+                    return Promise.resolve();
                 }
             });
+            await Promise.allSettled(promises);
         }
         /**
-       * 记录点击事件
-       */ trackClick(element, properties) {
-            this.track({
-                type: 'click',
-                name: 'click',
-                properties: {
-                    element,
-                    ...properties
-                }
-            });
+       * 发布事件（仅数据，向后兼容）
+       * 
+       * @param event - 事件名称
+       * @param data - 事件数据
+       */ async emitData(event, data) {
+            return this.emit(event, data);
         }
         /**
-       * 记录自定义事件
-       */ trackCustom(name, properties) {
-            this.track({
-                type: 'custom',
-                name,
-                properties
-            });
+       * 一次性订阅事件
+       * 
+       * @param event - 事件名称
+       * @param listener - 事件监听器
+       */ once(event, listener) {
+            const wrappedListener = async (data)=>{
+                // 处理 EventWrapper 或直接数据
+                const actualData = data.data !== undefined ? data.data : data;
+                await listener(actualData);
+                this.off(event, wrappedListener);
+            };
+            this.on(event, wrappedListener);
         }
         /**
-       * 记录错误事件
-       */ trackError(error, properties) {
-            this.track({
-                type: 'error',
-                name: 'error',
-                properties: {
-                    errorName: error.name,
-                    errorMessage: error.message,
-                    errorStack: error.stack,
-                    ...properties
-                }
-            });
+       * 清空所有事件监听器
+       */ clear() {
+            this.listeners.clear();
         }
         /**
-       * 记录性能事件
-       */ trackPerformance(metrics, properties) {
-            this.track({
-                type: 'performance',
-                name: 'performance',
-                properties: {
-                    ...metrics,
-                    ...properties
-                }
-            });
+       * 获取事件监听器数量
+       * 
+       * @param event - 事件名称，如果不提供则返回所有事件的监听器总数
+       */ listenerCount(event) {
+            if (event) {
+                return this.listeners.get(event)?.size || 0;
+            }
+            let count = 0;
+            for (const listeners of this.listeners.values()){
+                count += listeners.size;
+            }
+            return count;
         }
         /**
-       * 匿名化属性（使用深度脱敏）
-       */ anonymizeProperties(properties) {
-            if (!this.config.anonymize || !properties) {
-                return properties;
-            }
-            // 使用深度脱敏处理
-            return utils.SecurityUtils.deepSanitize(properties);
+       * 获取所有事件名称
+       */ eventNames() {
+            return Array.from(this.listeners.keys());
         }
         /**
-       * 刷新队列（批量上报）
-       */ flush() {
-            if (this.eventQueue.length === 0) {
-                return;
+       * 获取事件历史记录
+       * 
+       * @param event - 事件名称（可选，如果提供则只返回该事件的历史）
+       * @param limit - 限制返回的记录数
+       * @returns 事件历史记录
+       */ getEventHistory(event, limit) {
+            if (!this.config.enableTracking) {
+                return [];
             }
-            const events = [
-                ...this.eventQueue
-            ];
-            this.eventQueue = [];
-            if (this.config.onBatch) {
-                this.config.onBatch(events);
+            let history = this.eventHistory;
+            if (event) {
+                history = history.filter((h)=>h.event === event);
             }
-            logger.logger.debug(`分析服务批量上报 ${events.length} 个事件`);
+            if (limit) {
+                history = history.slice(-limit);
+            }
+            return [
+                ...history
+            ];
         }
         /**
-       * 启用分析
-       */ enable() {
-            this.config.enabled = true;
-            this.startBatchTimer();
+       * 清空事件历史记录
+       */ clearHistory() {
+            this.eventHistory = [];
         }
         /**
-       * 禁用分析
-       */ disable() {
-            this.config.enabled = false;
-            this.stopBatchTimer();
-            this.flush();
+       * 请求-响应模式：发送请求并等待响应
+       * 
+       * @param event - 事件名称
+       * @param data - 请求数据
+       * @param timeout - 超时时间（毫秒）
+       * @returns 响应数据
+       */ async request(event, data, timeout = 5000) {
+            return new Promise((resolve, reject)=>{
+                const responseEvent = `${event}:response`;
+                const requestId = `req_${Date.now()}_${Math.random()}`;
+                // 设置超时
+                const timeoutId = setTimeout(()=>{
+                    this.off(responseEvent, responseHandler);
+                    reject(new Error(`请求 ${event} 超时`));
+                }, timeout);
+                // 响应处理器
+                const responseHandler = (response)=>{
+                    // 处理 EventWrapper 或直接数据
+                    const actualResponse = response.data !== undefined ? response.data : response;
+                    if (actualResponse.requestId === requestId) {
+                        clearTimeout(timeoutId);
+                        this.off(responseEvent, responseHandler);
+                        resolve(actualResponse.data);
+                    }
+                };
+                // 订阅响应事件
+                this.on(responseEvent, responseHandler);
+                // 发送请求
+                this.emit(`${event}:request`, {
+                    requestId,
+                    data
+                });
+            });
         }
         /**
-       * 销毁服务
-       */ destroy() {
-            this.stopBatchTimer();
-            this.flush();
+       * 请求-响应模式：注册请求处理器
+       * 
+       * @param event - 事件名称
+       * @param handler - 请求处理器
+       * @returns 取消注册函数
+       */ onRequest(event, handler) {
+            const requestEvent = `${event}:request`;
+            const responseEvent = `${event}:response`;
+            return this.on(requestEvent, async (wrapper)=>{
+                try {
+                    // 处理 EventWrapper 或直接数据
+                    const actualWrapper = wrapper.data !== undefined ? wrapper : {
+                        data: wrapper,
+                        metadata: {
+                            timestamp: Date.now()
+                        }
+                    };
+                    const response = await handler(actualWrapper.data.data, actualWrapper.metadata);
+                    this.emit(responseEvent, {
+                        requestId: actualWrapper.data.requestId,
+                        data: response
+                    });
+                } catch (error) {
+                    const actualWrapper = wrapper.data !== undefined ? wrapper : {
+                        data: wrapper
+                    };
+                    this.emit(`${responseEvent}:error`, {
+                        requestId: actualWrapper.data.requestId,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            });
         }
-        constructor(config = {}){
-            _define_property$I(this, "config", void 0);
-            _define_property$I(this, "eventQueue", []);
-            _define_property$I(this, "batchTimer", null);
+        /**
+       * 获取配置
+       */ getConfig() {
+            return {
+                ...this.config
+            };
+        }
+        /**
+       * 更新配置
+       */ updateConfig(config) {
             this.config = {
-                enabled: config.enabled ?? true,
-                sampleRate: config.sampleRate ?? 1.0,
-                anonymize: config.anonymize ?? true,
-                onEvent: config.onEvent ?? (()=>{}),
-                onBatch: config.onBatch ?? (()=>{}),
-                batchSize: config.batchSize ?? 10,
-                batchInterval: config.batchInterval ?? 5000
+                ...this.config,
+                ...config
             };
-            if (this.config.enabled) {
-                this.startBatchTimer();
-            }
         }
-    }
-    /**
-     * 默认分析服务实例
-     */ let defaultAnalyticsService = null;
-    /**
-     * 初始化默认分析服务
-     */ function initAnalytics(config) {
-        if (!defaultAnalyticsService) {
-            defaultAnalyticsService = new AnalyticsService(config);
+        constructor(config = {}){
+            _define_property$H(this, "listeners", new Map());
+            _define_property$H(this, "eventHistory", []);
+            _define_property$H(this, "config", void 0);
+            _define_property$H(this, "eventCounter", 0);
+            this.config = {
+                enableTracking: config.enableTracking ?? false,
+                maxHistorySize: config.maxHistorySize ?? 100,
+                enableValidation: config.enableValidation ?? false,
+                validator: config.validator ?? (()=>true)
+            };
         }
-        return defaultAnalyticsService;
     }
     /**
-     * 获取默认分析服务
-     */ function getAnalytics() {
-        if (!defaultAnalyticsService) {
-            return initAnalytics();
-        }
-        return defaultAnalyticsService;
-    }
-
-    var analytics = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        AnalyticsService: AnalyticsService,
-        getAnalytics: getAnalytics,
-        initAnalytics: initAnalytics
+     * 全局插件事件总线实例
+     */ const pluginEventBus = new PluginEventBus({
+        enableTracking: process.env.NODE_ENV === 'development',
+        maxHistorySize: 100,
+        enableValidation: false
     });
 
-    /**
-     * 等待指定时间后解析的 Promise 工具函数
-     * 
-     * @param time - 等待时间（毫秒），默认为 100 毫秒
-     * @returns 返回一个 Promise，在指定时间后解析为 true
-     * 
-     * @example
-     * ```typescript
-     * // 等待 500 毫秒
-     * await waitTime(500);
-     * 
-     * // 使用默认等待时间（100 毫秒）
-     * await waitTime();
-     * ```
-     * @deprecated 建议使用基于实际完成状态的机制，而不是固定等待时间
-     */ const waitTime = (time = 100)=>{
-        return new Promise((resolve)=>{
-            setTimeout(()=>{
-                resolve(true);
-            }, time);
-        });
-    };
-
-    /**
-     * 插件沙箱
-     * 用于插件隔离和权限控制
-     */ function _define_property$H(obj, key, value) {
+    function _define_property$G(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -841,804 +838,418 @@
         return obj;
     }
     /**
-     * 插件沙箱
-     */ class PluginSandbox {
+     * 插件管理器
+     *
+     * 优化：
+     * 1. 支持插件依赖管理
+     * 2. 支持插件优先级控制
+     * 3. 支持插件生命周期管理
+     * 4. 支持插件热插拔（动态加载/卸载）
+     */ class PluginManager {
         /**
-       * 检查权限
-       * 
-       * @param permission - 权限
-       * @returns 是否有权限
-       */ hasPermission(permission) {
-            if (!this.config.strictMode) {
-                return true; // 非严格模式，允许所有权限
+       * 注册插件
+       *
+       * 优化：检查插件依赖是否已注册
+       */ register(plugin) {
+            if (this.plugins.has(plugin.name)) {
+                console.warn(`插件 ${plugin.name} 已存在，将被覆盖`);
             }
-            return this.permissions.has(permission);
-        }
-        /**
-       * 检查是否可以访问配置键
-       * 
-       * @param key - 配置键
-       * @returns 是否可以访问
-       */ canAccessConfig(key) {
-            if (!this.hasPermission("access_config")) {
-                return false;
+            // 检查依赖是否已注册
+            if (plugin.dependencies && plugin.dependencies.length > 0) {
+                const missingDeps = plugin.dependencies.filter((dep)=>!this.plugins.has(dep));
+                if (missingDeps.length > 0) {
+                    console.warn(`插件 ${plugin.name} 的依赖未注册: ${missingDeps.join(', ')}`);
+                }
             }
-            if (this.config.configWhitelist && this.config.configWhitelist.length > 0) {
-                return this.config.configWhitelist.includes(key);
+            this.plugins.set(plugin.name, plugin);
+            this.pluginStatus.set(plugin.name, 'registered');
+            // 创建插件沙箱
+            if (plugin.sandbox) {
+                const sandbox = new PluginSandbox({
+                    ...plugin.sandbox,
+                    name: plugin.name
+                });
+                this.sandboxes.set(plugin.name, sandbox);
+            } else {
+                // 如果没有配置沙箱，创建默认沙箱（非严格模式）
+                const sandbox = new PluginSandbox({
+                    strictMode: false,
+                    name: plugin.name
+                });
+                this.sandboxes.set(plugin.name, sandbox);
             }
-            return true;
         }
         /**
-       * 检查是否可以访问状态作用域
-       * 
-       * @param scope - 状态作用域
-       * @returns 是否可以访问
-       */ canAccessStateScope(scope) {
-            if (!this.hasPermission("access_state_manager")) {
-                return false;
-            }
-            if (this.config.stateScopeWhitelist && this.config.stateScopeWhitelist.length > 0) {
-                return this.config.stateScopeWhitelist.includes(scope);
+       * 获取插件加载顺序（考虑依赖和优先级）
+       *
+       * @returns 插件名称数组，按加载顺序排列
+       */ getLoadOrder() {
+            const plugins = Array.from(this.plugins.values());
+            // 按优先级排序
+            const sortedPlugins = plugins.sort((a, b)=>{
+                const priorityA = a.priority ?? 100;
+                const priorityB = b.priority ?? 100;
+                return priorityA - priorityB;
+            });
+            // 构建依赖图并拓扑排序
+            const visited = new Set();
+            const visiting = new Set();
+            const result = [];
+            const visit = (pluginName)=>{
+                if (visiting.has(pluginName)) {
+                    console.warn(`检测到循环依赖，涉及插件: ${pluginName}`);
+                    return;
+                }
+                if (visited.has(pluginName)) {
+                    return;
+                }
+                visiting.add(pluginName);
+                const plugin = this.plugins.get(pluginName);
+                if (plugin?.dependencies) {
+                    for (const dep of plugin.dependencies){
+                        visit(dep);
+                    }
+                }
+                visiting.delete(pluginName);
+                visited.add(pluginName);
+                result.push(pluginName);
+            };
+            for (const plugin of sortedPlugins){
+                visit(plugin.name);
             }
-            return true;
+            return result;
         }
         /**
-       * 过滤配置（根据白名单）
-       * 
-       * @param config - 完整配置
-       * @returns 过滤后的配置
-       */ filterConfig(config) {
-            if (!this.hasPermission("access_config")) {
-                return {};
-            }
-            if (!this.config.configWhitelist || this.config.configWhitelist.length === 0) {
-                return config;
-            }
-            const filtered = {};
-            for (const key of this.config.configWhitelist){
-                if (key in config) {
-                    filtered[key] = config[key];
-                }
+       * 注销插件
+       */ unregister(name) {
+            const plugin = this.plugins.get(name);
+            if (plugin && plugin.destroy) {
+                plugin.destroy();
             }
-            return filtered;
+            this.plugins.delete(name);
+            this.sandboxes.delete(name);
+            this.pluginStatus.delete(name);
+            this.pluginLoaders.delete(name);
         }
         /**
-       * 获取沙箱配置
-       */ getConfig() {
-            return {
-                ...this.config
-            };
-        }
-        /**
-       * 更新权限
-       * 
-       * @param permissions - 权限列表
-       */ updatePermissions(permissions) {
-            this.permissions = new Set(permissions);
-            this.config.permissions = permissions;
-        }
-        constructor(config){
-            _define_property$H(this, "config", void 0);
-            _define_property$H(this, "permissions", void 0);
-            this.config = {
-                strictMode: true,
-                ...config
-            };
-            this.permissions = new Set(config.permissions || []);
-        }
-    }
-
-    /**
-     * 插件事件总线
-     * 用于插件间通信
-     */ /**
-     * 事件监听器类型
-     */ function _define_property$G(obj, key, value) {
-        if (key in obj) {
-            Object.defineProperty(obj, key, {
-                value: value,
-                enumerable: true,
-                configurable: true,
-                writable: true
-            });
-        } else {
-            obj[key] = value;
-        }
-        return obj;
-    }
-    /**
-     * 事件总线
-     */ class PluginEventBus {
-        /**
-       * 订阅事件
-       * 
-       * @param event - 事件名称
-       * @param listener - 事件监听器（可以接收 EventWrapper 或直接数据）
-       * @returns 取消订阅函数
-       */ on(event, listener) {
-            if (!this.listeners.has(event)) {
-                this.listeners.set(event, new Set());
+       * 动态加载插件（热插拔）
+       *
+       * @param options - 插件加载选项
+       * @returns 加载的插件
+       */ async loadPlugin(options) {
+            let plugin;
+            if (options.url) {
+                // 从URL加载插件
+                const response = await fetch(options.url);
+                if (!response.ok) {
+                    throw new Error(`无法加载插件: ${options.url} (${response.status})`);
+                }
+                const pluginModule = await response.json();
+                plugin = pluginModule.default || pluginModule;
+            } else if (options.modulePath) {
+                // 从模块路径动态导入
+                const pluginModule = await import(/* @vite-ignore */ options.modulePath);
+                plugin = pluginModule.default || pluginModule;
+            } else {
+                throw new Error('必须提供 url 或 modulePath');
             }
-            const listeners = this.listeners.get(event);
-            listeners.add(listener);
-            // 返回取消订阅函数
-            return ()=>{
-                listeners.delete(listener);
-                if (listeners.size === 0) {
-                    this.listeners.delete(event);
+            if (!plugin || !plugin.name) {
+                throw new Error('插件格式无效：必须包含 name 属性');
+            }
+            // 检查插件是否已加载
+            if (this.plugins.has(plugin.name)) {
+                throw new Error(`插件 ${plugin.name} 已加载`);
+            }
+            // 设置加载状态
+            this.pluginStatus.set(plugin.name, 'loading');
+            try {
+                // 注册插件
+                this.register(plugin);
+                // 如果要求立即初始化
+                if (options.initialize && options.initContext && options.startOptions) {
+                    await this.initializePlugin(plugin.name, options.startOptions, options.initContext);
                 }
-            };
+                return plugin;
+            } catch (error) {
+                this.pluginStatus.delete(plugin.name);
+                throw error;
+            }
         }
         /**
-       * 取消订阅事件
-       * 
-       * @param event - 事件名称
-       * @param listener - 事件监听器
-       */ off(event, listener) {
-            const listeners = this.listeners.get(event);
-            if (listeners) {
-                listeners.delete(listener);
-                if (listeners.size === 0) {
-                    this.listeners.delete(event);
+       * 初始化单个插件
+       *
+       * @param name - 插件名称
+       * @param options - 启动选项
+       * @param context - 初始化上下文
+       */ async initializePlugin(name, options, context) {
+            const plugin = this.plugins.get(name);
+            if (!plugin) {
+                throw new Error(`插件 ${name} 未注册`);
+            }
+            const status = this.pluginStatus.get(name);
+            if (status === 'initialized') {
+                return; // 已经初始化
+            }
+            try {
+                const sandbox = this.sandboxes.get(name);
+                if (!sandbox) {
+                    throw new Error(`插件 ${name} 的沙箱未找到`);
+                }
+                // 执行初始化钩子
+                if (plugin.init) {
+                    const filteredOptions = sandbox.filterConfig(options);
+                    await plugin.init(filteredOptions, context, sandbox, pluginEventBus);
                 }
+                this.pluginStatus.set(name, 'initialized');
+            } catch (error) {
+                console.error(`插件 ${name} 初始化失败:`, error);
+                throw error;
             }
         }
         /**
-       * 发布事件
-       * 
-       * @param event - 事件名称
-       * @param data - 事件数据
-       * @param metadata - 事件元数据（可选）
-       */ async emit(event, data, metadata) {
-            // 事件验证
-            if (this.config.enableValidation && !this.config.validator(event, data)) {
-                console.warn(`事件 ${event} 验证失败，已忽略`);
-                return;
+       * 卸载插件（热插拔）
+       *
+       * @param name - 插件名称
+       * @param force - 是否强制卸载（即使有依赖）
+       */ async unloadPlugin(name, force = false) {
+            const plugin = this.plugins.get(name);
+            if (!plugin) {
+                throw new Error(`插件 ${name} 未加载`);
             }
-            // 构建事件元数据
-            const eventMetadata = {
-                source: metadata?.source,
-                timestamp: metadata?.timestamp ?? Date.now(),
-                eventId: metadata?.eventId ?? `event_${++this.eventCounter}`,
-                priority: metadata?.priority ?? 0
-            };
-            // 记录事件历史
-            if (this.config.enableTracking) {
-                this.eventHistory.push({
-                    event,
-                    data,
-                    metadata: eventMetadata
-                });
-                // 限制历史记录大小
-                if (this.eventHistory.length > this.config.maxHistorySize) {
-                    this.eventHistory.shift();
+            // 检查是否有其他插件依赖此插件
+            if (!force) {
+                const dependents = Array.from(this.plugins.values()).filter((p)=>p.dependencies && p.dependencies.includes(name));
+                if (dependents.length > 0) {
+                    throw new Error(`无法卸载插件 ${name}，以下插件依赖它: ${dependents.map((p)=>p.name).join(', ')}`);
                 }
             }
-            const listeners = this.listeners.get(event);
-            if (!listeners || listeners.size === 0) {
-                return;
-            }
-            // 创建事件包装器
-            const eventWrapper = {
-                data: data,
-                metadata: eventMetadata
-            };
-            // 按优先级排序监听器（如果有优先级）
-            const sortedListeners = Array.from(listeners);
-            // 并行执行所有监听器
-            const promises = sortedListeners.map((listener)=>{
+            // 执行销毁钩子
+            if (plugin.destroy) {
                 try {
-                    return Promise.resolve(listener(eventWrapper));
+                    await plugin.destroy();
                 } catch (error) {
-                    console.error(`事件 ${event} 的监听器执行失败:`, error);
-                    return Promise.resolve();
+                    console.error(`插件 ${name} 的 destroy 钩子执行失败:`, error);
                 }
-            });
-            await Promise.allSettled(promises);
-        }
-        /**
-       * 发布事件（仅数据，向后兼容）
-       * 
-       * @param event - 事件名称
-       * @param data - 事件数据
-       */ async emitData(event, data) {
-            return this.emit(event, data);
+            }
+            // 从事件总线移除相关监听器（如果有）
+            // 注意：事件总线是全局的，这里只移除插件相关的事件
+            // 实际实现可能需要更细粒度的控制
+            // 清理插件
+            this.unregister(name);
+            this.pluginStatus.set(name, 'destroyed');
         }
         /**
-       * 一次性订阅事件
-       * 
-       * @param event - 事件名称
-       * @param listener - 事件监听器
-       */ once(event, listener) {
-            const wrappedListener = async (data)=>{
-                // 处理 EventWrapper 或直接数据
-                const actualData = data.data !== undefined ? data.data : data;
-                await listener(actualData);
-                this.off(event, wrappedListener);
-            };
-            this.on(event, wrappedListener);
+       * 检查插件是否可以热加载
+       *
+       * @param plugin - 插件
+       * @returns 是否可以热加载
+       */ canHotLoad(plugin) {
+            // 检查依赖是否都已加载
+            if (plugin.dependencies && plugin.dependencies.length > 0) {
+                const missingDeps = plugin.dependencies.filter((dep)=>!this.plugins.has(dep));
+                if (missingDeps.length > 0) {
+                    return false;
+                }
+            }
+            return true;
         }
         /**
-       * 清空所有事件监听器
-       */ clear() {
-            this.listeners.clear();
+       * 注册插件加载器（用于延迟加载）
+       *
+       * @param name - 插件名称
+       * @param loader - 加载器函数
+       */ registerLoader(name, loader) {
+            this.pluginLoaders.set(name, loader);
         }
         /**
-       * 获取事件监听器数量
-       * 
-       * @param event - 事件名称，如果不提供则返回所有事件的监听器总数
-       */ listenerCount(event) {
-            if (event) {
-                return this.listeners.get(event)?.size || 0;
-            }
-            let count = 0;
-            for (const listeners of this.listeners.values()){
-                count += listeners.size;
+       * 使用加载器加载插件
+       *
+       * @param name - 插件名称
+       * @param options - 加载选项
+       * @returns 加载的插件
+       */ async loadPluginByLoader(name, options) {
+            const loader = this.pluginLoaders.get(name);
+            if (!loader) {
+                throw new Error(`插件 ${name} 的加载器未注册`);
             }
-            return count;
-        }
-        /**
-       * 获取所有事件名称
-       */ eventNames() {
-            return Array.from(this.listeners.keys());
-        }
-        /**
-       * 获取事件历史记录
-       * 
-       * @param event - 事件名称（可选，如果提供则只返回该事件的历史）
-       * @param limit - 限制返回的记录数
-       * @returns 事件历史记录
-       */ getEventHistory(event, limit) {
-            if (!this.config.enableTracking) {
-                return [];
+            const plugin = await loader();
+            if (!plugin || !plugin.name) {
+                throw new Error('插件格式无效：必须包含 name 属性');
             }
-            let history = this.eventHistory;
-            if (event) {
-                history = history.filter((h)=>h.event === event);
+            if (plugin.name !== name) {
+                throw new Error(`插件名称不匹配: 期望 ${name}，实际 ${plugin.name}`);
             }
-            if (limit) {
-                history = history.slice(-limit);
+            // 检查插件是否已加载
+            if (this.plugins.has(plugin.name)) {
+                return this.plugins.get(plugin.name);
+            }
+            // 设置加载状态
+            this.pluginStatus.set(plugin.name, 'loading');
+            try {
+                // 注册插件
+                this.register(plugin);
+                // 如果要求立即初始化
+                if (options?.initialize && options.initContext && options.startOptions) {
+                    await this.initializePlugin(plugin.name, options.startOptions, options.initContext);
+                }
+                return plugin;
+            } catch (error) {
+                this.pluginStatus.delete(plugin.name);
+                throw error;
             }
-            return [
-                ...history
-            ];
         }
         /**
-       * 清空事件历史记录
-       */ clearHistory() {
-            this.eventHistory = [];
+       * 获取插件
+       */ get(name) {
+            return this.plugins.get(name);
         }
         /**
-       * 请求-响应模式：发送请求并等待响应
-       * 
-       * @param event - 事件名称
-       * @param data - 请求数据
-       * @param timeout - 超时时间（毫秒）
-       * @returns 响应数据
-       */ async request(event, data, timeout = 5000) {
-            return new Promise((resolve, reject)=>{
-                const responseEvent = `${event}:response`;
-                const requestId = `req_${Date.now()}_${Math.random()}`;
-                // 设置超时
-                const timeoutId = setTimeout(()=>{
-                    this.off(responseEvent, responseHandler);
-                    reject(new Error(`请求 ${event} 超时`));
-                }, timeout);
-                // 响应处理器
-                const responseHandler = (response)=>{
-                    // 处理 EventWrapper 或直接数据
-                    const actualResponse = response.data !== undefined ? response.data : response;
-                    if (actualResponse.requestId === requestId) {
-                        clearTimeout(timeoutId);
-                        this.off(responseEvent, responseHandler);
-                        resolve(actualResponse.data);
-                    }
-                };
-                // 订阅响应事件
-                this.on(responseEvent, responseHandler);
-                // 发送请求
-                this.emit(`${event}:request`, {
-                    requestId,
-                    data
-                });
-            });
+       * 获取所有插件
+       */ getAll() {
+            return Array.from(this.plugins.values());
         }
         /**
-       * 请求-响应模式：注册请求处理器
-       * 
-       * @param event - 事件名称
-       * @param handler - 请求处理器
-       * @returns 取消注册函数
-       */ onRequest(event, handler) {
-            const requestEvent = `${event}:request`;
-            const responseEvent = `${event}:response`;
-            return this.on(requestEvent, async (wrapper)=>{
+       * 执行初始化前钩子
+       *
+       * 优化：按依赖顺序执行
+       */ async executeBeforeInit(options) {
+            const loadOrder = this.getLoadOrder();
+            for (const pluginName of loadOrder){
+                const plugin = this.plugins.get(pluginName);
+                if (!plugin || !plugin.beforeInit) {
+                    continue;
+                }
                 try {
-                    // 处理 EventWrapper 或直接数据
-                    const actualWrapper = wrapper.data !== undefined ? wrapper : {
-                        data: wrapper,
-                        metadata: {
-                            timestamp: Date.now()
-                        }
-                    };
-                    const response = await handler(actualWrapper.data.data, actualWrapper.metadata);
-                    this.emit(responseEvent, {
-                        requestId: actualWrapper.data.requestId,
-                        data: response
-                    });
+                    const sandbox = this.sandboxes.get(plugin.name);
+                    if (!sandbox) {
+                        console.warn(`插件 ${plugin.name} 的沙箱未找到`);
+                        continue;
+                    }
+                    // 根据沙箱配置过滤选项
+                    const filteredOptions = sandbox.filterConfig(options);
+                    await plugin.beforeInit(filteredOptions, sandbox, pluginEventBus);
                 } catch (error) {
-                    const actualWrapper = wrapper.data !== undefined ? wrapper : {
-                        data: wrapper
-                    };
-                    this.emit(`${responseEvent}:error`, {
-                        requestId: actualWrapper.data.requestId,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
+                    console.error(`插件 ${plugin.name} 的 beforeInit 钩子执行失败:`, error);
                 }
-            });
-        }
-        /**
-       * 获取配置
-       */ getConfig() {
-            return {
-                ...this.config
-            };
-        }
-        /**
-       * 更新配置
-       */ updateConfig(config) {
-            this.config = {
-                ...this.config,
-                ...config
-            };
-        }
-        constructor(config = {}){
-            _define_property$G(this, "listeners", new Map());
-            _define_property$G(this, "eventHistory", []);
-            _define_property$G(this, "config", void 0);
-            _define_property$G(this, "eventCounter", 0);
-            this.config = {
-                enableTracking: config.enableTracking ?? false,
-                maxHistorySize: config.maxHistorySize ?? 100,
-                enableValidation: config.enableValidation ?? false,
-                validator: config.validator ?? (()=>true)
-            };
-        }
-    }
-    /**
-     * 全局插件事件总线实例
-     */ const pluginEventBus = new PluginEventBus({
-        enableTracking: process.env.NODE_ENV === 'development',
-        maxHistorySize: 100,
-        enableValidation: false
-    });
-
-    function _define_property$F(obj, key, value) {
-        if (key in obj) {
-            Object.defineProperty(obj, key, {
-                value: value,
-                enumerable: true,
-                configurable: true,
-                writable: true
-            });
-        } else {
-            obj[key] = value;
+            }
         }
-        return obj;
-    }
-    /**
-     * 插件管理器
-     *
-     * 优化：
-     * 1. 支持插件依赖管理
-     * 2. 支持插件优先级控制
-     * 3. 支持插件生命周期管理
-     * 4. 支持插件热插拔（动态加载/卸载）
-     */ class PluginManager {
         /**
-       * 注册插件
+       * 执行初始化钩子
        *
-       * 优化：检查插件依赖是否已注册
-       */ register(plugin) {
-            if (this.plugins.has(plugin.name)) {
-                console.warn(`插件 ${plugin.name} 已存在，将被覆盖`);
-            }
-            // 检查依赖是否已注册
-            if (plugin.dependencies && plugin.dependencies.length > 0) {
-                const missingDeps = plugin.dependencies.filter((dep)=>!this.plugins.has(dep));
-                if (missingDeps.length > 0) {
-                    console.warn(`插件 ${plugin.name} 的依赖未注册: ${missingDeps.join(', ')}`);
+       * 优化：按依赖顺序执行，并更新插件状态
+       */ async executeInit(options, context) {
+            const loadOrder = this.getLoadOrder();
+            for (const pluginName of loadOrder){
+                const plugin = this.plugins.get(pluginName);
+                if (!plugin || !plugin.init) {
+                    continue;
+                }
+                try {
+                    const sandbox = this.sandboxes.get(plugin.name);
+                    if (!sandbox) {
+                        console.warn(`插件 ${plugin.name} 的沙箱未找到`);
+                        continue;
+                    }
+                    // 根据沙箱配置过滤选项
+                    const filteredOptions = sandbox.filterConfig(options);
+                    await plugin.init(filteredOptions, context, sandbox, pluginEventBus);
+                    this.pluginStatus.set(plugin.name, 'initialized');
+                } catch (error) {
+                    console.error(`插件 ${plugin.name} 的 init 钩子执行失败:`, error);
                 }
-            }
-            this.plugins.set(plugin.name, plugin);
-            this.pluginStatus.set(plugin.name, 'registered');
-            // 创建插件沙箱
-            if (plugin.sandbox) {
-                const sandbox = new PluginSandbox({
-                    ...plugin.sandbox,
-                    name: plugin.name
-                });
-                this.sandboxes.set(plugin.name, sandbox);
-            } else {
-                // 如果没有配置沙箱，创建默认沙箱（非严格模式）
-                const sandbox = new PluginSandbox({
-                    strictMode: false,
-                    name: plugin.name
-                });
-                this.sandboxes.set(plugin.name, sandbox);
             }
         }
         /**
-       * 获取插件加载顺序（考虑依赖和优先级）
+       * 执行初始化后钩子
        *
-       * @returns 插件名称数组，按加载顺序排列
-       */ getLoadOrder() {
-            const plugins = Array.from(this.plugins.values());
-            // 按优先级排序
-            const sortedPlugins = plugins.sort((a, b)=>{
-                const priorityA = a.priority ?? 100;
-                const priorityB = b.priority ?? 100;
-                return priorityA - priorityB;
-            });
-            // 构建依赖图并拓扑排序
-            const visited = new Set();
-            const visiting = new Set();
-            const result = [];
-            const visit = (pluginName)=>{
-                if (visiting.has(pluginName)) {
-                    console.warn(`检测到循环依赖，涉及插件: ${pluginName}`);
-                    return;
-                }
-                if (visited.has(pluginName)) {
-                    return;
-                }
-                visiting.add(pluginName);
+       * 优化：按依赖顺序执行（逆序，确保依赖插件先执行）
+       */ async executeAfterInit(options, context) {
+            const loadOrder = this.getLoadOrder();
+            // 逆序执行，确保依赖插件先执行
+            const reverseOrder = [
+                ...loadOrder
+            ].reverse();
+            for (const pluginName of reverseOrder){
                 const plugin = this.plugins.get(pluginName);
-                if (plugin?.dependencies) {
-                    for (const dep of plugin.dependencies){
-                        visit(dep);
-                    }
-                }
-                visiting.delete(pluginName);
-                visited.add(pluginName);
-                result.push(pluginName);
-            };
-            for (const plugin of sortedPlugins){
-                visit(plugin.name);
-            }
-            return result;
-        }
-        /**
-       * 注销插件
-       */ unregister(name) {
-            const plugin = this.plugins.get(name);
-            if (plugin && plugin.destroy) {
-                plugin.destroy();
-            }
-            this.plugins.delete(name);
-            this.sandboxes.delete(name);
-            this.pluginStatus.delete(name);
-            this.pluginLoaders.delete(name);
-        }
-        /**
-       * 动态加载插件（热插拔）
-       *
-       * @param options - 插件加载选项
-       * @returns 加载的插件
-       */ async loadPlugin(options) {
-            let plugin;
-            if (options.url) {
-                // 从URL加载插件
-                const response = await fetch(options.url);
-                if (!response.ok) {
-                    throw new Error(`无法加载插件: ${options.url} (${response.status})`);
+                if (!plugin || !plugin.afterInit) {
+                    continue;
                 }
-                const pluginModule = await response.json();
-                plugin = pluginModule.default || pluginModule;
-            } else if (options.modulePath) {
-                // 从模块路径动态导入
-                const pluginModule = await import(/* @vite-ignore */ options.modulePath);
-                plugin = pluginModule.default || pluginModule;
-            } else {
-                throw new Error('必须提供 url 或 modulePath');
-            }
-            if (!plugin || !plugin.name) {
-                throw new Error('插件格式无效：必须包含 name 属性');
-            }
-            // 检查插件是否已加载
-            if (this.plugins.has(plugin.name)) {
-                throw new Error(`插件 ${plugin.name} 已加载`);
-            }
-            // 设置加载状态
-            this.pluginStatus.set(plugin.name, 'loading');
-            try {
-                // 注册插件
-                this.register(plugin);
-                // 如果要求立即初始化
-                if (options.initialize && options.initContext && options.startOptions) {
-                    await this.initializePlugin(plugin.name, options.startOptions, options.initContext);
+                try {
+                    const sandbox = this.sandboxes.get(plugin.name);
+                    if (!sandbox) {
+                        console.warn(`插件 ${plugin.name} 的沙箱未找到`);
+                        continue;
+                    }
+                    // 根据沙箱配置过滤选项
+                    const filteredOptions = sandbox.filterConfig(options);
+                    await plugin.afterInit(filteredOptions, context, sandbox, pluginEventBus);
+                } catch (error) {
+                    console.error(`插件 ${plugin.name} 的 afterInit 钩子执行失败:`, error);
                 }
-                return plugin;
-            } catch (error) {
-                this.pluginStatus.delete(plugin.name);
-                throw error;
             }
         }
         /**
-       * 初始化单个插件
+       * 获取插件状态
        *
        * @param name - 插件名称
-       * @param options - 启动选项
-       * @param context - 初始化上下文
-       */ async initializePlugin(name, options, context) {
-            const plugin = this.plugins.get(name);
-            if (!plugin) {
-                throw new Error(`插件 ${name} 未注册`);
-            }
-            const status = this.pluginStatus.get(name);
-            if (status === 'initialized') {
-                return; // 已经初始化
-            }
-            try {
-                const sandbox = this.sandboxes.get(name);
-                if (!sandbox) {
-                    throw new Error(`插件 ${name} 的沙箱未找到`);
-                }
-                // 执行初始化钩子
-                if (plugin.init) {
-                    const filteredOptions = sandbox.filterConfig(options);
-                    await plugin.init(filteredOptions, context, sandbox, pluginEventBus);
-                }
-                this.pluginStatus.set(name, 'initialized');
-            } catch (error) {
-                console.error(`插件 ${name} 初始化失败:`, error);
-                throw error;
-            }
+       * @returns 插件状态
+       */ getPluginStatus(name) {
+            return this.pluginStatus.get(name);
         }
         /**
-       * 卸载插件（热插拔）
+       * 检查插件是否已加载
        *
        * @param name - 插件名称
-       * @param force - 是否强制卸载（即使有依赖）
-       */ async unloadPlugin(name, force = false) {
-            const plugin = this.plugins.get(name);
-            if (!plugin) {
-                throw new Error(`插件 ${name} 未加载`);
-            }
-            // 检查是否有其他插件依赖此插件
-            if (!force) {
-                const dependents = Array.from(this.plugins.values()).filter((p)=>p.dependencies && p.dependencies.includes(name));
-                if (dependents.length > 0) {
-                    throw new Error(`无法卸载插件 ${name}，以下插件依赖它: ${dependents.map((p)=>p.name).join(', ')}`);
-                }
-            }
-            // 执行销毁钩子
-            if (plugin.destroy) {
-                try {
-                    await plugin.destroy();
-                } catch (error) {
-                    console.error(`插件 ${name} 的 destroy 钩子执行失败:`, error);
-                }
-            }
-            // 从事件总线移除相关监听器（如果有）
-            // 注意：事件总线是全局的，这里只移除插件相关的事件
-            // 实际实现可能需要更细粒度的控制
-            // 清理插件
-            this.unregister(name);
-            this.pluginStatus.set(name, 'destroyed');
+       * @returns 是否已加载
+       */ isLoaded(name) {
+            return this.plugins.has(name);
         }
         /**
-       * 检查插件是否可以热加载
+       * 获取已加载的插件列表
        *
-       * @param plugin - 插件
-       * @returns 是否可以热加载
-       */ canHotLoad(plugin) {
-            // 检查依赖是否都已加载
-            if (plugin.dependencies && plugin.dependencies.length > 0) {
-                const missingDeps = plugin.dependencies.filter((dep)=>!this.plugins.has(dep));
-                if (missingDeps.length > 0) {
-                    return false;
-                }
-            }
-            return true;
+       * @returns 插件名称数组
+       */ getLoadedPlugins() {
+            return Array.from(this.plugins.keys());
         }
         /**
-       * 注册插件加载器（用于延迟加载）
+       * 获取所有插件状态
        *
-       * @param name - 插件名称
-       * @param loader - 加载器函数
-       */ registerLoader(name, loader) {
-            this.pluginLoaders.set(name, loader);
+       * @returns 插件状态映射
+       */ getAllPluginStatus() {
+            return new Map(this.pluginStatus);
         }
         /**
-       * 使用加载器加载插件
+       * 获取插件沙箱
        *
        * @param name - 插件名称
-       * @param options - 加载选项
-       * @returns 加载的插件
-       */ async loadPluginByLoader(name, options) {
-            const loader = this.pluginLoaders.get(name);
-            if (!loader) {
-                throw new Error(`插件 ${name} 的加载器未注册`);
-            }
-            const plugin = await loader();
-            if (!plugin || !plugin.name) {
-                throw new Error('插件格式无效：必须包含 name 属性');
-            }
-            if (plugin.name !== name) {
-                throw new Error(`插件名称不匹配: 期望 ${name}，实际 ${plugin.name}`);
-            }
-            // 检查插件是否已加载
-            if (this.plugins.has(plugin.name)) {
-                return this.plugins.get(plugin.name);
-            }
-            // 设置加载状态
-            this.pluginStatus.set(plugin.name, 'loading');
-            try {
-                // 注册插件
-                this.register(plugin);
-                // 如果要求立即初始化
-                if (options?.initialize && options.initContext && options.startOptions) {
-                    await this.initializePlugin(plugin.name, options.startOptions, options.initContext);
-                }
-                return plugin;
-            } catch (error) {
-                this.pluginStatus.delete(plugin.name);
-                throw error;
-            }
+       * @returns 插件沙箱或undefined
+       */ getSandbox(name) {
+            return this.sandboxes.get(name);
         }
         /**
-       * 获取插件
-       */ get(name) {
-            return this.plugins.get(name);
+       * 获取事件总线
+       */ getEventBus() {
+            return pluginEventBus;
         }
         /**
-       * 获取所有插件
-       */ getAll() {
-            return Array.from(this.plugins.values());
-        }
-        /**
-       * 执行初始化前钩子
-       *
-       * 优化：按依赖顺序执行
-       */ async executeBeforeInit(options) {
-            const loadOrder = this.getLoadOrder();
-            for (const pluginName of loadOrder){
-                const plugin = this.plugins.get(pluginName);
-                if (!plugin || !plugin.beforeInit) {
-                    continue;
-                }
-                try {
-                    const sandbox = this.sandboxes.get(plugin.name);
-                    if (!sandbox) {
-                        console.warn(`插件 ${plugin.name} 的沙箱未找到`);
-                        continue;
-                    }
-                    // 根据沙箱配置过滤选项
-                    const filteredOptions = sandbox.filterConfig(options);
-                    await plugin.beforeInit(filteredOptions, sandbox, pluginEventBus);
-                } catch (error) {
-                    console.error(`插件 ${plugin.name} 的 beforeInit 钩子执行失败:`, error);
-                }
-            }
-        }
-        /**
-       * 执行初始化钩子
-       *
-       * 优化：按依赖顺序执行，并更新插件状态
-       */ async executeInit(options, context) {
-            const loadOrder = this.getLoadOrder();
-            for (const pluginName of loadOrder){
-                const plugin = this.plugins.get(pluginName);
-                if (!plugin || !plugin.init) {
-                    continue;
-                }
-                try {
-                    const sandbox = this.sandboxes.get(plugin.name);
-                    if (!sandbox) {
-                        console.warn(`插件 ${plugin.name} 的沙箱未找到`);
-                        continue;
-                    }
-                    // 根据沙箱配置过滤选项
-                    const filteredOptions = sandbox.filterConfig(options);
-                    await plugin.init(filteredOptions, context, sandbox, pluginEventBus);
-                    this.pluginStatus.set(plugin.name, 'initialized');
-                } catch (error) {
-                    console.error(`插件 ${plugin.name} 的 init 钩子执行失败:`, error);
-                }
-            }
-        }
-        /**
-       * 执行初始化后钩子
-       *
-       * 优化：按依赖顺序执行（逆序，确保依赖插件先执行）
-       */ async executeAfterInit(options, context) {
-            const loadOrder = this.getLoadOrder();
-            // 逆序执行，确保依赖插件先执行
-            const reverseOrder = [
-                ...loadOrder
-            ].reverse();
-            for (const pluginName of reverseOrder){
-                const plugin = this.plugins.get(pluginName);
-                if (!plugin || !plugin.afterInit) {
-                    continue;
-                }
-                try {
-                    const sandbox = this.sandboxes.get(plugin.name);
-                    if (!sandbox) {
-                        console.warn(`插件 ${plugin.name} 的沙箱未找到`);
-                        continue;
-                    }
-                    // 根据沙箱配置过滤选项
-                    const filteredOptions = sandbox.filterConfig(options);
-                    await plugin.afterInit(filteredOptions, context, sandbox, pluginEventBus);
-                } catch (error) {
-                    console.error(`插件 ${plugin.name} 的 afterInit 钩子执行失败:`, error);
-                }
-            }
-        }
-        /**
-       * 获取插件状态
-       *
-       * @param name - 插件名称
-       * @returns 插件状态
-       */ getPluginStatus(name) {
-            return this.pluginStatus.get(name);
-        }
-        /**
-       * 检查插件是否已加载
-       *
-       * @param name - 插件名称
-       * @returns 是否已加载
-       */ isLoaded(name) {
-            return this.plugins.has(name);
-        }
-        /**
-       * 获取已加载的插件列表
-       *
-       * @returns 插件名称数组
-       */ getLoadedPlugins() {
-            return Array.from(this.plugins.keys());
-        }
-        /**
-       * 获取所有插件状态
-       *
-       * @returns 插件状态映射
-       */ getAllPluginStatus() {
-            return new Map(this.pluginStatus);
-        }
-        /**
-       * 获取插件沙箱
-       *
-       * @param name - 插件名称
-       * @returns 插件沙箱或undefined
-       */ getSandbox(name) {
-            return this.sandboxes.get(name);
-        }
-        /**
-       * 获取事件总线
-       */ getEventBus() {
-            return pluginEventBus;
-        }
-        /**
-       * 销毁所有插件
-       */ async destroyAll() {
-            for (const plugin of this.plugins.values()){
-                if (plugin.destroy) {
-                    try {
-                        await plugin.destroy();
-                    } catch (error) {
-                        console.error(`插件 ${plugin.name} 的 destroy 钩子执行失败:`, error);
-                    }
-                }
-            }
-            this.plugins.clear();
+       * 销毁所有插件
+       */ async destroyAll() {
+            for (const plugin of this.plugins.values()){
+                if (plugin.destroy) {
+                    try {
+                        await plugin.destroy();
+                    } catch (error) {
+                        console.error(`插件 ${plugin.name} 的 destroy 钩子执行失败:`, error);
+                    }
+                }
+            }
+            this.plugins.clear();
         }
         constructor(){
-            _define_property$F(this, "plugins", new Map());
-            _define_property$F(this, "sandboxes", new Map());
-            _define_property$F(this, "pluginStatus", new Map());
-            _define_property$F(this, "pluginLoaders", new Map());
+            _define_property$G(this, "plugins", new Map());
+            _define_property$G(this, "sandboxes", new Map());
+            _define_property$G(this, "pluginStatus", new Map());
+            _define_property$G(this, "pluginLoaders", new Map());
         }
     }
     /**
@@ -1719,7 +1330,7 @@
         }
     }
 
-    function _define_property$E(obj, key, value) {
+    function _define_property$F(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -1740,7 +1351,7 @@
         /**
        * 设置错误
        */ setError(error) {
-            this.error = utils.errorUtils.normalizeError(error);
+            this.error = vlianUtils.errorUtils.normalizeError(error);
             // 通知所有监听器
             this.listeners.forEach((listener)=>listener());
         }
@@ -1769,8 +1380,8 @@
             return this.error !== null;
         }
         constructor(){
-            _define_property$E(this, "error", null);
-            _define_property$E(this, "listeners", new Set());
+            _define_property$F(this, "error", null);
+            _define_property$F(this, "listeners", new Set());
         }
     };
     /**
@@ -2120,7 +1731,7 @@
         return true;
     }
 
-    function _define_property$D(obj, key, value) {
+    function _define_property$E(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -2173,7 +1784,7 @@
             return this.middlewares.length;
         }
         constructor(){
-            _define_property$D(this, "middlewares", []);
+            _define_property$E(this, "middlewares", []);
         }
     }
     /**
@@ -2182,7 +1793,7 @@
 
     /**
      * 状态实例核心实现
-     */ function _define_property$C(obj, key, value) {
+     */ function _define_property$D(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -2314,25 +1925,25 @@
        */ constructor(initialValue, options = {}){
             /**
        * 状态实例标识符
-       */ _define_property$C(this, "id", void 0);
+       */ _define_property$D(this, "id", void 0);
             /**
        * 状态作用域
-       */ _define_property$C(this, "scope", void 0);
+       */ _define_property$D(this, "scope", void 0);
             /**
        * 当前状态值
-       */ _define_property$C(this, "value", void 0);
+       */ _define_property$D(this, "value", void 0);
             /**
        * 订阅者集合
-       */ _define_property$C(this, "subscribers", new Set());
+       */ _define_property$D(this, "subscribers", new Set());
             /**
        * 是否已销毁
-       */ _define_property$C(this, "destroyed", false);
+       */ _define_property$D(this, "destroyed", false);
             /**
        * 开发模式标志
-       */ _define_property$C(this, "devMode", void 0);
+       */ _define_property$D(this, "devMode", void 0);
             /**
        * 中间件函数数组
-       */ _define_property$C(this, "middleware", void 0);
+       */ _define_property$D(this, "middleware", void 0);
             this.value = initialValue;
             this.id = options.id ?? Symbol('StateInstance');
             this.scope = options.scope;
@@ -2349,7 +1960,7 @@
 
     /**
      * 状态作用域管理
-     */ function _define_property$B(obj, key, value) {
+     */ function _define_property$C(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -2472,16 +2083,16 @@
         constructor(){
             /**
        * 作用域到状态实例的映射
-       */ _define_property$B(this, "scopeMap", new Map());
+       */ _define_property$C(this, "scopeMap", new Map());
             /**
        * 状态实例到作用域的映射（用于快速查找）
-       */ _define_property$B(this, "instanceToScopeMap", new Map());
+       */ _define_property$C(this, "instanceToScopeMap", new Map());
         }
     }
 
     /**
      * 状态注册表实现
-     */ function _define_property$A(obj, key, value) {
+     */ function _define_property$B(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -2575,17 +2186,17 @@
        */ constructor(){
             /**
        * 状态实例映射表（ID -> Instance）
-       */ _define_property$A(this, "instances", new Map());
+       */ _define_property$B(this, "instances", new Map());
             /**
        * 作用域管理器
-       */ _define_property$A(this, "scopeManager", void 0);
+       */ _define_property$B(this, "scopeManager", void 0);
             this.scopeManager = new StateScopeManager();
         }
     }
 
     /**
      * 派生状态实例实现
-     */ function _define_property$z(obj, key, value) {
+     */ function _define_property$A(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -2723,28 +2334,28 @@
        */ constructor(config, options = {}){
             /**
        * 状态实例标识符
-       */ _define_property$z(this, "id", void 0);
+       */ _define_property$A(this, "id", void 0);
             /**
        * 状态作用域
-       */ _define_property$z(this, "scope", void 0);
+       */ _define_property$A(this, "scope", void 0);
             /**
        * 派生状态配置
-       */ _define_property$z(this, "config", void 0);
+       */ _define_property$A(this, "config", void 0);
             /**
        * 当前派生值
-       */ _define_property$z(this, "value", void 0);
+       */ _define_property$A(this, "value", void 0);
             /**
        * 订阅者集合
-       */ _define_property$z(this, "subscribers", new Set());
+       */ _define_property$A(this, "subscribers", new Set());
             /**
        * 依赖状态的取消订阅函数数组
-       */ _define_property$z(this, "dependencyUnsubscribes", []);
+       */ _define_property$A(this, "dependencyUnsubscribes", []);
             /**
        * 是否已销毁
-       */ _define_property$z(this, "destroyed", false);
+       */ _define_property$A(this, "destroyed", false);
             /**
        * 是否正在重新计算
-       */ _define_property$z(this, "recomputing", false);
+       */ _define_property$A(this, "recomputing", false);
             this.config = config;
             this.id = options.id ?? Symbol('DerivedStateInstance');
             this.scope = options.scope;
@@ -2760,7 +2371,7 @@
      * 
      * 这是 Secra Framework 内置的默认状态适配器实现
      * 不依赖任何外部状态管理库，提供基础的状态管理能力
-     */ function _define_property$y(obj, key, value) {
+     */ function _define_property$z(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -2814,19 +2425,19 @@
         constructor(){
             /**
        * 适配器名称
-       */ _define_property$y(this, "name", 'DefaultAdapter');
+       */ _define_property$z(this, "name", 'DefaultAdapter');
             /**
        * 是否已销毁
-       */ _define_property$y(this, "destroyed", false);
+       */ _define_property$z(this, "destroyed", false);
             /**
        * 创建的状态实例集合（用于销毁时清理）
-       */ _define_property$y(this, "instances", new Set());
+       */ _define_property$z(this, "instances", new Set());
         }
     }
 
     /**
      * 状态适配器工厂
-     */ function _define_property$x(obj, key, value) {
+     */ function _define_property$y(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -2902,10 +2513,10 @@
     }
     /**
        * 默认适配器实例
-       */ _define_property$x(AdapterFactory, "defaultAdapter", null);
+       */ _define_property$y(AdapterFactory, "defaultAdapter", null);
     /**
        * 自定义适配器映射
-       */ _define_property$x(AdapterFactory, "customAdapters", new Map());
+       */ _define_property$y(AdapterFactory, "customAdapters", new Map());
 
     /**
      * Redux Toolkit 适配器
@@ -2928,7 +2539,7 @@
      * state.set(1);
      * console.log(state.get()); // 1
      * ```
-     */ function _define_property$w(obj, key, value) {
+     */ function _define_property$x(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -3086,37 +2697,37 @@
        */ constructor(store, sliceName, actions, initialValue, options = {}){
             /**
        * 状态实例标识符
-       */ _define_property$w(this, "id", void 0);
+       */ _define_property$x(this, "id", void 0);
             /**
        * 状态作用域
-       */ _define_property$w(this, "scope", void 0);
+       */ _define_property$x(this, "scope", void 0);
             /**
        * Redux store 引用
-       */ _define_property$w(this, "store", void 0);
+       */ _define_property$x(this, "store", void 0);
             /**
        * Redux slice 名称（在 store 中的路径）
-       */ _define_property$w(this, "sliceName", void 0);
+       */ _define_property$x(this, "sliceName", void 0);
             /**
        * Redux slice actions
-       */ _define_property$w(this, "actions", void 0);
+       */ _define_property$x(this, "actions", void 0);
             /**
        * 订阅者集合
-       */ _define_property$w(this, "subscribers", new Set());
+       */ _define_property$x(this, "subscribers", new Set());
             /**
        * Redux store 订阅取消函数
-       */ _define_property$w(this, "unsubscribeStore", void 0);
+       */ _define_property$x(this, "unsubscribeStore", void 0);
             /**
        * 是否已销毁
-       */ _define_property$w(this, "destroyed", false);
+       */ _define_property$x(this, "destroyed", false);
             /**
        * 开发模式标志
-       */ _define_property$w(this, "devMode", void 0);
+       */ _define_property$x(this, "devMode", void 0);
             /**
        * 中间件函数数组
-       */ _define_property$w(this, "middleware", void 0);
+       */ _define_property$x(this, "middleware", void 0);
             /**
        * 上一次的状态值（用于订阅通知）
-       */ _define_property$w(this, "previousValue", void 0);
+       */ _define_property$x(this, "previousValue", void 0);
             this.store = store;
             this.sliceName = sliceName;
             this.actions = actions;
@@ -3168,10 +2779,10 @@
        */ constructor(){
             /**
        * 当前 reducer 映射
-       */ _define_property$w(this, "reducers", new Map());
+       */ _define_property$x(this, "reducers", new Map());
             /**
        * 根 reducer 函数
-       */ _define_property$w(this, "rootReducer", void 0);
+       */ _define_property$x(this, "rootReducer", void 0);
             this.rootReducer = (state, action)=>{
                 const stateRecord = state ?? {};
                 const newState = {
@@ -3315,28 +2926,28 @@
        */ constructor(options){
             /**
        * 适配器名称
-       */ _define_property$w(this, "name", 'ReduxAdapter');
+       */ _define_property$x(this, "name", 'ReduxAdapter');
             /**
        * 是否已销毁
-       */ _define_property$w(this, "destroyed", false);
+       */ _define_property$x(this, "destroyed", false);
             /**
        * 创建的状态实例集合
-       */ _define_property$w(this, "instances", new Set());
+       */ _define_property$x(this, "instances", new Set());
             /**
        * Redux store 实例
-       */ _define_property$w(this, "store", null);
+       */ _define_property$x(this, "store", null);
             /**
        * Redux slice 名称计数器（用于生成唯一的 slice 名称）
-       */ _define_property$w(this, "sliceCounter", 0);
+       */ _define_property$x(this, "sliceCounter", 0);
             /**
        * Redux slice 名称到状态实例的映射
-       */ _define_property$w(this, "sliceToInstance", new Map());
+       */ _define_property$x(this, "sliceToInstance", new Map());
             /**
        * 动态 reducer 管理器
-       */ _define_property$w(this, "reducerManager", void 0);
+       */ _define_property$x(this, "reducerManager", void 0);
             /**
        * 是否启用开发模式
-       */ _define_property$w(this, "devMode", void 0);
+       */ _define_property$x(this, "devMode", void 0);
             this.devMode = options?.devMode ?? false;
             this.reducerManager = new DynamicReducerManager();
             this.store = options?.store ?? null;
@@ -3351,7 +2962,7 @@
      * 这是一个适配器接口示例，展示如何将 Zustand 集成到 Secra 状态管理器
      * 
      * ⚠️ 注意：这是一个占位实现，实际使用时需要安装 zustand 依赖
-     */ function _define_property$v(obj, key, value) {
+     */ function _define_property$w(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -3404,13 +3015,13 @@
         constructor(){
             /**
        * 适配器名称
-       */ _define_property$v(this, "name", 'ZustandAdapter');
+       */ _define_property$w(this, "name", 'ZustandAdapter');
             /**
        * 是否已销毁
-       */ _define_property$v(this, "destroyed", false);
+       */ _define_property$w(this, "destroyed", false);
             /**
        * 创建的状态实例集合
-       */ _define_property$v(this, "instances", new Set());
+       */ _define_property$w(this, "instances", new Set());
         }
     }
 
@@ -3418,7 +3029,7 @@
      * 状态管理器主类
      * 
      * 这是状态管理器的核心入口，提供统一的状态管理 API
-     */ function _define_property$u(obj, key, value) {
+     */ function _define_property$v(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -3543,19 +3154,19 @@
        */ constructor(options = {}){
             /**
        * 默认适配器
-       */ _define_property$u(this, "adapter", void 0);
+       */ _define_property$v(this, "adapter", void 0);
             /**
        * 状态注册表（如果启用）
-       */ _define_property$u(this, "registry", void 0);
+       */ _define_property$v(this, "registry", void 0);
             /**
        * 默认作用域
-       */ _define_property$u(this, "defaultScope", void 0);
+       */ _define_property$v(this, "defaultScope", void 0);
             /**
        * 是否启用开发模式
-       */ _define_property$u(this, "devMode", void 0);
+       */ _define_property$v(this, "devMode", void 0);
             /**
        * 是否已销毁
-       */ _define_property$u(this, "destroyed", false);
+       */ _define_property$v(this, "destroyed", false);
             this.adapter = options.defaultAdapter ?? AdapterFactory.getDefaultAdapter();
             this.defaultScope = options.defaultScope;
             this.devMode = options.devMode ?? false;
@@ -3570,7 +3181,7 @@
         }
     }
 
-    function _define_property$t(obj, key, value) {
+    function _define_property$u(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -3970,25 +3581,25 @@
             /**
        * 事件监听器映射表
        * 使用 Map + Set 结构提高性能
-       */ _define_property$t(this, "listeners", new Map());
+       */ _define_property$u(this, "listeners", new Map());
             /**
        * 事件历史记录
-       */ _define_property$t(this, "eventHistory", []);
+       */ _define_property$u(this, "eventHistory", []);
             /**
        * 事件中间件列表
-       */ _define_property$t(this, "middlewares", []);
+       */ _define_property$u(this, "middlewares", []);
             /**
        * 事件统计信息
-       */ _define_property$t(this, "stats", new Map());
+       */ _define_property$u(this, "stats", new Map());
             /**
        * 配置
-       */ _define_property$t(this, "config", void 0);
+       */ _define_property$u(this, "config", void 0);
             /**
        * 事件计数器（用于生成唯一事件ID）
-       */ _define_property$t(this, "eventCounter", 0);
+       */ _define_property$u(this, "eventCounter", 0);
             /**
        * 监听器ID计数器
-       */ _define_property$t(this, "listenerIdCounter", 0);
+       */ _define_property$u(this, "listenerIdCounter", 0);
             this.config = {
                 enableTracking: config.enableTracking ?? process.env.NODE_ENV === 'development',
                 maxHistorySize: config.maxHistorySize ?? 100,
@@ -4094,7 +3705,7 @@
         ]);
         logger.logger.info('关键服务初始化完成');
         // 初始化性能监控（依赖监控服务，必须在监控服务初始化后）
-        const performanceMonitor = new utils.PerformanceMonitor({
+        const performanceMonitor = new vlianUtils.PerformanceMonitor({
             ...options.performanceMonitor,
             onReport: (metrics)=>{
                 monitoring$1.reportPerformance(metrics);
@@ -4181,7 +3792,7 @@
         };
     }
 
-    function _define_property$s(obj, key, value) {
+    function _define_property$t(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -4299,7 +3910,7 @@
         /**
          * 私有构造函数，防止外部直接实例化
          */ constructor(){
-            _define_property$s(this, "_config", void 0);
+            _define_property$t(this, "_config", void 0);
             this._config = {
                 theme: {
                     mode: 'light'
@@ -4308,7 +3919,7 @@
             };
         }
     };
-    _define_property$s(AppConfigManager, "instance", null);
+    _define_property$t(AppConfigManager, "instance", null);
     /**
      * 应用配置单例实例
      */ const appConfig = AppConfigManager.getInstance();
@@ -4914,7 +4525,7 @@
       return r.length !== e.length || r.some((t, o) => !Object.is(t, e[o]));
     }
 
-    function _define_property$r(obj, key, value) {
+    function _define_property$s(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -4943,9 +4554,9 @@
        * @returns 错误处理结果
        */ async handleError(error, context) {
             // 标准化错误对象
-            const normalizedError = utils.errorUtils.normalizeError(error);
+            const normalizedError = vlianUtils.errorUtils.normalizeError(error);
             // 创建包含上下文信息的错误对象（由于 context 是只读的，需要创建新对象）
-            const errorWithContext = context ? new utils.FrameworkError(normalizedError.message, normalizedError.type, normalizedError.severity, {
+            const errorWithContext = context ? new vlianUtils.FrameworkError(normalizedError.message, normalizedError.type, normalizedError.severity, {
                 code: normalizedError.code,
                 originalError: normalizedError.originalError,
                 context: {
@@ -5025,23 +4636,23 @@
         /**
        * 记录错误
        */ logError(error) {
-            const errorInfo = utils.errorUtils.extractErrorInfo(error);
+            const errorInfo = vlianUtils.errorUtils.extractErrorInfo(error);
             // 根据错误严重程度选择日志级别
             switch(error.severity){
-                case utils.ErrorSeverity.CRITICAL:
-                case utils.ErrorSeverity.HIGH:
+                case vlianUtils.ErrorSeverity.CRITICAL:
+                case vlianUtils.ErrorSeverity.HIGH:
                     logger.logger.error('错误:', errorInfo);
                     break;
-                case utils.ErrorSeverity.MEDIUM:
+                case vlianUtils.ErrorSeverity.MEDIUM:
                     logger.logger.warn('警告:', errorInfo);
                     break;
-                case utils.ErrorSeverity.LOW:
+                case vlianUtils.ErrorSeverity.LOW:
                     logger.logger.info('信息:', errorInfo);
                     break;
             }
             // 开发环境显示详细错误信息
             if (this.config.showDetailedErrorsInDev && process.env.NODE_ENV === 'development') {
-                const detailedError = utils.errorUtils.formatErrorForDev(error);
+                const detailedError = vlianUtils.errorUtils.formatErrorForDev(error);
                 console.error(detailedError);
             }
         }
@@ -5113,8 +4724,8 @@
             return new ErrorHandler(config);
         }
         constructor(config = {}){
-            _define_property$r(this, "config", void 0);
-            _define_property$r(this, "monitoring", void 0);
+            _define_property$s(this, "config", void 0);
+            _define_property$s(this, "monitoring", void 0);
             this.monitoring = config.monitoring;
             this.config = {
                 defaultStrategies: config.defaultStrategies ?? [
@@ -5176,7 +4787,7 @@
         const errorHandler = React.useMemo(()=>getDefaultErrorHandler(), []);
         // 处理错误，将标准 Error 转换为 FrameworkError
         const handleError = React.useCallback(async (error, errorInfo)=>{
-            const normalizedError = utils.errorUtils.normalizeError(error);
+            const normalizedError = vlianUtils.errorUtils.normalizeError(error);
             // 将 react-error-boundary 的 errorInfo 转换为 React 的 ErrorInfo 格式
             const reactErrorInfo = {
                 componentStack: errorInfo.componentStack || ''
@@ -5221,7 +4832,7 @@
         // 默认 fallback UI（使用无框架 HTML 组件）
         // 使用内部组件来管理重试计数状态，使用 React.memo 优化性能
         const DefaultFallbackComponent = /*#__PURE__*/ React.memo(({ error, resetErrorBoundary })=>{
-            const normalizedError = utils.errorUtils.normalizeError(error);
+            const normalizedError = vlianUtils.errorUtils.normalizeError(error);
             const [retryCount, setRetryCount] = React.useState(retryCountRef.current);
             const [showDetails, setShowDetails] = React.useState(false);
             // 同步 ref 的值到 state，确保组件重新创建时能读取到最新的重试计数
@@ -5451,7 +5062,7 @@
         };
         // 如果提供了自定义 fallback，使用自定义的
         const fallbackRender = fallback ? ({ error, resetErrorBoundary })=>{
-            const normalizedError = utils.errorUtils.normalizeError(error);
+            const normalizedError = vlianUtils.errorUtils.normalizeError(error);
             return fallback(normalizedError, ()=>{
                 handleReset();
                 resetErrorBoundary();
@@ -5531,7 +5142,7 @@
         };
     }
 
-    function _define_property$q(obj, key, value) {
+    function _define_property$r(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -5590,8 +5201,8 @@
             }
         }
         constructor(maxSize = 50){
-            _define_property$q(this, "cache", new Map());
-            _define_property$q(this, "maxSize", void 0);
+            _define_property$r(this, "cache", new Map());
+            _define_property$r(this, "maxSize", void 0);
             this.maxSize = maxSize;
         }
     };
@@ -5829,7 +5440,7 @@
             }
         }
         // 使用 SecurityUtils 验证输入（最后检查，因为可能较慢）
-        const validation = utils.SecurityUtils.validateInput(path);
+        const validation = vlianUtils.SecurityUtils.validateInput(path);
         if (!validation.safe) {
             return {
                 valid: false,
@@ -5940,7 +5551,7 @@
             if (!validation.valid) {
                 // 生产环境错误信息脱敏
                 const errorMessage = process.env.NODE_ENV === 'development' ? `路径验证失败: ${validation.error}` : '路径验证失败';
-                const error = new utils.SecurityError(errorMessage, undefined, process.env.NODE_ENV === 'development' ? {
+                const error = new vlianUtils.SecurityError(errorMessage, undefined, process.env.NODE_ENV === 'development' ? {
                     path: normalizedPath
                 } : {});
                 if (options.enableDebugLog) {
@@ -5985,8 +5596,8 @@
             }
         }
         constructor(){
-            _define_property$q(this, "pool", []);
-            _define_property$q(this, "maxPoolSize", 100);
+            _define_property$r(this, "pool", []);
+            _define_property$r(this, "maxPoolSize", 100);
         }
     };
     const stackNodePool = new StackNodePool();
@@ -6201,7 +5812,7 @@
         } catch (error) {
             const err = error instanceof Error ? error : new Error('路由配置加载失败');
             logger.logger.error('路由配置加载失败:', err);
-            throw new utils.ValidationError('路由配置加载失败', {
+            throw new vlianUtils.ValidationError('路由配置加载失败', {
                 originalError: err
             });
         }
@@ -6313,7 +5924,7 @@
         } catch (error) {
             const err = error instanceof Error ? error : new Error('路由转换失败');
             logger.logger.error('路由转换失败:', err);
-            throw new utils.ValidationError('路由转换失败', {
+            throw new vlianUtils.ValidationError('路由转换失败', {
                 originalError: err
             });
         }
@@ -6816,7 +6427,7 @@
         return routerConfigSchema.safeParse(config);
     }
 
-    function _define_property$p(obj, key, value) {
+    function _define_property$q(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -6833,7 +6444,7 @@
      * 配置验证错误
      */ class ConfigValidationError extends Error {
         constructor(message, errors){
-            super(message), _define_property$p(this, "errors", void 0), this.errors = errors;
+            super(message), _define_property$q(this, "errors", void 0), this.errors = errors;
             this.name = 'ConfigValidationError';
         }
     }
@@ -7002,7 +6613,7 @@
         }
     }
 
-    function _define_property$o(obj, key, value) {
+    function _define_property$p(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -7114,7 +6725,7 @@
             return this.hooks.length;
         }
         constructor(){
-            _define_property$o(this, "hooks", []);
+            _define_property$p(this, "hooks", []);
         }
     }
     /**
@@ -7127,7 +6738,7 @@
         return lifecycleManagerInstance;
     }
 
-    function _define_property$n(obj, key, value) {
+    function _define_property$o(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -7287,10 +6898,10 @@
             return this.middlewares.length;
         }
         constructor(){
-            _define_property$n(this, "middlewares", []);
+            _define_property$o(this, "middlewares", []);
         }
     }
-    _define_property$n(RouterMiddlewareManager, "SAFE_REDIRECT_PATH_REGEX", /^(\/|\.\/|\.\.\/|#)/);
+    _define_property$o(RouterMiddlewareManager, "SAFE_REDIRECT_PATH_REGEX", /^(\/|\.\/|\.\.\/|#)/);
     /**
      * 获取路由中间件管理器单例
      */ let middlewareManagerInstance = null;
@@ -7388,9 +6999,9 @@
     }({});
     /**
      * 路由错误
-     */ class RouterError extends utils.FrameworkError {
-        constructor(message, code, severity = utils.ErrorSeverity.MEDIUM, cause, context){
-            super(message, utils.ErrorType.RUNTIME, severity, {
+     */ class RouterError extends vlianUtils.FrameworkError {
+        constructor(message, code, severity = vlianUtils.ErrorSeverity.MEDIUM, cause, context){
+            super(message, vlianUtils.ErrorType.RUNTIME, severity, {
                 code,
                 originalError: cause,
                 context: context || {}
@@ -7404,7 +7015,7 @@
         return new RouterError(message, code, severity, cause, context);
     }
 
-    function _define_property$m(obj, key, value) {
+    function _define_property$n(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -7642,12 +7253,12 @@
             };
         }
         constructor(config = {}){
-            _define_property$m(this, "cache", new Map());
-            _define_property$m(this, "matchCache", new Map());
-            _define_property$m(this, "config", void 0);
-            _define_property$m(this, "persistenceEnabled", false);
-            _define_property$m(this, "cleanupTimer", null);
-            _define_property$m(this, "stats", {
+            _define_property$n(this, "cache", new Map());
+            _define_property$n(this, "matchCache", new Map());
+            _define_property$n(this, "config", void 0);
+            _define_property$n(this, "persistenceEnabled", false);
+            _define_property$n(this, "cleanupTimer", null);
+            _define_property$n(this, "stats", {
                 transformHits: 0,
                 transformMisses: 0,
                 matchHits: 0,
@@ -7677,7 +7288,7 @@
         return routeCacheInstance;
     }
 
-    function _define_property$l(obj, key, value) {
+    function _define_property$m(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -7927,10 +7538,10 @@
             return stats;
         }
         constructor(config = {}){
-            _define_property$l(this, "tasks", new Map());
-            _define_property$l(this, "config", void 0);
-            _define_property$l(this, "preloadTimer", null);
-            _define_property$l(this, "idleHandle", null);
+            _define_property$m(this, "tasks", new Map());
+            _define_property$m(this, "config", void 0);
+            _define_property$m(this, "preloadTimer", null);
+            _define_property$m(this, "idleHandle", null);
             this.config = {
                 strategy: config.strategy ?? "none",
                 delay: config.delay ?? 1000,
@@ -7981,7 +7592,7 @@
         return PluginLifecycleStage;
     }({});
 
-    function _define_property$k(obj, key, value) {
+    function _define_property$l(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -8210,7 +7821,7 @@
             return this.plugins.size;
         }
         constructor(){
-            _define_property$k(this, "plugins", new Map());
+            _define_property$l(this, "plugins", new Map());
         }
     }
     /**
@@ -8223,7 +7834,7 @@
         return pluginManagerInstance;
     }
 
-    function _define_property$j(obj, key, value) {
+    function _define_property$k(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -8404,12 +8015,12 @@
             };
         }
         constructor(config = {}){
-            _define_property$j(this, "accessRecords", []);
-            _define_property$j(this, "performanceMetrics", new Map());
-            _define_property$j(this, "config", void 0);
-            _define_property$j(this, "monitoringService", monitoring.getMonitoring());
-            _define_property$j(this, "currentRouteStartTime", 0);
-            _define_property$j(this, "currentRoute", void 0);
+            _define_property$k(this, "accessRecords", []);
+            _define_property$k(this, "performanceMetrics", new Map());
+            _define_property$k(this, "config", void 0);
+            _define_property$k(this, "monitoringService", monitoring.getMonitoring());
+            _define_property$k(this, "currentRouteStartTime", 0);
+            _define_property$k(this, "currentRoute", void 0);
             this.config = {
                 enabled: config.enabled ?? true,
                 trackAccess: config.trackAccess ?? true,
@@ -8430,7 +8041,7 @@
         return routerMonitoringInstance;
     }
 
-    function _define_property$i(obj, key, value) {
+    function _define_property$j(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -8630,9 +8241,9 @@
             return this.adapters.size;
         }
         constructor(){
-            _define_property$i(this, "adapters", new Map());
-            _define_property$i(this, "currentAdapter", null);
-            _define_property$i(this, "defaultAdapterName", null);
+            _define_property$j(this, "adapters", new Map());
+            _define_property$j(this, "currentAdapter", null);
+            _define_property$j(this, "defaultAdapterName", null);
         }
     }
     /**
@@ -8647,7 +8258,7 @@
 
     /**
      * React Router 适配器实现
-     */ function _define_property$h(obj, key, value) {
+     */ function _define_property$i(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -8743,9 +8354,9 @@
             logger.logger.debug('React Router 适配器已销毁');
         }
         constructor(){
-            _define_property$h(this, "name", 'react-router');
-            _define_property$h(this, "version", '6.0.0');
-            _define_property$h(this, "router", null);
+            _define_property$i(this, "name", 'react-router');
+            _define_property$i(this, "version", '6.0.0');
+            _define_property$i(this, "router", null);
         }
     }
     /**
@@ -8756,7 +8367,7 @@
         };
     }
 
-    function _define_property$g(obj, key, value) {
+    function _define_property$h(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -8978,25 +8589,25 @@
             /**
          * 路由实例
          * 只能在 initialize 方法中赋值
-         */ _define_property$g(this, "router", null);
+         */ _define_property$h(this, "router", null);
             /**
          * 是否已初始化
-         */ _define_property$g(this, "initialized", false);
+         */ _define_property$h(this, "initialized", false);
             /**
          * 路由缓存实例
-         */ _define_property$g(this, "cache", getRouteCache());
+         */ _define_property$h(this, "cache", getRouteCache());
             /**
          * 路由预加载器实例
-         */ _define_property$g(this, "preloader", getRoutePreloader());
+         */ _define_property$h(this, "preloader", getRoutePreloader());
             /**
          * 路由插件管理器实例
-         */ _define_property$g(this, "pluginManager", getRouterPluginManager());
+         */ _define_property$h(this, "pluginManager", getRouterPluginManager());
             /**
          * 路由监控服务实例
-         */ _define_property$g(this, "monitoring", getRouterMonitoring());
+         */ _define_property$h(this, "monitoring", getRouterMonitoring());
             /**
          * 路由适配器管理器实例
-         */ _define_property$g(this, "adapterManager", getAdapterManager());
+         */ _define_property$h(this, "adapterManager", getAdapterManager());
             // 私有构造函数
             // 注册默认的 React Router 适配器
             this.adapterManager.register({
@@ -9006,7 +8617,7 @@
             });
         }
     }
-    _define_property$g(RouterManager, "instance", null);
+    _define_property$h(RouterManager, "instance", null);
     /**
      * 获取路由管理器
      */ function getRouterManager() {
@@ -9019,7 +8630,7 @@
         getRouterManager: getRouterManager
     });
 
-    function _define_property$f(obj, key, value) {
+    function _define_property$g(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -9147,7 +8758,7 @@
                 Promise.resolve().then(()=>{
                     try {
                         const configStr = JSON.stringify(options);
-                        const validation = utils.SecurityUtils.validateInput(configStr);
+                        const validation = vlianUtils.SecurityUtils.validateInput(configStr);
                         if (!validation.safe) {
                             services.monitoring.captureError(new Error('配置项包含不安全内容'), {
                                 reason: validation.reason
@@ -9267,15 +8878,15 @@
             return this.container;
         }
         constructor(){
-            _define_property$f(this, "root", null);
-            _define_property$f(this, "container", null);
+            _define_property$g(this, "root", null);
+            _define_property$g(this, "container", null);
         }
     }
 
     /**
      * 性能追踪模块
      * 负责收集和上报启动性能指标
-     */ function _define_property$e(obj, key, value) {
+     */ function _define_property$f(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -9430,9 +9041,9 @@
             return performance.now() - this.startTime;
         }
         constructor(monitoring){
-            _define_property$e(this, "monitoring", void 0);
-            _define_property$e(this, "metrics", {});
-            _define_property$e(this, "startTime", void 0);
+            _define_property$f(this, "monitoring", void 0);
+            _define_property$f(this, "metrics", {});
+            _define_property$f(this, "startTime", void 0);
             this.monitoring = monitoring;
             this.startTime = performance.now();
         }
@@ -9441,7 +9052,7 @@
     /**
      * 应用实例管理模块
      * 支持多实例隔离
-     */ function _define_property$d(obj, key, value) {
+     */ function _define_property$e(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -9533,25 +9144,25 @@
         constructor(id, options){
             /**
        * 实例ID
-       */ _define_property$d(this, "id", void 0);
+       */ _define_property$e(this, "id", void 0);
             /**
        * 应用渲染器
-       */ _define_property$d(this, "renderer", void 0);
+       */ _define_property$e(this, "renderer", void 0);
             /**
        * 服务实例
-       */ _define_property$d(this, "services", null);
+       */ _define_property$e(this, "services", null);
             /**
        * 性能追踪器
-       */ _define_property$d(this, "performanceTracker", null);
+       */ _define_property$e(this, "performanceTracker", null);
             /**
        * 启动配置
-       */ _define_property$d(this, "options", void 0);
+       */ _define_property$e(this, "options", void 0);
             /**
        * 是否已初始化
-       */ _define_property$d(this, "initialized", false);
+       */ _define_property$e(this, "initialized", false);
             /**
        * 是否已销毁
-       */ _define_property$d(this, "destroyed", false);
+       */ _define_property$e(this, "destroyed", false);
             this.id = id;
             this.options = options;
             this.renderer = new AppRenderer();
@@ -9649,19 +9260,19 @@
             this.defaultInstanceId = null;
         }
         constructor(){
-            _define_property$d(this, "instances", new Map());
-            _define_property$d(this, "defaultInstanceId", null);
+            _define_property$e(this, "instances", new Map());
+            _define_property$e(this, "defaultInstanceId", null);
         // 私有构造函数
         }
     }
-    _define_property$d(AppInstanceManager, "instance", null);
+    _define_property$e(AppInstanceManager, "instance", null);
     /**
      * 获取应用实例管理器
      */ function getAppInstanceManager() {
         return AppInstanceManager.getInstance();
     }
 
-    function _define_property$c(obj, key, value) {
+    function _define_property$d(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -9797,17 +9408,17 @@
             }
         }
         constructor(){
-            _define_property$c(this, "environment", void 0);
-            _define_property$c(this, "isBrowser", void 0);
-            _define_property$c(this, "isSSR", void 0);
-            _define_property$c(this, "isMicroFrontend", void 0);
+            _define_property$d(this, "environment", void 0);
+            _define_property$d(this, "isBrowser", void 0);
+            _define_property$d(this, "isSSR", void 0);
+            _define_property$d(this, "isMicroFrontend", void 0);
             this.isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
             this.isSSR = typeof window === 'undefined' && typeof process !== 'undefined';
             this.isMicroFrontend = this.detectMicroFrontend();
             this.environment = this.detectEnvironment();
         }
     }
-    _define_property$c(EnvironmentDetector, "instance", null);
+    _define_property$d(EnvironmentDetector, "instance", null);
     /**
      * 获取环境检测器实例
      */ function getEnvironmentDetector() {
@@ -9872,7 +9483,7 @@
     /**
      * 框架生命周期事件集成
      * 自动在框架关键节点触发事件
-     */ function _define_property$b(obj, key, value) {
+     */ function _define_property$c(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -9997,12 +9608,12 @@
             });
         }
         constructor(eventBus){
-            _define_property$b(this, "eventBus", void 0);
+            _define_property$c(this, "eventBus", void 0);
             this.eventBus = eventBus;
         }
     }
 
-    function _define_property$a(obj, key, value) {
+    function _define_property$b(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -10024,7 +9635,7 @@
     }
     class KernelBootError extends Error {
         constructor(message, options){
-            super(message), _define_property$a(this, "code", void 0), _define_property$a(this, "phase", void 0), _define_property$a(this, "severity", void 0), _define_property$a(this, "retryable", void 0), _define_property$a(this, "traceId", void 0), _define_property$a(this, "cause", void 0);
+            super(message), _define_property$b(this, "code", void 0), _define_property$b(this, "phase", void 0), _define_property$b(this, "severity", void 0), _define_property$b(this, "retryable", void 0), _define_property$b(this, "traceId", void 0), _define_property$b(this, "cause", void 0);
             this.name = 'KernelBootError';
             this.code = options.code;
             this.phase = options.phase;
@@ -10054,7 +9665,7 @@
         });
     }
 
-    function _define_property$9(obj, key, value) {
+    function _define_property$a(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -10131,7 +9742,7 @@
             }
         }
         constructor(){
-            _define_property$9(this, "instance", null);
+            _define_property$a(this, "instance", null);
         }
     };
     let DefaultEventBusAdapter = class DefaultEventBusAdapter {
@@ -10163,7 +9774,7 @@
             }
         }
         constructor(){
-            _define_property$9(this, "bus", null);
+            _define_property$a(this, "bus", null);
         }
     };
     const defaultI18nAdapter = {
@@ -10432,9 +10043,9 @@
             // 1. 环境检测和容器获取
             const container = options.container || envDetector.safeGetElement('#root');
             if (!container) {
-                throw new utils.InitializationError('未找到挂载容器', undefined, {
+                throw new vlianUtils.InitializationError('未找到挂载容器', undefined, {
                     container: options.container
-                }, utils.ErrorCode.CONTAINER_NOT_FOUND);
+                }, vlianUtils.ErrorCode.CONTAINER_NOT_FOUND);
             }
             logger.logger.info('框架启动中...');
             if (options.antd && !options.uiProvider) {
@@ -10710,7 +10321,7 @@
         }
     }
 
-    function _define_property$8(obj, key, value) {
+    function _define_property$9(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -10764,7 +10375,7 @@
             this.listeners.clear();
         }
         constructor(){
-            _define_property$8(this, "listeners", new Set());
+            _define_property$9(this, "listeners", new Set());
         }
     };
     /**
@@ -11015,7 +10626,7 @@
         }
     }
 
-    function _define_property$7(obj, key, value) {
+    function _define_property$8(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -11198,9 +10809,9 @@
             });
         }
     }
-    _define_property$7(RouterNavigation, "MAX_REDIRECTS", 10);
+    _define_property$8(RouterNavigation, "MAX_REDIRECTS", 10);
 
-    function _define_property$6(obj, key, value) {
+    function _define_property$7(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -11357,8 +10968,8 @@
             logger.logger.info('路由重新加载完成');
         }
         constructor(){
-            _define_property$6(this, "registeredRoutes", new Map());
-            _define_property$6(this, "routeVersion", 0);
+            _define_property$7(this, "registeredRoutes", new Map());
+            _define_property$7(this, "routeVersion", 0);
         }
     }
     /**
@@ -11371,7 +10982,7 @@
         return dynamicRouteManagerInstance;
     }
 
-    function _define_property$5(obj, key, value) {
+    function _define_property$6(obj, key, value) {
         if (key in obj) {
             Object.defineProperty(obj, key, {
                 value: value,
@@ -11533,9 +11144,9 @@
             return this.migrate(this.config.currentVersion, version, routes);
         }
         constructor(config){
-            _define_property$5(this, "versions", new Map());
-            _define_property$5(this, "migrations", new Map());
-            _define_property$5(this, "config", void 0);
+            _define_property$6(this, "versions", new Map());
+            _define_property$6(this, "migrations", new Map());
+            _define_property$6(this, "config", void 0);
             this.config = {
                 enableVersionCheck: config.enableVersionCheck ?? true,
                 enableAutoMigration: config.enableAutoMigration ?? false,
@@ -11844,85 +11455,509 @@
             ]
         });
     }
-    function resolvePosition(position) {
-        const style = {
-            position: 'fixed',
-            zIndex: 9998
-        };
-        const pos = position || 'bottom-right';
-        if (pos.includes('bottom')) style.bottom = 16;
-        if (pos.includes('top')) style.top = 16;
-        if (pos.includes('right')) style.right = 16;
-        if (pos.includes('left')) style.left = 16;
-        return style;
+    function resolvePosition(position) {
+        const style = {
+            position: 'fixed',
+            zIndex: 9998
+        };
+        const pos = position || 'bottom-right';
+        if (pos.includes('bottom')) style.bottom = 16;
+        if (pos.includes('top')) style.top = 16;
+        if (pos.includes('right')) style.right = 16;
+        if (pos.includes('left')) style.left = 16;
+        return style;
+    }
+    function DevToolsTrigger({ appInstance, position = 'bottom-right' }) {
+        const [visible, setVisible] = React.useState(false);
+        if (process.env.NODE_ENV !== 'development') {
+            return null;
+        }
+        return /*#__PURE__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
+            children: [
+                /*#__PURE__*/ jsxRuntime.jsx("button", {
+                    onClick: ()=>setVisible(true),
+                    style: {
+                        ...resolvePosition(position),
+                        border: 'none',
+                        background: '#2f80ed',
+                        color: '#fff',
+                        borderRadius: 999,
+                        padding: '8px 14px',
+                        cursor: 'pointer'
+                    },
+                    children: "DevTools"
+                }),
+                /*#__PURE__*/ jsxRuntime.jsx(DevTools, {
+                    appInstance: appInstance,
+                    visible: visible,
+                    onClose: ()=>setVisible(false)
+                })
+            ]
+        });
+    }
+
+    /**
+     * 启动框架
+     * 
+     * @param options - 启动配置选项
+     * @returns Promise<void>
+     * 
+     * @example
+     * ```typescript
+     * import { start } from '@vlian/framework';
+     * 
+     * start({
+     *   loggerLevel: LogLevel.DEBUG,
+     *   lifecycle: {
+     *     beforeInitialization: async () => {
+     *       console.log('初始化前执行');
+     *     },
+     *   },
+     * });
+     * ```
+     */ /**
+     * 启动框架（向后兼容的API）
+     * 
+     * @param options - 启动配置选项
+     * @returns Promise<void>
+     * 
+     * @deprecated 建议使用 startApp 函数，支持多实例
+     */ const start = async (options = {})=>{
+        // 使用新的启动函数，保持向后兼容
+        await startApp(options);
+    };
+    // 导出getStateManager（向后兼容）
+    const getStateManager = ()=>{
+        const instanceManager = getAppInstanceManager();
+        const instance = instanceManager.getInstance();
+        if (instance) {
+            return instance.getServices().stateManager;
+        }
+        return null;
+    };
+
+    const utils = vlianUtils__namespace;
+    const ErrorCode = utils.ErrorCode;
+    const ErrorMessages = utils.ErrorMessages;
+    const getErrorMessage = utils.getErrorMessage;
+    const getUserFriendlyMessage = utils.getUserFriendlyMessage;
+    const ErrorType = utils.ErrorType;
+    const ErrorSeverity = utils.ErrorSeverity;
+    const FrameworkError = utils.FrameworkError;
+    const InitializationError = utils.InitializationError;
+    const ConfigError = utils.ConfigError;
+    const StorageError = utils.StorageError;
+    const NetworkError = utils.NetworkError;
+    const ValidationError = utils.ValidationError;
+    const SecurityError = utils.SecurityError;
+    const errorUtils = utils.errorUtils;
+
+    /**
+     * 配置安全工具类
+     */ class ConfigSecurity {
+        /**
+       * 验证配置签名
+       */ static async verifySignature(config, signature, options) {
+            if (!options.enabled) {
+                return true;
+            }
+            if (!options.publicKey) {
+                throw new SecurityError('签名验证需要提供公钥');
+            }
+            if (!signature || signature.length === 0) {
+                throw new SecurityError('签名不能为空');
+            }
+            try {
+                // 使用 Web Crypto API 验证签名
+                if (typeof window === 'undefined' || !window.crypto || !window.crypto.subtle) {
+                    throw new SecurityError('签名验证需要浏览器支持 Web Crypto API');
+                }
+                // 将配置转换为字符串（用于签名验证）
+                // 使用稳定的 JSON 序列化（按键排序）
+                const configString = JSON.stringify(config, Object.keys(config).sort());
+                const encoder = new TextEncoder();
+                const data = encoder.encode(configString);
+                // 将签名从 Base64 解码
+                const signatureBuffer = Uint8Array.from(atob(signature), (c)=>c.charCodeAt(0));
+                // 导入公钥（支持 PEM 格式）
+                const algorithm = options.algorithm || 'RSASSA-PKCS1-v1_5';
+                let publicKey;
+                try {
+                    // 尝试导入 PEM 格式的公钥
+                    const pemHeader = '-----BEGIN PUBLIC KEY-----';
+                    const pemFooter = '-----END PUBLIC KEY-----';
+                    let pemKey = options.publicKey;
+                    if (!pemKey.includes(pemHeader)) {
+                        pemKey = `${pemHeader}\n${pemKey}\n${pemFooter}`;
+                    }
+                    // 将 PEM 转换为 ArrayBuffer
+                    const pemContents = pemKey.replace(pemHeader, '').replace(pemFooter, '').replace(/\s/g, '');
+                    const binaryDer = Uint8Array.from(atob(pemContents), (c)=>c.charCodeAt(0));
+                    publicKey = await window.crypto.subtle.importKey('spki', binaryDer.buffer, {
+                        name: algorithm,
+                        hash: 'SHA-256'
+                    }, false, [
+                        'verify'
+                    ]);
+                } catch (importError) {
+                    throw new SecurityError('公钥导入失败', importError instanceof Error ? importError : undefined);
+                }
+                // 验证签名
+                const isValid = await window.crypto.subtle.verify({
+                    name: algorithm
+                }, publicKey, signatureBuffer, data);
+                return isValid;
+            } catch (error) {
+                if (error instanceof SecurityError) {
+                    throw error;
+                }
+                throw new SecurityError('签名验证失败', error instanceof Error ? error : undefined);
+            }
+        }
+        /**
+       * 验证配置来源
+       */ static verifyOrigin(options) {
+            if (!options.allowedOrigins || options.allowedOrigins.length === 0) {
+                return true; // 如果没有配置白名单，允许所有来源
+            }
+            if (typeof window === 'undefined') {
+                return true; // 非浏览器环境，跳过验证
+            }
+            const currentOrigin = window.location.origin;
+            const referer = document.referrer;
+            // 验证当前来源
+            if (options.allowedOrigins.includes(currentOrigin)) {
+                return true;
+            }
+            // 验证 Referer
+            if (options.verifyReferer && referer) {
+                try {
+                    const refererOrigin = new URL(referer).origin;
+                    if (options.allowedOrigins.includes(refererOrigin)) {
+                        return true;
+                    }
+                } catch  {
+                // Referer 解析失败
+                }
+            }
+            return false;
+        }
+        /**
+       * 验证配置白名单
+       */ static verifyWhitelist(config, options) {
+            const errors = [];
+            // 检查允许的键
+            if (options.allowedKeys && options.allowedKeys.length > 0) {
+                const configKeys = Object.keys(config);
+                const invalidKeys = configKeys.filter((key)=>!options.allowedKeys.includes(key));
+                if (invalidKeys.length > 0) {
+                    errors.push(`配置包含不允许的键: ${invalidKeys.join(', ')}`);
+                }
+            }
+            // 检查禁止的键
+            if (options.forbiddenKeys && options.forbiddenKeys.length > 0) {
+                const configKeys = Object.keys(config);
+                const forbiddenFound = configKeys.filter((key)=>options.forbiddenKeys.includes(key));
+                if (forbiddenFound.length > 0) {
+                    errors.push(`配置包含禁止的键: ${forbiddenFound.join(', ')}`);
+                }
+            }
+            // 验证配置值
+            if (options.valueSchema) {
+                const result = vlianUtils.Validator.validateObject(options.valueSchema, config);
+                if (!result.valid) {
+                    errors.push(...result.errors);
+                }
+            }
+            return {
+                valid: errors.length === 0,
+                errors
+            };
+        }
+        /**
+       * 清理配置中的危险内容
+       */ static sanitizeConfig(config) {
+            const sanitized = {};
+            for (const [key, value] of Object.entries(config)){
+                if (typeof value === 'string') {
+                    // 检查是否包含危险内容
+                    const validation = vlianUtils.SecurityUtils.validateInput(value);
+                    if (validation.safe && validation.sanitized) {
+                        sanitized[key] = validation.sanitized;
+                    } else {
+                        // 包含危险内容，跳过或记录警告
+                        console.warn(`配置项 ${key} 包含潜在危险内容，已跳过`);
+                    }
+                } else if (value && typeof value === 'object' && !Array.isArray(value)) {
+                    // 递归清理对象
+                    sanitized[key] = this.sanitizeConfig(value);
+                } else {
+                    sanitized[key] = value;
+                }
+            }
+            return sanitized;
+        }
+        /**
+       * 验证配置安全性
+       */ static async validateConfigSecurity(config, options) {
+            const errors = [];
+            // 验证来源
+            if (options.origin) {
+                const originValid = this.verifyOrigin(options.origin);
+                if (!originValid) {
+                    errors.push('配置来源验证失败');
+                }
+            }
+            // 验证白名单
+            if (options.whitelist) {
+                const whitelistResult = this.verifyWhitelist(config, options.whitelist);
+                if (!whitelistResult.valid) {
+                    errors.push(...whitelistResult.errors);
+                }
+            }
+            // 清理配置（已实现但暂不使用返回值）
+            // const sanitizedConfig = this.sanitizeConfig(config);
+            return {
+                valid: errors.length === 0,
+                errors
+            };
+        }
+    }
+
+    var runtimeSecurity = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        RuntimeSecurity: vlianUtils.RuntimeSecurity
+    });
+
+    function _define_property$5(obj, key, value) {
+        if (key in obj) {
+            Object.defineProperty(obj, key, {
+                value: value,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        } else {
+            obj[key] = value;
+        }
+        return obj;
+    }
+    /**
+     * 分析服务类
+     */ class AnalyticsService {
+        /**
+       * 启动批量上报定时器
+       */ startBatchTimer() {
+            if (this.batchTimer) {
+                return;
+            }
+            this.batchTimer = setInterval(()=>{
+                this.flush();
+            }, this.config.batchInterval);
+        }
+        /**
+       * 停止批量上报定时器
+       */ stopBatchTimer() {
+            if (this.batchTimer) {
+                clearInterval(this.batchTimer);
+                this.batchTimer = null;
+            }
+        }
+        /**
+       * 记录事件
+       */ track(event) {
+            if (!this.config.enabled) {
+                return;
+            }
+            // 采样检查
+            if (Math.random() > this.config.sampleRate) {
+                return;
+            }
+            // 匿名化处理
+            const anonymizedEvent = {
+                ...event,
+                timestamp: Date.now(),
+                properties: this.anonymizeProperties(event.properties)
+            };
+            // 添加到队列
+            this.eventQueue.push(anonymizedEvent);
+            // 立即上报单个事件
+            if (this.config.onEvent) {
+                this.config.onEvent(anonymizedEvent);
+            }
+            // 检查是否需要批量上报
+            if (this.eventQueue.length >= this.config.batchSize) {
+                this.flush();
+            }
+        }
+        /**
+       * 记录页面浏览
+       */ trackPageView(page, properties) {
+            this.track({
+                type: 'pageview',
+                name: 'page_view',
+                properties: {
+                    page,
+                    ...properties
+                }
+            });
+        }
+        /**
+       * 记录点击事件
+       */ trackClick(element, properties) {
+            this.track({
+                type: 'click',
+                name: 'click',
+                properties: {
+                    element,
+                    ...properties
+                }
+            });
+        }
+        /**
+       * 记录自定义事件
+       */ trackCustom(name, properties) {
+            this.track({
+                type: 'custom',
+                name,
+                properties
+            });
+        }
+        /**
+       * 记录错误事件
+       */ trackError(error, properties) {
+            this.track({
+                type: 'error',
+                name: 'error',
+                properties: {
+                    errorName: error.name,
+                    errorMessage: error.message,
+                    errorStack: error.stack,
+                    ...properties
+                }
+            });
+        }
+        /**
+       * 记录性能事件
+       */ trackPerformance(metrics, properties) {
+            this.track({
+                type: 'performance',
+                name: 'performance',
+                properties: {
+                    ...metrics,
+                    ...properties
+                }
+            });
+        }
+        /**
+       * 匿名化属性（使用深度脱敏）
+       */ anonymizeProperties(properties) {
+            if (!this.config.anonymize || !properties) {
+                return properties;
+            }
+            // 使用深度脱敏处理
+            return vlianUtils.SecurityUtils.deepSanitize(properties);
+        }
+        /**
+       * 刷新队列（批量上报）
+       */ flush() {
+            if (this.eventQueue.length === 0) {
+                return;
+            }
+            const events = [
+                ...this.eventQueue
+            ];
+            this.eventQueue = [];
+            if (this.config.onBatch) {
+                this.config.onBatch(events);
+            }
+            logger.logger.debug(`分析服务批量上报 ${events.length} 个事件`);
+        }
+        /**
+       * 启用分析
+       */ enable() {
+            this.config.enabled = true;
+            this.startBatchTimer();
+        }
+        /**
+       * 禁用分析
+       */ disable() {
+            this.config.enabled = false;
+            this.stopBatchTimer();
+            this.flush();
+        }
+        /**
+       * 销毁服务
+       */ destroy() {
+            this.stopBatchTimer();
+            this.flush();
+        }
+        constructor(config = {}){
+            _define_property$5(this, "config", void 0);
+            _define_property$5(this, "eventQueue", []);
+            _define_property$5(this, "batchTimer", null);
+            this.config = {
+                enabled: config.enabled ?? true,
+                sampleRate: config.sampleRate ?? 1.0,
+                anonymize: config.anonymize ?? true,
+                onEvent: config.onEvent ?? (()=>{}),
+                onBatch: config.onBatch ?? (()=>{}),
+                batchSize: config.batchSize ?? 10,
+                batchInterval: config.batchInterval ?? 5000
+            };
+            if (this.config.enabled) {
+                this.startBatchTimer();
+            }
+        }
+    }
+    /**
+     * 默认分析服务实例
+     */ let defaultAnalyticsService = null;
+    /**
+     * 初始化默认分析服务
+     */ function initAnalytics(config) {
+        if (!defaultAnalyticsService) {
+            defaultAnalyticsService = new AnalyticsService(config);
+        }
+        return defaultAnalyticsService;
     }
-    function DevToolsTrigger({ appInstance, position = 'bottom-right' }) {
-        const [visible, setVisible] = React.useState(false);
-        if (process.env.NODE_ENV !== 'development') {
-            return null;
+    /**
+     * 获取默认分析服务
+     */ function getAnalytics() {
+        if (!defaultAnalyticsService) {
+            return initAnalytics();
         }
-        return /*#__PURE__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
-            children: [
-                /*#__PURE__*/ jsxRuntime.jsx("button", {
-                    onClick: ()=>setVisible(true),
-                    style: {
-                        ...resolvePosition(position),
-                        border: 'none',
-                        background: '#2f80ed',
-                        color: '#fff',
-                        borderRadius: 999,
-                        padding: '8px 14px',
-                        cursor: 'pointer'
-                    },
-                    children: "DevTools"
-                }),
-                /*#__PURE__*/ jsxRuntime.jsx(DevTools, {
-                    appInstance: appInstance,
-                    visible: visible,
-                    onClose: ()=>setVisible(false)
-                })
-            ]
-        });
+        return defaultAnalyticsService;
     }
 
+    var analytics = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        AnalyticsService: AnalyticsService,
+        getAnalytics: getAnalytics,
+        initAnalytics: initAnalytics
+    });
+
     /**
-     * 启动框架
+     * 等待指定时间后解析的 Promise 工具函数
      * 
-     * @param options - 启动配置选项
-     * @returns Promise<void>
+     * @param time - 等待时间（毫秒），默认为 100 毫秒
+     * @returns 返回一个 Promise，在指定时间后解析为 true
      * 
      * @example
      * ```typescript
-     * import { start } from '@vlian/framework';
+     * // 等待 500 毫秒
+     * await waitTime(500);
      * 
-     * start({
-     *   loggerLevel: LogLevel.DEBUG,
-     *   lifecycle: {
-     *     beforeInitialization: async () => {
-     *       console.log('初始化前执行');
-     *     },
-     *   },
-     * });
+     * // 使用默认等待时间（100 毫秒）
+     * await waitTime();
      * ```
-     */ /**
-     * 启动框架（向后兼容的API）
-     * 
-     * @param options - 启动配置选项
-     * @returns Promise<void>
-     * 
-     * @deprecated 建议使用 startApp 函数，支持多实例
-     */ const start = async (options = {})=>{
-        // 使用新的启动函数，保持向后兼容
-        await startApp(options);
-    };
-    // 导出getStateManager（向后兼容）
-    const getStateManager = ()=>{
-        const instanceManager = getAppInstanceManager();
-        const instance = instanceManager.getInstance();
-        if (instance) {
-            return instance.getServices().stateManager;
-        }
-        return null;
+     * @deprecated 建议使用基于实际完成状态的机制，而不是固定等待时间
+     */ const waitTime = (time = 100)=>{
+        return new Promise((resolve)=>{
+            setTimeout(()=>{
+                resolve(true);
+            }, time);
+        });
     };
 
     function resolveStorage(storage) {
@@ -12759,113 +12794,45 @@
         return adapter();
     }
 
-    Object.defineProperty(exports, "ConfigError", {
-        enumerable: true,
-        get: function () { return utils.ConfigError; }
-    });
-    Object.defineProperty(exports, "ErrorCode", {
-        enumerable: true,
-        get: function () { return utils.ErrorCode; }
-    });
-    Object.defineProperty(exports, "ErrorMessages", {
-        enumerable: true,
-        get: function () { return utils.ErrorMessages; }
-    });
-    Object.defineProperty(exports, "ErrorSeverity", {
-        enumerable: true,
-        get: function () { return utils.ErrorSeverity; }
-    });
-    Object.defineProperty(exports, "ErrorType", {
-        enumerable: true,
-        get: function () { return utils.ErrorType; }
-    });
-    Object.defineProperty(exports, "FrameworkError", {
-        enumerable: true,
-        get: function () { return utils.FrameworkError; }
-    });
-    Object.defineProperty(exports, "InitializationError", {
-        enumerable: true,
-        get: function () { return utils.InitializationError; }
-    });
-    Object.defineProperty(exports, "NetworkError", {
-        enumerable: true,
-        get: function () { return utils.NetworkError; }
-    });
     Object.defineProperty(exports, "PERFORMANCE_METRIC_UNITS", {
         enumerable: true,
-        get: function () { return utils.PERFORMANCE_METRIC_UNITS; }
+        get: function () { return vlianUtils.PERFORMANCE_METRIC_UNITS; }
     });
     Object.defineProperty(exports, "PerformanceMonitor", {
         enumerable: true,
-        get: function () { return utils.PerformanceMonitor; }
+        get: function () { return vlianUtils.PerformanceMonitor; }
     });
     Object.defineProperty(exports, "ResourceLoader", {
         enumerable: true,
-        get: function () { return utils.ResourceLoader; }
+        get: function () { return vlianUtils.ResourceLoader; }
     });
     Object.defineProperty(exports, "RuntimeSecurity", {
         enumerable: true,
-        get: function () { return utils.RuntimeSecurity; }
+        get: function () { return vlianUtils.RuntimeSecurity; }
     });
     Object.defineProperty(exports, "SENSITIVE_FIELDS", {
         enumerable: true,
-        get: function () { return utils.SENSITIVE_FIELDS; }
-    });
-    Object.defineProperty(exports, "SecurityError", {
-        enumerable: true,
-        get: function () { return utils.SecurityError; }
+        get: function () { return vlianUtils.SENSITIVE_FIELDS; }
     });
     Object.defineProperty(exports, "SecurityUtils", {
         enumerable: true,
-        get: function () { return utils.SecurityUtils; }
-    });
-    Object.defineProperty(exports, "StorageError", {
-        enumerable: true,
-        get: function () { return utils.StorageError; }
-    });
-    Object.defineProperty(exports, "ValidationError", {
-        enumerable: true,
-        get: function () { return utils.ValidationError; }
+        get: function () { return vlianUtils.SecurityUtils; }
     });
     Object.defineProperty(exports, "Validator", {
         enumerable: true,
-        get: function () { return utils.Validator; }
+        get: function () { return vlianUtils.Validator; }
     });
     Object.defineProperty(exports, "commonSchemas", {
         enumerable: true,
-        get: function () { return utils.commonSchemas; }
+        get: function () { return vlianUtils.commonSchemas; }
     });
     Object.defineProperty(exports, "convertMetricsToWithUnits", {
         enumerable: true,
-        get: function () { return utils.convertMetricsToWithUnits; }
-    });
-    Object.defineProperty(exports, "errorUtils", {
-        enumerable: true,
-        get: function () { return utils.errorUtils; }
-    });
-    Object.defineProperty(exports, "getErrorMessage", {
-        enumerable: true,
-        get: function () { return utils.getErrorMessage; }
-    });
-    Object.defineProperty(exports, "getUserFriendlyMessage", {
-        enumerable: true,
-        get: function () { return utils.getUserFriendlyMessage; }
+        get: function () { return vlianUtils.convertMetricsToWithUnits; }
     });
     Object.defineProperty(exports, "resourceLoader", {
         enumerable: true,
-        get: function () { return utils.resourceLoader; }
-    });
-    Object.defineProperty(exports, "MonitoringService", {
-        enumerable: true,
-        get: function () { return monitoring.MonitoringService; }
-    });
-    Object.defineProperty(exports, "getMonitoring", {
-        enumerable: true,
-        get: function () { return monitoring.getMonitoring; }
-    });
-    Object.defineProperty(exports, "initMonitoring", {
-        enumerable: true,
-        get: function () { return monitoring.initMonitoring; }
+        get: function () { return vlianUtils.resourceLoader; }
     });
     Object.defineProperty(exports, "LogFormat", {
         enumerable: true,
@@ -12919,6 +12886,18 @@
         enumerable: true,
         get: function () { return logger.setCurrentTraceId; }
     });
+    Object.defineProperty(exports, "MonitoringService", {
+        enumerable: true,
+        get: function () { return monitoring.MonitoringService; }
+    });
+    Object.defineProperty(exports, "getMonitoring", {
+        enumerable: true,
+        get: function () { return monitoring.getMonitoring; }
+    });
+    Object.defineProperty(exports, "initMonitoring", {
+        enumerable: true,
+        get: function () { return monitoring.initMonitoring; }
+    });
     Object.defineProperty(exports, "MonitoringEventType", {
         enumerable: true,
         get: function () { return request.MonitoringEventType; }
@@ -13022,6 +13001,7 @@
     exports.AppContextProvider = AppContextProvider;
     exports.AppEventBus = AppEventBus;
     exports.AppRenderer = AppRenderer;
+    exports.ConfigError = ConfigError;
     exports.ConfigFileFormat = ConfigFileFormat;
     exports.ConfigLoader = ConfigLoader;
     exports.ConfigSecurity = ConfigSecurity;
@@ -13034,12 +13014,19 @@
     exports.DynamicRouteManager = DynamicRouteManager;
     exports.EnvironmentDetector = EnvironmentDetector;
     exports.ErrorBoundary = ErrorBoundary;
+    exports.ErrorCode = ErrorCode;
+    exports.ErrorMessages = ErrorMessages;
+    exports.ErrorSeverity = ErrorSeverity;
+    exports.ErrorType = ErrorType;
+    exports.FrameworkError = FrameworkError;
     exports.FrameworkEventManager = FrameworkEventManager;
     exports.FrameworkEventType = FrameworkEventType;
+    exports.InitializationError = InitializationError;
     exports.Kernel = Kernel;
     exports.KernelBootError = KernelBootError;
     exports.LocaleSwitch = LocaleSwitch;
     exports.MiddlewareManager = MiddlewareManager;
+    exports.NetworkError = NetworkError;
     exports.PerformanceTracker = PerformanceTracker;
     exports.PluginManager = PluginManager;
     exports.PreloadStrategy = PreloadStrategy;
@@ -13059,22 +13046,27 @@
     exports.RouterPluginManager = RouterPluginManager;
     exports.RuntimeEnvironment = RuntimeEnvironment;
     exports.STARTUP_METRIC_UNITS = STARTUP_METRIC_UNITS;
+    exports.SecurityError = SecurityError;
     exports.StateInstance = StateInstance;
     exports.StateManager = StateManager;
     exports.StateRegistry = StateRegistry;
     exports.StateScopeManager = StateScopeManager;
+    exports.StorageError = StorageError;
     exports.ThemeSwitch = ThemeSwitch;
+    exports.ValidationError = ValidationError;
     exports.ZustandAdapter = ZustandAdapter;
     exports.appConfig = appConfig;
     exports.componentImportSchema = componentImportSchema;
     exports.createAuthMiddleware = createAuthMiddleware;
     exports.createReactRouterAdapter = createReactRouterAdapter;
     exports.createRouterError = createRouterError;
+    exports.errorUtils = errorUtils;
     exports.getAdapterManager = getAdapterManager;
     exports.getAnalytics = getAnalytics;
     exports.getAppInstanceManager = getAppInstanceManager;
     exports.getDynamicRouteManager = getDynamicRouteManager;
     exports.getEnvironmentDetector = getEnvironmentDetector;
+    exports.getErrorMessage = getErrorMessage;
     exports.getKernel = getKernel;
     exports.getRouteCache = getRouteCache;
     exports.getRoutePreloader = getRoutePreloader;
@@ -13085,6 +13077,7 @@
     exports.getRouterMonitoring = getRouterMonitoring;
     exports.getRouterPluginManager = getRouterPluginManager;
     exports.getStateManager = getStateManager;
+    exports.getUserFriendlyMessage = getUserFriendlyMessage;
     exports.initAnalytics = initAnalytics;
     exports.initializeServices = initializeServices;
     exports.kernelStartApp = kernelStartApp;