@chatbi-v/core 2.1.10 → 3.1.1

package/dist/index.d.cts

@@ -1,644 +1,678 @@
-import React, { Component, ReactNode, ErrorInfo } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import { S as StoragePort, a as StorageItemSchema, P as Plugin, b as PluginContext, c as PluginManifest, d as PluginCapabilities, e as SlotPosition, f as PluginExtension, R as RouteConfig, A as ApiAdapter, g as ApiRequestConfig, h as StreamCallbacks, i as ApiEndpointConfig, j as ApiInterceptor, k as ApiConfig, l as RequestOptions, D as Dependency } from './plugin-port-CHRPxDOi.cjs';
+export { F as ApiPort, y as ApiResponseContext, M as BasePlugin, Q as Command, U as CommandHandler, V as CommandType, W as Compatibility, a4 as EXTENSION_TYPES, X as Entry, E as ErrorStrategy, z as EventBusPort, Y as Extension, Z as ExtensionType, _ as HookType, H as HttpMethod, $ as OnActivateHandler, a0 as OnDeactivateHandler, a1 as OnErrorHandler, B as PLUGIN_TYPES, m as Permission, n as PermissionAction, o as PermissionScope, p as PermissionType, J as PluginConfigItem, u as PluginId, v as PluginIdSchema, L as PluginLifecycle, a3 as PluginManifestSchema, O as PluginMetadata, K as PluginStorage, C as PluginType, a5 as RENDER_MODES, a2 as RenderMode, G as Slot, w as SlotKey, x as SlotKeySchema, I as SlotType, T as TypedStorage, q as createPluginId, r as createSlotKey, N as definePlugin, s as isPluginId, t as isSlotKey } from './plugin-port-CHRPxDOi.cjs';
+import { z } from 'zod';
+import * as zustand_vanilla from 'zustand/vanilla';
+import * as zustand_middleware from 'zustand/middleware';
+export { ValidationResult, assertManifest, extractManifestFromPlugin, normalizePluginManifest, validateManifest } from './manifest/index.cjs';
+export { AdapterFactory, AdapterRegistry, AdapterState, AdapterStatus, BaseAdapter, TransformOptions, UIAdapter, adapterRegistry } from './adapters/index.cjs';
 import dayjs from 'dayjs';
 
 /**
- * HTTP 请求方法
+ * @file template-literals.ts
+ * @description 模板字面量类型 - 用于精确类型检查
  */
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+
 /**
- * 错误处理策略
+ * SemVer 版本号类型
+ * @description 匹配符合 SemVer 规范 (^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?$) 的版本号
+ * 支持如 1.0.0, 1.2.3-beta.1, 2.0.0-alpha+001 等格式
  */
-type ErrorStrategy = 'reject' | 'resolve' | 'silent';
+type SemVer = string & {
+    __semver: 'SemVer';
+};
 /**
- * API 接口端点配置
+ * RoutePath 路由路径类型
+ * @description 以 / 开头的路由路径
  */
-interface ApiEndpointConfig {
-    /** 接口路径 (支持 :param 语法) */
-    url: string;
-    /** 请求方法 */
-    method: HttpMethod;
-    /** 接口描述 */
-    desc?: string;
-    /** Mock 响应数据结构定义 */
-    responseSchema?: any;
-    /** 错误处理策略 */
-    errorStrategy?: ErrorStrategy;
-}
+type RoutePath = string & {
+    __routePath: 'RoutePath';
+};
+
 /**
- * API 请求配置
+ * SemVer 的 Zod 验证 Schema
  */
-interface ApiRequestConfig {
-    /** 请求 URL */
-    url: string;
-    /** 请求方法 */
-    method: HttpMethod;
-    /** 请求体数据 (POST/PUT 等) */
-    data?: any;
-    /** 查询参数 (GET 等) */
-    params?: any;
-    /** 请求头 */
-    headers?: any;
-    /** 用于取消请求的信号对象 */
-    signal?: AbortSignal;
-}
+declare const SemVerSchema: z.ZodString;
 /**
- * 流式响应回调函数接口
+ * RoutePath 的 Zod 验证 Schema
  */
-interface StreamCallbacks {
-    /** 收到消息片段时的回调 */
-    onMessage?: (data: any) => void;
-    /** 发生错误时的回调 */
-    onError?: (error: any) => void;
-    /** 请求完成时的回调 */
-    onFinish?: () => void;
-    /** 收到 HTTP 响应头部信息的回调，返回 true 表示劫持并中止流 */
-    onResponse?: (response: any) => Promise<boolean> | boolean;
-}
+declare const RoutePathSchema: z.ZodString;
 /**
- * API 适配器端口接口
- * @description 所有底层请求引擎（如 Fetch, Axios, Mock）都必须实现此接口，以确保内核对具体通信库的解耦。
+ * 创建类型安全的 SemVer 版本号
+ * @param version - 版本号字符串
+ * @returns 带类型标记的 SemVer 类型
  */
-interface ApiAdapter {
-    /**
-     * 发起普通 HTTP 请求
-     * @param config - 请求配置
-     * @param endpointConfig - 接口端点定义的元数据配置
-     * @returns 响应数据的 Promise
-     */
-    request<T = any>(config: ApiRequestConfig, endpointConfig?: ApiEndpointConfig): Promise<T>;
-    /**
-     * 发起流式请求 (SSE 或 Chunked Transfer)
-     * @param config - 请求配置
-     * @param callbacks - 流式处理的回调函数集合
-     * @param endpointConfig - 接口端点定义的元数据配置
-     */
-    stream?(config: ApiRequestConfig, callbacks: StreamCallbacks, endpointConfig?: ApiEndpointConfig): Promise<void>;
-}
+declare function createSemVer(version: string): SemVer;
 /**
- * API 配置集合 (按模块和动作分组)
+ * 创建类型安全的 RoutePath 路由路径
+ * @param path - 路由路径字符串
+ * @returns 带类型标记的 RoutePath 类型
  */
-interface ApiConfig {
-    /** 模块名称 */
-    [module: string]: {
-        /** 动作/接口名称 */
-        [action: string]: ApiEndpointConfig;
-    };
-}
+declare function createRoutePath(path: string): RoutePath;
 /**
- * 业务侧发起请求时的选项
+ * 类型守卫：检查是否为有效的 SemVer
+ * @param value - 要检查的值
+ * @returns 是否为 SemVer 类型
  */
-interface RequestOptions extends Partial<ApiRequestConfig> {
-    /** 是否跳过全局错误处理逻辑 */
-    skipErrorHandler?: boolean;
-    /** 路径参数集合 (将替换 url 中的 :param 占位符) */
-    params?: any;
-    /** 流式响应：收到数据片段的回调 */
-    onMessage?: (data: any) => void;
-    /** 流式响应：发生错误的回调 */
-    onError?: (error: any) => void;
-    /** 流式响应：正常结束的回调 */
-    onFinish?: () => void;
-    /** 允许透传其他底层适配器所需的属性 (例如 axios 的特定配置) */
-    [key: string]: any;
-}
+declare function isSemVer(value: unknown): value is SemVer;
+/**
+ * 类型守卫：检查是否为有效的 RoutePath
+ * @param value - 要检查的值
+ * @returns 是否为 RoutePath 类型
+ */
+declare function isRoutePath(value: unknown): value is RoutePath;
+
+/**
+ * 深度只读类型
+ * @description 递归将所有属性（包括嵌套对象和数组）设为只读
+ * @example
+ * type ReadonlyPluginConfig = DeepReadonly<PluginConfig>;
+ * // 所有嵌套属性都变为 readonly
+ */
+type DeepReadonly<T> = {
+    readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
+};
 /**
- * API 响应拦截上下文对象
+ * 配置项定义
  */
