@djvlc/runtime-core 1.0.0 → 1.0.2

package/dist/index.d.cts

@@ -1,10 +1,6 @@
-import { RuntimeError, RuntimeEvent, PerformanceMetric, PageResolveResult, ComponentLoadResult, PageSchema, HostAPI, ErrorCode, ManifestItem, PageManifest, EventBus as EventBus$1, RuntimeEventType, ComponentEvent, ExpressionNode, ExpressionContext, ExpressionValidationResult, RuntimeContext, DataQueryResponse, ActionExecuteResponse, NavigateOptions, DialogOptions, ToastOptions, TrackEvent, ClipboardResult, StorageOptions, BlockedComponent } from '@djvlc/contracts-types';
-export { ActionExecuteResponse, ComponentInstance, ComponentLoadResult, ComponentLoadStatus, DataQueryResponse, ExpressionContext, HostAPI, ManifestItem, PageManifest, PageResolveResult, PageSchema, PerformanceMetric, RuntimeConfig, RuntimeError, RuntimeEvent, RuntimeEventType } from '@djvlc/contracts-types';
-
-/**
- * Runtime 类型定义
- * 基于 @djvlc/contracts-types 扩展的运行时特有类型
- */
+import * as _djvlc_contracts_types from '@djvlc/contracts-types';
+import { ExpressionContext, Expression, ExpressionValidationResult, ActionRef, EventHandler, HostApi, NavigateOptions, TrackEvent, ActionResult, DialogOptions, DialogResult, ToastOptions, ClipboardApi, StorageApi, ShareOptions, ShareResult, ConfirmOptions, ActionSheetOptions, ActionSheetResult, PreviewImageOptions, ScanCodeResult, ComponentContext, ErrorCode, ManifestItem, PageManifest, CapabilityName, PageSchema, PageLifecycle } from '@djvlc/contracts-types';
+export { ActionExecuteRequest, ActionExecuteResponse, ActionPolicy, ActionRef, ActionResult, AnyValueOrExpression, BlockedComponentInfo, BuiltinActionType, CapabilityDeclaration, CompatInfo, ComponentContext, ComponentMeta, ComponentNode, DataBinding, DataLoadStrategy, DataQueryRequest, DataQueryResponse, DialogOptions, DialogResult, ErrorCode, ErrorMessages, EventDeclaration, EventHandler, Expression, ExpressionContext, ExpressionLocal, ExpressionMeta, ExpressionType, ExpressionValidationResult, HostApi as HostAPI, HostApi, JsonValue, LayoutConfig, LayoutValues, LoopConfig, ManifestItem, NavigateOptions, NodeStyleConfig, PageConfig, PageLifecycle, PageManifest, PageMeta, PageSEO, PageSchema, PageState, PropDefinition, PropsSchema, RuntimeSpec, SchemaVersion, SemVer, StateFieldDefinition, ToastOptions, TrackEvent, UniqueId } from '@djvlc/contracts-types';
 
 /**
  * 运行时初始化选项
@@ -12,7 +8,7 @@ export { ActionExecuteResponse, ComponentInstance, ComponentLoadResult, Componen
 interface RuntimeOptions {
     /** 容器元素或选择器 */
     container: string | HTMLElement;
-    /** 页面 UID */
+    /** 页面 UID（pageId） */
     pageUid: string;
     /** API 基础 URL */
     apiBaseUrl: string;
@@ -34,28 +30,34 @@ interface RuntimeOptions {
     enableSRI?: boolean;
     /** 自定义请求头 */
     headers?: Record<string, string>;
+    /** 应用 ID */
+    appId?: string;
+    /** 环境 */
+    env?: 'development' | 'staging' | 'production';
     /** 错误回调 */
     onError?: (error: RuntimeError) => void;
     /** 事件回调 */
     onEvent?: (event: RuntimeEvent) => void;
     /** 性能指标回调 */
     onMetric?: (metric: PerformanceMetric) => void;
+    /** 加载完成回调 */
+    onLoad?: (data: PageResolveResult) => void;
 }
 /**
  * 运行时阶段
  */
-type RuntimePhase = 'idle' | 'resolving' | 'loading' | 'rendering' | 'ready' | 'error';
+type RuntimePhase = 'idle' | 'resolving' | 'loading' | 'rendering' | 'ready' | 'error' | 'destroyed';
 /**
  * 运行时状态
  */
 interface RuntimeState {
     /** 当前阶段 */
     phase: RuntimePhase;
-    /** 页面数据 */
+    /** 页面解析结果 */
     page: PageResolveResult | null;
-    /** 页面状态（可变） */
+    /** 页面状态变量（可变） */
     variables: Record<string, unknown>;
-    /** 查询结果缓存 */
+    /** 数据查询结果缓存 */
     queries: Record<string, unknown>;
     /** 组件加载状态 */
     components: Map<string, ComponentLoadResult>;
@@ -64,6 +66,60 @@ interface RuntimeState {
     /** 是否已销毁 */
     destroyed: boolean;
 }
+/**
+ * 页面解析结果（Runtime 使用）
+ */
+interface PageResolveResult {
+    /** 页面 UID */
+    pageUid: string;
+    /** 页面版本 ID */
+    pageVersionId: string;
+    /** 页面 JSON（PageSchema） */
+    pageJson: _djvlc_contracts_types.PageSchema;
+    /** 组件清单 */
+    manifest: _djvlc_contracts_types.PageManifest;
+    /** 运行时配置 */
+    runtimeConfig?: {
+        /** 被阻断的组件列表 */
+        blockedComponents?: Array<{
+            name: string;
+            version: string;
+            reason: string;
+        }>;
+        /** Kill Switch 状态 */
+        killSwitches?: Array<{
+            type: string;
+            enabled: boolean;
+        }>;
+        /** 功能开关 */
+        features?: Record<string, boolean>;
+    };
+    /** 是否为预览模式 */
+    isPreview?: boolean;
+    /** 预加载的数据 */
+    preloadedData?: Record<string, unknown>;
+}
+/**
+ * 组件加载状态
+ */
+type ComponentLoadStatus = 'loading' | 'loaded' | 'failed' | 'blocked';
+/**
+ * 组件加载结果
+ */
+interface ComponentLoadResult {
+    /** 组件名称 */
+    name: string;
+    /** 组件版本 */
+    version: string;
+    /** 加载状态 */
+    status: ComponentLoadStatus;
+    /** 组件构造函数（加载成功时） */
+    component?: CustomElementConstructor | unknown;
+    /** 加载耗时（毫秒） */
+    loadTime?: number;
+    /** 错误信息（加载失败时） */
+    error?: string;
+}
 /**
  * 已加载的组件模块
  */
@@ -77,7 +133,72 @@ interface LoadedComponent {
     /** 加载耗时 */
     loadTime: number;
     /** 元数据 */
-    meta?: Record<string, unknown>;
+    meta?: _djvlc_contracts_types.ComponentMeta;
+}
+/**
+ * 运行时错误类型
+ */
+type RuntimeErrorType = 'LOAD_ERROR' | 'RENDER_ERROR' | 'ACTION_ERROR' | 'QUERY_ERROR' | 'EXPRESSION_ERROR' | 'COMPONENT_ERROR' | 'SECURITY_ERROR' | 'NETWORK_ERROR' | 'UNKNOWN_ERROR';
+/**
+ * 运行时错误
+ */
+interface RuntimeError {
+    /** 错误类型 */
+    type: RuntimeErrorType;
+    /** 错误消息 */
+    message: string;
+    /** 错误码 */
+    code?: string;
+    /** 详细信息 */
+    details?: Record<string, unknown>;
+    /** 原始错误 */
+    cause?: Error;
+    /** 追踪 ID */
+    traceId?: string;
+    /** 时间戳 */
+    timestamp: number;
+}
+/**
+ * 运行时事件类型
+ */
+type RuntimeEventType = 'page:resolving' | 'page:resolved' | 'page:loading' | 'page:loaded' | 'page:rendered' | 'page:error' | 'page:destroyed' | 'component:loading' | 'component:loaded' | 'component:error' | 'action:executing' | 'action:executed' | 'action:error' | 'query:fetching' | 'query:fetched' | 'query:error' | 'state:changed';
+/**
+ * 运行时事件
+ */
+interface RuntimeEvent<T = unknown> {
+    /** 事件类型 */
+    type: RuntimeEventType;
+    /** 事件数据 */
+    data: T;
+    /** 追踪 ID */
+    traceId?: string;
+    /** 时间戳 */
+    timestamp: number;
+}
+/**
+ * 性能指标类型
+ */
+type MetricType = 'pageResolveTime' | 'pageLoadTime' | 'componentLoadTime' | 'firstRenderTime' | 'actionExecuteTime' | 'queryFetchTime' | 'expressionEvalTime';
+/**
+ * 性能指标
+ */
+interface PerformanceMetric {
+    /** 指标类型 */
+    type: MetricType;
+    /** 指标值（毫秒） */
+    value: number;
+    /** 页面版本 ID */
+    pageVersionId?: string;
+    /** 组件名称 */
+    componentName?: string;
+    /** 组件版本 */
+    componentVersion?: string;
+    /** 动作类型 */
+    actionType?: string;
+    /** 查询 ID */
+    queryId?: string;
+    /** 时间戳 */
+    timestamp: number;
 }
 /**
  * 渲染器接口（框架无关）
@@ -86,16 +207,18 @@ interface Renderer {
     /** 初始化 */
     init(): void;
     /** 渲染页面 */
-    render(schema: PageSchema, container: HTMLElement): void;
+    render(schema: _djvlc_contracts_types.PageSchema, container: HTMLElement): void;
     /** 更新组件 */
     updateComponent(componentId: string, props: Record<string, unknown>): void;
+    /** 更新表达式上下文 */
+    updateContext(context: Partial<_djvlc_contracts_types.ExpressionContext>): void;
     /** 销毁 */
     destroy(): void;
 }
 /**
- * 事件处理器
+ * 事件处理器函数
  */
-type EventHandler<T = unknown> = (event: RuntimeEvent<T>) => void;
+type EventHandlerFn<T = unknown> = (event: RuntimeEvent<T>) => void;
 /**
  * 事件订阅取消函数
  */
