@vlian/infrastructure 0.9.10

package/dist/cjs/managers/AuthManager/AuthManager.js

@@ -0,0 +1,695 @@
+/**
+ * AuthManager - 认证状态管理器
+ * 
+ * 纯状态管理，不内置登录逻辑
+ * 完全泛型化，用户信息类型由用户定义
+ * 基于 @vlian/framework 的 Storage 和 AppEventBus
+ * 
+ * 架构分层：
+ * - Core 层：TokenManager, AuthStateManager, StorageManager, EncryptionService, EnvironmentDetector, ConcurrencyController
+ * - Runtime 层：RefreshScheduler
+ * - Observability 层：EventManager, PerformanceMonitor, ErrorHandler
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AuthManager", {
+    enumerable: true,
+    get: function() {
+        return AuthManager;
+    }
+});
+const _types = require("./types");
+const _constants = require("./constants");
+const _TokenManager = require("./modules/core/TokenManager");
+const _AuthStateManager = require("./modules/core/AuthStateManager");
+const _StorageManager = require("./modules/core/StorageManager");
+const _EncryptionService = require("./modules/core/EncryptionService");
+const _EnvironmentDetector = require("./modules/core/EnvironmentDetector");
+const _ConcurrencyController = require("./modules/core/ConcurrencyController");
+const _RefreshScheduler = require("./modules/runtime/RefreshScheduler");
+const _EventManager = require("./modules/observability/EventManager");
+const _PerformanceMonitor = require("./modules/observability/PerformanceMonitor");
+const _ErrorHandler = require("./modules/observability/ErrorHandler");
+function _define_property(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;
+}
+let AuthManager = class AuthManager {
+    // ========== 私有方法（仅保留必要的协调方法）==========
+    /**
+   * 处理过期 Token
+   */ async handleExpiredToken() {
+        const strategy = this.options.expiredTokenStrategy || 'none';
+        switch(strategy){
+            case 'clear':
+                this.options.logger?.info('Token expired, clearing auth state');
+                await this.clearAuth();
+                this.eventManager.emitEvent(_types.AuthEventType.TOKEN_EXPIRED, {
+                    strategy: 'cleared'
+                });
+                break;
+            case 'refresh':
+                if (this.options.refreshTokenFunction && this.authStateManager.getRefreshToken()) {
+                    this.options.logger?.info('Token expired, attempting to refresh');
+                    try {
+                        await this.refreshToken(this.options.refreshTokenFunction);
+                    } catch (error) {
+                        const sanitizedError = _ErrorHandler.ErrorHandler.sanitizeError(error, this.options.sanitizeErrors, this.options.errorSanitizer);
+                        this.options.logger?.error('Failed to refresh expired token:', sanitizedError);
+                        // 刷新失败，根据配置决定是否清除
+                        if (strategy === 'refresh') {
+                            await this.clearAuth();
+                        }
+                    }
+                } else {
+                    this.options.logger?.warn('Token expired but no refresh token available, clearing auth state');
+                    await this.clearAuth();
+                }
+                this.eventManager.emitEvent(_types.AuthEventType.TOKEN_EXPIRED, {
+                    strategy: 'refresh_attempted'
+                });
+                break;
+            case 'none':
+            default:
+                // 不处理，仅触发事件
+                this.eventManager.emitEvent(_types.AuthEventType.TOKEN_EXPIRED, {
+                    strategy: 'none'
+                });
+                break;
+        }
+    }
+    /**
+   * 从存储中恢复认证状态
+   */ async restoreAuthState() {
+        try {
+            const authData = await this.storageManager.restoreAuthState();
+            if (authData) {
+                this.authStateManager.restoreAuthState(authData);
+                // 验证 Token 是否过期
+                if (this.tokenManager.isTokenExpired(authData)) {
+                    this.options.logger?.warn('Restored token is expired');
+                    // 根据配置的过期策略处理
+                    await this.handleExpiredToken();
+                }
+            }
+        } catch (error) {
+            const sanitizedError = _ErrorHandler.ErrorHandler.sanitizeError(error, this.options.sanitizeErrors, this.options.errorSanitizer);
+            this.options.logger?.error('Failed to restore auth state:', sanitizedError);
+            // 上报错误到监控服务（使用脱敏后的错误信息）
+            this.options.monitoring?.captureError(error, {
+                context: 'auth_restore_state',
+                operation: 'restoreAuthState',
+                sanitizedMessage: sanitizedError
+            });
+            this.authStateManager.restoreAuthState(null);
+        }
+    }
+    /**
+   * 保存认证状态到存储（支持批量写入优化）
+   */ async saveAuthState() {
+        const authData = this.authStateManager.getAuthData();
+        await this.storageManager.saveAuthState(authData);
+    }
+    /**
+   * 强制立即保存认证状态（用于关键操作，如登出）
+   */ async saveAuthStateForce() {
+        const authData = this.authStateManager.getAuthData();
+        await this.storageManager.saveAuthStateForce(authData);
+    }
+    /**
+   * 检查并刷新 Token
+   */ async checkAndRefreshToken() {
+        // 检查是否可以刷新（页面可见性和网络状态）
+        if (this.refreshScheduler && !this.refreshScheduler.canRefresh()) {
+            return;
+        }
+        // 检查是否有认证数据
+        const authData = this.authStateManager.getAuthData();
+        if (!authData || !this.options.refreshTokenFunction) {
+            return;
+        }
+        const tokenInfo = authData.tokenInfo;
+        if (!tokenInfo || !tokenInfo.refreshToken) {
+            return;
+        }
+        // 如果 Token 已过期，根据策略处理
+        if (this.tokenManager.isTokenExpired(authData)) {
+            await this.handleExpiredToken();
+            return;
+        }
+        // 如果 Token 即将过期（在阈值时间内），则刷新
+        if (this.tokenManager.isTokenExpiringSoon(authData, this.options.refreshThreshold)) {
+            await this.refreshToken(this.options.refreshTokenFunction);
+        }
+    }
+    // ========== 公共 API：状态管理 ==========
+    /**
+   * 设置认证状态（用户登录成功后调用）
+   * @param authDataOrTokenInfo Token 信息或完整的认证数据
+   */ async setAuth(authDataOrTokenInfo) {
+        return this.concurrencyController.execute(async ()=>{
+            const startTime = Date.now();
+            const traceId = this.options.enableTracing ? this.performanceMonitor.generateTraceId() : undefined;
+            // 判断传入的是 TokenInfo 还是 AuthData
+            let tokenInfo;
+            let userInfo;
+            if ('tokenInfo' in authDataOrTokenInfo) {
+                // 传入的是 AuthData
+                tokenInfo = authDataOrTokenInfo.tokenInfo;
+                userInfo = authDataOrTokenInfo.userInfo;
+            } else {
+                // 传入的是 TokenInfo
+                tokenInfo = authDataOrTokenInfo;
+            }
+            // 验证 Token 信息
+            this.tokenManager.validateTokenInfo(tokenInfo);
+            // 计算过期时间和设置默认值
+            tokenInfo = this.tokenManager.calculateExpiryTime(tokenInfo);
+            if (!tokenInfo.tokenType) {
+                tokenInfo.tokenType = _constants.DEFAULT_OPTIONS.tokenType;
+            }
+            const authData = {
+                tokenInfo,
+                ...userInfo !== undefined && {
+                    userInfo
+                }
+            };
+            // 设置认证状态（内部会执行生命周期钩子和中间件）
+            await this.authStateManager.setAuth(authData, traceId);
+            // 保存到存储（登录是关键操作，使用强制保存）
+            await this.saveAuthStateForce();
+            // 触发事件
+            this.eventManager.emitEvent(_types.AuthEventType.AUTH_SET, {
+                authData,
+                traceId
+            });
+            // 重启自动刷新
+            if (this.refreshScheduler) {
+                this.refreshScheduler.startAutoRefresh();
+                // 立即检查一次 Token
+                Promise.resolve().then(()=>{
+                    this.checkAndRefreshToken().catch((error)=>{
+                        const sanitizedError = _ErrorHandler.ErrorHandler.sanitizeError(error, this.options.sanitizeErrors, this.options.errorSanitizer);
+                        this.options.logger?.error('Failed to check token after setAuth:', sanitizedError);
+                    });
+                });
+            }
+            const duration = Date.now() - startTime;
+            this.performanceMonitor.recordPerformance('setAuth', duration, {
+                traceId
+            });
+            this.options.logger?.info('Auth state set successfully', {
+                traceId,
+                duration
+            });
+        });
+    }
+    /**
+   * 清除认证状态（用户登出时调用）
+   */ async clearAuth() {
+        return this.concurrencyController.execute(async ()=>{
+            const startTime = Date.now();
+            const traceId = this.options.enableTracing ? this.performanceMonitor.generateTraceId() : undefined;
+            // 清除认证状态（内部会执行生命周期钩子和中间件）
+            await this.authStateManager.clearAuth(traceId);
+            // 登出是关键操作，使用强制保存确保立即执行
+            await this.saveAuthStateForce();
+            // 停止自动刷新
+            if (this.refreshScheduler) {
+                this.refreshScheduler.stopAutoRefresh();
+            }
+            // 触发事件
+            this.eventManager.emitEvent(_types.AuthEventType.AUTH_CLEAR, {
+                traceId
+            });
+            const duration = Date.now() - startTime;
+            this.performanceMonitor.recordPerformance('clearAuth', duration, {
+                traceId
+            });
+            this.options.logger?.info('Auth state cleared', {
+                traceId,
+                duration
+            });
+        });
+    }
+    /**
+   * 更新用户信息（不改变登录状态）
+   * @param userInfo 新的用户信息
+   */ async updateUserInfo(userInfo) {
+        return this.concurrencyController.execute(async ()=>{
+            const previousUserInfo = this.authStateManager.getUserInfo();
+            await this.authStateManager.updateUserInfo(userInfo);
+            await this.saveAuthState();
+            // 触发事件
+            this.eventManager.emitEvent(_types.AuthEventType.USER_INFO_UPDATE, {
+                userInfo,
+                previousUserInfo
+            });
+            this.options.logger?.info('User info updated');
+        });
+    }
+    /**
+   * 更新 Token（用于 Token 刷新）
+   * @param tokenInfo Token 信息
+   */ async updateToken(tokenInfo) {
+        return this.concurrencyController.execute(async ()=>{
+            // 计算过期时间和设置默认值
+            tokenInfo = this.tokenManager.calculateExpiryTime(tokenInfo);
+            if (!tokenInfo.tokenType) {
+                tokenInfo.tokenType = _constants.DEFAULT_OPTIONS.tokenType;
+            }
+            await this.authStateManager.updateToken(tokenInfo);
+            await this.saveAuthState();
+            // 触发事件
+            this.eventManager.emitEvent(_types.AuthEventType.TOKEN_UPDATE, {
+                tokenInfo
+            });
+            this.options.logger?.info('Token updated');
+        });
+    }
+    // ========== 公共 API：状态获取 ==========
+    /**
+   * 检查是否已认证
+   */ isAuthenticated() {
+        const authData = this.authStateManager.getAuthData();
+        return this.authStateManager.isAuthenticated(this.tokenManager.isTokenExpired(authData));
+    }
+    /**
+   * 获取访问 Token
+   */ getToken() {
+        return this.authStateManager.getToken();
+    }
+    /**
+   * 获取刷新 Token
+   */ getRefreshToken() {
+        return this.authStateManager.getRefreshToken();
+    }
+    /**
+   * 获取完整的认证数据
+   */ getAuthData() {
+        return this.authStateManager.getAuthData();
+    }
+    /**
+   * 获取用户信息（泛型，完全由用户定义类型）
+   */ getUserInfo() {
+        return this.authStateManager.getUserInfo();
+    }
+    /**
+   * 获取用户ID
+   * 尝试从 JWT token 中解析用户ID，如果 token 不是 JWT 格式或解析失败，返回 null
+   */ getUserId() {
+        return this.authStateManager.getUserId();
+    }
+    // ========== 公共 API：Token 管理 ==========
+    /**
+   * 检查 Token 是否过期
+   */ isTokenExpired() {
+        const authData = this.authStateManager.getAuthData();
+        return this.tokenManager.isTokenExpired(authData);
+    }
+    /**
+   * 获取 Token 过期时间戳
+   */ getTokenExpiryTime() {
+        const authData = this.authStateManager.getAuthData();
+        return this.tokenManager.getTokenExpiryTime(authData);
+    }
+    /**
+   * 手动刷新 Token（需要用户提供刷新函数，支持重试）
+   * @param refreshFn 刷新 Token 的函数
+   */ async refreshToken(refreshFn) {
+        if (!this.isAuthenticated()) {
+            throw new _types.AuthError('Cannot refresh token: not authenticated', _types.AuthErrorCode.INVALID_TOKEN);
+        }
+        const refreshToken = this.authStateManager.getRefreshToken();
+        if (!refreshToken) {
+            throw new _types.AuthError('Cannot refresh token: refresh token not available', _types.AuthErrorCode.INVALID_TOKEN);
+        }
+        const traceId = this.options.enableTracing ? this.performanceMonitor.generateTraceId() : undefined;
+        const refreshStartTime = Date.now();
+        // 执行生命周期钩子
+        if (this.options.lifecycleHooks?.beforeRefreshToken) {
+            await this.options.lifecycleHooks.beforeRefreshToken(refreshToken);
+        }
+        try {
+            // 使用 TokenManager 刷新 Token（内部会处理重试、超时等）
+            const newTokenInfo = await this.tokenManager.refreshToken(refreshToken, refreshFn, traceId);
+            const refreshDuration = Date.now() - refreshStartTime;
+            // 记录性能指标
+            this.performanceMonitor.recordPerformance('token_refresh', refreshDuration, {
+                traceId,
+                status: 'success'
+            });
+            this.options.logger?.info('Token refreshed successfully', {
+                duration: refreshDuration,
+                traceId
+            });
+            return newTokenInfo;
+        } catch (error) {
+            const refreshDuration = Date.now() - refreshStartTime;
+            const authError = error instanceof _types.AuthError ? error : new _types.AuthError('Token refresh failed', _types.AuthErrorCode.TOKEN_REFRESH_FAILED, undefined, error instanceof Error ? error : new Error(String(error)));
+            // 记录性能指标
+            this.performanceMonitor.recordPerformance('token_refresh', refreshDuration, {
+                traceId,
+                status: 'failed',
+                error: authError.code
+            });
+            const sanitizedError = _ErrorHandler.ErrorHandler.sanitizeError(error, this.options.sanitizeErrors, this.options.errorSanitizer);
+            this.options.logger?.error('Token refresh failed:', sanitizedError, {
+                traceId
+            });
+            throw authError;
+        }
+    }
+    // ========== 公共 API：事件订阅 ==========
+    /**
+   * 订阅事件
+   */ on(event, listener, options) {
+        return this.eventManager.on(event, listener, options);
+    }
+    /**
+   * 取消订阅
+   */ off(event, listener) {
+        return this.eventManager.off(event, listener);
+    }
+    /**
+   * 一次性订阅
+   */ once(event, listener) {
+        return this.eventManager.once(event, listener);
+    }
+    /**
+   * 健康检查
+   */ async healthCheck() {
+        const checks = {
+            storage: false,
+            eventBus: false,
+            authState: false,
+            tokenValid: false
+        };
+        const details = {};
+        // 检查存储
+        try {
+            const storage = this.storageManager.getStorage();
+            await storage.get('__health_check__');
+            checks.storage = true;
+        } catch (error) {
+            details.storageError = _ErrorHandler.ErrorHandler.sanitizeError(error, this.options.sanitizeErrors, this.options.errorSanitizer);
+        }
+        // 检查事件总线（通过 EventManager）
+        try {
+            // EventManager 内部会处理事件总线检查
+            checks.eventBus = true; // EventManager 初始化时已检查
+        } catch (error) {
+            details.eventBusError = _ErrorHandler.ErrorHandler.sanitizeError(error, this.options.sanitizeErrors, this.options.errorSanitizer);
+        }
+        // 检查认证状态
+        const authData = this.authStateManager.getAuthData();
+        checks.authState = authData !== null;
+        // 检查 Token 有效性
+        if (checks.authState) {
+            checks.tokenValid = this.isAuthenticated();
+            if (!checks.tokenValid) {
+                details.tokenExpired = this.isTokenExpired();
+                details.expiryTime = this.getTokenExpiryTime();
+            }
+        }
+        // 计算总体状态
+        const allHealthy = Object.values(checks).every((check)=>check === true);
+        const someHealthy = Object.values(checks).some((check)=>check === true);
+        let status;
+        if (allHealthy) {
+            status = 'healthy';
+        } else if (someHealthy) {
+            status = 'degraded';
+        } else {
+            status = 'unhealthy';
+        }
+        return {
+            status,
+            checks,
+            details: Object.keys(details).length > 0 ? details : undefined
+        };
+    }
+    /**
+   * 获取性能指标
+   */ getPerformanceMetrics() {
+        return this.performanceMonitor.getPerformanceMetrics();
+    }
+    /**
+   * 清除性能指标
+   */ clearPerformanceMetrics() {
+        this.performanceMonitor.clearPerformanceMetrics();
+    }
+    /**
+   * 获取环境信息
+   */ getEnvironment() {
+        return this.environment;
+    }
+    /**
+   * 是否在生产环境
+   */ isProductionEnvironment() {
+        return this.isProduction;
+    }
+    /**
+   * 销毁实例（清理资源）
+   */ destroy() {
+        // 停止自动刷新（Runtime 层）
+        if (this.refreshScheduler) {
+            this.refreshScheduler.destroy();
+        }
+        // 清理并发控制器（Core 层）
+        this.concurrencyController.clear();
+        // 清理 Token 管理器（Core 层）
+        this.tokenManager.destroy();
+        // 清理存储管理器（Core 层）
+        this.storageManager.destroy();
+        // 清理事件管理器（Observability 层）
+        this.eventManager.destroy();
+        // 清理认证状态管理器（Core 层）
+        this.authStateManager.destroy();
+        this.options.logger?.debug('AuthManager destroyed');
+    }
+    /**
+   * 构造函数
+   * @param options 配置选项
+   */ constructor(options){
+        // 配置选项
+        _define_property(this, "options", void 0);
+        // Core 层模块（必须）
+        _define_property(this, "tokenManager", void 0);
+        _define_property(this, "authStateManager", void 0);
+        _define_property(this, "storageManager", void 0);
+        _define_property(this, "encryptionService", void 0);
+        _define_property(this, "environment", void 0);
+        _define_property(this, "isProduction", void 0);
+        _define_property(this, "concurrencyController", void 0);
+        // Runtime 层模块
+        _define_property(this, "refreshScheduler", void 0);
+        // Observability 层模块（可选）
+        _define_property(this, "eventManager", void 0);
+        _define_property(this, "performanceMonitor", void 0);
+        // ========== 1. 环境检测（Core 层）==========
+        this.environment = _EnvironmentDetector.EnvironmentDetector.detectEnvironment();
+        this.isProduction = _EnvironmentDetector.EnvironmentDetector.checkIsProduction();
+        // 从环境变量读取配置（如果启用）
+        const envOptions = _EnvironmentDetector.EnvironmentDetector.loadEnvConfig(options.envPrefix);
+        const mergedOptions = {
+            ...options,
+            ...envOptions
+        };
+        // 验证必需配置
+        if (!mergedOptions.storage) {
+            throw new _types.AuthError('Storage configuration is required', _types.AuthErrorCode.CONFIG_ERROR);
+        }
+        // 合并默认配置
+        this.options = {
+            ..._constants.DEFAULT_OPTIONS,
+            ...mergedOptions,
+            storage: mergedOptions.storage,
+            eventBus: mergedOptions.eventBus,
+            logger: mergedOptions.logger
+        };
+        // 应用生产环境覆盖
+        if (this.isProduction) {
+            this.options = {
+                ...this.options,
+                ..._constants.PRODUCTION_OVERRIDES
+            };
+        }
+        // 配置验证（Core 层）
+        if (this.options.validateConfig !== false) {
+            const validation = _EnvironmentDetector.EnvironmentDetector.validateConfig(this.options, this.isProduction);
+            if (!validation.valid) {
+                const errorMsg = `Configuration validation failed: ${validation.errors.join(', ')}`;
+                if (this.options.devMode) {
+                    throw new _types.AuthError(`${errorMsg}\nWarnings: ${validation.warnings.join(', ')}`, _types.AuthErrorCode.CONFIG_ERROR);
+                } else {
+                    throw new _types.AuthError(errorMsg, _types.AuthErrorCode.CONFIG_ERROR);
+                }
+            }
+            // 输出警告
+            if (validation.warnings.length > 0 && this.options.devMode) {
+                validation.warnings.forEach((warning)=>{
+                    this.options.logger?.warn(`Config warning: ${warning}`);
+                });
+            }
+        }
+        // 验证加密/解密配置
+        if (this.options.encryptToken !== undefined && this.options.decryptToken === undefined) {
+            throw new _types.AuthError('decryptToken is required when encryptToken is provided', _types.AuthErrorCode.CONFIG_ERROR);
+        }
+        if (this.options.decryptToken !== undefined && this.options.encryptToken === undefined) {
+            throw new _types.AuthError('encryptToken is required when decryptToken is provided', _types.AuthErrorCode.CONFIG_ERROR);
+        }
+        // 初始化 Token 刷新重试配置
+        const refreshRetryConfig = {
+            maxRetries: this.options.refreshRetryConfig?.maxRetries ?? _constants.DEFAULT_OPTIONS.refreshRetryConfig.maxRetries,
+            retryDelay: this.options.refreshRetryConfig?.retryDelay ?? _constants.DEFAULT_OPTIONS.refreshRetryConfig.retryDelay,
+            backoffMultiplier: this.options.refreshRetryConfig?.backoffMultiplier ?? _constants.DEFAULT_OPTIONS.refreshRetryConfig.backoffMultiplier,
+            retryableErrors: this.options.refreshRetryConfig?.retryableErrors ?? _constants.DEFAULT_OPTIONS.refreshRetryConfig.retryableErrors
+        };
+        // ========== 2. 初始化 Core 层模块 ==========
+        // 加密服务
+        this.encryptionService = new _EncryptionService.EncryptionService({
+            encryptToken: this.options.encryptToken,
+            decryptToken: this.options.decryptToken,
+            useDefaultEncryption: this.options.useDefaultEncryption,
+            defaultEncryptionKey: this.options.defaultEncryptionKey,
+            isProduction: this.isProduction,
+            logger: this.options.logger
+        });
+        // 存储管理器
+        this.storageManager = new _StorageManager.StorageManager({
+            storage: this.options.storage,
+            encryptionService: this.encryptionService,
+            authDataKey: this.options.authDataKey,
+            environment: this.environment,
+            batchWriteDelay: this.options.batchWriteDelay,
+            logger: this.options.logger
+        });
+        // 认证状态管理器
+        this.authStateManager = new _AuthStateManager.AuthStateManager({
+            middlewares: this.options.middlewares,
+            lifecycleHooks: this.options.lifecycleHooks,
+            onStateChange: (isAuthenticated, previousState)=>{
+                this.eventManager.emitEvent(_types.AuthEventType.AUTH_STATE_CHANGE, {
+                    isAuthenticated,
+                    previousState
+                });
+            }
+        });
+        // Token 管理器
+        this.tokenManager = new _TokenManager.TokenManager({
+            refreshTimeout: this.options.refreshTimeout,
+            refreshRetryConfig,
+            logger: this.options.logger,
+            onTokenUpdate: async (tokenInfo)=>{
+                await this.authStateManager.updateToken(tokenInfo);
+                await this.storageManager.saveAuthState(this.authStateManager.getAuthData());
+                this.eventManager.emitEvent(_types.AuthEventType.TOKEN_UPDATE, {
+                    tokenInfo
+                });
+            },
+            onRefreshSuccess: (tokenInfo)=>{
+                this.eventManager.emitEvent(_types.AuthEventType.TOKEN_REFRESH, {
+                    tokenInfo
+                });
+            },
+            onRefreshFailure: (error)=>{
+                this.eventManager.emitEvent(_types.AuthEventType.TOKEN_REFRESH_FAILURE, {
+                    error
+                });
+            }
+        });
+        // ========== 3. 初始化 Observability 层模块（可选）==========
+        // 事件管理器
+        this.eventManager = new _EventManager.EventManager({
+            eventBus: this.options.eventBus,
+            eventNamespace: this.options.eventNamespace,
+            enableEvents: this.options.enableEvents,
+            logger: this.options.logger,
+            monitoring: this.options.monitoring
+        });
+        // 性能监控器
+        this.performanceMonitor = new _PerformanceMonitor.PerformanceMonitor({
+            enableDetailedMetrics: this.options.enableDetailedMetrics,
+            enableTracing: this.options.enableTracing,
+            monitoring: this.options.monitoring,
+            metricsCollector: this.options.metricsCollector,
+            environment: this.environment
+        });
+        // 初始化并发控制器
+        this.concurrencyController = new _ConcurrencyController.ConcurrencyController({
+            strategy: this.options.concurrencyStrategy,
+            maxQueueSize: this.options.maxQueueSize,
+            operationTimeout: this.options.operationTimeout
+        });
+        // ========== 4. 初始化 Runtime 层模块 ==========
+        // 刷新调度器（如果启用自动刷新）
+        if (this.options.autoRefresh && this.options.refreshTokenFunction !== undefined) {
+            this.refreshScheduler = new _RefreshScheduler.RefreshScheduler({
+                autoRefresh: this.options.autoRefresh,
+                pauseRefreshOnHidden: this.options.pauseRefreshOnHidden,
+                useSmartScheduling: this.options.useSmartScheduling,
+                refreshInterval: this.options.refreshInterval,
+                listenNetworkStatus: this.options.listenNetworkStatus,
+                environment: this.environment,
+                logger: this.options.logger,
+                networkStatusListener: this.options.networkStatusListener,
+                onCheckAndRefresh: async ()=>{
+                    await this.checkAndRefreshToken();
+                },
+                onStartRefresh: ()=>{
+                // 刷新开始回调
+                },
+                onStopRefresh: ()=>{
+                // 刷新停止回调
+                }
+            });
+        }
+        // 设置实例隔离（如果提供了 instanceId）
+        if (this.options.instanceId) {
+            this.options.authDataKey = `${this.options.instanceId}:${this.options.authDataKey}`;
+        }
+        // 从存储中恢复认证状态
+        this.restoreAuthState().catch((error)=>{
+            const sanitizedError = _ErrorHandler.ErrorHandler.sanitizeError(error, this.options.sanitizeErrors, this.options.errorSanitizer);
+            this.options.logger?.error('Failed to restore auth state:', sanitizedError);
+            this.options.monitoring?.captureError(error, {
+                context: 'auth_restore_state',
+                operation: 'restoreAuthState',
+                sanitizedMessage: sanitizedError
+            });
+        });
+        // 启动自动刷新检查
+        if (this.refreshScheduler) {
+            this.refreshScheduler.startAutoRefresh();
+            // 立即检查一次 Token
+            Promise.resolve().then(()=>{
+                this.checkAndRefreshToken().catch((error)=>{
+                    const sanitizedError = _ErrorHandler.ErrorHandler.sanitizeError(error, this.options.sanitizeErrors, this.options.errorSanitizer);
+                    this.options.logger?.error('Failed to check token after initialization:', sanitizedError);
+                });
+            });
+        }
+        // 开发模式日志
+        if (this.options.devMode) {
+            this.options.logger?.debug('AuthManager initialized', {
+                environment: this.environment,
+                isProduction: this.isProduction,
+                options: _EnvironmentDetector.EnvironmentDetector.sanitizeConfigForLog(this.options)
+            });
+        }
+    }
+};
+
+//# sourceMappingURL=AuthManager.js.map