-interface ApiResponseContext {
-    /** 原始响应对象 (例如 AxiosResponse 或 Fetch Response) */
-    response: any;
-    /** HTTP 响应状态码 */
-    status: number;
-    /** 响应头集合 */
-    headers: Record<string, string>;
-    /** 解析后的业务数据体 */
-    data: any;
-    /** 对应的原始请求配置 */
-    config: ApiRequestConfig;
+interface ConfigItemDefinition {
+    key: string;
+    type: 'string' | 'number' | 'boolean' | 'select';
+    label: string;
+    description?: string;
+    default?: unknown;
+    options?: Array<{
+        label: string;
+        value: unknown;
+    }>;
 }
 /**
- * API 拦截器定义
+ * 安全的插件配置类型
+ * @description 根据插件的 configuration 定义生成运行时配置类型
+ * @example
+ * interface MyPluginConfig {
+ *   apiKey: string;
+ *   maxResults: number;
+ * }
+ * type SafeConfig = SafePluginConfig<{ apiKey: string; maxResults: number }>;
+ */
+type SafePluginConfig<T extends ConfigItemDefinition[]> = {
+    [K in T[number] as K['key']]: K['default'];
+};
+/**
+ * Plugin Manifest 类型
+ * @description 从 Zod Schema 推断出的插件清单类型
+ */
+type PluginManifestType = {
+    id: string;
+    version: string;
+    name: string;
+    entry: string | {
+        url: string;
+        shareScope?: string;
+    };
+    type?: 'business' | 'functional' | 'view' | 'theme' | 'renderer' | 'system';
+    description?: string;
+    author?: string;
+    icon?: string;
+    compatibility?: {
+        minVersion?: string;
+        maxVersion?: string;
+        supportedVersions?: string[];
+    };
+    dependencies?: Array<{
+        id: string;
+        version: string;
+        optional?: boolean;
+    }>;
+    extensions?: Array<{
+        name: string;
+        type: 'slot' | 'hook' | 'command' | 'service';
+        description?: string;
+        slot?: string;
+        config?: Record<string, unknown>;
+        renderMode?: 'replace' | 'append' | 'prepend';
+        condition?: Record<string, unknown>;
+    }>;
+    capabilities?: Record<string, boolean>;
+    configuration?: ConfigItemDefinition[];
+    storage?: unknown[];
+    routes?: Array<{
+        path: string;
+    }>;
+    permissions?: Array<{
+        action: 'read' | 'write' | 'execute' | 'admin';
+        scope: 'plugin' | 'global' | 'user';
+        resource: string;
+    }>;
+    priority?: number;
+};
+/**
+ * 类型守卫: 检查值是否为有效的 PluginManifest
+ * @param value - 要检查的值
+ * @returns 如果值符合 PluginManifestSchema 则返回 true
+ * @example
+ * if (isPluginManifest(data)) {
+ *   console.log(data.name); // TypeScript 知道这是有效的 PluginManifest
+ * }
+ */
+declare function isPluginManifest(value: unknown): value is PluginManifestType;
+
+/**
+ * 服务注册中心 (Service Registry)
+ * @description 核心应用层服务，作为微内核架构中的“中枢调度员”。
+ * 主要职责：
+ * 1. 服务解耦：允许插件将其内部功能暴露为“服务”，而无需与其他插件产生物理依赖。
+ * 2. 动态发现：提供按名称查找服务的能力，支持服务热插拔。
+ * 3. 依赖协调：通过 `waitFor` 机制解决插件间由于加载顺序导致的初始化依赖问题。
+ *
+ * 建议的服务命名规范: `pluginId.serviceName` (例如: `auth.sessionService`)
  */
-interface ApiInterceptor {
+declare class ServiceRegistry {
+    /** 存储已注册服务的 Map 对象 */
+    private services;
+    /** 存储正在等待特定服务的监听器集合 */
+    private listeners;
     /**
-     * 请求发送前的拦截逻辑
-     * @param config - 原始请求配置
-     * @returns 修改后的请求配置，或其 Promise
+     * 注册一个服务实现
+     * @param name - 唯一的服务名称
+     * @param service - 服务实例或对象
      */
-    interceptRequest?: (config: ApiRequestConfig) => ApiRequestConfig | Promise<ApiRequestConfig>;
+    register(name: string, service: any): void;
     /**
-     * 响应接收后的拦截逻辑
-     * @param context - 响应上下文信息
-     * @returns 如果返回 true，表示该拦截器已接管并处理了响应，后续拦截器及业务回调将不再触发
+     * 同步获取服务实例
+     * @template T - 服务类型的泛型
+     * @param name - 服务名称
+     * @returns 服务实例，若不存在则返回 undefined
      */
-    interceptResponse?: (context: ApiResponseContext) => boolean | Promise<boolean>;
-}
-
-/**
- * 事件总线端口接口
- * @description 定义应用内部事件通信的标准契约，支持发布订阅模式。
- */
-interface EventBusPort {
+    get<T = any>(name: string): T | undefined;
     /**
-     * 订阅事件
-     * @param event - 事件名称
-     * @param callback - 事件触发时的回调函数
-     * @returns 取消订阅的函数
+     * 异步等待并获取服务
+     * @description 如果服务尚未注册，将返回一个 Promise，直到该服务被注册时 resolve。
+     * 支持设置超时时间，防止因插件加载失败导致的永久挂起。
+     *
+     * @template T - 服务类型的泛型
+     * @param name - 待等待的服务名称
+     * @param timeout - 超时时间 (毫秒)，默认 10000ms (10秒)。若为 0 则永不超时。
+     * @returns 包含服务实例的 Promise
+     * @throws {Error} 若在规定时间内服务未注册，则抛出超时异常。
      */
-    on(event: string, callback: (...args: any[]) => any): () => void;
+    waitFor<T = any>(name: string, timeout?: number): Promise<T>;
     /**
-     * 取消订阅事件
-     * @param event - 事件名称
-     * @param callback - 之前注册的回调函数
+     * 检查服务是否已注册
+     * @param name - 服务名称
      */
-    off(event: string, callback: (...args: any[]) => any): void;
+    has(name: string): boolean;
     /**
-     * 触发事件 (发布)
-     * @param event - 事件名称
-     * @param args - 传递给回调函数的参数列表
+     * 注销特定的服务
+     * @param name - 服务名称
      */
-    emit(event: string, ...args: any[]): void;
+    unregister(name: string): void;
     /**
-     * 订阅一次性事件
-     * @description 事件触发一次后会自动取消订阅
-     * @param event - 事件名称
-     * @param callback - 事件触发时的回调函数
+     * 清除所有已注册的服务和监听器
+     * @description 通常仅在系统重置或大型热更新时使用。
      */
-    once(event: string, callback: (...args: any[]) => any): void;
+    clear(): void;
 }
+declare const serviceRegistry: ServiceRegistry;
 
 /**
- * 存储端口接口
- * @description 定义数据持久化的标准契约，兼容 Web Storage API。
+ * 配置管理器
+ * @description 核心工具类，负责管理应用的全局系统配置以及各插件的初始化业务配置。
+ * 配置数据通常在应用启动时通过 `usePluginLoader` 注入，并作为插件运行时的取值回退来源。
  */
-interface StoragePort {
+declare class ConfigManager<T = Record<string, unknown>> {
+    /** 内部存储配置的 Map 对象 */
+    private config;
     /**
-     * 获取存储项
-     * @param key - 键名
-     * @returns 对应的值，如果不存在则返回 null
+     * 设置特定的配置项
+     * @param key - 配置键名（如 'system' 或插件 ID）
+     * @param value - 配置内容对象
      */
-    getItem(key: string): string | null;
+    set<K extends keyof T>(key: K, value: T[K]): void;
+    set(key: string, value: unknown): void;
     /**
-     * 设置存储项
-     * @param key - 键名
-     * @param value - 键值 (字符串)
+     * 获取指定的配置项
+     * @param key - 配置键名
+     * @returns 配置内容，若不存在则返回 undefined
      */
-    setItem(key: string, value: string): void;
+    get<K extends keyof T>(key: K): T[K] | undefined;
+    get(key: string): unknown;
     /**
-     * 移除指定的存储项
-     * @param key - 键名
+     * 深度合并配置对象
+     * @description 对配置进行深度合并，嵌套对象会被递归合并而非完全覆盖。
+     * @param config - 待合并的配置对象映射
      */
-    removeItem(key: string): void;
+    merge(config: Partial<T> & Record<string, unknown>): void;
     /**
-     * 清空所有存储项
+     * 深度合并两个对象
      */
-    clear(): void;
+    private deepMerge;
+    /**
+     * 获取当前存储的所有配置快照
+     * @returns 包含所有配置的普通对象
+     */
+    getAll(): T;
     /**
-     * 返回存储对象中当前存储的数据项总数
+     * 检查配置项是否存在
      */
-    readonly length: number;
+    has(key: string): boolean;
     /**
-     * 根据索引返回存储中对应键的名称
-     * @param index - 数值索引
-     * @returns 键名，如果索引超出范围则返回 null
+     * 删除指定配置项
      */
-    key(index: number): string | null;
-}
-/**
- * 类型化存储接口
- * @description 提供泛型支持的存储访问能力，自动处理序列化
- */
-interface TypedStorage {
-    /** 获取存储数据 */
-    get: <T = any>(key: string) => T | null;
-    /** 设置存储数据 */
-    set: <T = any>(key: string, value: T) => void;
-    /** 移除存储数据 */
-    remove: (key: string) => void;
+    delete(key: string): boolean;
+    /**
+     * 清空所有配置
+     */
+    clear(): void;
 }
+/** 全局配置管理器单例 */
+declare const configManager: ConfigManager<Record<string, unknown>>;
 
 /**
- * 插件类型定义
- */
-declare const PLUGIN_TYPES: readonly ["business", "functional", "view", "theme", "renderer", "system"];
-type PluginType = typeof PLUGIN_TYPES[number];
-/**
- * 路由配置
+ * AI 能力抽象层类型定义
  */
-interface RouteConfig {
-    path: string;
-    component: React.ComponentType<any>;
-    meta?: Record<string, any>;
+interface AIMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: ToolCall[];
+    createdAt?: number;
 }
-/**
- * 插件插槽位置
- * @description 定义插件可以注入 UI 的标准位置
- */
-declare const Slot: {
-    readonly Sidebar: "sidebar";
-    readonly SidebarPanel: "sidebar-panel";
-    readonly Header: "header";
-    readonly StatusBar: "status-bar";
-    readonly Settings: "settings";
-    readonly MessageRenderer: "message-renderer";
-    readonly MessageContentRenderer: "message-content-renderer";
-    readonly SidebarSystem: "sidebar-system";
-    readonly SidebarBottom: "sidebar-bottom";
-    readonly RootLayout: "root-layout";
-    readonly Custom: "custom";
-};
-type SlotType = typeof Slot[keyof typeof Slot];
-type SlotPosition = SlotType | string;
-/**
- * 插件扩展 (插槽注入配置)
- */
-interface PluginExtension {
-    /** 插槽位置标识符 */
-    slot: SlotPosition;
-    /** 要注入的 React 组件 */
-    component: React.ComponentType<any>;
-    /** 排序权重，数值越小越靠前 */
-    order?: number;
-    /** @internal 插件 ID，由系统在加载时自动注入，用于溯源 */
-    _pluginId?: string;
-    /** 扩展的元数据信息 */
-    meta?: {
-        /** 显示图标 */
-        icon?: React.ReactNode;
-        /** 显示标签文本 */
-        label?: string;
-        /** 详细描述 */
-        description?: string;
-        /** 唯一标识符，用于某些特定插槽的索引 */
-        key?: string;
-        /** 允许其他自定义属性 */
-        [key: string]: any;
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
     };
 }
-/**
- * 插件配置项定义
- */
-interface PluginConfigItem {
-    /** 配置键名 */
-    key: string;
-    /** 配置类型 */
-    type: 'string' | 'number' | 'boolean' | 'select';
-    /** 配置显示的标签 */
-    label: string;
-    /** 配置描述信息 */
-    description?: string;
-    /** 默认值 */
-    default?: any;
-    /** 当类型为 select 时的选项列表 */
-    options?: {
-        label: string;
-        value: any;
-    }[];
-    /** 选择模式：支持多选或标签模式 (AntD 风格) */
-    mode?: 'multiple' | 'tags';
-    /** 最小值 (针对 number 类型) */
-    min?: number;
-    /** 最大值 (针对 number 类型) */
-    max?: number;
-    /**
-     * 是否为私有配置
-     * @description 如果为 true，则该配置不会通过自动配置服务暴露给其他插件
-     * @default false
-     */
-    private?: boolean;
+interface ChatOptions {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    tools?: AITool[];
+    stream?: boolean;
+    systemPrompt?: string;
+}
+interface AIProvider {
+    chat(messages: AIMessage[], options?: ChatOptions): Promise<AIMessage>;
+    stream(messages: AIMessage[], options?: ChatOptions): AsyncIterable<AIChunk>;
+    functionCall(messages: AIMessage[], tools: AITool[], options?: ChatOptions): Promise<FunctionCallResult>;
+}
+interface AIChunk {
+    type: 'content' | 'tool-call' | 'done' | 'error';
+    content?: string;
+    toolCall?: ToolCall;
+    error?: string;
+}
+interface FunctionCallResult {
+    message: AIMessage;
+    toolCalls: ToolCall[];
+}
+interface Session {
+    id: string;
+    name: string;
+    messages: AIMessage[];
+    createdAt: number;
+    updatedAt: number;
+    metadata?: Record<string, unknown>;
+}
+interface AITool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (args: Record<string, unknown>) => Promise<unknown>;
 }
+
 /**
- * 插件能力定义 (Behavioral Capabilities)
- * @description 定义插件的行为特征。注意：路由(routes)和扩展(extensions)属于结构化能力，直接通过 metadata 字段声明，不在此列。
+ * 工具注册表
+ * 管理 AI 函数的注册和执行
  */
-interface PluginCapabilities {
+declare class ToolRegistry {
+    private tools;
     /**
-     * 是否支持配置设置
-     * @default false (如果 metadata.configuration 存在，则可能被隐式视为 true，建议显式声明)
+     * 注册工具
      */
-    configurable?: boolean;
+    register(tool: AITool): void;
     /**
-     * 是否可嵌入其他页面
-     * @description 声明该插件是否可以作为 Widget 被其他插件引用
+     * 注销工具
      */
-    embeddable?: boolean;
+    unregister(name: string): void;
     /**
-     * 是否支持多实例
-     * @description 默认为 false (单例)。如果在聊天窗口中每个会话都需要独立状态，则设为 true
+     * 获取工具
      */
-    multiInstance?: boolean;
+    get(name: string): AITool | null;
     /**
-     * 是否需要后台运行
-     * @description 如果为 true，即使 UI 不可见，插件也不会被卸载
+     * 列出所有工具
      */
-    background?: boolean;
-    [key: string]: boolean | undefined;
-}
-/**
- * 存储项数据结构定义 (Schema)
- */
-interface StorageItemSchema {
-    /** 存储键名 */
-    key: string;
-    /** 数据类型 */
-    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
-    /** 默认值 */
-    default?: any;
-    /** 描述信息 */
-    description?: string;
+    list(): AITool[];
     /**
-     * 作用域
-     * @description 'plugin' 表示仅当前插件可见（带插件 ID 前缀），'shared' 表示全局共享
-     */
-    scope?: 'plugin' | 'shared';
-}
-/**
- * 插件存储接口
- * @description 包含私有存储和共享存储访问能力
- */
-interface PluginStorage extends TypedStorage {
-    /** 获取插件私有存储数据 */
-    get: TypedStorage['get'];
-    /** 设置插件私有存储数据 */
-    set: TypedStorage['set'];
-    /** 移除插件私有存储数据 */
-    remove: TypedStorage['remove'];
-    /** 全局共享存储访问 */
-    shared: TypedStorage & {
-        /** 获取全局共享存储数据 */
-        get: TypedStorage['get'];
-        /** 设置全局共享存储数据 */
-        set: TypedStorage['set'];
-        /** 移除全局共享存储数据 */
-        remove: TypedStorage['remove'];
-    };
+     * 执行工具
+     */
+    execute(name: string, args: Record<string, unknown>): Promise<unknown>;
 }
+
 /**
- * 插件生命周期 Hooks
- * @description 插件可以在不同的生命周期阶段执行特定的逻辑
+ * Mock AI Provider
+ * 用于演示和测试环境，返回预设的智能回复
  */
-interface PluginLifecycle {
-    /**
-     * 插件加载时调用
-     * @description 在插件被扫描并注入内核时触发。用于初始化内部状态、注册服务、设置拦截器等。此时 UI 尚未挂载。
-     * @param context - 插件上下文对象，提供核心能力的访问
-     */
-    onLoad?: (context: PluginContext) => void | Promise<void>;
+declare class MockAIProvider implements AIProvider {
+    private responses;
     /**
-     * 插件挂载到 UI 时调用
-     * @description 当插件的 UI 组件（如有）被 React 挂载到 DOM 时触发。
-     * @param context - 插件上下文对象
+     * 生成回复
      */
-    onMount?: (context: PluginContext) => void;
+    private generateResponse;
     /**
-     * 插件从 UI 卸载时调用
-     * @description 当插件的 UI 组件被销毁时触发。用于清理定时器、取消订阅等。
-     * @param context - 插件上下文对象
+     * 生成唯一 ID
      */
-    onUnmount?: (context: PluginContext) => void;
+    private generateId;
     /**
-     * 插件配置发生变化时调用
-     * @description 当用户通过配置中心修改插件设置时触发。
-     * @param newConfig - 变更后的新配置对象
-     * @param oldConfig - 变更前的旧配置对象
+     * 聊天（非流式）
      */
-    onConfigChange?: (newConfig: any, oldConfig: any) => void;
-}
-/**
- * 插件上下文
- * @description 传递给插件生命周期钩子的核心对象，是插件访问宿主环境能力的唯一入口。
- */
-interface PluginContext {
-    /** 当前插件的唯一标识符 */
-    pluginId: string;
-    /** API 请求能力入口 */
-    api: any;
-    /** 事件总线能力入口 */
-    events: EventBusPort;
-    /** 存储管理能力入口 */
-    storage: PluginStorage;
-    /** 日志输出工具，自动携带插件 ID 前缀 */
-    logger: {
-        debug: (...args: any[]) => void;
-        info: (...args: any[]) => void;
-        warn: (...args: any[]) => void;
-        error: (...args: any[]) => void;
-    };
+    chat(messages: AIMessage[], options?: ChatOptions): Promise<AIMessage>;
     /**
-     * 访问其他插件提供的服务
-     * @param serviceName - 服务注册名称
-     * @returns 服务实例，如果不存在则返回 undefined
+     * 流式响应
      */
-    getService: <T = any>(serviceName: string) => T | undefined;
+    stream(messages: AIMessage[], options?: ChatOptions): AsyncIterable<AIChunk>;
     /**
-     * 注册当前插件的服务供他人使用
-     * @param serviceName - 唯一服务名称
-     * @param service - 服务实现对象
+     * 函数调用
      */
-    registerService: (serviceName: string, service: any) => void;
-    /** 宿主环境 Window 的代理对象 (用于沙箱隔离) */
-    window: WindowProxy;
+    functionCall(messages: AIMessage[], tools: AITool[], options?: ChatOptions): Promise<FunctionCallResult>;
 }
+
 /**
- * 完整的插件对象定义
+ * OpenAI Provider 实现
+ * 支持 chat、stream、functionCall 方法
  */
-interface Plugin extends PluginLifecycle {
-    /**
-     * 插件唯一标识符
-     * @description 必须与 metadata.id 一致，通常为只读。
-     */
-    readonly id: string;
-    /** 插件元数据配置 */
-    metadata: PluginMetadata;
-    /** 插件提供的功能组件集合 (可选) */
-    components?: Record<string, React.ComponentType<any>>;
-    /** 插件提供的工具函数集合 (可选) */
-    utils?: Record<string, any>;
-    /** 插件的初始默认配置 (可选) */
-    defaultConfig?: Record<string, any>;
+declare class OpenAIProvider implements AIProvider {
+    private client;
+    private defaultOptions;
+    constructor(apiKey: string, defaultOptions?: ChatOptions);
+    chat(messages: AIMessage[], options?: ChatOptions): Promise<AIMessage>;
+    stream(messages: AIMessage[], options?: ChatOptions): AsyncIterable<AIChunk>;
+    functionCall(messages: AIMessage[], tools: AITool[], options?: ChatOptions): Promise<FunctionCallResult>;
+    private toOpenAIMessages;
+    private toOpenAITools;
+    private fromOpenAIMessage;
+    private fromOpenAIToolCall;
 }
-/**
- * 插件基础类
- * @deprecated 建议统一使用工厂模式 definePlugin() 定义插件，以消除类与对象定义的歧义。
- * @description 解决插件定义时 id 与 metadata.id 重复定义的问题，并提供基础生命周期管理
- */
-declare abstract class BasePlugin implements Plugin {
-    abstract metadata: PluginMetadata;
-    /**
-     * 插件 ID
-     * @description 自动从 metadata.id 获取
-     */
-    get id(): string;
-    onLoad?(context: PluginContext): void | Promise<void>;
-    onMount?(context: PluginContext): void;
-    onUnmount?(context: PluginContext): void;
-    onConfigChange?(newConfig: any, oldConfig: any): void;
+
+interface SessionStorage {
+    save(sessions: Session[]): void;
+    load(): Session[];
 }
+interface SessionManagerInterface {
+    createSession(name?: string): Session;
+    getSession(id: string): Session | null;
+    listSessions(): Session[];
+    deleteSession(id: string): void;
+    addMessage(sessionId: string, message: AIMessage): void;
+    clearMessages(sessionId: string): void;
+}
+
 /**
- * 辅助函数：定义插件并自动从 metadata.id 注入顶级 id
- * @description 解决插件定义时 id 与 metadata.id 重复定义的问题，提高代码优雅度
- * @param plugin 插件定义（不包含顶级 id）
- * @returns 完整的插件对象
- */
-declare function definePlugin(plugin: Omit<Plugin, 'id'>): Plugin;
+ * 会话管理器
+ * 提供会话的创建、查询、删除、消息管理等功能
+ */
+declare class SessionManager implements SessionManagerInterface {
+    private sessions;
+    private storage?;
+    constructor(storage?: SessionStorage);
+    createSession(name?: string): Session;
+    getSession(id: string): Session | null;
+    listSessions(): Session[];
+    deleteSession(id: string): void;
+    addMessage(sessionId: string, message: AIMessage): void;
+    clearMessages(sessionId: string): void;
+    private loadFromStorage;
+    private saveToStorage;
+}
+
 /**
- * 插件元数据定义
- * @description 描述插件的静态属性，用于插件市场展示、权限校验和内核加载参考。
+ * LocalStorage 适配器，用于会话持久化
+ * 注意：仅在浏览器环境可用
  */
-interface PluginMetadata {
-    /** 插件唯一 ID (推荐反向域名格式，如 com.company.plugin) */
-    id: string;
-    /** 插件显示名称 */
-    name: string;
-    /** 插件版本号 (符合 SemVer 规范) */
-    version: string;
-    /** 插件类型 */
-    type: PluginType;
-    /** 插件功能描述 */
-    description?: string;
-    /** 插件作者信息 */
-    author?: string;
-    /** 插件图标 (React 组件或图标名称) */
-    icon?: React.ReactNode;
-    /** 插件依赖的其他插件 ID 列表 */
-    dependencies?: string[];
-    /** 路由配置集合，用于在主应用中注册页面 */
-    routes?: RouteConfig[];
-    /** 插槽扩展集合，用于在主应用 UI 预留位注入组件 */
-    extensions?: PluginExtension[];
-    /** 插件所需调用的 API 接口配置 */
-    api?: ApiConfig;
-    /** 插件行为能力声明 */
-    capabilities?: PluginCapabilities;
-    /** 插件的可配置项定义 */
-    configuration?: PluginConfigItem[];
-    /** 插件所需的存储结构定义 */
-    storage?: StorageItemSchema[];
-    /**
-     * 系统状态自动绑定
-     * @description 将插件的配置项自动同步到系统的全局状态中 (如主题色、身份认证等)
-     */
-    systemStateBindings?: {
-        /** 插件配置中的键名 */
-        configKey: string;
-        /** 系统全局状态中的键名 */
-        stateKey: string;
-        /** 预设的转换逻辑名称 */
-        transform?: 'theme-mode' | 'identity';
-    }[];
+declare class SessionLocalStorageAdapter implements SessionStorage {
+    save(sessions: Session[]): void;
+    load(): Session[];
 }
 
+interface AIState {
+    provider: AIProvider | null;
+    setProvider: (provider: AIProvider) => void;
+    sessions: Session[];
+    currentSessionId: string | null;
+    sessionManager: SessionManager;
+    toolRegistry: ToolRegistry;
+    createSession: (name?: string) => Session;
+    selectSession: (id: string) => void;
+    deleteSession: (id: string) => void;
+    addMessage: (message: AIMessage) => void;
+    registerTool: (tool: AITool) => void;
+    unregisterTool: (name: string) => void;
+    sendMessage: (content: string) => Promise<void>;
+    clearCurrentSession: () => void;
+    streamMessage: (content: string, onChunk: (chunk: string) => void) => Promise<void>;
+}
+declare const aiStore: zustand_vanilla.StoreApi<AIState>;
+declare function createAIStore(apiKey: string, defaultModel?: string): void;
+
 /**
- * 基于 Axios 的默认请求适配器
+ * 插件注册表接口
+ * @description 键为插件 ID，值为一个返回插件定义的异步加载函数。
  */
-declare class AxiosAdapter implements ApiAdapter {
-    private client;
-    constructor(baseURL?: string, timeout?: number);
-    request<T = any>(config: ApiRequestConfig): Promise<T>;
-    stream(config: ApiRequestConfig, callbacks: StreamCallbacks, _endpointConfig?: ApiEndpointConfig): Promise<void>;
+interface PluginRegistry {
+    [pluginId: string]: () => Promise<any>;
 }
-
 /**
- * API 引擎核心类
- * @description 负责加载配置并执行请求，支持策略模式切换底层请求实现
+ * 插件自动发现规则
  */
-declare class ApiEngine {
-    private adapter;
-    private config;
-    private interceptors;
-    constructor(adapter?: ApiAdapter);
-    /**
-     * 注册拦截器
-     */
-    registerInterceptor(interceptor: ApiInterceptor): void;
-    /**
-     * 移除拦截器
-     */
-    unregisterInterceptor(interceptor: ApiInterceptor): void;
-    /**
-     * 切换请求适配器
-     * @param adapter 新的适配器实例
-     */
-    useAdapter(adapter: ApiAdapter): void;
-    /**
-     * 注册 API 配置
-     * @param config 配置对象
-     */
-    register(config: ApiConfig): void;
-    /**
-     * 获取接口配置
-     */
-    getEndpoint(module: string, action: string): ApiEndpointConfig | undefined;
-    /**
-     * 发起 API 请求
-     * @param module 模块名
-     * @param action 动作名
-     * @param data 请求数据 (Body 或 Query)
-     * @param options 请求选项
-     */
-    call<T = any>(module: string, action: string, data?: any, options?: RequestOptions): Promise<T>;
-    /**
-     * 发起流式请求
-     * @param module 模块名
-     * @param action 动作名
-     * @param data 请求数据
-     * @param options 请求选项
-     */
-    stream(module: string, action: string, data?: any, options?: RequestOptions): Promise<void>;
+interface DiscoveryRule {
     /**
-     * 准备请求配置，应用 URL 参数替换和请求拦截器
+     * 路径匹配标识。
+     * @example 'plugins' 或 '@chatbi-plugins'
      */
-    private prepareRequestConfig;
+    pathSegment: string;
     /**
-     * 应用所有请求拦截器
+     * 生成插件 ID 时的前缀。
+     * @example '@chatbi-v/plugin'，最终生成如 '@chatbi-v/plugin-demo'
      */
-    private applyRequestInterceptors;
-    /**
-     * 应用所有响应拦截器
-     * @returns 是否被劫持
+    idPrefix: string;
+}
+/**
+ * 解析插件注册表
+ * @description 核心逻辑：将 Vite 的 `import.meta.glob` 结果映射为标准的插件注册表。
+ * 它会根据预定义的路径匹配规则，从文件路径中提取插件目录名，并拼接前缀生成唯一的插件 ID。
+ *
+ * @param options - 包含待处理模块和匹配规则的选项对象
+ * @returns 解析后的 PluginRegistry 对象
+ */
+declare const resolvePluginRegistry: (options: {
+    /** 原始模块映射 (来自 Vite glob) */
+    modules: Record<string, () => Promise<any>>;
+    /** 自定义发现规则 (可选) */
+    rules?: DiscoveryRule[];
+}) => PluginRegistry;
+
+/**
+ * 日志等级枚举
+ */
+declare enum LogLevel {
+    /** 调试级别：输出最详尽的信息 */
+    DEBUG = 0,
+    /** 信息级别：输出重要的运行状态 */
+    INFO = 1,
+    /** 警告级别：输出潜在的问题，但不影响运行 */
+    WARN = 2,
+    /** 错误级别：输出严重的运行异常 */
+    ERROR = 3,
+    /** 禁用日志：不输出任何信息 */
+    NONE = 4
+}
+/**
+ * 日志工具类
+ * @description 核心工具类，提供统一的日志输出格式 `[Prefix] Message`。
+ * 支持通过 `LogLevel` 进行全局过滤。
+ * 支持日志缓冲和自动分组，以减少控制台噪音。
+ * 支持浏览器端 CSS 样式和 Node.js 端 ANSI 颜色。
+ */
+declare class Logger {
+    /** 全局静态日志等级，所有实例共享 */
+    private static level;
+    /** 日志缓冲区 */
+    private static buffer;
+    /** 缓冲输出防抖定时器 */
+    private static flushTimer;
+    /** 缓冲时间窗口 (ms) */
+    private static FLUSH_INTERVAL;
+    /** 是否启用缓冲模式 */
+    private static bufferEnabled;
+    /** 是否为浏览器环境 */
+    private static isBrowser;
+    /** 当前实例的业务模块前缀 */
+    private prefix;
+    /** 实例特定的颜色 */
+    private color;
+    /**
+     * 构造函数
+     * @param prefix - 业务模块前缀，默认为 'App'
      */
-    private applyResponseInterceptors;
+    constructor(prefix?: string);
     /**
-     * 检查 HTTP 状态码
+     * 静态方法：设置全局日志输出等级
+     * @param level - 目标日志等级
      */
-    private checkHttpStatus;
+    static setLevel(level: LogLevel): void;
     /**
-     * 提取响应数据
+     * 静态方法：启用或禁用日志缓冲
+     * @param enabled - 是否启用
      */
-    private extractResponseData;
+    static setBufferEnabled(enabled: boolean): void;
     /**
-     * 处理业务错误
+     * 静态方法：获取当前全局日志等级
+     * @returns 当前生效的全局日志等级
      */
-    private handleBusinessError;
+    static getLevel(): LogLevel;
     /**
-     * 判断是否为 BaseResponse
+     * 格式化输出前缀
      */
-    private isBaseResponse;
+    private getFormattedPrefix;
     /**
-     * 严格判断是否为 AxiosResponse
+     * 生成分组标题参数
      */
-    private isAxiosResponse;
+    private static getGroupTitleArgs;
     /**
-     * 创建拦截上下文
+     * 内部方法：将日志推入缓冲区或直接输出
      */
-    private createInterceptorContext;
+    private log;
+    /**
+     * 静态方法：刷新缓冲区，分组输出日志
+     */
+    static flush(): void;
+    /**
+     * 打印 DEBUG 级别日志
+     */
+    debug(...args: any[]): void;
+    /**
+     * 打印 INFO 级别日志
+     */
+    info(...args: any[]): void;
+    /**
+     * 打印 WARN 级别日志
+     */
+    warn(...args: any[]): void;
+    /**
+     * 打印 ERROR 级别日志
+     */
+    error(...args: any[]): void;
+    /**
+     * 开始一个日志控制台分组
+     */
+    group(label: string, collapsed?: boolean): void;
+    /**
+     * 结束当前日志控制台分组
+     */
+    groupEnd(): void;
 }
-declare const apiEngine: ApiEngine;
+/** 默认 Logger 实例 */
+declare const logger: Logger;
+/**
+ * 创建带特定前缀的 Logger 实例
+ * @param prefix 日志前缀
+ * @returns Logger 实例
+ */
+declare const createLogger: (prefix: string) => Logger;
 
 /**
- * 自动检测是否处于 Mock 模式
+ * @file errors.ts
+ * @description Core 层统一错误处理定义
  */
-declare function isMockMode(): boolean;
+
 /**
- * 从文件模块映射中解析 API 配置
- * @description 配合 Vite 的 import.meta.glob 使用，自动匹配定义文件和 Mock 文件
- * @param definitionsMap API 定义文件映射 (import.meta.glob('./modules/*.ts', { eager: true }))
- * @param mocksMap Mock 文件映射 (import.meta.glob('./modules/*.mock.ts', { eager: true }))
- * @param useMock 是否启用 Mock (如果不传，将自动调用 isMockMode())
- * @returns 合并后的 ApiConfig
+ * 核心错误码枚举
+ */
+declare enum CoreErrorCode {
+    UNKNOWN = "1000",
+    NOT_FOUND = "1001",
+    INVALID_PARAMS = "1002",
+    TIMEOUT = "1003",
+    PLUGIN_NOT_FOUND = "2001",
+    PLUGIN_LOAD_FAILED = "2002",
+    PLUGIN_MOUNT_FAILED = "2003",
+    PLUGIN_UNMOUNT_FAILED = "2004",
+    PLUGIN_DEPENDENCY_MISSING = "2005",
+    PLUGIN_CIRCULAR_DEPENDENCY = "2006",
+    PLUGIN_INIT_FAILED = "2007",
+    STORAGE_READ_FAILED = "3001",
+    STORAGE_WRITE_FAILED = "3002",
+    STORAGE_SCHEMA_VIOLATION = "3003",
+    STORAGE_QUOTA_EXCEEDED = "3004",
+    API_REQUEST_FAILED = "4001",
+    API_RESPONSE_INVALID = "4002",
+    API_NETWORK_ERROR = "4003",
+    API_TIMEOUT = "4004",
+    API_UNAUTHORIZED = "4005",
+    SANDBOX_EVAL_FAILED = "5001",
+    SANDBOX_ISOLATION_BREACHED = "5002",
+    SANDBOX_MEMORY_LIMIT = "5003",
+    SERVICE_NOT_FOUND = "6001",
+    SERVICE_REGISTER_FAILED = "6002",
+    SERVICE_WAIT_TIMEOUT = "6003"
+}
+/**
+ * 错误处理策略
  */
-declare function resolveApiModules(definitionsMap: Record<string, any>, mocksMap?: Record<string, any>): ApiConfig;
+declare enum CoreErrorStrategy {
+    THROW = "throw",// 抛出异常
+    RESOLVE = "resolve",// 返回默认值
+    REJECT = "reject",// 返回 Promise reject
+    SILENT = "silent"
+}
+/**
+ * 错误处理选项
+ */
+interface ErrorHandlerOptions {
+    code: CoreErrorCode;
+    strategy: CoreErrorStrategy;
+    defaultValue?: any;
+    logger?: ReturnType<typeof createLogger>;
+    context?: Record<string, any>;
+}
+/**
+ * 核心错误类
+ */
+declare class CoreError extends Error {
+    readonly code: CoreErrorCode;
+    readonly originalError?: Error;
+    readonly context?: Record<string, any>;
+    constructor(code: CoreErrorCode, message: string, originalError?: Error, context?: Record<string, any>);
+}
+/**
+ * 统一错误处理函数
+ */
+declare function handleError(error: unknown, options: ErrorHandlerOptions): any;
 
 /**
  * 成功状态码
@@ -683,254 +717,444 @@ interface Scene {
     cover?: string;
 }
 
-interface ApiProviderProps {
-    api: ApiEngine;
-    children: React.ReactNode;
+/**
+ * @file performance/types.ts
+ * @description 性能监测数据类型定义
+ * @author ChatBI Team
+ */
+/**
+ * 插件生命周期阶段
+ */
+type LifecyclePhase = 'load' | 'mount' | 'unmount';
+/**
+ * 生命周期性能指标
+ * 记录插件 load/mount/unmount 阶段的执行耗时
+ */
+interface LifecycleMetric {
+    /** 插件 ID */
+    pluginId: string;
+    /** 生命周期阶段 */
+    phase: LifecyclePhase;
+    /** 执行耗时（毫秒） */
+    duration: number;
+    /** 时间戳 */
+    timestamp: number;
+    /** 是否成功 */
+    success: boolean;
+    /** 错误信息（仅在 success 为 false 时存在） */
+    error?: string;
+}
+/**
+ * 运行时性能指标
+ * 记录插件运行期间的内存、帧率等数据
+ */
+interface RuntimeMetric {
+    /** 插件 ID */
+    pluginId: string;
+    /** 时间戳 */
+    timestamp: number;
+    /** 内存使用量（字节） */
+    memory?: number;
+    /** 帧率 */
+    fps?: number;
+    /** API 调用次数 */
+    apiCalls?: number;
+}
+/**
+ * 性能数据集合
+ */
+interface PerformanceData {
+    /** 生命周期指标集合 */
+    lifecycle: LifecycleMetric[];
+    /** 运行时采样数据集合 */
+    samples: RuntimeMetric[];
+}
+/**
+ * 性能监测配置
+ */
+interface PerformanceSettings {
+    /** 生命周期记录最大条数（默认 1000） */
+    maxLifecycleRecords: number;
+    /** 运行时采样最大条数（默认 500） */
+    maxRuntimeSamples: number;
+    /** 采样率（0-1 之间） */
+    sampleRate: number;
 }
-declare const ApiProvider: React.FC<ApiProviderProps>;
-declare const useApi: () => ApiEngine;
+/**
+ * 默认性能监测配置
+ */
+declare const DEFAULT_PERFORMANCE_SETTINGS: PerformanceSettings;
 
 /**
- * 服务注册中心 (Service Registry)
- * @description 核心应用层服务，作为微内核架构中的“中枢调度员”。
- * 主要职责：
- * 1. 服务解耦：允许插件将其内部功能暴露为“服务”，而无需与其他插件产生物理依赖。
- * 2. 动态发现：提供按名称查找服务的能力，支持服务热插拔。
- * 3. 依赖协调：通过 `waitFor` 机制解决插件间由于加载顺序导致的初始化依赖问题。
- *
- * 建议的服务命名规范: `pluginId.serviceName` (例如: `auth.sessionService`)
+ * 核心领域服务：存储管理器
+ * @description 统一管理应用内所有的持久化存储资源。
+ * 核心功能：
+ * 1. 作用域隔离：通过前缀划分 `plugin`、`shared` 和 `system` 三个层级的存储空间。
+ * 2. Schema 校验：支持注册存储描述，规范数据存取，避免键名冲突。
+ * 3. 默认值与配置回退：支持从 Schema 默认值或 ConfigManager 中回退取值。
+ * 4. LRU 缓存：使用 LRU 策略管理内存缓存，防止无限增长。
  */
-declare class ServiceRegistry {
-    /** 存储已注册服务的 Map 对象 */
-    private services;
-    /** 存储正在等待特定服务的监听器集合 */
-    private listeners;
+declare class StorageManager {
+    /** 底层物理存储驱动 */
+    private baseStorage;
+    /** 插件 ID 与存储描述定义的映射关系 */
+    private schemas;
+    /** LRU 内存缓存，减少 JSON 序列化和物理 IO 开销 */
+    private memoryCache;
     /**
-     * 注册一个服务实现
-     * @param name - 唯一的服务名称
-     * @param service - 服务实例或对象
+     * 初始化存储管理器
+     * @param baseStorage - 符合 StoragePort 接口的物理存储驱动（如 LocalStorageAdapter）
      */
-    register(name: string, service: any): void;
+    constructor(baseStorage: StoragePort);
     /**
-     * 同步获取服务实例
-     * @template T - 服务类型的泛型
-     * @param name - 服务名称
-     * @returns 服务实例，若不存在则返回 undefined
+     * 注册插件的存储 Schema
+     * @param pluginId - 插件 ID
+     * @param schema - 存储项定义列表
      */
-    get<T = any>(name: string): T | undefined;
+    registerSchema(pluginId: string, schema: StorageItemSchema[]): void;
     /**
-     * 异步等待并获取服务
-     * @description 如果服务尚未注册，将返回一个 Promise，直到该服务被注册时 resolve。
-     * 支持设置超时时间，防止因插件加载失败导致的永久挂起。
-     *
-     * @template T - 服务类型的泛型
-     * @param name - 待等待的服务名称
-     * @param timeout - 超时时间 (毫秒)，默认 10000ms (10秒)。若为 0 则永不超时。
-     * @returns 包含服务实例的 Promise
-     * @throws {Error} 若在规定时间内服务未注册，则抛出超时异常。
+     * 删除插件的所有存储数据
+     * @description 包括插件私有存储、上下文存储、注册 Schema 及内存缓存
+     * @param pluginId - 插件 ID
      */
-    waitFor<T = any>(name: string, timeout?: number): Promise<T>;
+    deletePluginStorage(pluginId: string): void;
     /**
-     * 检查服务是否已注册
-     * @param name - 服务名称
+     * 内部校验方法：检查键名是否在 Schema 中声明
+     * @param pluginId - 插件 ID
+     * @param key - 待校验的键名
+     * @param scope - 目标作用域
      */
-    has(name: string): boolean;
+    private validateKey;
     /**
-     * 注销特定的服务
-     * @param name - 服务名称
+     * 获取插件私有存储适配器
+     * @param pluginId - 插件 ID
+     * @returns 自动添加 `plugin:{id}:` 前缀的存储接口
      */
-    unregister(name: string): void;
+    getPluginStorage(pluginId: string): StoragePort;
     /**
-     * 清除所有已注册的服务和监听器
-     * @description 通常仅在系统重置或大型热更新时使用。
+     * 获取全局共享存储适配器
+     * @returns 自动添加 `shared:` 前缀的存储接口
      */
-    clear(): void;
-}
-declare const serviceRegistry: ServiceRegistry;
-
-/**
- * 配置管理器
- * @description 核心工具类，负责管理应用的全局系统配置以及各插件的初始化业务配置。
- * 配置数据通常在应用启动时通过 `usePluginLoader` 注入，并作为插件运行时的取值回退来源。
- */
-declare class ConfigManager {
-    /** 内部存储配置的 Map 对象 */
-    private config;
+    getSharedStorage(): StoragePort;
     /**
-     * 设置特定的配置项
-     * @param key - 配置键名（如 'system' 或插件 ID）
-     * @param value - 配置内容对象
+     * 获取系统内部存储适配器
+     * @returns 自动添加 `system:` 前缀的存储接口
      */
-    set(key: string, value: any): void;
+    getSystemStorage(): StoragePort;
     /**
-     * 获取指定的配置项
-     * @param key - 配置键名
-     * @returns 配置内容，若不存在则返回 undefined
+     * 创建插件沙箱使用的复合存储对象
+     * @description 返回的对象封装了对私有存储和共享存储的操作。
+     * 特性：
+     * - 内存级 LRU 缓存：极大提升高频读写性能。
+     * - 自动序列化/反序列化 JSON。
+     * - 自动校验 Schema。
+     * - 取值回退逻辑：持久化存储 -> ConfigManager -> Schema 默认值。
+     *
+     * @param pluginId - 插件 ID
+     * @returns 包含 get/set/remove 及 shared 子对象的复合接口
      */
-    get(key: string): any;
+    getContextStorage(pluginId: string): {
+        shared: {
+            get: <T = any>(key: string) => T | null;
+            set: <T = any>(key: string, value: T) => void;
+            remove: (key: string) => void;
+        };
+        get: <T = any>(key: string) => T | null;
+        set: <T = any>(key: string, value: T) => void;
+        remove: (key: string) => void;
+    };
+}
+
+/**
+ * 性能数据存储层
+ * @description 负责性能数据的持久化，支持生命周期指标和运行时采样数据的存储与查询
+ */
+declare class PerformanceStorage {
+    private storageManager;
+    private systemStorage;
+    private settings;
+    private lifecycleCache;
+    private runtimeCache;
+    private readonly LIFECYCLE_KEY;
+    private readonly RUNTIME_KEY;
     /**
-     * 批量合并配置对象
-     * @description 对顶层属性进行浅合并，若属性值为对象则进行一层深度的合并。
-     * @param config - 待合并的配置对象映射
+     * 构造函数
+     * @param storageManager - 存储管理器实例
+     * @param settings - 性能设置（可选，默认使用 DEFAULT_PERFORMANCE_SETTINGS）
      */
-    merge(config: Record<string, any>): void;
+    constructor(storageManager: StorageManager, settings?: PerformanceSettings);
     /**
-     * 获取当前存储的所有配置快照
-     * @returns 包含所有配置的普通对象
+     * 从持久化存储加载数据到内存缓存
      */
-    getAll(): Record<string, any>;
-}
-/** 全局配置管理器单例 */
-declare const configManager: ConfigManager;
-
-/** 插件错误边界组件属性 */
-interface Props {
-    /** 发生错误的插件 ID */
-    pluginId?: string;
-    /** 错误发生时的降级 UI */
-    fallback?: ReactNode;
-    /** 子组件内容 */
-    children: ReactNode;
-    /** 是否静默模式，开启后不显示任何错误 UI，仅记录日志 */
-    silent?: boolean;
-}
-/** 插件错误边界组件状态 */
-interface State {
-    /** 是否捕获到错误 */
-    hasError: boolean;
-    /** 捕获到的错误对象 */
-    error: Error | null;
-}
-/**
- * 插件错误边界组件
- * @description 核心组件，用于捕获子组件渲染过程中的 JavaScript 错误，记录日志并显示降级 UI。
- * 确保单个插件的运行异常不会导致整个主应用或其他插件崩溃。
- */
-declare class PluginErrorBoundary extends Component<Props, State> {
-    constructor(props: Props);
-    /**
-     * 从错误中派生状态
-     * @param error - 捕获到的错误
-     */
-    static getDerivedStateFromError(error: any): State;
-    /**
-     * 捕获到错误后的回调
-     * @param error - 错误对象
-     * @param errorInfo - 错误堆栈信息
+    private loadFromStorage;
+    /**
+     * 保存生命周期指标
+     * @param metric - 生命周期指标
      */
-    componentDidCatch(error: any, errorInfo: ErrorInfo): void;
+    saveLifecycleMetric(metric: LifecycleMetric): void;
     /**
-     * 重置错误状态，尝试重新渲染
+     * 保存运行时指标
+     * @param metric - 运行时指标
      */
-    handleRetry: () => void;
-    render(): string | number | boolean | Iterable<React.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
-}
-
-/** 插件插槽组件属性 */
-interface PluginSlotProps {
-    /** 插槽位置标识，决定渲染哪些插件扩展 */
-    slot: SlotPosition;
-    /** 传递给扩展组件的 Props 对象 */
-    props?: Record<string, any>;
-    /** 自定义容器类名 (Tailwind CSS) */
-    className?: string;
-    /** 自定义容器内联样式 */
-    style?: React.CSSProperties;
-    /**
-     * 自定义渲染函数
-     * @param item - 包含 key、组件和扩展元信息的对象
-     * @param index - 索引位置
+    saveRuntimeMetric(metric: RuntimeMetric): void;
+    /**
+     * 保存指标（通用方法，自动识别类型）
+     * @param metric - 指标数据
+     */
+    saveMetric(metric: LifecycleMetric | RuntimeMetric): void;
+    /**
+     * 强制执行生命周期数据上限（FIFO）
+     */
+    private enforceLifecycleLimit;
+    /**
+     * 强制执行运行时数据上限（FIFO）
+     */
+    private enforceRuntimeLimit;
+    /**
+     * 持久化生命周期数据
+     */
+    private persistLifecycle;
+    /**
+     * 持久化运行时数据
+     */
+    private persistRuntime;
+    /**
+     * 获取生命周期指标
+     * @param pluginId - 插件 ID（可选，不传则返回所有）
+     */
+    getLifecycleMetrics(pluginId?: string): LifecycleMetric[];
+    /**
+     * 获取运行时指标
+     * @param pluginId - 插件 ID（可选，不传则返回所有）
+     */
+    getRuntimeMetrics(pluginId?: string): RuntimeMetric[];
+    /**
+     * 清除性能数据
+     * @param pluginId - 插件 ID（可选，不传则清除所有）
+     */
+    clearMetrics(pluginId?: string): void;
+    /**
+     * 获取所有性能数据
+     */
+    getAllData(): PerformanceData;
+    /**
+     * 获取指定插件的性能数据
      */
-    renderItem?: (item: {
-        key: string;
-        component: React.ReactNode;
-        extension: PluginExtension;
-    }, index: number) => React.ReactNode;
-    /** 骨架屏组件，当插槽内无插件扩展时显示的占位 UI */
-    skeleton?: React.ReactNode;
-    /** 回退组件，当插槽内无插件扩展时显示的 UI，优先级高于 skeleton */
-    fallback?: React.ReactNode;
+    getPluginData(pluginId: string): PerformanceData;
 }
-/**
- * 插件插槽组件
- * @description UI 层的核心组件，用于在应用中声明一个“插槽”。
- * 它会自动根据 slot 标识从 PluginManager 中获取所有注册的插件扩展组件并按顺序渲染。
- * 支持订阅插件变更，实现动态热插拔。
- */
-declare const PluginSlot: React.FC<PluginSlotProps>;
 
 /**
- * 通用插槽骨架屏组件集合
- * @description 提供一组预定义的骨架屏 UI，用于在插件加载或插槽内容未准备好时提供更好的用户体验。
- */
-/**
- * 侧边栏图标骨架屏
- * @param expanded - 是否处于展开状态
- */
-declare const SidebarIconSkeleton: React.FC<{
-    expanded?: boolean;
-}>;
-/**
- * 状态栏项骨架屏
- */
-declare const StatusBarItemSkeleton: React.FC;
-/**
- * 头像骨架屏
+ * 性能计时器
+ * @description 用于测量代码块执行耗时，自动计算 duration 并保存到存储
  */
-declare const AvatarSkeleton: React.FC;
+declare class PerformanceTimer {
+    private startTime;
+    private phase;
+    private pluginId;
+    private storage;
+    /**
+     * 构造函数
+     * @param phase - 生命周期阶段
+     * @param pluginId - 插件 ID
+     * @param storage - 性能存储实例
+     */
+    constructor(phase: LifecyclePhase, pluginId: string, storage: PerformanceStorage);
+    /**
+     * 开始计时
+     */
+    start(): void;
+    /**
+     * 结束计时并保存结果
+     * @param success - 是否成功
+     * @param error - 错误信息（可选）
+     */
+    end(success: boolean, error?: string): void;
+}
 /**
- * 通用块级骨架屏
- * @param className - 自定义类名
+ * 性能数据采集器
+ * @description 负责性能数据的采集和记录，提供计时器创建和运行时指标记录功能
  */
-declare const BlockSkeleton: React.FC<{
-    className?: string;
-}>;
+declare class PerformanceCollector {
+    private storage;
+    /**
+     * 构造函数
+     * @param storage - 性能存储实例
+     */
+    constructor(storage: PerformanceStorage);
+    /**
+     * 开始测量指定生命周期阶段
+     * @param phase - 生命周期阶段
+     * @param pluginId - 插件 ID
+     * @returns PerformanceTimer 实例
+     */
+    startMeasure(phase: LifecyclePhase, pluginId: string): PerformanceTimer;
+    /**
+     * 记录运行时指标
+     * @param metric - 运行时指标（不包含 timestamp）
+     */
+    recordRuntimeMetric(metric: Omit<RuntimeMetric, 'timestamp'>): void;
+    /**
+     * 获取性能指标
+     * @param pluginId - 插件 ID（可选，不传则返回所有）
+     */
+    getMetrics(pluginId?: string): {
+        lifecycle: LifecycleMetric[];
+        runtime: RuntimeMetric[];
+    };
+    /**
+     * 清除性能数据
+     * @param pluginId - 插件 ID（可选，不传则清除所有）
+     */
+    clearMetrics(pluginId?: string): void;
+    /**
+     * 获取存储实例（供外部使用）
+     */
+    getStorage(): PerformanceStorage;
+}
+
 /**
- * 自动根据插槽位置匹配骨架屏
+ * @file plugin-runtime.ts
+ * @description 插件运行时，封装单个插件的生命周期（load/mount/unmount）、沙箱环境和隔离上下文
+ * @author ChatBI Team
  */
-declare const SlotSkeletons: React.FC<{
-    slot: string;
-    expanded?: boolean;
-}>;
 
 /**
- * 插件注册表接口
- * @description 键为插件 ID，值为一个返回插件定义的异步加载函数。
+ * 插件运行时类
+ * @description 为单个插件提供独立的运行环境，负责管理其生命周期、初始化沙箱环境并组装上下文对象。
  */
-interface PluginRegistry {
-    [pluginId: string]: () => Promise<any>;
+declare class PluginRuntime {
+    /** 插件定义对象 */
+    plugin: Plugin;
+    /** 传递给插件的上下文对象 */
+    context: PluginContext;
+    /** 存储沙箱隔离设施 */
+    private storageSandbox;
+    /** Window/全局对象沙箱隔离设施 */
+    private windowSandbox;
+    /** 是否已完成加载阶段 */
+    private isLoaded;
+    /** 是否已完成挂载阶段 */
+    private isMounted;
+    /** 运行时捕获的错误信息 */
+    private error;
+    /**
+     * 构造函数
+     * @param plugin - 插件定义对象
+     * @param sharedContext - 来自内核的共享上下文资源 (如 API 引擎、事件总线)
+     * @param storageManager - 全局存储管理器
+     */
+    constructor(plugin: Plugin, sharedContext: Record<string, any>, storageManager: StorageManager);
+    /**
+     * 检查插件是否已完成加载
+     */
+    isLoadedStatus(): boolean;
+    /**
+     * 执行插件的加载逻辑 (onLoad)
+     * @description 此阶段会自动注册插件声明的 API 配置，并调用插件的 onLoad 钩子。
+     * 用于执行非 UI 的初始化逻辑，如注册服务、拦截器等。
+     */
+    load(): Promise<void>;
+    /**
+     * 执行插件的挂载逻辑 (onMount)
+     * @description 此阶段会激活 Window 沙箱并调用插件的 onMount 钩子。
+     * 此时插件的 UI 组件（如有）即将或已经进入 DOM。
+     */
+    mount(): Promise<void>;
+    /**
+     * 执行插件的卸载逻辑 (onUnmount)
+     * @description 调用插件的 onUnmount 钩子并停用沙箱。
+     */
+    unmount(): Promise<void>;
+    /**
+     * 彻底销毁插件实例
+     * @description 卸载插件并重置加载状态。
+     */
+    destroy(): Promise<void>;
+    /**
+     * 设置运行时错误 (内部使用)
+     * @internal
+     */
+    _setError(error: Error | null): void;
+    /**
+     * 获取插件运行时错误
+     */
+    getError(): Error | null;
+    /**
+     * 获取插件当前运行状态
+     * @returns 'error' | 'mounted' | 'loaded' | 'initial'
+     */
+    get status(): "error" | "mounted" | "loaded" | "initial";
 }
+
 /**
- * 插件自动发现规则
+ * 生命周期监测器（装饰器模式）
+ * @description 通过代理模式包装 PluginRuntime，在生命周期各阶段自动记录耗时
  */
-interface DiscoveryRule {
+declare class LifecycleMonitor {
+    private runtime;
+    private collector;
     /**
-     * 路径匹配标识。
-     * @example 'plugins' 或 '@chatbi-plugins'
+     * 构造函数
+     * @param runtime - 插件运行时实例
+     * @param collector - 性能采集器实例
      */
-    pathSegment: string;
+    constructor(runtime: PluginRuntime, collector: PerformanceCollector);
     /**
-     * 生成插件 ID 时的前缀。
-     * @example '@chatbi-v/plugin'，最终生成如 '@chatbi-v/plugin-demo'
+     * 包装插件运行时，返回代理对象
+     * @returns 包装后的运行时对象
      */
-    idPrefix: string;
+    wrap(): PluginRuntime;
+    /**
+     * 包装指定方法，在执行前后记录耗时
+     * @param phase - 生命周期阶段
+     * @param originalMethod - 原始方法
+     */
+    private wrapMethod;
 }
 /**
- * 解析插件注册表
- * @description 核心逻辑：将 Vite 的 `import.meta.glob` 结果映射为标准的插件注册表。
- * 它会根据预定义的路径匹配规则，从文件路径中提取插件目录名，并拼接前缀生成唯一的插件 ID。
- *
- * @param options - 包含待处理模块和匹配规则的选项对象
- * @returns 解析后的 PluginRegistry 对象
+ * 创建生命周期监测器
+ * @param runtime - 插件运行时实例
+ * @param collector - 性能采集器实例
+ * @returns LifecycleMonitor 实例
  */
-declare const resolvePluginRegistry: (options: {
-    /** 原始模块映射 (来自 Vite glob) */
-    modules: Record<string, () => Promise<any>>;
-    /** 自定义发现规则 (可选) */
-    rules?: DiscoveryRule[];
-}) => PluginRegistry;
+declare function createLifecycleMonitor(runtime: PluginRuntime, collector: PerformanceCollector): LifecycleMonitor;
+
+/**
+ * @file performance/index.ts
+ * @description 性能监测模块统一导出
+ * @author ChatBI Team
+ */
+
+/**
+ * 性能监测系统工厂函数
+ * @param storageManager - 存储管理器实例
+ * @param settings - 性能设置（可选）
+ * @returns 包含 collector, storage, monitor 的对象
+ */
+declare function createPerformanceMonitor(storageManager: StorageManager, settings?: PerformanceSettings): {
+    collector: PerformanceCollector;
+    storage: PerformanceStorage;
+    createMonitor: (runtime: any) => LifecycleMonitor;
+};
 
-type EventCallback = (...args: any[]) => any;
+declare const PluginEvents: {
+    readonly LOAD: "plugin:load";
+    readonly LOADED: "plugin:loaded";
+    readonly MOUNT: "plugin:mount";
+    readonly MOUNTED: "plugin:mounted";
+    readonly UNMOUNT: "plugin:unmount";
+    readonly LOAD_FAILED: "plugin:load-failed";
+    readonly MOUNT_FAILED: "plugin:mount-failed";
+};
+declare const ConfigEvents: {
+    readonly CHANGE: "config:change";
+};
+/**
+ * 事件回调函数类型
+ * @param T 事件参数类型元组
+ * @returns void
+ */
+type EventCallback<T extends unknown[] = unknown[]> = (...args: T) => void;
 /**
  * 事件总线接口
  */
@@ -941,170 +1165,157 @@ interface EventBus {
      * @param callback 回调函数
      * @returns 取消订阅函数
      */
-    on(event: string, callback: EventCallback): () => void;
+    on<T extends unknown[]>(event: string, callback: EventCallback<T>): () => void;
     /**
      * 取消订阅
      * @param event 事件名称
      * @param callback 回调函数
      */
-    off(event: string, callback: EventCallback): void;
+    off<T extends unknown[]>(event: string, callback: EventCallback<T>): void;
     /**
      * 触发事件
      * @param event 事件名称
      * @param args 事件参数
      */
-    emit(event: string, ...args: any[]): void;
+    emit<T extends unknown[]>(event: string, ...args: T): void;
     /**
      * 订阅一次性事件
      * @param event 事件名称
      * @param callback 回调函数
      */
-    once(event: string, callback: EventCallback): void;
+    once<T extends unknown[]>(event: string, callback: EventCallback<T>): void;
 }
 declare class DefaultEventBus implements EventBus {
     private listeners;
-    on(event: string, callback: EventCallback): () => void;
-    off(event: string, callback: EventCallback): void;
-    emit(event: string, ...args: any[]): void;
-    once(event: string, callback: EventCallback): void;
+    on<T extends unknown[]>(event: string, callback: EventCallback<T>): () => void;
+    off<T extends unknown[]>(event: string, callback: EventCallback<T>): void;
+    emit<T extends unknown[]>(event: string, ...args: T): void;
+    once<T extends unknown[]>(event: string, callback: EventCallback<T>): void;
 }
 
 /**
- * 核心领域服务：存储管理器
- * @description 统一管理应用内所有的持久化存储资源。
- * 核心功能：
- * 1. 作用域隔离：通过前缀划分 `plugin`、`shared` 和 `system` 三个层级的存储空间。
- * 2. Schema 校验：支持注册存储描述，规范数据存取，避免键名冲突。
- * 3. 默认值与配置回退：支持从 Schema 默认值或 ConfigManager 中回退取值。
+ * 插件错误分类
+ */
+declare enum PluginErrorType {
+    /** 可恢复错误：网络波动、超时等，可以重试 */
+    RECOVERABLE = "recoverable",
+    /** 致命错误：语法错误、循环依赖等，无法通过重试恢复 */
+    FATAL = "fatal",
+    /** 配置错误：插件配置无效 */
+    CONFIG = "config",
+    /** 依赖错误：依赖插件不存在或版本不匹配 */
+    DEPENDENCY = "dependency"
+}
+/**
+ * 插件错误
  */
-declare class StorageManager {
-    /** 底层物理存储驱动 */
-    private baseStorage;
-    /** 插件 ID 与存储描述定义的映射关系 */
-    private schemas;
-    /** 内存缓存，减少 JSON 序列化和物理 IO 开销 */
-    private memoryCache;
+declare class PluginError extends Error {
+    pluginId: string;
+    type: PluginErrorType;
+    originalError?: Error | undefined;
+    retryCount: number;
+    constructor(pluginId: string, type: PluginErrorType, message: string, originalError?: Error | undefined, retryCount?: number);
+}
+/**
+ * 插件管理器
+ * @description 核心领域服务，负责插件的完整生命周期管理，包括扫描、注册、配置合并、状态切换及依赖解析。
+ */
+declare class PluginManager {
+    /** 全局事件总线，用于插件间及插件与内核间的异步通信 */
+    readonly eventBus: DefaultEventBus;
+    /** 存储管理服务，负责插件私有存储和系统级状态的持久化 */
+    private storageManager;
+    /** 插件 ID 到运行时实例的映射表 */
+    private runtimes;
+    /** 插件 ID 到原始插件定义对象的映射表 */
+    private plugins;
+    /** 收集到的所有插件路由配置 */
+    private routes;
+    /** 收集到的所有插件扩展点配置，按插槽位置分组 */
+    private extensions;
+    /** 插件的启用状态和排序信息的内存缓存 */
+    private pluginStates;
+    /** 扩展点缓存，避免重复计算 */
+    private memoizedExtensions;
+    /** 路由缓存 */
+    private memoizedRoutes;
+    /** 传递给插件的共享上下文缓存 */
+    private sharedContext;
+    /** 收集到的插件工具函数集合 */
+    private utils;
+    /** 插件强制启用标记（系统插件不可禁用） */
+    private pluginForces;
+    /** 插件懒加载标记 */
+    private pluginLazyInit;
+    /** 插件默认启用状态 */
+    private pluginDefaultEnabled;
+    /** 是否正在初始化插件中，防止重入导致多次加载 */
+    private isInitializing;
     /**
-     * 初始化存储管理器
-     * @param baseStorage - 符合 StoragePort 接口的物理存储驱动（如 LocalStorageAdapter）
+     * 构造函数
+     * @param storage - 底层存储适配器
      */
-    constructor(baseStorage: StoragePort);
+    constructor(storage: StoragePort);
     /**
-     * 注册插件的存储 Schema
-     * @param pluginId - 插件 ID
-     * @param schema - 存储项定义列表
+     * 从持久化存储中恢复插件状态 (启用/禁用、排序等)
      */
-    registerSchema(pluginId: string, schema: StorageItemSchema[]): void;
+    private loadStates;
     /**
-     * 内部校验方法：检查键名是否在 Schema 中声明
-     * @param pluginId - 插件 ID
-     * @param key - 待校验的键名
-     * @param scope - 目标作用域
+     * 将当前的插件状态持久化到存储中
      */
-    private validateKey;
+    private saveStates;
     /**
-     * 获取插件私有存储适配器
-     * @param pluginId - 插件 ID
-     * @returns 自动添加 `plugin:{id}:` 前缀的存储接口
+     * 订阅插件状态变更
+     * @param listener 回调函数，当插件状态变更时被调用
+     * @returns 取消订阅的函数
      */
-    getPluginStorage(pluginId: string): StoragePort;
+    subscribe(listener: () => void): () => void;
     /**
-     * 获取全局共享存储适配器
-     * @returns 自动添加 `shared:` 前缀的存储接口
+     * 订阅路由变更
+     * @param listener 回调函数，当路由变更时被调用
+     * @returns 取消订阅的函数
      */
-    getSharedStorage(): StoragePort;
+    subscribeToRoutes(listener: () => void): () => void;
     /**
-     * 获取系统内部存储适配器
-     * @returns 自动添加 `system:` 前缀的存储接口
+     * 获取存储管理器实例
+     * @returns StorageManager 实例
      */
-    getSystemStorage(): StoragePort;
+    getStorageManager(): StorageManager;
     /**
-     * 创建插件沙箱使用的复合存储对象
-     * @description 返回的对象封装了对私有存储和共享存储的操作。
-     * 特性：
-     * - 内存级 LRU 缓存：极大提升高频读写性能。
-     * - 自动序列化/反序列化 JSON。
-     * - 自动校验 Schema。
-     * - 取值回退逻辑：持久化存储 -> ConfigManager -> Schema 默认值。
-     *
-     * @param pluginId - 插件 ID
-     * @returns 包含 get/set/remove 及 shared 子对象的复合接口
+     * 用于调度状态更新的函数，可由外部宿主环境（如 React）注入
      */
-    getContextStorage(pluginId: string): {
-        shared: {
-            get: <T = any>(key: string) => T | null;
-            set: <T = any>(key: string, value: T) => void;
-            remove: (key: string) => void;
-        };
-        get: <T = any>(key: string) => T | null;
-        set: <T = any>(key: string, value: T) => void;
-        remove: (key: string) => void;
-    };
-}
-
-/**
- * 插件管理器
- * @description 核心领域服务，负责插件的完整生命周期管理，包括扫描、注册、配置合并、状态切换及依赖解析。
- */
-declare class PluginManager {
-    /** 全局事件总线，用于插件间及插件与内核间的异步通信 */
-    readonly eventBus: DefaultEventBus;
-    /** 存储管理服务，负责插件私有存储和系统级状态的持久化 */
-    private storageManager;
-    /** 插件 ID 到运行时实例的映射表 */
-    private runtimes;
-    /** 插件 ID 到原始插件定义对象的映射表 */
-    private plugins;
-    /** 收集到的所有插件路由配置 */
-    private routes;
-    /** 收集到的所有插件扩展点配置，按插槽位置分组 */
-    private extensions;
-    /** 插件的启用状态和排序信息的内存缓存 */
-    private pluginStates;
-    /** 状态变更监听器集合，支持按插槽过滤 */
-    private listeners;
-    /** 按插槽位置存储的监听器，用于精确通知 */
-    private slotListeners;
-    /** 扩展点缓存，避免重复计算 */
-    private memoizedExtensions;
-    /** 路由缓存 */
-    private memoizedRoutes;
-    /** 传递给插件的共享上下文缓存 */
-    private sharedContext;
-    /** 收集到的插件工具函数集合 */
-    private utils;
-    /** 是否正在初始化插件中，防止重入导致多次加载 */
-    private isInitializing;
+    private stateUpdateScheduler;
     /**
-     * 构造函数
-     * @param storage - 底层存储适配器
+     * 注入状态更新调度器
      */
-    constructor(storage: StoragePort);
+    setUpdateScheduler(scheduler: (callback: () => void) => void): void;
     /**
-     * 从持久化存储中恢复插件状态 (启用/禁用、排序等)
+     * 触发状态变更通知
+     * @description 统一使用 Zustand Store 进行状态管理，EventBus 仅用于一次性事件
+     * @param affectedSlot - (可选) 受影响的插槽位置
      */
-    private loadStates;
+    private notify;
     /**
-     * 将当前的插件状态持久化到存储中
+     * 获取指定插件
+     * @param pluginId 插件 ID
      */
-    private saveStates;
+    getPlugin(pluginId: string): Plugin | undefined;
     /**
-     * 订阅插件状态的变更通知
-     * @param listener - 变更时的回调函数
-     * @param slot - (可选) 指定监听的插槽位置，若提供则仅在该插槽受影响时通知
-     * @returns 取消订阅的函数
+     * 检查插件是否已注册
+     * @param pluginId - 插件 ID
      */
-    subscribe(listener: () => void, slot?: SlotPosition | string): () => void;
+    hasPlugin(pluginId: string): boolean;
     /**
-     * 获取存储管理器实例
-     * @returns StorageManager 实例
+     * 获取指定插件的运行时实例
+     * @param pluginId 插件 ID
+     * @returns 插件运行时实例，如果不存在则返回 undefined
      */
-    getStorageManager(): StorageManager;
+    getPluginRuntime(pluginId: string): PluginRuntime | undefined;
     /**
-     * 触发状态变更通知
-     * @param affectedSlot - (可选) 受影响的插槽位置
+     * 激活插件
+     * @param pluginId - 插件 ID
      */
-    private notify;
+    activate(pluginId: string): Promise<void>;
     /**
      * 获取所有已注册的插件列表
      * @description 结果会根据插件类型优先级和用户自定义排序进行排序
@@ -1126,6 +1337,18 @@ declare class PluginManager {
      * @returns 是否启用
      */
     isPluginEnabled(pluginId: string): boolean;
+    /**
+     * 检查插件是否可禁用
+     * @param pluginId - 插件 ID
+     * @returns 是否可禁用
+     */
+    canDisablePlugin(pluginId: string): boolean;
+    /**
+     * 检查插件是否应默认启用
+     * @param pluginId - 插件 ID
+     * @returns 是否默认启用
+     */
+    shouldEnableByDefault(pluginId: string): boolean;
     /**
      * 切换插件的启用/禁用状态
      * @description 禁用插件会立即触发其卸载生命周期并销毁运行时。
@@ -1133,6 +1356,21 @@ declare class PluginManager {
      * @param enabled - 目标状态
      */
     togglePlugin(pluginId: string, enabled: boolean): void;
+    /**
+     * 删除插件及其所有关联状态
+     * @description 完整清理流程：禁用 -> 卸载运行时 -> 清理存储 -> 清理配置 -> 清理状态 -> 通知
+     * @param pluginId - 插件 ID
+     * @param cleanupStorage - 是否清理存储（默认 true）
+     */
+    deletePlugin(pluginId: string, cleanupStorage?: boolean): Promise<void>;
+    /**
+     * 更新插件元数据和包地址
+     * @description 更新流程：禁用旧版本 -> 卸载 -> 更新元数据 -> 重新加载并激活
+     * @param pluginId - 插件 ID
+     * @param newManifest - 新的插件清单
+     * @param newBundleUrl - 新的包地址（可选，如果不改变则传 undefined）
+     */
+    updatePlugin(pluginId: string, newManifest: Partial<PluginManifest>, newBundleUrl?: string): Promise<void>;
     /**
      * 设置插件的显示排序权重
      * @param pluginId - 插件 ID
@@ -1221,6 +1459,14 @@ declare class PluginManager {
      * @param autoMount 是否自动挂载所有插件 (默认为 false，启用按需加载模式)
      */
     initPlugins(sharedContext?: Record<string, any>, autoMount?: boolean): Promise<void>;
+    /**
+     * 带重试机制的插件加载
+     */
+    private loadPluginWithRetry;
+    /**
+     * 带重试机制的插件挂载
+     */
+    private mountPluginWithRetry;
     /**
      * 获取排序后的插件 ID 列表 (处理依赖)
      */
@@ -1252,83 +1498,18 @@ declare class PluginManager {
     private handleFunctionalPlugin;
     private handleViewPlugin;
     private handleThemePlugin;
+    private handleRendererPlugin;
     private handleSystemPlugin;
+    /**
+     * 注册插件默认配置
+     */
+    private registerDefaultConfig;
 }
 /**
  * 全局插件管理器实例
  */
 declare const pluginManager: PluginManager;
 
-/**
- * @file plugin-runtime.ts
- * @description 插件运行时，封装单个插件的生命周期（load/mount/unmount）、沙箱环境和隔离上下文
- * @author ChatBI Team
- */
-
-/**
- * 插件运行时类
- * @description 为单个插件提供独立的运行环境，负责管理其生命周期、初始化沙箱环境并组装上下文对象。
- */
-declare class PluginRuntime {
-    /** 插件定义对象 */
-    plugin: Plugin;
-    /** 传递给插件的上下文对象 */
-    context: PluginContext;
-    /** 存储沙箱隔离设施 */
-    private storageSandbox;
-    /** Window/全局对象沙箱隔离设施 */
-    private windowSandbox;
-    /** 是否已完成加载阶段 */
-    private isLoaded;
-    /** 是否已完成挂载阶段 */
-    private isMounted;
-    /** 运行时捕获的错误信息 */
-    private error;
-    /**
-     * 构造函数
-     * @param plugin - 插件定义对象
-     * @param sharedContext - 来自内核的共享上下文资源 (如 API 引擎、事件总线)
-     * @param storageManager - 全局存储管理器
-     */
-    constructor(plugin: Plugin, sharedContext: Record<string, any>, storageManager: StorageManager);
-    /**
-     * 执行插件的加载逻辑 (onLoad)
-     * @description 此阶段会自动注册插件声明的 API 配置，并调用插件的 onLoad 钩子。
-     * 用于执行非 UI 的初始化逻辑，如注册服务、拦截器等。
-     */
-    load(): Promise<void>;
-    /**
-     * 执行插件的挂载逻辑 (onMount)
-     * @description 此阶段会激活 Window 沙箱并调用插件的 onMount 钩子。
-     * 此时插件的 UI 组件（如有）即将或已经进入 DOM。
-     */
-    mount(): Promise<void>;
-    /**
-     * 执行插件的卸载逻辑 (onUnmount)
-     * @description 调用插件的 onUnmount 钩子并停用沙箱。
-     */
-    unmount(): Promise<void>;
-    /**
-     * 彻底销毁插件实例
-     * @description 卸载插件并重置加载状态。
-     */
-    destroy(): Promise<void>;
-    /**
-     * 设置运行时错误 (内部使用)
-     * @internal
-     */
-    _setError(error: Error | null): void;
-    /**
-     * 获取插件运行时错误
-     */
-    getError(): Error | null;
-    /**
-     * 获取插件当前运行状态
-     * @returns 'error' | 'mounted' | 'loaded' | 'initial'
-     */
-    get status(): "error" | "mounted" | "loaded" | "initial";
-}
-
 /**
  * 插件隔离沙箱
  * @description 核心领域服务，为每个插件实例创建独立的运行上下文。
@@ -1369,6 +1550,147 @@ declare class PluginSandbox {
     get logger(): Logger;
 }
 
+/** 特性规则类型 */
+type RuleType = 'environment' | 'user' | 'percentage';
+/** 特性规则 */
+interface FeatureRule {
+    type: RuleType;
+    condition: string;
+    value?: string | number;
+}
+/** 特性配置 */
+interface FeatureConfig {
+    enabled: boolean;
+    rules: FeatureRule[];
+    namespace: string;
+    description?: string;
+}
+/** 迁移警告 */
+interface MigrationWarning {
+    pluginId: string;
+    currentVersion: string;
+    targetVersion: string;
+    steps: string[];
+}
+/** 废弃信息 */
+interface DeprecationInfo {
+    deprecatedIn: string;
+    willRemoveIn: string;
+    message: string;
+}
+/** 废弃警告 */
+interface DeprecationWarning {
+    feature: string;
+    info: DeprecationInfo;
+}
+declare const FEATURE_NAMESPACE_PREFIX = "chatbi:feature:";
+declare const STORAGE_KEY = "chatbi:feature:store";
+interface FeatureRegistryState {
+    features: Record<string, FeatureConfig>;
+    migrationPaths: Record<string, {
+        toVersion: string;
+        steps: string[];
+    }>;
+    deprecatedFeatures: Record<string, DeprecationInfo>;
+    setFeature: (name: string, config: Partial<FeatureConfig>) => void;
+    getFeature: (name: string) => FeatureConfig | undefined;
+    removeFeature: (name: string) => void;
+    isEnabled: (name: string, context?: {
+        userId?: string;
+        env?: string;
+    }) => boolean;
+    addMigrationPath: (fromVersion: string, toVersion: string, steps: string[]) => void;
+    checkMigration: (plugins: PluginManifest[]) => MigrationWarning[];
+    registerDeprecation: (feature: string, info: DeprecationInfo) => void;
+    checkDeprecations: (features?: string[]) => DeprecationWarning[];
+}
+declare function simpleHash$1(str: string): number;
+declare function evaluateRules$1(rules: FeatureRule[], context: {
+    userId?: string;
+    env?: string;
+}): boolean;
+declare const featureFlagsStore: Omit<zustand_vanilla.StoreApi<FeatureRegistryState>, "setState" | "persist"> & {
+    setState(partial: FeatureRegistryState | Partial<FeatureRegistryState> | ((state: FeatureRegistryState) => FeatureRegistryState | Partial<FeatureRegistryState>), replace?: false | undefined): unknown;
+    setState(state: FeatureRegistryState | ((state: FeatureRegistryState) => FeatureRegistryState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<FeatureRegistryState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: FeatureRegistryState) => void) => () => void;
+        onFinishHydration: (fn: (state: FeatureRegistryState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<FeatureRegistryState, unknown, unknown>>;
+    };
+};
+
+/**
+ * 规则引擎
+ * @description 提供特性规则的评估能力，支持环境、用户和百分比规则
+ */
+
+declare function simpleHash(str: string): number;
+/** 规则评估上下文 */
+interface RuleContext {
+    userId?: string;
+    env?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * 评估规则列表
+ * @param rules 规则数组
+ * @param context 评估上下文
+ * @returns 任意规则匹配返回 true，否则返回 false
+ */
+declare function evaluateRules(rules: FeatureRule[], context: RuleContext): boolean;
+/**
+ * 评估单条规则
+ * @param rule 规则
+ * @param context 评估上下文
+ * @returns 规则是否匹配
+ */
+declare function evaluateRule(rule: FeatureRule, context: RuleContext): boolean;
+/**
+ * 创建百分比规则
+ * @param percentage 百分比值 (0-100)
+ * @returns 百分比规则
+ */
+declare function createPercentageRule(percentage: number): FeatureRule;
+/**
+ * 创环境规则
+ * @param env 环境名称
+ * @returns 环境规则
+ */
+declare function createEnvironmentRule(env: string): FeatureRule;
+/**
+ * 创建用户规则
+ * @param userId 用户 ID
+ * @returns 用户规则
+ */
+declare function createUserRule(userId: string): FeatureRule;
+
+/**
+ * 核心状态 Store 接口
+ */
+interface CoreState {
+    /** 插件列表变更版本号，用于触发插件管理器的列表更新 */
+    pluginVersion: number;
+    /** 扩展点变更版本号（按插槽），用于实现插槽级别的精确更新 */
+    slotVersions: Record<string, number>;
+    /** 路由变更版本号 */
+    routeVersion: number;
+    /** 触发全局插件列表更新 */
+    notifyPluginsChanged: () => void;
+    /** 触发特定插槽的更新 */
+    notifySlotChanged: (slot: SlotPosition | string) => void;
+    /** 触发路由配置更新 */
+    notifyRoutesChanged: () => void;
+}
+/**
+ * 创建 Vanilla Store 实例
+ */
+declare const coreStore: zustand_vanilla.StoreApi<CoreState>;
+declare const coreStoreApi: zustand_vanilla.StoreApi<CoreState>;
+
 /**
  * 浏览器本地存储 (LocalStorage) 适配器
  * @description 实现 `StoragePort` 接口，封装了对原生 `localStorage` 的访问。
@@ -1417,342 +1739,908 @@ declare class LocalStorageAdapter implements StoragePort {
      * - 若定义了前缀：仅删除以该前缀开头的键名，不影响其他数据。
      * - 若未定义前缀：调用原生 `localStorage.clear()` 清空所有数据。
      */
-    clear(): void;
+    clear(): void;
+    /**
+     * 返回当前命名空间下的存储项总数
+     */
+    get length(): number;
+    /**
+     * 根据索引获取对应的原始键名
+     * @param index - 索引位置
+     * @returns 对应的业务键名，不存在则返回 null
+     */
+    key(index: number): string | null;
+}
+
+/**
+ * 作用域存储适配器 (ScopedStorageAdapter)
+ * @description 采用装饰器模式实现。它包装一个现有的 `StoragePort` 实例，
+ * 并为所有存储操作透明地注入一个前缀（命名空间），从而实现逻辑上的存储隔离。
+ * 常用于为插件分配独立的存储空间，而无需修改插件代码。
+ */
+declare class ScopedStorageAdapter implements StoragePort {
+    private underlyingStorage;
+    private prefix;
+    /**
+     * 初始化作用域适配器
+     * @param underlyingStorage - 被装饰的底层存储适配器实例
+     * @param prefix - 用于隔离的作用域前缀字符串
+     */
+    constructor(underlyingStorage: StoragePort, prefix: string);
+    /**
+     * 内部方法：计算实际存储的键名
+     * @param key - 业务层传入的原始键名
+     * @returns 拼接前缀后的物理键名
+     */
+    private getKey;
+    /**
+     * 内部方法：从物理键名还原业务键名
+     * @param namespacedKey - 物理存储中的完整键名
+     * @returns 还原后的原始键名，若前缀不匹配则返回 null
+     */
+    private getOriginalKey;
+    /**
+     * 读取当前作用域下的存储项
+     * @param key - 原始键名
+     * @returns 字符串内容，不存在则返回 null
+     */
+    getItem(key: string): string | null;
+    /**
+     * 写入当前作用域下的存储项
+     * @param key - 原始键名
+     * @param value - 字符串内容
+     */
+    setItem(key: string, value: string): void;
+    /**
+     * 移除当前作用域下的特定存储项
+     * @param key - 原始键名
+     */
+    removeItem(key: string): void;
+    /**
+     * 清空当前作用域下的所有存储项
+     * @description 仅删除匹配当前前缀的键值对，不会影响底层存储中的其他数据。
+     */
+    clear(): void;
+    /**
+     * 返回当前作用域下的存储项总数
+     */
+    get length(): number;
+    /**
+     * 根据索引获取当前作用域下的原始键名
+     * @param index - 索引位置
+     * @returns 对应的业务键名，不存在则返回 null
+     */
+    key(index: number): string | null;
+}
+
+/**
+ * 基于 Axios 的默认请求适配器
+ */
+declare class AxiosAdapter implements ApiAdapter {
+    private client;
+    constructor(baseURL?: string, timeout?: number);
+    request<T = any>(config: ApiRequestConfig): Promise<T>;
+    stream(config: ApiRequestConfig, callbacks: StreamCallbacks, _endpointConfig?: ApiEndpointConfig): Promise<void>;
+}
+
+/**
+ * API 引擎核心类
+ * @description 负责加载配置并执行请求，支持策略模式切换底层请求实现
+ */
+declare class ApiEngine {
+    private adapter;
+    private config;
+    private interceptors;
+    /** 可配置的成功码 */
+    private successCodes;
+    constructor(adapter?: ApiAdapter);
+    /**
+     * 注册拦截器
+     */
+    registerInterceptor(interceptor: ApiInterceptor): void;
+    /**
+     * 移除拦截器
+     */
+    unregisterInterceptor(interceptor: ApiInterceptor): void;
+    /**
+     * 设置成功码
+     */
+    setSuccessCodes(codes: string[]): void;
+    /**
+     * 切换请求适配器
+     * @param adapter 新的适配器实例
+     */
+    useAdapter(adapter: ApiAdapter): void;
+    /**
+     * 注册 API 配置
+     * @param config 配置对象
+     */
+    register(config: ApiConfig): void;
+    /**
+     * 获取接口配置
+     */
+    getEndpoint(module: string, action: string): ApiEndpointConfig | undefined;
+    /**
+     * 发起 API 请求
+     * @param module 模块名
+     * @param action 动作名
+     * @param data 请求数据 (Body 或 Query)
+     * @param options 请求选项
+     */
+    call<T = any>(module: string, action: string, data?: any, options?: RequestOptions): Promise<T>;
+    /**
+     * 发起流式请求
+     * @param module 模块名
+     * @param action 动作名
+     * @param data 请求数据
+     * @param options 请求选项
+     */
+    stream(module: string, action: string, data?: any, options?: RequestOptions): Promise<void>;
+    /**
+     * 准备请求配置，应用 URL 参数替换和请求拦截器
+     */
+    private prepareRequestConfig;
+    /**
+     * 应用所有请求拦截器
+     */
+    private applyRequestInterceptors;
+    /**
+     * 应用所有响应拦截器
+     * @returns 是否被劫持
+     */
+    private applyResponseInterceptors;
+    /**
+     * 检查 HTTP 状态码
+     */
+    private checkHttpStatus;
+    /**
+     * 提取响应数据
+     */
+    private extractResponseData;
+    /**
+     * 处理业务错误
+     */
+    private handleBusinessError;
+    /**
+     * 检查响应是否成功
+     */
+    protected isSuccess(response: any): boolean;
+    /**
+     * 处理响应错误
+     */
+    protected handleResponseError(response: any, context: any): void;
+    /**
+     * 判断是否为 BaseResponse
+     */
+    private isBaseResponse;
+    /**
+     * 严格判断是否为 AxiosResponse
+     */
+    private isAxiosResponse;
+    /**
+     * 创建拦截上下文
+     */
+    private createInterceptorContext;
+}
+declare const apiEngine: ApiEngine;
+
+/**
+ * 自动检测是否处于 Mock 模式
+ */
+declare function isMockMode(): boolean;
+/**
+ * 从文件模块映射中解析 API 配置
+ * @description 配合 Vite 的 import.meta.glob 使用，自动匹配定义文件和 Mock 文件
+ * @param definitionsMap API 定义文件映射 (import.meta.glob('./modules/*.ts', { eager: true }))
+ * @param mocksMap Mock 文件映射 (import.meta.glob('./modules/*.mock.ts', { eager: true }))
+ * @param useMock 是否启用 Mock (如果不传，将自动调用 isMockMode())
+ * @returns 合并后的 ApiConfig
+ */
+declare function resolveApiModules(definitionsMap: Record<string, any>, mocksMap?: Record<string, any>): ApiConfig;
+
+/**
+ * 沙箱选项
+ */
+interface SandboxOptions {
+    /** 严格模式：启用所有安全限制 */
+    strict?: boolean;
+    /** 自定义白名单 */
+    customWhitelist?: Record<string, boolean>;
+    /** 是否允许 DOM 访问 */
+    allowDOM?: boolean;
+    /** 是否允许网络请求 */
+    allowNetwork?: boolean;
+}
+/**
+ * ProxySandbox 类
+ * @description 基于 Proxy 的 JS 沙箱实现，模拟独立的 Window 环境
+ */
+declare class ProxySandbox {
+    /** 沙箱名称 */
+    name: string;
+    /** 代理后的 Window 对象 */
+    proxy: WindowProxy;
+    /** 沙箱是否激活 */
+    running: boolean;
+    /** 沙箱选项 */
+    private options;
+    /** 记录新增/修改的全局变量 */
+    private updatedValueSet;
+    /** 绑定函数的缓存池，避免重复 bind 带来的性能开销 */
+    private boundFunctionCache;
+    /** 副作用记录池 */
+    private effectPool;
+    /** 真实的 Window 对象 */
+    private globalContext;
+    /** 白名单全局变量（允许透传访问真实 Window） */
+    private static globalWhitelist;
+    constructor(name: string, options?: SandboxOptions, globalContext?: Window & typeof globalThis);
+    /**
+     * 激活沙箱
+     */
+    active(): void;
+    /**
+     * 销毁沙箱
+     */
+    inactive(): void;
+    /**
+     * 获取缓存的绑定函数，避免重复 bind
+     */
+    getBoundFunction(fn: Function, context: Window): Function;
+    /**
+     * 获取当前缓存大小（用于监控和调试）
+     */
+    getCacheSize(): number;
+    /**
+     * 在沙箱中执行代码
+     * @param code JS 代码字符串
+     * @param options 执行选项
+     * @returns 执行结果
+     * @description 使用 IIFE 模式执行代码，替代已废弃的 with 语句
+     */
+    eval(code: string, options?: {
+        useStrict?: boolean;
+    }): any;
+    /**
+     * 创建伪造的 Window 对象
+     */
+    private createFakeWindow;
+    private isConstructor;
+    private isNativeFunction;
+    /**
+     * 劫持全局副作用 API
+     */
+    private patchGlobalEffects;
+}
+
+/**
+ * 日期时间格式化工具类
+ */
+declare const dateUtils: {
+    /**
+     * 格式化日期为 YYYY-MM-DD
+     */
+    formatDate(date?: dayjs.ConfigType): string;
+    /**
+     * 格式化时间为 HH:mm:ss
+     */
+    formatTime(date?: dayjs.ConfigType): string;
+    /**
+     * 格式化日期时间为 YYYY-MM-DD HH:mm:ss
+     */
+    formatDateTime(date?: dayjs.ConfigType): string;
+    /**
+     * 获取当前时间戳（毫秒）
+     */
+    now(): number;
+    /**
+     * 获取相对时间（例如：几分钟前）
+     */
+    fromNow(date: dayjs.ConfigType): string;
+    /**
+     * 原始 dayjs 对象，用于更复杂的场景
+     */
+    dayjs: typeof dayjs;
+};
+
+type KeepStrategy = 'first' | 'last' | 'search' | 'hash';
+/**
+ * 把当前地址中所有出现的参数合并成一份。
+ * 重复 key 的处理策略：
+ *  - 'first'  : 按出现顺序，第一次的值生效
+ *  - 'last'   : 按出现顺序，最后一次的值生效（默认，最直观）
+ *  - 'search' : 只要 search 里出现过，就用 search 的
+ *  - 'hash'   : 只要 hash 里出现过，就用 hash 的
+ */
+declare function normalizeParams(strategy?: KeepStrategy): URLSearchParams;
+/**
+ * 清除 URL 中的特定参数并返回新的 URL
+ * @description 同时处理 search 和 hash 中的参数
+ */
+declare function cleanUrlParams(keysToRemove: string[]): string;
+
+declare const version = "1.0.0";
+
+/**
+ * Remote Plugin Source 类型定义
+ * @description 定义远程插件源接口和配置选项
+ */
+/**
+ * 远程插件源
+ * @description 表示一个远程插件仓库地址
+ */
+interface RemotePluginSource {
+    /** 唯一标识符 */
+    id: string;
+    /** 显示名称 */
+    name: string;
+    /** plugin.json URL */
+    url: string;
+    /** 是否启用 */
+    enabled?: boolean;
+}
+/**
+ * 缓存配置选项
+ */
+interface CacheOptions {
+    /** 缓存 TTL (毫秒)，默认 5 分钟 */
+    ttl: number;
+    /** 最大缓存条目数 */
+    maxSize?: number;
+}
+/**
+ * 重试配置选项
+ */
+interface RetryOptions {
+    /** 最大重试次数 */
+    maxRetries: number;
+    /** 重试延迟 (毫秒) */
+    retryDelay: number;
+    /** 自定义重试条件 */
+    retryCondition?: (error: any) => boolean;
+}
+/**
+ * 远程源配置选项
+ */
+interface RemoteSourceOptions {
+    /** 请求超时 (毫秒) */
+    timeout?: number;
+    /** 重试配置 */
+    retry?: RetryOptions;
+    /** 缓存配置 */
+    cache?: CacheOptions;
+}
+/**
+ * 缓存条目元数据
+ */
+interface CacheEntry<T = any> {
+    /** 缓存数据 */
+    data: T;
+    /** 创建时间戳 */
+    createdAt: number;
+    /** 最后访问时间戳 */
+    lastAccessedAt: number;
+    /** 过期时间戳 */
+    expiresAt: number;
+}
+/**
+ * 加载结果
+ */
+interface LoadResult<T = any> {
+    /** 是否成功 */
+    success: boolean;
+    /** 加载的数据 */
+    data?: T;
+    /** 加载错误 */
+    error?: LoadError;
+    /** 是否来自缓存 */
+    fromCache?: boolean;
+}
+/**
+ * 加载错误
+ */
+interface LoadError {
+    /** 错误代码 */
+    code: 'NETWORK' | 'TIMEOUT' | 'PARSE' | 'NOT_FOUND' | 'CACHE_ERROR' | 'VALIDATION_ERROR';
+    /** 错误消息 */
+    message: string;
+    /** 是否可重试 */
+    retryable: boolean;
+    /** 原始错误 */
+    originalError?: any;
+}
+
+/**
+ * 远程缓存管理器
+ * @description 管理远程插件Manifest的缓存，支持TTL和大小限制
+ */
+declare class RemoteCache<T = any> {
+    private cache;
+    private defaultTtl;
+    /**
+     * 创建远程缓存管理器
+     * @param options 缓存配置选项
+     */
+    constructor(options?: CacheOptions);
+    /**
+     * 获取缓存条目
+     * @param key 缓存键
+     * @returns 缓存条目，如果不存在或已过期返回 undefined
+     */
+    get(key: string): CacheEntry<T> | undefined;
+    /**
+     * 设置缓存条目
+     * @param key 缓存键
+     * @param data 要缓存的数据
+     * @param ttl 自定义 TTL (毫秒)，使用默认 TTL 如果未指定
+     */
+    set(key: string, data: T, ttl?: number): void;
+    /**
+     * 删除缓存条目
+     * @param key 缓存键
+     * @returns 是否成功删除
+     */
+    delete(key: string): boolean;
+    /**
+     * 清空所有缓存
+     */
+    clear(): void;
+    /**
+     * 检查缓存键是否存在
+     * @param key 缓存键
+     */
+    has(key: string): boolean;
     /**
-     * 返回当前命名空间下的存储项总数
+     * 获取缓存条目数量
      */
-    get length(): number;
+    size(): number;
     /**
-     * 根据索引获取对应的原始键名
-     * @param index - 索引位置
-     * @returns 对应的业务键名，不存在则返回 null
+     * 获取缓存条目的元数据（不触发访问时间更新）
+     * @param key 缓存键
      */
-    key(index: number): string | null;
+    getMetadata(key: string): CacheEntry<T> | undefined;
+    /**
+     * 更新缓存 TTL
+     * @param key 缓存键
+     * @param ttl 新 TTL (毫秒)
+     */
+    updateTTL(key: string, ttl: number): boolean;
 }
 
 /**
- * 作用域存储适配器 (ScopedStorageAdapter)
- * @description 采用装饰器模式实现。它包装一个现有的 `StoragePort` 实例，
- * 并为所有存储操作透明地注入一个前缀（命名空间），从而实现逻辑上的存储隔离。
- * 常用于为插件分配独立的存储空间，而无需修改插件代码。
+ * 远程插件加载器
+ * @description 管理远程插件源的添加、移除和 Manifest 加载
  */
-declare class ScopedStorageAdapter implements StoragePort {
-    private underlyingStorage;
-    private prefix;
+declare class RemoteLoader {
+    private sources;
+    private cache;
+    private retryStrategy;
+    private options;
     /**
-     * 初始化作用域适配器
-     * @param underlyingStorage - 被装饰的底层存储适配器实例
-     * @param prefix - 用于隔离的作用域前缀字符串
+     * 创建远程加载器
+     * @param options 远程源配置选项
      */
-    constructor(underlyingStorage: StoragePort, prefix: string);
+    constructor(options?: RemoteSourceOptions);
     /**
-     * 内部方法：计算实际存储的键名
-     * @param key - 业务层传入的原始键名
-     * @returns 拼接前缀后的物理键名
+     * 添加远程插件源
+     * @param source 远程插件源
      */
-    private getKey;
+    addSource(source: RemotePluginSource): void;
     /**
-     * 内部方法：从物理键名还原业务键名
-     * @param namespacedKey - 物理存储中的完整键名
-     * @returns 还原后的原始键名，若前缀不匹配则返回 null
+     * 移除远程插件源
+     * @param sourceId 插件源 ID
+     * @returns 是否成功移除
      */
-    private getOriginalKey;
+    removeSource(sourceId: string): boolean;
     /**
-     * 读取当前作用域下的存储项
-     * @param key - 原始键名
-     * @returns 字符串内容，不存在则返回 null
+     * 获取所有远程插件源
+     * @returns 远程插件源列表
      */
-    getItem(key: string): string | null;
+    getSources(): RemotePluginSource[];
     /**
-     * 写入当前作用域下的存储项
-     * @param key - 原始键名
-     * @param value - 字符串内容
+     * 获取指定远程插件源
+     * @param sourceId 插件源 ID
      */
-    setItem(key: string, value: string): void;
+    getSource(sourceId: string): RemotePluginSource | undefined;
     /**
-     * 移除当前作用域下的特定存储项
-     * @param key - 原始键名
+     * 启用/禁用远程插件源
+     * @param sourceId 插件源 ID
+     * @param enabled 是否启用
      */
-    removeItem(key: string): void;
+    setSourceEnabled(sourceId: string, enabled: boolean): boolean;
     /**
-     * 清空当前作用域下的所有存储项
-     * @description 仅删除匹配当前前缀的键值对，不会影响底层存储中的其他数据。
+     * 从远程加载插件 Manifest
+     * @param sourceId 插件源 ID
+     * @returns 加载结果
      */
-    clear(): void;
+    loadManifest<T = PluginManifest>(sourceId: string): Promise<LoadResult<T>>;
     /**
-     * 返回当前作用域下的存储项总数
+     * 带重试的请求
+     * @param url 请求 URL
+     * @param attempt 当前尝试次数
+     * @returns 响应数据
      */
-    get length(): number;
+    private fetchWithRetry;
     /**
-     * 根据索引获取当前作用域下的原始键名
-     * @param index - 索引位置
-     * @returns 对应的业务键名，不存在则返回 null
+     * 处理加载错误
+     * @param error 错误对象
+     * @returns 错误结果
      */
-    key(index: number): string | null;
+    private handleLoadError;
+    /**
+     * 创建错误结果
+     * @param code 错误代码
+     * @param message 错误消息
+     * @param retryable 是否可重试
+     * @returns 错误结果
+     */
+    private createErrorResult;
+    /**
+     * 清除缓存
+     * @param sourceId 可选，指定源 ID（只清除该源的缓存）
+     */
+    clearCache(sourceId?: string): void;
+    /**
+     * 获取缓存大小
+     */
+    getCacheSize(): number;
+    /**
+     * 睡眠
+     * @param ms 毫秒数
+     */
+    private sleep;
 }
 
-interface PluginProviderProps {
-    manager: PluginManager;
-    children: React.ReactNode;
-}
-declare const PluginProvider: React.FC<PluginProviderProps>;
-declare const usePluginManager: () => PluginManager;
+/**
+ * Retry Strategy 实现
+ * @description 提供重试延迟计算和错误判断逻辑
+ */
 
 /**
- * ProxySandbox 类
- * @description 基于 Proxy 的 JS 沙箱实现，模拟独立的 Window 环境
+ * 重试策略类
+ * @description 计算重试延迟、判断错误是否可重试
  */
-declare class ProxySandbox {
-    /** 沙箱名称 */
-    name: string;
-    /** 代理后的 Window 对象 */
-    proxy: WindowProxy;
-    /** 沙箱是否激活 */
-    running: boolean;
-    /** 记录新增/修改的全局变量 */
-    private updatedValueSet;
-    /** 绑定函数的缓存池，避免重复 bind 带来的性能开销 */
-    private boundFunctionCache;
-    /** 副作用记录池 */
-    private effectPool;
-    /** 真实的 Window 对象 */
-    private globalContext;
-    /** 白名单全局变量（允许透传访问真实 Window） */
-    private static globalWhitelist;
-    constructor(name: string, globalContext?: Window & typeof globalThis);
+declare class RetryStrategy {
+    private defaultOptions;
     /**
-     * 激活沙箱
+     * 创建重试策略
+     * @param options 重试配置选项
      */
-    active(): void;
+    constructor(options?: RetryOptions);
     /**
-     * 销毁沙箱
+     * 计算重试延迟（指数退避）
+     * @param attempt 当前尝试次数 (从 1 开始)
+     * @returns 延迟毫秒数
      */
-    inactive(): void;
+    calculateDelay(attempt: number): number;
     /**
-     * 在沙箱中执行代码
-     * @param code JS 代码字符串
-     * @returns 执行结果
+     * 判断错误是否可重试
+     * @param error 错误对象
+     * @returns 是否可重试
      */
-    eval(code: string): any;
+    isRetryable(error: any): boolean;
     /**
-     * 创建伪造的 Window 对象
+     * 默认重试条件判断
+     * @param error 错误对象
+     * @returns 是否可重试
      */
-    private createFakeWindow;
-    private isConstructor;
-    private isNativeFunction;
+    private defaultRetryCondition;
     /**
-     * 劫持全局副作用 API
+     * 获取最大重试次数
      */
-    private patchGlobalEffects;
+    getMaxRetries(): number;
+    /**
+     * 获取基础重试延迟
+     */
+    getBaseDelay(): number;
 }
 
+/** 插件依赖输入 */
+interface PluginDependencyInput {
+    id: string;
+    dependencies: Dependency[];
+}
+/** 共享依赖检测结果 */
+interface SharedDependencyResult {
+    /** 包 ID */
+    packageId: string;
+    /** 请求的版本列表 */
+    requestedVersions: string[];
+    /** 解析后的版本 */
+    resolvedVersion: string;
+    /** 请求者列表 */
+    requestedBy: string[];
+    /** 是否有冲突 */
+    hasConflict: boolean;
+}
 /**
- * 日期时间格式化工具类
+ * 共享依赖检测器
+ * @description 识别多个插件共享的 npm 包，检查版本冲突，使用最高版本策略解决
  */
-declare const dateUtils: {
+declare class SharedDepsDetector {
     /**
-     * 格式化日期为 YYYY-MM-DD
+     * 检测共享依赖
+     * @param plugins 插件列表
+     * @returns 共享依赖检测结果
      */
-    formatDate(date?: dayjs.ConfigType): string;
+    detect(plugins: PluginDependencyInput[]): SharedDependencyResult[];
     /**
-     * 格式化时间为 HH:mm:ss
+     * 检查版本是否冲突
+     * @param versions 版本列表
+     * @returns 是否有冲突
      */
-    formatTime(date?: dayjs.ConfigType): string;
+    private checkConflict;
     /**
-     * 格式化日期时间为 YYYY-MM-DD HH:mm:ss
+     * 最高版本策略
+     * @param versions 版本列表
+     * @returns 最高兼容版本
      */
-    formatDateTime(date?: dayjs.ConfigType): string;
+    resolveHighest(versions: string[]): string;
     /**
-     * 获取当前时间戳（毫秒）
+     * 最低版本策略
+     * @param versions 版本列表
+     * @returns 最低兼容版本
      */
-    now(): number;
+    resolveLowest(versions: string[]): string;
+}
+
+/** 冲突解决结果 */
+interface ConflictResolution {
+    /** 包 ID */
+    packageId: string;
+    /** 请求的版本列表 */
+    requestedVersions: string[];
+    /** 解析后的版本 */
+    resolvedVersion: string;
+    /** 解决策略 */
+    strategy: 'highest' | 'lowest' | 'user-selected';
+    /** 请求者列表 */
+    requestedBy: string[];
+}
+/**
+ * 版本冲突解决器
+ * @description 使用最高版本策略 (默认) 解决版本冲突
+ */
+declare class ConflictResolver {
     /**
-     * 获取相对时间（例如：几分钟前）
+     * 解决版本冲突
+     * @param deps 共享依赖检测结果
+     * @param strategy 解决策略，默认 highest
+     * @returns 冲突解决结果
      */
-    fromNow(date: dayjs.ConfigType): string;
+    resolve(deps: SharedDependencyResult[], strategy?: 'highest' | 'lowest'): ConflictResolution[];
     /**
-     * 原始 dayjs 对象，用于更复杂的场景
+     * 使用最高版本策略解决
+     * @param dep 共享依赖
+     * @returns 解决的版本
      */
-    dayjs: typeof dayjs;
-};
+    resolveHighest(dep: SharedDependencyResult): string;
+    /**
+     * 使用最低版本策略解决
+     * @param dep 共享依赖
+     * @returns 解决的版本
+     */
+    resolveLowest(dep: SharedDependencyResult): string;
+    /**
+     * 使用 maxSatisfying 解析版本范围
+     * @param range 版本范围
+     * @param versions 可用版本列表
+     * @returns 满足范围的最高版本
+     */
+    resolveWithRange(range: string, versions: string[]): string | null;
+}
 
 /**
- * 日志等级枚举
+ * 循环依赖检测
+ * @description 使用 DFS 检测插件依赖中的循环引用，生成警告日志
  */
-declare enum LogLevel {
-    /** 调试级别：输出最详尽的信息 */
-    DEBUG = 0,
-    /** 信息级别：输出重要的运行状态 */
-    INFO = 1,
-    /** 警告级别：输出潜在的问题，但不影响运行 */
-    WARN = 2,
-    /** 错误级别：输出严重的运行异常 */
-    ERROR = 3,
-    /** 禁用日志：不输出任何信息 */
-    NONE = 4
+
+/** 插件依赖输入 */
+interface CycleDetectorInput {
+    id: string;
+    dependencies: Dependency[];
+}
+/** 循环警告 */
+interface CycleWarning {
+    /** 循环路径 */
+    cycle: string[];
+    /** 完整路径 */
+    path: string[];
 }
 /**
- * 日志工具类
- * @description 核心工具类，提供统一的日志输出格式 `[Prefix] Message`。
- * 支持通过 `LogLevel` 进行全局过滤。
- * 支持日志缓冲和自动分组，以减少控制台噪音。
- * 支持浏览器端 CSS 样式和 Node.js 端 ANSI 颜色。
+ * 循环依赖检测器
+ * @description 使用 DFS 检测循环依赖，生成警告但不阻断加载
  */
-declare class Logger {
-    /** 全局静态日志等级，所有实例共享 */
-    private static level;
-    /** 日志缓冲区 */
-    private static buffer;
-    /** 缓冲输出防抖定时器 */
-    private static flushTimer;
-    /** 缓冲时间窗口 (ms) */
-    private static FLUSH_INTERVAL;
-    /** 是否启用缓冲模式 */
-    private static bufferEnabled;
-    /** 是否为浏览器环境 */
-    private static isBrowser;
-    /** 当前实例的业务模块前缀 */
-    private prefix;
-    /** 实例特定的颜色 */
-    private color;
+declare class CycleDetector {
     /**
-     * 构造函数
-     * @param prefix - 业务模块前缀，默认为 'App'
+     * 检测循环依赖
+     * @param plugins 插件列表
+     * @returns 循环警告列表
      */
-    constructor(prefix?: string);
+    detect(plugins: CycleDetectorInput[]): CycleWarning[];
     /**
-     * 静态方法：设置全局日志输出等级
-     * @param level - 目标日志等级
+     * 从依赖图检测循环
+     * @param graph 依赖图
+     * @returns 循环警告列表
      */
-    static setLevel(level: LogLevel): void;
+    detectFromGraph(graph: Map<string, string[]>): CycleWarning[];
     /**
-     * 静态方法：启用或禁用日志缓冲
-     * @param enabled - 是否启用
+     * 生成循环警告消息
+     * @param warning 循环警告
+     * @returns 警告消息
      */
-    static setBufferEnabled(enabled: boolean): void;
+    formatWarning(warning: CycleWarning): string;
     /**
-     * 静态方法：获取当前全局日志等级
-     * @returns 当前生效的全局日志等级
+     * 格式化所有警告
+     * @param warnings 循环警告列表
+     * @returns 警告消息列表
      */
-    static getLevel(): LogLevel;
+    formatWarnings(warnings: CycleWarning[]): string[];
+}
+
+/**
+ * 依赖图构建器
+ * @description 提供插件依赖拓扑构建、依赖查询功能
+ */
+/** 依赖节点 */
+interface DependencyNode {
+    /** 节点 ID (插件或包名) */
+    id: string;
+    /** 直接依赖列表 */
+    dependencies: string[];
+    /** 版本 */
+    version: string;
+}
+/** 依赖边 */
+interface DependencyEdge {
+    from: string;
+    to: string;
+}
+/**
+ * 依赖图
+ * @description 构建和管理插件依赖拓扑
+ */
+declare class DependencyGraph {
+    private nodes;
+    private edges;
     /**
-     * 格式化输出前缀
+     * 添加依赖节点
+     * @param node 依赖节点
      */
-    private getFormattedPrefix;
+    addNode(node: DependencyNode): void;
     /**
-     * 生成分组标题参数
+     * 添加依赖边
+     * @param from 依赖者 ID
+     * @param to 被依赖者 ID
      */
-    private static getGroupTitleArgs;
+    addEdge(from: string, to: string): void;
     /**
-     * 内部方法：将日志推入缓冲区或直接输出
+     * 获取依赖指定包的所有插件
+     * @param packageId 包 ID
+     * @returns 依赖该包的插件列表
      */
-    private log;
+    getDependents(packageId: string): string[];
     /**
-     * 静态方法：刷新缓冲区，分组输出日志
+     * 获取指定插件的所有依赖
+     * @param pluginId 插件 ID
+     * @returns 依赖列表
      */
-    static flush(): void;
+    getDependencies(pluginId: string): string[];
     /**
-     * 打印 DEBUG 级别日志
+     * 获取完整依赖图
+     * @returns 节点 ID 到依赖列表的映射
      */
-    debug(...args: any[]): void;
+    getGraph(): Map<string, string[]>;
     /**
-     * 打印 INFO 级别日志
+     * 获取所有节点
+     * @returns 节点列表
      */
-    info(...args: any[]): void;
+    getNodes(): DependencyNode[];
     /**
-     * 打印 WARN 级别日志
+     * 获取所有边
+     * @returns 边列表
      */
-    warn(...args: any[]): void;
+    getEdges(): DependencyEdge[];
     /**
-     * 打印 ERROR 级别日志
+     * 检查节点是否存在
+     * @param id 节点 ID
+     * @returns 是否存在
      */
-    error(...args: any[]): void;
+    hasNode(id: string): boolean;
     /**
-     * 开始一个日志控制台分组
+     * 获取节点
+     * @param id 节点 ID
+     * @returns 节点，不存在返回 undefined
      */
-    group(label: string, collapsed?: boolean): void;
+    getNode(id: string): DependencyNode | undefined;
     /**
-     * 结束当前日志控制台分组
+     * 清空图
      */
-    groupEnd(): void;
+    clear(): void;
+    /**
+     * 获取图的大小
+     * @returns 节点数量
+     */
+    size(): number;
 }
-/** 默认 Logger 实例 */
-declare const logger: Logger;
-/**
- * 创建带特定前缀的 Logger 实例
- * @param prefix 日志前缀
- * @returns Logger 实例
- */
-declare const createLogger: (prefix: string) => Logger;
-
-type KeepStrategy = 'first' | 'last' | 'search' | 'hash';
-/**
- * 把当前地址中所有出现的参数合并成一份。
- * 重复 key 的处理策略：
- *  - 'first'  : 按出现顺序，第一次的值生效
- *  - 'last'   : 按出现顺序，最后一次的值生效（默认，最直观）
- *  - 'search' : 只要 search 里出现过，就用 search 的
- *  - 'hash'   : 只要 hash 里出现过，就用 hash 的
- */
-declare function normalizeParams(strategy?: KeepStrategy): URLSearchParams;
-/**
- * 清除 URL 中的特定参数并返回新的 URL
- * @description 同时处理 search 和 hash 中的参数
- */
-declare function cleanUrlParams(keysToRemove: string[]): string;
-
-declare const version = "1.0.0";
-
-/** 插件加载 Hook 的配置选项 */
-interface PluginLoaderOptions {
-    /** 插件发现规则，定义如何从模块列表中识别插件 */
-    discoveryRules?: any[];
-    /** 插件模块映射，通常由 Vite 的 `import.meta.glob` 生成，键为路径，值为加载函数 */
-    modules?: Record<string, () => Promise<any>>;
-    /** 预注册的插件注册表，用于手动指定插件加载逻辑，优先级高于自动发现 */
-    registry?: Record<string, () => Promise<any>>;
-    /** 插件的业务配置映射，键为插件 ID */
-    pluginConfigs: Record<string, any>;
-    /** 初始化的共享上下文服务，将注入到每个插件的 onLoad 中 */
-    sharedContext?: Record<string, any>;
-    /** 系统级全局配置，如标题、版本号、Logo 等 */
-    systemConfig?: Record<string, any>;
-    /** 资源发现的基础 URL，默认为当前 window.location.origin */
-    baseUrl?: string;
-}
-/**
- * 核心 Hook：通用插件加载器
- * @description 负责应用启动时的插件全生命周期管理：
- * 1. 自动发现：解析 modules 并根据规则识别插件。
- * 2. 注册：将插件信息录入 PluginManager。
- * 3. 加载：调用插件的加载逻辑 (onLoad)。
- * 4. 初始化：调用插件的挂载逻辑 (onMount)。
- * 5. 响应式更新：订阅插件状态变更并触发 UI 刷新。
- *
- * @param options - 加载配置项
- * @returns { pluginsLoaded: boolean, pluginVersion: number }
- * - pluginsLoaded: 插件是否已全部完成初始化
- * - pluginVersion: 插件状态版本号，用于强制触发依赖插件状态的组件重渲染
- */
-declare const usePluginLoader: (options: PluginLoaderOptions) => {
-    pluginsLoaded: boolean;
-    pluginVersion: number;
-};
 
+/** npm 包元数据 */
+interface NpmPackageMeta {
+    name: string;
+    versions: Record<string, unknown>;
+    'dist-tags': Record<string, string>;
+    time?: Record<string, string>;
+}
+/** 版本信息 */
+interface VersionInfo {
+    version: string;
+    date?: string;
+    deprecated?: boolean;
+}
 /**
- * Hook 配置选项
+ * NPM Registry 客户端
+ * @description 集成 npm Registry API，支持包元数据查询、版本解析和缓存
  */
-interface UseStorageStateOptions<T> {
-    defaultValue?: T;
-    scope?: 'plugin' | 'shared';
+declare class NpmRegistry {
+    private client;
+    private cache;
+    /**
+     * 创建 NPM Registry 客户端
+     * @param baseUrl Registry 基础 URL，默认 https://registry.npmjs.org
+     */
+    constructor(baseUrl?: string);
+    /**
+     * 获取包元数据
+     * @param packageName 包名
+     * @param useCache 是否使用缓存，默认 true
+     * @returns 包元数据，不存在返回 null
+     */
+    getPackageMeta(packageName: string, useCache?: boolean): Promise<NpmPackageMeta | null>;
+    /**
+     * 获取包的所有版本
+     * @param packageName 包名
+     * @returns 版本列表
+     */
+    getVersions(packageName: string): Promise<string[]>;
+    /**
+     * 获取包的最新版本
+     * @param packageName 包名
+     * @returns 最新版本，不存在返回 null
+     */
+    getLatestVersion(packageName: string): Promise<string | null>;
+    /**
+     * 从版本范围解析最佳版本
+     * @param packageName 包名
+     * @param range 版本范围 (如 ^1.0.0, >=1.0.0)
+     * @returns 满足范围的最高版本，不存在返回 null
+     */
+    resolveVersion(packageName: string, range: string): Promise<string | null>;
+    /**
+     * 获取指定版本的详细信息
+     * @param packageName 包名
+     * @param version 版本号
+     * @returns 版本信息，不存在返回 null
+     */
+    getVersionInfo(packageName: string, version: string): Promise<VersionInfo | null>;
+    /**
+     * 批量解析依赖
+     * @param dependencies 依赖列表 [{ id, version }]
+     * @returns 包名到解析后版本的映射
+     */
+    resolveDependencies(dependencies: Array<{
+        id: string;
+        version: string;
+    }>): Promise<Map<string, string>>;
+    /**
+     * 清除缓存
+     * @param packageName 包名，不提供则清除所有缓存
+     */
+    clearCache(packageName?: string): void;
 }
 /**
- * 统一存储状态 Hook
- * @description 提供与 StorageManager 和 Schema Registry 集成的持久化状态 Hook。
- * @param pluginId 定义该 Key 的插件 ID
- * @param key 存储键名 (必须在 Schema 中注册)
- * @param options 配置项，包含默认值和作用域
+ * 获取默认 Registry 实例
+ * @returns 默认 NpmRegistry 实例
  */
-declare function useStorageState<T>(pluginId: string, key: string, options?: UseStorageStateOptions<T>): [T, (value: T | ((val: T) => T)) => void];
+declare function getDefaultRegistry(): NpmRegistry;
 
-export { type ApiAdapter, type ApiConfig, type ApiEndpointConfig, ApiEngine, type ApiInterceptor, ApiProvider, type ApiProviderProps, type ApiRequestConfig, type ApiResponseContext, AvatarSkeleton, AxiosAdapter, BasePlugin, type BaseResponse, BlockSkeleton, ConfigManager, DefaultEventBus, type DiscoveryRule, type ErrorStrategy, type EventBus, type EventBusPort, type EventCallback, type HttpMethod, LocalStorageAdapter, LogLevel, Logger, PLUGIN_TYPES, type Plugin, type PluginCapabilities, type PluginConfigItem, type PluginContext, PluginErrorBoundary, type PluginExtension, type PluginLifecycle, type PluginLoaderOptions, PluginManager, type PluginMetadata, PluginProvider, type PluginProviderProps, type PluginRegistry, PluginRuntime, PluginSandbox, PluginSlot, type PluginStorage, type PluginType, ProxySandbox, type RequestOptions, type RouteConfig, SUCCESS_CODE, type Scene, ScopedStorageAdapter, ServiceRegistry, SidebarIconSkeleton, Slot, type SlotPosition, SlotSkeletons, type SlotType, StatusBarItemSkeleton, type StorageItemSchema, StorageManager, type StoragePort, type StreamCallbacks, type TypedStorage, type UseStorageStateOptions, apiEngine, cleanUrlParams, configManager, createLogger, dateUtils, definePlugin, isMockMode, logger, normalizeParams, pluginManager, resolveApiModules, resolvePluginRegistry, serviceRegistry, useApi, usePluginLoader, usePluginManager, useStorageState, version };
+export { type AIChunk, type AIMessage, type AIProvider, type AITool, ApiAdapter, ApiConfig, ApiEndpointConfig, ApiEngine, ApiInterceptor, ApiRequestConfig, AxiosAdapter, type BaseResponse, type CacheEntry, type CacheOptions, type ChatOptions, ConfigEvents, type ConfigItemDefinition, ConfigManager, type ConflictResolution, ConflictResolver, CoreError, CoreErrorCode, CoreErrorStrategy, type CoreState, CycleDetector, type CycleDetectorInput, type CycleWarning, DEFAULT_PERFORMANCE_SETTINGS, type DeepReadonly, DefaultEventBus, Dependency, type DependencyEdge, DependencyGraph, type DependencyNode, type DeprecationInfo, type DeprecationWarning, type DiscoveryRule, type ErrorHandlerOptions, type EventBus, type EventCallback, FEATURE_NAMESPACE_PREFIX, type FeatureConfig, type FeatureRegistryState, type FeatureRule, type FunctionCallResult, type LifecycleMetric, LifecycleMonitor, type LifecyclePhase, type LoadError, type LoadResult, LocalStorageAdapter, LogLevel, Logger, type MigrationWarning, MockAIProvider, type NpmPackageMeta, NpmRegistry, OpenAIProvider, PerformanceCollector, type PerformanceData, type PerformanceSettings, PerformanceStorage, PerformanceTimer, Plugin, PluginCapabilities, PluginContext, type PluginDependencyInput, PluginError, PluginErrorType, PluginEvents, PluginExtension, PluginManager, PluginManifest, type PluginManifestType, type PluginRegistry, PluginRuntime, PluginSandbox, ProxySandbox, RemoteCache, RemoteLoader, type RemotePluginSource, type RemoteSourceOptions, RequestOptions, type RetryOptions, RetryStrategy, RouteConfig, type RoutePath, RoutePathSchema, type RuleContext, type RuleType, type RuntimeMetric, STORAGE_KEY, SUCCESS_CODE, type SafePluginConfig, type SandboxOptions, type Scene, ScopedStorageAdapter, type SemVer, SemVerSchema, ServiceRegistry, type Session, SessionLocalStorageAdapter, SessionManager, type SessionManagerInterface, type SessionStorage, type SharedDependencyResult, SharedDepsDetector, SlotPosition, StorageItemSchema, StorageManager, StoragePort, StreamCallbacks, type ToolCall, ToolRegistry, type VersionInfo, aiStore, apiEngine, cleanUrlParams, configManager, coreStore, coreStoreApi, createAIStore, createEnvironmentRule, createLifecycleMonitor, createLogger, createPercentageRule, createPerformanceMonitor, createRoutePath, createSemVer, createUserRule, dateUtils, evaluateRules as evaluateFeatureRules, evaluateRule, evaluateRules$1 as evaluateRules, featureFlagsStore, getDefaultRegistry, handleError, simpleHash as hashString, isMockMode, isPluginManifest, isRoutePath, isSemVer, logger, normalizeParams, pluginManager, resolveApiModules, resolvePluginRegistry, serviceRegistry, simpleHash$1 as simpleHash, version };