@@ -115,841 +238,1112 @@ interface Logger {
 }
 
 /**
- * 主运行时类
- * 统一管理整个运行时生命周期
+ * 状态管理器
+ * 管理页面运行时状态，兼容 PageSchema V2
  */
 
 /**
- * 创建运行时实例
+ * 状态变更监听器
  */
-declare function createRuntime(options: RuntimeOptions): DjvlcRuntime;
+type StateListener = (state: RuntimeState) => void;
 /**
- * DJVLC 运行时
+ * 状态变更详情
  */
-declare class DjvlcRuntime {
-    private options;
-    private container;
-    private pageLoader;
-    private componentLoader;
-    private assetLoader;
-    private stateManager;
-    private eventBus;
-    private expressionEngine;
-    private securityManager;
-    private telemetryManager;
-    private renderer;
-    private hostApi;
-    private logger;
-    constructor(options: RuntimeOptions);
+interface StateChangeDetail {
+    /** 变更的键 */
+    key: string;
+    /** 旧值 */
+    oldValue: unknown;
+    /** 新值 */
+    newValue: unknown;
+}
+/**
+ * 状态变更回调
+ */
+type StateChangeCallback = (detail: StateChangeDetail) => void;
+/**
+ * 状态管理器
+ */
+declare class StateManager {
+    private state;
+    private listeners;
+    private changeCallbacks;
+    constructor();
     /**
-     * 初始化运行时
+     * 获取当前状态
      */
-    init(): Promise<void>;
+    getState(): RuntimeState;
     /**
-     * 加载页面
+     * 获取当前阶段
      */
-    load(): Promise<PageResolveResult>;
+    getPhase(): RuntimePhase;
     /**
-     * 渲染页面
+     * 设置阶段
      */
-    render(): Promise<void>;
+    setPhase(phase: RuntimePhase): void;
     /**
-     * 获取 Host API
+     * 设置页面数据（兼容 V2 PageSchema）
      */
-    getHostApi(): HostAPI;
+    setPage(page: PageResolveResult): void;
     /**
-     * 获取当前状态
+     * 初始化页面状态（从 PageSchema V2 的 state 定义）
      */
-    getState(): RuntimeState;
+    private initializePageState;
     /**
-     * 订阅状态变更
+     * 设置错误
      */
-    onStateChange(listener: (state: RuntimeState) => void): () => void;
+    setError(error: RuntimeError): void;
     /**
-     * 订阅事件
+     * 清除错误
      */
-    on<T>(type: RuntimeEvent<T>['type'], handler: (event: RuntimeEvent<T>) => void): () => void;
+    clearError(): void;
     /**
-     * 更新组件
+     * 获取变量值
      */
-    updateComponent(componentId: string, props: Record<string, unknown>): void;
+    getVariable<T = unknown>(key: string): T | undefined;
     /**
-     * 设置变量
+     * 设置变量值
      */
     setVariable(key: string, value: unknown): void;
     /**
-     * 刷新数据
+     * 批量设置变量
      */
-    refreshData(queryId: string): Promise<void>;
+    setVariables(variables: Record<string, unknown>): void;
     /**
-     * 销毁运行时
+     * 获取查询结果
      */
-    destroy(): void;
-    private resolveContainer;
-    private initHostApi;
-    private initRenderer;
-    private handleError;
-    private emitEvent;
-    private createLogger;
-    private log;
+    getQuery<T = unknown>(queryId: string): T | undefined;
+    /**
+     * 设置查询结果
+     */
+    setQuery(queryId: string, data: unknown): void;
+    /**
+     * 清除查询结果
+     */
+    clearQuery(queryId: string): void;
+    /**
+     * 更新组件加载状态
+     */
+    setComponentStatus(key: string, result: ComponentLoadResult): void;
+    /**
+     * 获取组件加载状态
+     */
+    getComponentStatus(key: string): ComponentLoadResult | undefined;
+    /**
+     * 标记为已销毁
+     */
+    setDestroyed(): void;
+    /**
+     * 检查是否已销毁
+     */
+    isDestroyed(): boolean;
+    /**
+     * 订阅状态变更
+     */
+    subscribe(listener: StateListener): () => void;
+    /**
+     * 订阅特定状态键的变更
+     */
+    onStateChange(callback: StateChangeCallback): () => void;
+    /**
+     * 重置状态
+     */
+    reset(): void;
+    /**
+     * 获取表达式上下文
+     * 对齐 contracts 中的 ExpressionContext 定义：
+     * - state: 页面状态变量
+     * - binding: 数据绑定结果（即查询结果）
+     * - local: 局部变量（循环变量、事件参数等，由渲染器管理）
+     * - context: 运行时上下文（额外信息）
+     */
+    getExpressionContext(): {
+        state: Record<string, unknown>;
+        binding: Record<string, unknown>;
+        local: Record<string, unknown>;
+        context: Record<string, unknown>;
+    };
+    private setState;
+    private notifyListeners;
+    private notifyChange;
+    private getNestedValue;
+    private setNestedValue;
+    private createInitialState;
 }
 
 /**
- * 运行时错误类型定义
+ * 表达式词法分析器
+ * 将表达式字符串分解为 Token
  */
-
 /**
- * 运行时错误基类
+ * Token 类型
  */
-declare class DjvlcRuntimeError extends Error {
-    readonly code: ErrorCode;
-    readonly details?: Record<string, unknown>;
-    readonly traceId?: string;
-    readonly timestamp: number;
-    constructor(code: ErrorCode, message?: string, details?: Record<string, unknown>, traceId?: string);
-    toJSON(): {
-        name: string;
-        code: ErrorCode;
-        message: string;
-        details: Record<string, unknown> | undefined;
-        traceId: string | undefined;
-        timestamp: number;
-    };
-}
+type TokenType = 'NUMBER' | 'STRING' | 'BOOLEAN' | 'NULL' | 'IDENTIFIER' | 'OPERATOR' | 'DOT' | 'LBRACKET' | 'RBRACKET' | 'LPAREN' | 'RPAREN' | 'COMMA' | 'QUESTION' | 'COLON' | 'EOF';
 /**
- * 页面加载错误
+ * Token
  */
-declare class PageLoadError extends DjvlcRuntimeError {
-    constructor(message: string, details?: Record<string, unknown>, traceId?: string);
+interface Token {
+    type: TokenType;
+    value: string | number | boolean | null;
+    start: number;
+    end: number;
 }
 /**
- * 组件加载错误
+ * 词法分析器
  */
-declare class ComponentLoadError extends DjvlcRuntimeError {
-    readonly componentName: string;
-    readonly componentVersion: string;
-    constructor(componentName: string, componentVersion: string, message: string, code?: ErrorCode, details?: Record<string, unknown>);
+declare class Lexer {
+    private input;
+    private pos;
+    private tokens;
+    constructor(input: string);
+    /**
+     * 分析表达式，返回 Token 列表
+     */
+    tokenize(): Token[];
+    private readToken;
+    private readNumber;
+    private readString;
+    private readIdentifier;
+    private readOperator;
+    private skipWhitespace;
+    private isDigit;
+    private isIdentifierStart;
+    private isIdentifierChar;
+    private peek;
 }
+
 /**
- * 组件完整性校验错误
+ * 表达式解析器
+ * 将 Token 列表解析为 AST
  */
-declare class IntegrityError extends DjvlcRuntimeError {
-    readonly componentName: string;
-    readonly componentVersion: string;
-    readonly expectedHash: string;
-    readonly actualHash: string;
-    constructor(componentName: string, componentVersion: string, expectedHash: string, actualHash: string);
-}
+
 /**
- * 组件阻断错误
+ * AST 基础节点接口
  */
-declare class ComponentBlockedError extends DjvlcRuntimeError {
-    readonly componentName: string;
-    readonly componentVersion: string;
-    readonly reason: string;
-    constructor(componentName: string, componentVersion: string, reason: string);
+interface BaseASTNode {
+    type: string;
+    /** 起始位置（可选，用于错误定位） */
+    start?: number;
+    /** 结束位置（可选，用于错误定位） */
+    end?: number;
+    /** 原始字符串（可选，用于调试） */
+    raw?: string;
 }
 /**
- * 表达式求值错误
+ * AST 节点类型
  */
-declare class ExpressionError extends DjvlcRuntimeError {
-    readonly expression: string;
-    readonly position?: {
-        start: number;
-        end: number;
-    };
-    constructor(expression: string, message: string, position?: {
-        start: number;
-        end: number;
-    }, details?: Record<string, unknown>);
+interface LiteralASTNode extends BaseASTNode {
+    type: 'literal';
+    value: string | number | boolean | null;
 }
-/**
- * 动作执行错误
- */
-declare class ActionError extends DjvlcRuntimeError {
-    readonly actionType: string;
-    readonly actionId?: string;
-    constructor(actionType: string, message: string, code?: ErrorCode, actionId?: string, details?: Record<string, unknown>);
+interface IdentifierASTNode extends BaseASTNode {
+    type: 'identifier';
+    name: string;
 }
-/**
- * 数据查询错误
- */
-declare class QueryError extends DjvlcRuntimeError {
-    readonly queryId: string;
-    constructor(queryId: string, message: string, code?: ErrorCode, details?: Record<string, unknown>);
+interface MemberASTNode extends BaseASTNode {
+    type: 'member';
+    object: ASTNode;
+    property: string | ASTNode;
+    computed: boolean;
 }
-/**
- * 渲染错误
+interface CallASTNode extends BaseASTNode {
+    type: 'call';
+    callee: string;
+    arguments: ASTNode[];
+}
+interface BinaryASTNode extends BaseASTNode {
+    type: 'binary';
+    operator: string;
+    left: ASTNode;
+    right: ASTNode;
+}
+interface UnaryASTNode extends BaseASTNode {
+    type: 'unary';
+    operator: string;
+    argument: ASTNode;
+}
+interface ConditionalASTNode extends BaseASTNode {
+    type: 'conditional';
+    test: ASTNode;
+    consequent: ASTNode;
+    alternate: ASTNode;
+}
+interface ArrayASTNode extends BaseASTNode {
+    type: 'array';
+    elements: ASTNode[];
+}
+type ASTNode = LiteralASTNode | IdentifierASTNode | MemberASTNode | CallASTNode | BinaryASTNode | UnaryASTNode | ConditionalASTNode | ArrayASTNode;
+/**
+ * 表达式解析器
  */
-declare class RenderError extends DjvlcRuntimeError {
-    readonly componentId: string;
-    readonly componentType: string;
-    constructor(componentId: string, componentType: string, message: string, details?: Record<string, unknown>);
+declare class Parser {
+    private tokens;
+    private pos;
+    constructor(tokens: Token[]);
+    /**
+     * 解析表达式
+     */
+    parse(): ASTNode;
+    private parseExpression;
+    private parseTernary;
+    private parseBinary;
+    private parseUnary;
+    private parsePostfix;
+    private parsePrimary;
+    private parseArray;
+    private parseArguments;
+    private current;
+    private advance;
+    private expect;
 }
 
 /**
- * 页面加载器
- * 负责从 API 解析页面配置
+ * 表达式求值器
+ * 安全地执行 AST，无 eval
  */
 
 /**
- * 页面加载器配置
+ * 求值结果
  */
-interface PageLoaderOptions {
-    /** API 基础 URL */
-    apiBaseUrl: string;
-    /** 渠道 */
-    channel?: 'preview' | 'prod' | 'gray';
-    /** 认证 Token */
-    authToken?: string;
-    /** 预览 Token */
-    previewToken?: string;
-    /** 请求头 */
-    headers?: Record<string, string>;
-    /** 缓存配置 */
-    cache?: {
-        enabled: boolean;
-        maxAge?: number;
-    };
-    /** 日志器 */
-    logger?: Logger;
+interface EvaluationResult {
+    value: unknown;
+    error?: Error;
 }
 /**
- * 页面加载器
- * 负责调用 /page/resolve 接口获取页面数据
+ * 求值器配置
  */
-declare class PageLoader {
+interface EvaluatorOptions {
+    /** 最大递归深度 */
+    maxDepth?: number;
+    /** 最大执行时间（毫秒） */
+    timeout?: number;
+    /** 调试模式 */
+    debug?: boolean;
+}
+/**
+ * 表达式求值器
+ */
+declare class Evaluator {
     private options;
-    private cache;
-    constructor(options: PageLoaderOptions);
-    /**
-     * 解析页面
-     * @param pageUid 页面 UID
-     * @param params 额外参数
-     */
-    resolve(pageUid: string, params?: {
-        uid?: string;
-        deviceId?: string;
-    }): Promise<PageResolveResult>;
-    /**
-     * 预连接 API 服务器
-     */
-    preconnect(): void;
+    private depth;
+    private startTime;
+    constructor(options?: EvaluatorOptions);
     /**
-     * 清除缓存
+     * 求值表达式
      */
-    clearCache(pageUid?: string): void;
-    private buildResolveUrl;
-    private buildHeaders;
-    private getCacheKey;
-    private isCacheValid;
-    private isValidPageResolveResult;
-    private log;
+    evaluate(ast: ASTNode, context: ExpressionContext): EvaluationResult;
+    private evaluateNode;
+    private evaluateLiteral;
+    private evaluateIdentifier;
+    private evaluateMember;
+    private evaluateCall;
+    private evaluateBinary;
+    private evaluateUnary;
+    private evaluateConditional;
+    private evaluateArray;
+    private checkLimits;
 }
 
 /**
- * 组件加载器
- * 负责从 CDN 加载组件资源
+ * 表达式引擎
+ * 统一的表达式解析和求值入口
  */
 
 /**
- * 组件加载器配置
+ * 表达式引擎配置
  */
-interface ComponentLoaderOptions {
-    /** CDN 基础 URL */
-    cdnBaseUrl: string;
-    /** 是否启用 SRI 校验 */
-    enableSRI?: boolean;
-    /** 被阻断的组件列表 */
-    blockedComponents?: string[];
-    /** 并行加载数量 */
-    concurrency?: number;
-    /** 超时时间（毫秒） */
-    timeout?: number;
+interface ExpressionEngineOptions extends EvaluatorOptions {
+    /** 是否缓存 AST */
+    cacheAST?: boolean;
+    /** 最大缓存大小 */
+    maxCacheSize?: number;
     /** 日志器 */
     logger?: Logger;
 }
 /**
- * 组件加载器
- * 负责加载 Web Components
+ * 表达式引擎
+ * 安全的表达式解析和求值，无 eval/new Function
  */
-declare class ComponentLoader {
+declare class ExpressionEngine {
     private options;
-    private loadedComponents;
-    private loadingPromises;
-    private blockedSet;
-    constructor(options: ComponentLoaderOptions);
-    /**
-     * 加载单个组件
-     */
-    load(item: ManifestItem): Promise<LoadedComponent>;
+    private evaluator;
+    private astCache;
+    constructor(options?: ExpressionEngineOptions);
     /**
-     * 加载 Manifest 中的所有组件
+     * 求值表达式
      */
-    loadAll(manifest: PageManifest): Promise<Map<string, ComponentLoadResult>>;
+    evaluate(expression: string, context: ExpressionContext): EvaluationResult;
     /**
-     * 预加载组件
+     * 求值表达式并返回值
+     * 出错时返回 fallback 值
+     *
+     * @param expression - 表达式字符串或 Expression 对象
+     * @param context - 表达式上下文
+     * @param fallback - 求值失败时的默认值
      */
-    preload(items: ManifestItem[]): void;
+    evaluateWithFallback<T>(expression: string | Expression, context: ExpressionContext, fallback?: T): T;
     /**
-     * 检查组件是否已加载
+     * 求值模板字符串
+     * 支持 ${expression} 语法
      */
-    isLoaded(name: string, version: string): boolean;
+    evaluateTemplate(template: string, context: ExpressionContext): string;
     /**
-     * 获取已加载的组件
+     * 解析表达式为 AST
      */
-    get(name: string, version: string): LoadedComponent | undefined;
+    parse(expression: string): ASTNode;
     /**
-     * 检查组件是否被阻断
+     * 校验表达式
      */
-    isBlocked(name: string, version: string): boolean;
+    validate(expression: string): ExpressionValidationResult;
     /**
-     * 更新阻断列表
+     * 清除 AST 缓存
      */
-    updateBlockedList(blocked: string[]): void;
-    private loadComponent;
-    private fetchWithTimeout;
-    private validateIntegrity;
-    private executeScript;
-    private resolveUrl;
-    private getComponentKey;
+    clearCache(): void;
+    private collectReferences;
+    private buildMemberPath;
     private log;
 }
 
 /**
- * 资源加载器
- * 负责预连接、预加载等资源优化
+ * 内置函数实现
+ * 表达式中可调用的白名单函数
  */
+type BuiltinFn = (...args: unknown[]) => unknown;
 /**
- * 资源加载器配置
+ * 内置函数映射
  */
-interface AssetLoaderOptions {
-    /** CDN 域名列表 */
-    cdnHosts: string[];
-    /** API 域名列表 */
-    apiHosts: string[];
+declare const builtinFunctions: Record<string, BuiltinFn>;
+
+/**
+ * 事件总线
+ * 运行时事件系统
+ */
+
+/**
+ * 事件总线配置
+ */
+interface EventBusOptions {
+    /** 是否开启调试 */
+    debug?: boolean;
+    /** 日志器 */
+    logger?: Logger;
+    /** 最大监听器数量 */
+    maxListeners?: number;
 }
 /**
- * 资源加载器
- * 负责资源预连接、预加载等优化
+ * 事件总线实现
  */
-declare class AssetLoader {
+declare class EventBus {
+    private handlers;
     private options;
-    private preconnectedHosts;
-    private preloadedAssets;
-    constructor(options: AssetLoaderOptions);
+    constructor(options?: EventBusOptions);
     /**
-     * 预连接所有域名
+     * 发送事件
      */
-    preconnectAll(): void;
+    emit<T>(event: RuntimeEvent<T>): void;
     /**
-     * 预连接单个域名
+     * 订阅事件
      */
-    preconnect(host: string): void;
+    on<T>(type: RuntimeEventType, handler: EventHandlerFn<T>): Unsubscribe;
     /**
-     * DNS 预解析
+     * 取消订阅
      */
-    dnsPrefetch(host: string): void;
+    off<T>(type: RuntimeEventType, handler: EventHandlerFn<T>): void;
     /**
-     * 预加载脚本
+     * 一次性订阅
      */
-    preloadScript(url: string, integrity?: string): void;
+    once<T>(type: RuntimeEventType, handler: EventHandlerFn<T>): Unsubscribe;
     /**
-     * 预加载样式
+     * 清除所有监听器
      */
-    preloadStyle(url: string, integrity?: string): void;
+    clear(type?: RuntimeEventType): void;
     /**
-     * 预加载图片
-     */
-    preloadImage(url: string): void;
-    /**
-     * 预获取资源（低优先级）
-     */
-    prefetch(url: string, as?: 'script' | 'style' | 'image' | 'document'): void;
-    /**
-     * 加载样式表
+     * 获取监听器数量
      */
-    loadStylesheet(url: string, integrity?: string): Promise<void>;
+    listenerCount(type: RuntimeEventType): number;
     /**
-     * 加载脚本
+     * 创建事件
      */
-    loadScript(url: string, integrity?: string): Promise<void>;
+    static createEvent<T>(type: RuntimeEventType, data: T, traceId?: string): RuntimeEvent<T>;
+    private log;
 }
 
 /**
- * 状态管理器
- * 管理页面运行时状态
+ * 动作执行器接口
  */
-
+interface ActionExecutor {
+    /** 执行自定义动作（通过 Action Gateway） */
+    executeAction<T = unknown>(actionType: string, params: Record<string, unknown>): Promise<{
+        success: boolean;
+        data?: T;
+        errorCode?: string;
+        errorMessage?: string;
+    }>;
+    /** 执行数据查询（通过 Data Proxy） */
+    requestData<T = unknown>(queryId: string, params?: Record<string, unknown>): Promise<{
+        success: boolean;
+        data?: T;
+        message?: string;
+    }>;
+    /** 导航 */
+    navigate(options: _djvlc_contracts_types.NavigateOptions): void;
+    /** 打开对话框 */
+    openDialog(options: {
+        type: string;
+        content: string;
+        title?: string;
+    }): Promise<unknown>;
+    /** 关闭对话框 */
+    closeDialog(dialogId?: string): void;
+    /** 显示 Toast */
+    showToast(options: {
+        message: string;
+        type?: string;
+        duration?: number;
+    }): void;
+    /** 显示加载 */
+    showLoading(message?: string): void;
+    /** 隐藏加载 */
+    hideLoading(): void;
+    /** 埋点上报 */
+    track(event: {
+        eventName: string;
+        params?: Record<string, unknown>;
+    }): void;
+    /** 设置状态 */
+    setState(key: string, value: unknown): void;
+    /** 获取状态 */
+    getState<T = unknown>(key: string): T | undefined;
+    /** 刷新数据 */
+    refreshData(queryId: string): Promise<void>;
+}
 /**
- * 状态变更监听器
+ * 动作桥接器配置
  */
-type StateListener = (state: RuntimeState) => void;
+interface ActionBridgeOptions {
+    /** 动作执行器 */
+    executor: ActionExecutor;
+    /** 表达式引擎 */
+    expressionEngine: ExpressionEngine;
+    /** 调试模式 */
+    debug?: boolean;
+    /** 日志器 */
+    logger?: Logger;
+    /** 动作执行前回调 */
+    onActionStart?: (actionRef: ActionRef, params: Record<string, unknown>) => void;
+    /** 动作执行后回调 */
+    onActionComplete?: (actionRef: ActionRef, result: {
+        success: boolean;
+        data?: unknown;
+        error?: Error;
+    }) => void;
+}
 /**
- * 状态管理器
+ * 动作执行上下文
  */
-declare class StateManager {
-    private state;
-    private listeners;
-    constructor();
+interface ActionExecutionContext {
+    /** 事件数据 */
+    $event: unknown;
+    /** 上一个动作的结果 */
+    $prevResult: unknown;
+    /** 所有动作的结果 */
+    $results: Record<string, unknown>;
+}
+/**
+ * 动作桥接器
+ * 将组件事件转换为动作执行，支持动作链、条件执行、重试等
+ */
+declare class ActionBridge {
+    private options;
+    private debounceTimers;
+    private throttleTimers;
+    constructor(options: ActionBridgeOptions);
     /**
-     * 获取当前状态
+     * 处理事件处理器
      */
-    getState(): RuntimeState;
+    handleEvent(handler: EventHandler, eventData: unknown, baseContext: ExpressionContext): Promise<void>;
     /**
-     * 获取当前阶段
+     * 执行动作链
      */
-    getPhase(): RuntimePhase;
+    executeActionChain(actions: ActionRef[], baseContext: ExpressionContext, executionContext: ActionExecutionContext): Promise<void>;
     /**
-     * 设置阶段
+     * 执行单个动作
      */
-    setPhase(phase: RuntimePhase): void;
+    private executeSingleAction;
     /**
-     * 设置页面数据
+     * 执行动作（带重试）
      */
-    setPage(page: PageResolveResult): void;
+    private executeWithRetry;
     /**
-     * 设置错误
+     * 执行内置动作
      */
-    setError(error: RuntimeError): void;
+    private executeBuiltinAction;
     /**
-     * 获取变量值
+     * 执行自定义动作
      */
-    getVariable<T = unknown>(key: string): T | undefined;
+    private executeCustomAction;
     /**
-     * 设置变量值
+     * Expression 类型列表（用于判断是否为 Expression 对象）
      */
-    setVariable(key: string, value: unknown): void;
+    private static readonly EXPRESSION_TYPES;
     /**
-     * 批量设置变量
+     * 解析参数中的表达式
+     *
+     * @param params - ActionRef.params，类型为 Record<string, AnyValueOrExpression>
      */
-    setVariables(variables: Record<string, unknown>): void;
+    private resolveParams;
     /**
-     * 获取查询结果
+     * 解析单个值（支持 AnyValueOrExpression）
+     *
+     * AnyValueOrExpression 可以是：
+     * - Expression 对象：{ type: 'state' | 'binding' | 'local' | 'template' | 'computed', value: string, fallback?: any }
+     * - 原始值：string | number | boolean | null
+     * - 嵌套数组：AnyValueOrExpression[]
+     * - 嵌套对象：{ [key: string]: AnyValueOrExpression }
      */
-    getQuery<T = unknown>(queryId: string): T | undefined;
+    private resolveValue;
     /**
-     * 设置查询结果
+     * 求值条件表达式
+     * 将事件数据注入到 local 上下文中（对齐 contracts 的 ExpressionContext）
+     *
+     * @param condition - Expression 对象，包含 type、value、fallback
      */
-    setQuery(queryId: string, data: unknown): void;
+    private evaluateCondition;
     /**
-     * 更新组件加载状态
+     * 构建动作执行上下文
+     * 将事件数据和动作结果注入到 local 上下文中
      */
-    setComponentStatus(key: string, result: ComponentLoadResult): void;
+    private buildActionContext;
     /**
-     * 标记为已销毁
+     * 带超时的 Promise
      */
-    setDestroyed(): void;
+    private withTimeout;
     /**
-     * 订阅状态变更
+     * 防抖
      */
-    subscribe(listener: StateListener): () => void;
+    private debounce;
     /**
-     * 重置状态
+     * 节流
      */
-    reset(): void;
-    private setState;
-    private notifyListeners;
-    private createInitialState;
+    private throttle;
+    /**
+     * 延迟
+     */
+    private delay;
+    /**
+     * 销毁
+     */
+    destroy(): void;
+    private log;
 }
 
 /**
- * 事件总线
- * 运行时事件系统
+ * Host API 实现
+ * 提供给组件的安全 API，完全对齐 @djvlc/contracts-types 中的 HostApi 定义
+ *
+ * 组件只能通过 HostAPI 与外界交互，禁止：
+ * - 直接调用 window.fetch（绕过 Data Proxy）
+ * - 直接操作 location.href（绕过权限/埋点）
+ * - 随意访问 localStorage（乱写）
+ * - 随意上报（污染数据）
  */
 
 /**
- * 事件总线配置
+ * 运行时上下文
  */
-interface EventBusOptions {
-    /** 是否开启调试 */
+interface RuntimeContext {
+    pageUid: string;
+    pageVersionId: string;
+    runtimeVersion: string;
+    userId?: string;
+    deviceId?: string;
+    channel?: string;
+    appId: string;
+    env: 'development' | 'staging' | 'production';
+    isEditMode: boolean;
+    isPreviewMode: boolean;
+}
+/**
+ * Host API 配置
+ */
+interface HostAPIOptions {
+    /** API 基础 URL */
+    apiBaseUrl: string;
+    /** 认证 Token */
+    authToken?: string;
+    /** 请求头 */
+    headers?: Record<string, string>;
+    /** 状态管理器 */
+    stateManager: StateManager;
+    /** 事件总线 */
+    eventBus: EventBus;
+    /** 表达式引擎 */
+    expressionEngine: ExpressionEngine;
+    /** 运行时上下文 */
+    context: RuntimeContext;
+    /** 调试模式 */
     debug?: boolean;
     /** 日志器 */
     logger?: Logger;
-    /** 最大监听器数量 */
-    maxListeners?: number;
 }
 /**
- * 事件总线实现
+ * Host API 实现
+ * 完全实现 @djvlc/contracts-types 中定义的 HostApi 接口
  */
-declare class EventBus implements EventBus$1 {
-    private handlers;
+declare class HostAPIImpl implements HostApi {
     private options;
-    constructor(options?: EventBusOptions);
+    private storageNamespace;
+    private loadingCount;
+    private loadingElement;
+    constructor(options: HostAPIOptions);
+    navigate(options: NavigateOptions): Promise<void>;
+    track(event: TrackEvent): void;
+    requestData<T = unknown>(queryId: string, params?: Record<string, unknown>): Promise<T>;
+    executeAction<T = unknown>(actionType: string, params?: Record<string, unknown>): Promise<ActionResult<T>>;
+    openDialog(options: DialogOptions): Promise<DialogResult>;
+    closeDialog(dialogId?: string): void;
+    showToast(options: ToastOptions): void;
+    showLoading(message?: string): void;
+    hideLoading(): void;
+    clipboard: ClipboardApi;
+    storage: StorageApi;
+    share(options: ShareOptions): Promise<ShareResult>;
+    confirm(options: ConfirmOptions): Promise<boolean>;
+    showActionSheet(options: ActionSheetOptions): Promise<ActionSheetResult>;
+    previewImage(options: PreviewImageOptions): void;
+    scanCode(): Promise<ScanCodeResult>;
+    getState<T = unknown>(path: string): T | undefined;
+    setState(path: string, value: unknown): void;
+    getContext(): ComponentContext;
+    private buildHeaders;
+    private generateIdempotencyKey;
+    private simpleHash;
+    private fallbackCopy;
+    private log;
+}
+
+/**
+ * 主运行时类
+ * 统一管理整个运行时生命周期
+ *
+ * 仅支持 PageSchema V1.0.0（与 contracts-types 保持一致）
+ */
+
+/**
+ * 支持的 Schema 版本（与 contracts-types 保持一致）
+ */
+declare const SUPPORTED_SCHEMA_VERSION = "1.0.0";
+/**
+ * 创建运行时实例
+ */
+declare function createRuntime(options: RuntimeOptions): DjvlcRuntime;
+/**
+ * DJVLC 运行时
+ *
+ * 核心职责：
+ * 1. resolve & load：拿到 pageVersion 与 manifest，按 componentVersion 拉资源
+ * 2. render：把 schema 变成 UI（基于 Web Components）
+ * 3. boundary：组件只能通过 hostApi 触发 data/action/navigate/track
+ */
+declare class DjvlcRuntime {
+    private options;
+    private container;
+    private pageLoader;
+    private componentLoader;
+    private assetLoader;
+    private stateManager;
+    private dataBindingManager;
+    private eventBus;
+    private actionBridge;
+    private expressionEngine;
+    private securityManager;
+    private telemetryManager;
+    private renderer;
+    private hostApi;
+    private lifecycleManager;
+    private logger;
+    constructor(options: RuntimeOptions);
     /**
-     * 发送事件
+     * 初始化运行时
      */
-    emit<T>(event: RuntimeEvent<T>): void;
+    init(): Promise<void>;
+    /**
+     * 加载页面
+     */
+    load(): Promise<PageResolveResult>;
+    /**
+     * 渲染页面
+     */
+    render(): Promise<void>;
+    /**
+     * 获取 Host API
+     */
+    getHostApi(): HostAPIImpl;
+    /**
+     * 获取当前状态
+     */
+    getState(): RuntimeState;
+    /**
+     * 订阅状态变更
+     */
+    onStateChange(listener: (state: RuntimeState) => void): () => void;
     /**
      * 订阅事件
      */
-    on<T>(type: RuntimeEventType, handler: EventHandler<T>): Unsubscribe;
+    on<T>(type: RuntimeEvent<T>['type'], handler: (event: RuntimeEvent<T>) => void): () => void;
+    /**
+     * 更新组件
+     */
+    updateComponent(componentId: string, props: Record<string, unknown>): void;
     /**
-     * 取消订阅
+     * 设置变量
      */
-    off<T>(type: RuntimeEventType, handler: EventHandler<T>): void;
+    setVariable(key: string, value: unknown): void;
     /**
-     * 一次性订阅
+     * 获取变量
      */
-    once<T>(type: RuntimeEventType, handler: EventHandler<T>): Unsubscribe;
+    getVariable<T = unknown>(key: string): T | undefined;
     /**
-     * 清除所有监听器
+     * 刷新数据
      */
-    clear(type?: RuntimeEventType): void;
+    refreshData(queryId: string): Promise<void>;
     /**
-     * 获取监听器数量
+     * 执行动作
      */
-    listenerCount(type: RuntimeEventType): number;
+    executeAction(actionType: string, params?: Record<string, unknown>): Promise<unknown>;
     /**
-     * 创建事件
+     * 销毁运行时
      */
-    static createEvent<T>(type: RuntimeEventType, data: T, traceId?: string): RuntimeEvent<T>;
+    destroy(): Promise<void>;
+    /**
+     * 验证 Schema 版本
+     */
+    private validateSchemaVersion;
+    private resolveContainer;
+    private initHostApi;
+    private initActionBridge;
+    private initDataBindingManager;
+    private initLifecycleManager;
+    private initRenderer;
+    /**
+     * 处理组件事件
+     */
+    private handleComponentEvent;
+    private handleError;
+    private emitEvent;
+    private createLogger;
     private log;
 }
 
 /**
- * 动作桥接器
- * 处理组件事件到动作的映射
+ * 运行时错误类型定义
  */
 
 /**
- * 动作执行器
+ * 运行时错误基类
  */
-interface ActionExecutor {
-    execute(actionType: string, params: Record<string, unknown>): Promise<unknown>;
+declare class DjvlcRuntimeError extends Error {
+    readonly code: ErrorCode;
+    readonly details?: Record<string, unknown>;
+    readonly traceId?: string;
+    readonly timestamp: number;
+    constructor(code: ErrorCode, message?: string, details?: Record<string, unknown>, traceId?: string);
+    toJSON(): {
+        name: string;
+        code: ErrorCode;
+        message: string;
+        details: Record<string, unknown> | undefined;
+        traceId: string | undefined;
+        timestamp: number;
+    };
 }
 /**
- * 动作桥接器配置
+ * 页面加载错误
  */
-interface ActionBridgeOptions {
-    /** 动作执行器 */
-    executor: ActionExecutor;
-    /** 调试模式 */
-    debug?: boolean;
-    /** 日志器 */
-    logger?: Logger;
+declare class PageLoadError extends DjvlcRuntimeError {
+    constructor(message: string, details?: Record<string, unknown>, traceId?: string);
 }
 /**
- * 动作桥接器
- * 将组件事件转换为动作执行
+ * 组件加载错误
  */
-declare class ActionBridge {
-    private options;
-    private debounceTimers;
-    private throttleTimers;
-    constructor(options: ActionBridgeOptions);
-    /**
-     * 处理组件事件
-     */
-    handleEvent(event: ComponentEvent, eventData: Record<string, unknown>, context: Record<string, unknown>): Promise<void>;
-    /**
-     * 销毁
-     */
-    destroy(): void;
-    private executeAction;
-    private resolveParams;
-    private debounce;
-    private throttle;
-    private delay;
-    private log;
+declare class ComponentLoadError extends DjvlcRuntimeError {
+    readonly componentName: string;
+    readonly componentVersion: string;
+    constructor(componentName: string, componentVersion: string, message: string, code?: ErrorCode, details?: Record<string, unknown>);
 }
-
 /**
- * 表达式词法分析器
- * 将表达式字符串分解为 Token
+ * 组件完整性校验错误
  */
+declare class IntegrityError extends DjvlcRuntimeError {
+    readonly componentName: string;
+    readonly componentVersion: string;
+    readonly expectedHash: string;
+    readonly actualHash: string;
+    constructor(componentName: string, componentVersion: string, expectedHash: string, actualHash: string);
+}
 /**
- * Token 类型
+ * 组件阻断错误
  */
-type TokenType = 'NUMBER' | 'STRING' | 'BOOLEAN' | 'NULL' | 'IDENTIFIER' | 'OPERATOR' | 'DOT' | 'LBRACKET' | 'RBRACKET' | 'LPAREN' | 'RPAREN' | 'COMMA' | 'QUESTION' | 'COLON' | 'EOF';
+declare class ComponentBlockedError extends DjvlcRuntimeError {
+    readonly componentName: string;
+    readonly componentVersion: string;
+    readonly reason: string;
+    constructor(componentName: string, componentVersion: string, reason: string);
+}
 /**
- * Token
+ * 表达式求值错误
  */
-interface Token {
-    type: TokenType;
-    value: string | number | boolean | null;
-    start: number;
-    end: number;
+declare class ExpressionError extends DjvlcRuntimeError {
+    readonly expression: string;
+    readonly position?: {
+        start: number;
+        end: number;
+    };
+    constructor(expression: string, message: string, position?: {
+        start: number;
+        end: number;
+    }, details?: Record<string, unknown>);
 }
 /**
- * 词法分析器
+ * 动作执行错误
  */
-declare class Lexer {
-    private input;
-    private pos;
-    private tokens;
-    constructor(input: string);
-    /**
-     * 分析表达式，返回 Token 列表
-     */
-    tokenize(): Token[];
-    private readToken;
-    private readNumber;
-    private readString;
-    private readIdentifier;
-    private readOperator;
-    private skipWhitespace;
-    private isDigit;
-    private isIdentifierStart;
-    private isIdentifierChar;
-    private peek;
+declare class ActionError extends DjvlcRuntimeError {
+    readonly actionType: string;
+    readonly actionId?: string;
+    constructor(actionType: string, message: string, code?: ErrorCode, actionId?: string, details?: Record<string, unknown>);
+}
+/**
+ * 数据查询错误
+ */
+declare class QueryError extends DjvlcRuntimeError {
+    readonly queryId: string;
+    constructor(queryId: string, message: string, code?: ErrorCode, details?: Record<string, unknown>);
+}
+/**
+ * 渲染错误
+ */
+declare class RenderError extends DjvlcRuntimeError {
+    readonly componentId: string;
+    readonly componentType: string;
+    constructor(componentId: string, componentType: string, message: string, details?: Record<string, unknown>);
 }
 
 /**
- * 表达式解析器
- * 将 Token 列表解析为 AST
+ * 页面加载器
+ * 负责从 API 解析页面配置
  */
 
 /**
- * AST 节点类型
+ * 页面加载器配置
  */
-interface LiteralASTNode extends ExpressionNode {
-    type: 'literal';
-    value: string | number | boolean | null;
-}
-interface IdentifierASTNode extends ExpressionNode {
-    type: 'identifier';
-    name: string;
-}
-interface MemberASTNode extends ExpressionNode {
-    type: 'member';
-    object: ASTNode;
-    property: string | ASTNode;
-    computed: boolean;
-}
-interface CallASTNode extends ExpressionNode {
-    type: 'call';
-    callee: string;
-    arguments: ASTNode[];
-}
-interface BinaryASTNode extends ExpressionNode {
-    type: 'binary';
-    operator: string;
-    left: ASTNode;
-    right: ASTNode;
-}
-interface UnaryASTNode extends ExpressionNode {
-    type: 'unary';
-    operator: string;
-    argument: ASTNode;
-}
-interface ConditionalASTNode extends ExpressionNode {
-    type: 'conditional';
-    test: ASTNode;
-    consequent: ASTNode;
-    alternate: ASTNode;
-}
-interface ArrayASTNode extends ExpressionNode {
-    type: 'array';
-    elements: ASTNode[];
+interface PageLoaderOptions {
+    /** API 基础 URL */
+    apiBaseUrl: string;
+    /** 渠道 */
+    channel?: 'preview' | 'prod' | 'gray';
+    /** 认证 Token */
+    authToken?: string;
+    /** 预览 Token */
+    previewToken?: string;
+    /** 请求头 */
+    headers?: Record<string, string>;
+    /** 缓存配置 */
+    cache?: {
+        enabled: boolean;
+        maxAge?: number;
+    };
+    /** 日志器 */
+    logger?: Logger;
 }
-type ASTNode = LiteralASTNode | IdentifierASTNode | MemberASTNode | CallASTNode | BinaryASTNode | UnaryASTNode | ConditionalASTNode | ArrayASTNode;
 /**
- * 表达式解析器
+ * 页面加载器
+ * 负责调用 /page/resolve 接口获取页面数据
  */
-declare class Parser {
-    private tokens;
-    private pos;
-    constructor(tokens: Token[]);
+declare class PageLoader {
+    private options;
+    private cache;
+    constructor(options: PageLoaderOptions);
     /**
-     * 解析表达式
+     * 解析页面
+     * @param pageUid 页面 UID
+     * @param params 额外参数
      */
-    parse(): ASTNode;
-    private parseExpression;
-    private parseTernary;
-    private parseBinary;
-    private parseUnary;
-    private parsePostfix;
-    private parsePrimary;
-    private parseArray;
-    private parseArguments;
-    private current;
-    private advance;
-    private expect;
+    resolve(pageUid: string, params?: {
+        uid?: string;
+        deviceId?: string;
+    }): Promise<PageResolveResult>;
+    /**
+     * 预连接 API 服务器
+     */
+    preconnect(): void;
+    /**
+     * 清除缓存
+     */
+    clearCache(pageUid?: string): void;
+    private buildResolveUrl;
+    private buildHeaders;
+    private getCacheKey;
+    private isCacheValid;
+    private isValidPageResolveResult;
+    private log;
 }
 
 /**
- * 表达式求值器
- * 安全地执行 AST，无 eval
+ * 组件加载器
+ * 负责从 CDN 加载组件资源
  */
 
 /**
- * 求值结果
- */
-interface EvaluationResult {
-    value: unknown;
-    error?: Error;
-}
-/**
- * 求值器配置
+ * 组件加载器配置
  */
-interface EvaluatorOptions {
-    /** 最大递归深度 */
-    maxDepth?: number;
-    /** 最大执行时间（毫秒） */
+interface ComponentLoaderOptions {
+    /** CDN 基础 URL */
+    cdnBaseUrl: string;
+    /** 是否启用 SRI 校验 */
+    enableSRI?: boolean;
+    /** 被阻断的组件列表 */
+    blockedComponents?: string[];
+    /** 并行加载数量 */
+    concurrency?: number;
+    /** 超时时间（毫秒） */
     timeout?: number;
-    /** 调试模式 */
-    debug?: boolean;
+    /** 日志器 */
+    logger?: Logger;
 }
 /**
- * 表达式求值器
+ * 组件加载器
+ * 负责加载 Web Components
  */
-declare class Evaluator {
+declare class ComponentLoader {
     private options;
-    private depth;
-    private startTime;
-    constructor(options?: EvaluatorOptions);
+    private loadedComponents;
+    private loadingPromises;
+    private blockedSet;
+    constructor(options: ComponentLoaderOptions);
     /**
-     * 求值表达式
+     * 加载单个组件
      */
-    evaluate(ast: ASTNode, context: ExpressionContext): EvaluationResult;
-    private evaluateNode;
-    private evaluateLiteral;
-    private evaluateIdentifier;
-    private evaluateMember;
-    private evaluateCall;
-    private evaluateBinary;
-    private evaluateUnary;
-    private evaluateConditional;
-    private evaluateArray;
-    private checkLimits;
+    load(item: ManifestItem): Promise<LoadedComponent>;
+    /**
+     * 加载 Manifest 中的所有组件
+     */
+    loadAll(manifest: PageManifest): Promise<Map<string, ComponentLoadResult>>;
+    /**
+     * 预加载组件
+     */
+    preload(items: ManifestItem[]): void;
+    /**
+     * 检查组件是否已加载
+     */
+    isLoaded(name: string, version: string): boolean;
+    /**
+     * 获取已加载的组件
+     */
+    get(name: string, version: string): LoadedComponent | undefined;
+    /**
+     * 检查组件是否被阻断
+     */
+    isBlocked(name: string, version: string): boolean;
+    /**
+     * 更新阻断列表
+     */
+    updateBlockedList(blocked: string[]): void;
+    private loadComponent;
+    private fetchWithTimeout;
+    private validateIntegrity;
+    private executeScript;
+    private resolveUrl;
+    private getComponentKey;
+    private log;
 }
 
 /**
- * 表达式引擎
- * 统一的表达式解析和求值入口
+ * 资源加载器
+ * 负责预连接、预加载等资源优化
  */
-
 /**
- * 表达式引擎配置
+ * 资源加载器配置
  */
-interface ExpressionEngineOptions extends EvaluatorOptions {
-    /** 是否缓存 AST */
-    cacheAST?: boolean;
-    /** 最大缓存大小 */
-    maxCacheSize?: number;
-    /** 日志器 */
-    logger?: Logger;
+interface AssetLoaderOptions {
+    /** CDN 域名列表 */
+    cdnHosts: string[];
+    /** API 域名列表 */
+    apiHosts: string[];
 }
 /**
- * 表达式引擎
- * 安全的表达式解析和求值，无 eval/new Function
+ * 资源加载器
+ * 负责资源预连接、预加载等优化
  */
-declare class ExpressionEngine {
+declare class AssetLoader {
     private options;
-    private evaluator;
-    private astCache;
-    constructor(options?: ExpressionEngineOptions);
+    private preconnectedHosts;
+    private preloadedAssets;
+    constructor(options: AssetLoaderOptions);
     /**
-     * 求值表达式
+     * 预连接所有域名
      */
-    evaluate(expression: string, context: ExpressionContext): EvaluationResult;
+    preconnectAll(): void;
     /**
-     * 求值表达式并返回值
-     * 出错时返回 fallback 值
+     * 预连接单个域名
      */
-    evaluateWithFallback<T>(expression: string, context: ExpressionContext, fallback: T): T;
+    preconnect(host: string): void;
     /**
-     * 求值模板字符串
-     * 支持 ${expression} 语法
+     * DNS 预解析
      */
-    evaluateTemplate(template: string, context: ExpressionContext): string;
+    dnsPrefetch(host: string): void;
     /**
-     * 解析表达式为 AST
+     * 预加载脚本
      */
-    parse(expression: string): ASTNode;
+    preloadScript(url: string, integrity?: string): void;
     /**
-     * 校验表达式
+     * 预加载样式
      */
-    validate(expression: string): ExpressionValidationResult;
+    preloadStyle(url: string, integrity?: string): void;
     /**
-     * 清除 AST 缓存
+     * 预加载图片
      */
-    clearCache(): void;
-    private collectReferences;
-    private buildMemberPath;
-    private log;
+    preloadImage(url: string): void;
+    /**
+     * 预获取资源（低优先级）
+     */
+    prefetch(url: string, as?: 'script' | 'style' | 'image' | 'document'): void;
+    /**
+     * 加载样式表
+     */
+    loadStylesheet(url: string, integrity?: string): Promise<void>;
+    /**
+     * 加载脚本
+     */
+    loadScript(url: string, integrity?: string): Promise<void>;
 }
 
 /**
- * 内置函数实现
- * 表达式中可调用的白名单函数
- */
-type BuiltinFn = (...args: unknown[]) => unknown;
-/**
- * 内置函数映射
- */
-declare const builtinFunctions: Record<string, BuiltinFn>;
-
-/**
- * Host API 实现
- * 提供给组件的安全 API
+ * 安全管理器
+ * SRI 校验、域名白名单、组件阻止、能力校验等
+ *
+ * 核心安全保证：
+ * - 组件加载必须校验 SRI (integrity.json)
+ * - 支持 registry blocklist（紧急止血）
+ * - CSP 推荐配置（脚本域名收敛）
+ * - 表达式引擎无 eval，函数白名单
  */
 
 /**
- * Host API 配置
+ * 组件能力类型（与 contracts CapabilityName 对齐）
  */
-interface HostAPIOptions {
-    /** API 基础 URL */
-    apiBaseUrl: string;
-    /** 认证 Token */
-    authToken?: string;
-    /** 请求头 */
-    headers?: Record<string, string>;
-    /** 状态管理器 */
-    stateManager: StateManager;
-    /** 事件总线 */
-    eventBus: EventBus;
-    /** 表达式引擎 */
-    expressionEngine: ExpressionEngine;
-    /** 运行时上下文 */
-    context: RuntimeContext;
-    /** 调试模式 */
-    debug?: boolean;
-    /** 日志器 */
-    logger?: Logger;
-}
+type CapabilityType = CapabilityName;
 /**
- * Host API 实现
+ * 被阻断的组件信息
  */
-declare class HostAPIImpl implements HostAPI {
-    private options;
-    private storageNamespace;
-    constructor(options: HostAPIOptions);
-    requestData<T = unknown>(queryId: string, params?: Record<string, unknown>): Promise<DataQueryResponse<T>>;
-    executeAction<T = unknown>(actionType: string, params?: Record<string, unknown>): Promise<ActionExecuteResponse<T>>;
-    navigate(options: NavigateOptions): void;
-    goBack(): void;
-    refresh(): void;
-    openDialog(options: DialogOptions): Promise<boolean | string>;
-    closeDialog(): void;
-    showToast(options: ToastOptions): void;
-    track(event: TrackEvent): void;
-    copyToClipboard(text: string): Promise<ClipboardResult>;
-    readFromClipboard(): Promise<ClipboardResult>;
-    getState<T = unknown>(key: string): T | undefined;
-    setState(key: string, value: unknown): void;
-    getVariable<T = unknown>(name: string): T | undefined;
-    postMessage(componentId: string, message: unknown): void;
-    broadcast(channel: string, message: unknown): void;
-    storage: {
-        get: <T = unknown>(key: string, options?: StorageOptions) => T | undefined;
-        set: (key: string, value: unknown, options?: StorageOptions) => void;
-        remove: (key: string, options?: StorageOptions) => void;
-    };
-    getContext(): RuntimeContext;
-    private buildHeaders;
-    private getStorageKey;
-    private generateIdempotencyKey;
-    private simpleHash;
-    private log;
+interface BlockedComponent {
+    name: string;
+    version: string;
+    reason: string;
+    blockedAt?: string;
+    blockedBy?: string;
+    urgent?: boolean;
+    fallbackVersion?: string;
 }
-
-/**
- * 安全管理器
- * SRI 校验、域名白名单、组件阻止等
- */
-
 /**
  * 安全管理器配置
  */
@@ -964,6 +1358,10 @@ interface SecurityManagerOptions {
     blockedComponents?: BlockedComponent[];
     /** 被阻断的动作类型 */
     blockedActions?: string[];
+    /** 允许的能力列表（白名单模式） */
+    allowedCapabilities?: CapabilityType[];
+    /** 是否应用 CSP */
+    applyCSPOnInit?: boolean;
     /** 日志器 */
     logger?: Logger;
 }
@@ -974,11 +1372,20 @@ declare class SecurityManager {
     private options;
     private blockedComponentsMap;
     private blockedActionsSet;
+    private allowedCapabilitiesSet;
     constructor(options?: SecurityManagerOptions);
     /**
      * 更新阻断列表
      */
-    updateBlockedList(components: BlockedComponent[], actions: string[]): void;
+    updateBlockedList(components: string[], actions: string[]): void;
+    /**
+     * 添加被阻断的组件
+     */
+    addBlockedComponent(component: BlockedComponent): void;
+    /**
+     * 移除组件阻断
+     */
+    removeBlockedComponent(name: string, version: string): void;
     /**
      * 检查组件是否被阻断
      */
@@ -987,18 +1394,44 @@ declare class SecurityManager {
      * 获取组件阻断信息
      */
     getBlockedInfo(name: string, version: string): BlockedComponent | undefined;
+    /**
+     * 获取所有被阻断的组件
+     */
+    getAllBlockedComponents(): BlockedComponent[];
     /**
      * 检查动作是否被阻断
      */
     isActionBlocked(actionType: string): boolean;
     /**
-     * 验证组件完整性
+     * 检查能力是否被允许
+     */
+    isCapabilityAllowed(capability: CapabilityType): boolean;
+    /**
+     * 校验组件能力声明
+     */
+    validateCapabilities(componentName: string, componentVersion: string, capabilities: CapabilityType[]): {
+        valid: boolean;
+        disallowed: CapabilityType[];
+    };
+    /**
+     * 验证组件完整性 (SRI)
+     */
+    validateIntegrity(name: string, version: string, content: string, expectedIntegrity: string): Promise<void>;
+    /**
+     * 生成 SRI 哈希
      */
-    validateComponent(name: string, version: string, content: string, expectedIntegrity: string): Promise<void>;
+    generateIntegrity(content: string, algorithm?: 'sha256' | 'sha384' | 'sha512'): Promise<string>;
     /**
      * 验证 URL 是否在白名单内
      */
     isAllowedUrl(url: string, type: 'cdn' | 'api'): boolean;
+    /**
+     * 验证外部 URL 安全性
+     */
+    validateExternalUrl(url: string): {
+        safe: boolean;
+        reason?: string;
+    };
     /**
      * 生成 CSP 策略
      */
@@ -1011,17 +1444,21 @@ declare class SecurityManager {
      * 确保组件未被阻断
      */
     assertNotBlocked(name: string, version: string): void;
+    /**
+     * 创建安全的 eval 替代方案（用于动态代码执行）
+     * 注意：应尽量避免使用，优先使用表达式引擎
+     */
+    createSafeEvaluator(): (code: string, context: Record<string, unknown>) => unknown;
     /**
      * 计算哈希值
      */
     private computeHash;
-    private _log;
-    protected get log(): (level: "debug" | "info" | "warn" | "error", message: string) => void;
+    private log;
 }
 
 /**
  * 基础渲染器
- * 框架无关的渲染核心
+ * 框架无关的渲染核心，支持 PageSchema V1.0.0
  */
 
 /**
@@ -1034,6 +1471,8 @@ interface BaseRendererOptions {
     components: Map<string, LoadedComponent>;
     /** Host API 注入函数 */
     injectHostApi: (element: HTMLElement, componentId: string) => void;
+    /** 事件处理器 */
+    onComponentEvent?: (componentId: string, eventName: string, handlers: EventHandler[], eventData: unknown) => void;
     /** 调试模式 */
     debug?: boolean;
     /** 日志器 */
@@ -1043,13 +1482,25 @@ interface BaseRendererOptions {
 }
 /**
  * 基础渲染器
- * 将 PageSchema 渲染为 DOM
+ * 将 PageSchema V1.0.0 渲染为 DOM
  */
 declare class BaseRenderer implements Renderer {
     private options;
     private container;
     private renderedElements;
+    private componentEventListeners;
+    /**
+     * 表达式上下文
+     * 使用 contracts 中的 ExpressionContext 定义：
+     * - state: 页面状态
+     * - binding: 数据绑定结果
+     * - local: 局部变量（循环变量、事件参数等）
+     * - props?: 组件属性
+     * - event?: 事件上下文
+     */
     private expressionContext;
+    private loopContextStack;
+    private styleElement;
     constructor(options: BaseRendererOptions);
     /**
      * 初始化渲染器
@@ -1067,18 +1518,85 @@ declare class BaseRenderer implements Renderer {
      * 更新表达式上下文
      */
     updateContext(context: Partial<ExpressionContext>): void;
+    /**
+     * 获取当前表达式上下文
+     */
+    getContext(): ExpressionContext;
     /**
      * 销毁渲染器
      */
     destroy(): void;
     /**
-     * 渲染单个组件
+     * 清理资源
+     */
+    private cleanup;
+    /**
+     * 渲染组件节点
+     */
+    private renderNode;
+    /**
+     * 创建组件元素
+     */
+    private createElement;
+    /**
+     * 渲染循环
+     */
+    private renderLoop;
+    /**
+     * 渲染子组件
+     */
+    private renderChildren;
+    /**
+     * 创建插槽容器
      */
-    private renderComponent;
+    private createSlotContainer;
+    /**
+     * 绑定事件处理器
+     */
+    private bindEventHandlers;
+    /**
+     * 创建节流处理器
+     */
+    private createThrottledHandler;
+    /**
+     * 创建防抖处理器
+     */
+    private createDebouncedHandler;
+    /**
+     * 求值条件表达式
+     */
+    private evaluateCondition;
+    /**
+     * 求值表达式
+     */
+    private evaluateExpression;
+    /**
+     * 构建表达式上下文（包含循环变量）
+     */
+    private buildExpressionContext;
+    /**
+     * 解析 props 中的表达式
+     */
+    /**
+     * Expression 类型列表（用于判断是否为 Expression 对象）
+     */
+    private static readonly EXPRESSION_TYPES;
     /**
      * 解析 props 中的表达式
+     *
+     * @param props - ComponentNode.props，类型为 Record<string, AnyValueOrExpression>
      */
     private resolveProps;
+    /**
+     * 解析单个值（支持 AnyValueOrExpression）
+     *
+     * AnyValueOrExpression 可以是：
+     * - Expression 对象：{ type: 'state' | 'binding' | 'local' | 'template' | 'computed', value: string, fallback?: any }
+     * - 原始值：string | number | boolean | null
+     * - 嵌套数组：AnyValueOrExpression[]
+     * - 嵌套对象：{ [key: string]: AnyValueOrExpression }
+     */
+    private resolveValue;
     /**
      * 应用 props 到元素
      */
@@ -1088,9 +1606,101 @@ declare class BaseRenderer implements Renderer {
      */
     private applyStyles;
     /**
-     * 应用页面样式
+     * 应用布局到元素
+     */
+    private applyLayout;
+    /**
+     * 应用响应式布局
+     */
+    private applyResponsiveLayout;
+    /**
+     * 将布局值转换为 CSS
+     */
+    private layoutToCSS;
+    /**
+     * 应用页面配置（PageConfig 结构）
+     *
+     * PageConfig 三层分离结构：
+     * - layout: PageLayoutConfig - 布局决策（关键路径，同步解析）
+     * - styles?: PageStylesConfig - 样式注入（可延迟应用）
+     * - behavior?: PageBehaviorConfig - 行为控制（独立处理）
+     */
+    private applyPageConfig;
+    /**
+     * 应用行为配置
+     */
+    private applyBehaviorConfig;
+    /**
+     * 应用国际化配置
+     *
+     * @description
+     * 根据 PageI18nConfig 设置页面语言环境：
+     * - 检测当前语言（根据 detection 策略）
+     * - 设置 HTML lang 属性
+     * - 初始化翻译上下文
+     */
+    private applyI18nConfig;
+    /**
+     * 检测当前语言
+     *
+     * @description
+     * 根据检测策略确定当前语言：
+     * - browser: 使用浏览器语言
+     * - url: URL 参数（如 ?lang=zh）
+     * - path: URL 路径（如 /zh/page）
+     * - cookie: Cookie 中的语言设置
+     * - header: Accept-Language 头（服务端使用）
+     * - manual: 手动设置，使用默认语言
      */
-    private applyPageStyles;
+    private detectLocale;
+    /**
+     * 从浏览器语言设置检测
+     */
+    private detectBrowserLocale;
+    /**
+     * 从 URL 参数检测（如 ?lang=zh）
+     */
+    private detectUrlLocale;
+    /**
+     * 从 URL 路径检测（如 /zh/page）
+     */
+    private detectPathLocale;
+    /**
+     * 从 Cookie 检测
+     */
+    private detectCookieLocale;
+    /**
+     * 获取文本方向（RTL 语言支持）
+     */
+    private getTextDirection;
+    /**
+     * 应用布局配置
+     */
+    private applyLayoutConfig;
+    /**
+     * 应用样式配置
+     */
+    private applyStylesConfig;
+    /**
+     * 应用主题配置
+     */
+    private applyThemeConfig;
+    /**
+     * 应用背景配置
+     */
+    private applyBackgroundConfig;
+    /**
+     * 注入自定义 CSS
+     */
+    private injectCustomCSS;
+    /**
+     * 初始化页面状态（从 PageState.fields）
+     */
+    private initializePageState;
+    /**
+     * 创建错误 fallback 元素
+     */
+    private createErrorFallback;
     private log;
 }
 
@@ -1110,19 +1720,33 @@ declare function createFallbackElement(type: 'fallback' | 'blocked' | 'error', m
 /**
  * 遥测管理器
  * 链路追踪、性能监控、错误上报
+ *
+ * 可观测字段贯穿：pageVersionId + componentVersion + actionId + traceId
+ *
+ * 集成方式：
+ * - OTel trace context 透传模块
+ * - Sentry 上报适配（release 对齐 runtimeVersion）
  */
 
 /**
- * Span 信息
+ * Span 信息（OpenTelemetry 兼容）
  */
 interface Span {
+    /** Span ID */
     spanId: string;
+    /** Trace ID */
     traceId: string;
+    /** 父 Span ID */
     parentSpanId?: string;
+    /** Span 名称 */
     name: string;
+    /** 开始时间 (ms) */
     startTime: number;
+    /** 结束时间 (ms) */
     endTime?: number;
+    /** 状态 */
     status?: 'ok' | 'error';
+    /** 属性 */
     attributes?: Record<string, unknown>;
 }
 /**
@@ -1135,14 +1759,47 @@ interface TelemetryManagerOptions {
     pageVersionId: string;
     /** 应用 ID */
     appId?: string;
+    /** 运行时版本（用于 Sentry release） */
+    runtimeVersion?: string;
     /** 采样率 (0-1) */
     sampleRate?: number;
     /** 上报 URL */
     endpoint?: string;
+    /** 批量上报大小 */
+    batchSize?: number;
+    /** 批量上报间隔 (ms) */
+    flushInterval?: number;
     /** 日志器 */
     logger?: Logger;
     /** 调试模式 */
     debug?: boolean;
+    /** 指标回调 */
+    onMetric?: (metric: PerformanceMetric) => void;
+    /** 错误回调 */
+    onError?: (error: TelemetryError) => void;
+}
+/**
+ * 遥测错误
+ */
+interface TelemetryError {
+    /** 错误类型 */
+    type: string;
+    /** 错误消息 */
+    message: string;
+    /** 堆栈 */
+    stack?: string;
+    /** 追踪 ID */
+    traceId: string;
+    /** 页面版本 ID */
+    pageVersionId: string;
+    /** 组件版本 */
+    componentVersion?: string;
+    /** 动作 ID */
+    actionId?: string;
+    /** 额外上下文 */
+    context?: Record<string, unknown>;
+    /** 时间戳 */
+    timestamp: number;
 }
 /**
  * 遥测管理器
@@ -1154,6 +1811,7 @@ declare class TelemetryManager {
     private metrics;
     private errors;
     private shouldSample;
+    private flushTimer?;
     constructor(options: TelemetryManagerOptions);
     /**
      * 获取 Trace ID
@@ -1161,8 +1819,17 @@ declare class TelemetryManager {
     getTraceId(): string;
     /**
      * 获取 W3C Trace Context 格式的 traceparent
+     * 格式: version-traceId-parentId-flags
+     */
+    getTraceparent(parentSpanId?: string): string;
+    /**
+     * 从 traceparent 解析 trace context
      */
-    getTraceparent(): string;
+    parseTraceparent(traceparent: string): {
+        traceId: string;
+        parentSpanId: string;
+        sampled: boolean;
+    } | null;
     /**
      * 开始一个 Span
      */
@@ -1170,23 +1837,15 @@ declare class TelemetryManager {
     /**
      * 结束一个 Span
      */
-    endSpan(spanId: string, status?: 'ok' | 'error'): void;
-    /**
-     * 记录性能指标
-     */
-    recordMetric(type: PerformanceMetric['type'], name: string, duration: number, extra?: Record<string, unknown>): void;
-    /**
-     * 记录错误
-     */
-    recordError(error: Error | RuntimeError, context?: Record<string, unknown>): void;
+    endSpan(spanId: string, status?: 'ok' | 'error', attributes?: Record<string, unknown>): void;
     /**
      * 记录页面加载时间
      */
-    recordPageLoad(duration: number, extra?: Record<string, unknown>): void;
+    recordPageLoad(duration: number): void;
     /**
      * 记录组件加载时间
      */
-    recordComponentLoad(name: string, version: string, duration: number, success: boolean): void;
+    recordComponentLoad(componentName: string, componentVersion: string, duration: number, success: boolean): void;
     /**
      * 记录首次渲染时间
      */
@@ -1194,11 +1853,19 @@ declare class TelemetryManager {
     /**
      * 记录动作执行时间
      */
-    recordActionExecute(actionType: string, duration: number, success: boolean): void;
+    recordActionExecute(actionType: string, actionId: string, duration: number, success: boolean): void;
     /**
      * 记录查询执行时间
      */
-    recordQueryExecute(queryId: string, duration: number, success: boolean, fromCache: boolean): void;
+    recordQueryExecute(queryId: string, duration: number, success: boolean, fromCache?: boolean): void;
+    /**
+     * 记录表达式求值时间
+     */
+    recordExpressionEval(_expression: string, duration: number, _success: boolean): void;
+    /**
+     * 记录错误
+     */
+    recordError(error: Error, context?: Record<string, unknown>): void;
     /**
      * 获取所有指标
      */
@@ -1207,6 +1874,20 @@ declare class TelemetryManager {
      * 获取所有 Span
      */
     getSpans(): Span[];
+    /**
+     * 获取所有错误
+     */
+    getErrors(): TelemetryError[];
+    /**
+     * 获取性能摘要
+     */
+    getPerformanceSummary(): {
+        pageLoadTime?: number;
+        firstRenderTime?: number;
+        componentCount: number;
+        avgComponentLoadTime: number;
+        errorCount: number;
+    };
     /**
      * 清理数据
      */
@@ -1215,14 +1896,116 @@ declare class TelemetryManager {
      * 刷新上报
      */
     flush(): Promise<void>;
-    private reportError;
-    private generateId;
+    /**
+     * 销毁管理器
+     */
+    destroy(): void;
+    private recordMetricInternal;
+    private startAutoFlush;
+    private generateTraceId;
+    private generateSpanId;
     private log;
 }
-declare module './telemetry-manager' {
-    interface TelemetryManagerOptions {
-        onMetric?: (metric: PerformanceMetric) => void;
-    }
+
+/**
+ * 生命周期管理器
+ * 处理 PageSchema 中的 PageLifecycle 配置
+ *
+ * 支持的生命周期钩子：
+ * - onMounted: 页面挂载完成时触发
+ * - onBeforeUnmount: 页面卸载前触发
+ * - onVisibilityChange: 页面可见性变化时触发
+ */
+
+/**
+ * 生命周期管理器配置
+ */
+interface LifecycleManagerOptions {
+    /** 动作桥接器 */
+    actionBridge: ActionBridge;
+    /** 获取表达式上下文 */
+    getContext: () => ExpressionContext;
+    /** 调试模式 */
+    debug?: boolean;
+    /** 日志器 */
+    logger?: Logger;
+    /** 生命周期事件回调 */
+    onLifecycleEvent?: (event: LifecycleEventType, data?: unknown) => void;
+}
+/**
+ * 生命周期事件类型
+ */
+type LifecycleEventType = 'mounted' | 'beforeUnmount' | 'visibilityChange';
+/**
+ * 生命周期管理器
+ * 管理页面生命周期事件的注册和触发
+ */
+declare class LifecycleManager {
+    private options;
+    private lifecycle;
+    private mounted;
+    private destroyed;
+    private cleanupFns;
+    constructor(options: LifecycleManagerOptions);
+    /**
+     * 注册生命周期钩子
+     */
+    register(lifecycle: PageLifecycle | undefined): void;
+    /**
+     * 触发 onMounted 生命周期
+     */
+    triggerMounted(): Promise<void>;
+    /**
+     * 触发 onBeforeUnmount 生命周期
+     */
+    triggerBeforeUnmount(): Promise<void>;
+    /**
+     * 触发 onVisibilityChange 生命周期
+     */
+    triggerVisibilityChange(isVisible: boolean): Promise<void>;
+    /**
+     * 销毁生命周期管理器
+     */
+    destroy(): Promise<void>;
+    /**
+     * 检查是否已挂载
+     */
+    isMounted(): boolean;
+    /**
+     * 检查是否已销毁
+     */
+    isDestroyed(): boolean;
+    /**
+     * 设置可见性监听器
+     */
+    private setupVisibilityListener;
+    /**
+     * 执行生命周期动作
+     */
+    private executeLifecycleActions;
+    /**
+     * 使用指定上下文执行生命周期动作
+     */
+    private executeLifecycleActionsWithContext;
+    private log;
 }
 
-export { type ASTNode, ActionBridge, type ActionBridgeOptions, ActionError, type ActionExecutor, AssetLoader, type AssetLoaderOptions, BaseRenderer, type BaseRendererOptions, ComponentBlockedError, ComponentLoadError, ComponentLoader, type ComponentLoaderOptions, DjvlcRuntime, DjvlcRuntimeError, type EvaluationResult, Evaluator, type EvaluatorOptions, EventBus, type EventBusOptions, type EventHandler, ExpressionEngine, type ExpressionEngineOptions, ExpressionError, HostAPIImpl, type HostAPIOptions, IntegrityError, Lexer, type LoadedComponent, type LogLevel, type Logger, PageLoadError, PageLoader, type PageLoaderOptions, Parser, QueryError, RenderError, type Renderer, type RuntimeOptions, type RuntimePhase, type RuntimeState, SecurityManager, type SecurityManagerOptions, type Span, type StateListener, StateManager, TelemetryManager, type TelemetryManagerOptions, type Token, type TokenType, type Unsubscribe, builtinFunctions, createFallbackElement, createRuntime, registerFallbackComponents };
+/**
+ * @djvlc/runtime-core
+ * DJV 低代码平台运行时核心库
+ *
+ * 核心原则：
+ * - 不可变版本：pageVersion/componentVersion 发布后永不修改
+ * - contracts 是宪法仓：只读依赖 @djvlc/contracts-* 系列包
+ * - 可观测字段贯穿：pageVersionId + componentVersion + actionId + traceId
+ * - 危险能力收口：业务动作只走 Action Gateway，数据访问只走 Data Proxy
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Runtime 版本号
+ */
+declare const RUNTIME_VERSION = "1.0.0";
+
+export { type ASTNode, ActionBridge, type ActionBridgeOptions, ActionError, type ActionExecutor, AssetLoader, type AssetLoaderOptions, BaseRenderer, type BaseRendererOptions, ComponentBlockedError, ComponentLoadError, type ComponentLoadResult, type ComponentLoadStatus, ComponentLoader, type ComponentLoaderOptions, DjvlcRuntime, DjvlcRuntimeError, type EvaluationResult, Evaluator, type EvaluatorOptions, EventBus, type EventBusOptions, type EventHandlerFn, ExpressionEngine, type ExpressionEngineOptions, ExpressionError, HostAPIImpl, type HostAPIOptions, IntegrityError, Lexer, type LifecycleEventType, LifecycleManager, type LifecycleManagerOptions, type LoadedComponent, type LogLevel, type Logger, type MetricType, PageLoadError, PageLoader, type PageLoaderOptions, type PageResolveResult, Parser, type PerformanceMetric, QueryError, RUNTIME_VERSION, RenderError, type Renderer, type RuntimeError, type RuntimeErrorType, type RuntimeEvent, type RuntimeEventType, type RuntimeOptions, type RuntimePhase, type RuntimeState, SUPPORTED_SCHEMA_VERSION as SCHEMA_VERSION, SUPPORTED_SCHEMA_VERSION, SecurityManager, type SecurityManagerOptions, type Span, type StateListener, StateManager, TelemetryManager, type TelemetryManagerOptions, type Token, type TokenType, type Unsubscribe, builtinFunctions, createFallbackElement, createRuntime, registerFallbackComponents };