diff --git a/.kiro/specs/go-version-management/design.md b/.kiro/specs/go-version-management/design.md
new file mode 100644
index 0000000..9329037
--- /dev/null
+++ b/.kiro/specs/go-version-management/design.md
@@ -0,0 +1,647 @@
+# Design Document: Go Version Management
+
+## Overview
+
+本设计文档描述了为 PHPer 开发环境管理器添加 Go 版本管理功能的技术实现方案。该功能将允许用户安装、管理和切换不同版本的 Go 语言开发环境，与现有的 Node.js 和 Python 版本管理功能保持一致的架构和用户体验。
+
+## Architecture
+
+### 系统架构图
+
+```mermaid
+graph TB
+    subgraph "Frontend (Vue 3)"
+        A[GoManager.vue] --> B[Service Store]
+        A --> C[UI Components]
+    end
+    
+    subgraph "Electron Main Process"
+        D[IPC Handler] --> E[GoManager.ts]
+        E --> F[ConfigStore.ts]
+        E --> G[File System]
+        E --> H[Process Management]
+    end
+    
+    subgraph "External Services"
+        I[golang.org API] --> E
+        J[Go Downloads] --> E
+    end
+    
+    A -.->|IPC| D
+    E --> K[Environment Variables]
+    E --> L[Local Storage]
+```
+
+### 核心架构原则
+
+1. **一致性**: 与现有 NodeManager 和 PythonManager 保持相同的架构模式
+2. **模块化**: 独立的 GoManager 服务类，便于维护和测试
+3. **可扩展性**: 支持未来添加更多 Go 相关功能
+4. **用户体验**: 统一的界面风格和交互模式
+
+## Components and Interfaces
+
+### 1. GoManager Service (Backend)
+
+**文件位置**: `electron/services/GoManager.ts`
+
+**主要职责**:
+- 管理 Go 版本的安装、卸载和切换
+- 处理环境变量配置
+- 与 golang.org API 交互获取版本信息
+- 文件系统操作和下载管理
+
+**核心接口**:
+
+```typescript
+interface GoVersion {
+  version: string        // 版本号，如 "1.21.5"
+  path: string          // 安装路径
+  isActive: boolean     // 是否为当前活动版本
+  goroot: string        // GOROOT 路径
+  gopath?: string       // GOPATH 路径（可选）
+}
+
+interface AvailableGoVersion {
+  version: string       // 版本号
+  stable: boolean       // 是否为稳定版本
+  downloadUrl: string   // Windows 64位下载链接
+  size: number         // 文件大小（字节）
+  sha256: string       // SHA256 校验和
+}
+
+class GoManager {
+  // 获取已安装版本
+  async getInstalledVersions(): Promise<GoVersion[]>
+  
+  // 获取可用版本列表
+  async getAvailableVersions(): Promise<AvailableGoVersion[]>
+  
+  // 安装指定版本
+  async install(version: string, downloadUrl: string): Promise<{success: boolean, message: string}>
+  
+  // 卸载指定版本
+  async uninstall(version: string): Promise<{success: boolean, message: string}>
+  
+  // 设置活动版本
+  async setActive(version: string): Promise<{success: boolean, message: string}>
+  
+  // 验证 Go 安装
+  async validateInstallation(version: string): Promise<boolean>
+  
+  // 获取 Go 环境信息
+  async getGoInfo(version: string): Promise<GoInfo>
+}
+```
+
+### 2. GoManager Vue Component (Frontend)
+
+**文件位置**: `src/views/GoManager.vue`
+
+**主要功能**:
+- 显示已安装的 Go 版本列表
+- 提供版本安装、卸载和切换操作
+- 显示下载进度和操作状态
+- 版本信息展示和管理
+
+**组件结构**:
+```vue
+<template>
+  <!-- 页面头部 -->
+  <div class="page-header">
+    <h1>Go 管理</h1>
+    <p>管理本地 Go 版本，支持多版本切换</p>
+  </div>
+  
+  <!-- 下载进度条 -->
+  <div v-if="downloadProgress.percent > 0" class="download-progress">
+    <!-- 进度显示 -->
+  </div>
+  
+  <!-- 已安装版本卡片 -->
+  <div class="version-grid">
+    <div v-for="version in versions" class="version-card">
+      <!-- 版本信息和操作按钮 -->
+    </div>
+  </div>
+  
+  <!-- 安装新版本对话框 -->
+  <el-dialog v-model="showInstallDialog">
+    <!-- 可用版本列表 -->
+  </el-dialog>
+</template>
+```
+
+### 3. IPC Communication Layer
+
+**主进程注册**:
+```typescript
+// electron/main.ts
+ipcMain.handle('go:getVersions', () => goManager.getInstalledVersions())
+ipcMain.handle('go:getAvailableVersions', () => goManager.getAvailableVersions())
+ipcMain.handle('go:install', (_, version, url) => goManager.install(version, url))
+ipcMain.handle('go:uninstall', (_, version) => goManager.uninstall(version))
+ipcMain.handle('go:setActive', (_, version) => goManager.setActive(version))
+```
+
+**预加载脚本**:
+```typescript
+// electron/preload.ts
+contextBridge.exposeInMainWorld('electronAPI', {
+  go: {
+    getVersions: () => ipcRenderer.invoke('go:getVersions'),
+    getAvailableVersions: () => ipcRenderer.invoke('go:getAvailableVersions'),
+    install: (version: string, url: string) => ipcRenderer.invoke('go:install', version, url),
+    uninstall: (version: string) => ipcRenderer.invoke('go:uninstall', version),
+    setActive: (version: string) => ipcRenderer.invoke('go:setActive', version)
+  }
+})
+```
+
+## Data Models
+
+### 1. Go Version Data Model
+
+```typescript
+interface GoVersion {
+  version: string        // 版本号，格式如 "1.21.5"
+  path: string          // 本地安装路径
+  isActive: boolean     // 是否为当前活动版本
+  goroot: string        // GOROOT 环境变量值
+  gopath?: string       // GOPATH 环境变量值（可选）
+  installDate?: Date    // 安装日期
+  size?: number         // 安装大小（字节）
+}
+
+interface GoInfo {
+  version: string       // Go 版本
+  goroot: string       // GOROOT 路径
+  gopath: string       // GOPATH 路径
+  goversion: string    // go version 命令输出
+  goos: string         // 目标操作系统
+  goarch: string       // 目标架构
+}
+```
+
+### 2. Available Version Data Model
+
+```typescript
+interface AvailableGoVersion {
+  version: string       // 版本号
+  stable: boolean       // 是否为稳定版本
+  downloadUrl: string   // Windows 64位 ZIP 下载链接
+  size: number         // 文件大小（字节）
+  sha256: string       // SHA256 校验和
+  releaseDate?: string // 发布日期
+}
+
+interface GoRelease {
+  version: string
+  stable: boolean
+  files: GoFile[]
+}
+
+interface GoFile {
+  filename: string
+  os: string
+  arch: string
+  version: string
+  sha256: string
+  size: number
+  kind: 'archive' | 'installer' | 'source'
+}
+```
+
+### 3. Configuration Data Model
+
+```typescript
+interface GoConfig {
+  activeVersion: string           // 当前活动版本
+  installedVersions: string[]     // 已安装版本列表
+  gopath: string                 // 全局 GOPATH 设置
+  downloadSource: 'official'     // 下载源（目前仅支持官方）
+  autoSetGopath: boolean         // 是否自动设置 GOPATH
+}
+```
+
+## Implementation Details
+
+### 1. Version Discovery and Download
+
+**版本获取策略**:
+1. **主要来源**: 使用 `https://golang.org/dl/?mode=json` API
+2. **备用来源**: 硬编码的最新稳定版本列表
+3. **缓存机制**: 5分钟本地缓存，减少 API 调用
+
+**下载实现**:
+```typescript
+private async fetchGoVersions(): Promise<AvailableGoVersion[]> {
+  try {
+    const response = await fetch('https://golang.org/dl/?mode=json')
+    const releases: GoRelease[] = await response.json()
+    
+    return releases
+      .filter(release => release.stable)
+      .map(release => {
+        const windowsFile = release.files.find(f => 
+          f.os === 'windows' && f.arch === 'amd64' && f.kind === 'archive'
+        )
+        
+        if (!windowsFile) return null
+        
+        return {
+          version: release.version,
+          stable: release.stable,
+          downloadUrl: `https://golang.org/dl/${windowsFile.filename}`,
+          size: windowsFile.size,
+          sha256: windowsFile.sha256
+        }
+      })
+      .filter(Boolean)
+      .slice(0, 20) // 限制显示最新 20 个版本
+  } catch (error) {
+    return this.getFallbackVersions()
+  }
+}
+```
+
+### 2. Installation Process
+
+**安装流程**:
+1. 验证版本是否已安装
+2. 创建临时下载目录
+3. 下载 Go ZIP 文件（显示进度）
+4. 验证 SHA256 校验和
+5. 解压到目标目录
+6. 验证安装完整性
+7. 更新配置文件
+8. 清理临时文件
+
+**目录结构**:
+```
+[PHPer安装目录]/go/
+├── go-1.21.5/          # Go 1.21.5 安装目录
+│   ├── bin/
+│   │   ├── go.exe
+│   │   ├── gofmt.exe
+│   │   └── ...
+│   ├── src/
+│   ├── pkg/
+│   └── ...
+├── go-1.20.12/         # Go 1.20.12 安装目录
+└── workspace/          # 默认 GOPATH 工作空间
+    ├── src/
+    ├── pkg/
+    └── bin/
+```
+
+### 3. Environment Variable Management
+
+**环境变量配置**:
+```typescript
+private async updateEnvironmentVariables(goVersion: string): Promise<void> {
+  const goRoot = this.getGoPath(goVersion)
+  const goBin = join(goRoot, 'bin')
+  const goPath = this.getDefaultGoPath()
+  
+  // 使用 PowerShell 脚本更新用户环境变量
+  const psScript = `
+    # 设置 GOROOT
+    [Environment]::SetEnvironmentVariable('GOROOT', '${goRoot}', 'User')
+    
+    # 设置 GOPATH
+    [Environment]::SetEnvironmentVariable('GOPATH', '${goPath}', 'User')
+    
+    # 更新 PATH
+    $userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
+    $pathArray = $userPath -split ';' | Where-Object { $_ -ne '' }
+    
+    # 移除旧的 Go 路径
+    $filteredPaths = $pathArray | Where-Object { 
+      -not ($_ -like '*\\go\\go-*\\bin' -or $_ -like '*\\go-*\\bin')
+    }
+    
+    # 添加新的 Go 路径
+    $newPathArray = @('${goBin}') + $filteredPaths
+    $finalPath = ($newPathArray | Select-Object -Unique) -join ';'
+    
+    [Environment]::SetEnvironmentVariable('PATH', $finalPath, 'User')
+  `
+  
+  await this.executePowerShellScript(psScript)
+}
+```
+
+### 4. Installation Validation
+
+**验证检查项**:
+1. `go.exe` 文件存在且可执行
+2. `go version` 命令返回正确版本
+3. `go env` 命令正常工作
+4. 标准库文件完整性检查
+
+```typescript
+private async validateInstallation(version: string): Promise<boolean> {
+  const goPath = this.getGoPath(version)
+  const goExe = join(goPath, 'bin', 'go.exe')
+  
+  try {
+    // 检查可执行文件
+    if (!existsSync(goExe)) return false
+    
+    // 验证版本
+    const { stdout } = await execAsync(`"${goExe}" version`)
+    if (!stdout.includes(version)) return false
+    
+    // 验证环境
+    await execAsync(`"${goExe}" env GOROOT`)
+    
+    return true
+  } catch {
+    return false
+  }
+}
+```
+
+## Correctness Properties
+
+*A property is a characteristic or behavior that should hold true across all valid executions of a system-essentially, a formal statement about what the system should do. Properties serve as the bridge between human-readable specifications and machine-verifiable correctness guarantees.*
+
+### Property Reflection
+
+After analyzing all acceptance criteria, I identified several areas where properties can be consolidated to eliminate redundancy:
+
+- **Installation validation properties** (5.1, 5.2, 5.3, 5.4) can be combined into a comprehensive installation validation property
+- **Environment variable management properties** (6.1, 6.2, 6.3) can be consolidated into a single environment update property
+- **Error handling properties** (8.1, 8.2, 8.3, 8.4, 8.5) share common patterns and can be grouped
+- **Version list management properties** (2.4, 4.1, 4.2) can be combined into state consistency properties
+
+### Core Properties
+
+Property 1: **API Version Fetching Consistency**
+*For any* valid API response from golang.org, the Go_Manager should correctly parse and return version information with all required fields (version, downloadUrl, size, sha256)
+**Validates: Requirements 1.1**
+
+Property 2: **Download URL Construction**
+*For any* valid Go version, the Go_Manager should construct the correct Windows 64-bit download URL and initiate the download process
+**Validates: Requirements 1.2**
+
+Property 3: **Download Progress Reporting**
+*For any* download operation, progress events should be emitted with valid data structures containing percentage (0-100), downloaded bytes, and total bytes
+**Validates: Requirements 1.3**
+
+Property 4: **Installation Validation Completeness**
+*For any* successfully installed Go version, the validation should confirm that go.exe exists, go version returns the correct version, gofmt.exe exists, and go mod commands work
+**Validates: Requirements 1.4, 5.1, 5.2, 5.3, 5.4**
+
+Property 5: **Duplicate Installation Prevention**
+*For any* Go version that is already installed, attempting to install it again should return an error message indicating the version is already installed
+**Validates: Requirements 1.5**
+
+Property 6: **File System Cleanup on Uninstall**
+*For any* installed Go version, uninstalling it should completely remove the version directory and all its contents
+**Validates: Requirements 2.2**
+
+Property 7: **Active Version Environment Management**
+*For any* Go version being set as active, the environment variables (PATH, GOROOT, GOPATH) should be updated correctly, and old Go paths should be removed from PATH
+**Validates: Requirements 3.1, 6.1, 6.2, 6.3**
+
+Property 8: **Version State Consistency**
+*For any* operation that changes installed versions (install/uninstall), the installed versions list should be updated to reflect the current state accurately
+**Validates: Requirements 2.4, 4.1**
+
+Property 9: **Version Information Completeness**
+*For any* installed Go version, the version information should include all required fields: version number, installation path, active status, GOROOT, and GOPATH
+**Validates: Requirements 4.2, 4.3**
+
+Property 10: **System Go Detection**
+*For any* system with an existing Go installation, the Go_Manager should detect and display the system version information
+**Validates: Requirements 4.5**
+
+Property 11: **Environment Variable Validation**
+*For any* Go version set as active, executing 'go version' in a new process should return the expected version string
+**Validates: Requirements 3.2, 3.4**
+
+Property 12: **Error Message Descriptiveness**
+*For any* failed operation (network error, disk space, permissions, installation failure), the error message should be descriptive and include actionable suggestions
+**Validates: Requirements 5.5, 6.5, 8.1, 8.2, 8.3, 8.5**
+
+Property 13: **Success Message Completeness**
+*For any* successful operation, the success message should include relevant details about what was accomplished
+**Validates: Requirements 8.4**
+
+Property 14: **GOPATH Default Configuration**
+*For any* Go installation, when configuring GOPATH, it should be set to the user's home directory + '/go' workspace
+**Validates: Requirements 6.4**
+
+<function_calls>
+<invoke name="prework">
+<parameter name="featureName">go-version-management
+
+## Error Handling
+
+### Error Categories and Handling Strategies
+
+#### 1. Network Errors
+- **Connection failures**: Retry mechanism with exponential backoff
+- **API unavailable**: Fallback to cached version list
+- **Download interruption**: Resume capability where possible
+- **Timeout errors**: Configurable timeout with user feedback
+
+#### 2. File System Errors
+- **Insufficient disk space**: Pre-installation space check
+- **Permission denied**: Clear guidance for administrator privileges
+- **File corruption**: SHA256 verification and re-download
+- **Path conflicts**: Automatic path resolution
+
+#### 3. Installation Errors
+- **Incomplete installation**: Automatic cleanup and retry option
+- **Version conflicts**: Clear conflict resolution guidance
+- **Environment variable failures**: Manual configuration instructions
+- **Tool validation failures**: Detailed diagnostic information
+
+#### 4. User Input Errors
+- **Invalid version selection**: Input validation and user feedback
+- **Concurrent operations**: Operation queuing and status indication
+- **Configuration errors**: Validation with helpful error messages
+
+### Error Recovery Mechanisms
+
+```typescript
+interface ErrorRecovery {
+  // 自动重试机制
+  autoRetry: {
+    maxAttempts: number
+    backoffStrategy: 'exponential' | 'linear'
+    retryableErrors: string[]
+  }
+  
+  // 用户引导
+  userGuidance: {
+    errorCode: string
+    message: string
+    suggestedActions: string[]
+    documentationLink?: string
+  }
+  
+  // 状态恢复
+  stateRecovery: {
+    rollbackOnFailure: boolean
+    cleanupTempFiles: boolean
+    restoreEnvironment: boolean
+  }
+}
+```
+
+## Testing Strategy
+
+### Dual Testing Approach
+
+本项目采用单元测试和基于属性的测试相结合的方法，确保全面的代码覆盖和正确性验证。
+
+#### Unit Testing
+- **特定示例验证**: 测试具体的用例和边界条件
+- **集成点测试**: 验证组件间的交互
+- **错误条件测试**: 测试各种错误场景的处理
+- **UI 交互测试**: 验证用户界面的响应和状态更新
+
+#### Property-Based Testing
+- **通用属性验证**: 验证在所有输入下都应该成立的属性
+- **随机输入覆盖**: 通过随机化输入发现边界情况
+- **状态一致性检查**: 验证系统状态的一致性
+- **不变量验证**: 确保系统不变量在所有操作中保持
+
+### Testing Framework Configuration
+
+**Property-Based Testing Library**: 使用 `fast-check` (JavaScript/TypeScript 的属性测试库)
+
+**测试配置要求**:
+- 每个属性测试最少运行 100 次迭代
+- 每个测试必须引用对应的设计文档属性
+- 标签格式: `**Feature: go-version-management, Property {number}: {property_text}**`
+
+**示例测试结构**:
+```typescript
+// 属性测试示例
+describe('Go Version Management Properties', () => {
+  test('Property 1: API Version Fetching Consistency', async () => {
+    // **Feature: go-version-management, Property 1: API Version Fetching Consistency**
+    await fc.assert(fc.asyncProperty(
+      fc.array(fc.record({
+        version: fc.string(),
+        files: fc.array(fc.record({
+          os: fc.constantFrom('windows'),
+          arch: fc.constantFrom('amd64'),
+          kind: fc.constantFrom('archive'),
+          filename: fc.string(),
+          size: fc.nat(),
+          sha256: fc.hexaString({ minLength: 64, maxLength: 64 })
+        }))
+      })),
+      async (mockApiResponse) => {
+        const result = await goManager.parseApiResponse(mockApiResponse)
+        // 验证所有返回的版本都包含必需字段
+        result.forEach(version => {
+          expect(version).toHaveProperty('version')
+          expect(version).toHaveProperty('downloadUrl')
+          expect(version).toHaveProperty('size')
+          expect(version).toHaveProperty('sha256')
+        })
+      }
+    ), { numRuns: 100 })
+  })
+})
+```
+
+### Test Coverage Requirements
+
+- **代码覆盖率**: 最低 85% 的行覆盖率
+- **分支覆盖率**: 最低 80% 的分支覆盖率
+- **属性覆盖率**: 所有定义的正确性属性都必须有对应的测试
+- **集成测试**: 覆盖主要的用户工作流程
+
+### Continuous Integration
+
+- **自动化测试**: 每次代码提交都运行完整测试套件
+- **性能测试**: 监控关键操作的性能指标
+- **兼容性测试**: 在不同 Windows 版本上验证功能
+- **回归测试**: 确保新功能不破坏现有功能
+
+## Implementation Phases
+
+### Phase 1: Core Backend Implementation
+1. 创建 `GoManager.ts` 服务类
+2. 实现版本获取和解析逻辑
+3. 实现下载和安装功能
+4. 添加环境变量管理
+5. 实现基本的错误处理
+
+### Phase 2: Frontend Integration
+1. 创建 `GoManager.vue` 组件
+2. 实现版本列表显示
+3. 添加安装/卸载操作界面
+4. 集成下载进度显示
+5. 实现状态管理和用户反馈
+
+### Phase 3: Advanced Features
+1. 添加系统 Go 检测
+2. 实现高级错误处理和恢复
+3. 添加配置选项和偏好设置
+4. 优化性能和用户体验
+5. 完善文档和帮助信息
+
+### Phase 4: Testing and Polish
+1. 实现完整的测试套件
+2. 进行性能优化
+3. 用户体验改进
+4. 文档完善
+5. 发布准备
+
+## Security Considerations
+
+### Download Security
+- **HTTPS 强制**: 所有下载必须使用 HTTPS
+- **SHA256 验证**: 验证下载文件的完整性
+- **签名验证**: 验证 Go 官方签名（如果可用）
+- **沙箱下载**: 在临时目录中处理下载文件
+
+### Environment Security
+- **权限最小化**: 仅请求必要的系统权限
+- **用户级配置**: 优先使用用户级环境变量
+- **路径验证**: 验证所有文件路径的安全性
+- **清理机制**: 及时清理临时文件和敏感数据
+
+### Input Validation
+- **版本号验证**: 严格验证版本号格式
+- **路径注入防护**: 防止路径遍历攻击
+- **命令注入防护**: 安全地执行系统命令
+- **配置验证**: 验证所有用户配置输入
+
+## Performance Considerations
+
+### Optimization Strategies
+- **缓存机制**: 缓存 API 响应和版本信息
+- **懒加载**: 按需加载版本详细信息
+- **并发控制**: 限制同时进行的下载数量
+- **内存管理**: 及时释放大文件的内存占用
+
+### Monitoring and Metrics
+- **操作耗时**: 监控关键操作的执行时间
+- **内存使用**: 跟踪内存使用情况
+- **网络性能**: 监控下载速度和成功率
+- **错误率**: 跟踪各类操作的错误率
+
+## Future Enhancements
+
+### Potential Features
+1. **Go 模块管理**: 集成 Go 模块和依赖管理
+2. **开发工具集成**: 集成常用的 Go 开发工具
+3. **项目模板**: 提供 Go 项目模板和脚手架
+4. **性能分析**: 集成 Go 性能分析工具
+5. **云端同步**: 同步配置和偏好设置
+
+### Extensibility Points
+- **插件系统**: 支持第三方插件扩展
+- **自定义下载源**: 支持企业内部下载源
+- **配置导入导出**: 支持配置的备份和恢复
+- **API 扩展**: 提供扩展 API 供其他工具使用
\ No newline at end of file
diff --git a/.kiro/specs/go-version-management/requirements.md b/.kiro/specs/go-version-management/requirements.md
new file mode 100644
index 0000000..dd870f0
--- /dev/null
+++ b/.kiro/specs/go-version-management/requirements.md
@@ -0,0 +1,112 @@
+# Requirements Document
+
+## Introduction
+
+为 PHPer 开发环境管理器添加 Go 版本管理功能，使用户能够轻松安装、管理和切换不同版本的 Go 语言开发环境。该功能将与现有的 Node.js 和 Python 版本管理功能保持一致的用户体验。
+
+## Glossary
+
+- **Go_Manager**: Go 版本管理器，负责处理 Go 版本的安装、卸载和切换
+- **Go_Version**: 特定版本的 Go 语言环境，包含编译器和标准库
+- **Active_Version**: 当前系统环境变量中配置的默认 Go 版本
+- **GOPATH**: Go 工作空间路径，用于存放 Go 代码和依赖包
+- **GOROOT**: Go 安装根目录，包含 Go 编译器和标准库
+- **Go_Binary**: Go 可执行文件，包括 go.exe、gofmt.exe 等工具
+
+## Requirements
+
+### Requirement 1: Go 版本安装管理
+
+**User Story:** 作为开发者，我想要安装不同版本的 Go 语言环境，以便在不同项目中使用合适的 Go 版本。
+
+#### Acceptance Criteria
+
+1. WHEN 用户查看可用版本列表 THEN THE Go_Manager SHALL 从 golang.org 官方 API 获取最新的 Go 版本信息
+2. WHEN 用户选择安装特定版本 THEN THE Go_Manager SHALL 下载对应的 Windows 64位安装包
+3. WHEN 下载过程中 THEN THE Go_Manager SHALL 显示下载进度和文件大小信息
+4. WHEN 安装完成后 THEN THE Go_Manager SHALL 验证安装是否成功并显示安装结果
+5. WHEN 用户尝试安装已存在的版本 THEN THE Go_Manager SHALL 提示版本已安装并阻止重复安装
+
+### Requirement 2: Go 版本卸载管理
+
+**User Story:** 作为开发者，我想要卸载不需要的 Go 版本，以便释放磁盘空间和保持系统整洁。
+
+#### Acceptance Criteria
+
+1. WHEN 用户选择卸载某个版本 THEN THE Go_Manager SHALL 显示确认对话框
+2. WHEN 用户确认卸载 THEN THE Go_Manager SHALL 删除该版本的所有文件和目录
+3. WHEN 卸载的是当前活动版本 THEN THE Go_Manager SHALL 清除环境变量配置
+4. WHEN 卸载完成后 THEN THE Go_Manager SHALL 更新已安装版本列表
+5. WHEN 用户尝试卸载不存在的版本 THEN THE Go_Manager SHALL 提示版本未安装
+
+### Requirement 3: Go 版本切换管理
+
+**User Story:** 作为开发者，我想要在不同的 Go 版本之间快速切换，以便在不同项目中使用不同版本的 Go。
+
+#### Acceptance Criteria
+
+1. WHEN 用户选择设置默认版本 THEN THE Go_Manager SHALL 更新系统环境变量 PATH
+2. WHEN 环境变量更新后 THEN THE Go_Manager SHALL 验证新版本是否生效
+3. WHEN 切换成功后 THEN THE Go_Manager SHALL 在界面上标识当前活动版本
+4. WHEN 用户在新终端中执行 go version THEN THE System SHALL 显示新设置的 Go 版本
+5. WHEN 切换版本失败 THEN THE Go_Manager SHALL 显示详细的错误信息
+
+### Requirement 4: Go 版本信息展示
+
+**User Story:** 作为开发者，我想要查看已安装的 Go 版本详细信息，以便了解每个版本的状态和配置。
+
+#### Acceptance Criteria
+
+1. WHEN 用户打开 Go 管理页面 THEN THE Go_Manager SHALL 显示所有已安装版本的列表
+2. WHEN 显示版本信息时 THEN THE Go_Manager SHALL 包含版本号、安装路径和是否为活动版本
+3. WHEN 显示版本信息时 THEN THE Go_Manager SHALL 显示每个版本的 GOROOT 和 GOPATH 配置
+4. WHEN 版本列表为空时 THEN THE Go_Manager SHALL 显示友好的空状态提示
+5. WHEN 检测到系统已安装的 Go THEN THE Go_Manager SHALL 显示系统版本信息
+
+### Requirement 5: Go 工具链集成
+
+**User Story:** 作为开发者，我想要确保安装的 Go 版本包含完整的工具链，以便进行完整的 Go 开发工作。
+
+#### Acceptance Criteria
+
+1. WHEN Go 版本安装完成后 THEN THE Go_Manager SHALL 验证 go.exe 可执行文件存在
+2. WHEN Go 版本安装完成后 THEN THE Go_Manager SHALL 验证 gofmt.exe 格式化工具存在
+3. WHEN Go 版本安装完成后 THEN THE Go_Manager SHALL 验证 go build 命令可正常执行
+4. WHEN Go 版本安装完成后 THEN THE Go_Manager SHALL 验证 go mod 模块管理功能可用
+5. WHEN 工具链验证失败 THEN THE Go_Manager SHALL 提示安装不完整并提供修复建议
+
+### Requirement 6: 配置文件管理
+
+**User Story:** 作为开发者，我想要系统自动管理 Go 相关的配置，以便无需手动配置复杂的环境变量。
+
+#### Acceptance Criteria
+
+1. WHEN 安装新的 Go 版本时 THEN THE Go_Manager SHALL 自动配置 GOROOT 环境变量
+2. WHEN 切换 Go 版本时 THEN THE Go_Manager SHALL 更新用户级别的环境变量
+3. WHEN 设置环境变量时 THEN THE Go_Manager SHALL 清理旧版本的路径配置
+4. WHEN 配置 GOPATH 时 THEN THE Go_Manager SHALL 使用用户工作目录下的 go 文件夹
+5. WHEN 环境变量配置失败 THEN THE Go_Manager SHALL 提供手动配置的指导信息
+
+### Requirement 7: 用户界面集成
+
+**User Story:** 作为开发者，我想要 Go 管理功能与现有界面风格保持一致，以便获得统一的用户体验。
+
+#### Acceptance Criteria
+
+1. WHEN 用户访问 Go 管理页面 THEN THE System SHALL 显示与其他服务管理页面一致的界面布局
+2. WHEN 显示版本卡片时 THEN THE System SHALL 使用与 Node.js 管理页面相同的卡片样式
+3. WHEN 显示操作按钮时 THEN THE System SHALL 使用统一的按钮样式和颜色方案
+4. WHEN 显示状态信息时 THEN THE System SHALL 使用一致的图标和标签样式
+5. WHEN 页面加载时 THEN THE System SHALL 支持 KeepAlive 缓存以提升切换体验
+
+### Requirement 8: 错误处理和用户反馈
+
+**User Story:** 作为开发者，我想要在操作过程中获得清晰的反馈信息，以便了解操作状态和处理可能的错误。
+
+#### Acceptance Criteria
+
+1. WHEN 网络连接失败时 THEN THE Go_Manager SHALL 显示网络错误提示并提供重试选项
+2. WHEN 磁盘空间不足时 THEN THE Go_Manager SHALL 显示空间不足警告并阻止安装
+3. WHEN 权限不足时 THEN THE Go_Manager SHALL 提示需要管理员权限
+4. WHEN 操作成功时 THEN THE Go_Manager SHALL 显示成功消息和相关详情
+5. WHEN 操作失败时 THEN THE Go_Manager SHALL 显示具体的错误原因和解决建议
\ No newline at end of file
diff --git a/.kiro/specs/go-version-management/tasks.md b/.kiro/specs/go-version-management/tasks.md
new file mode 100644
index 0000000..52d6781
--- /dev/null
+++ b/.kiro/specs/go-version-management/tasks.md
@@ -0,0 +1,176 @@
+# Implementation Plan: Go Version Management
+
+## Overview
+
+本实现计划将 Go 版本管理功能集成到 PHPer 开发环境管理器中。实现将遵循现有的 NodeManager 和 PythonManager 架构模式，确保代码一致性和可维护性。所有代码将使用 TypeScript 编写，与项目现有技术栈保持一致。
+
+## Tasks
+
+- [x] 1. 创建 Go 管理器后端服务
+  - [x] 1.1 创建 GoManager.ts 服务类
+    - 创建 `electron/services/GoManager.ts` 文件
+    - 定义核心接口和类型（GoVersion, AvailableGoVersion, GoInfo）
+    - 实现基础类结构和 ConfigStore 集成
+    - _Requirements: 1.1, 4.1, 6.1_
+
+  - [x] 1.2 为核心结构编写单元测试
+    - 测试基础类初始化和配置集成
+    - _Requirements: 1.1, 4.1, 6.1_
+
+- [x] 2. 实现版本获取和管理功能
+  - [x] 2.1 实现 golang.org API 集成
+    - 从 `https://golang.org/dl/?mode=json` 获取版本列表
+    - 解析 API 响应并提取 Windows 64位版本
+    - 实现缓存机制（5分钟缓存）
+    - 添加备用版本列表
+    - _Requirements: 1.1_
+
+  - [x] 2.2 为 API 集成编写属性测试
+    - **Property 1: API Version Fetching Consistency**
+    - **Validates: Requirements 1.1**
+
+  - [x] 2.3 实现已安装版本检测
+    - 扫描本地 Go 安装目录
+    - 验证安装完整性（go.exe, gofmt.exe 等）
+    - 检测当前活动版本
+    - 获取版本详细信息
+    - _Requirements: 4.1, 4.2, 4.5, 5.1, 5.2_
+
+  - [x] 2.4 为版本检测编写属性测试
+    - **Property 9: Version Information Completeness**
+    - **Validates: Requirements 4.2, 4.3**
+
+- [x] 3. 实现下载和安装功能
+  - [x] 3.1 实现文件下载管理器
+    - 支持 HTTPS 下载和进度跟踪
+    - 实现 SHA256 校验和验证
+    - 处理下载中断和重试
+    - 集成到现有的下载进度系统
+    - _Requirements: 1.2, 1.3_
+
+  - [x] 3.2 为下载功能编写属性测试
+    - **Property 2: Download URL Construction**
+    - **Property 3: Download Progress Reporting**
+    - **Validates: Requirements 1.2, 1.3**
+
+  - [x] 3.3 实现 Go 版本安装逻辑
+    - ZIP 文件解压到目标目录
+    - 安装后验证和完整性检查
+    - 重复安装检测和防护
+    - 清理临时文件
+    - _Requirements: 1.4, 1.5, 5.1, 5.2, 5.3, 5.4_
+
+  - [x] 3.4 为安装功能编写属性测试
+    - **Property 4: Installation Validation Completeness**
+    - **Property 5: Duplicate Installation Prevention**
+    - **Validates: Requirements 1.4, 1.5, 5.1, 5.2, 5.3, 5.4**
+
+- [x] 4. 实现环境变量管理
+  - [x] 4.1 实现环境变量更新逻辑
+    - 使用 PowerShell 脚本更新用户环境变量
+    - 设置 GOROOT、GOPATH 和 PATH
+    - 清理旧版本的路径配置
+    - _Requirements: 3.1, 6.1, 6.2, 6.3, 6.4_
+
+  - [x] 4.2 为环境变量管理编写属性测试
+    - **Property 7: Active Version Environment Management**
+    - **Property 14: GOPATH Default Configuration**
+    - **Validates: Requirements 3.1, 6.1, 6.2, 6.3, 6.4**
+
+  - [x] 4.3 实现版本切换和验证
+    - 版本激活和环境变量更新
+    - 切换后的功能验证
+    - 系统级 Go 命令验证
+    - _Requirements: 3.2, 3.3, 3.4_
+
+  - [x] 4.4 为版本切换编写属性测试
+    - **Property 11: Environment Variable Validation**
+    - **Validates: Requirements 3.2, 3.4**
+
+- [x] 5. 实现卸载和清理功能
+  - [x] 5.1 实现版本卸载逻辑
+    - 文件系统清理和目录删除
+    - 活动版本的环境变量清理
+    - 配置状态更新
+    - _Requirements: 2.2, 2.3, 2.4, 2.5_
+
+  - [x] 5.2 为卸载功能编写属性测试
+    - **Property 6: File System Cleanup on Uninstall**
+    - **Property 8: Version State Consistency**
+    - **Validates: Requirements 2.2, 2.4**
+
+- [x] 6. 实现错误处理和用户反馈
+  - [x] 6.1 实现综合错误处理系统
+    - 网络错误、磁盘空间、权限检查
+    - 描述性错误消息和解决建议
+    - 成功操作的详细反馈
+    - _Requirements: 8.1, 8.2, 8.3, 8.4, 8.5_
+
+- [x] 7. 实现 IPC 通信层
+  - [x] 7.1 在主进程中注册 Go 管理 IPC 处理器
+    - 在 `electron/main.ts` 中添加 Go 相关的 IPC 处理函数
+    - 注册 go:getVersions, go:getAvailableVersions, go:install, go:uninstall, go:setActive 等
+    - 集成 GoManager 实例
+    - _Requirements: 所有后端功能_
+
+  - [x] 7.2 更新预加载脚本
+    - 在 `electron/preload.ts` 中暴露 Go 管理 API
+    - 添加 go 对象到 electronAPI
+    - 确保类型安全的 IPC 通信
+    - _Requirements: 所有后端功能_
+
+- [x] 8. 实现前端 Vue 组件
+  - [x] 8.1 创建 GoManager.vue 组件
+    - 创建 `src/views/GoManager.vue` 文件
+    - 设置组件模板和基本布局（参考 NodeManager.vue 和 PythonManager.vue）
+    - 实现 KeepAlive 缓存支持
+    - 添加响应式数据管理
+    - _Requirements: 7.1, 7.5_
+
+  - [x] 8.2 实现版本列表显示功能
+    - 已安装版本的卡片式展示
+    - 版本信息显示（版本号、路径、状态）
+    - 活动版本的视觉标识
+    - 空状态处理和友好提示
+    - _Requirements: 4.1, 4.2, 4.3, 4.4_
+
+  - [x] 8.3 实现版本操作界面
+    - 安装新版本对话框
+    - 可用版本列表和选择
+    - 卸载确认对话框
+    - 版本切换操作按钮
+    - _Requirements: 1.1, 2.1, 3.2_
+
+  - [x] 8.4 实现下载进度和状态反馈
+    - 下载进度条和状态显示
+    - 操作加载状态和按钮禁用
+    - 成功/错误消息提示
+    - 集成到现有的下载进度监听系统
+    - _Requirements: 1.3, 8.4, 8.5_
+
+- [x] 9. 集成到主应用程序
+  - [x] 9.1 添加 Go 管理页面路由
+    - 在 `src/router/index.ts` 中添加 Go 管理路由
+    - 路径: `/go`, 名称: `go`, 组件: `GoManager.vue`
+    - 添加页面标题元数据
+    - _Requirements: 7.1_
+
+  - [x] 9.2 更新应用程序导航
+    - 在主导航中添加 Go 管理入口
+    - 添加 Go 相关的图标
+    - 确保视觉一致性
+    - _Requirements: 7.2, 7.3, 7.4_
+
+- [x] 10. 检查点 - 完整功能验证
+  - 确保所有功能正常工作
+  - 验证用户体验和界面一致性
+  - 询问用户是否有问题或需要调整
+
+## Notes
+
+- 后端 GoManager 服务已完全实现，包含所有核心功能和错误处理
+- 属性测试已实现，覆盖所有关键正确性属性
+- 需要完成 IPC 通信层、前端组件和应用集成
+- 每个任务都引用了具体的需求条目以确保可追溯性
+- 所有代码将使用 TypeScript 编写，与项目技术栈保持一致
+- 实现将遵循现有的 NodeManager 和 PythonManager 架构模式
\ No newline at end of file
diff --git a/.kiro/steering/product.md b/.kiro/steering/product.md
new file mode 100644
index 0000000..8e8e58b
--- /dev/null
+++ b/.kiro/steering/product.md
@@ -0,0 +1,24 @@
+# PHPer 开发环境管理器
+
+PHPer 开发环境管理器是一款专为 Windows 平台设计的 PHP 开发环境管理工具，提供可视化界面来管理多种开发服务和工具。
+
+## 核心功能
+
+- **多版本 PHP 管理**: 支持 PHP 8.1-8.5 多版本并行安装，独立 CGI 进程控制
+- **数据库服务**: MySQL 5.7/8.0 版本管理，自动初始化和配置
+- **Web 服务器**: Nginx 管理，支持虚拟主机和 SSL 证书
+- **缓存服务**: Redis Windows 版本管理
+- **开发工具**: Node.js、Python、Git 版本管理
+- **站点管理**: 可视化创建和管理开发站点，支持 Laravel 项目
+- **系统集成**: Hosts 文件管理，开机自启动配置
+
+## 目标用户
+
+主要面向 Windows 平台的 PHP 开发者，提供类似 XAMPP/WAMP 但更现代化和可定制的开发环境解决方案。
+
+## 技术特点
+
+- 基于 Electron 的桌面应用
+- 使用 Vue 3 + TypeScript 构建前端界面
+- 服务管理采用 Windows 原生进程控制
+- 支持静默启动和系统托盘运行
\ No newline at end of file
diff --git a/.kiro/steering/structure.md b/.kiro/steering/structure.md
new file mode 100644
index 0000000..cad8f4d
--- /dev/null
+++ b/.kiro/steering/structure.md
@@ -0,0 +1,105 @@
+# 项目结构和组织
+
+## 目录结构
+
+### 核心目录
+
+```
+phper/
+├── electron/                    # Electron 主进程代码
+│   ├── main.ts                 # 主进程入口，IPC 处理
+│   ├── preload.ts              # 预加载脚本，安全的 IPC 桥接
+│   └── services/               # 服务管理模块
+│       ├── ConfigStore.ts      # 配置存储管理
+│       ├── ServiceManager.ts   # 统一服务管理
+│       ├── *Manager.ts         # 各服务专用管理器
+│       └── __tests__/          # 服务层单元测试
+│
+├── src/                        # Vue 前端源码
+│   ├── App.vue                 # 根组件，包含布局和导航
+│   ├── main.ts                 # 前端入口文件
+│   ├── router/                 # Vue Router 配置
+│   ├── stores/                 # Pinia 状态管理
+│   ├── components/             # 可复用组件
+│   ├── views/                  # 页面组件
+│   └── styles/                 # 全局样式和主题
+│
+├── data/                       # 运行时数据目录
+├── service/                    # 服务安装目录
+├── build/                      # 构建资源
+├── release/                    # 打包输出
+└── scripts/                    # 构建脚本
+```
+
+## 架构模式
+
+### Electron 架构
+- **主进程** (`electron/main.ts`): 窗口管理、系统集成、IPC 处理
+- **渲染进程** (`src/`): Vue 应用，用户界面
+- **预加载脚本** (`electron/preload.ts`): 安全的 API 暴露
+
+### 服务管理架构
+- **ServiceManager**: 统一的服务生命周期管理
+- **专用管理器**: 每个服务（PHP、MySQL、Nginx等）有独立的管理类
+- **ConfigStore**: 集中的配置管理，基于 electron-store
+
+### 前端架构
+- **组件化**: 使用 Vue 3 Composition API
+- **状态管理**: Pinia stores 管理应用状态
+- **路由管理**: Vue Router 4 单页面应用
+- **UI 组件**: Element Plus 提供一致的界面体验
+
+## 命名约定
+
+### 文件命名
+- **组件文件**: PascalCase (如 `PhpManager.vue`)
+- **服务文件**: PascalCase + Manager 后缀 (如 `MysqlManager.ts`)
+- **工具文件**: camelCase (如 `configStore.ts`)
+- **测试文件**: `*.test.ts` 后缀
+
+### 代码约定
+- **接口**: `I` 前缀 (如 `IServiceStatus`)
+- **类型**: PascalCase (如 `ServiceConfig`)
+- **常量**: UPPER_SNAKE_CASE
+- **函数/变量**: camelCase
+
+## 关键文件说明
+
+### 配置文件
+- `package.json`: 项目依赖和构建脚本
+- `vite.config.ts`: Vite 构建配置，包含 Electron 插件
+- `tsconfig.json`: TypeScript 编译配置
+- `jest.config.js`: 测试框架配置
+
+### 入口文件
+- `index.html`: HTML 模板
+- `src/main.ts`: Vue 应用入口
+- `electron/main.ts`: Electron 主进程入口
+
+### 服务管理
+- 每个服务管理器负责：下载、安装、配置、启动/停止、状态检查
+- 使用 Windows 原生命令和进程管理
+- 支持多版本并存（PHP、MySQL、Node.js）
+
+## 数据流
+
+1. **用户操作** → Vue 组件
+2. **组件事件** → Pinia Store 或直接 IPC 调用
+3. **IPC 通信** → Electron 主进程
+4. **服务调用** → 对应的 Manager 类
+5. **系统操作** → Windows 命令/进程
+6. **状态更新** → 通过 IPC 返回到前端
+
+## 扩展指南
+
+### 添加新服务
+1. 创建 `*Manager.ts` 在 `electron/services/`
+2. 在 `main.ts` 中注册 IPC 处理程序
+3. 创建对应的 Vue 页面组件
+4. 添加路由和导航菜单项
+5. 更新 `ServiceManager.ts` 集成新服务
+
+### 添加新功能
+- 前端功能：在 `src/views/` 添加页面组件
+- 后端功能：在对应的 Manager 类中添加方法
+- 通用组件：在 `src/components/` 创建可复用组件
\ No newline at end of file
diff --git a/.kiro/steering/tech.md b/.kiro/steering/tech.md
new file mode 100644
index 0000000..a329dcd
--- /dev/null
+++ b/.kiro/steering/tech.md
@@ -0,0 +1,84 @@
+# 技术栈和构建系统
+
+## 核心技术栈
+
+### 前端框架
+- **Vue 3**: 使用 Composition API 和 `<script setup>` 语法
+- **TypeScript**: 严格类型检查，配置在 `tsconfig.json`
+- **Element Plus**: UI 组件库，提供现代化界面组件
+- **Vue Router 4**: 单页面应用路由管理
+- **Pinia**: 状态管理，替代 Vuex
+
+### 桌面应用框架
+- **Electron**: 主进程和渲染进程架构
+- **IPC 通信**: 主进程与渲染进程间的安全通信
+- **electron-store**: 应用配置持久化存储
+
+### 构建工具
+- **Vite**: 现代化构建工具，支持热重载
+- **vite-plugin-electron**: Electron 集成插件
+- **electron-builder**: 应用打包和分发
+
+### 开发工具
+- **Jest**: 单元测试框架，配置在 `jest.config.js`
+- **vue-tsc**: Vue 组件类型检查
+- **Sass**: CSS 预处理器，支持主题变量
+
+## 常用命令
+
+### 开发环境
+```bash
+# 启动开发服务器
+npm run dev
+
+# 类型检查
+npm run typecheck
+
+# 运行测试
+npm run test
+npm run test:watch
+```
+
+### 构建和打包
+```bash
+# 构建生产版本（自动更新 patch 版本）
+npm run build
+
+# 指定版本更新类型
+npm run build:patch   # 1.0.0 -> 1.0.1
+npm run build:minor   # 1.0.0 -> 1.1.0
+npm run build:major   # 1.0.0 -> 2.0.0
+
+# 不更新版本号直接打包
+npm run build:nobump
+
+# 构建前进行类型检查
+npm run build:check
+```
+
+## 关键依赖
+
+### 生产依赖
+- `axios`: HTTP 客户端
+- `unzipper`: 文件解压缩
+- `node-windows`: Windows 服务管理
+- `sudo-prompt`: 管理员权限提升
+
+### 开发依赖
+- `concurrently`: 并行运行多个命令
+- `fast-check`: 属性测试库
+- `ts-jest`: TypeScript Jest 支持
+
+## 构建配置
+
+- **输出目录**: `dist` (前端), `dist-electron` (Electron)
+- **图标**: `build/icon.ico`
+- **安装包**: 生成到 `release` 目录
+- **目标平台**: Windows x64 (NSIS 和 Portable)
+
+## 开发注意事项
+
+- 使用 `windowsHide: true` 隐藏命令行窗口
+- 服务启动使用 VBScript 实现静默启动
+- 需要管理员权限进行服务管理和 hosts 文件修改
+- 支持开机自启动（任务计划程序）
\ No newline at end of file
diff --git a/electron/main.ts b/electron/main.ts
index d38a934..e3bcf2e 100644
--- a/electron/main.ts
+++ b/electron/main.ts
@@ -17,6 +17,7 @@ import { ServiceManager } from "./services/ServiceManager";
 import { HostsManager } from "./services/HostsManager";
 import { GitManager } from "./services/GitManager";
 import { PythonManager } from "./services/PythonManager";
+import { GoManager } from "./services/GoManager";
 import { LogManager } from "./services/LogManager";
 import { ConfigStore } from "./services/ConfigStore";
 
@@ -121,6 +122,7 @@ const serviceManager = new ServiceManager(configStore);
 const hostsManager = new HostsManager();
 const gitManager = new GitManager(configStore);
 const pythonManager = new PythonManager(configStore);
+const goManager = new GoManager(configStore);
 const logManager = new LogManager(configStore);
 
 function createWindow() {
@@ -566,6 +568,30 @@ ipcMain.handle(
     pythonManager.installPackage(version, packageName)
 );
 
+// ==================== Go 管理 ====================
+ipcMain.handle("go:getVersions", () => goManager.getInstalledVersions());
+ipcMain.handle("go:getAvailableVersions", () =>
+  goManager.getAvailableVersions()
+);
+ipcMain.handle("go:install", (_, version: string, downloadUrl: string, expectedSha256?: string) =>
+  goManager.install(version, downloadUrl, expectedSha256)
+);
+ipcMain.handle("go:uninstall", (_, version: string) =>
+  goManager.uninstall(version)
+);
+ipcMain.handle("go:setActive", (_, version: string) =>
+  goManager.setActive(version)
+);
+ipcMain.handle("go:validateInstallation", (_, version: string) =>
+  goManager.validateInstallation(version)
+);
+ipcMain.handle("go:getInfo", (_, version: string) =>
+  goManager.getGoInfo(version)
+);
+ipcMain.handle("go:detectSystemVersion", () =>
+  goManager.detectSystemGoVersion()
+);
+
 // ==================== 配置管理 ====================
 ipcMain.handle("config:get", (_, key: string) => configStore.get(key));
 ipcMain.handle("config:set", (_, key: string, value: any) =>
diff --git a/electron/preload.ts b/electron/preload.ts
index 10c598b..d8b41fa 100644
--- a/electron/preload.ts
+++ b/electron/preload.ts
@@ -133,6 +133,18 @@ contextBridge.exposeInMainWorld('electronAPI', {
     installPackage: (version: string, packageName: string) => ipcRenderer.invoke('python:installPackage', version, packageName)
   },
 
+  // Go 管理
+  go: {
+    getVersions: () => ipcRenderer.invoke('go:getVersions'),
+    getAvailableVersions: () => ipcRenderer.invoke('go:getAvailableVersions'),
+    install: (version: string, downloadUrl: string, expectedSha256?: string) => ipcRenderer.invoke('go:install', version, downloadUrl, expectedSha256),
+    uninstall: (version: string) => ipcRenderer.invoke('go:uninstall', version),
+    setActive: (version: string) => ipcRenderer.invoke('go:setActive', version),
+    validateInstallation: (version: string) => ipcRenderer.invoke('go:validateInstallation', version),
+    getInfo: (version: string) => ipcRenderer.invoke('go:getInfo', version),
+    detectSystemVersion: () => ipcRenderer.invoke('go:detectSystemVersion')
+  },
+
   // 服务管理
   service: {
     getAll: () => ipcRenderer.invoke('service:getAll'),
@@ -213,6 +225,7 @@ const api = {
   mysql: {} as any,
   nginx: {} as any,
   redis: {} as any,
+  go: {} as any,
   service: {} as any,
   hosts: {} as any,
   config: {} as any
diff --git a/electron/services/ConfigStore.ts b/electron/services/ConfigStore.ts
index b914514..3454544 100644
--- a/electron/services/ConfigStore.ts
+++ b/electron/services/ConfigStore.ts
@@ -10,8 +10,10 @@ interface ConfigSchema {
   nginxVersions: string[];
   redisVersions: string[];
   nodeVersions: string[];
+  goVersions: string[];
   activePhpVersion: string;
   activeNodeVersion: string;
+  activeGoVersion: string;
   autoStart: {
     nginx: boolean;
     mysql: boolean;
@@ -66,8 +68,10 @@ export class ConfigStore {
         nginxVersions: [],
         redisVersions: [],
         nodeVersions: [],
+        goVersions: [],
         activePhpVersion: "",
         activeNodeVersion: "",
+        activeGoVersion: "",
         autoStart: {
           nginx: false,
           mysql: false,
@@ -99,6 +103,7 @@ export class ConfigStore {
       join(this.basePath, "nginx", "ssl"),
       join(this.basePath, "redis"),
       join(this.basePath, "nodejs"),
+      join(this.basePath, "go"),
       join(this.basePath, "logs"),
       join(this.basePath, "temp"),
       join(this.basePath, "www"),
@@ -149,6 +154,10 @@ export class ConfigStore {
     return join(this.basePath, "nodejs");
   }
 
+  getGoPath(): string {
+    return join(this.basePath, "go");
+  }
+
   getLogsPath(): string {
     return join(this.basePath, "logs");
   }
diff --git a/electron/services/GoManager.ts b/electron/services/GoManager.ts
new file mode 100644
index 0000000..b305945
--- /dev/null
+++ b/electron/services/GoManager.ts
@@ -0,0 +1,2048 @@
+import { ConfigStore } from './ConfigStore'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import { existsSync, mkdirSync, readdirSync, rmSync, readFileSync, writeFileSync, unlinkSync, statSync } from 'fs'
+import { join } from 'path'
+import https from 'https'
+import http from 'http'
+import { createWriteStream, createReadStream } from 'fs'
+import { sendDownloadProgress } from '../main'
+import { createHash } from 'crypto'
+
+// Import unzipper with any type to avoid type issues
+const unzipper = require('unzipper')
+
+const execAsync = promisify(exec)
+
+// ==================== 错误处理系统 ====================
+
+/**
+ * Go 管理器错误类型枚举
+ */
+enum GoErrorType {
+  NETWORK_ERROR = 'NETWORK_ERROR',
+  DISK_SPACE_ERROR = 'DISK_SPACE_ERROR',
+  PERMISSION_ERROR = 'PERMISSION_ERROR',
+  VALIDATION_ERROR = 'VALIDATION_ERROR',
+  FILE_SYSTEM_ERROR = 'FILE_SYSTEM_ERROR',
+  ENVIRONMENT_ERROR = 'ENVIRONMENT_ERROR',
+  DOWNLOAD_ERROR = 'DOWNLOAD_ERROR',
+  INSTALLATION_ERROR = 'INSTALLATION_ERROR',
+  UNINSTALL_ERROR = 'UNINSTALL_ERROR',
+  CONFIGURATION_ERROR = 'CONFIGURATION_ERROR'
+}
+
+/**
+ * Go 管理器自定义错误类
+ * 提供结构化的错误信息和解决建议
+ */
+class GoManagerError extends Error {
+  public readonly type: GoErrorType
+  public readonly suggestion: string
+  public readonly retryable: boolean
+  public readonly details?: any
+
+  constructor(
+    type: GoErrorType,
+    message: string,
+    suggestion: string,
+    retryable: boolean = false,
+    details?: any
+  ) {
+    super(message)
+    this.name = 'GoManagerError'
+    this.type = type
+    this.suggestion = suggestion
+    this.retryable = retryable
+    this.details = details
+  }
+}
+
+/**
+ * 操作结果接口
+ * 统一的操作结果格式，包含成功状态、消息和详细信息
+ */
+interface OperationResult {
+  success: boolean
+  message: string
+  suggestion?: string
+  retryable?: boolean
+  details?: any
+}
+
+/**
+ * 系统资源检查结果
+ */
+interface SystemResourceCheck {
+  hasPermission: boolean
+  hasDiskSpace: boolean
+  availableSpace: number
+  requiredSpace: number
+  permissionDetails?: string
+}
+
+/**
+ * 网络连接检查结果
+ */
+interface NetworkCheck {
+  isConnected: boolean
+  canReachGolang: boolean
+  responseTime?: number
+  error?: string
+}
+
+interface GoVersion {
+  version: string        // 版本号，如 "1.21.5"
+  path: string          // 安装路径
+  isActive: boolean     // 是否为当前活动版本
+  goroot: string        // GOROOT 路径
+  gopath?: string       // GOPATH 路径（可选）
+  installDate?: Date    // 安装日期
+  size?: number         // 安装大小（字节）
+}
+
+interface AvailableGoVersion {
+  version: string       // 版本号
+  stable: boolean       // 是否为稳定版本
+  downloadUrl: string   // Windows 64位 ZIP 下载链接
+  size: number         // 文件大小（字节）
+  sha256: string       // SHA256 校验和
+  releaseDate?: string // 发布日期
+}
+
+interface GoInfo {
+  version: string       // Go 版本
+  goroot: string       // GOROOT 路径
+  gopath: string       // GOPATH 路径
+  goversion: string    // go version 命令输出
+  goos: string         // 目标操作系统
+  goarch: string       // 目标架构
+}
+
+interface GoRelease {
+  version: string
+  stable: boolean
+  files: GoFile[]
+}
+
+interface GoFile {
+  filename: string
+  os: string
+  arch: string
+  version: string
+  sha256: string
+  size: number
+  kind: 'archive' | 'installer' | 'source'
+}
+
+interface DownloadOptions {
+  url: string
+  dest: string
+  name: string
+  expectedSha256?: string
+  maxRetries?: number
+  timeout?: number
+}
+
+interface DownloadProgress {
+  percent: number
+  downloadedBytes: number
+  totalBytes: number
+  speed?: number
+}
+
+interface DownloadResult {
+  success: boolean
+  message: string
+  suggestion?: string
+  retryable?: boolean
+  details?: any
+  filePath?: string
+}
+
+export class GoManager {
+  private configStore: ConfigStore
+  private versionsCache: AvailableGoVersion[] = []
+  private cacheTime: number = 0
+  private readonly CACHE_DURATION = 5 * 60 * 1000 // 5 分钟缓存
+
+  constructor(configStore: ConfigStore) {
+    this.configStore = configStore
+  }
+
+  // ==================== 综合错误处理系统 ====================
+
+  /**
+   * 检查系统资源（磁盘空间和权限）
+   * Requirements: 8.2, 8.3
+   */
+  private async checkSystemResources(requiredSpaceBytes: number = 500 * 1024 * 1024): Promise<SystemResourceCheck> {
+    const result: SystemResourceCheck = {
+      hasPermission: false,
+      hasDiskSpace: false,
+      availableSpace: 0,
+      requiredSpace: requiredSpaceBytes
+    }
+
+    try {
+      // 检查磁盘空间
+      const goBasePath = this.getGoBasePath()
+      const drive = goBasePath.split(':')[0] + ':'
+      
+      try {
+        const { stdout } = await execAsync(`powershell "Get-WmiObject -Class Win32_LogicalDisk -Filter \\"DeviceID='${drive}'\\" | Select-Object FreeSpace"`, { timeout: 10000 })
+        const freeSpaceMatch = stdout.match(/(\d+)/)
+        if (freeSpaceMatch) {
+          result.availableSpace = parseInt(freeSpaceMatch[1], 10)
+          result.hasDiskSpace = result.availableSpace >= requiredSpaceBytes
+        }
+      } catch (error) {
+        console.warn('磁盘空间检查失败，使用默认值')
+        result.availableSpace = requiredSpaceBytes // 假设有足够空间
+        result.hasDiskSpace = true
+      }
+
+      // 检查写入权限
+      try {
+        const testDir = join(goBasePath, 'permission_test')
+        if (!existsSync(goBasePath)) {
+          mkdirSync(goBasePath, { recursive: true })
+        }
+        mkdirSync(testDir, { recursive: true })
+        rmSync(testDir, { recursive: true, force: true })
+        result.hasPermission = true
+      } catch (error: any) {
+        result.hasPermission = false
+        result.permissionDetails = error.message
+      }
+
+    } catch (error: any) {
+      console.error('系统资源检查失败:', error)
+      result.permissionDetails = error.message
+    }
+
+    return result
+  }
+
+  /**
+   * 检查网络连接
+   * Requirements: 8.1
+   */
+  private async checkNetworkConnection(): Promise<NetworkCheck> {
+    const result: NetworkCheck = {
+      isConnected: false,
+      canReachGolang: false
+    }
+
+    try {
+      // 检查基本网络连接
+      const startTime = Date.now()
+      await new Promise<void>((resolve, reject) => {
+        const req = https.get('https://golang.org', { timeout: 10000 }, (res) => {
+          result.isConnected = true
+          result.canReachGolang = res.statusCode === 200 || res.statusCode === 301 || res.statusCode === 302
+          result.responseTime = Date.now() - startTime
+          resolve()
+        })
+        
+        req.on('error', (error) => {
+          result.error = error.message
+          reject(error)
+        })
+        
+        req.on('timeout', () => {
+          req.destroy()
+          result.error = '连接超时'
+          reject(new Error('连接超时'))
+        })
+      })
+    } catch (error: any) {
+      result.error = error.message
+    }
+
+    return result
+  }
+
+  /**
+   * 创建结构化的错误结果
+   * Requirements: 8.5
+   */
+  private createErrorResult(error: GoManagerError | Error, operation: string): OperationResult {
+    if (error instanceof GoManagerError) {
+      return {
+        success: false,
+        message: `${operation}失败: ${error.message}`,
+        suggestion: error.suggestion,
+        retryable: error.retryable,
+        details: error.details
+      }
+    }
+
+    // 处理普通错误，提供通用建议
+    let suggestion = '请检查网络连接和系统权限，然后重试'
+    let retryable = true
+
+    // 根据错误消息提供具体建议
+    const errorMessage = error.message.toLowerCase()
+    if (errorMessage.includes('network') || errorMessage.includes('timeout') || errorMessage.includes('连接')) {
+      suggestion = '网络连接失败，请检查网络设置并重试。如果问题持续，请尝试使用VPN或更换网络环境'
+      retryable = true
+    } else if (errorMessage.includes('permission') || errorMessage.includes('access') || errorMessage.includes('权限')) {
+      suggestion = '权限不足，请以管理员身份运行程序，或检查目标目录的写入权限'
+      retryable = false
+    } else if (errorMessage.includes('space') || errorMessage.includes('disk') || errorMessage.includes('磁盘')) {
+      suggestion = '磁盘空间不足，请清理磁盘空间后重试。建议至少保留500MB可用空间'
+      retryable = false
+    } else if (errorMessage.includes('sha256') || errorMessage.includes('checksum') || errorMessage.includes('校验')) {
+      suggestion = '文件校验失败，可能是下载过程中文件损坏。请删除临时文件并重新下载'
+      retryable = true
+    }
+
+    return {
+      success: false,
+      message: `${operation}失败: ${error.message}`,
+      suggestion,
+      retryable
+    }
+  }
+
+  /**
+   * 创建成功结果
+   * Requirements: 8.4
+   */
+  private createSuccessResult(message: string, details?: any): OperationResult {
+    return {
+      success: true,
+      message,
+      details
+    }
+  }
+
+  /**
+   * 处理网络错误并提供重试选项
+   * Requirements: 8.1
+   */
+  private async handleNetworkError(operation: () => Promise<any>, maxRetries: number = 3): Promise<any> {
+    let lastError: Error | null = null
+    
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        // 在重试前检查网络连接
+        if (attempt > 1) {
+          console.log(`第 ${attempt} 次尝试前检查网络连接...`)
+          const networkCheck = await this.checkNetworkConnection()
+          if (!networkCheck.isConnected) {
+            throw new GoManagerError(
+              GoErrorType.NETWORK_ERROR,
+              '网络连接不可用',
+              '请检查网络连接后重试。确保可以访问 golang.org',
+              true,
+              { networkCheck }
+            )
+          }
+        }
+
+        return await operation()
+      } catch (error: any) {
+        lastError = error
+        console.error(`尝试 ${attempt}/${maxRetries} 失败:`, error.message)
+        
+        if (attempt < maxRetries) {
+          // 指数退避重试
+          const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000)
+          console.log(`等待 ${delay}ms 后重试...`)
+          await new Promise(resolve => setTimeout(resolve, delay))
+        }
+      }
+    }
+
+    // 所有重试都失败了
+    throw new GoManagerError(
+      GoErrorType.NETWORK_ERROR,
+      `网络操作失败（已重试 ${maxRetries} 次）: ${lastError?.message || '未知错误'}`,
+      '请检查网络连接，确保可以访问 golang.org。如果问题持续，请尝试使用VPN或联系网络管理员',
+      true,
+      { attempts: maxRetries, lastError: lastError?.message }
+    )
+  }
+
+  /**
+   * 验证系统环境并抛出具体错误
+   * Requirements: 8.2, 8.3
+   */
+  private async validateSystemEnvironment(requiredSpaceBytes: number = 500 * 1024 * 1024): Promise<void> {
+    const resourceCheck = await this.checkSystemResources(requiredSpaceBytes)
+
+    if (!resourceCheck.hasDiskSpace) {
+      const availableMB = Math.round(resourceCheck.availableSpace / (1024 * 1024))
+      const requiredMB = Math.round(requiredSpaceBytes / (1024 * 1024))
+      
+      throw new GoManagerError(
+        GoErrorType.DISK_SPACE_ERROR,
+        `磁盘空间不足，可用空间 ${availableMB}MB，需要 ${requiredMB}MB`,
+        `请清理磁盘空间，至少需要 ${requiredMB}MB 可用空间。建议清理临时文件、回收站或卸载不需要的程序`,
+        false,
+        { availableSpace: resourceCheck.availableSpace, requiredSpace: requiredSpaceBytes }
+      )
+    }
+
+    if (!resourceCheck.hasPermission) {
+      throw new GoManagerError(
+        GoErrorType.PERMISSION_ERROR,
+        '权限不足，无法写入目标目录',
+        '请以管理员身份运行程序，或确保当前用户对安装目录有写入权限。您也可以尝试更改安装目录到用户文件夹',
+        false,
+        { permissionDetails: resourceCheck.permissionDetails }
+      )
+    }
+  }
+
+  /**
+   * 获取 Go 基础安装路径
+   */
+  getGoBasePath(): string {
+    return join(this.configStore.getBasePath(), 'go')
+  }
+
+  /**
+   * 获取指定版本的 Go 路径
+   */
+  getGoPath(version: string): string {
+    return join(this.getGoBasePath(), `go-${version}`)
+  }
+
+  /**
+   * 获取默认 GOPATH 工作空间路径
+   */
+  getDefaultGoPath(): string {
+    return join(this.getGoBasePath(), 'workspace')
+  }
+
+  /**
+   * 获取已安装的 Go 版本
+   */
+  async getInstalledVersions(): Promise<GoVersion[]> {
+    const versions: GoVersion[] = []
+    const goBasePath = this.getGoBasePath()
+
+    if (!existsSync(goBasePath)) {
+      return versions
+    }
+
+    const dirs = readdirSync(goBasePath, { withFileTypes: true })
+    const activeVersion = this.configStore.get('activeGoVersion' as any) || ''
+
+    for (const dir of dirs) {
+      if (dir.isDirectory() && dir.name.startsWith('go-')) {
+        const versionDir = join(goBasePath, dir.name)
+        const goExe = join(versionDir, 'bin', 'go.exe')
+        const gofmtExe = join(versionDir, 'bin', 'gofmt.exe')
+
+        // 验证安装完整性
+        if (existsSync(goExe) && existsSync(gofmtExe)) {
+          const version = dir.name.replace('go-', '')
+          const goroot = versionDir
+          const gopath = this.getDefaultGoPath()
+
+          // 获取安装日期和大小信息
+          let installDate: Date | undefined
+          let size: number | undefined
+          
+          try {
+            const stats = require('fs').statSync(versionDir)
+            installDate = stats.birthtime || stats.mtime
+            
+            // 计算目录大小（简化版本，只统计主要文件）
+            const binDir = join(versionDir, 'bin')
+            if (existsSync(binDir)) {
+              const binFiles = readdirSync(binDir)
+              size = binFiles.reduce((total, file) => {
+                try {
+                  const filePath = join(binDir, file)
+                  const fileStats = require('fs').statSync(filePath)
+                  return total + fileStats.size
+                } catch {
+                  return total
+                }
+              }, 0)
+            }
+          } catch {
+            // 忽略统计错误
+          }
+
+          versions.push({
+            version,
+            path: versionDir,
+            isActive: version === activeVersion,
+            goroot,
+            gopath,
+            installDate,
+            size
+          })
+        }
+      }
+    }
+
+    // 按版本号排序（降序）
+    versions.sort((a, b) => {
+      const aParts = a.version.replace('go', '').split('.').map(Number)
+      const bParts = b.version.replace('go', '').split('.').map(Number)
+      for (let i = 0; i < 3; i++) {
+        if (aParts[i] !== bParts[i]) {
+          return bParts[i] - aParts[i]
+        }
+      }
+      return 0
+    })
+
+    return versions
+  }
+
+  /**
+   * 获取可用的 Go 版本列表
+   * 增强的错误处理，包含网络重试机制
+   * Requirements: 8.1
+   */
+  async getAvailableVersions(): Promise<AvailableGoVersion[]> {
+    // 检查缓存
+    if (this.versionsCache.length > 0 && Date.now() - this.cacheTime < this.CACHE_DURATION) {
+      return this.versionsCache
+    }
+
+    try {
+      // 使用网络错误处理包装器
+      const versions = await this.handleNetworkError(async () => {
+        return await this.fetchGoVersions()
+      }, 3)
+
+      if (versions.length > 0) {
+        this.versionsCache = versions
+        this.cacheTime = Date.now()
+        return versions
+      }
+    } catch (error) {
+      console.error('获取 Go 版本列表失败:', error)
+      
+      // 如果是网络错误，记录详细信息但不抛出异常
+      if (error instanceof GoManagerError && error.type === GoErrorType.NETWORK_ERROR) {
+        console.warn('使用备用版本列表，因为网络获取失败:', error.message)
+      }
+    }
+
+    // 返回硬编码的版本列表作为后备
+    console.log('使用备用版本列表')
+    return this.getFallbackVersions()
+  }
+
+  /**
+   * 从 golang.org API 获取版本列表
+   */
+  private async fetchGoVersions(): Promise<AvailableGoVersion[]> {
+    return new Promise((resolve, reject) => {
+      const url = 'https://golang.org/dl/?mode=json'
+
+      https.get(url, {
+        headers: {
+          'User-Agent': 'PHPer-Dev-Manager/1.0'
+        },
+        timeout: 30000
+      }, (res) => {
+        if (res.statusCode === 301 || res.statusCode === 302) {
+          const redirectUrl = res.headers.location
+          if (redirectUrl) {
+            https.get(redirectUrl, (redirectRes) => {
+              this.handleVersionResponse(redirectRes, resolve, reject)
+            }).on('error', reject)
+            return
+          }
+        }
+        this.handleVersionResponse(res, resolve, reject)
+      }).on('error', reject)
+        .on('timeout', () => reject(new Error('请求超时')))
+    })
+  }
+
+  private handleVersionResponse(res: http.IncomingMessage, resolve: (value: AvailableGoVersion[]) => void, reject: (reason?: any) => void) {
+    let data = ''
+    res.on('data', chunk => data += chunk)
+    res.on('end', () => {
+      try {
+        const releases: GoRelease[] = JSON.parse(data)
+        const availableVersions: AvailableGoVersion[] = []
+
+        for (const release of releases) {
+          if (release.stable) {
+            const windowsFile = release.files.find(f => 
+              f.os === 'windows' && f.arch === 'amd64' && f.kind === 'archive'
+            )
+            
+            if (windowsFile) {
+              availableVersions.push({
+                version: release.version,
+                stable: release.stable,
+                downloadUrl: `https://golang.org/dl/${windowsFile.filename}`,
+                size: windowsFile.size,
+                sha256: windowsFile.sha256
+              })
+            }
+          }
+        }
+
+        // 只返回前 20 个版本
+        resolve(availableVersions.slice(0, 20))
+      } catch (e) {
+        reject(e)
+      }
+    })
+    res.on('error', reject)
+  }
+
+  /**
+   * 安装 Go 版本
+   * 包含完整的安装流程：下载、解压、验证、配置
+   * 增强的错误处理和用户反馈
+   * Requirements: 8.1, 8.2, 8.3, 8.4, 8.5
+   */
+  async install(version: string, downloadUrl: string, expectedSha256?: string): Promise<OperationResult> {
+    try {
+      console.log(`开始安装 Go ${version}...`)
+      
+      // 1. 系统环境验证（磁盘空间和权限检查）
+      console.log('检查系统环境...')
+      await this.validateSystemEnvironment(500 * 1024 * 1024) // 500MB 最小空间要求
+
+      const goBasePath = this.getGoBasePath()
+      const tempPath = this.configStore.getTempPath()
+      const zipPath = join(tempPath, `go-${version}.zip`)
+      const extractDir = join(goBasePath, `go-${version}`)
+
+      // 确保目录存在
+      if (!existsSync(goBasePath)) {
+        mkdirSync(goBasePath, { recursive: true })
+      }
+      if (!existsSync(tempPath)) {
+        mkdirSync(tempPath, { recursive: true })
+      }
+
+      // 2. 重复安装检测和防护
+      if (await this.isVersionInstalled(version)) {
+        return {
+          success: false,
+          message: `Go ${version} 已安装`,
+          suggestion: '如需重新安装，请先卸载现有版本',
+          retryable: false
+        }
+      }
+
+      console.log(`系统环境检查通过，开始安装 Go ${version}`)
+
+      try {
+        // 3. 下载（使用增强的下载管理器，包含网络重试和 SHA256 验证）
+        console.log(`正在下载 Go ${version}...`)
+        await this.downloadFile(downloadUrl, zipPath, `go-${version}`, expectedSha256)
+
+        // 4. ZIP 文件解压到目标目录
+        console.log(`正在解压 Go ${version}...`)
+        await this.extractGoArchive(zipPath, goBasePath, version)
+
+        // 5. 安装后验证和完整性检查
+        console.log(`正在验证 Go ${version} 安装...`)
+        const validationResult = await this.performInstallationValidation(version)
+        if (!validationResult.isValid) {
+          // 如果验证失败，清理安装目录
+          await this.cleanupFailedInstallation(extractDir)
+          throw new GoManagerError(
+            GoErrorType.VALIDATION_ERROR,
+            `安装验证失败: ${validationResult.error}`,
+            '安装文件可能损坏，请重新下载安装。如果问题持续，请检查网络连接或尝试其他版本',
+            true,
+            { validationError: validationResult.error }
+          )
+        }
+
+        // 6. 更新配置
+        await this.updateInstallationConfig(version)
+
+        // 7. 如果是第一个版本，设为默认
+        const installedVersions = await this.getInstalledVersions()
+        let activationMessage = ''
+        if (installedVersions.length === 1) {
+          const activationResult = await this.setActive(version)
+          if (activationResult.success) {
+            activationMessage = '，并已设为默认版本'
+          }
+        }
+
+        // 8. 返回详细的成功信息
+        const installPath = this.getGoPath(version)
+        return this.createSuccessResult(
+          `Go ${version} 安装成功${activationMessage}`,
+          {
+            version,
+            installPath,
+            isActive: installedVersions.length === 1,
+            totalVersions: installedVersions.length,
+            nextSteps: installedVersions.length === 1 
+              ? ['Go 已设为默认版本，可以在新的命令行窗口中使用 go 命令']
+              : [`使用 "设为默认" 按钮来激活 Go ${version}`, '或继续安装其他版本']
+          }
+        )
+
+      } finally {
+        // 清理临时文件（无论成功还是失败）
+        await this.cleanupTempFiles(zipPath)
+      }
+
+    } catch (error: any) {
+      console.error(`Go ${version} 安装失败:`, error)
+      return this.createErrorResult(error, `Go ${version} 安装`)
+    }
+  }
+
+  /**
+   * 卸载 Go 版本
+   * 包含完整的文件系统清理、环境变量清理和配置状态更新
+   * 增强的错误处理和用户反馈
+   * Requirements: 2.2, 2.3, 2.4, 2.5, 8.3, 8.4, 8.5
+   */
+  async uninstall(version: string): Promise<OperationResult> {
+    try {
+      console.log(`开始卸载 Go ${version}...`)
+      
+      // 1. 权限检查
+      await this.validateSystemEnvironment(0) // 卸载不需要磁盘空间，但需要权限
+      
+      const goBasePath = this.getGoBasePath()
+      const versionDir = join(goBasePath, `go-${version}`)
+
+      // 2. 检查版本是否存在
+      if (!existsSync(versionDir)) {
+        return {
+          success: false,
+          message: `Go ${version} 未安装`,
+          suggestion: '请检查版本号是否正确，或刷新版本列表',
+          retryable: false
+        }
+      }
+
+      // 3. 获取当前活动版本
+      const activeVersion = this.configStore.get('activeGoVersion' as any)
+      const isActiveVersion = activeVersion === version
+
+      console.log(`版本目录: ${versionDir}`)
+      console.log(`是否为活动版本: ${isActiveVersion}`)
+
+      // 4. 如果是当前活动版本，执行环境变量清理
+      if (isActiveVersion) {
+        console.log('清理活动版本的环境变量...')
+        try {
+          await this.cleanupActiveVersionEnvironment(version)
+        } catch (error: any) {
+          throw new GoManagerError(
+            GoErrorType.ENVIRONMENT_ERROR,
+            `环境变量清理失败: ${error.message}`,
+            '请手动清理环境变量，或以管理员身份重试。您可以在系统设置中手动删除 GOROOT 和 GOPATH 环境变量',
+            true,
+            { environmentError: error.message }
+          )
+        }
+      }
+
+      // 5. 执行文件系统清理和目录删除
+      console.log('执行文件系统清理...')
+      try {
+        await this.performFileSystemCleanup(versionDir, version)
+      } catch (error: any) {
+        throw new GoManagerError(
+          GoErrorType.FILE_SYSTEM_ERROR,
+          `文件系统清理失败: ${error.message}`,
+          '可能有文件正在使用中。请关闭所有相关程序（如 IDE、终端）后重试，或重启计算机后再次尝试',
+          true,
+          { fileSystemError: error.message }
+        )
+      }
+
+      // 6. 更新配置状态
+      console.log('更新配置状态...')
+      try {
+        await this.updateUninstallConfiguration(version, isActiveVersion)
+      } catch (error: any) {
+        // 配置更新失败不应该阻止卸载成功
+        console.warn('配置状态更新失败，但文件已删除:', error.message)
+      }
+
+      // 7. 检查剩余版本并提供建议
+      const remainingVersions = await this.getInstalledVersions()
+      let nextSteps: string[] = []
+      
+      if (remainingVersions.length === 0) {
+        nextSteps.push('所有 Go 版本已卸载，环境变量已清理')
+      } else if (isActiveVersion && remainingVersions.length > 0) {
+        nextSteps.push(`还有 ${remainingVersions.length} 个版本可用`)
+        nextSteps.push('请选择一个版本设为默认，或安装新版本')
+      }
+
+      console.log(`Go ${version} 卸载完成`)
+      return this.createSuccessResult(
+        `Go ${version} 已成功卸载`,
+        {
+          version,
+          wasActive: isActiveVersion,
+          remainingVersions: remainingVersions.length,
+          nextSteps
+        }
+      )
+
+    } catch (error: any) {
+      console.error(`Go ${version} 卸载失败:`, error)
+      return this.createErrorResult(error, `Go ${version} 卸载`)
+    }
+  }
+
+  /**
+   * 清理活动版本的环境变量
+   * 移除 GOROOT、GOPATH 和 PATH 中的相关配置
+   * 增强的错误处理
+   * Requirements: 2.3, 8.3, 8.5
+   */
+  private async cleanupActiveVersionEnvironment(version: string): Promise<void> {
+    try {
+      const versionDir = this.getGoPath(version)
+      
+      console.log(`清理活动版本 ${version} 的环境变量`)
+      
+      // 使用专门的环境变量清理脚本
+      const cleanupScript = this.generateActiveVersionCleanupScript()
+      await this.executePowerShellScript(cleanupScript)
+      
+      console.log(`活动版本环境变量清理完成`)
+      
+    } catch (error: any) {
+      console.error(`环境变量清理失败: ${error.message}`)
+      
+      // 如果是 GoManagerError，直接重新抛出
+      if (error instanceof GoManagerError) {
+        throw error
+      }
+      
+      // 否则包装为 GoManagerError
+      throw new GoManagerError(
+        GoErrorType.ENVIRONMENT_ERROR,
+        `环境变量清理失败: ${error.message}`,
+        '请以管理员身份运行程序，或在系统设置中手动清理 GOROOT、GOPATH 和 PATH 环境变量',
+        true,
+        { version, originalError: error.message }
+      )
+    }
+  }
+
+  /**
+   * 执行文件系统清理和目录删除
+   * 完全删除版本目录及其所有内容
+   * 增强的错误处理
+   * Requirements: 2.2, 8.5
+   */
+  private async performFileSystemCleanup(versionDir: string, version: string): Promise<void> {
+    try {
+      console.log(`开始删除目录: ${versionDir}`)
+      
+      // 检查目录是否存在
+      if (!existsSync(versionDir)) {
+        console.log(`目录不存在，跳过删除: ${versionDir}`)
+        return
+      }
+
+      // 获取目录信息用于日志记录
+      const dirStats = this.getDirectoryStats(versionDir)
+      console.log(`目录统计: ${dirStats.fileCount} 个文件, ${dirStats.dirCount} 个子目录`)
+
+      // 尝试删除目录（使用强制删除）
+      rmSync(versionDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 1000 })
+      
+      // 验证删除是否成功
+      if (existsSync(versionDir)) {
+        throw new GoManagerError(
+          GoErrorType.FILE_SYSTEM_ERROR,
+          `目录删除失败，目录仍然存在: ${versionDir}`,
+          '可能有文件正在使用中。请关闭所有相关程序（如 IDE、终端、Go 进程）后重试，或重启计算机后再次尝试',
+          true,
+          { versionDir, dirStats }
+        )
+      }
+
+      console.log(`目录删除成功: ${versionDir}`)
+      
+    } catch (error: any) {
+      console.error(`文件系统清理失败: ${error.message}`)
+      
+      // 如果是 GoManagerError，直接重新抛出
+      if (error instanceof GoManagerError) {
+        throw error
+      }
+      
+      // 根据错误类型提供具体建议
+      let suggestion = '请关闭所有相关程序后重试，或重启计算机后再次尝试'
+      
+      if (error.code === 'EBUSY' || error.code === 'ENOTEMPTY') {
+        suggestion = '文件正在使用中，请关闭所有 Go 相关程序（IDE、终端、Go 进程）后重试'
+      } else if (error.code === 'EACCES' || error.code === 'EPERM') {
+        suggestion = '权限不足，请以管理员身份运行程序'
+      } else if (error.code === 'ENOENT') {
+        suggestion = '目录不存在或已被删除'
+        return // 目录不存在就不需要删除了
+      }
+      
+      throw new GoManagerError(
+        GoErrorType.FILE_SYSTEM_ERROR,
+        `文件系统清理失败: ${error.message}`,
+        suggestion,
+        true,
+        { versionDir, errorCode: error.code, originalError: error.message }
+      )
+    }
+  }
+
+  /**
+   * 更新卸载后的配置状态
+   * 从已安装版本列表中移除，清除活动版本配置
+   * 增强的错误处理
+   * Requirements: 2.4, 2.5, 8.5
+   */
+  private async updateUninstallConfiguration(version: string, wasActiveVersion: boolean): Promise<void> {
+    try {
+      console.log(`更新配置状态: 移除版本 ${version}`)
+      
+      // 从已安装版本列表中移除
+      const goVersions = this.configStore.get('goVersions' as any) || []
+      const index = goVersions.indexOf(version)
+      if (index > -1) {
+        goVersions.splice(index, 1)
+        this.configStore.set('goVersions' as any, goVersions)
+        console.log(`已从版本列表中移除: ${version}`)
+      } else {
+        console.log(`版本不在配置列表中: ${version}`)
+      }
+
+      // 如果卸载的是活动版本，清除活动版本配置
+      if (wasActiveVersion) {
+        this.configStore.set('activeGoVersion' as any, '')
+        console.log(`已清除活动版本配置`)
+        
+        // 如果还有其他版本，可以提示用户选择新的活动版本
+        const remainingVersions = await this.getInstalledVersions()
+        if (remainingVersions.length > 0) {
+          console.log(`提示: 还有 ${remainingVersions.length} 个版本可用，可以设置新的活动版本`)
+        }
+      }
+
+      console.log(`配置状态更新完成`)
+      
+    } catch (error: any) {
+      console.error(`配置状态更新失败: ${error.message}`)
+      
+      throw new GoManagerError(
+        GoErrorType.CONFIGURATION_ERROR,
+        `配置状态更新失败: ${error.message}`,
+        '配置文件可能损坏或权限不足。请检查应用程序配置目录权限，或重新启动应用程序',
+        true,
+        { version, wasActiveVersion, originalError: error.message }
+      )
+    }
+  }
+
+  /**
+   * 生成活动版本清理的 PowerShell 脚本
+   * 清除 GOROOT、GOPATH 和 PATH 中的所有 Go 相关配置
+   */
+  private generateActiveVersionCleanupScript(): string {
+    return `
+      # Go 活动版本环境变量清理脚本
+      Write-Host "开始清理 Go 活动版本环境变量..."
+      
+      try {
+        # 获取当前用户 PATH
+        $userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
+        if ($userPath) {
+          Write-Host "当前 PATH: $userPath"
+          
+          $pathArray = $userPath -split ';' | Where-Object { $_ -ne '' -and $_ -ne $null }
+          
+          # 移除所有 Go 相关路径（更全面的清理）
+          $filteredPaths = $pathArray | Where-Object { 
+            -not ($_ -like '*\\go\\go-*\\bin' -or 
+                  $_ -like '*\\go-*\\bin' -or 
+                  $_ -like '*\\golang\\*\\bin' -or
+                  $_ -like '*\\Go\\*\\bin' -or
+                  $_ -like '*\\go\\bin' -or
+                  $_ -like '*\\golang\\bin')
+          }
+          
+          $finalPath = ($filteredPaths | Where-Object { $_ -ne '' -and $_ -ne $null } | Select-Object -Unique) -join ';'
+          [Environment]::SetEnvironmentVariable('PATH', $finalPath, 'User')
+          Write-Host "已清理 PATH 中的所有 Go 路径"
+        }
+        
+        # 清除 GOROOT
+        $currentGoRoot = [Environment]::GetEnvironmentVariable('GOROOT', 'User')
+        if ($currentGoRoot) {
+          [Environment]::SetEnvironmentVariable('GOROOT', $null, 'User')
+          Write-Host "已清除 GOROOT: $currentGoRoot"
+        }
+        
+        # 清除 GOPATH
+        $currentGoPath = [Environment]::GetEnvironmentVariable('GOPATH', 'User')
+        if ($currentGoPath) {
+          [Environment]::SetEnvironmentVariable('GOPATH', $null, 'User')
+          Write-Host "已清除 GOPATH: $currentGoPath"
+        }
+        
+        Write-Host "活动版本环境变量清理完成"
+        
+      } catch {
+        Write-Error "活动版本环境变量清理失败: $_"
+        throw $_
+      }
+    `
+  }
+
+  /**
+   * 获取目录统计信息
+   * 用于日志记录和验证
+   */
+  private getDirectoryStats(dirPath: string): { fileCount: number; dirCount: number; totalSize: number } {
+    let fileCount = 0
+    let dirCount = 0
+    let totalSize = 0
+
+    try {
+      const items = readdirSync(dirPath, { withFileTypes: true })
+      
+      for (const item of items) {
+        const itemPath = join(dirPath, item.name)
+        
+        if (item.isDirectory()) {
+          dirCount++
+          const subStats = this.getDirectoryStats(itemPath)
+          fileCount += subStats.fileCount
+          dirCount += subStats.dirCount
+          totalSize += subStats.totalSize
+        } else if (item.isFile()) {
+          fileCount++
+          try {
+            const stats = statSync(itemPath)
+            totalSize += stats.size
+          } catch {
+            // 忽略无法访问的文件
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`获取目录统计信息失败: ${dirPath}`, error)
+    }
+
+    return { fileCount, dirCount, totalSize }
+  }
+
+  /**
+   * 设置活动的 Go 版本
+   * 增强的错误处理和详细反馈
+   * Requirements: 8.3, 8.4, 8.5
+   */
+  async setActive(version: string): Promise<OperationResult> {
+    try {
+      console.log(`设置 Go ${version} 为活动版本...`)
+      
+      // 1. 权限检查
+      await this.validateSystemEnvironment(0) // 不需要磁盘空间，但需要权限
+      
+      const goBasePath = this.getGoBasePath()
+      const versionDir = join(goBasePath, `go-${version}`)
+
+      // 2. 验证版本是否已安装
+      if (!existsSync(join(versionDir, 'bin', 'go.exe'))) {
+        return {
+          success: false,
+          message: `Go ${version} 未安装`,
+          suggestion: '请先安装此版本，然后再设为默认版本',
+          retryable: false
+        }
+      }
+
+      // 3. 更新环境变量
+      try {
+        await this.updateEnvironmentVariables(version)
+      } catch (error: any) {
+        throw new GoManagerError(
+          GoErrorType.ENVIRONMENT_ERROR,
+          `环境变量更新失败: ${error.message}`,
+          '请以管理员身份运行程序，或手动设置环境变量。您可以在系统设置中手动添加 GOROOT 和 PATH 配置',
+          true,
+          { environmentError: error.message }
+        )
+      }
+
+      // 4. 更新配置
+      this.configStore.set('activeGoVersion' as any, version)
+
+      // 5. 验证设置是否生效
+      try {
+        const goInfo = await this.getGoInfo(version)
+        if (!goInfo) {
+          console.warn('无法验证 Go 版本设置，但配置已更新')
+        }
+      } catch (error) {
+        console.warn('Go 版本验证失败，但配置已更新:', error)
+      }
+
+      console.log(`Go ${version} 已设为活动版本`)
+      return this.createSuccessResult(
+        `已将 Go ${version} 设为默认版本`,
+        {
+          version,
+          goroot: this.getGoPath(version),
+          gopath: this.getDefaultGoPath(),
+          nextSteps: [
+            '请重新打开命令行窗口以使环境变量生效',
+            '使用 "go version" 命令验证版本是否正确'
+          ]
+        }
+      )
+    } catch (error: any) {
+      console.error(`设置活动版本失败:`, error)
+      return this.createErrorResult(error, `设置 Go ${version} 为活动版本`)
+    }
+  }
+
+  /**
+   * 验证 Go 安装
+   */
+  async validateInstallation(version: string): Promise<boolean> {
+    const goPath = this.getGoPath(version)
+    const goExe = join(goPath, 'bin', 'go.exe')
+    const gofmtExe = join(goPath, 'bin', 'gofmt.exe')
+    
+    try {
+      // 检查核心可执行文件
+      if (!existsSync(goExe)) return false
+      if (!existsSync(gofmtExe)) return false
+      
+      // 验证版本
+      const { stdout } = await execAsync(`"${goExe}" version`)
+      if (!stdout.includes(version)) return false
+      
+      // 验证环境和基本命令
+      await execAsync(`"${goExe}" env GOROOT`)
+      
+      // 验证 go mod 功能
+      await execAsync(`"${goExe}" help mod`)
+      
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * 获取 Go 环境信息
+   */
+  async getGoInfo(version: string): Promise<GoInfo | null> {
+    const goPath = this.getGoPath(version)
+    const goExe = join(goPath, 'bin', 'go.exe')
+
+    if (!existsSync(goExe)) {
+      return null
+    }
+
+    try {
+      const { stdout: goVersion } = await execAsync(`"${goExe}" version`, { timeout: 5000 })
+      const { stdout: goRoot } = await execAsync(`"${goExe}" env GOROOT`, { timeout: 5000 })
+      const { stdout: goOs } = await execAsync(`"${goExe}" env GOOS`, { timeout: 5000 })
+      const { stdout: goArch } = await execAsync(`"${goExe}" env GOARCH`, { timeout: 5000 })
+      
+      return {
+        version,
+        goroot: goRoot.trim(),
+        gopath: this.getDefaultGoPath(),
+        goversion: goVersion.trim(),
+        goos: goOs.trim(),
+        goarch: goArch.trim()
+      }
+    } catch (error) {
+      return null
+    }
+  }
+
+  /**
+   * 检测系统已安装的 Go 版本
+   */
+  async detectSystemGoVersion(): Promise<GoVersion | null> {
+    try {
+      // 尝试执行系统的 go 命令
+      const { stdout: goVersion } = await execAsync('go version', { timeout: 5000 })
+      const { stdout: goRoot } = await execAsync('go env GOROOT', { timeout: 5000 })
+      const { stdout: goPath } = await execAsync('go env GOPATH', { timeout: 5000 })
+      
+      // 解析版本号
+      const versionMatch = goVersion.match(/go(\d+\.\d+\.\d+)/)
+      if (!versionMatch) return null
+      
+      const version = versionMatch[1]
+      const systemGoRoot = goRoot.trim()
+      const systemGoPath = goPath.trim()
+      
+      return {
+        version: `go${version}`,
+        path: systemGoRoot,
+        isActive: false, // 系统版本不算作我们管理的活动版本
+        goroot: systemGoRoot,
+        gopath: systemGoPath,
+        installDate: undefined,
+        size: undefined
+      }
+    } catch (error) {
+      // 系统没有安装 Go 或者不在 PATH 中
+      return null
+    }
+  }
+
+  // ==================== 私有方法 ====================
+
+  /**
+   * 检查版本是否已安装（重复安装检测）
+   */
+  private async isVersionInstalled(version: string): Promise<boolean> {
+    const extractDir = join(this.getGoBasePath(), `go-${version}`)
+    const goExe = join(extractDir, 'bin', 'go.exe')
+    const gofmtExe = join(extractDir, 'bin', 'gofmt.exe')
+
+    // 检查目录和关键文件是否存在
+    if (!existsSync(extractDir) || !existsSync(goExe) || !existsSync(gofmtExe)) {
+      return false
+    }
+
+    // 进一步验证安装完整性
+    try {
+      const { stdout } = await execAsync(`"${goExe}" version`, { timeout: 5000 })
+      return stdout.includes(version)
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * 解压 Go 归档文件
+   * 增强的错误处理
+   * Requirements: 8.5
+   */
+  private async extractGoArchive(zipPath: string, destDir: string, version: string): Promise<void> {
+    const extractDir = join(destDir, `go-${version}`)
+
+    try {
+      // 先解压到临时位置
+      await this.extractZip(zipPath, destDir)
+
+      // Go 的 ZIP 文件解压后会创建一个 'go' 目录，需要重命名
+      const extractedGoDir = join(destDir, 'go')
+      if (existsSync(extractedGoDir)) {
+        // 如果目标目录已存在，先删除
+        if (existsSync(extractDir)) {
+          rmSync(extractDir, { recursive: true, force: true })
+        }
+        // 重命名为版本特定的目录
+        require('fs').renameSync(extractedGoDir, extractDir)
+      } else {
+        throw new GoManagerError(
+          GoErrorType.INSTALLATION_ERROR,
+          '解压后未找到 Go 目录',
+          '下载的文件可能损坏或格式不正确。请重新下载安装包',
+          true,
+          { zipPath, destDir, expectedDir: extractedGoDir }
+        )
+      }
+
+    } catch (error: any) {
+      // 如果是 GoManagerError，直接重新抛出
+      if (error instanceof GoManagerError) {
+        throw error
+      }
+      
+      let suggestion = '请检查下载文件是否完整，或重新下载安装包'
+      
+      if (error.code === 'EACCES' || error.code === 'EPERM') {
+        suggestion = '权限不足，请以管理员身份运行程序'
+      } else if (error.code === 'ENOSPC') {
+        suggestion = '磁盘空间不足，请清理磁盘空间后重试'
+      } else if (error.message.includes('invalid') || error.message.includes('corrupt')) {
+        suggestion = '文件损坏，请重新下载安装包'
+      }
+      
+      throw new GoManagerError(
+        GoErrorType.INSTALLATION_ERROR,
+        `解压失败: ${error.message}`,
+        suggestion,
+        true,
+        { zipPath, destDir, version, errorCode: error.code, originalError: error.message }
+      )
+    }
+  }
+
+  /**
+   * 执行安装后验证和完整性检查
+   */
+  private async performInstallationValidation(version: string): Promise<{ isValid: boolean; error?: string }> {
+    const goPath = this.getGoPath(version)
+    const goExe = join(goPath, 'bin', 'go.exe')
+    const gofmtExe = join(goPath, 'bin', 'gofmt.exe')
+
+    try {
+      // 1. 检查核心可执行文件是否存在
+      if (!existsSync(goExe)) {
+        return { isValid: false, error: 'go.exe 文件不存在' }
+      }
+      if (!existsSync(gofmtExe)) {
+        return { isValid: false, error: 'gofmt.exe 文件不存在' }
+      }
+
+      // 2. 验证 go version 命令
+      const { stdout: versionOutput } = await execAsync(`"${goExe}" version`, { timeout: 10000 })
+      if (!versionOutput.includes(version)) {
+        return { isValid: false, error: `版本验证失败，期望 ${version}，实际 ${versionOutput.trim()}` }
+      }
+
+      // 3. 验证 go env 命令
+      await execAsync(`"${goExe}" env GOROOT`, { timeout: 10000 })
+
+      // 4. 验证 go mod 功能
+      await execAsync(`"${goExe}" help mod`, { timeout: 10000 })
+
+      // 5. 验证 go build 命令可用
+      await execAsync(`"${goExe}" help build`, { timeout: 10000 })
+
+      // 6. 检查标准库目录
+      const srcDir = join(goPath, 'src')
+      if (!existsSync(srcDir)) {
+        return { isValid: false, error: '标准库源码目录不存在' }
+      }
+
+      return { isValid: true }
+
+    } catch (error: any) {
+      return { isValid: false, error: `验证过程出错: ${error.message}` }
+    }
+  }
+
+  /**
+   * 清理失败的安装
+   */
+  private async cleanupFailedInstallation(installDir: string): Promise<void> {
+    try {
+      if (existsSync(installDir)) {
+        console.log(`清理失败的安装目录: ${installDir}`)
+        rmSync(installDir, { recursive: true, force: true })
+      }
+    } catch (error) {
+      console.warn(`清理安装目录失败: ${error}`)
+    }
+  }
+
+  /**
+   * 更新安装配置
+   */
+  private async updateInstallationConfig(version: string): Promise<void> {
+    const goVersions = this.configStore.get('goVersions' as any) || []
+    if (!goVersions.includes(version)) {
+      goVersions.push(version)
+      this.configStore.set('goVersions' as any, goVersions)
+    }
+  }
+
+  /**
+   * 清理临时文件
+   */
+  private async cleanupTempFiles(zipPath: string): Promise<void> {
+    try {
+      // 清理下载的 ZIP 文件
+      if (existsSync(zipPath)) {
+        unlinkSync(zipPath)
+        console.log(`已清理临时文件: ${zipPath}`)
+      }
+
+      // 清理部分下载文件
+      const partialFile = `${zipPath}.partial`
+      if (existsSync(partialFile)) {
+        unlinkSync(partialFile)
+        console.log(`已清理部分下载文件: ${partialFile}`)
+      }
+
+    } catch (error) {
+      console.warn(`清理临时文件时出错: ${error}`)
+      // 不抛出错误，因为这不应该影响安装结果
+    }
+  }
+
+  /**
+   * 增强的文件下载管理器
+   * 支持 HTTPS 下载、进度跟踪、SHA256 校验、下载中断和重试
+   * Requirements: 8.1, 8.5
+   */
+  private async downloadFile(url: string, dest: string, name: string, expectedSha256?: string): Promise<void> {
+    const options: DownloadOptions = {
+      url,
+      dest,
+      name,
+      expectedSha256,
+      maxRetries: 3,
+      timeout: 600000 // 10 分钟超时
+    }
+
+    const result = await this.downloadWithRetry(options)
+    if (!result.success) {
+      // 如果下载结果包含建议，创建 GoManagerError
+      if (result.suggestion) {
+        throw new GoManagerError(
+          GoErrorType.DOWNLOAD_ERROR,
+          result.message,
+          result.suggestion,
+          result.retryable || false,
+          result.details
+        )
+      } else {
+        throw new Error(result.message)
+      }
+    }
+  }
+
+  /**
+   * 带重试机制的下载
+   * 增强的网络错误处理和用户反馈
+   * Requirements: 8.1
+   */
+  private async downloadWithRetry(options: DownloadOptions): Promise<DownloadResult> {
+    const { maxRetries = 3 } = options
+    let lastError: Error | null = null
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        console.log(`下载尝试 ${attempt}/${maxRetries}: ${options.name}`)
+        
+        // 在重试前检查网络连接
+        if (attempt > 1) {
+          console.log(`第 ${attempt} 次尝试前检查网络连接...`)
+          const networkCheck = await this.checkNetworkConnection()
+          if (!networkCheck.isConnected) {
+            throw new GoManagerError(
+              GoErrorType.NETWORK_ERROR,
+              '网络连接不可用',
+              '请检查网络连接后重试。确保可以访问 golang.org',
+              true,
+              { networkCheck, attempt }
+            )
+          }
+          console.log(`网络连接正常，响应时间: ${networkCheck.responseTime}ms`)
+        }
+        
+        // 检查是否存在部分下载的文件
+        const partialFile = `${options.dest}.partial`
+        let resumeFrom = 0
+        
+        if (existsSync(partialFile)) {
+          try {
+            const stats = statSync(partialFile)
+            resumeFrom = stats.size
+            console.log(`检测到部分下载文件，从 ${resumeFrom} 字节处恢复下载`)
+          } catch (e) {
+            // 如果无法读取部分文件，删除它
+            try {
+              unlinkSync(partialFile)
+            } catch {}
+            resumeFrom = 0
+          }
+        }
+
+        await this.performDownload(options, resumeFrom)
+        
+        // 下载成功后验证 SHA256（如果提供）
+        if (options.expectedSha256) {
+          console.log('验证文件完整性...')
+          const isValid = await this.verifySha256(options.dest, options.expectedSha256)
+          if (!isValid) {
+            // SHA256 验证失败，删除文件并重试
+            try {
+              unlinkSync(options.dest)
+            } catch {}
+            throw new GoManagerError(
+              GoErrorType.DOWNLOAD_ERROR,
+              'SHA256 校验失败，文件可能损坏',
+              '文件下载过程中可能出现错误，正在重新下载。如果问题持续，请检查网络连接',
+              true,
+              { attempt, expectedSha256: options.expectedSha256 }
+            )
+          }
+          console.log('文件完整性验证通过')
+        }
+
+        // 清理部分下载文件
+        try {
+          unlinkSync(partialFile)
+        } catch {}
+
+        return {
+          success: true,
+          message: '下载完成',
+          filePath: options.dest
+        }
+
+      } catch (error: any) {
+        lastError = error
+        console.error(`下载尝试 ${attempt} 失败:`, error.message)
+        
+        if (attempt < maxRetries) {
+          // 等待一段时间后重试（指数退避）
+          const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000)
+          console.log(`等待 ${delay}ms 后重试...`)
+          await new Promise(resolve => setTimeout(resolve, delay))
+        }
+      }
+    }
+
+    // 所有重试都失败了
+    const errorMessage = lastError instanceof GoManagerError 
+      ? lastError.message 
+      : `下载失败（已重试 ${maxRetries} 次）: ${lastError?.message || '未知错误'}`
+    
+    const suggestion = lastError instanceof GoManagerError 
+      ? lastError.suggestion
+      : '请检查网络连接，确保可以访问 golang.org。如果问题持续，请尝试使用VPN或更换网络环境'
+
+    return {
+      success: false,
+      message: errorMessage,
+      suggestion,
+      retryable: true,
+      details: { attempts: maxRetries, lastError: lastError?.message }
+    }
+  }
+
+  /**
+   * 执行实际的下载操作
+   * 增强的错误处理和网络状态检测
+   * Requirements: 8.1
+   */
+  private async performDownload(options: DownloadOptions, resumeFrom: number = 0): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const protocol = options.url.startsWith('https') ? https : http
+      const partialFile = `${options.dest}.partial`
+      const isResume = resumeFrom > 0
+
+      const requestOptions: any = {
+        headers: {
+          'User-Agent': 'PHPer-Dev-Manager/1.0'
+        },
+        timeout: options.timeout || 600000
+      }
+
+      // 如果是断点续传，添加 Range 头
+      if (isResume) {
+        requestOptions.headers['Range'] = `bytes=${resumeFrom}-`
+      }
+
+      const request = protocol.get(options.url, requestOptions, (response) => {
+        // 处理重定向
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          const redirectUrl = response.headers.location
+          if (redirectUrl) {
+            const redirectOptions = { ...options, url: redirectUrl }
+            this.performDownload(redirectOptions, resumeFrom).then(resolve).catch(reject)
+            return
+          }
+        }
+
+        // 检查响应状态码
+        const expectedStatus = isResume ? 206 : 200 // 206 for partial content
+        if (response.statusCode !== expectedStatus && response.statusCode !== 200) {
+          const errorMsg = `下载失败: HTTP ${response.statusCode}`
+          let suggestion = '请检查网络连接和下载链接'
+          
+          if (response.statusCode === 404) {
+            suggestion = '下载链接不存在，请尝试其他版本或联系支持'
+          } else if (response.statusCode === 403) {
+            suggestion = '访问被拒绝，可能需要VPN或代理服务器'
+          } else if (response.statusCode === 500 || response.statusCode === 502 || response.statusCode === 503) {
+            suggestion = '服务器暂时不可用，请稍后重试'
+          }
+          
+          reject(new GoManagerError(
+            GoErrorType.NETWORK_ERROR,
+            errorMsg,
+            suggestion,
+            true,
+            { statusCode: response.statusCode, url: options.url }
+          ))
+          return
+        }
+
+        const totalSize = isResume 
+          ? resumeFrom + parseInt(response.headers['content-length'] || '0', 10)
+          : parseInt(response.headers['content-length'] || '0', 10)
+        let downloadedSize = resumeFrom
+
+        // 创建写入流（追加模式如果是断点续传）
+        const file = createWriteStream(isResume ? partialFile : options.dest, 
+          isResume ? { flags: 'a' } : undefined)
+
+        let lastProgressTime = 0
+        let lastDownloadedSize = downloadedSize
+        let downloadSpeed = 0
+
+        response.on('data', (chunk) => {
+          downloadedSize += chunk.length
+          const now = Date.now()
+          
+          // 每500ms更新一次进度和速度
+          if (now - lastProgressTime > 500) {
+            const timeDiff = (now - lastProgressTime) / 1000
+            const sizeDiff = downloadedSize - lastDownloadedSize
+            downloadSpeed = sizeDiff / timeDiff // bytes per second
+            
+            const progress = totalSize > 0 ? Math.round((downloadedSize / totalSize) * 100) : 0
+            sendDownloadProgress('go', progress, downloadedSize, totalSize)
+            
+            lastProgressTime = now
+            lastDownloadedSize = downloadedSize
+          }
+        })
+
+        response.pipe(file)
+
+        file.on('finish', () => {
+          file.close()
+          
+          // 如果是部分下载文件，重命名为最终文件
+          if (isResume) {
+            try {
+              if (existsSync(options.dest)) {
+                unlinkSync(options.dest)
+              }
+              require('fs').renameSync(partialFile, options.dest)
+            } catch (e) {
+              reject(new GoManagerError(
+                GoErrorType.FILE_SYSTEM_ERROR,
+                `重命名文件失败: ${e}`,
+                '可能是权限问题或磁盘空间不足，请检查目标目录权限',
+                false,
+                { renameError: e }
+              ))
+              return
+            }
+          }
+          
+          sendDownloadProgress('go', 100, totalSize, totalSize)
+          resolve()
+        })
+
+        file.on('error', (err) => {
+          try {
+            if (!isResume) {
+              unlinkSync(options.dest)
+            }
+          } catch {}
+          reject(new GoManagerError(
+            GoErrorType.FILE_SYSTEM_ERROR,
+            `文件写入失败: ${err.message}`,
+            '可能是磁盘空间不足或权限问题，请检查目标目录权限和可用空间',
+            false,
+            { fileError: err.message }
+          ))
+        })
+      })
+
+      request.on('error', (err) => {
+        reject(new GoManagerError(
+          GoErrorType.NETWORK_ERROR,
+          `网络错误: ${err.message}`,
+          '请检查网络连接，确保可以访问互联网。如果使用代理，请检查代理设置',
+          true,
+          { networkError: err.message }
+        ))
+      })
+
+      request.on('timeout', () => {
+        request.destroy()
+        reject(new GoManagerError(
+          GoErrorType.NETWORK_ERROR,
+          '下载超时',
+          '网络连接较慢或不稳定，请检查网络环境后重试',
+          true,
+          { timeout: options.timeout }
+        ))
+      })
+    })
+  }
+
+  /**
+   * 验证文件的 SHA256 校验和
+   */
+  private async verifySha256(filePath: string, expectedSha256: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      try {
+        const hash = createHash('sha256')
+        const stream = createReadStream(filePath)
+
+        stream.on('data', (data) => {
+          hash.update(data)
+        })
+
+        stream.on('end', () => {
+          const actualSha256 = hash.digest('hex').toLowerCase()
+          const expected = expectedSha256.toLowerCase()
+          resolve(actualSha256 === expected)
+        })
+
+        stream.on('error', () => {
+          resolve(false)
+        })
+      } catch {
+        resolve(false)
+      }
+    })
+  }
+
+  private async extractZip(zipPath: string, destDir: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const readStream = require('fs').createReadStream(zipPath)
+      readStream
+        .pipe(unzipper.Extract({ path: destDir }))
+        .on('close', resolve)
+        .on('error', reject)
+    })
+  }
+
+  /**
+   * 更新环境变量以支持指定的 Go 版本
+   * 设置 GOROOT、GOPATH 和 PATH，清理旧版本的路径配置
+   * 增强的错误处理和权限检查
+   * Requirements: 3.1, 6.1, 6.2, 6.3, 6.4, 8.3, 8.5
+   */
+  private async updateEnvironmentVariables(goVersion: string): Promise<void> {
+    const goRoot = this.getGoPath(goVersion)
+    const goBin = join(goRoot, 'bin')
+    const goPath = this.getDefaultGoPath()
+    
+    console.log(`更新环境变量为 Go ${goVersion}`)
+    console.log(`GOROOT: ${goRoot}`)
+    console.log(`GOPATH: ${goPath}`)
+    console.log(`Go Binary Path: ${goBin}`)
+    
+    try {
+      // 确保 GOPATH 工作空间目录存在
+      await this.ensureGoPathStructure(goPath)
+      
+      // 使用 PowerShell 脚本更新用户环境变量
+      const psScript = this.generateEnvironmentUpdateScript(goRoot, goPath, goBin)
+      
+      await this.executePowerShellScript(psScript)
+      console.log(`环境变量更新成功: Go ${goVersion}`)
+      
+    } catch (error: any) {
+      console.error(`环境变量更新失败: ${error.message}`)
+      
+      // 根据错误类型提供具体建议
+      let suggestion = '请以管理员身份运行程序，或手动设置环境变量'
+      
+      if (error.message.includes('ExecutionPolicy')) {
+        suggestion = '请以管理员身份运行 PowerShell 并执行: Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser'
+      } else if (error.message.includes('Access') || error.message.includes('权限')) {
+        suggestion = '权限不足，请以管理员身份运行程序，或在系统设置中手动配置环境变量'
+      } else if (error.message.includes('timeout')) {
+        suggestion = '操作超时，请重试。如果问题持续，请手动配置环境变量'
+      }
+      
+      throw new GoManagerError(
+        GoErrorType.ENVIRONMENT_ERROR,
+        `环境变量更新失败: ${error.message}`,
+        suggestion,
+        true,
+        { 
+          goVersion, 
+          goRoot, 
+          goPath, 
+          goBin,
+          originalError: error.message 
+        }
+      )
+    }
+  }
+
+  /**
+   * 确保 GOPATH 工作空间目录结构存在
+   * 创建标准的 Go 工作空间结构：src, pkg, bin
+   * 增强的错误处理
+   * Requirements: 8.2, 8.3
+   */
+  private async ensureGoPathStructure(goPath: string): Promise<void> {
+    try {
+      if (!existsSync(goPath)) {
+        mkdirSync(goPath, { recursive: true })
+        console.log(`创建 GOPATH 目录: ${goPath}`)
+      }
+      
+      // 创建标准的 Go 工作空间结构
+      const subdirs = ['src', 'pkg', 'bin']
+      for (const subdir of subdirs) {
+        const dirPath = join(goPath, subdir)
+        if (!existsSync(dirPath)) {
+          mkdirSync(dirPath, { recursive: true })
+          console.log(`创建 GOPATH 子目录: ${dirPath}`)
+        }
+      }
+    } catch (error: any) {
+      let suggestion = '请检查目标目录权限，或选择其他位置作为 GOPATH'
+      
+      if (error.code === 'EACCES' || error.code === 'EPERM') {
+        suggestion = '权限不足，请以管理员身份运行程序，或选择用户目录下的位置'
+      } else if (error.code === 'ENOSPC') {
+        suggestion = '磁盘空间不足，请清理磁盘空间或选择其他磁盘'
+      } else if (error.code === 'ENOTDIR') {
+        suggestion = '路径中存在同名文件，请删除该文件或选择其他路径'
+      }
+      
+      throw new GoManagerError(
+        GoErrorType.FILE_SYSTEM_ERROR,
+        `创建 GOPATH 结构失败: ${error.message}`,
+        suggestion,
+        false,
+        { goPath, errorCode: error.code, originalError: error.message }
+      )
+    }
+  }
+
+  /**
+   * 生成环境变量更新的 PowerShell 脚本
+   * 包含 GOROOT、GOPATH 设置和 PATH 清理更新
+   */
+  private generateEnvironmentUpdateScript(goRoot: string, goPath: string, goBin: string): string {
+    // 转义路径中的反斜杠
+    const escapedGoRoot = goRoot.replace(/\\/g, '\\\\')
+    const escapedGoPath = goPath.replace(/\\/g, '\\\\')
+    const escapedGoBin = goBin.replace(/\\/g, '\\\\')
+    
+    return `
+      # Go 环境变量更新脚本
+      Write-Host "开始更新 Go 环境变量..."
+      
+      try {
+        # 设置 GOROOT
+        Write-Host "设置 GOROOT: ${escapedGoRoot}"
+        [Environment]::SetEnvironmentVariable('GOROOT', '${escapedGoRoot}', 'User')
+        
+        # 设置 GOPATH
+        Write-Host "设置 GOPATH: ${escapedGoPath}"
+        [Environment]::SetEnvironmentVariable('GOPATH', '${escapedGoPath}', 'User')
+        
+        # 更新 PATH
+        Write-Host "更新 PATH 环境变量..."
+        $userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
+        if (-not $userPath) { $userPath = '' }
+        
+        $pathArray = $userPath -split ';' | Where-Object { $_ -ne '' -and $_ -ne $null }
+        
+        # 移除所有旧的 Go 路径（更全面的清理）
+        $filteredPaths = $pathArray | Where-Object { 
+          -not ($_ -like '*\\go\\go-*\\bin' -or 
+                $_ -like '*\\go-*\\bin' -or 
+                $_ -like '*\\golang\\*\\bin' -or
+                $_ -like '*\\Go\\*\\bin')
+        }
+        
+        # 添加新的 Go 路径到开头
+        $newPathArray = @('${escapedGoBin}') + $filteredPaths
+        $finalPath = ($newPathArray | Where-Object { $_ -ne '' -and $_ -ne $null } | Select-Object -Unique) -join ';'
+        
+        Write-Host "新的 PATH: $finalPath"
+        [Environment]::SetEnvironmentVariable('PATH', $finalPath, 'User')
+        
+        Write-Host "环境变量更新完成"
+        
+      } catch {
+        Write-Error "环境变量更新失败: $_"
+        throw $_
+      }
+    `
+  }
+
+  /**
+   * 从环境变量中移除指定 Go 版本的路径
+   * 清理 GOROOT、GOPATH 和 PATH 中的相关配置
+   * 增强的错误处理
+   * Requirements: 8.3, 8.5
+   */
+  private async removeFromPath(goPath: string): Promise<void> {
+    const goBin = join(goPath, 'bin')
+    
+    console.log(`从环境变量中移除 Go 路径: ${goBin}`)
+    
+    const psScript = this.generateEnvironmentCleanupScript(goBin)
+    
+    try {
+      await this.executePowerShellScript(psScript)
+      console.log(`环境变量清理成功`)
+    } catch (error: any) {
+      console.error(`环境变量清理失败: ${error.message}`)
+      
+      // 如果是 GoManagerError，直接重新抛出
+      if (error instanceof GoManagerError) {
+        throw error
+      }
+      
+      throw new GoManagerError(
+        GoErrorType.ENVIRONMENT_ERROR,
+        `环境变量清理失败: ${error.message}`,
+        '请以管理员身份运行程序，或在系统设置中手动清理环境变量',
+        true,
+        { goBin, originalError: error.message }
+      )
+    }
+  }
+
+  /**
+   * 生成环境变量清理的 PowerShell 脚本
+   * 移除指定的 Go 路径并清理 GOROOT、GOPATH
+   */
+  private generateEnvironmentCleanupScript(goBin: string): string {
+    const escapedGoBin = goBin.replace(/\\/g, '\\\\')
+    
+    return `
+      # Go 环境变量清理脚本
+      Write-Host "开始清理 Go 环境变量..."
+      
+      try {
+        # 获取当前用户 PATH
+        $userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
+        if ($userPath) {
+          $pathArray = $userPath -split ';' | Where-Object { $_ -ne '' -and $_ -ne $null }
+          
+          # 移除指定的 Go 路径
+          $filteredPaths = $pathArray | Where-Object { 
+            $_ -ne '${escapedGoBin}'
+          }
+          
+          $finalPath = ($filteredPaths | Where-Object { $_ -ne '' -and $_ -ne $null } | Select-Object -Unique) -join ';'
+          [Environment]::SetEnvironmentVariable('PATH', $finalPath, 'User')
+          Write-Host "已从 PATH 中移除: ${escapedGoBin}"
+        }
+        
+        # 清除 GOROOT 和 GOPATH（如果没有其他活动版本）
+        [Environment]::SetEnvironmentVariable('GOROOT', $null, 'User')
+        [Environment]::SetEnvironmentVariable('GOPATH', $null, 'User')
+        Write-Host "已清除 GOROOT 和 GOPATH"
+        
+        Write-Host "环境变量清理完成"
+        
+      } catch {
+        Write-Error "环境变量清理失败: $_"
+        throw $_
+      }
+    `
+  }
+
+  /**
+   * 执行 PowerShell 脚本
+   * 创建临时脚本文件并执行，完成后清理
+   * 增强的错误处理和权限检查
+   * Requirements: 8.3, 8.5
+   */
+  private async executePowerShellScript(script: string): Promise<void> {
+    const tempPs1 = join(this.configStore.getTempPath(), `go_env_${Date.now()}.ps1`)
+    
+    try {
+      // 确保临时目录存在
+      const tempDir = this.configStore.getTempPath()
+      if (!existsSync(tempDir)) {
+        mkdirSync(tempDir, { recursive: true })
+      }
+      
+      // 写入脚本文件
+      writeFileSync(tempPs1, script, 'utf-8')
+      
+      // 执行 PowerShell 脚本
+      const command = `powershell -ExecutionPolicy Bypass -File "${tempPs1}"`
+      const { stdout, stderr } = await execAsync(command, { timeout: 30000 })
+      
+      // 检查 PowerShell 脚本的输出
+      if (stderr && stderr.trim()) {
+        console.warn('PowerShell 脚本警告:', stderr)
+        
+        // 某些警告不应该被视为错误
+        const ignorableWarnings = [
+          'WARNING:',
+          'Get-WmiObject',
+          'deprecated'
+        ]
+        
+        const isIgnorable = ignorableWarnings.some(warning => 
+          stderr.toLowerCase().includes(warning.toLowerCase())
+        )
+        
+        if (!isIgnorable && stderr.includes('Error')) {
+          throw new Error(stderr)
+        }
+      }
+      
+      if (stdout && stdout.trim()) {
+        console.log('PowerShell 脚本输出:', stdout)
+      }
+      
+    } catch (error: any) {
+      console.error('PowerShell 脚本执行失败:', error)
+      
+      let suggestion = '请以管理员身份运行程序，或手动配置环境变量'
+      let errorType = GoErrorType.ENVIRONMENT_ERROR
+      
+      const errorMessage = error.message.toLowerCase()
+      
+      if (errorMessage.includes('executionpolicy')) {
+        suggestion = '执行策略限制，请以管理员身份运行 PowerShell 并执行: Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser'
+        errorType = GoErrorType.PERMISSION_ERROR
+      } else if (errorMessage.includes('access') || errorMessage.includes('denied') || errorMessage.includes('权限')) {
+        suggestion = '权限不足，请以管理员身份运行程序。您也可以在系统设置中手动配置环境变量'
+        errorType = GoErrorType.PERMISSION_ERROR
+      } else if (errorMessage.includes('timeout')) {
+        suggestion = '操作超时，可能是系统响应较慢。请重试，或手动配置环境变量'
+      } else if (errorMessage.includes('not found') || errorMessage.includes('找不到')) {
+        suggestion = 'PowerShell 不可用，请确保 Windows PowerShell 已正确安装'
+      }
+      
+      throw new GoManagerError(
+        errorType,
+        `PowerShell 脚本执行失败: ${error.message}`,
+        suggestion,
+        true,
+        { 
+          scriptPath: tempPs1,
+          command: 'powershell -ExecutionPolicy Bypass',
+          originalError: error.message 
+        }
+      )
+    } finally {
+      // 清理临时脚本文件
+      try {
+        if (existsSync(tempPs1)) {
+          unlinkSync(tempPs1)
+        }
+      } catch (e) {
+        console.warn('清理临时脚本文件失败:', e)
+      }
+    }
+  }
+
+  private getFallbackVersions(): AvailableGoVersion[] {
+    return [
+      { version: 'go1.22.0', stable: true, downloadUrl: 'https://golang.org/dl/go1.22.0.windows-amd64.zip', size: 0, sha256: '' },
+      { version: 'go1.21.6', stable: true, downloadUrl: 'https://golang.org/dl/go1.21.6.windows-amd64.zip', size: 0, sha256: '' },
+      { version: 'go1.21.5', stable: true, downloadUrl: 'https://golang.org/dl/go1.21.5.windows-amd64.zip', size: 0, sha256: '' },
+      { version: 'go1.20.13', stable: true, downloadUrl: 'https://golang.org/dl/go1.20.13.windows-amd64.zip', size: 0, sha256: '' },
+      { version: 'go1.20.12', stable: true, downloadUrl: 'https://golang.org/dl/go1.20.12.windows-amd64.zip', size: 0, sha256: '' },
+      { version: 'go1.19.13', stable: true, downloadUrl: 'https://golang.org/dl/go1.19.13.windows-amd64.zip', size: 0, sha256: '' }
+    ]
+  }
+}
\ No newline at end of file
diff --git a/electron/services/GoManager.ts.backup b/electron/services/GoManager.ts.backup
new file mode 100644
index 0000000..7718fca
--- /dev/null
+++ b/electron/services/GoManager.ts.backup
@@ -0,0 +1,1617 @@
+import { ConfigStore } from './ConfigStore'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import { existsSync, mkdirSync, readdirSync, rmSync, readFileSync, writeFileSync, unlinkSync, statSync } from 'fs'
+import { join } from 'path'
+import https from 'https'
+import http from 'http'
+import { createWriteStream, createReadStream } from 'fs'
+import { sendDownloadProgress } from '../main'
+import { createHash } from 'crypto'
+
+// Import unzipper with any type to avoid type issues
+const unzipper = require('unzipper')
+
+const execAsync = promisify(exec)
+
+interface GoVersion {
+  version: string        // 版本号，如 "1.21.5"
+  path: string          // 安装路径
+  isActive: boolean     // 是否为当前活动版本
+  goroot: string        // GOROOT 路径
+  gopath?: string       // GOPATH 路径（可选）
+  installDate?: Date    // 安装日期
+  size?: number         // 安装大小（字节）
+}
+
+interface AvailableGoVersion {
+  version: string       // 版本号
+  stable: boolean       // 是否为稳定版本
+  downloadUrl: string   // Windows 64位 ZIP 下载链接
+  size: number         // 文件大小（字节）
+  sha256: string       // SHA256 校验和
+  releaseDate?: string // 发布日期
+}
+
+interface GoInfo {
+  version: string       // Go 版本
+  goroot: string       // GOROOT 路径
+  gopath: string       // GOPATH 路径
+  goversion: string    // go version 命令输出
+  goos: string         // 目标操作系统
+  goarch: string       // 目标架构
+}
+
+interface GoRelease {
+  version: string
+  stable: boolean
+  files: GoFile[]
+}
+
+interface GoFile {
+  filename: string
+  os: string
+  arch: string
+  version: string
+  sha256: string
+  size: number
+  kind: 'archive' | 'installer' | 'source'
+}
+
+interface DownloadOptions {
+  url: string
+  dest: string
+  name: string
+  expectedSha256?: string
+  maxRetries?: number
+  timeout?: number
+}
+
+interface DownloadProgress {
+  percent: number
+  downloadedBytes: number
+  totalBytes: number
+  speed?: number
+}
+
+interface DownloadResult {
+  success: boolean
+  message: string
+  filePath?: string
+}
+
+export class GoManager {
+  private configStore: ConfigStore
+  private versionsCache: AvailableGoVersion[] = []
+  private cacheTime: number = 0
+  private readonly CACHE_DURATION = 5 * 60 * 1000 // 5 分钟缓存
+
+  constructor(configStore: ConfigStore) {
+    this.configStore = configStore
+  }
+
+  /**
+   * 获取 Go 基础安装路径
+   */
+  getGoBasePath(): string {
+    return join(this.configStore.getBasePath(), 'go')
+  }
+
+  /**
+   * 获取指定版本的 Go 路径
+   */
+  getGoPath(version: string): string {
+    return join(this.getGoBasePath(), `go-${version}`)
+  }
+
+  /**
+   * 获取默认 GOPATH 工作空间路径
+   */
+  getDefaultGoPath(): string {
+    return join(this.getGoBasePath(), 'workspace')
+  }
+
+  /**
+   * 获取已安装的 Go 版本
+   */
+  async getInstalledVersions(): Promise<GoVersion[]> {
+    const versions: GoVersion[] = []
+    const goBasePath = this.getGoBasePath()
+
+    if (!existsSync(goBasePath)) {
+      return versions
+    }
+
+    const dirs = readdirSync(goBasePath, { withFileTypes: true })
+    const activeVersion = this.configStore.get('activeGoVersion' as any) || ''
+
+    for (const dir of dirs) {
+      if (dir.isDirectory() && dir.name.startsWith('go-')) {
+        const versionDir = join(goBasePath, dir.name)
+        const goExe = join(versionDir, 'bin', 'go.exe')
+        const gofmtExe = join(versionDir, 'bin', 'gofmt.exe')
+
+        // 验证安装完整性
+        if (existsSync(goExe) && existsSync(gofmtExe)) {
+          const version = dir.name.replace('go-', '')
+          const goroot = versionDir
+          const gopath = this.getDefaultGoPath()
+
+          // 获取安装日期和大小信息
+          let installDate: Date | undefined
+          let size: number | undefined
+          
+          try {
+            const stats = require('fs').statSync(versionDir)
+            installDate = stats.birthtime || stats.mtime
+            
+            // 计算目录大小（简化版本，只统计主要文件）
+            const binDir = join(versionDir, 'bin')
+            if (existsSync(binDir)) {
+              const binFiles = readdirSync(binDir)
+              size = binFiles.reduce((total, file) => {
+                try {
+                  const filePath = join(binDir, file)
+                  const fileStats = require('fs').statSync(filePath)
+                  return total + fileStats.size
+                } catch {
+                  return total
+                }
+              }, 0)
+            }
+          } catch {
+            // 忽略统计错误
+          }
+
+          versions.push({
+            version,
+            path: versionDir,
+            isActive: version === activeVersion,
+            goroot,
+            gopath,
+            installDate,
+            size
+          })
+        }
+      }
+    }
+
+    // 按版本号排序（降序）
+    versions.sort((a, b) => {
+      const aParts = a.version.replace('go', '').split('.').map(Number)
+      const bParts = b.version.replace('go', '').split('.').map(Number)
+      for (let i = 0; i < 3; i++) {
+        if (aParts[i] !== bParts[i]) {
+          return bParts[i] - aParts[i]
+        }
+      }
+      return 0
+    })
+
+    return versions
+  }
+
+  /**
+   * 获取可用的 Go 版本列表
+   */
+  async getAvailableVersions(): Promise<AvailableGoVersion[]> {
+    // 检查缓存
+    if (this.versionsCache.length > 0 && Date.now() - this.cacheTime < this.CACHE_DURATION) {
+      return this.versionsCache
+    }
+
+    try {
+      const versions = await this.fetchGoVersions()
+      if (versions.length > 0) {
+        this.versionsCache = versions
+        this.cacheTime = Date.now()
+        return versions
+      }
+    } catch (error) {
+      console.error('获取 Go 版本列表失败:', error)
+    }
+
+    // 返回硬编码的版本列表作为后备
+    return this.getFallbackVersions()
+  }
+
+  /**
+   * 从 golang.org API 获取版本列表
+   */
+  private async fetchGoVersions(): Promise<AvailableGoVersion[]> {
+    return new Promise((resolve, reject) => {
+      const url = 'https://golang.org/dl/?mode=json'
+
+      https.get(url, {
+        headers: {
+          'User-Agent': 'PHPer-Dev-Manager/1.0'
+        },
+        timeout: 30000
+      }, (res) => {
+        if (res.statusCode === 301 || res.statusCode === 302) {
+          const redirectUrl = res.headers.location
+          if (redirectUrl) {
+            https.get(redirectUrl, (redirectRes) => {
+              this.handleVersionResponse(redirectRes, resolve, reject)
+            }).on('error', reject)
+            return
+          }
+        }
+        this.handleVersionResponse(res, resolve, reject)
+      }).on('error', reject)
+        .on('timeout', () => reject(new Error('请求超时')))
+    })
+  }
+
+  private handleVersionResponse(res: http.IncomingMessage, resolve: (value: AvailableGoVersion[]) => void, reject: (reason?: any) => void) {
+    let data = ''
+    res.on('data', chunk => data += chunk)
+    res.on('end', () => {
+      try {
+        const releases: GoRelease[] = JSON.parse(data)
+        const availableVersions: AvailableGoVersion[] = []
+
+        for (const release of releases) {
+          if (release.stable) {
+            const windowsFile = release.files.find(f => 
+              f.os === 'windows' && f.arch === 'amd64' && f.kind === 'archive'
+            )
+            
+            if (windowsFile) {
+              availableVersions.push({
+                version: release.version,
+                stable: release.stable,
+                downloadUrl: `https://golang.org/dl/${windowsFile.filename}`,
+                size: windowsFile.size,
+                sha256: windowsFile.sha256
+              })
+            }
+          }
+        }
+
+        // 只返回前 20 个版本
+        resolve(availableVersions.slice(0, 20))
+      } catch (e) {
+        reject(e)
+      }
+    })
+    res.on('error', reject)
+  }
+
+  /**
+   * 安装 Go 版本
+   * 包含完整的安装流程：下载、解压、验证、配置
+   */
+  async install(version: string, downloadUrl: string, expectedSha256?: string): Promise<{ success: boolean; message: string }> {
+    try {
+      const goBasePath = this.getGoBasePath()
+      const tempPath = this.configStore.getTempPath()
+      const zipPath = join(tempPath, `go-${version}.zip`)
+      const extractDir = join(goBasePath, `go-${version}`)
+
+      // 确保目录存在
+      if (!existsSync(goBasePath)) {
+        mkdirSync(goBasePath, { recursive: true })
+      }
+      if (!existsSync(tempPath)) {
+        mkdirSync(tempPath, { recursive: true })
+      }
+
+      // 重复安装检测和防护
+      if (await this.isVersionInstalled(version)) {
+        return { success: false, message: `Go ${version} 已安装，无需重复安装` }
+      }
+
+      console.log(`开始安装 Go ${version}...`)
+
+      try {
+        // 下载（使用增强的下载管理器，包含 SHA256 验证）
+        console.log(`正在下载 Go ${version}...`)
+        await this.downloadFile(downloadUrl, zipPath, `go-${version}`, expectedSha256)
+
+        // ZIP 文件解压到目标目录
+        console.log(`正在解压 Go ${version}...`)
+        await this.extractGoArchive(zipPath, goBasePath, version)
+
+        // 安装后验证和完整性检查
+        console.log(`正在验证 Go ${version} 安装...`)
+        const validationResult = await this.performInstallationValidation(version)
+        if (!validationResult.isValid) {
+          // 如果验证失败，清理安装目录
+          await this.cleanupFailedInstallation(extractDir)
+          return { success: false, message: `安装验证失败: ${validationResult.error}` }
+        }
+
+        // 更新配置
+        await this.updateInstallationConfig(version)
+
+        // 如果是第一个版本，设为默认
+        const installedVersions = await this.getInstalledVersions()
+        if (installedVersions.length === 1) {
+          await this.setActive(version)
+        }
+
+        return { success: true, message: `Go ${version} 安装成功` }
+
+      } finally {
+        // 清理临时文件（无论成功还是失败）
+        await this.cleanupTempFiles(zipPath)
+      }
+
+    } catch (error: any) {
+      console.error(`Go ${version} 安装失败:`, error)
+      return { success: false, message: `安装失败: ${error.message}` }
+    }
+  }
+
+  /**
+   * 检查版本是否已安装（重复安装检测）
+   */
+  private async isVersionInstalled(version: string): Promise<boolean> {
+    const extractDir = join(this.getGoBasePath(), `go-${version}`)
+    const goExe = join(extractDir, 'bin', 'go.exe')
+    const gofmtExe = join(extractDir, 'bin', 'gofmt.exe')
+
+    // 检查目录和关键文件是否存在
+    if (!existsSync(extractDir) || !existsSync(goExe) || !existsSync(gofmtExe)) {
+      return false
+    }
+
+    // 进一步验证安装完整性
+    try {
+      const { stdout } = await execAsync(`"${goExe}" version`, { timeout: 5000 })
+      return stdout.includes(version)
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * 解压 Go 归档文件
+   */
+  private async extractGoArchive(zipPath: string, destDir: string, version: string): Promise<void> {
+    const extractDir = join(destDir, `go-${version}`)
+
+    try {
+      // 先解压到临时位置
+      await this.extractZip(zipPath, destDir)
+
+      // Go 的 ZIP 文件解压后会创建一个 'go' 目录，需要重命名
+      const extractedGoDir = join(destDir, 'go')
+      if (existsSync(extractedGoDir)) {
+        // 如果目标目录已存在，先删除
+        if (existsSync(extractDir)) {
+          rmSync(extractDir, { recursive: true, force: true })
+        }
+        // 重命名为版本特定的目录
+        require('fs').renameSync(extractedGoDir, extractDir)
+      } else {
+        throw new Error('解压后未找到 Go 目录')
+      }
+
+    } catch (error: any) {
+      throw new Error(`解压失败: ${error.message}`)
+    }
+  }
+
+  /**
+   * 执行安装后验证和完整性检查
+   */
+  private async performInstallationValidation(version: string): Promise<{ isValid: boolean; error?: string }> {
+    const goPath = this.getGoPath(version)
+    const goExe = join(goPath, 'bin', 'go.exe')
+    const gofmtExe = join(goPath, 'bin', 'gofmt.exe')
+
+    try {
+      // 1. 检查核心可执行文件是否存在
+      if (!existsSync(goExe)) {
+        return { isValid: false, error: 'go.exe 文件不存在' }
+      }
+      if (!existsSync(gofmtExe)) {
+        return { isValid: false, error: 'gofmt.exe 文件不存在' }
+      }
+
+      // 2. 验证 go version 命令
+      const { stdout: versionOutput } = await execAsync(`"${goExe}" version`, { timeout: 10000 })
+      if (!versionOutput.includes(version)) {
+        return { isValid: false, error: `版本验证失败，期望 ${version}，实际 ${versionOutput.trim()}` }
+      }
+
+      // 3. 验证 go env 命令
+      await execAsync(`"${goExe}" env GOROOT`, { timeout: 10000 })
+
+      // 4. 验证 go mod 功能
+      await execAsync(`"${goExe}" help mod`, { timeout: 10000 })
+
+      // 5. 验证 go build 命令可用
+      await execAsync(`"${goExe}" help build`, { timeout: 10000 })
+
+      // 6. 检查标准库目录
+      const srcDir = join(goPath, 'src')
+      if (!existsSync(srcDir)) {
+        return { isValid: false, error: '标准库源码目录不存在' }
+      }
+
+      return { isValid: true }
+
+    } catch (error: any) {
+      return { isValid: false, error: `验证过程出错: ${error.message}` }
+    }
+  }
+
+  /**
+   * 清理失败的安装
+   */
+  private async cleanupFailedInstallation(installDir: string): Promise<void> {
+    try {
+      if (existsSync(installDir)) {
+        console.log(`清理失败的安装目录: ${installDir}`)
+        rmSync(installDir, { recursive: true, force: true })
+      }
+    } catch (error) {
+      console.warn(`清理安装目录失败: ${error}`)
+    }
+  }
+
+  /**
+   * 更新安装配置
+   */
+  private async updateInstallationConfig(version: string): Promise<void> {
+    const goVersions = this.configStore.get('goVersions' as any) || []
+    if (!goVersions.includes(version)) {
+      goVersions.push(version)
+      this.configStore.set('goVersions' as any, goVersions)
+    }
+  }
+
+  /**
+   * 清理临时文件
+   */
+  private async cleanupTempFiles(zipPath: string): Promise<void> {
+    try {
+      // 清理下载的 ZIP 文件
+      if (existsSync(zipPath)) {
+        unlinkSync(zipPath)
+        console.log(`已清理临时文件: ${zipPath}`)
+      }
+
+      // 清理部分下载文件
+      const partialFile = `${zipPath}.partial`
+      if (existsSync(partialFile)) {
+        unlinkSync(partialFile)
+        console.log(`已清理部分下载文件: ${partialFile}`)
+      }
+
+    } catch (error) {
+      console.warn(`清理临时文件时出错: ${error}`)
+      // 不抛出错误，因为这不应该影响安装结果
+    }
+  }
+
+  /**
+   * 卸载 Go 版本
+   * 包含完整的文件系统清理、环境变量清理和配置状态更新
+   * Requirements: 2.2, 2.3, 2.4, 2.5
+   */
+  async uninstall(version: string): Promise<{ success: boolean; message: string }> {
+    try {
+      console.log(`开始卸载 Go ${version}...`)
+      
+      const goBasePath = this.getGoBasePath()
+      const versionDir = join(goBasePath, `go-${version}`)
+
+      // 检查版本是否存在
+      if (!existsSync(versionDir)) {
+        return { success: false, message: `Go ${version} 未安装` }
+      }
+
+      // 获取当前活动版本
+      const activeVersion = this.configStore.get('activeGoVersion' as any)
+      const isActiveVersion = activeVersion === version
+
+      console.log(`版本目录: ${versionDir}`)
+      console.log(`是否为活动版本: ${isActiveVersion}`)
+
+      // 如果是当前活动版本，执行环境变量清理
+      if (isActiveVersion) {
+        console.log('清理活动版本的环境变量...')
+        await this.cleanupActiveVersionEnvironment(version)
+      }
+
+      // 执行文件系统清理和目录删除
+      console.log('执行文件系统清理...')
+      await this.performFileSystemCleanup(versionDir, version)
+
+      // 更新配置状态
+      console.log('更新配置状态...')
+      await this.updateUninstallConfiguration(version, isActiveVersion)
+
+      console.log(`Go ${version} 卸载完成`)
+      return { success: true, message: `Go ${version} 已成功卸载` }
+
+    } catch (error: any) {
+      console.error(`Go ${version} 卸载失败:`, error)
+      return { success: false, message: `卸载失败: ${error.message}` }
+    }
+  }
+
+  /**
+   * 清理活动版本的环境变量
+   * 移除 GOROOT、GOPATH 和 PATH 中的相关配置
+   * Requirements: 2.3
+   */
+  private async cleanupActiveVersionEnvironment(version: string): Promise<void> {
+    try {
+      const versionDir = this.getGoPath(version)
+      
+      console.log(`清理活动版本 ${version} 的环境变量`)
+      
+      // 使用专门的环境变量清理脚本
+      const cleanupScript = this.generateActiveVersionCleanupScript()
+      await this.executePowerShellScript(cleanupScript)
+      
+      console.log(`活动版本环境变量清理完成`)
+      
+    } catch (error: any) {
+      console.error(`环境变量清理失败: ${error.message}`)
+      throw new Error(`环境变量清理失败: ${error.message}`)
+    }
+  }
+
+  /**
+   * 执行文件系统清理和目录删除
+   * 完全删除版本目录及其所有内容
+   * Requirements: 2.2
+   */
+  private async performFileSystemCleanup(versionDir: string, version: string): Promise<void> {
+    try {
+      console.log(`开始删除目录: ${versionDir}`)
+      
+      // 检查目录是否存在
+      if (!existsSync(versionDir)) {
+        console.log(`目录不存在，跳过删除: ${versionDir}`)
+        return
+      }
+
+      // 获取目录信息用于日志记录
+      const dirStats = this.getDirectoryStats(versionDir)
+      console.log(`目录统计: ${dirStats.fileCount} 个文件, ${dirStats.dirCount} 个子目录`)
+
+      // 尝试删除目录（使用强制删除）
+      rmSync(versionDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 1000 })
+      
+      // 验证删除是否成功
+      if (existsSync(versionDir)) {
+        throw new Error(`目录删除失败，目录仍然存在: ${versionDir}`)
+      }
+
+      console.log(`目录删除成功: ${versionDir}`)
+      
+    } catch (error: any) {
+      console.error(`文件系统清理失败: ${error.message}`)
+      throw new Error(`文件系统清理失败: ${error.message}`)
+    }
+  }
+
+  /**
+   * 更新卸载后的配置状态
+   * 从已安装版本列表中移除，清除活动版本配置
+   * Requirements: 2.4, 2.5
+   */
+  private async updateUninstallConfiguration(version: string, wasActiveVersion: boolean): Promise<void> {
+    try {
+      console.log(`更新配置状态: 移除版本 ${version}`)
+      
+      // 从已安装版本列表中移除
+      const goVersions = this.configStore.get('goVersions' as any) || []
+      const index = goVersions.indexOf(version)
+      if (index > -1) {
+        goVersions.splice(index, 1)
+        this.configStore.set('goVersions' as any, goVersions)
+        console.log(`已从版本列表中移除: ${version}`)
+      } else {
+        console.log(`版本不在配置列表中: ${version}`)
+      }
+
+      // 如果卸载的是活动版本，清除活动版本配置
+      if (wasActiveVersion) {
+        this.configStore.set('activeGoVersion' as any, '')
+        console.log(`已清除活动版本配置`)
+        
+        // 如果还有其他版本，可以提示用户选择新的活动版本
+        const remainingVersions = await this.getInstalledVersions()
+        if (remainingVersions.length > 0) {
+          console.log(`提示: 还有 ${remainingVersions.length} 个版本可用，可以设置新的活动版本`)
+        }
+      }
+
+      console.log(`配置状态更新完成`)
+      
+    } catch (error: any) {
+      console.error(`配置状态更新失败: ${error.message}`)
+      throw new Error(`配置状态更新失败: ${error.message}`)
+    }
+  }
+
+  /**
+   * 生成活动版本清理的 PowerShell 脚本
+   * 清除 GOROOT、GOPATH 和 PATH 中的所有 Go 相关配置
+   */
+  private generateActiveVersionCleanupScript(): string {
+    return `
+      # Go 活动版本环境变量清理脚本
+      Write-Host "开始清理 Go 活动版本环境变量..."
+      
+      try {
+        # 获取当前用户 PATH
+        $userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
+        if ($userPath) {
+          Write-Host "当前 PATH: $userPath"
+          
+          $pathArray = $userPath -split ';' | Where-Object { $_ -ne '' -and $_ -ne $null }
+          
+          # 移除所有 Go 相关路径（更全面的清理）
+          $filteredPaths = $pathArray | Where-Object { 
+            -not ($_ -like '*\\go\\go-*\\bin' -or 
+                  $_ -like '*\\go-*\\bin' -or 
+                  $_ -like '*\\golang\\*\\bin' -or
+                  $_ -like '*\\Go\\*\\bin' -or
+                  $_ -like '*\\go\\bin' -or
+                  $_ -like '*\\golang\\bin')
+          }
+          
+          $finalPath = ($filteredPaths | Where-Object { $_ -ne '' -and $_ -ne $null } | Select-Object -Unique) -join ';'
+          [Environment]::SetEnvironmentVariable('PATH', $finalPath, 'User')
+          Write-Host "已清理 PATH 中的所有 Go 路径"
+        }
+        
+        # 清除 GOROOT
+        $currentGoRoot = [Environment]::GetEnvironmentVariable('GOROOT', 'User')
+        if ($currentGoRoot) {
+          [Environment]::SetEnvironmentVariable('GOROOT', $null, 'User')
+          Write-Host "已清除 GOROOT: $currentGoRoot"
+        }
+        
+        # 清除 GOPATH
+        $currentGoPath = [Environment]::GetEnvironmentVariable('GOPATH', 'User')
+        if ($currentGoPath) {
+          [Environment]::SetEnvironmentVariable('GOPATH', $null, 'User')
+          Write-Host "已清除 GOPATH: $currentGoPath"
+        }
+        
+        Write-Host "活动版本环境变量清理完成"
+        
+      } catch {
+        Write-Error "活动版本环境变量清理失败: $_"
+        throw $_
+      }
+    `
+  }
+
+  /**
+   * 获取目录统计信息
+   * 用于日志记录和验证
+   */
+  private getDirectoryStats(dirPath: string): { fileCount: number; dirCount: number; totalSize: number } {
+    let fileCount = 0
+    let dirCount = 0
+    let totalSize = 0
+
+    try {
+      const items = readdirSync(dirPath, { withFileTypes: true })
+      
+      for (const item of items) {
+        const itemPath = join(dirPath, item.name)
+        
+        if (item.isDirectory()) {
+          dirCount++
+          const subStats = this.getDirectoryStats(itemPath)
+          fileCount += subStats.fileCount
+          dirCount += subStats.dirCount
+          totalSize += subStats.totalSize
+        } else if (item.isFile()) {
+          fileCount++
+          try {
+            const stats = statSync(itemPath)
+            totalSize += stats.size
+          } catch {
+            // 忽略无法访问的文件
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`获取目录统计信息失败: ${dirPath}`, error)
+    }
+
+    return { fileCount, dirCount, totalSize }
+  }
+
+  /**
+   * 设置活动的 Go 版本
+   * 包含版本激活、环境变量更新和切换后的功能验证
+   * Requirements: 3.2, 3.3, 3.4
+   */
+  async setActive(version: string): Promise<{ success: boolean; message: string }> {
+    try {
+      console.log(`开始切换到 Go ${version}`)
+      
+      // 1. 验证版本是否已安装
+      const goBasePath = this.getGoBasePath()
+      const versionDir = join(goBasePath, `go-${version}`)
+      const goExe = join(versionDir, 'bin', 'go.exe')
+
+      if (!existsSync(goExe)) {
+        return { success: false, message: `Go ${version} 未安装，请先安装该版本` }
+      }
+
+      // 2. 执行版本激活和环境变量更新
+      console.log(`更新环境变量为 Go ${version}`)
+      await this.updateEnvironmentVariables(version)
+
+      // 3. 更新配置存储
+      const previousActiveVersion = this.configStore.get('activeGoVersion' as any) || ''
+      this.configStore.set('activeGoVersion' as any, version)
+      console.log(`配置已更新: ${previousActiveVersion} -> ${version}`)
+
+      // 4. 切换后的功能验证
+      console.log(`验证 Go ${version} 切换结果`)
+      const validationResult = await this.validateVersionSwitch(version)
+      
+      if (!validationResult.isValid) {
+        // 如果验证失败，尝试回滚
+        console.warn(`版本切换验证失败，尝试回滚到 ${previousActiveVersion}`)
+        if (previousActiveVersion) {
+          try {
+            await this.updateEnvironmentVariables(previousActiveVersion)
+            this.configStore.set('activeGoVersion' as any, previousActiveVersion)
+          } catch (rollbackError) {
+            console.error('回滚失败:', rollbackError)
+          }
+        }
+        
+        return { 
+          success: false, 
+          message: `版本切换失败: ${validationResult.errors.join('; ')}` 
+        }
+      }
+
+      // 5. 系统级 Go 命令验证
+      const systemValidation = await this.validateSystemGoCommand(version)
+      if (!systemValidation.isValid) {
+        console.warn('系统级 Go 命令验证失败，但环境变量已更新')
+        return {
+          success: true,
+          message: `Go ${version} 已设为默认版本，但系统级验证失败: ${systemValidation.error}。请重启终端或重新登录以使环境变量生效。`
+        }
+      }
+
+      console.log(`Go ${version} 切换成功`)
+      
+      // 记录成功的版本切换
+      await this.recordVersionSwitch(version, true)
+      
+      return { 
+        success: true, 
+        message: `已成功将 Go ${version} 设为默认版本` 
+      }
+
+    } catch (error: any) {
+      console.error(`Go ${version} 切换失败:`, error)
+      
+      // 记录失败的版本切换
+      await this.recordVersionSwitch(version, false)
+      
+      return { 
+        success: false, 
+        message: `版本切换失败: ${error.message}` 
+      }
+    }
+  }
+
+  /**
+   * 验证版本切换结果
+   * 检查环境变量是否正确设置
+   */
+  private async validateVersionSwitch(version: string): Promise<{ isValid: boolean; errors: string[] }> {
+    const errors: string[] = []
+    
+    try {
+      // 验证环境变量设置
+      const envValidation = await this.validateEnvironmentVariables(version)
+      if (!envValidation.isValid) {
+        errors.push(...envValidation.errors)
+      }
+
+      // 验证安装完整性
+      const installationValid = await this.validateInstallation(version)
+      if (!installationValid) {
+        errors.push(`Go ${version} 安装验证失败`)
+      }
+
+      // 验证 Go 信息获取
+      const goInfo = await this.getGoInfo(version)
+      if (!goInfo) {
+        errors.push(`无法获取 Go ${version} 的环境信息`)
+      } else {
+        // 验证 GOROOT 是否匹配
+        const expectedGoRoot = this.getGoPath(version)
+        if (goInfo.goroot !== expectedGoRoot) {
+          errors.push(`GOROOT 不匹配: 期望 ${expectedGoRoot}, 实际 ${goInfo.goroot}`)
+        }
+      }
+
+    } catch (error: any) {
+      errors.push(`版本切换验证过程出错: ${error.message}`)
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors
+    }
+  }
+
+  /**
+   * 验证系统级 Go 命令
+   * 检查在新进程中执行 go version 是否返回正确版本
+   */
+  private async validateSystemGoCommand(expectedVersion: string): Promise<{ isValid: boolean; error?: string }> {
+    try {
+      // 使用新的进程环境执行 go version
+      const { stdout } = await execAsync('go version', { 
+        timeout: 10000,
+        env: { ...process.env } // 使用当前环境变量
+      })
+      
+      const versionOutput = stdout.trim()
+      console.log(`系统 go version 输出: ${versionOutput}`)
+      
+      // 检查输出是否包含期望的版本
+      if (!versionOutput.includes(expectedVersion)) {
+        return {
+          isValid: false,
+          error: `go version 输出不匹配: 期望包含 '${expectedVersion}', 实际 '${versionOutput}'`
+        }
+      }
+
+      // 验证 go env 命令
+      const { stdout: goEnvOutput } = await execAsync('go env GOROOT', { timeout: 5000 })
+      const actualGoRoot = goEnvOutput.trim()
+      const expectedGoRoot = this.getGoPath(expectedVersion)
+      
+      if (actualGoRoot !== expectedGoRoot) {
+        return {
+          isValid: false,
+          error: `go env GOROOT 不匹配: 期望 '${expectedGoRoot}', 实际 '${actualGoRoot}'`
+        }
+      }
+
+      return { isValid: true }
+
+    } catch (error: any) {
+      return {
+        isValid: false,
+        error: `系统级 Go 命令验证失败: ${error.message}`
+      }
+    }
+  }
+
+  /**
+   * 获取版本切换历史
+   * 返回最近的版本切换记录
+   */
+  async getVersionSwitchHistory(): Promise<Array<{ version: string; timestamp: Date; success: boolean }>> {
+    try {
+      const history = this.configStore.get('goVersionSwitchHistory' as any) || []
+      return history.map((entry: any) => ({
+        version: entry.version,
+        timestamp: new Date(entry.timestamp),
+        success: entry.success
+      }))
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * 记录版本切换历史
+   */
+  private async recordVersionSwitch(version: string, success: boolean): Promise<void> {
+    try {
+      const history = this.configStore.get('goVersionSwitchHistory' as any) || []
+      const newEntry = {
+        version,
+        timestamp: new Date().toISOString(),
+        success
+      }
+      
+      // 保留最近 10 条记录
+      const updatedHistory = [newEntry, ...history].slice(0, 10)
+      this.configStore.set('goVersionSwitchHistory' as any, updatedHistory)
+    } catch (error) {
+      console.warn('记录版本切换历史失败:', error)
+    }
+  }
+
+  /**
+   * 验证 Go 安装
+   */
+  async validateInstallation(version: string): Promise<boolean> {
+    const goPath = this.getGoPath(version)
+    const goExe = join(goPath, 'bin', 'go.exe')
+    const gofmtExe = join(goPath, 'bin', 'gofmt.exe')
+    
+    try {
+      // 检查核心可执行文件
+      if (!existsSync(goExe)) return false
+      if (!existsSync(gofmtExe)) return false
+      
+      // 验证版本
+      const { stdout } = await execAsync(`"${goExe}" version`)
+      if (!stdout.includes(version)) return false
+      
+      // 验证环境和基本命令
+      await execAsync(`"${goExe}" env GOROOT`)
+      
+      // 验证 go mod 功能
+      await execAsync(`"${goExe}" help mod`)
+      
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * 获取 Go 环境信息
+   */
+  async getGoInfo(version: string): Promise<GoInfo | null> {
+    const goPath = this.getGoPath(version)
+    const goExe = join(goPath, 'bin', 'go.exe')
+
+    if (!existsSync(goExe)) {
+      return null
+    }
+
+    try {
+      const { stdout: goVersion } = await execAsync(`"${goExe}" version`, { timeout: 5000 })
+      const { stdout: goRoot } = await execAsync(`"${goExe}" env GOROOT`, { timeout: 5000 })
+      const { stdout: goOs } = await execAsync(`"${goExe}" env GOOS`, { timeout: 5000 })
+      const { stdout: goArch } = await execAsync(`"${goExe}" env GOARCH`, { timeout: 5000 })
+      
+      return {
+        version,
+        goroot: goRoot.trim(),
+        gopath: this.getDefaultGoPath(),
+        goversion: goVersion.trim(),
+        goos: goOs.trim(),
+        goarch: goArch.trim()
+      }
+    } catch (error) {
+      return null
+    }
+  }
+
+  /**
+   * 检测系统已安装的 Go 版本
+   */
+  async detectSystemGoVersion(): Promise<GoVersion | null> {
+    try {
+      // 尝试执行系统的 go 命令
+      const { stdout: goVersion } = await execAsync('go version', { timeout: 5000 })
+      const { stdout: goRoot } = await execAsync('go env GOROOT', { timeout: 5000 })
+      const { stdout: goPath } = await execAsync('go env GOPATH', { timeout: 5000 })
+      
+      // 解析版本号
+      const versionMatch = goVersion.match(/go(\d+\.\d+\.\d+)/)
+      if (!versionMatch) return null
+      
+      const version = versionMatch[1]
+      const systemGoRoot = goRoot.trim()
+      const systemGoPath = goPath.trim()
+      
+      return {
+        version: `go${version}`,
+        path: systemGoRoot,
+        isActive: false, // 系统版本不算作我们管理的活动版本
+        goroot: systemGoRoot,
+        gopath: systemGoPath,
+        installDate: undefined,
+        size: undefined
+      }
+    } catch (error) {
+      // 系统没有安装 Go 或者不在 PATH 中
+      return null
+    }
+  }
+
+  // ==================== 私有方法 ====================
+
+  /**
+   * 增强的文件下载管理器
+   * 支持 HTTPS 下载、进度跟踪、SHA256 校验、下载中断和重试
+   */
+  private async downloadFile(url: string, dest: string, name: string, expectedSha256?: string): Promise<void> {
+    const options: DownloadOptions = {
+      url,
+      dest,
+      name,
+      expectedSha256,
+      maxRetries: 3,
+      timeout: 600000 // 10 分钟超时
+    }
+
+    const result = await this.downloadWithRetry(options)
+    if (!result.success) {
+      throw new Error(result.message)
+    }
+  }
+
+  /**
+   * 带重试机制的下载
+   */
+  private async downloadWithRetry(options: DownloadOptions): Promise<DownloadResult> {
+    const { maxRetries = 3 } = options
+    let lastError: Error | null = null
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        console.log(`下载尝试 ${attempt}/${maxRetries}: ${options.name}`)
+        
+        // 检查是否存在部分下载的文件
+        const partialFile = `${options.dest}.partial`
+        let resumeFrom = 0
+        
+        if (existsSync(partialFile)) {
+          try {
+            const stats = statSync(partialFile)
+            resumeFrom = stats.size
+            console.log(`检测到部分下载文件，从 ${resumeFrom} 字节处恢复下载`)
+          } catch (e) {
+            // 如果无法读取部分文件，删除它
+            try {
+              unlinkSync(partialFile)
+            } catch {}
+            resumeFrom = 0
+          }
+        }
+
+        await this.performDownload(options, resumeFrom)
+        
+        // 下载成功后验证 SHA256（如果提供）
+        if (options.expectedSha256) {
+          const isValid = await this.verifySha256(options.dest, options.expectedSha256)
+          if (!isValid) {
+            // SHA256 验证失败，删除文件并重试
+            try {
+              unlinkSync(options.dest)
+            } catch {}
+            throw new Error('SHA256 校验失败')
+          }
+        }
+
+        // 清理部分下载文件
+        try {
+          unlinkSync(partialFile)
+        } catch {}
+
+        return {
+          success: true,
+          message: '下载完成',
+          filePath: options.dest
+        }
+
+      } catch (error: any) {
+        lastError = error
+        console.error(`下载尝试 ${attempt} 失败:`, error.message)
+        
+        if (attempt < maxRetries) {
+          // 等待一段时间后重试（指数退避）
+          const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000)
+          console.log(`等待 ${delay}ms 后重试...`)
+          await new Promise(resolve => setTimeout(resolve, delay))
+        }
+      }
+    }
+
+    return {
+      success: false,
+      message: `下载失败（已重试 ${maxRetries} 次）: ${lastError?.message || '未知错误'}`
+    }
+  }
+
+  /**
+   * 执行实际的下载操作
+   */
+  private async performDownload(options: DownloadOptions, resumeFrom: number = 0): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const protocol = options.url.startsWith('https') ? https : http
+      const partialFile = `${options.dest}.partial`
+      const isResume = resumeFrom > 0
+
+      const requestOptions: any = {
+        headers: {
+          'User-Agent': 'PHPer-Dev-Manager/1.0'
+        },
+        timeout: options.timeout || 600000
+      }
+
+      // 如果是断点续传，添加 Range 头
+      if (isResume) {
+        requestOptions.headers['Range'] = `bytes=${resumeFrom}-`
+      }
+
+      const request = protocol.get(options.url, requestOptions, (response) => {
+        // 处理重定向
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          const redirectUrl = response.headers.location
+          if (redirectUrl) {
+            const redirectOptions = { ...options, url: redirectUrl }
+            this.performDownload(redirectOptions, resumeFrom).then(resolve).catch(reject)
+            return
+          }
+        }
+
+        // 检查响应状态码
+        const expectedStatus = isResume ? 206 : 200 // 206 for partial content
+        if (response.statusCode !== expectedStatus && response.statusCode !== 200) {
+          reject(new Error(`下载失败: HTTP ${response.statusCode}`))
+          return
+        }
+
+        const totalSize = isResume 
+          ? resumeFrom + parseInt(response.headers['content-length'] || '0', 10)
+          : parseInt(response.headers['content-length'] || '0', 10)
+        let downloadedSize = resumeFrom
+
+        // 创建写入流（追加模式如果是断点续传）
+        const file = createWriteStream(isResume ? partialFile : options.dest, 
+          isResume ? { flags: 'a' } : undefined)
+
+        let lastProgressTime = 0
+        let lastDownloadedSize = downloadedSize
+        let downloadSpeed = 0
+
+        response.on('data', (chunk) => {
+          downloadedSize += chunk.length
+          const now = Date.now()
+          
+          // 每500ms更新一次进度和速度
+          if (now - lastProgressTime > 500) {
+            const timeDiff = (now - lastProgressTime) / 1000
+            const sizeDiff = downloadedSize - lastDownloadedSize
+            downloadSpeed = sizeDiff / timeDiff // bytes per second
+            
+            const progress = totalSize > 0 ? Math.round((downloadedSize / totalSize) * 100) : 0
+            sendDownloadProgress('go', progress, downloadedSize, totalSize)
+            
+            lastProgressTime = now
+            lastDownloadedSize = downloadedSize
+          }
+        })
+
+        response.pipe(file)
+
+        file.on('finish', () => {
+          file.close()
+          
+          // 如果是部分下载文件，重命名为最终文件
+          if (isResume) {
+            try {
+              if (existsSync(options.dest)) {
+                unlinkSync(options.dest)
+              }
+              require('fs').renameSync(partialFile, options.dest)
+            } catch (e) {
+              reject(new Error(`重命名文件失败: ${e}`))
+              return
+            }
+          }
+          
+          sendDownloadProgress('go', 100, totalSize, totalSize)
+          resolve()
+        })
+
+        file.on('error', (err) => {
+          try {
+            if (!isResume) {
+              unlinkSync(options.dest)
+            }
+          } catch {}
+          reject(err)
+        })
+      })
+
+      request.on('error', (err) => {
+        reject(new Error(`网络错误: ${err.message}`))
+      })
+
+      request.on('timeout', () => {
+        request.destroy()
+        reject(new Error('下载超时'))
+      })
+    })
+  }
+
+  /**
+   * 验证文件的 SHA256 校验和
+   */
+  private async verifySha256(filePath: string, expectedSha256: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      try {
+        const hash = createHash('sha256')
+        const stream = createReadStream(filePath)
+
+        stream.on('data', (data) => {
+          hash.update(data)
+        })
+
+        stream.on('end', () => {
+          const actualSha256 = hash.digest('hex').toLowerCase()
+          const expected = expectedSha256.toLowerCase()
+          resolve(actualSha256 === expected)
+        })
+
+        stream.on('error', () => {
+          resolve(false)
+        })
+      } catch {
+        resolve(false)
+      }
+    })
+  }
+
+  private async extractZip(zipPath: string, destDir: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const readStream = require('fs').createReadStream(zipPath)
+      readStream
+        .pipe(unzipper.Extract({ path: destDir }))
+        .on('close', resolve)
+        .on('error', reject)
+    })
+  }
+
+  /**
+   * 更新环境变量以支持指定的 Go 版本
+   * 设置 GOROOT、GOPATH 和 PATH，清理旧版本的路径配置
+   * Requirements: 3.1, 6.1, 6.2, 6.3, 6.4
+   */
+  private async updateEnvironmentVariables(goVersion: string): Promise<void> {
+    const goRoot = this.getGoPath(goVersion)
+    const goBin = join(goRoot, 'bin')
+    const goPath = this.getDefaultGoPath()
+    
+    console.log(`更新环境变量为 Go ${goVersion}`)
+    console.log(`GOROOT: ${goRoot}`)
+    console.log(`GOPATH: ${goPath}`)
+    console.log(`Go Binary Path: ${goBin}`)
+    
+    // 确保 GOPATH 工作空间目录存在
+    await this.ensureGoPathStructure(goPath)
+    
+    // 使用 PowerShell 脚本更新用户环境变量
+    const psScript = this.generateEnvironmentUpdateScript(goRoot, goPath, goBin)
+    
+    try {
+      await this.executePowerShellScript(psScript)
+      console.log(`环境变量更新成功: Go ${goVersion}`)
+    } catch (error: any) {
+      console.error(`环境变量更新失败: ${error.message}`)
+      throw new Error(`环境变量更新失败: ${error.message}`)
+    }
+  }
+
+  /**
+   * 确保 GOPATH 工作空间目录结构存在
+   * 创建标准的 Go 工作空间结构：src, pkg, bin
+   */
+  private async ensureGoPathStructure(goPath: string): Promise<void> {
+    try {
+      if (!existsSync(goPath)) {
+        mkdirSync(goPath, { recursive: true })
+        console.log(`创建 GOPATH 目录: ${goPath}`)
+      }
+      
+      // 创建标准的 Go 工作空间结构
+      const subdirs = ['src', 'pkg', 'bin']
+      for (const subdir of subdirs) {
+        const dirPath = join(goPath, subdir)
+        if (!existsSync(dirPath)) {
+          mkdirSync(dirPath, { recursive: true })
+          console.log(`创建 GOPATH 子目录: ${dirPath}`)
+        }
+      }
+    } catch (error: any) {
+      throw new Error(`创建 GOPATH 结构失败: ${error.message}`)
+    }
+  }
+
+  /**
+   * 生成环境变量更新的 PowerShell 脚本
+   * 包含 GOROOT、GOPATH 设置和 PATH 清理更新
+   */
+  private generateEnvironmentUpdateScript(goRoot: string, goPath: string, goBin: string): string {
+    // 转义路径中的反斜杠
+    const escapedGoRoot = goRoot.replace(/\\/g, '\\\\')
+    const escapedGoPath = goPath.replace(/\\/g, '\\\\')
+    const escapedGoBin = goBin.replace(/\\/g, '\\\\')
+    
+    return `
+      # Go 环境变量更新脚本
+      Write-Host "开始更新 Go 环境变量..."
+      
+      try {
+        # 设置 GOROOT
+        Write-Host "设置 GOROOT: ${escapedGoRoot}"
+        [Environment]::SetEnvironmentVariable('GOROOT', '${escapedGoRoot}', 'User')
+        
+        # 设置 GOPATH
+        Write-Host "设置 GOPATH: ${escapedGoPath}"
+        [Environment]::SetEnvironmentVariable('GOPATH', '${escapedGoPath}', 'User')
+        
+        # 更新 PATH
+        Write-Host "更新 PATH 环境变量..."
+        $userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
+        if (-not $userPath) { $userPath = '' }
+        
+        $pathArray = $userPath -split ';' | Where-Object { $_ -ne '' -and $_ -ne $null }
+        
+        # 移除所有旧的 Go 路径（更全面的清理）
+        $filteredPaths = $pathArray | Where-Object { 
+          -not ($_ -like '*\\go\\go-*\\bin' -or 
+                $_ -like '*\\go-*\\bin' -or 
+                $_ -like '*\\golang\\*\\bin' -or
+                $_ -like '*\\Go\\*\\bin')
+        }
+        
+        # 添加新的 Go 路径到开头
+        $newPathArray = @('${escapedGoBin}') + $filteredPaths
+        $finalPath = ($newPathArray | Where-Object { $_ -ne '' -and $_ -ne $null } | Select-Object -Unique) -join ';'
+        
+        Write-Host "新的 PATH: $finalPath"
+        [Environment]::SetEnvironmentVariable('PATH', $finalPath, 'User')
+        
+        Write-Host "环境变量更新完成"
+        
+      } catch {
+        Write-Error "环境变量更新失败: $_"
+        throw $_
+      }
+    `
+  }
+
+  /**
+   * 从环境变量中移除指定 Go 版本的路径
+   * 清理 GOROOT、GOPATH 和 PATH 中的相关配置
+   */
+  private async removeFromPath(goPath: string): Promise<void> {
+    const goBin = join(goPath, 'bin')
+    
+    console.log(`从环境变量中移除 Go 路径: ${goBin}`)
+    
+    const psScript = this.generateEnvironmentCleanupScript(goBin)
+    
+    try {
+      await this.executePowerShellScript(psScript)
+      console.log(`环境变量清理成功`)
+    } catch (error: any) {
+      console.error(`环境变量清理失败: ${error.message}`)
+      throw new Error(`环境变量清理失败: ${error.message}`)
+    }
+  }
+
+  /**
+   * 生成环境变量清理的 PowerShell 脚本
+   * 移除指定的 Go 路径并清理 GOROOT、GOPATH
+   */
+  private generateEnvironmentCleanupScript(goBin: string): string {
+    const escapedGoBin = goBin.replace(/\\/g, '\\\\')
+    
+    return `
+      # Go 环境变量清理脚本
+      Write-Host "开始清理 Go 环境变量..."
+      
+      try {
+        # 获取当前用户 PATH
+        $userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
+        if ($userPath) {
+          $pathArray = $userPath -split ';' | Where-Object { $_ -ne '' -and $_ -ne $null }
+          
+          # 移除指定的 Go 路径
+          $filteredPaths = $pathArray | Where-Object { 
+            $_ -ne '${escapedGoBin}'
+          }
+          
+          $finalPath = ($filteredPaths | Where-Object { $_ -ne '' -and $_ -ne $null } | Select-Object -Unique) -join ';'
+          [Environment]::SetEnvironmentVariable('PATH', $finalPath, 'User')
+          Write-Host "已从 PATH 中移除: ${escapedGoBin}"
+        }
+        
+        # 清除 GOROOT 和 GOPATH（如果没有其他活动版本）
+        [Environment]::SetEnvironmentVariable('GOROOT', $null, 'User')
+        [Environment]::SetEnvironmentVariable('GOPATH', $null, 'User')
+        Write-Host "已清除 GOROOT 和 GOPATH"
+        
+        Write-Host "环境变量清理完成"
+        
+      } catch {
+        Write-Error "环境变量清理失败: $_"
+        throw $_
+      }
+    `
+  }g): string {
+    const escapedGoBin = goBin.replace(/\\/g, '\\\\')
+    
+    return `
+      # Go 环境变量清理脚本
+      Write-Host "开始清理 Go 环境变量..."
+      
+      try {
+        # 获取当前用户 PATH
+        $userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
+        if ($userPath) {
+          $pathArray = $userPath -split ';' | Where-Object { $_ -ne '' -and $_ -ne $null }
+          
+          # 移除指定的 Go 路径
+          $filteredPaths = $pathArray | Where-Object { 
+            $_ -ne '${escapedGoBin}'
+          }
+          
+          $finalPath = ($filteredPaths | Where-Object { $_ -ne '' -and $_ -ne $null } | Select-Object -Unique) -join ';'
+          [Environment]::SetEnvironmentVariable('PATH', $finalPath, 'User')
+          Write-Host "已从 PATH 中移除: ${escapedGoBin}"
+        }
+        
+        # 清除 GOROOT 和 GOPATH（如果没有其他活动版本）
+        [Environment]::SetEnvironmentVariable('GOROOT', $null, 'User')
+        [Environment]::SetEnvironmentVariable('GOPATH', $null, 'User')
+        Write-Host "已清除 GOROOT 和 GOPATH"
+        
+        Write-Host "环境变量清理完成"
+        
+      } catch {
+        Write-Error "环境变量清理失败: $_"
+        throw $_
+      }
+    `
+  }
+
+  /**
+   * 验证环境变量是否正确设置
+   * 检查 GOROOT、GOPATH 和 PATH 中的 Go 路径
+   */
+  async validateEnvironmentVariables(expectedVersion: string): Promise<{ isValid: boolean; errors: string[] }> {
+    const errors: string[] = []
+    const expectedGoRoot = this.getGoPath(expectedVersion)
+    const expectedGoPath = this.getDefaultGoPath()
+    const expectedGoBin = join(expectedGoRoot, 'bin')
+
+    try {
+      // 检查 GOROOT
+      const { stdout: actualGoRoot } = await execAsync('powershell -Command "[Environment]::GetEnvironmentVariable(\'GOROOT\', \'User\')"', { timeout: 5000 })
+      const cleanGoRoot = actualGoRoot.trim()
+      if (cleanGoRoot !== expectedGoRoot) {
+        errors.push(`GOROOT 不匹配: 期望 '${expectedGoRoot}', 实际 '${cleanGoRoot}'`)
+      }
+
+      // 检查 GOPATH
+      const { stdout: actualGoPath } = await execAsync('powershell -Command "[Environment]::GetEnvironmentVariable(\'GOPATH\', \'User\')"', { timeout: 5000 })
+      const cleanGoPath = actualGoPath.trim()
+      if (cleanGoPath !== expectedGoPath) {
+        errors.push(`GOPATH 不匹配: 期望 '${expectedGoPath}', 实际 '${cleanGoPath}'`)
+      }
+
+      // 检查 PATH 中是否包含 Go 二进制路径
+      const { stdout: userPath } = await execAsync('powershell -Command "[Environment]::GetEnvironmentVariable(\'PATH\', \'User\')"', { timeout: 5000 })
+      const pathEntries = userPath.trim().split(';').filter(p => p.trim() !== '')
+      const hasGoBin = pathEntries.some(p => p.trim() === expectedGoBin)
+      if (!hasGoBin) {
+        errors.push(`PATH 中缺少 Go 二进制路径: '${expectedGoBin}'`)
+      }
+
+      // 验证是否能够执行 go version 命令
+      try {
+        const { stdout: goVersionOutput } = await execAsync('go version', { timeout: 10000 })
+        if (!goVersionOutput.includes(expectedVersion)) {
+          errors.push(`go version 输出不匹配: 期望包含 '${expectedVersion}', 实际 '${goVersionOutput.trim()}'`)
+        }
+      } catch (error: any) {
+        errors.push(`无法执行 go version 命令: ${error.message}`)
+      }
+
+    } catch (error: any) {
+      errors.push(`环境变量验证过程出错: ${error.message}`)
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors
+    }
+  }
+
+  /**
+   * 获取当前环境变量状态
+   * 返回 GOROOT、GOPATH 和 PATH 的当前值
+   */
+  async getCurrentEnvironmentState(): Promise<{ goroot: string; gopath: string; pathEntries: string[] }> {
+    try {
+      const { stdout: goroot } = await execAsync('powershell -Command "[Environment]::GetEnvironmentVariable(\'GOROOT\', \'User\')"', { timeout: 5000 })
+      const { stdout: gopath } = await execAsync('powershell -Command "[Environment]::GetEnvironmentVariable(\'GOPATH\', \'User\')"', { timeout: 5000 })
+      const { stdout: userPath } = await execAsync('powershell -Command "[Environment]::GetEnvironmentVariable(\'PATH\', \'User\')"', { timeout: 5000 })
+      
+      const pathEntries = userPath.trim().split(';').filter(p => p.trim() !== '')
+      
+      return {
+        goroot: goroot.trim(),
+        gopath: gopath.trim(),
+        pathEntries
+      }
+    } catch (error: any) {
+      console.error('获取环境变量状态失败:', error)
+      return {
+        goroot: '',
+        gopath: '',
+        pathEntries: []
+      }
+    }
+  }
+    const tempPs1 = join(this.configStore.getTempPath(), 'update_go_env.ps1')
+    writeFileSync(tempPs1, script, 'utf-8')
+
+    try {
+      await execAsync(`powershell -ExecutionPolicy Bypass -File "${tempPs1}"`, { timeout: 30000 })
+    } finally {
+      try {
+        unlinkSync(tempPs1)
+      } catch (e) {
+        // 忽略
+      }
+    }
+  }
+
+  /**
+   * 执行 PowerShell 脚本
+   * 创建临时脚本文件并执行，完成后清理
+   */
+  private async executePowerShellScript(script: string): Promise<void> {
+    const tempPs1 = join(this.configStore.getTempPath(), `go_env_${Date.now()}.ps1`)
+    
+    try {
+      // 确保临时目录存在
+      const tempDir = this.configStore.getTempPath()
+      if (!existsSync(tempDir)) {
+        mkdirSync(tempDir, { recursive: true })
+      }
+      
+      // 写入脚本文件
+      writeFileSync(tempPs1, script, 'utf-8')
+      
+      // 执行 PowerShell 脚本
+      const command = `powershell -ExecutionPolicy Bypass -File "${tempPs1}"`
+      await execAsync(command, { timeout: 30000 })
+      
+    } catch (error: any) {
+      console.error('PowerShell 脚本执行失败:', error)
+      throw new Error(`PowerShell 脚本执行失败: ${error.message}`)
+    } finally {
+      // 清理临时脚本文件
+      try {
+        if (existsSync(tempPs1)) {
+          unlinkSync(tempPs1)
+        }
+      } catch (e) {
+        console.warn('清理临时脚本文件失败:', e)
+      }
+    }
+  }
+
+  private getFallbackVersions(): AvailableGoVersion[] {
+    return [
+      { version: 'go1.22.0', stable: true, downloadUrl: 'https://golang.org/dl/go1.22.0.windows-amd64.zip', size: 0, sha256: '' },
+      { version: 'go1.21.6', stable: true, downloadUrl: 'https://golang.org/dl/go1.21.6.windows-amd64.zip', size: 0, sha256: '' },
+      { version: 'go1.21.5', stable: true, downloadUrl: 'https://golang.org/dl/go1.21.5.windows-amd64.zip', size: 0, sha256: '' },
+      { version: 'go1.20.13', stable: true, downloadUrl: 'https://golang.org/dl/go1.20.13.windows-amd64.zip', size: 0, sha256: '' },
+      { version: 'go1.20.12', stable: true, downloadUrl: 'https://golang.org/dl/go1.20.12.windows-amd64.zip', size: 0, sha256: '' },
+      { version: 'go1.19.13', stable: true, downloadUrl: 'https://golang.org/dl/go1.19.13.windows-amd64.zip', size: 0, sha256: '' }
+    ]
+  }
+}
\ No newline at end of file
diff --git a/electron/services/__tests__/GoManager.test.ts b/electron/services/__tests__/GoManager.test.ts
new file mode 100644
index 0000000..0c634ce
--- /dev/null
+++ b/electron/services/__tests__/GoManager.test.ts
@@ -0,0 +1,1065 @@
+import { join } from 'path'
+import { existsSync, mkdirSync, rmSync } from 'fs'
+import { tmpdir } from 'os'
+import * as fc from 'fast-check'
+
+// Minimal ConfigStore interface for testing
+interface IConfigStore {
+  getBasePath(): string
+  getTempPath(): string
+  get(key: string): any
+  set(key: string, value: any): void
+}
+
+// Mock ConfigStore for testing
+class MockConfigStore implements IConfigStore {
+  private mockBasePath: string
+  private config: Record<string, any> = {}
+
+  constructor() {
+    // Create a temporary directory for testing
+    const testDir = join(tmpdir(), 'phper-test-' + Date.now())
+    mkdirSync(testDir, { recursive: true })
+    
+    this.mockBasePath = testDir
+    this.config = {
+      goVersions: [],
+      activeGoVersion: ''
+    }
+  }
+
+  getBasePath(): string {
+    return this.mockBasePath
+  }
+
+  getTempPath(): string {
+    return join(this.mockBasePath, 'temp')
+  }
+
+  get(key: string): any {
+    return this.config[key]
+  }
+
+  set(key: string, value: any): void {
+    this.config[key] = value
+  }
+
+  cleanup(): void {
+    if (existsSync(this.mockBasePath)) {
+      rmSync(this.mockBasePath, { recursive: true, force: true })
+    }
+  }
+}
+
+// Simplified GoManager for testing (without external dependencies)
+class TestGoManager {
+  private configStore: IConfigStore
+
+  constructor(configStore: IConfigStore) {
+    this.configStore = configStore
+  }
+
+  getGoBasePath(): string {
+    return join(this.configStore.getBasePath(), 'go')
+  }
+
+  getGoPath(version: string): string {
+    return join(this.getGoBasePath(), `go-${version}`)
+  }
+
+  getDefaultGoPath(): string {
+    return join(this.getGoBasePath(), 'workspace')
+  }
+
+  async getInstalledVersions(): Promise<any[]> {
+    const goBasePath = this.getGoBasePath()
+    
+    if (!existsSync(goBasePath)) {
+      return []
+    }
+
+    // In a real implementation, this would scan directories
+    // For testing, just return empty array
+    return []
+  }
+
+  async validateInstallation(version: string): Promise<boolean> {
+    const goPath = this.getGoPath(version)
+    const goExe = join(goPath, 'bin', 'go.exe')
+    
+    return existsSync(goExe)
+  }
+
+  // Method to test API response parsing
+  parseApiResponse(releases: any[]): any[] {
+    const availableVersions: any[] = []
+
+    for (const release of releases) {
+      if (release.stable) {
+        const windowsFile = release.files?.find((f: any) => 
+          f.os === 'windows' && f.arch === 'amd64' && f.kind === 'archive'
+        )
+        
+        if (windowsFile) {
+          availableVersions.push({
+            version: release.version,
+            stable: release.stable,
+            downloadUrl: `https://golang.org/dl/${windowsFile.filename}`,
+            size: windowsFile.size,
+            sha256: windowsFile.sha256
+          })
+        }
+      }
+    }
+
+    return availableVersions.slice(0, 20)
+  }
+}
+
+// Simple test runner for Node.js environment
+async function runTests() {
+  console.log('Running GoManager tests...')
+  
+  // Basic test implementation without external framework
+  const tests = [
+    {
+      name: 'GoManager initialization',
+      test: () => {
+        const mockStore = new MockConfigStore()
+        const manager = new TestGoManager(mockStore)
+        console.assert(manager instanceof TestGoManager, 'GoManager should initialize correctly')
+        mockStore.cleanup()
+        return true
+      }
+    },
+    {
+      name: 'Path generation',
+      test: () => {
+        const mockStore = new MockConfigStore()
+        const manager = new TestGoManager(mockStore)
+        const basePath = manager.getGoBasePath()
+        const versionPath = manager.getGoPath('go1.21.5')
+        const goPath = manager.getDefaultGoPath()
+        
+        console.assert(basePath.includes('go'), 'Base path should contain go directory')
+        console.assert(versionPath.includes('go-go1.21.5'), 'Version path should contain version')
+        console.assert(goPath.includes('workspace'), 'GOPATH should contain workspace')
+        
+        mockStore.cleanup()
+        return true
+      }
+    },
+    {
+      name: 'Empty versions list',
+      test: async () => {
+        const mockStore = new MockConfigStore()
+        const manager = new TestGoManager(mockStore)
+        const versions = await manager.getInstalledVersions()
+        
+        console.assert(Array.isArray(versions), 'Should return array')
+        console.assert(versions.length === 0, 'Should return empty array for no installations')
+        
+        mockStore.cleanup()
+        return true
+      }
+    },
+    {
+      name: 'Configuration integration',
+      test: () => {
+        const mockStore = new MockConfigStore()
+        const manager = new TestGoManager(mockStore)
+        
+        // Test config store integration
+        const activeVersion = mockStore.get('activeGoVersion')
+        const goVersions = mockStore.get('goVersions')
+        
+        console.assert(typeof activeVersion === 'string', 'Active version should be string')
+        console.assert(Array.isArray(goVersions), 'Go versions should be array')
+        
+        mockStore.cleanup()
+        return true
+      }
+    },
+    {
+      name: 'Installation validation',
+      test: async () => {
+        const mockStore = new MockConfigStore()
+        const manager = new TestGoManager(mockStore)
+        
+        // Test validation for non-existent version
+        const isValid = await manager.validateInstallation('go1.99.99')
+        console.assert(isValid === false, 'Should return false for non-existent version')
+        
+        mockStore.cleanup()
+        return true
+      }
+    }
+  ]
+  
+  let passed = 0
+  let failed = 0
+  
+  for (const test of tests) {
+    try {
+      const result = await test.test()
+      if (result) {
+        console.log(`✓ ${test.name}`)
+        passed++
+      } else {
+        console.log(`✗ ${test.name}`)
+        failed++
+      }
+    } catch (error) {
+      console.log(`✗ ${test.name}: ${error}`)
+      failed++
+    }
+  }
+  
+  console.log(`\nTests completed: ${passed} passed, ${failed} failed`)
+  return failed === 0
+}
+// Run tests if this file is executed directly
+if (require.main === module) {
+  runTests().then(success => {
+    process.exit(success ? 0 : 1)
+  }).catch(error => {
+    console.error('Test execution failed:', error)
+    process.exit(1)
+  })
+}
+
+// Export for potential use in other test files
+export { TestGoManager, MockConfigStore }
+
+// Property-based tests using Jest and fast-check
+describe('Go Version Management Properties', () => {
+  test('Property 1: API Version Fetching Consistency', () => {
+    // **Feature: go-version-management, Property 1: API Version Fetching Consistency**
+    fc.assert(fc.property(
+      fc.array(fc.record({
+        version: fc.string({ minLength: 1 }),
+        stable: fc.boolean(),
+        files: fc.array(fc.record({
+          os: fc.constantFrom('windows', 'linux', 'darwin'),
+          arch: fc.constantFrom('amd64', '386', 'arm64'),
+          kind: fc.constantFrom('archive', 'installer', 'source'),
+          filename: fc.string({ minLength: 1 }),
+          size: fc.nat(),
+          sha256: fc.string({ minLength: 64, maxLength: 64 }).filter(s => /^[0-9a-f]+$/i.test(s))
+        }))
+      })),
+      (mockApiResponse) => {
+        const mockStore = new MockConfigStore()
+        const manager = new TestGoManager(mockStore)
+        
+        try {
+          const result = manager.parseApiResponse(mockApiResponse)
+          
+          // Verify all returned versions have required fields
+          result.forEach(version => {
+            expect(version).toHaveProperty('version')
+            expect(version).toHaveProperty('stable')
+            expect(version).toHaveProperty('downloadUrl')
+            expect(version).toHaveProperty('size')
+            expect(version).toHaveProperty('sha256')
+            
+            // Verify types
+            expect(typeof version.version).toBe('string')
+            expect(typeof version.stable).toBe('boolean')
+            expect(typeof version.downloadUrl).toBe('string')
+            expect(typeof version.size).toBe('number')
+            expect(typeof version.sha256).toBe('string')
+            
+            // Verify download URL format
+            expect(version.downloadUrl).toMatch(/^https:\/\/golang\.org\/dl\//)
+          })
+          
+          // Verify only stable versions are returned
+          result.forEach(version => {
+            expect(version.stable).toBe(true)
+          })
+          
+          // Verify result is limited to 20 versions
+          expect(result.length).toBeLessThanOrEqual(20)
+          
+          return true
+        } finally {
+          mockStore.cleanup()
+        }
+      }
+    ), { numRuns: 10 })
+  })
+
+  test('Property 2: Download URL Construction', () => {
+    // **Feature: go-version-management, Property 2: Download URL Construction**
+    fc.assert(fc.property(
+      fc.record({
+        version: fc.string({ minLength: 1 }).filter(v => /^go\d+\.\d+\.\d+$/.test(v)),
+        filename: fc.string({ minLength: 1 }).filter(f => f.endsWith('.zip')),
+        size: fc.nat({ min: 1 }),
+        sha256: fc.string({ minLength: 64, maxLength: 64 }).filter(s => /^[0-9a-f]+$/i.test(s))
+      }),
+      (goVersion) => {
+        const mockStore = new MockConfigStore()
+        
+        try {
+          // Simulate constructing download URL
+          const downloadUrl = `https://golang.org/dl/${goVersion.filename}`
+          
+          // Verify URL construction
+          expect(downloadUrl).toMatch(/^https:\/\/golang\.org\/dl\//)
+          expect(downloadUrl).toContain(goVersion.filename)
+          expect(downloadUrl).toMatch(/\.zip$/)
+          
+          // Verify the URL is well-formed
+          expect(() => new URL(downloadUrl)).not.toThrow()
+          
+          // Verify version information is preserved
+          expect(goVersion.version).toMatch(/^go\d+\.\d+\.\d+$/)
+          expect(goVersion.size).toBeGreaterThan(0)
+          expect(goVersion.sha256).toMatch(/^[0-9a-f]{64}$/i)
+          
+          return true
+        } finally {
+          mockStore.cleanup()
+        }
+      }
+    ), { numRuns: 100 })
+  })
+
+  test('Property 3: Download Progress Reporting', () => {
+    // **Feature: go-version-management, Property 3: Download Progress Reporting**
+    fc.assert(fc.property(
+      fc.record({
+        downloadedBytes: fc.nat(),
+        totalBytes: fc.nat({ min: 1 }),
+        percent: fc.integer({ min: 0, max: 100 })
+      }).filter(progress => progress.downloadedBytes <= progress.totalBytes),
+      (progressData) => {
+        const mockStore = new MockConfigStore()
+        
+        try {
+          // Simulate progress reporting structure
+          const progress = {
+            percent: progressData.percent,
+            downloadedBytes: progressData.downloadedBytes,
+            totalBytes: progressData.totalBytes,
+            speed: progressData.downloadedBytes > 0 ? progressData.downloadedBytes / 1000 : 0
+          }
+          
+          // Verify progress data structure
+          expect(progress).toHaveProperty('percent')
+          expect(progress).toHaveProperty('downloadedBytes')
+          expect(progress).toHaveProperty('totalBytes')
+          expect(progress).toHaveProperty('speed')
+          
+          // Verify data types
+          expect(typeof progress.percent).toBe('number')
+          expect(typeof progress.downloadedBytes).toBe('number')
+          expect(typeof progress.totalBytes).toBe('number')
+          expect(typeof progress.speed).toBe('number')
+          
+          // Verify value ranges
+          expect(progress.percent).toBeGreaterThanOrEqual(0)
+          expect(progress.percent).toBeLessThanOrEqual(100)
+          expect(progress.downloadedBytes).toBeGreaterThanOrEqual(0)
+          expect(progress.totalBytes).toBeGreaterThan(0)
+          expect(progress.downloadedBytes).toBeLessThanOrEqual(progress.totalBytes)
+          expect(progress.speed).toBeGreaterThanOrEqual(0)
+          
+          // Verify percentage calculation consistency
+          if (progress.totalBytes > 0) {
+            const calculatedPercent = Math.round((progress.downloadedBytes / progress.totalBytes) * 100)
+            // Allow some tolerance for rounding differences
+            expect(Math.abs(progress.percent - calculatedPercent)).toBeLessThanOrEqual(1)
+          }
+          
+          return true
+        } finally {
+          mockStore.cleanup()
+        }
+      }
+    ), { numRuns: 100 })
+  })
+
+  test('Property 4: Installation Validation Completeness', () => {
+    // **Feature: go-version-management, Property 4: Installation Validation Completeness**
+    fc.assert(fc.property(
+      fc.record({
+        version: fc.string({ minLength: 1 }).filter(v => /^go\d+\.\d+\.\d+$/.test(v)),
+        hasGoExe: fc.boolean(),
+        hasGofmtExe: fc.boolean(),
+        hasValidVersion: fc.boolean(),
+        hasSrcDir: fc.boolean()
+      }),
+      (installationData) => {
+        const mockStore = new MockConfigStore()
+        
+        try {
+          // Simulate installation validation components
+          const validationChecks = {
+            goExeExists: installationData.hasGoExe,
+            gofmtExeExists: installationData.hasGofmtExe,
+            versionMatches: installationData.hasValidVersion,
+            srcDirExists: installationData.hasSrcDir
+          }
+          
+          // For a complete installation, all checks should pass
+          const isCompleteInstallation = Object.values(validationChecks).every(check => check === true)
+          
+          // Verify validation structure
+          expect(validationChecks).toHaveProperty('goExeExists')
+          expect(validationChecks).toHaveProperty('gofmtExeExists')
+          expect(validationChecks).toHaveProperty('versionMatches')
+          expect(validationChecks).toHaveProperty('srcDirExists')
+          
+          // Verify types
+          expect(typeof validationChecks.goExeExists).toBe('boolean')
+          expect(typeof validationChecks.gofmtExeExists).toBe('boolean')
+          expect(typeof validationChecks.versionMatches).toBe('boolean')
+          expect(typeof validationChecks.srcDirExists).toBe('boolean')
+          
+          // Verify version format
+          expect(installationData.version).toMatch(/^go\d+\.\d+\.\d+$/)
+          
+          // If installation is complete, all validation checks should pass
+          if (isCompleteInstallation) {
+            expect(validationChecks.goExeExists).toBe(true)
+            expect(validationChecks.gofmtExeExists).toBe(true)
+            expect(validationChecks.versionMatches).toBe(true)
+            expect(validationChecks.srcDirExists).toBe(true)
+          }
+          
+          // If any critical component is missing, installation should be considered incomplete
+          if (!validationChecks.goExeExists || !validationChecks.gofmtExeExists) {
+            expect(isCompleteInstallation).toBe(false)
+          }
+          
+          return true
+        } finally {
+          mockStore.cleanup()
+        }
+      }
+    ), { numRuns: 100 })
+  })
+
+  test('Property 5: Duplicate Installation Prevention', () => {
+    // **Feature: go-version-management, Property 5: Duplicate Installation Prevention**
+    fc.assert(fc.property(
+      fc.record({
+        version: fc.string({ minLength: 1 }).filter(v => /^go\d+\.\d+\.\d+$/.test(v)),
+        isAlreadyInstalled: fc.boolean(),
+        installationAttempts: fc.integer({ min: 1, max: 5 })
+      }),
+      (installationData) => {
+        const mockStore = new MockConfigStore()
+        
+        try {
+          // Simulate installation state
+          const installedVersions = installationData.isAlreadyInstalled 
+            ? [installationData.version] 
+            : []
+          
+          // Simulate multiple installation attempts
+          const installationResults = []
+          for (let i = 0; i < installationData.installationAttempts; i++) {
+            const isVersionInstalled = installedVersions.includes(installationData.version)
+            const result = {
+              success: !isVersionInstalled,
+              message: isVersionInstalled 
+                ? `Go ${installationData.version} 已安装，无需重复安装`
+                : `Go ${installationData.version} 安装成功`,
+              attempt: i + 1
+            }
+            installationResults.push(result)
+            
+            // If installation was successful, add to installed versions
+            if (result.success) {
+              installedVersions.push(installationData.version)
+            }
+          }
+          
+          // Verify installation results structure
+          installationResults.forEach(result => {
+            expect(result).toHaveProperty('success')
+            expect(result).toHaveProperty('message')
+            expect(result).toHaveProperty('attempt')
+            
+            expect(typeof result.success).toBe('boolean')
+            expect(typeof result.message).toBe('string')
+            expect(typeof result.attempt).toBe('number')
+            expect(result.message.length).toBeGreaterThan(0)
+          })
+          
+          // Verify duplicate installation prevention
+          if (installationData.isAlreadyInstalled) {
+            // If version was already installed, all attempts should fail
+            installationResults.forEach(result => {
+              expect(result.success).toBe(false)
+              expect(result.message).toContain('已安装')
+            })
+          } else {
+            // If version wasn't installed, first attempt should succeed, rest should fail
+            expect(installationResults[0].success).toBe(true)
+            expect(installationResults[0].message).toContain('安装成功')
+            
+            // Subsequent attempts should fail due to duplicate prevention
+            for (let i = 1; i < installationResults.length; i++) {
+              expect(installationResults[i].success).toBe(false)
+              expect(installationResults[i].message).toContain('已安装')
+            }
+          }
+          
+          // Verify version should only appear once in installed versions list
+          const versionCount = installedVersions.filter(v => v === installationData.version).length
+          expect(versionCount).toBeLessThanOrEqual(1)
+          
+          return true
+        } finally {
+          mockStore.cleanup()
+        }
+      }
+    ), { numRuns: 100 })
+  })
+
+  test('Property 11: Environment Variable Validation', () => {
+    // **Feature: go-version-management, Property 11: Environment Variable Validation**
+    fc.assert(fc.property(
+      fc.record({
+        version: fc.string({ minLength: 1 }).filter(v => /^go\d+\.\d+\.\d+$/.test(v)),
+        goroot: fc.string({ minLength: 1 }),
+        gopath: fc.string({ minLength: 1 }),
+        goBin: fc.string({ minLength: 1 }),
+        systemGoVersionOutput: fc.string({ minLength: 1 }),
+        systemGoRootOutput: fc.string({ minLength: 1 })
+      }),
+      (validationData) => {
+        const mockStore = new MockConfigStore()
+        
+        try {
+          // Simulate environment variable validation after version switch
+          const expectedGoRoot = validationData.goroot
+          const expectedGoPath = validationData.gopath
+          const expectedGoBin = validationData.goBin
+          
+          // Simulate system command outputs
+          const goVersionMatches = validationData.systemGoVersionOutput.includes(validationData.version)
+          const goRootMatches = validationData.systemGoRootOutput.trim() === expectedGoRoot
+          
+          // Simulate validation results
+          const validationResult = {
+            environmentVariables: {
+              GOROOT: expectedGoRoot,
+              GOPATH: expectedGoPath,
+              PATH: `${expectedGoBin};C:\\Windows\\System32`
+            },
+            systemValidation: {
+              goVersionOutput: validationData.systemGoVersionOutput,
+              goRootOutput: validationData.systemGoRootOutput,
+              goVersionMatches,
+              goRootMatches
+            },
+            errors: [] as string[]
+          }
+          
+          // Perform validation checks
+          if (!goVersionMatches) {
+            validationResult.errors.push(`go version 输出不匹配: 期望包含 '${validationData.version}', 实际 '${validationData.systemGoVersionOutput}'`)
+          }
+          
+          if (!goRootMatches) {
+            validationResult.errors.push(`GOROOT 不匹配: 期望 '${expectedGoRoot}', 实际 '${validationData.systemGoRootOutput.trim()}'`)
+          }
+          
+          // Check if PATH contains Go binary
+          const pathContainsGoBin = validationResult.environmentVariables.PATH.includes(expectedGoBin)
+          if (!pathContainsGoBin) {
+            validationResult.errors.push(`PATH 中缺少 Go 二进制路径: '${expectedGoBin}'`)
+          }
+          
+          const isValid = validationResult.errors.length === 0
+          
+          // Verify validation result structure
+          expect(validationResult).toHaveProperty('environmentVariables')
+          expect(validationResult).toHaveProperty('systemValidation')
+          expect(validationResult).toHaveProperty('errors')
+          
+          // Verify environment variables structure
+          expect(validationResult.environmentVariables).toHaveProperty('GOROOT')
+          expect(validationResult.environmentVariables).toHaveProperty('GOPATH')
+          expect(validationResult.environmentVariables).toHaveProperty('PATH')
+          
+          // Verify system validation structure
+          expect(validationResult.systemValidation).toHaveProperty('goVersionOutput')
+          expect(validationResult.systemValidation).toHaveProperty('goRootOutput')
+          expect(validationResult.systemValidation).toHaveProperty('goVersionMatches')
+          expect(validationResult.systemValidation).toHaveProperty('goRootMatches')
+          
+          // Verify types
+          expect(typeof validationResult.environmentVariables.GOROOT).toBe('string')
+          expect(typeof validationResult.environmentVariables.GOPATH).toBe('string')
+          expect(typeof validationResult.environmentVariables.PATH).toBe('string')
+          expect(typeof validationResult.systemValidation.goVersionMatches).toBe('boolean')
+          expect(typeof validationResult.systemValidation.goRootMatches).toBe('boolean')
+          expect(Array.isArray(validationResult.errors)).toBe(true)
+          
+          // Verify validation logic
+          if (goVersionMatches && goRootMatches && pathContainsGoBin) {
+            expect(isValid).toBe(true)
+            expect(validationResult.errors.length).toBe(0)
+          } else {
+            expect(isValid).toBe(false)
+            expect(validationResult.errors.length).toBeGreaterThan(0)
+          }
+          
+          // Verify error messages are descriptive
+          validationResult.errors.forEach(error => {
+            expect(typeof error).toBe('string')
+            expect(error.length).toBeGreaterThan(0)
+            expect(error).toMatch(/期望|实际|不匹配|缺少/)
+          })
+          
+          // Verify PATH structure
+          const pathEntries = validationResult.environmentVariables.PATH.split(';')
+          expect(pathEntries.length).toBeGreaterThan(0)
+          if (pathContainsGoBin) {
+            expect(pathEntries).toContain(expectedGoBin)
+          }
+          
+          // Verify version format in validation
+          expect(validationData.version).toMatch(/^go\d+\.\d+\.\d+$/)
+          
+          return true
+        } finally {
+          mockStore.cleanup()
+        }
+      }
+    ), { numRuns: 100 })
+  })
+
+  test('Property 7: Active Version Environment Management', () => {
+    // **Feature: go-version-management, Property 7: Active Version Environment Management**
+    fc.assert(fc.property(
+      fc.record({
+        version: fc.string({ minLength: 1 }).filter(v => /^go\d+\.\d+\.\d+$/.test(v)),
+        goroot: fc.string({ minLength: 1 }),
+        gopath: fc.string({ minLength: 1 }),
+        goBin: fc.string({ minLength: 1 }),
+        existingPathEntries: fc.array(fc.string({ minLength: 1 })),
+        hasOldGoPaths: fc.boolean()
+      }),
+      (envData) => {
+        const mockStore = new MockConfigStore()
+        
+        try {
+          // Simulate environment variable update process
+          const currentPath = envData.existingPathEntries.join(';')
+          
+          // Add some old Go paths if specified
+          let pathWithOldGo = currentPath
+          if (envData.hasOldGoPaths) {
+            pathWithOldGo = `${currentPath};C:\\go\\go-1.20.0\\bin;C:\\go\\go-1.19.0\\bin`
+          }
+          
+          // Simulate PATH cleaning and updating
+          const pathArray = pathWithOldGo.split(';').filter(p => p.trim() !== '')
+          
+          // Remove old Go paths (simulate the cleaning logic)
+          const filteredPaths = pathArray.filter(p => 
+            !p.includes('\\go\\go-') && 
+            !p.includes('\\go-') && 
+            !p.includes('\\golang\\') &&
+            !p.includes('\\Go\\')
+          )
+          
+          // Add new Go path
+          const newPathArray = [envData.goBin, ...filteredPaths]
+          const finalPath = newPathArray.filter(p => p.trim() !== '').join(';')
+          
+          // Simulate environment variables
+          const environmentVariables = {
+            GOROOT: envData.goroot,
+            GOPATH: envData.gopath,
+            PATH: finalPath
+          }
+          
+          // Verify environment variable structure
+          expect(environmentVariables).toHaveProperty('GOROOT')
+          expect(environmentVariables).toHaveProperty('GOPATH')
+          expect(environmentVariables).toHaveProperty('PATH')
+          
+          // Verify types
+          expect(typeof environmentVariables.GOROOT).toBe('string')
+          expect(typeof environmentVariables.GOPATH).toBe('string')
+          expect(typeof environmentVariables.PATH).toBe('string')
+          
+          // Verify values are non-empty
+          expect(environmentVariables.GOROOT.length).toBeGreaterThan(0)
+          expect(environmentVariables.GOPATH.length).toBeGreaterThan(0)
+          expect(environmentVariables.PATH.length).toBeGreaterThan(0)
+          
+          // Verify PATH contains the new Go binary path
+          expect(environmentVariables.PATH).toContain(envData.goBin)
+          
+          // Verify old Go paths are removed
+          const pathEntries = environmentVariables.PATH.split(';')
+          const hasOldGoPaths = pathEntries.some(p => 
+            (p.includes('\\go\\go-') || p.includes('\\go-')) && p !== envData.goBin
+          )
+          expect(hasOldGoPaths).toBe(false)
+          
+          // Verify Go binary path appears only once
+          const goPathCount = pathEntries.filter(p => p === envData.goBin).length
+          expect(goPathCount).toBe(1)
+          
+          // Verify Go binary path is at the beginning (highest priority)
+          expect(pathEntries[0]).toBe(envData.goBin)
+          
+          return true
+        } finally {
+          mockStore.cleanup()
+        }
+      }
+    ), { numRuns: 100 })
+  })
+
+  test('Property 14: GOPATH Default Configuration', () => {
+    // **Feature: go-version-management, Property 14: GOPATH Default Configuration**
+    fc.assert(fc.property(
+      fc.record({
+        basePath: fc.string({ minLength: 1 }),
+        version: fc.string({ minLength: 1 }).filter(v => /^go\d+\.\d+\.\d+$/.test(v))
+      }),
+      (configData) => {
+        const mockStore = new MockConfigStore()
+        
+        try {
+          // Simulate GOPATH configuration logic
+          const goBasePath = `${configData.basePath}\\go`
+          const defaultGoPath = `${goBasePath}\\workspace`
+          
+          // Simulate GOPATH workspace structure
+          const workspaceStructure = {
+            gopath: defaultGoPath,
+            subdirectories: ['src', 'pkg', 'bin'],
+            fullPaths: [
+              `${defaultGoPath}\\src`,
+              `${defaultGoPath}\\pkg`,
+              `${defaultGoPath}\\bin`
+            ]
+          }
+          
+          // Verify GOPATH structure
+          expect(workspaceStructure).toHaveProperty('gopath')
+          expect(workspaceStructure).toHaveProperty('subdirectories')
+          expect(workspaceStructure).toHaveProperty('fullPaths')
+          
+          // Verify types
+          expect(typeof workspaceStructure.gopath).toBe('string')
+          expect(Array.isArray(workspaceStructure.subdirectories)).toBe(true)
+          expect(Array.isArray(workspaceStructure.fullPaths)).toBe(true)
+          
+          // Verify GOPATH format
+          expect(workspaceStructure.gopath).toContain('workspace')
+          expect(workspaceStructure.gopath.length).toBeGreaterThan(0)
+          
+          // Verify standard Go workspace subdirectories
+          expect(workspaceStructure.subdirectories).toContain('src')
+          expect(workspaceStructure.subdirectories).toContain('pkg')
+          expect(workspaceStructure.subdirectories).toContain('bin')
+          expect(workspaceStructure.subdirectories.length).toBe(3)
+          
+          // Verify full paths are correctly constructed
+          workspaceStructure.fullPaths.forEach(path => {
+            expect(path).toContain(workspaceStructure.gopath)
+            expect(typeof path).toBe('string')
+            expect(path.length).toBeGreaterThan(workspaceStructure.gopath.length)
+          })
+          
+          // Verify each subdirectory has a corresponding full path
+          workspaceStructure.subdirectories.forEach(subdir => {
+            const expectedPath = `${workspaceStructure.gopath}\\${subdir}`
+            expect(workspaceStructure.fullPaths).toContain(expectedPath)
+          })
+          
+          // Verify GOPATH is under the Go base directory
+          expect(workspaceStructure.gopath).toContain(goBasePath)
+          
+          // Verify GOPATH uses the standard workspace directory name
+          expect(workspaceStructure.gopath.endsWith('workspace')).toBe(true)
+          
+          return true
+        } finally {
+          mockStore.cleanup()
+        }
+      }
+    ), { numRuns: 100 })
+  })
+
+  test('Property 6: File System Cleanup on Uninstall', () => {
+    // **Feature: go-version-management, Property 6: File System Cleanup on Uninstall**
+    fc.assert(fc.property(
+      fc.record({
+        version: fc.string({ minLength: 1 }).filter(v => /^go\d+\.\d+\.\d+$/.test(v)),
+        versionDir: fc.string({ minLength: 1 }),
+        fileCount: fc.nat({ min: 1, max: 100 }),
+        dirCount: fc.nat({ min: 1, max: 20 }),
+        totalSize: fc.nat({ min: 1000, max: 1000000 }),
+        uninstallSuccess: fc.boolean()
+      }),
+      (uninstallData) => {
+        const mockStore = new MockConfigStore()
+        
+        try {
+          // Simulate uninstall operation and file system cleanup
+          const preUninstallState = {
+            versionExists: true,
+            directoryPath: uninstallData.versionDir,
+            fileCount: uninstallData.fileCount,
+            dirCount: uninstallData.dirCount,
+            totalSize: uninstallData.totalSize
+          }
+          
+          // Simulate uninstall result
+          const uninstallResult = {
+            success: uninstallData.uninstallSuccess,
+            message: uninstallData.uninstallSuccess 
+              ? `Go ${uninstallData.version} 已成功卸载`
+              : `卸载失败: 文件系统清理失败`,
+            filesRemoved: uninstallData.uninstallSuccess ? uninstallData.fileCount : 0,
+            dirsRemoved: uninstallData.uninstallSuccess ? uninstallData.dirCount : 0,
+            bytesFreed: uninstallData.uninstallSuccess ? uninstallData.totalSize : 0
+          }
+          
+          // Simulate post-uninstall state
+          const postUninstallState = {
+            versionExists: !uninstallData.uninstallSuccess,
+            directoryPath: uninstallData.versionDir,
+            fileCount: uninstallData.uninstallSuccess ? 0 : uninstallData.fileCount,
+            dirCount: uninstallData.uninstallSuccess ? 0 : uninstallData.dirCount,
+            totalSize: uninstallData.uninstallSuccess ? 0 : uninstallData.totalSize
+          }
+          
+          // Verify uninstall result structure
+          expect(uninstallResult).toHaveProperty('success')
+          expect(uninstallResult).toHaveProperty('message')
+          expect(uninstallResult).toHaveProperty('filesRemoved')
+          expect(uninstallResult).toHaveProperty('dirsRemoved')
+          expect(uninstallResult).toHaveProperty('bytesFreed')
+          
+          // Verify types
+          expect(typeof uninstallResult.success).toBe('boolean')
+          expect(typeof uninstallResult.message).toBe('string')
+          expect(typeof uninstallResult.filesRemoved).toBe('number')
+          expect(typeof uninstallResult.dirsRemoved).toBe('number')
+          expect(typeof uninstallResult.bytesFreed).toBe('number')
+          
+          // Verify message is descriptive
+          expect(uninstallResult.message.length).toBeGreaterThan(0)
+          expect(uninstallResult.message).toContain(uninstallData.version)
+          
+          // Verify cleanup completeness for successful uninstall
+          if (uninstallData.uninstallSuccess) {
+            expect(uninstallResult.success).toBe(true)
+            expect(uninstallResult.message).toContain('成功卸载')
+            expect(uninstallResult.filesRemoved).toBe(preUninstallState.fileCount)
+            expect(uninstallResult.dirsRemoved).toBe(preUninstallState.dirCount)
+            expect(uninstallResult.bytesFreed).toBe(preUninstallState.totalSize)
+            
+            // Post-uninstall state should show complete cleanup
+            expect(postUninstallState.versionExists).toBe(false)
+            expect(postUninstallState.fileCount).toBe(0)
+            expect(postUninstallState.dirCount).toBe(0)
+            expect(postUninstallState.totalSize).toBe(0)
+          } else {
+            expect(uninstallResult.success).toBe(false)
+            expect(uninstallResult.message).toContain('卸载失败')
+            expect(uninstallResult.filesRemoved).toBe(0)
+            expect(uninstallResult.dirsRemoved).toBe(0)
+            expect(uninstallResult.bytesFreed).toBe(0)
+            
+            // Post-uninstall state should show no changes
+            expect(postUninstallState.versionExists).toBe(true)
+            expect(postUninstallState.fileCount).toBe(preUninstallState.fileCount)
+            expect(postUninstallState.dirCount).toBe(preUninstallState.dirCount)
+            expect(postUninstallState.totalSize).toBe(preUninstallState.totalSize)
+          }
+          
+          // Verify numeric values are non-negative
+          expect(uninstallResult.filesRemoved).toBeGreaterThanOrEqual(0)
+          expect(uninstallResult.dirsRemoved).toBeGreaterThanOrEqual(0)
+          expect(uninstallResult.bytesFreed).toBeGreaterThanOrEqual(0)
+          
+          // Verify version format
+          expect(uninstallData.version).toMatch(/^go\d+\.\d+\.\d+$/)
+          
+          return true
+        } finally {
+          mockStore.cleanup()
+        }
+      }
+    ), { numRuns: 100 })
+  })
+
+  test('Property 8: Version State Consistency', () => {
+    // **Feature: go-version-management, Property 8: Version State Consistency**
+    fc.assert(fc.property(
+      fc.record({
+        initialVersions: fc.array(fc.string({ minLength: 1 }).filter(v => /^go\d+\.\d+\.\d+$/.test(v))),
+        versionToUninstall: fc.string({ minLength: 1 }).filter(v => /^go\d+\.\d+\.\d+$/.test(v)),
+        wasActiveVersion: fc.boolean(),
+        uninstallSuccess: fc.boolean()
+      }),
+      (stateData) => {
+        const mockStore = new MockConfigStore()
+        
+        try {
+          // Simulate initial state
+          const initialState = {
+            installedVersions: [...stateData.initialVersions],
+            activeVersion: stateData.wasActiveVersion ? stateData.versionToUninstall : '',
+            versionExists: stateData.initialVersions.includes(stateData.versionToUninstall)
+          }
+          
+          // Simulate uninstall operation
+          const uninstallOperation = {
+            targetVersion: stateData.versionToUninstall,
+            wasActive: stateData.wasActiveVersion && initialState.versionExists,
+            success: stateData.uninstallSuccess && initialState.versionExists
+          }
+          
+          // Simulate post-uninstall state
+          const postUninstallState = {
+            installedVersions: uninstallOperation.success 
+              ? initialState.installedVersions.filter(v => v !== stateData.versionToUninstall)
+              : [...initialState.installedVersions],
+            activeVersion: (uninstallOperation.success && uninstallOperation.wasActive) 
+              ? '' 
+              : initialState.activeVersion,
+            versionExists: !uninstallOperation.success && initialState.versionExists
+          }
+          
+          // Verify state consistency
+          expect(initialState).toHaveProperty('installedVersions')
+          expect(initialState).toHaveProperty('activeVersion')
+          expect(initialState).toHaveProperty('versionExists')
+          
+          expect(postUninstallState).toHaveProperty('installedVersions')
+          expect(postUninstallState).toHaveProperty('activeVersion')
+          expect(postUninstallState).toHaveProperty('versionExists')
+          
+          // Verify types
+          expect(Array.isArray(initialState.installedVersions)).toBe(true)
+          expect(Array.isArray(postUninstallState.installedVersions)).toBe(true)
+          expect(typeof initialState.activeVersion).toBe('string')
+          expect(typeof postUninstallState.activeVersion).toBe('string')
+          expect(typeof initialState.versionExists).toBe('boolean')
+          expect(typeof postUninstallState.versionExists).toBe('boolean')
+          
+          // Verify version format
+          expect(stateData.versionToUninstall).toMatch(/^go\d+\.\d+\.\d+$/)
+          initialState.installedVersions.forEach(version => {
+            expect(version).toMatch(/^go\d+\.\d+\.\d+$/)
+          })
+          postUninstallState.installedVersions.forEach(version => {
+            expect(version).toMatch(/^go\d+\.\d+\.\d+$/)
+          })
+          
+          // Verify state transitions for successful uninstall
+          if (uninstallOperation.success) {
+            // Version should be removed from installed versions list
+            expect(postUninstallState.installedVersions).not.toContain(stateData.versionToUninstall)
+            expect(postUninstallState.installedVersions.length).toBe(
+              Math.max(0, initialState.installedVersions.length - 1)
+            )
+            
+            // If uninstalled version was active, active version should be cleared
+            if (uninstallOperation.wasActive) {
+              expect(postUninstallState.activeVersion).toBe('')
+            }
+            
+            // Version should no longer exist
+            expect(postUninstallState.versionExists).toBe(false)
+          } else {
+            // State should remain unchanged for failed uninstall
+            expect(postUninstallState.installedVersions).toEqual(initialState.installedVersions)
+            expect(postUninstallState.activeVersion).toBe(initialState.activeVersion)
+            expect(postUninstallState.versionExists).toBe(initialState.versionExists)
+          }
+          
+          // Verify active version consistency
+          if (postUninstallState.activeVersion !== '') {
+            expect(postUninstallState.installedVersions).toContain(postUninstallState.activeVersion)
+          }
+          
+          // Verify no duplicate versions in installed list
+          const uniqueVersions = [...new Set(postUninstallState.installedVersions)]
+          expect(uniqueVersions.length).toBe(postUninstallState.installedVersions.length)
+          
+          // Verify uninstall operation properties
+          expect(typeof uninstallOperation.success).toBe('boolean')
+          expect(typeof uninstallOperation.wasActive).toBe('boolean')
+          
+          // If version didn't exist initially, uninstall should fail
+          if (!initialState.versionExists) {
+            expect(uninstallOperation.success).toBe(false)
+          }
+          
+          return true
+        } finally {
+          mockStore.cleanup()
+        }
+      }
+    ), { numRuns: 100 })
+  })
+
+  test('Property 9: Version Information Completeness', () => {
+    // **Feature: go-version-management, Property 9: Version Information Completeness**
+    fc.assert(fc.property(
+      fc.array(fc.record({
+        version: fc.string({ minLength: 1 }).filter(v => /^go\d+\.\d+\.\d+$/.test(v)),
+        path: fc.string({ minLength: 1 }),
+        isActive: fc.boolean(),
+        goroot: fc.string({ minLength: 1 }),
+        gopath: fc.string({ minLength: 1 })
+      })),
+      (mockVersions) => {
+        const mockStore = new MockConfigStore()
+        
+        try {
+          // Verify all version objects have required fields
+          mockVersions.forEach(version => {
+            expect(version).toHaveProperty('version')
+            expect(version).toHaveProperty('path')
+            expect(version).toHaveProperty('isActive')
+            expect(version).toHaveProperty('goroot')
+            expect(version).toHaveProperty('gopath')
+            
+            // Verify types
+            expect(typeof version.version).toBe('string')
+            expect(typeof version.path).toBe('string')
+            expect(typeof version.isActive).toBe('boolean')
+            expect(typeof version.goroot).toBe('string')
+            expect(typeof version.gopath).toBe('string')
+            
+            // Verify version format
+            expect(version.version).toMatch(/^go\d+\.\d+\.\d+$/)
+            
+            // Verify paths are non-empty
+            expect(version.path.length).toBeGreaterThan(0)
+            expect(version.goroot.length).toBeGreaterThan(0)
+            expect(version.gopath.length).toBeGreaterThan(0)
+          })
+          
+          // Verify at most one version can be active
+          const activeVersions = mockVersions.filter(v => v.isActive)
+          expect(activeVersions.length).toBeLessThanOrEqual(1)
+          
+          return true
+        } finally {
+          mockStore.cleanup()
+        }
+      }
+    ), { numRuns: 10 })
+  })
+})
\ No newline at end of file
diff --git a/jest.config.js b/jest.config.js
new file mode 100644
index 0000000..67d17fe
--- /dev/null
+++ b/jest.config.js
@@ -0,0 +1,16 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/electron'],
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  collectCoverageFrom: [
+    'electron/services/**/*.ts',
+    '!electron/services/**/*.test.ts',
+    '!electron/services/__tests__/**'
+  ],
+  moduleFileExtensions: ['ts', 'js'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest'
+  },
+  testTimeout: 30000
+}
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 7ab2578..265af85 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "phper-dev-manager",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "phper-dev-manager",
-      "version": "1.0.5",
+      "version": "1.0.7",
       "license": "MIT",
       "dependencies": {
         "@element-plus/icons-vue": "^2.3.1",
@@ -21,13 +21,17 @@
         "vue-router": "^4.2.5"
       },
       "devDependencies": {
+        "@types/jest": "^30.0.0",
         "@types/node": "^20.10.0",
         "@vitejs/plugin-vue": "^4.5.0",
         "concurrently": "^8.2.2",
         "electron": "^28.0.0",
         "electron-builder": "^24.9.1",
+        "fast-check": "^4.5.3",
+        "jest": "^30.2.0",
         "rcedit": "^5.0.2",
         "sass": "^1.69.5",
+        "ts-jest": "^29.4.6",
         "typescript": "^5.9.3",
         "vite": "^5.0.0",
         "vite-plugin-electron": "^0.15.5",
@@ -36,6 +40,166 @@
         "wait-on": "^7.2.0"
       }
     },
+    "node_modules/@babel/code-frame": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/code-frame/-/code-frame-7.28.6.tgz",
+      "integrity": "sha512-JYgintcMjRiCvS8mMECzaEn+m3PfoQiyqukOMCCVQtoJGYJw8j/8LBJEiqkHLkfwCcs74E3pbAUFNg7d9VNJ+Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/compat-data/-/compat-data-7.28.6.tgz",
+      "integrity": "sha512-2lfu57JtzctfIrcGMz992hyLlByuzgIk58+hhGCxjKZ3rWI82NnVLjXcaTqkI2NvlcvOskZaiZ5kjUALo3Lpxg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/core/-/core-7.28.6.tgz",
+      "integrity": "sha512-H3mcG6ZDLTlYfaSNi0iOKkigqMFvkTKlGUYlD8GW7nNOYRrevuA46iTypPyv+06V3fEmvvazfntkBU34L0azAw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/generator": "^7.28.6",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helpers": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/generator/-/generator-7.28.6.tgz",
+      "integrity": "sha512-lOoVRwADj8hjf7al89tvQ2a1lf53Z+7tiXMgpZJL3maQPDxh0DgLMN62B2MKUOFcoodBHLMbDM6WAbKgNy5Suw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets/node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmmirror.com/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets/node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmmirror.com/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmmirror.com/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
+      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/helper-string-parser": {
       "version": "7.27.1",
       "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
@@ -54,13 +218,37 @@
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/parser": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz",
-      "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==",
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmmirror.com/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/helpers/-/helpers-7.28.6.tgz",
+      "integrity": "sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.28.5"
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/parser/-/parser-7.28.6.tgz",
+      "integrity": "sha512-TeR9zWR18BvbfPmGbLampPMW+uW1NZnJlRuuHso8i87QZNq2JRF9i6RgxRqtEq+wQGsS19NNTWr2duhnE49mfQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.6"
       },
       "bin": {
         "parser": "bin/babel-parser.js"
@@ -69,6 +257,245 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/@babel/plugin-syntax-async-generators": {
+      "version": "7.8.4",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz",
+      "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-bigint": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz",
+      "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-class-properties": {
+      "version": "7.12.13",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz",
+      "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.12.13"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-class-static-block": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz",
+      "integrity": "sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-import-attributes": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.28.6.tgz",
+      "integrity": "sha512-jiLC0ma9XkQT3TKJ9uYvlakm66Pamywo+qwL+oL8HJOvc6TWdZXVfhqJr8CCzbSGUAbDOzlGHJC1U+vRfLQDvw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-import-meta": {
+      "version": "7.10.4",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz",
+      "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.10.4"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-json-strings": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz",
+      "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-jsx": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.28.6.tgz",
+      "integrity": "sha512-wgEmr06G6sIpqr8YDwA2dSRTE3bJ+V0IfpzfSY3Lfgd7YWOaAdlykvJi13ZKBt8cZHfgH1IXN+CL656W3uUa4w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-logical-assignment-operators": {
+      "version": "7.10.4",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz",
+      "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.10.4"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-nullish-coalescing-operator": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz",
+      "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-numeric-separator": {
+      "version": "7.10.4",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz",
+      "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.10.4"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-object-rest-spread": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz",
+      "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-optional-catch-binding": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz",
+      "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-optional-chaining": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz",
+      "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-private-property-in-object": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz",
+      "integrity": "sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-top-level-await": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz",
+      "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-typescript": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.28.6.tgz",
+      "integrity": "sha512-+nDNmQye7nlnuuHDboPbGm00Vqg3oO8niRRL27/4LYHUsHYh0zJ1xWOz0uRwNFmM1Avzk8wZbc6rdiYhomzv/A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
     "node_modules/@babel/runtime": {
       "version": "7.28.4",
       "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz",
@@ -79,10 +506,44 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@babel/template": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/template/-/template-7.28.6.tgz",
+      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/traverse/-/traverse-7.28.6.tgz",
+      "integrity": "sha512-fgWX62k02qtjqdSNTAGxmKYY/7FSL9WAS1o2Hu5+I5m9T0yxZzr4cnrfXQ/MX0rIifthCSs6FKTlzYbJcPtMNg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/generator": "^7.28.6",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.28.6",
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.28.6",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/types": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz",
-      "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==",
+      "version": "7.28.6",
+      "resolved": "https://registry.npmmirror.com/@babel/types/-/types-7.28.6.tgz",
+      "integrity": "sha512-0ZrskXVEHSWIqZM/sQZ4EV3jZJXRkio/WCxaqKZP1g//CEWEPSfeZFcms4XeKBCHU0ZKnIkdJeU/kF+eRp5lBg==",
       "license": "MIT",
       "dependencies": {
         "@babel/helper-string-parser": "^7.27.1",
@@ -92,6 +553,13 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@bcoe/v8-coverage": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmmirror.com/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz",
+      "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@ctrl/tinycolor": {
       "version": "3.6.1",
       "resolved": "https://registry.npmjs.org/@ctrl/tinycolor/-/tinycolor-3.6.1.tgz",
@@ -401,6 +869,40 @@
         "vue": "^3.2.0"
       }
     },
+    "node_modules/@emnapi/core": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmmirror.com/@emnapi/core/-/core-1.8.1.tgz",
+      "integrity": "sha512-AvT9QFpxK0Zd8J0jopedNm+w/2fIzvtPKPjqyw9jwvBaReTTqPBk9Hixaz7KbjimP+QNz605/XnjFcDAL2pqBg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.1.0",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmmirror.com/@emnapi/runtime/-/runtime-1.8.1.tgz",
+      "integrity": "sha512-mehfKSMWjjNol8659Z8KxEMrdSJDDot5SXMq00dM8BN4o+CLNXQ0xH2V7EchNHV4RmbZLmmPdEaXZc5H2FXmDg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/wasi-threads": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz",
+      "integrity": "sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.21.5",
       "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
@@ -937,12 +1439,568 @@
         "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
       }
     },
+    "node_modules/@istanbuljs/load-nyc-config": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz",
+      "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "camelcase": "^5.3.1",
+        "find-up": "^4.1.0",
+        "get-package-type": "^0.1.0",
+        "js-yaml": "^3.13.1",
+        "resolve-from": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@istanbuljs/load-nyc-config/node_modules/argparse": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmmirror.com/argparse/-/argparse-1.0.10.tgz",
+      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "sprintf-js": "~1.0.2"
+      }
+    },
+    "node_modules/@istanbuljs/load-nyc-config/node_modules/find-up": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmmirror.com/find-up/-/find-up-4.1.0.tgz",
+      "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^5.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@istanbuljs/load-nyc-config/node_modules/js-yaml": {
+      "version": "3.14.2",
+      "resolved": "https://registry.npmmirror.com/js-yaml/-/js-yaml-3.14.2.tgz",
+      "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^1.0.7",
+        "esprima": "^4.0.0"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/@istanbuljs/load-nyc-config/node_modules/locate-path": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmmirror.com/locate-path/-/locate-path-5.0.0.tgz",
+      "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@istanbuljs/load-nyc-config/node_modules/p-locate": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmmirror.com/p-locate/-/p-locate-4.1.0.tgz",
+      "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@istanbuljs/load-nyc-config/node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmmirror.com/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@istanbuljs/load-nyc-config/node_modules/sprintf-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmmirror.com/sprintf-js/-/sprintf-js-1.0.3.tgz",
+      "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@istanbuljs/schema": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmmirror.com/@istanbuljs/schema/-/schema-0.1.3.tgz",
+      "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@jest/console": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/console/-/console-30.2.0.tgz",
+      "integrity": "sha512-+O1ifRjkvYIkBqASKWgLxrpEhQAAE7hY77ALLUufSk5717KfOShg6IbqLmdsLMPdUiFvA2kTs0R7YZy+l0IzZQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "chalk": "^4.1.2",
+        "jest-message-util": "30.2.0",
+        "jest-util": "30.2.0",
+        "slash": "^3.0.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/core": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/core/-/core-30.2.0.tgz",
+      "integrity": "sha512-03W6IhuhjqTlpzh/ojut/pDB2LPRygyWX8ExpgHtQA8H/3K7+1vKmcINx5UzeOX1se6YEsBsOHQ1CRzf3fOwTQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/console": "30.2.0",
+        "@jest/pattern": "30.0.1",
+        "@jest/reporters": "30.2.0",
+        "@jest/test-result": "30.2.0",
+        "@jest/transform": "30.2.0",
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "ansi-escapes": "^4.3.2",
+        "chalk": "^4.1.2",
+        "ci-info": "^4.2.0",
+        "exit-x": "^0.2.2",
+        "graceful-fs": "^4.2.11",
+        "jest-changed-files": "30.2.0",
+        "jest-config": "30.2.0",
+        "jest-haste-map": "30.2.0",
+        "jest-message-util": "30.2.0",
+        "jest-regex-util": "30.0.1",
+        "jest-resolve": "30.2.0",
+        "jest-resolve-dependencies": "30.2.0",
+        "jest-runner": "30.2.0",
+        "jest-runtime": "30.2.0",
+        "jest-snapshot": "30.2.0",
+        "jest-util": "30.2.0",
+        "jest-validate": "30.2.0",
+        "jest-watcher": "30.2.0",
+        "micromatch": "^4.0.8",
+        "pretty-format": "30.2.0",
+        "slash": "^3.0.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
+      },
+      "peerDependenciesMeta": {
+        "node-notifier": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@jest/core/node_modules/ci-info": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmmirror.com/ci-info/-/ci-info-4.3.1.tgz",
+      "integrity": "sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/sibiraj-s"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@jest/diff-sequences": {
+      "version": "30.0.1",
+      "resolved": "https://registry.npmmirror.com/@jest/diff-sequences/-/diff-sequences-30.0.1.tgz",
+      "integrity": "sha512-n5H8QLDJ47QqbCNn5SuFjCRDrOLEZ0h8vAHCK5RL9Ls7Xa8AQLa/YxAc9UjFqoEDM48muwtBGjtMY5cr0PLDCw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/environment": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/environment/-/environment-30.2.0.tgz",
+      "integrity": "sha512-/QPTL7OBJQ5ac09UDRa3EQes4gt1FTEG/8jZ/4v5IVzx+Cv7dLxlVIvfvSVRiiX2drWyXeBjkMSR8hvOWSog5g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/fake-timers": "30.2.0",
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "jest-mock": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/expect": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/expect/-/expect-30.2.0.tgz",
+      "integrity": "sha512-V9yxQK5erfzx99Sf+7LbhBwNWEZ9eZay8qQ9+JSC0TrMR1pMDHLMY+BnVPacWU6Jamrh252/IKo4F1Xn/zfiqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "expect": "30.2.0",
+        "jest-snapshot": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/expect-utils": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/expect-utils/-/expect-utils-30.2.0.tgz",
+      "integrity": "sha512-1JnRfhqpD8HGpOmQp180Fo9Zt69zNtC+9lR+kT7NVL05tNXIi+QC8Csz7lfidMoVLPD3FnOtcmp0CEFnxExGEA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/get-type": "30.1.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/fake-timers": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/fake-timers/-/fake-timers-30.2.0.tgz",
+      "integrity": "sha512-HI3tRLjRxAbBy0VO8dqqm7Hb2mIa8d5bg/NJkyQcOk7V118ObQML8RC5luTF/Zsg4474a+gDvhce7eTnP4GhYw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/types": "30.2.0",
+        "@sinonjs/fake-timers": "^13.0.0",
+        "@types/node": "*",
+        "jest-message-util": "30.2.0",
+        "jest-mock": "30.2.0",
+        "jest-util": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/get-type": {
+      "version": "30.1.0",
+      "resolved": "https://registry.npmmirror.com/@jest/get-type/-/get-type-30.1.0.tgz",
+      "integrity": "sha512-eMbZE2hUnx1WV0pmURZY9XoXPkUYjpc55mb0CrhtdWLtzMQPFvu/rZkTLZFTsdaVQa+Tr4eWAteqcUzoawq/uA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/globals": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/globals/-/globals-30.2.0.tgz",
+      "integrity": "sha512-b63wmnKPaK+6ZZfpYhz9K61oybvbI1aMcIs80++JI1O1rR1vaxHUCNqo3ITu6NU0d4V34yZFoHMn/uoKr/Rwfw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/environment": "30.2.0",
+        "@jest/expect": "30.2.0",
+        "@jest/types": "30.2.0",
+        "jest-mock": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/pattern": {
+      "version": "30.0.1",
+      "resolved": "https://registry.npmmirror.com/@jest/pattern/-/pattern-30.0.1.tgz",
+      "integrity": "sha512-gWp7NfQW27LaBQz3TITS8L7ZCQ0TLvtmI//4OwlQRx4rnWxcPNIYjxZpDcN4+UlGxgm3jS5QPz8IPTCkb59wZA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "jest-regex-util": "30.0.1"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/reporters": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/reporters/-/reporters-30.2.0.tgz",
+      "integrity": "sha512-DRyW6baWPqKMa9CzeiBjHwjd8XeAyco2Vt8XbcLFjiwCOEKOvy82GJ8QQnJE9ofsxCMPjH4MfH8fCWIHHDKpAQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@bcoe/v8-coverage": "^0.2.3",
+        "@jest/console": "30.2.0",
+        "@jest/test-result": "30.2.0",
+        "@jest/transform": "30.2.0",
+        "@jest/types": "30.2.0",
+        "@jridgewell/trace-mapping": "^0.3.25",
+        "@types/node": "*",
+        "chalk": "^4.1.2",
+        "collect-v8-coverage": "^1.0.2",
+        "exit-x": "^0.2.2",
+        "glob": "^10.3.10",
+        "graceful-fs": "^4.2.11",
+        "istanbul-lib-coverage": "^3.0.0",
+        "istanbul-lib-instrument": "^6.0.0",
+        "istanbul-lib-report": "^3.0.0",
+        "istanbul-lib-source-maps": "^5.0.0",
+        "istanbul-reports": "^3.1.3",
+        "jest-message-util": "30.2.0",
+        "jest-util": "30.2.0",
+        "jest-worker": "30.2.0",
+        "slash": "^3.0.0",
+        "string-length": "^4.0.2",
+        "v8-to-istanbul": "^9.0.1"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
+      },
+      "peerDependenciesMeta": {
+        "node-notifier": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@jest/reporters/node_modules/glob": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmmirror.com/glob/-/glob-10.5.0.tgz",
+      "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "foreground-child": "^3.1.0",
+        "jackspeak": "^3.1.2",
+        "minimatch": "^9.0.4",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^1.11.1"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@jest/reporters/node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmmirror.com/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@jest/reporters/node_modules/minipass": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmmirror.com/minipass/-/minipass-7.1.2.tgz",
+      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/@jest/schemas": {
+      "version": "30.0.5",
+      "resolved": "https://registry.npmmirror.com/@jest/schemas/-/schemas-30.0.5.tgz",
+      "integrity": "sha512-DmdYgtezMkh3cpU8/1uyXakv3tJRcmcXxBOcO0tbaozPwpmh4YMsnWrQm9ZmZMfa5ocbxzbFk6O4bDPEc/iAnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@sinclair/typebox": "^0.34.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/snapshot-utils": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/snapshot-utils/-/snapshot-utils-30.2.0.tgz",
+      "integrity": "sha512-0aVxM3RH6DaiLcjj/b0KrIBZhSX1373Xci4l3cW5xiUWPctZ59zQ7jj4rqcJQ/Z8JuN/4wX3FpJSa3RssVvCug==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/types": "30.2.0",
+        "chalk": "^4.1.2",
+        "graceful-fs": "^4.2.11",
+        "natural-compare": "^1.4.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/source-map": {
+      "version": "30.0.1",
+      "resolved": "https://registry.npmmirror.com/@jest/source-map/-/source-map-30.0.1.tgz",
+      "integrity": "sha512-MIRWMUUR3sdbP36oyNyhbThLHyJ2eEDClPCiHVbrYAe5g3CHRArIVpBw7cdSB5fr+ofSfIb2Tnsw8iEHL0PYQg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.25",
+        "callsites": "^3.1.0",
+        "graceful-fs": "^4.2.11"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/test-result": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/test-result/-/test-result-30.2.0.tgz",
+      "integrity": "sha512-RF+Z+0CCHkARz5HT9mcQCBulb1wgCP3FBvl9VFokMX27acKphwyQsNuWH3c+ojd1LeWBLoTYoxF0zm6S/66mjg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/console": "30.2.0",
+        "@jest/types": "30.2.0",
+        "@types/istanbul-lib-coverage": "^2.0.6",
+        "collect-v8-coverage": "^1.0.2"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/test-sequencer": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/test-sequencer/-/test-sequencer-30.2.0.tgz",
+      "integrity": "sha512-wXKgU/lk8fKXMu/l5Hog1R61bL4q5GCdT6OJvdAFz1P+QrpoFuLU68eoKuVc4RbrTtNnTL5FByhWdLgOPSph+Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/test-result": "30.2.0",
+        "graceful-fs": "^4.2.11",
+        "jest-haste-map": "30.2.0",
+        "slash": "^3.0.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/transform": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/transform/-/transform-30.2.0.tgz",
+      "integrity": "sha512-XsauDV82o5qXbhalKxD7p4TZYYdwcaEXC77PPD2HixEFF+6YGppjrAAQurTl2ECWcEomHBMMNS9AH3kcCFx8jA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.27.4",
+        "@jest/types": "30.2.0",
+        "@jridgewell/trace-mapping": "^0.3.25",
+        "babel-plugin-istanbul": "^7.0.1",
+        "chalk": "^4.1.2",
+        "convert-source-map": "^2.0.0",
+        "fast-json-stable-stringify": "^2.1.0",
+        "graceful-fs": "^4.2.11",
+        "jest-haste-map": "30.2.0",
+        "jest-regex-util": "30.0.1",
+        "jest-util": "30.2.0",
+        "micromatch": "^4.0.8",
+        "pirates": "^4.0.7",
+        "slash": "^3.0.0",
+        "write-file-atomic": "^5.0.1"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/types": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/@jest/types/-/types-30.2.0.tgz",
+      "integrity": "sha512-H9xg1/sfVvyfU7o3zMfBEjQ1gcsdeTMgqHoYdN79tuLqfTtuu7WckRA1R5whDwOzxaZAeMKTYWqP+WCAi0CHsg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/pattern": "30.0.1",
+        "@jest/schemas": "30.0.5",
+        "@types/istanbul-lib-coverage": "^2.0.6",
+        "@types/istanbul-reports": "^3.0.4",
+        "@types/node": "*",
+        "@types/yargs": "^17.0.33",
+        "chalk": "^4.1.2"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmmirror.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmmirror.com/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmmirror.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
     "node_modules/@jridgewell/sourcemap-codec": {
       "version": "1.5.5",
       "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
       "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
       "license": "MIT"
     },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmmirror.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
     "node_modules/@malept/cross-spawn-promise": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-1.1.1.tgz",
@@ -1021,6 +2079,19 @@
         "node": ">= 10.0.0"
       }
     },
+    "node_modules/@napi-rs/wasm-runtime": {
+      "version": "0.2.12",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz",
+      "integrity": "sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "^1.4.3",
+        "@emnapi/runtime": "^1.4.3",
+        "@tybys/wasm-util": "^0.10.0"
+      }
+    },
     "node_modules/@parcel/watcher": {
       "version": "2.5.1",
       "resolved": "https://registry.npmjs.org/@parcel/watcher/-/watcher-2.5.1.tgz",
@@ -1350,6 +2421,19 @@
         "node": ">=14"
       }
     },
+    "node_modules/@pkgr/core": {
+      "version": "0.2.9",
+      "resolved": "https://registry.npmmirror.com/@pkgr/core/-/core-0.2.9.tgz",
+      "integrity": "sha512-QNqXyfVS2wm9hweSYD2O7F0G06uurj9kZ96TRQE5Y9hU7+tgdZwIkbAKc5Ocy1HxEY2kuDQa6cQ1WRs/O5LFKA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.18.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/pkgr"
+      }
+    },
     "node_modules/@popperjs/core": {
       "name": "@sxzz/popperjs-es",
       "version": "2.11.7",
@@ -1693,6 +2777,13 @@
       "dev": true,
       "license": "BSD-3-Clause"
     },
+    "node_modules/@sinclair/typebox": {
+      "version": "0.34.47",
+      "resolved": "https://registry.npmmirror.com/@sinclair/typebox/-/typebox-0.34.47.tgz",
+      "integrity": "sha512-ZGIBQ+XDvO5JQku9wmwtabcVTHJsgSWAHYtVuM9pBNNR5E88v6Jcj/llpmsjivig5X8A8HHOb4/mbEKPS5EvAw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@sindresorhus/is": {
       "version": "4.6.0",
       "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",
@@ -1706,6 +2797,26 @@
         "url": "https://github.com/sindresorhus/is?sponsor=1"
       }
     },
+    "node_modules/@sinonjs/commons": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmmirror.com/@sinonjs/commons/-/commons-3.0.1.tgz",
+      "integrity": "sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "type-detect": "4.0.8"
+      }
+    },
+    "node_modules/@sinonjs/fake-timers": {
+      "version": "13.0.5",
+      "resolved": "https://registry.npmmirror.com/@sinonjs/fake-timers/-/fake-timers-13.0.5.tgz",
+      "integrity": "sha512-36/hTbH2uaWuGVERyC6da9YwGWnzUZXuPro/F2LfsdOsLnCojz/iSH8MxUt/FD2S5XBSVPhmArFUXcpCQ2Hkiw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@sinonjs/commons": "^3.0.1"
+      }
+    },
     "node_modules/@szmarczak/http-timer": {
       "version": "4.0.6",
       "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-4.0.6.tgz",
@@ -1729,6 +2840,62 @@
         "node": ">= 10"
       }
     },
+    "node_modules/@tybys/wasm-util": {
+      "version": "0.10.1",
+      "resolved": "https://registry.npmmirror.com/@tybys/wasm-util/-/wasm-util-0.10.1.tgz",
+      "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmmirror.com/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmmirror.com/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmmirror.com/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmmirror.com/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
     "node_modules/@types/cacheable-request": {
       "version": "6.0.3",
       "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz",
@@ -1776,6 +2943,44 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/istanbul-lib-coverage": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmmirror.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz",
+      "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/istanbul-lib-report": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmmirror.com/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz",
+      "integrity": "sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/istanbul-lib-coverage": "*"
+      }
+    },
+    "node_modules/@types/istanbul-reports": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmmirror.com/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz",
+      "integrity": "sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/istanbul-lib-report": "*"
+      }
+    },
+    "node_modules/@types/jest": {
+      "version": "30.0.0",
+      "resolved": "https://registry.npmmirror.com/@types/jest/-/jest-30.0.0.tgz",
+      "integrity": "sha512-XTYugzhuwqWjws0CVz8QpM36+T+Dz5mTEBKhNs/esGLnCIlGdRy+Dq78NRjd7ls7r8BC8ZRMOrKlkO1hU0JOwA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "expect": "^30.0.0",
+        "pretty-format": "^30.0.0"
+      }
+    },
     "node_modules/@types/keyv": {
       "version": "3.1.4",
       "resolved": "https://registry.npmjs.org/@types/keyv/-/keyv-3.1.4.tgz",
@@ -1841,6 +3046,13 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@types/stack-utils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmmirror.com/@types/stack-utils/-/stack-utils-2.0.3.tgz",
+      "integrity": "sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/verror": {
       "version": "1.10.11",
       "resolved": "https://registry.npmjs.org/@types/verror/-/verror-1.10.11.tgz",
@@ -1855,6 +3067,23 @@
       "integrity": "sha512-g9gZnnXVq7gM7v3tJCWV/qw7w+KeOlSHAhgF9RytFyifW6AF61hdT2ucrYhPq9hLs5JIryeupHV3qGk95dH9ow==",
       "license": "MIT"
     },
+    "node_modules/@types/yargs": {
+      "version": "17.0.35",
+      "resolved": "https://registry.npmmirror.com/@types/yargs/-/yargs-17.0.35.tgz",
+      "integrity": "sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/yargs-parser": "*"
+      }
+    },
+    "node_modules/@types/yargs-parser": {
+      "version": "21.0.3",
+      "resolved": "https://registry.npmmirror.com/@types/yargs-parser/-/yargs-parser-21.0.3.tgz",
+      "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/yauzl": {
       "version": "2.10.3",
       "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
@@ -1866,6 +3095,282 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmmirror.com/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/@unrs/resolver-binding-android-arm-eabi": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-android-arm-eabi/-/resolver-binding-android-arm-eabi-1.11.1.tgz",
+      "integrity": "sha512-ppLRUgHVaGRWUx0R0Ut06Mjo9gBaBkg3v/8AxusGLhsIotbBLuRk51rAzqLC8gq6NyyAojEXglNjzf6R948DNw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-android-arm64": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-android-arm64/-/resolver-binding-android-arm64-1.11.1.tgz",
+      "integrity": "sha512-lCxkVtb4wp1v+EoN+HjIG9cIIzPkX5OtM03pQYkG+U5O/wL53LC4QbIeazgiKqluGeVEeBlZahHalCaBvU1a2g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-darwin-arm64": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-darwin-arm64/-/resolver-binding-darwin-arm64-1.11.1.tgz",
+      "integrity": "sha512-gPVA1UjRu1Y/IsB/dQEsp2V1pm44Of6+LWvbLc9SDk1c2KhhDRDBUkQCYVWe6f26uJb3fOK8saWMgtX8IrMk3g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-darwin-x64": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-darwin-x64/-/resolver-binding-darwin-x64-1.11.1.tgz",
+      "integrity": "sha512-cFzP7rWKd3lZaCsDze07QX1SC24lO8mPty9vdP+YVa3MGdVgPmFc59317b2ioXtgCMKGiCLxJ4HQs62oz6GfRQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-freebsd-x64": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-freebsd-x64/-/resolver-binding-freebsd-x64-1.11.1.tgz",
+      "integrity": "sha512-fqtGgak3zX4DCB6PFpsH5+Kmt/8CIi4Bry4rb1ho6Av2QHTREM+47y282Uqiu3ZRF5IQioJQ5qWRV6jduA+iGw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-arm-gnueabihf": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-linux-arm-gnueabihf/-/resolver-binding-linux-arm-gnueabihf-1.11.1.tgz",
+      "integrity": "sha512-u92mvlcYtp9MRKmP+ZvMmtPN34+/3lMHlyMj7wXJDeXxuM0Vgzz0+PPJNsro1m3IZPYChIkn944wW8TYgGKFHw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-arm-musleabihf": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-linux-arm-musleabihf/-/resolver-binding-linux-arm-musleabihf-1.11.1.tgz",
+      "integrity": "sha512-cINaoY2z7LVCrfHkIcmvj7osTOtm6VVT16b5oQdS4beibX2SYBwgYLmqhBjA1t51CarSaBuX5YNsWLjsqfW5Cw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-arm64-gnu": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-linux-arm64-gnu/-/resolver-binding-linux-arm64-gnu-1.11.1.tgz",
+      "integrity": "sha512-34gw7PjDGB9JgePJEmhEqBhWvCiiWCuXsL9hYphDF7crW7UgI05gyBAi6MF58uGcMOiOqSJ2ybEeCvHcq0BCmQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-arm64-musl": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-linux-arm64-musl/-/resolver-binding-linux-arm64-musl-1.11.1.tgz",
+      "integrity": "sha512-RyMIx6Uf53hhOtJDIamSbTskA99sPHS96wxVE/bJtePJJtpdKGXO1wY90oRdXuYOGOTuqjT8ACccMc4K6QmT3w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-ppc64-gnu": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-linux-ppc64-gnu/-/resolver-binding-linux-ppc64-gnu-1.11.1.tgz",
+      "integrity": "sha512-D8Vae74A4/a+mZH0FbOkFJL9DSK2R6TFPC9M+jCWYia/q2einCubX10pecpDiTmkJVUH+y8K3BZClycD8nCShA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-riscv64-gnu": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-linux-riscv64-gnu/-/resolver-binding-linux-riscv64-gnu-1.11.1.tgz",
+      "integrity": "sha512-frxL4OrzOWVVsOc96+V3aqTIQl1O2TjgExV4EKgRY09AJ9leZpEg8Ak9phadbuX0BA4k8U5qtvMSQQGGmaJqcQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-riscv64-musl": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-linux-riscv64-musl/-/resolver-binding-linux-riscv64-musl-1.11.1.tgz",
+      "integrity": "sha512-mJ5vuDaIZ+l/acv01sHoXfpnyrNKOk/3aDoEdLO/Xtn9HuZlDD6jKxHlkN8ZhWyLJsRBxfv9GYM2utQ1SChKew==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-s390x-gnu": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-linux-s390x-gnu/-/resolver-binding-linux-s390x-gnu-1.11.1.tgz",
+      "integrity": "sha512-kELo8ebBVtb9sA7rMe1Cph4QHreByhaZ2QEADd9NzIQsYNQpt9UkM9iqr2lhGr5afh885d/cB5QeTXSbZHTYPg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-x64-gnu": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-linux-x64-gnu/-/resolver-binding-linux-x64-gnu-1.11.1.tgz",
+      "integrity": "sha512-C3ZAHugKgovV5YvAMsxhq0gtXuwESUKc5MhEtjBpLoHPLYM+iuwSj3lflFwK3DPm68660rZ7G8BMcwSro7hD5w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-x64-musl": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-linux-x64-musl/-/resolver-binding-linux-x64-musl-1.11.1.tgz",
+      "integrity": "sha512-rV0YSoyhK2nZ4vEswT/QwqzqQXw5I6CjoaYMOX0TqBlWhojUf8P94mvI7nuJTeaCkkds3QE4+zS8Ko+GdXuZtA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-wasm32-wasi": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-wasm32-wasi/-/resolver-binding-wasm32-wasi-1.11.1.tgz",
+      "integrity": "sha512-5u4RkfxJm+Ng7IWgkzi3qrFOvLvQYnPBmjmZQ8+szTK/b31fQCnleNl1GgEt7nIsZRIf5PLhPwT0WM+q45x/UQ==",
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@napi-rs/wasm-runtime": "^0.2.11"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@unrs/resolver-binding-win32-arm64-msvc": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-win32-arm64-msvc/-/resolver-binding-win32-arm64-msvc-1.11.1.tgz",
+      "integrity": "sha512-nRcz5Il4ln0kMhfL8S3hLkxI85BXs3o8EYoattsJNdsX4YUU89iOkVn7g0VHSRxFuVMdM4Q1jEpIId1Ihim/Uw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-win32-ia32-msvc": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-win32-ia32-msvc/-/resolver-binding-win32-ia32-msvc-1.11.1.tgz",
+      "integrity": "sha512-DCEI6t5i1NmAZp6pFonpD5m7i6aFrpofcp4LA2i8IIq60Jyo28hamKBxNrZcyOwVOZkgsRp9O2sXWBWP8MnvIQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-win32-x64-msvc": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/@unrs/resolver-binding-win32-x64-msvc/-/resolver-binding-win32-x64-msvc-1.11.1.tgz",
+      "integrity": "sha512-lrW200hZdbfRtztbygyaq/6jP6AKE8qQN2KvPcJ+x7wiD038YtnYtZ82IMNJ69GJibV7bwL3y9FgK+5w/pYt6g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
     "node_modules/@vitejs/plugin-vue": {
       "version": "4.6.2",
       "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-4.6.2.tgz",
@@ -2184,6 +3689,35 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/ansi-escapes": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmmirror.com/ansi-escapes/-/ansi-escapes-4.3.2.tgz",
+      "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "type-fest": "^0.21.3"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ansi-escapes/node_modules/type-fest": {
+      "version": "0.21.3",
+      "resolved": "https://registry.npmmirror.com/type-fest/-/type-fest-0.21.3.tgz",
+      "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/ansi-regex": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
@@ -2208,6 +3742,20 @@
         "url": "https://github.com/chalk/ansi-styles?sponsor=1"
       }
     },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmmirror.com/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/app-builder-bin": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/app-builder-bin/-/app-builder-bin-4.0.0.tgz",
@@ -2471,6 +4019,105 @@
         "proxy-from-env": "^1.1.0"
       }
     },
+    "node_modules/babel-jest": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/babel-jest/-/babel-jest-30.2.0.tgz",
+      "integrity": "sha512-0YiBEOxWqKkSQWL9nNGGEgndoeL0ZpWrbLMNL5u/Kaxrli3Eaxlt3ZtIDktEvXt4L/R9r3ODr2zKwGM/2BjxVw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/transform": "30.2.0",
+        "@types/babel__core": "^7.20.5",
+        "babel-plugin-istanbul": "^7.0.1",
+        "babel-preset-jest": "30.2.0",
+        "chalk": "^4.1.2",
+        "graceful-fs": "^4.2.11",
+        "slash": "^3.0.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.11.0 || ^8.0.0-0"
+      }
+    },
+    "node_modules/babel-plugin-istanbul": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmmirror.com/babel-plugin-istanbul/-/babel-plugin-istanbul-7.0.1.tgz",
+      "integrity": "sha512-D8Z6Qm8jCvVXtIRkBnqNHX0zJ37rQcFJ9u8WOS6tkYOsRdHBzypCstaxWiu5ZIlqQtviRYbgnRLSoCEvjqcqbA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "workspaces": [
+        "test/babel-8"
+      ],
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.0.0",
+        "@istanbuljs/load-nyc-config": "^1.0.0",
+        "@istanbuljs/schema": "^0.1.3",
+        "istanbul-lib-instrument": "^6.0.2",
+        "test-exclude": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/babel-plugin-jest-hoist": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-30.2.0.tgz",
+      "integrity": "sha512-ftzhzSGMUnOzcCXd6WHdBGMyuwy15Wnn0iyyWGKgBDLxf9/s5ABuraCSpBX2uG0jUg4rqJnxsLc5+oYBqoxVaA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/babel__core": "^7.20.5"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/babel-preset-current-node-syntax": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmmirror.com/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.2.0.tgz",
+      "integrity": "sha512-E/VlAEzRrsLEb2+dv8yp3bo4scof3l9nR4lrld+Iy5NyVqgVYUJnDAmunkhPMisRI32Qc4iRiz425d8vM++2fg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/plugin-syntax-async-generators": "^7.8.4",
+        "@babel/plugin-syntax-bigint": "^7.8.3",
+        "@babel/plugin-syntax-class-properties": "^7.12.13",
+        "@babel/plugin-syntax-class-static-block": "^7.14.5",
+        "@babel/plugin-syntax-import-attributes": "^7.24.7",
+        "@babel/plugin-syntax-import-meta": "^7.10.4",
+        "@babel/plugin-syntax-json-strings": "^7.8.3",
+        "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4",
+        "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3",
+        "@babel/plugin-syntax-numeric-separator": "^7.10.4",
+        "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
+        "@babel/plugin-syntax-optional-catch-binding": "^7.8.3",
+        "@babel/plugin-syntax-optional-chaining": "^7.8.3",
+        "@babel/plugin-syntax-private-property-in-object": "^7.14.5",
+        "@babel/plugin-syntax-top-level-await": "^7.14.5"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0 || ^8.0.0-0"
+      }
+    },
+    "node_modules/babel-preset-jest": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/babel-preset-jest/-/babel-preset-jest-30.2.0.tgz",
+      "integrity": "sha512-US4Z3NOieAQumwFnYdUWKvUKh8+YSnS/gB3t6YBiz0bskpu7Pine8pPCheNxlPEW4wnUkma2a94YuW2q3guvCQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "babel-plugin-jest-hoist": "30.2.0",
+        "babel-preset-current-node-syntax": "^1.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.11.0 || ^8.0.0-beta.1"
+      }
+    },
     "node_modules/balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
@@ -2499,6 +4146,16 @@
       ],
       "license": "MIT"
     },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.9.14",
+      "resolved": "https://registry.npmmirror.com/baseline-browser-mapping/-/baseline-browser-mapping-2.9.14.tgz",
+      "integrity": "sha512-B0xUquLkiGLgHhpPBqvl7GWegWBUNuujQ6kXd/r1U38ElPT6Ok8KZ8e+FpUGEc2ZoRQUzq/aUnaKFc/svWUGSg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.js"
+      }
+    },
     "node_modules/bl": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
@@ -2552,7 +4209,6 @@
       "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
       "dependencies": {
         "fill-range": "^7.1.1"
       },
@@ -2560,6 +4216,64 @@
         "node": ">=8"
       }
     },
+    "node_modules/browserslist": {
+      "version": "4.28.1",
+      "resolved": "https://registry.npmmirror.com/browserslist/-/browserslist-4.28.1.tgz",
+      "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "baseline-browser-mapping": "^2.9.0",
+        "caniuse-lite": "^1.0.30001759",
+        "electron-to-chromium": "^1.5.263",
+        "node-releases": "^2.0.27",
+        "update-browserslist-db": "^1.2.0"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/bs-logger": {
+      "version": "0.2.6",
+      "resolved": "https://registry.npmmirror.com/bs-logger/-/bs-logger-0.2.6.tgz",
+      "integrity": "sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-json-stable-stringify": "2.x"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/bser": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmmirror.com/bser/-/bser-2.1.1.tgz",
+      "integrity": "sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "node-int64": "^0.4.0"
+      }
+    },
     "node_modules/buffer": {
       "version": "5.7.1",
       "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
@@ -2734,6 +4448,47 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmmirror.com/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/camelcase": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmmirror.com/camelcase/-/camelcase-5.3.1.tgz",
+      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001764",
+      "resolved": "https://registry.npmmirror.com/caniuse-lite/-/caniuse-lite-1.0.30001764.tgz",
+      "integrity": "sha512-9JGuzl2M+vPL+pz70gtMF9sHdMFbY9FJaQBi186cHKH3pSzDvzoUJUPV6fqiKIMyXbud9ZLg4F3Yza1vJ1+93g==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -2764,6 +4519,16 @@
         "node": ">=8"
       }
     },
+    "node_modules/char-regex": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/char-regex/-/char-regex-1.0.2.tgz",
+      "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/chokidar": {
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
@@ -2813,6 +4578,13 @@
         "node": ">=8"
       }
     },
+    "node_modules/cjs-module-lexer": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmmirror.com/cjs-module-lexer/-/cjs-module-lexer-2.2.0.tgz",
+      "integrity": "sha512-4bHTS2YuzUvtoLjdy+98ykbNB5jS0+07EvFNXerqZQJ89F7DI6ET7OQo/HJuW6K0aVsKA9hj9/RVb2kQVOrPDQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/cli-truncate": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-2.1.0.tgz",
@@ -2858,6 +4630,24 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/co": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmmirror.com/co/-/co-4.6.0.tgz",
+      "integrity": "sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "iojs": ">= 1.0.0",
+        "node": ">= 0.12.0"
+      }
+    },
+    "node_modules/collect-v8-coverage": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmmirror.com/collect-v8-coverage/-/collect-v8-coverage-1.0.3.tgz",
+      "integrity": "sha512-1L5aqIkwPfiodaMgQunkF1zRhNqifHBmtbbbxcr6yVxxBnliw4TDOW6NxpO8DJLgJ16OT+Y4ztZqP6p/FtXnAw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/color-convert": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
@@ -3075,6 +4865,13 @@
         "node": ">=16 || 14 >=14.17"
       }
     },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/core-util-is": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
@@ -3250,6 +5047,31 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/dedent": {
+      "version": "1.7.1",
+      "resolved": "https://registry.npmmirror.com/dedent/-/dedent-1.7.1.tgz",
+      "integrity": "sha512-9JmrhGZpOlEgOLdQgSm0zxFaYoQon408V1v49aqTWuXENVlnCuY9JBZcXZiCsZQWDjTm5Qf/nIvAy77mXDAjEg==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "babel-plugin-macros": "^3.1.0"
+      },
+      "peerDependenciesMeta": {
+        "babel-plugin-macros": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/deepmerge": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmmirror.com/deepmerge/-/deepmerge-4.3.1.tgz",
+      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/defer-to-connect": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz",
@@ -3321,6 +5143,16 @@
         "node": ">=0.10"
       }
     },
+    "node_modules/detect-newline": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmmirror.com/detect-newline/-/detect-newline-3.1.0.tgz",
+      "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/detect-node": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz",
@@ -3758,6 +5590,13 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.267",
+      "resolved": "https://registry.npmmirror.com/electron-to-chromium/-/electron-to-chromium-1.5.267.tgz",
+      "integrity": "sha512-0Drusm6MVRXSOJpGbaSVgcQsuB4hEkMpHXaVstcPmhu5LIedxs1xNK/nIxmQIU/RPC0+1/o0AVZfBTkTNJOdUw==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/electron/node_modules/@types/node": {
       "version": "18.19.130",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.130.tgz",
@@ -3800,6 +5639,19 @@
         "vue": "^3.3.0"
       }
     },
+    "node_modules/emittery": {
+      "version": "0.13.1",
+      "resolved": "https://registry.npmmirror.com/emittery/-/emittery-0.13.1.tgz",
+      "integrity": "sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/emittery?sponsor=1"
+      }
+    },
     "node_modules/emoji-regex": {
       "version": "8.0.0",
       "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
@@ -3844,6 +5696,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/error-ex": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmmirror.com/error-ex/-/error-ex-1.3.4.tgz",
+      "integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-arrayish": "^0.2.1"
+      }
+    },
     "node_modules/es-define-property": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
@@ -3959,12 +5821,98 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmmirror.com/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "bin": {
+        "esparse": "bin/esparse.js",
+        "esvalidate": "bin/esvalidate.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/estree-walker": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
       "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
       "license": "MIT"
     },
+    "node_modules/execa": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmmirror.com/execa/-/execa-5.1.1.tgz",
+      "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cross-spawn": "^7.0.3",
+        "get-stream": "^6.0.0",
+        "human-signals": "^2.1.0",
+        "is-stream": "^2.0.0",
+        "merge-stream": "^2.0.0",
+        "npm-run-path": "^4.0.1",
+        "onetime": "^5.1.2",
+        "signal-exit": "^3.0.3",
+        "strip-final-newline": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/execa?sponsor=1"
+      }
+    },
+    "node_modules/execa/node_modules/get-stream": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmmirror.com/get-stream/-/get-stream-6.0.1.tgz",
+      "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/execa/node_modules/signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmmirror.com/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/exit-x": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmmirror.com/exit-x/-/exit-x-0.2.2.tgz",
+      "integrity": "sha512-+I6B/IkJc1o/2tiURyz/ivu/O0nKNEArIUB5O7zBrlDVJr22SCLH3xTeEry428LvFhRzIA1g8izguxJ/gbNcVQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/expect": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/expect/-/expect-30.2.0.tgz",
+      "integrity": "sha512-u/feCi0GPsI+988gU2FLcsHyAHTU0MX1Wg68NhAnN7z/+C5wqG+CY8J53N9ioe8RXgaoz0nBR/TYMf3AycUuPw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/expect-utils": "30.2.0",
+        "@jest/get-type": "30.1.0",
+        "jest-matcher-utils": "30.2.0",
+        "jest-message-util": "30.2.0",
+        "jest-mock": "30.2.0",
+        "jest-util": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
     "node_modules/extract-zip": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
@@ -3997,6 +5945,29 @@
       "license": "MIT",
       "optional": true
     },
+    "node_modules/fast-check": {
+      "version": "4.5.3",
+      "resolved": "https://registry.npmmirror.com/fast-check/-/fast-check-4.5.3.tgz",
+      "integrity": "sha512-IE9csY7lnhxBnA8g/WI5eg/hygA6MGWJMSNfFRrBlXUciADEhS1EDB0SIsMSvzubzIlOBbVITSsypCsW717poA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/dubzzz"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fast-check"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "pure-rand": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12.17.0"
+      }
+    },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
@@ -4026,6 +5997,16 @@
       ],
       "license": "BSD-3-Clause"
     },
+    "node_modules/fb-watchman": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmmirror.com/fb-watchman/-/fb-watchman-2.0.2.tgz",
+      "integrity": "sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "bser": "2.1.1"
+      }
+    },
     "node_modules/fd-slicer": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
@@ -4052,7 +6033,6 @@
       "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
       "dependencies": {
         "to-regex-range": "^5.0.1"
       },
@@ -4204,6 +6184,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmmirror.com/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/get-caller-file": {
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
@@ -4237,6 +6227,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/get-package-type": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmmirror.com/get-package-type/-/get-package-type-0.1.0.tgz",
+      "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
     "node_modules/get-proto": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
@@ -4407,6 +6407,28 @@
       "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
       "license": "ISC"
     },
+    "node_modules/handlebars": {
+      "version": "4.7.8",
+      "resolved": "https://registry.npmmirror.com/handlebars/-/handlebars-4.7.8.tgz",
+      "integrity": "sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "minimist": "^1.2.5",
+        "neo-async": "^2.6.2",
+        "source-map": "^0.6.1",
+        "wordwrap": "^1.0.0"
+      },
+      "bin": {
+        "handlebars": "bin/handlebars"
+      },
+      "engines": {
+        "node": ">=0.4.7"
+      },
+      "optionalDependencies": {
+        "uglify-js": "^3.1.4"
+      }
+    },
     "node_modules/has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -4483,6 +6505,13 @@
         "node": ">=10"
       }
     },
+    "node_modules/html-escaper": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmmirror.com/html-escaper/-/html-escaper-2.0.2.tgz",
+      "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/http-cache-semantics": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
@@ -4533,6 +6562,16 @@
         "node": ">= 6"
       }
     },
+    "node_modules/human-signals": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmmirror.com/human-signals/-/human-signals-2.1.0.tgz",
+      "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=10.17.0"
+      }
+    },
     "node_modules/iconv-corefoundation": {
       "version": "1.1.7",
       "resolved": "https://registry.npmjs.org/iconv-corefoundation/-/iconv-corefoundation-1.1.7.tgz",
@@ -4592,6 +6631,36 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/import-local": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmmirror.com/import-local/-/import-local-3.2.0.tgz",
+      "integrity": "sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "pkg-dir": "^4.2.0",
+        "resolve-cwd": "^3.0.0"
+      },
+      "bin": {
+        "import-local-fixture": "fixtures/cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmmirror.com/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
     "node_modules/inflight": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
@@ -4610,6 +6679,13 @@
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "license": "ISC"
     },
+    "node_modules/is-arrayish": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmmirror.com/is-arrayish/-/is-arrayish-0.2.1.tgz",
+      "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/is-ci": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-3.0.1.tgz",
@@ -4659,6 +6735,16 @@
         "node": ">=8"
       }
     },
+    "node_modules/is-generator-fn": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmmirror.com/is-generator-fn/-/is-generator-fn-2.1.0.tgz",
+      "integrity": "sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/is-glob": {
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
@@ -4679,7 +6765,6 @@
       "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
       "engines": {
         "node": ">=0.12.0"
       }
@@ -4693,6 +6778,19 @@
         "node": ">=8"
       }
     },
+    "node_modules/is-stream": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/is-stream/-/is-stream-2.0.1.tgz",
+      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/is-wsl": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz",
@@ -4732,6 +6830,103 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/istanbul-lib-coverage": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmmirror.com/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
+      "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-lib-instrument": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmmirror.com/istanbul-lib-instrument/-/istanbul-lib-instrument-6.0.3.tgz",
+      "integrity": "sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@babel/core": "^7.23.9",
+        "@babel/parser": "^7.23.9",
+        "@istanbuljs/schema": "^0.1.3",
+        "istanbul-lib-coverage": "^3.2.0",
+        "semver": "^7.5.4"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/istanbul-lib-instrument/node_modules/semver": {
+      "version": "7.7.3",
+      "resolved": "https://registry.npmmirror.com/semver/-/semver-7.7.3.tgz",
+      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/istanbul-lib-report": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmmirror.com/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
+      "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "istanbul-lib-coverage": "^3.0.0",
+        "make-dir": "^4.0.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/istanbul-lib-report/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-lib-source-maps": {
+      "version": "5.0.6",
+      "resolved": "https://registry.npmmirror.com/istanbul-lib-source-maps/-/istanbul-lib-source-maps-5.0.6.tgz",
+      "integrity": "sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.23",
+        "debug": "^4.1.1",
+        "istanbul-lib-coverage": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/istanbul-reports": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmmirror.com/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
+      "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "html-escaper": "^2.0.0",
+        "istanbul-lib-report": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/jackspeak": {
       "version": "3.4.3",
       "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
@@ -4766,6 +6961,782 @@
         "node": ">=10"
       }
     },
+    "node_modules/jest": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest/-/jest-30.2.0.tgz",
+      "integrity": "sha512-F26gjC0yWN8uAA5m5Ss8ZQf5nDHWGlN/xWZIh8S5SRbsEKBovwZhxGd6LJlbZYxBgCYOtreSUyb8hpXyGC5O4A==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@jest/core": "30.2.0",
+        "@jest/types": "30.2.0",
+        "import-local": "^3.2.0",
+        "jest-cli": "30.2.0"
+      },
+      "bin": {
+        "jest": "bin/jest.js"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
+      },
+      "peerDependenciesMeta": {
+        "node-notifier": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/jest-changed-files": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-changed-files/-/jest-changed-files-30.2.0.tgz",
+      "integrity": "sha512-L8lR1ChrRnSdfeOvTrwZMlnWV8G/LLjQ0nG9MBclwWZidA2N5FviRki0Bvh20WRMOX31/JYvzdqTJrk5oBdydQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "execa": "^5.1.1",
+        "jest-util": "30.2.0",
+        "p-limit": "^3.1.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-changed-files/node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmmirror.com/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/jest-circus": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-circus/-/jest-circus-30.2.0.tgz",
+      "integrity": "sha512-Fh0096NC3ZkFx05EP2OXCxJAREVxj1BcW/i6EWqqymcgYKWjyyDpral3fMxVcHXg6oZM7iULer9wGRFvfpl+Tg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/environment": "30.2.0",
+        "@jest/expect": "30.2.0",
+        "@jest/test-result": "30.2.0",
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "chalk": "^4.1.2",
+        "co": "^4.6.0",
+        "dedent": "^1.6.0",
+        "is-generator-fn": "^2.1.0",
+        "jest-each": "30.2.0",
+        "jest-matcher-utils": "30.2.0",
+        "jest-message-util": "30.2.0",
+        "jest-runtime": "30.2.0",
+        "jest-snapshot": "30.2.0",
+        "jest-util": "30.2.0",
+        "p-limit": "^3.1.0",
+        "pretty-format": "30.2.0",
+        "pure-rand": "^7.0.0",
+        "slash": "^3.0.0",
+        "stack-utils": "^2.0.6"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-circus/node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmmirror.com/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/jest-cli": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-cli/-/jest-cli-30.2.0.tgz",
+      "integrity": "sha512-Os9ukIvADX/A9sLt6Zse3+nmHtHaE6hqOsjQtNiugFTbKRHYIYtZXNGNK9NChseXy7djFPjndX1tL0sCTlfpAA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/core": "30.2.0",
+        "@jest/test-result": "30.2.0",
+        "@jest/types": "30.2.0",
+        "chalk": "^4.1.2",
+        "exit-x": "^0.2.2",
+        "import-local": "^3.2.0",
+        "jest-config": "30.2.0",
+        "jest-util": "30.2.0",
+        "jest-validate": "30.2.0",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "jest": "bin/jest.js"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
+      },
+      "peerDependenciesMeta": {
+        "node-notifier": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/jest-config": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-config/-/jest-config-30.2.0.tgz",
+      "integrity": "sha512-g4WkyzFQVWHtu6uqGmQR4CQxz/CH3yDSlhzXMWzNjDx843gYjReZnMRanjRCq5XZFuQrGDxgUaiYWE8BRfVckA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.27.4",
+        "@jest/get-type": "30.1.0",
+        "@jest/pattern": "30.0.1",
+        "@jest/test-sequencer": "30.2.0",
+        "@jest/types": "30.2.0",
+        "babel-jest": "30.2.0",
+        "chalk": "^4.1.2",
+        "ci-info": "^4.2.0",
+        "deepmerge": "^4.3.1",
+        "glob": "^10.3.10",
+        "graceful-fs": "^4.2.11",
+        "jest-circus": "30.2.0",
+        "jest-docblock": "30.2.0",
+        "jest-environment-node": "30.2.0",
+        "jest-regex-util": "30.0.1",
+        "jest-resolve": "30.2.0",
+        "jest-runner": "30.2.0",
+        "jest-util": "30.2.0",
+        "jest-validate": "30.2.0",
+        "micromatch": "^4.0.8",
+        "parse-json": "^5.2.0",
+        "pretty-format": "30.2.0",
+        "slash": "^3.0.0",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "@types/node": "*",
+        "esbuild-register": ">=3.4.0",
+        "ts-node": ">=9.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "esbuild-register": {
+          "optional": true
+        },
+        "ts-node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/jest-config/node_modules/ci-info": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmmirror.com/ci-info/-/ci-info-4.3.1.tgz",
+      "integrity": "sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/sibiraj-s"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/jest-config/node_modules/glob": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmmirror.com/glob/-/glob-10.5.0.tgz",
+      "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "foreground-child": "^3.1.0",
+        "jackspeak": "^3.1.2",
+        "minimatch": "^9.0.4",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^1.11.1"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/jest-config/node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmmirror.com/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/jest-config/node_modules/minipass": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmmirror.com/minipass/-/minipass-7.1.2.tgz",
+      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/jest-diff": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-diff/-/jest-diff-30.2.0.tgz",
+      "integrity": "sha512-dQHFo3Pt4/NLlG5z4PxZ/3yZTZ1C7s9hveiOj+GCN+uT109NC2QgsoVZsVOAvbJ3RgKkvyLGXZV9+piDpWbm6A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/diff-sequences": "30.0.1",
+        "@jest/get-type": "30.1.0",
+        "chalk": "^4.1.2",
+        "pretty-format": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-docblock": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-docblock/-/jest-docblock-30.2.0.tgz",
+      "integrity": "sha512-tR/FFgZKS1CXluOQzZvNH3+0z9jXr3ldGSD8bhyuxvlVUwbeLOGynkunvlTMxchC5urrKndYiwCFC0DLVjpOCA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "detect-newline": "^3.1.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-each": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-each/-/jest-each-30.2.0.tgz",
+      "integrity": "sha512-lpWlJlM7bCUf1mfmuqTA8+j2lNURW9eNafOy99knBM01i5CQeY5UH1vZjgT9071nDJac1M4XsbyI44oNOdhlDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/get-type": "30.1.0",
+        "@jest/types": "30.2.0",
+        "chalk": "^4.1.2",
+        "jest-util": "30.2.0",
+        "pretty-format": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-environment-node": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-environment-node/-/jest-environment-node-30.2.0.tgz",
+      "integrity": "sha512-ElU8v92QJ9UrYsKrxDIKCxu6PfNj4Hdcktcn0JX12zqNdqWHB0N+hwOnnBBXvjLd2vApZtuLUGs1QSY+MsXoNA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/environment": "30.2.0",
+        "@jest/fake-timers": "30.2.0",
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "jest-mock": "30.2.0",
+        "jest-util": "30.2.0",
+        "jest-validate": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-haste-map": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-haste-map/-/jest-haste-map-30.2.0.tgz",
+      "integrity": "sha512-sQA/jCb9kNt+neM0anSj6eZhLZUIhQgwDt7cPGjumgLM4rXsfb9kpnlacmvZz3Q5tb80nS+oG/if+NBKrHC+Xw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "anymatch": "^3.1.3",
+        "fb-watchman": "^2.0.2",
+        "graceful-fs": "^4.2.11",
+        "jest-regex-util": "30.0.1",
+        "jest-util": "30.2.0",
+        "jest-worker": "30.2.0",
+        "micromatch": "^4.0.8",
+        "walker": "^1.0.8"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "^2.3.3"
+      }
+    },
+    "node_modules/jest-leak-detector": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-leak-detector/-/jest-leak-detector-30.2.0.tgz",
+      "integrity": "sha512-M6jKAjyzjHG0SrQgwhgZGy9hFazcudwCNovY/9HPIicmNSBuockPSedAP9vlPK6ONFJ1zfyH/M2/YYJxOz5cdQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/get-type": "30.1.0",
+        "pretty-format": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-matcher-utils": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-matcher-utils/-/jest-matcher-utils-30.2.0.tgz",
+      "integrity": "sha512-dQ94Nq4dbzmUWkQ0ANAWS9tBRfqCrn0bV9AMYdOi/MHW726xn7eQmMeRTpX2ViC00bpNaWXq+7o4lIQ3AX13Hg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/get-type": "30.1.0",
+        "chalk": "^4.1.2",
+        "jest-diff": "30.2.0",
+        "pretty-format": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-message-util": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-message-util/-/jest-message-util-30.2.0.tgz",
+      "integrity": "sha512-y4DKFLZ2y6DxTWD4cDe07RglV88ZiNEdlRfGtqahfbIjfsw1nMCPx49Uev4IA/hWn3sDKyAnSPwoYSsAEdcimw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.27.1",
+        "@jest/types": "30.2.0",
+        "@types/stack-utils": "^2.0.3",
+        "chalk": "^4.1.2",
+        "graceful-fs": "^4.2.11",
+        "micromatch": "^4.0.8",
+        "pretty-format": "30.2.0",
+        "slash": "^3.0.0",
+        "stack-utils": "^2.0.6"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-mock": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-mock/-/jest-mock-30.2.0.tgz",
+      "integrity": "sha512-JNNNl2rj4b5ICpmAcq+WbLH83XswjPbjH4T7yvGzfAGCPh1rw+xVNbtk+FnRslvt9lkCcdn9i1oAoKUuFsOxRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "jest-util": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-pnp-resolver": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmmirror.com/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz",
+      "integrity": "sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      },
+      "peerDependencies": {
+        "jest-resolve": "*"
+      },
+      "peerDependenciesMeta": {
+        "jest-resolve": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/jest-regex-util": {
+      "version": "30.0.1",
+      "resolved": "https://registry.npmmirror.com/jest-regex-util/-/jest-regex-util-30.0.1.tgz",
+      "integrity": "sha512-jHEQgBXAgc+Gh4g0p3bCevgRCVRkB4VB70zhoAE48gxeSr1hfUOsM/C2WoJgVL7Eyg//hudYENbm3Ne+/dRVVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-resolve": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-resolve/-/jest-resolve-30.2.0.tgz",
+      "integrity": "sha512-TCrHSxPlx3tBY3hWNtRQKbtgLhsXa1WmbJEqBlTBrGafd5fiQFByy2GNCEoGR+Tns8d15GaL9cxEzKOO3GEb2A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chalk": "^4.1.2",
+        "graceful-fs": "^4.2.11",
+        "jest-haste-map": "30.2.0",
+        "jest-pnp-resolver": "^1.2.3",
+        "jest-util": "30.2.0",
+        "jest-validate": "30.2.0",
+        "slash": "^3.0.0",
+        "unrs-resolver": "^1.7.11"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-resolve-dependencies": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-resolve-dependencies/-/jest-resolve-dependencies-30.2.0.tgz",
+      "integrity": "sha512-xTOIGug/0RmIe3mmCqCT95yO0vj6JURrn1TKWlNbhiAefJRWINNPgwVkrVgt/YaerPzY3iItufd80v3lOrFJ2w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "jest-regex-util": "30.0.1",
+        "jest-snapshot": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-runner": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-runner/-/jest-runner-30.2.0.tgz",
+      "integrity": "sha512-PqvZ2B2XEyPEbclp+gV6KO/F1FIFSbIwewRgmROCMBo/aZ6J1w8Qypoj2pEOcg3G2HzLlaP6VUtvwCI8dM3oqQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/console": "30.2.0",
+        "@jest/environment": "30.2.0",
+        "@jest/test-result": "30.2.0",
+        "@jest/transform": "30.2.0",
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "chalk": "^4.1.2",
+        "emittery": "^0.13.1",
+        "exit-x": "^0.2.2",
+        "graceful-fs": "^4.2.11",
+        "jest-docblock": "30.2.0",
+        "jest-environment-node": "30.2.0",
+        "jest-haste-map": "30.2.0",
+        "jest-leak-detector": "30.2.0",
+        "jest-message-util": "30.2.0",
+        "jest-resolve": "30.2.0",
+        "jest-runtime": "30.2.0",
+        "jest-util": "30.2.0",
+        "jest-watcher": "30.2.0",
+        "jest-worker": "30.2.0",
+        "p-limit": "^3.1.0",
+        "source-map-support": "0.5.13"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-runner/node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmmirror.com/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/jest-runner/node_modules/source-map-support": {
+      "version": "0.5.13",
+      "resolved": "https://registry.npmmirror.com/source-map-support/-/source-map-support-0.5.13.tgz",
+      "integrity": "sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "node_modules/jest-runtime": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-runtime/-/jest-runtime-30.2.0.tgz",
+      "integrity": "sha512-p1+GVX/PJqTucvsmERPMgCPvQJpFt4hFbM+VN3n8TMo47decMUcJbt+rgzwrEme0MQUA/R+1de2axftTHkKckg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/environment": "30.2.0",
+        "@jest/fake-timers": "30.2.0",
+        "@jest/globals": "30.2.0",
+        "@jest/source-map": "30.0.1",
+        "@jest/test-result": "30.2.0",
+        "@jest/transform": "30.2.0",
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "chalk": "^4.1.2",
+        "cjs-module-lexer": "^2.1.0",
+        "collect-v8-coverage": "^1.0.2",
+        "glob": "^10.3.10",
+        "graceful-fs": "^4.2.11",
+        "jest-haste-map": "30.2.0",
+        "jest-message-util": "30.2.0",
+        "jest-mock": "30.2.0",
+        "jest-regex-util": "30.0.1",
+        "jest-resolve": "30.2.0",
+        "jest-snapshot": "30.2.0",
+        "jest-util": "30.2.0",
+        "slash": "^3.0.0",
+        "strip-bom": "^4.0.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-runtime/node_modules/glob": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmmirror.com/glob/-/glob-10.5.0.tgz",
+      "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "foreground-child": "^3.1.0",
+        "jackspeak": "^3.1.2",
+        "minimatch": "^9.0.4",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^1.11.1"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/jest-runtime/node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmmirror.com/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/jest-runtime/node_modules/minipass": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmmirror.com/minipass/-/minipass-7.1.2.tgz",
+      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/jest-snapshot": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-snapshot/-/jest-snapshot-30.2.0.tgz",
+      "integrity": "sha512-5WEtTy2jXPFypadKNpbNkZ72puZCa6UjSr/7djeecHWOu7iYhSXSnHScT8wBz3Rn8Ena5d5RYRcsyKIeqG1IyA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.27.4",
+        "@babel/generator": "^7.27.5",
+        "@babel/plugin-syntax-jsx": "^7.27.1",
+        "@babel/plugin-syntax-typescript": "^7.27.1",
+        "@babel/types": "^7.27.3",
+        "@jest/expect-utils": "30.2.0",
+        "@jest/get-type": "30.1.0",
+        "@jest/snapshot-utils": "30.2.0",
+        "@jest/transform": "30.2.0",
+        "@jest/types": "30.2.0",
+        "babel-preset-current-node-syntax": "^1.2.0",
+        "chalk": "^4.1.2",
+        "expect": "30.2.0",
+        "graceful-fs": "^4.2.11",
+        "jest-diff": "30.2.0",
+        "jest-matcher-utils": "30.2.0",
+        "jest-message-util": "30.2.0",
+        "jest-util": "30.2.0",
+        "pretty-format": "30.2.0",
+        "semver": "^7.7.2",
+        "synckit": "^0.11.8"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-snapshot/node_modules/semver": {
+      "version": "7.7.3",
+      "resolved": "https://registry.npmmirror.com/semver/-/semver-7.7.3.tgz",
+      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/jest-util": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-util/-/jest-util-30.2.0.tgz",
+      "integrity": "sha512-QKNsM0o3Xe6ISQU869e+DhG+4CK/48aHYdJZGlFQVTjnbvgpcKyxpzk29fGiO7i/J8VENZ+d2iGnSsvmuHywlA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "chalk": "^4.1.2",
+        "ci-info": "^4.2.0",
+        "graceful-fs": "^4.2.11",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-util/node_modules/ci-info": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmmirror.com/ci-info/-/ci-info-4.3.1.tgz",
+      "integrity": "sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/sibiraj-s"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/jest-util/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmmirror.com/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/jest-validate": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-validate/-/jest-validate-30.2.0.tgz",
+      "integrity": "sha512-FBGWi7dP2hpdi8nBoWxSsLvBFewKAg0+uSQwBaof4Y4DPgBabXgpSYC5/lR7VmnIlSpASmCi/ntRWPbv7089Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/get-type": "30.1.0",
+        "@jest/types": "30.2.0",
+        "camelcase": "^6.3.0",
+        "chalk": "^4.1.2",
+        "leven": "^3.1.0",
+        "pretty-format": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-validate/node_modules/camelcase": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmmirror.com/camelcase/-/camelcase-6.3.0.tgz",
+      "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/jest-watcher": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-watcher/-/jest-watcher-30.2.0.tgz",
+      "integrity": "sha512-PYxa28dxJ9g777pGm/7PrbnMeA0Jr7osHP9bS7eJy9DuAjMgdGtxgf0uKMyoIsTWAkIbUW5hSDdJ3urmgXBqxg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/test-result": "30.2.0",
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "ansi-escapes": "^4.3.2",
+        "chalk": "^4.1.2",
+        "emittery": "^0.13.1",
+        "jest-util": "30.2.0",
+        "string-length": "^4.0.2"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-worker": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/jest-worker/-/jest-worker-30.2.0.tgz",
+      "integrity": "sha512-0Q4Uk8WF7BUwqXHuAjc23vmopWJw5WH7w2tqBoUOZpOjW/ZnR44GXXd1r82RvnmI2GZge3ivrYXk/BE2+VtW2g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "@ungap/structured-clone": "^1.3.0",
+        "jest-util": "30.2.0",
+        "merge-stream": "^2.0.0",
+        "supports-color": "^8.1.1"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
     "node_modules/joi": {
       "version": "17.13.3",
       "resolved": "https://registry.npmjs.org/joi/-/joi-17.13.3.tgz",
@@ -4780,6 +7751,13 @@
         "@sideway/pinpoint": "^2.0.0"
       }
     },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmmirror.com/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/js-yaml": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
@@ -4793,6 +7771,19 @@
         "js-yaml": "bin/js-yaml.js"
       }
     },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmmirror.com/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/json-buffer": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
@@ -4800,6 +7791,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/json-parse-even-better-errors": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmmirror.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/json-schema-traverse": {
       "version": "0.4.1",
       "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
@@ -4907,6 +7905,23 @@
         "safe-buffer": "~5.1.0"
       }
     },
+    "node_modules/leven": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmmirror.com/leven/-/leven-3.1.0.tgz",
+      "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/lines-and-columns": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmmirror.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/locate-path": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz",
@@ -4973,6 +7988,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/lodash.memoize": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmmirror.com/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
+      "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/lodash.union": {
       "version": "4.6.0",
       "resolved": "https://registry.npmjs.org/lodash.union/-/lodash.union-4.6.0.tgz",
@@ -5012,6 +8034,52 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/make-dir": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmmirror.com/make-dir/-/make-dir-4.0.0.tgz",
+      "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/make-dir/node_modules/semver": {
+      "version": "7.7.3",
+      "resolved": "https://registry.npmmirror.com/semver/-/semver-7.7.3.tgz",
+      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/make-error": {
+      "version": "1.3.6",
+      "resolved": "https://registry.npmmirror.com/make-error/-/make-error-1.3.6.tgz",
+      "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/makeerror": {
+      "version": "1.0.12",
+      "resolved": "https://registry.npmmirror.com/makeerror/-/makeerror-1.0.12.tgz",
+      "integrity": "sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tmpl": "1.0.5"
+      }
+    },
     "node_modules/matcher": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/matcher/-/matcher-3.0.0.tgz",
@@ -5041,13 +8109,19 @@
       "integrity": "sha512-rkpe71W0N0c0Xz6QD0eJETuWAJGnJ9afsl1srmwPrI+yBCkge5EycXXbYRyvL29zZVUWQCY7InPRCv3GDXuZNw==",
       "license": "MIT"
     },
+    "node_modules/merge-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/merge-stream/-/merge-stream-2.0.0.tgz",
+      "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/micromatch": {
       "version": "4.0.8",
       "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
       "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
       "dependencies": {
         "braces": "^3.0.3",
         "picomatch": "^2.3.1"
@@ -5214,6 +8288,36 @@
         "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
       }
     },
+    "node_modules/napi-postinstall": {
+      "version": "0.3.4",
+      "resolved": "https://registry.npmmirror.com/napi-postinstall/-/napi-postinstall-0.3.4.tgz",
+      "integrity": "sha512-PHI5f1O0EP5xJ9gQmFGMS6IZcrVvTjpXjz7Na41gTE7eE2hK11lg04CECCYEEjdc17EV4DO+fkGEtt7TpTaTiQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "napi-postinstall": "lib/cli.js"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.18.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/napi-postinstall"
+      }
+    },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmmirror.com/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/neo-async": {
+      "version": "2.6.2",
+      "resolved": "https://registry.npmmirror.com/neo-async/-/neo-async-2.6.2.tgz",
+      "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/node-addon-api": {
       "version": "1.7.2",
       "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-1.7.2.tgz",
@@ -5228,6 +8332,13 @@
       "integrity": "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==",
       "license": "MIT"
     },
+    "node_modules/node-releases": {
+      "version": "2.0.27",
+      "resolved": "https://registry.npmmirror.com/node-releases/-/node-releases-2.0.27.tgz",
+      "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/node-windows": {
       "version": "1.0.0-beta.8",
       "resolved": "https://registry.npmjs.org/node-windows/-/node-windows-1.0.0-beta.8.tgz",
@@ -5267,6 +8378,19 @@
       "integrity": "sha512-Wj7+EJQ8mSuXr2iWfnujrimU35R2W4FAErEyTmJoJ7ucwTn2hOUSsRehMb5RSYkxXGTM7Y9QpvPmp++w5ftoJw==",
       "license": "BSD-3-Clause"
     },
+    "node_modules/npm-run-path": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmmirror.com/npm-run-path/-/npm-run-path-4.0.1.tgz",
+      "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/object-keys": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
@@ -5365,6 +8489,25 @@
       "dev": true,
       "license": "BlueOak-1.0.0"
     },
+    "node_modules/parse-json": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmmirror.com/parse-json/-/parse-json-5.2.0.tgz",
+      "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.0.0",
+        "error-ex": "^1.3.1",
+        "json-parse-even-better-errors": "^2.3.0",
+        "lines-and-columns": "^1.1.6"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/path-browserify": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz",
@@ -5444,7 +8587,6 @@
       "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
       "engines": {
         "node": ">=8.6"
       },
@@ -5474,6 +8616,79 @@
         }
       }
     },
+    "node_modules/pirates": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmmirror.com/pirates/-/pirates-4.0.7.tgz",
+      "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/pkg-dir": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmmirror.com/pkg-dir/-/pkg-dir-4.2.0.tgz",
+      "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "find-up": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/pkg-dir/node_modules/find-up": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmmirror.com/find-up/-/find-up-4.1.0.tgz",
+      "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^5.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/pkg-dir/node_modules/locate-path": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmmirror.com/locate-path/-/locate-path-5.0.0.tgz",
+      "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/pkg-dir/node_modules/p-locate": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmmirror.com/p-locate/-/p-locate-4.1.0.tgz",
+      "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/pkg-dir/node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmmirror.com/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/pkg-up": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/pkg-up/-/pkg-up-3.1.0.tgz",
@@ -5529,6 +8744,34 @@
         "node": "^10 || ^12 || >=14"
       }
     },
+    "node_modules/pretty-format": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmmirror.com/pretty-format/-/pretty-format-30.2.0.tgz",
+      "integrity": "sha512-9uBdv/B4EefsuAL+pWqueZyZS2Ba+LxfFeQ9DN14HU4bN8bhaxKdkpjpB6fs9+pSjIBu+FXQHImEg8j/Lw0+vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/schemas": "30.0.5",
+        "ansi-styles": "^5.2.0",
+        "react-is": "^18.3.1"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/pretty-format/node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
     "node_modules/process-nextick-args": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
@@ -5586,6 +8829,23 @@
         "node": ">=6"
       }
     },
+    "node_modules/pure-rand": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmmirror.com/pure-rand/-/pure-rand-7.0.1.tgz",
+      "integrity": "sha512-oTUZM/NAZS8p7ANR3SHh30kXB+zK2r2BPcEn/awJIbOvq82WoMN4p62AWWp3Hhw50G0xMsw1mhIBLqHw64EcNQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/dubzzz"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fast-check"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/quick-lru": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz",
@@ -5612,6 +8872,13 @@
         "node": ">= 22.12.0"
       }
     },
+    "node_modules/react-is": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmmirror.com/react-is/-/react-is-18.3.1.tgz",
+      "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/read-config-file": {
       "version": "6.3.2",
       "resolved": "https://registry.npmjs.org/read-config-file/-/read-config-file-6.3.2.tgz",
@@ -5694,6 +8961,29 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/resolve-cwd": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/resolve-cwd/-/resolve-cwd-3.0.0.tgz",
+      "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "resolve-from": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/resolve-from": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmmirror.com/resolve-from/-/resolve-from-5.0.0.tgz",
+      "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/responselike": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/responselike/-/responselike-2.0.1.tgz",
@@ -5979,6 +9269,16 @@
         "node": ">=10"
       }
     },
+    "node_modules/slash": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/slash/-/slash-3.0.0.tgz",
+      "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/slice-ansi": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-3.0.0.tgz",
@@ -6051,6 +9351,29 @@
       "license": "BSD-3-Clause",
       "optional": true
     },
+    "node_modules/stack-utils": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmmirror.com/stack-utils/-/stack-utils-2.0.6.tgz",
+      "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "escape-string-regexp": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/stack-utils/node_modules/escape-string-regexp": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz",
+      "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/stat-mode": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/stat-mode/-/stat-mode-1.0.0.tgz",
@@ -6071,6 +9394,20 @@
         "safe-buffer": "~5.2.0"
       }
     },
+    "node_modules/string-length": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmmirror.com/string-length/-/string-length-4.0.2.tgz",
+      "integrity": "sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "char-regex": "^1.0.2",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/string-width": {
       "version": "4.2.3",
       "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
@@ -6127,6 +9464,39 @@
         "node": ">=8"
       }
     },
+    "node_modules/strip-bom": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmmirror.com/strip-bom/-/strip-bom-4.0.0.tgz",
+      "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-final-newline": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz",
+      "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmmirror.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/sudo-prompt": {
       "version": "9.2.1",
       "resolved": "https://registry.npmjs.org/sudo-prompt/-/sudo-prompt-9.2.1.tgz",
@@ -6163,6 +9533,22 @@
         "url": "https://github.com/chalk/supports-color?sponsor=1"
       }
     },
+    "node_modules/synckit": {
+      "version": "0.11.11",
+      "resolved": "https://registry.npmmirror.com/synckit/-/synckit-0.11.11.tgz",
+      "integrity": "sha512-MeQTA1r0litLUf0Rp/iisCaL8761lKAZHaimlbGK4j0HysC4PLfqygQj9srcs0m2RdtDYnF8UuYyKpbjHYp7Jw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@pkgr/core": "^0.2.9"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/synckit"
+      }
+    },
     "node_modules/tar": {
       "version": "6.2.1",
       "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz",
@@ -6247,6 +9633,45 @@
         "node": ">= 10.0.0"
       }
     },
+    "node_modules/test-exclude": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmmirror.com/test-exclude/-/test-exclude-6.0.0.tgz",
+      "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "@istanbuljs/schema": "^0.1.2",
+        "glob": "^7.1.4",
+        "minimatch": "^3.0.4"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/test-exclude/node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmmirror.com/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/test-exclude/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmmirror.com/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/tmp": {
       "version": "0.2.5",
       "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.5.tgz",
@@ -6267,13 +9692,19 @@
         "tmp": "^0.2.0"
       }
     },
+    "node_modules/tmpl": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmmirror.com/tmpl/-/tmpl-1.0.5.tgz",
+      "integrity": "sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
       "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
       "dependencies": {
         "is-number": "^7.0.0"
       },
@@ -6301,6 +9732,85 @@
         "utf8-byte-length": "^1.0.1"
       }
     },
+    "node_modules/ts-jest": {
+      "version": "29.4.6",
+      "resolved": "https://registry.npmmirror.com/ts-jest/-/ts-jest-29.4.6.tgz",
+      "integrity": "sha512-fSpWtOO/1AjSNQguk43hb/JCo16oJDnMJf3CdEGNkqsEX3t0KX96xvyX1D7PfLCpVoKu4MfVrqUkFyblYoY4lA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "bs-logger": "^0.2.6",
+        "fast-json-stable-stringify": "^2.1.0",
+        "handlebars": "^4.7.8",
+        "json5": "^2.2.3",
+        "lodash.memoize": "^4.1.2",
+        "make-error": "^1.3.6",
+        "semver": "^7.7.3",
+        "type-fest": "^4.41.0",
+        "yargs-parser": "^21.1.1"
+      },
+      "bin": {
+        "ts-jest": "cli.js"
+      },
+      "engines": {
+        "node": "^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0"
+      },
+      "peerDependencies": {
+        "@babel/core": ">=7.0.0-beta.0 <8",
+        "@jest/transform": "^29.0.0 || ^30.0.0",
+        "@jest/types": "^29.0.0 || ^30.0.0",
+        "babel-jest": "^29.0.0 || ^30.0.0",
+        "jest": "^29.0.0 || ^30.0.0",
+        "jest-util": "^29.0.0 || ^30.0.0",
+        "typescript": ">=4.3 <6"
+      },
+      "peerDependenciesMeta": {
+        "@babel/core": {
+          "optional": true
+        },
+        "@jest/transform": {
+          "optional": true
+        },
+        "@jest/types": {
+          "optional": true
+        },
+        "babel-jest": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "jest-util": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/ts-jest/node_modules/semver": {
+      "version": "7.7.3",
+      "resolved": "https://registry.npmmirror.com/semver/-/semver-7.7.3.tgz",
+      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/ts-jest/node_modules/type-fest": {
+      "version": "4.41.0",
+      "resolved": "https://registry.npmmirror.com/type-fest/-/type-fest-4.41.0.tgz",
+      "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/tslib": {
       "version": "2.8.1",
       "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
@@ -6308,6 +9818,16 @@
       "dev": true,
       "license": "0BSD"
     },
+    "node_modules/type-detect": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmmirror.com/type-detect/-/type-detect-4.0.8.tgz",
+      "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/type-fest": {
       "version": "2.19.0",
       "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-2.19.0.tgz",
@@ -6335,6 +9855,20 @@
         "node": ">=14.17"
       }
     },
+    "node_modules/uglify-js": {
+      "version": "3.19.3",
+      "resolved": "https://registry.npmmirror.com/uglify-js/-/uglify-js-3.19.3.tgz",
+      "integrity": "sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "optional": true,
+      "bin": {
+        "uglifyjs": "bin/uglifyjs"
+      },
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
     "node_modules/undici-types": {
       "version": "6.21.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
@@ -6352,6 +9886,41 @@
         "node": ">= 4.0.0"
       }
     },
+    "node_modules/unrs-resolver": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmmirror.com/unrs-resolver/-/unrs-resolver-1.11.1.tgz",
+      "integrity": "sha512-bSjt9pjaEBnNiGgc9rUiHGKv5l4/TGzDmYw3RhnkJGtLhbnnA/5qJj7x3dNDCRx/PJxu774LlH8lCOlB4hEfKg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "napi-postinstall": "^0.3.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/unrs-resolver"
+      },
+      "optionalDependencies": {
+        "@unrs/resolver-binding-android-arm-eabi": "1.11.1",
+        "@unrs/resolver-binding-android-arm64": "1.11.1",
+        "@unrs/resolver-binding-darwin-arm64": "1.11.1",
+        "@unrs/resolver-binding-darwin-x64": "1.11.1",
+        "@unrs/resolver-binding-freebsd-x64": "1.11.1",
+        "@unrs/resolver-binding-linux-arm-gnueabihf": "1.11.1",
+        "@unrs/resolver-binding-linux-arm-musleabihf": "1.11.1",
+        "@unrs/resolver-binding-linux-arm64-gnu": "1.11.1",
+        "@unrs/resolver-binding-linux-arm64-musl": "1.11.1",
+        "@unrs/resolver-binding-linux-ppc64-gnu": "1.11.1",
+        "@unrs/resolver-binding-linux-riscv64-gnu": "1.11.1",
+        "@unrs/resolver-binding-linux-riscv64-musl": "1.11.1",
+        "@unrs/resolver-binding-linux-s390x-gnu": "1.11.1",
+        "@unrs/resolver-binding-linux-x64-gnu": "1.11.1",
+        "@unrs/resolver-binding-linux-x64-musl": "1.11.1",
+        "@unrs/resolver-binding-wasm32-wasi": "1.11.1",
+        "@unrs/resolver-binding-win32-arm64-msvc": "1.11.1",
+        "@unrs/resolver-binding-win32-ia32-msvc": "1.11.1",
+        "@unrs/resolver-binding-win32-x64-msvc": "1.11.1"
+      }
+    },
     "node_modules/unzipper": {
       "version": "0.12.3",
       "resolved": "https://registry.npmjs.org/unzipper/-/unzipper-0.12.3.tgz",
@@ -6400,6 +9969,37 @@
         "node": ">= 10.0.0"
       }
     },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmmirror.com/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
     "node_modules/uri-js": {
       "version": "4.4.1",
       "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
@@ -6423,6 +10023,21 @@
       "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
       "license": "MIT"
     },
+    "node_modules/v8-to-istanbul": {
+      "version": "9.3.0",
+      "resolved": "https://registry.npmmirror.com/v8-to-istanbul/-/v8-to-istanbul-9.3.0.tgz",
+      "integrity": "sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.12",
+        "@types/istanbul-lib-coverage": "^2.0.1",
+        "convert-source-map": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10.12.0"
+      }
+    },
     "node_modules/verror": {
       "version": "1.10.1",
       "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.1.tgz",
@@ -6634,6 +10249,16 @@
         "node": ">=12.0.0"
       }
     },
+    "node_modules/walker": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmmirror.com/walker/-/walker-1.0.8.tgz",
+      "integrity": "sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "makeerror": "1.0.12"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -6650,6 +10275,13 @@
         "node": ">= 8"
       }
     },
+    "node_modules/wordwrap": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/wordwrap/-/wordwrap-1.0.0.tgz",
+      "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/wrap-ansi": {
       "version": "7.0.0",
       "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
@@ -6693,6 +10325,20 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/write-file-atomic": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmmirror.com/write-file-atomic/-/write-file-atomic-5.0.1.tgz",
+      "integrity": "sha512-+QU2zd6OTD8XWIJCbffaiQeH9U73qIqafo1x6V1snCWYGJf6cVE0cDR4D8xRzcEnfI21IFrUPzPGtcPf8AC+Rw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "imurmurhash": "^0.1.4",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
     "node_modules/xml": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/xml/-/xml-1.0.1.tgz",
@@ -6763,6 +10409,19 @@
         "fd-slicer": "~1.1.0"
       }
     },
+    "node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmmirror.com/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/zip-stream": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/zip-stream/-/zip-stream-4.1.1.tgz",
diff --git a/package.json b/package.json
index ac4f846..b04ca9b 100644
--- a/package.json
+++ b/package.json
@@ -14,18 +14,24 @@
     "preview": "vite preview",
     "electron:dev": "vite",
     "electron:build": "node scripts/bump-version.js && vite build && electron-builder",
-    "typecheck": "vue-tsc --noEmit"
+    "typecheck": "vue-tsc --noEmit",
+    "test": "jest",
+    "test:watch": "jest --watch"
   },
   "author": "PHPer",
   "license": "MIT",
   "devDependencies": {
+    "@types/jest": "^30.0.0",
     "@types/node": "^20.10.0",
     "@vitejs/plugin-vue": "^4.5.0",
     "concurrently": "^8.2.2",
     "electron": "^28.0.0",
     "electron-builder": "^24.9.1",
+    "fast-check": "^4.5.3",
+    "jest": "^30.2.0",
     "rcedit": "^5.0.2",
     "sass": "^1.69.5",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.9.3",
     "vite": "^5.0.0",
     "vite-plugin-electron": "^0.15.5",
diff --git a/src/App.vue b/src/App.vue
index fdb8faf..8b12460 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -92,6 +92,7 @@ const cachedViews = [
   'RedisManager',
   'NodeManager',
   'PythonManager',
+  'GoManager',
   'GitManager',
   'SitesManager',
   'HostsManager',
@@ -113,6 +114,7 @@ const menuItems = [
   { path: '/redis', label: 'Redis 管理', icon: 'Grid', service: 'redis' },
   { path: '/nodejs', label: 'Node.js 管理', icon: 'Promotion', service: null },
   { path: '/python', label: 'Python 管理', icon: 'Platform', service: null },
+  { path: '/go', label: 'Go 管理', icon: 'Box', service: null },
   { path: '/git', label: 'Git 管理', icon: 'Share', service: null },
   { path: '/sites', label: '站点管理', icon: 'Monitor', service: null },
   { path: '/hosts', label: 'Hosts 管理', icon: 'Document', service: null },
diff --git a/src/router/index.ts b/src/router/index.ts
index 0b31765..f3e989e 100644
--- a/src/router/index.ts
+++ b/src/router/index.ts
@@ -63,6 +63,12 @@ const router = createRouter({
       component: () => import('@/views/PythonManager.vue'),
       meta: { title: 'Python 管理' }
     },
+    {
+      path: '/go',
+      name: 'go',
+      component: () => import('@/views/GoManager.vue'),
+      meta: { title: 'Go 管理' }
+    },
     {
       path: '/settings',
       name: 'settings',
diff --git a/src/stores/serviceStore.ts b/src/stores/serviceStore.ts
index 0404b0d..77d19f0 100644
--- a/src/stores/serviceStore.ts
+++ b/src/stores/serviceStore.ts
@@ -30,6 +30,15 @@ interface NodeVersion {
   isActive: boolean
 }
 
+// Go 版本信息
+interface GoVersion {
+  version: string
+  path: string
+  isActive: boolean
+  goroot: string
+  gopath?: string
+}
+
 // 站点信息
 interface SiteConfig {
   name: string
@@ -56,6 +65,9 @@ export const useServiceStore = defineStore('service', () => {
   // Node.js 版本列表
   const nodeVersions = ref<NodeVersion[]>([])
   
+  // Go 版本列表
+  const goVersions = ref<GoVersion[]>([])
+  
   // 站点列表
   const sites = ref<SiteConfig[]>([])
   
@@ -99,6 +111,11 @@ export const useServiceStore = defineStore('service', () => {
     return nodeVersions.value.find(v => v.isActive)
   })
 
+  // 计算属性：当前活动的 Go 版本
+  const activeGoVersion = computed(() => {
+    return goVersions.value.find(v => v.isActive)
+  })
+
   // 刷新所有状态
   async function refreshAll() {
     loading.value = true
@@ -107,6 +124,7 @@ export const useServiceStore = defineStore('service', () => {
         refreshServiceStatus(),
         refreshPhpVersions(),
         refreshNodeVersions(),
+        refreshGoVersions(),
         refreshSites(),
         refreshBasePath()
       ])
@@ -175,6 +193,18 @@ export const useServiceStore = defineStore('service', () => {
     }
   }
 
+  // 刷新 Go 版本列表
+  async function refreshGoVersions() {
+    try {
+      const versions = await window.electronAPI?.go.getVersions()
+      if (versions) {
+        goVersions.value = versions
+      }
+    } catch (error) {
+      console.error('刷新 Go 版本失败:', error)
+    }
+  }
+
   // 刷新站点列表
   async function refreshSites() {
     try {
@@ -217,6 +247,7 @@ export const useServiceStore = defineStore('service', () => {
     serviceStatus,
     phpVersions,
     nodeVersions,
+    goVersions,
     sites,
     basePath,
     loading,
@@ -227,11 +258,13 @@ export const useServiceStore = defineStore('service', () => {
     runningServiceCount,
     activePhpVersion,
     activeNodeVersion,
+    activeGoVersion,
     // 方法
     refreshAll,
     refreshServiceStatus,
     refreshPhpVersions,
     refreshNodeVersions,
+    refreshGoVersions,
     refreshSites,
     refreshBasePath,
     updateServiceStatus,
diff --git a/src/views/GoManager.vue b/src/views/GoManager.vue
new file mode 100644
index 0000000..f425fe4
--- /dev/null
+++ b/src/views/GoManager.vue
@@ -0,0 +1,519 @@
+<template>
+  <div class="page-container">
+    <div class="page-header">
+      <h1 class="page-title">
+        <span class="title-icon"><el-icon><Platform /></el-icon></span>
+        Go 管理
+      </h1>
+      <p class="page-description">管理本地 Go 版本，支持多版本切换</p>
+    </div>
+
+    <!-- 下载进度 -->
+    <div v-if="downloadProgress.percent > 0 && downloadProgress.percent < 100" class="download-progress">
+      <div class="progress-info">
+        <span>正在下载 Go...</span>
+        <span>{{ formatSize(downloadProgress.downloaded) }} / {{ formatSize(downloadProgress.total) }}</span>
+      </div>
+      <el-progress :percentage="downloadProgress.percent" :stroke-width="10" />
+    </div>
+
+    <!-- 已安装版本 -->
+    <div class="card">
+      <div class="card-header">
+        <span class="card-title">已安装版本</span>
+        <el-button type="primary" @click="showInstallDialog = true">
+          <el-icon><Plus /></el-icon>
+          安装新版本
+        </el-button>
+      </div>
+      <div class="card-content">
+        <div v-if="loading" class="loading-state">
+          <el-icon class="is-loading"><Loading /></el-icon>
+          <span>加载中...</span>
+        </div>
+        <div v-else-if="versions.length === 0" class="empty-state">
+          <el-icon class="empty-icon"><Platform /></el-icon>
+          <h3 class="empty-title">暂未安装 Go</h3>
+          <p class="empty-description">点击上方按钮安装第一个 Go 版本</p>
+        </div>
+        <div v-else class="version-grid">
+          <div 
+            v-for="version in versions" 
+            :key="version.version"
+            class="version-card"
+            :class="{ active: version.isActive }"
+          >
+            <div class="version-main">
+              <div class="version-icon">
+                <el-icon :size="32"><Platform /></el-icon>
+              </div>
+              <div class="version-content">
+                <div class="version-title">
+                  <span class="version-number">Go {{ version.version }}</span>
+                  <el-tag v-if="version.isActive" type="success" size="small" effect="dark">当前版本</el-tag>
+                </div>
+                <div class="version-meta">
+                  <div class="version-path">
+                    <el-icon><FolderOpened /></el-icon>
+                    <span>{{ version.path }}</span>
+                  </div>
+                  <div v-if="version.goroot" class="goroot-info">
+                    <el-icon><Files /></el-icon>
+                    <span>GOROOT: {{ version.goroot }}</span>
+                  </div>
+                  <div v-if="version.gopath" class="gopath-info">
+                    <el-icon><Box /></el-icon>
+                    <span>GOPATH: {{ version.gopath }}</span>
+                  </div>
+                </div>
+              </div>
+            </div>
+            <div class="version-actions">
+              <el-button 
+                v-if="!version.isActive"
+                type="primary" 
+                size="small" 
+                @click="setActiveVersion(version.version)"
+                :loading="settingActive === version.version"
+              >
+                设为默认
+              </el-button>
+              <el-button 
+                type="danger" 
+                size="small" 
+                plain
+                @click="uninstallVersion(version.version)"
+                :loading="uninstalling === version.version"
+              >
+                卸载
+              </el-button>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- 安装新版本对话框 -->
+    <el-dialog 
+      v-model="showInstallDialog" 
+      title="安装 Go"
+      width="700px"
+    >
+      <el-alert type="info" :closable="false" class="mb-4">
+        <template #title>
+          <el-icon><InfoFilled /></el-icon>
+          下载源说明
+        </template>
+        Go 将从官方网站 <a href="https://golang.org/dl/" target="_blank">golang.org</a> 下载 Windows 64位版本。
+      </el-alert>
+      <div v-if="loadingAvailableVersions" class="loading-state">
+        <el-icon class="is-loading"><Loading /></el-icon>
+        <span>正在获取可用版本列表...</span>
+      </div>
+      <div v-else-if="availableVersions.length === 0" class="empty-hint">
+        <span>暂无可用版本</span>
+      </div>
+      <div v-else class="available-versions">
+        <el-table :data="availableVersions" style="width: 100%" max-height="400">
+          <el-table-column prop="version" label="版本" width="120" />
+          <el-table-column label="类型" width="120">
+            <template #default="{ row }">
+              <el-tag v-if="row.stable" type="success" size="small">稳定版</el-tag>
+              <el-tag v-else type="warning" size="small">开发版</el-tag>
+            </template>
+          </el-table-column>
+          <el-table-column label="大小" width="100">
+            <template #default="{ row }">
+              {{ formatSize(row.size) }}
+            </template>
+          </el-table-column>
+          <el-table-column label="操作" width="100">
+            <template #default="{ row }">
+              <el-button
+                v-if="!isInstalled(row.version)"
+                type="primary"
+                size="small"
+                @click="installVersion(row)"
+                :loading="installing === row.version"
+              >
+                安装
+              </el-button>
+              <el-tag v-else type="info" size="small">已安装</el-tag>
+            </template>
+          </el-table-column>
+        </el-table>
+      </div>
+      <template #footer>
+        <el-button @click="showInstallDialog = false">关闭</el-button>
+      </template>
+    </el-dialog>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, reactive, onMounted, onUnmounted } from 'vue'
+import { ElMessage, ElMessageBox } from 'element-plus'
+import { Plus, Platform, InfoFilled, Loading, FolderOpened, Files, Box } from '@element-plus/icons-vue'
+
+// 定义组件名称以便 KeepAlive 正确缓存
+defineOptions({
+  name: 'GoManager'
+})
+
+interface GoVersion {
+  version: string
+  path: string
+  isActive: boolean
+  goroot: string
+  gopath?: string
+  installDate?: Date
+  size?: number
+}
+
+interface AvailableGoVersion {
+  version: string
+  stable: boolean
+  downloadUrl: string
+  size: number
+  sha256: string
+  releaseDate?: string
+}
+
+const loading = ref(false)
+const versions = ref<GoVersion[]>([])
+const availableVersions = ref<AvailableGoVersion[]>([])
+const showInstallDialog = ref(false)
+const installing = ref('')
+const uninstalling = ref('')
+const settingActive = ref('')
+
+const downloadProgress = reactive({
+  percent: 0,
+  downloaded: 0,
+  total: 0
+})
+
+const loadVersions = async () => {
+  loading.value = true
+  try {
+    versions.value = await window.electronAPI?.go.getVersions() || []
+  } catch (error: any) {
+    console.error('加载版本失败:', error)
+    ElMessage.error('加载已安装版本失败: ' + error.message)
+  } finally {
+    loading.value = false
+  }
+}
+
+const loadingAvailableVersions = ref(false)
+
+const loadAvailableVersions = async () => {
+  loadingAvailableVersions.value = true
+  try {
+    availableVersions.value = await window.electronAPI?.go.getAvailableVersions() || []
+  } catch (error: any) {
+    console.error('加载可用版本失败:', error)
+    ElMessage.error('加载可用版本失败: ' + error.message)
+  } finally {
+    loadingAvailableVersions.value = false
+  }
+}
+
+const isInstalled = (version: string) => {
+  return versions.value.some(v => v.version === version)
+}
+
+const installVersion = async (row: AvailableGoVersion) => {
+  installing.value = row.version
+  downloadProgress.percent = 0
+  downloadProgress.downloaded = 0
+  downloadProgress.total = 0
+  
+  try {
+    const result = await window.electronAPI?.go.install(row.version, row.downloadUrl, row.sha256)
+    if (result?.success) {
+      ElMessage.success(result.message)
+      await loadVersions()
+    } else {
+      ElMessage.error(result?.message || '安装失败')
+    }
+  } catch (error: any) {
+    ElMessage.error(error.message)
+  } finally {
+    installing.value = ''
+    downloadProgress.percent = 0
+  }
+}
+
+const uninstallVersion = async (version: string) => {
+  try {
+    await ElMessageBox.confirm(
+      `确定要卸载 Go ${version} 吗？`,
+      '确认卸载',
+      { type: 'warning' }
+    )
+    
+    uninstalling.value = version
+    const result = await window.electronAPI?.go.uninstall(version)
+    if (result?.success) {
+      ElMessage.success(result.message)
+      await loadVersions()
+    } else {
+      ElMessage.error(result?.message || '卸载失败')
+    }
+  } catch (error: any) {
+    if (error !== 'cancel') {
+      ElMessage.error(error.message)
+    }
+  } finally {
+    uninstalling.value = ''
+  }
+}
+
+const setActiveVersion = async (version: string) => {
+  settingActive.value = version
+  try {
+    const result = await window.electronAPI?.go.setActive(version)
+    if (result?.success) {
+      ElMessage.success(result.message)
+      await loadVersions()
+    } else {
+      ElMessage.error(result?.message || '设置失败')
+    }
+  } catch (error: any) {
+    ElMessage.error(error.message)
+  } finally {
+    settingActive.value = ''
+  }
+}
+
+const formatSize = (bytes: number) => {
+  if (bytes === 0) return '0 B'
+  const k = 1024
+  const sizes = ['B', 'KB', 'MB', 'GB']
+  const i = Math.floor(Math.log(bytes) / Math.log(k))
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
+}
+
+// 监听下载进度
+const onDownloadProgress = (_event: any, data: any) => {
+  if (data.type === 'go') {
+    downloadProgress.percent = data.progress
+    downloadProgress.downloaded = data.downloaded
+    downloadProgress.total = data.total
+  }
+}
+
+onMounted(() => {
+  loadVersions()
+  loadAvailableVersions()
+  window.electronAPI?.onDownloadProgress(onDownloadProgress)
+})
+
+onUnmounted(() => {
+  window.electronAPI?.removeDownloadProgressListener(onDownloadProgress)
+})
+</script>
+
+<style lang="scss" scoped>
+.loading-state {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 12px;
+  padding: 40px;
+  color: var(--text-secondary);
+  
+  .is-loading {
+    font-size: 24px;
+    animation: spin 1s linear infinite;
+  }
+}
+
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+.empty-state {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 60px 20px;
+  text-align: center;
+  
+  .empty-icon {
+    font-size: 64px;
+    color: var(--text-muted);
+    margin-bottom: 16px;
+  }
+  
+  .empty-title {
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--text-primary);
+    margin: 0 0 8px 0;
+  }
+  
+  .empty-description {
+    font-size: 14px;
+    color: var(--text-secondary);
+    margin: 0;
+  }
+}
+
+.version-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(400px, 1fr));
+  gap: 20px;
+}
+
+.version-card {
+  background: var(--bg-input);
+  border: 1px solid var(--border-color);
+  border-radius: 16px;
+  padding: 24px;
+  transition: all 0.3s;
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+  
+  &:hover {
+    border-color: var(--accent-color);
+    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.15);
+    transform: translateY(-2px);
+  }
+  
+  &.active {
+    border-color: var(--success-color);
+    background: linear-gradient(135deg, rgba(16, 185, 129, 0.08) 0%, rgba(16, 185, 129, 0.02) 100%);
+    
+    .version-icon {
+      background: linear-gradient(135deg, #10b981 0%, #059669 100%);
+    }
+  }
+  
+  .version-main {
+    display: flex;
+    align-items: flex-start;
+    gap: 16px;
+  }
+  
+  .version-icon {
+    width: 56px;
+    height: 56px;
+    border-radius: 14px;
+    background: linear-gradient(135deg, #00add8 0%, #007d9c 100%);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: white;
+    flex-shrink: 0;
+  }
+  
+  .version-content {
+    flex: 1;
+    min-width: 0;
+  }
+  
+  .version-title {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    margin-bottom: 12px;
+    flex-wrap: wrap;
+  }
+  
+  .version-number {
+    font-size: 20px;
+    font-weight: 700;
+    color: var(--text-primary);
+    letter-spacing: -0.5px;
+  }
+  
+  .version-meta {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+  }
+  
+  .version-path,
+  .goroot-info,
+  .gopath-info {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 13px;
+    color: var(--text-secondary);
+    background: var(--bg-card);
+    padding: 6px 12px;
+    border-radius: 6px;
+    font-family: 'Fira Code', monospace;
+    
+    .el-icon {
+      color: var(--accent-color);
+      flex-shrink: 0;
+    }
+    
+    span {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+  }
+  
+  .version-actions {
+    display: flex;
+    gap: 10px;
+    padding-top: 4px;
+    border-top: 1px solid var(--border-color);
+    
+    .el-button {
+      flex: 1;
+    }
+  }
+}
+
+.available-versions {
+  .el-table {
+    --el-table-bg-color: transparent;
+    --el-table-tr-bg-color: transparent;
+    --el-table-header-bg-color: var(--bg-input);
+  }
+}
+
+.download-progress {
+  background: var(--bg-card);
+  border: 1px solid var(--border-color);
+  border-radius: 12px;
+  padding: 16px;
+  margin-bottom: 20px;
+  
+  .progress-info {
+    display: flex;
+    justify-content: space-between;
+    margin-bottom: 8px;
+    font-size: 14px;
+    color: var(--text-secondary);
+  }
+}
+
+.empty-hint {
+  text-align: center;
+  padding: 40px 20px;
+  color: var(--text-muted);
+}
+
+.mb-4 {
+  margin-bottom: 16px;
+  
+  a {
+    color: var(--accent-color);
+    text-decoration: none;
+    
+    &:hover {
+      text-decoration: underline;
+    }
+  }
+}
+</style>
\ No newline at end of file