@djvlc/runtime-core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,3368 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActionBridge: () => ActionBridge,
+  ActionError: () => ActionError,
+  AssetLoader: () => AssetLoader,
+  BaseRenderer: () => BaseRenderer,
+  ComponentBlockedError: () => ComponentBlockedError,
+  ComponentLoadError: () => ComponentLoadError,
+  ComponentLoader: () => ComponentLoader,
+  DjvlcRuntime: () => DjvlcRuntime,
+  DjvlcRuntimeError: () => DjvlcRuntimeError,
+  Evaluator: () => Evaluator,
+  EventBus: () => EventBus,
+  ExpressionEngine: () => ExpressionEngine,
+  ExpressionError: () => ExpressionError,
+  HostAPIImpl: () => HostAPIImpl,
+  IntegrityError: () => IntegrityError,
+  Lexer: () => Lexer,
+  PageLoadError: () => PageLoadError,
+  PageLoader: () => PageLoader,
+  Parser: () => Parser,
+  QueryError: () => QueryError,
+  RenderError: () => RenderError,
+  SecurityManager: () => SecurityManager,
+  StateManager: () => StateManager,
+  TelemetryManager: () => TelemetryManager,
+  builtinFunctions: () => builtinFunctions,
+  createFallbackElement: () => createFallbackElement,
+  createRuntime: () => createRuntime,
+  registerFallbackComponents: () => registerFallbackComponents
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/errors.ts
+var import_contracts_types = require("@djvlc/contracts-types");
+var DjvlcRuntimeError = class extends Error {
+  constructor(code, message, details, traceId) {
+    super(message || import_contracts_types.ErrorMessages[code] || "Unknown error");
+    this.name = "DjvlcRuntimeError";
+    this.code = code;
+    this.details = details;
+    this.traceId = traceId;
+    this.timestamp = Date.now();
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      traceId: this.traceId,
+      timestamp: this.timestamp
+    };
+  }
+};
+var PageLoadError = class extends DjvlcRuntimeError {
+  constructor(message, details, traceId) {
+    super(import_contracts_types.ErrorCode.PAGE_NOT_FOUND, message, details, traceId);
+    this.name = "PageLoadError";
+  }
+};
+var ComponentLoadError = class extends DjvlcRuntimeError {
+  constructor(componentName, componentVersion, message, code = import_contracts_types.ErrorCode.COMPONENT_NOT_FOUND, details) {
+    super(code, message, { ...details, componentName, componentVersion });
+    this.name = "ComponentLoadError";
+    this.componentName = componentName;
+    this.componentVersion = componentVersion;
+  }
+};
+var IntegrityError = class extends DjvlcRuntimeError {
+  constructor(componentName, componentVersion, expectedHash, actualHash) {
+    super(
+      import_contracts_types.ErrorCode.COMPONENT_INTEGRITY_MISMATCH,
+      `Integrity check failed for ${componentName}@${componentVersion}`,
+      { expectedHash, actualHash }
+    );
+    this.name = "IntegrityError";
+    this.componentName = componentName;
+    this.componentVersion = componentVersion;
+    this.expectedHash = expectedHash;
+    this.actualHash = actualHash;
+  }
+};
+var ComponentBlockedError = class extends DjvlcRuntimeError {
+  constructor(componentName, componentVersion, reason) {
+    super(import_contracts_types.ErrorCode.COMPONENT_BLOCKED, `Component ${componentName}@${componentVersion} is blocked`, {
+      componentName,
+      componentVersion,
+      reason
+    });
+    this.name = "ComponentBlockedError";
+    this.componentName = componentName;
+    this.componentVersion = componentVersion;
+    this.reason = reason;
+  }
+};
+var ExpressionError = class extends DjvlcRuntimeError {
+  constructor(expression, message, position, details) {
+    super(import_contracts_types.ErrorCode.UNKNOWN, message, { ...details, expression, position });
+    this.name = "ExpressionError";
+    this.expression = expression;
+    this.position = position;
+  }
+};
+var ActionError = class extends DjvlcRuntimeError {
+  constructor(actionType, message, code = import_contracts_types.ErrorCode.ACTION_EXECUTION_FAILED, actionId, details) {
+    super(code, message, { ...details, actionType, actionId });
+    this.name = "ActionError";
+    this.actionType = actionType;
+    this.actionId = actionId;
+  }
+};
+var QueryError = class extends DjvlcRuntimeError {
+  constructor(queryId, message, code = import_contracts_types.ErrorCode.QUERY_EXECUTION_FAILED, details) {
+    super(code, message, { ...details, queryId });
+    this.name = "QueryError";
+    this.queryId = queryId;
+  }
+};
+var RenderError = class extends DjvlcRuntimeError {
+  constructor(componentId, componentType, message, details) {
+    super(import_contracts_types.ErrorCode.UNKNOWN, message, { ...details, componentId, componentType });
+    this.name = "RenderError";
+    this.componentId = componentId;
+    this.componentType = componentType;
+  }
+};
+
+// src/loader/page-loader.ts
+var PageLoader = class {
+  constructor(options) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.options = {
+      channel: "prod",
+      cache: { enabled: true, maxAge: 300 },
+      ...options
+    };
+  }
+  /**
+   * 解析页面
+   * @param pageUid 页面 UID
+   * @param params 额外参数
+   */
+  async resolve(pageUid, params) {
+    const cacheKey = this.getCacheKey(pageUid, params);
+    if (this.options.cache?.enabled) {
+      const cached = this.cache.get(cacheKey);
+      if (cached && this.isCacheValid(cached.timestamp)) {
+        this.log("debug", `Page ${pageUid} loaded from cache`);
+        return cached.data;
+      }
+    }
+    const startTime = performance.now();
+    try {
+      const url = this.buildResolveUrl(pageUid, params);
+      const response = await fetch(url, {
+        method: "GET",
+        headers: this.buildHeaders()
+      });
+      if (!response.ok) {
+        throw new PageLoadError(
+          `Failed to resolve page: ${response.status} ${response.statusText}`,
+          { pageUid, status: response.status }
+        );
+      }
+      const result = await response.json();
+      if (!this.isValidPageResolveResult(result)) {
+        throw new PageLoadError("Invalid page resolve response", { pageUid });
+      }
+      const data = result.data;
+      if (this.options.cache?.enabled) {
+        this.cache.set(cacheKey, { data, timestamp: Date.now() });
+      }
+      const loadTime = performance.now() - startTime;
+      this.log("info", `Page ${pageUid} resolved in ${loadTime.toFixed(2)}ms`);
+      return data;
+    } catch (error) {
+      if (error instanceof PageLoadError) {
+        throw error;
+      }
+      throw new PageLoadError(
+        `Failed to resolve page: ${error instanceof Error ? error.message : "Unknown error"}`,
+        { pageUid }
+      );
+    }
+  }
+  /**
+   * 预连接 API 服务器
+   */
+  preconnect() {
+    const link = document.createElement("link");
+    link.rel = "preconnect";
+    link.href = this.options.apiBaseUrl;
+    document.head.appendChild(link);
+  }
+  /**
+   * 清除缓存
+   */
+  clearCache(pageUid) {
+    if (pageUid) {
+      for (const key of this.cache.keys()) {
+        if (key.startsWith(pageUid)) {
+          this.cache.delete(key);
+        }
+      }
+    } else {
+      this.cache.clear();
+    }
+  }
+  buildResolveUrl(pageUid, params) {
+    const url = new URL(`${this.options.apiBaseUrl}/page/resolve`);
+    url.searchParams.set("pageUid", pageUid);
+    if (this.options.channel) {
+      url.searchParams.set("channel", this.options.channel);
+    }
+    if (this.options.previewToken) {
+      url.searchParams.set("previewToken", this.options.previewToken);
+    }
+    if (params?.uid) {
+      url.searchParams.set("uid", params.uid);
+    }
+    if (params?.deviceId) {
+      url.searchParams.set("deviceId", params.deviceId);
+    }
+    return url.toString();
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.options.headers
+    };
+    if (this.options.authToken) {
+      headers["Authorization"] = `Bearer ${this.options.authToken}`;
+    }
+    return headers;
+  }
+  getCacheKey(pageUid, params) {
+    const parts = [pageUid, this.options.channel];
+    if (params?.uid) parts.push(params.uid);
+    if (params?.deviceId) parts.push(params.deviceId);
+    return parts.join(":");
+  }
+  isCacheValid(timestamp) {
+    const maxAge = (this.options.cache?.maxAge ?? 300) * 1e3;
+    return Date.now() - timestamp < maxAge;
+  }
+  isValidPageResolveResult(result) {
+    if (!result || typeof result !== "object") return false;
+    const r = result;
+    if (!r.data || typeof r.data !== "object") return false;
+    const data = r.data;
+    return typeof data.pageUid === "string" && typeof data.pageVersionId === "string" && data.pageJson !== void 0 && data.manifest !== void 0;
+  }
+  log(level, message) {
+    if (this.options.logger) {
+      this.options.logger[level](message);
+    }
+  }
+};
+
+// src/loader/component-loader.ts
+var ComponentLoader = class {
+  constructor(options) {
+    this.loadedComponents = /* @__PURE__ */ new Map();
+    this.loadingPromises = /* @__PURE__ */ new Map();
+    this.options = {
+      enableSRI: true,
+      concurrency: 4,
+      timeout: 3e4,
+      blockedComponents: [],
+      ...options
+    };
+    this.blockedSet = new Set(this.options.blockedComponents);
+  }
+  /**
+   * 加载单个组件
+   */
+  async load(item) {
+    const key = this.getComponentKey(item.name, item.version);
+    if (this.isBlocked(item.name, item.version)) {
+      throw new ComponentBlockedError(item.name, item.version, "Component is blocked");
+    }
+    const loaded = this.loadedComponents.get(key);
+    if (loaded) {
+      return loaded;
+    }
+    const loading = this.loadingPromises.get(key);
+    if (loading) {
+      return loading;
+    }
+    const loadPromise = this.loadComponent(item);
+    this.loadingPromises.set(key, loadPromise);
+    try {
+      const component = await loadPromise;
+      this.loadedComponents.set(key, component);
+      return component;
+    } finally {
+      this.loadingPromises.delete(key);
+    }
+  }
+  /**
+   * 加载 Manifest 中的所有组件
+   */
+  async loadAll(manifest) {
+    const results = /* @__PURE__ */ new Map();
+    const { concurrency = 4 } = this.options;
+    const components = manifest.components;
+    for (let i = 0; i < components.length; i += concurrency) {
+      const batch = components.slice(i, i + concurrency);
+      const batchPromises = batch.map(async (item) => {
+        const key = this.getComponentKey(item.name, item.version);
+        const startTime = performance.now();
+        try {
+          const loaded = await this.load(item);
+          results.set(key, {
+            name: item.name,
+            version: item.version,
+            status: "loaded",
+            component: loaded.Component,
+            loadTime: performance.now() - startTime
+          });
+        } catch (error) {
+          const status = error instanceof ComponentBlockedError ? "blocked" : "failed";
+          results.set(key, {
+            name: item.name,
+            version: item.version,
+            status,
+            error: error instanceof Error ? error.message : "Unknown error",
+            loadTime: performance.now() - startTime
+          });
+          if (item.critical) {
+            throw error;
+          }
+        }
+      });
+      await Promise.all(batchPromises);
+    }
+    return results;
+  }
+  /**
+   * 预加载组件
+   */
+  preload(items) {
+    items.forEach((item) => {
+      const link = document.createElement("link");
+      link.rel = "preload";
+      link.as = "script";
+      link.href = this.resolveUrl(item.entryUrl);
+      if (this.options.enableSRI && item.integrity) {
+        link.integrity = item.integrity;
+        link.crossOrigin = "anonymous";
+      }
+      document.head.appendChild(link);
+    });
+  }
+  /**
+   * 检查组件是否已加载
+   */
+  isLoaded(name, version) {
+    return this.loadedComponents.has(this.getComponentKey(name, version));
+  }
+  /**
+   * 获取已加载的组件
+   */
+  get(name, version) {
+    return this.loadedComponents.get(this.getComponentKey(name, version));
+  }
+  /**
+   * 检查组件是否被阻断
+   */
+  isBlocked(name, version) {
+    return this.blockedSet.has(`${name}@${version}`) || this.blockedSet.has(name);
+  }
+  /**
+   * 更新阻断列表
+   */
+  updateBlockedList(blocked) {
+    this.blockedSet = new Set(blocked);
+  }
+  async loadComponent(item) {
+    const startTime = performance.now();
+    const url = this.resolveUrl(item.entryUrl);
+    this.log("debug", `Loading component ${item.name}@${item.version}`);
+    try {
+      const response = await this.fetchWithTimeout(url);
+      if (!response.ok) {
+        throw new ComponentLoadError(
+          item.name,
+          item.version,
+          `Failed to fetch component: ${response.status} ${response.statusText}`
+        );
+      }
+      const content = await response.text();
+      if (this.options.enableSRI && item.integrity) {
+        await this.validateIntegrity(item, content);
+      }
+      const Component = await this.executeScript(content, item);
+      const loadTime = performance.now() - startTime;
+      this.log("info", `Component ${item.name}@${item.version} loaded in ${loadTime.toFixed(2)}ms`);
+      return {
+        name: item.name,
+        version: item.version,
+        Component,
+        loadTime
+      };
+    } catch (error) {
+      if (error instanceof ComponentLoadError || error instanceof IntegrityError || error instanceof ComponentBlockedError) {
+        throw error;
+      }
+      throw new ComponentLoadError(
+        item.name,
+        item.version,
+        `Failed to load component: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  async fetchWithTimeout(url) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.options.timeout);
+    try {
+      return await fetch(url, {
+        signal: controller.signal,
+        credentials: "omit"
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async validateIntegrity(item, content) {
+    if (!item.integrity) return;
+    const [algorithm, expectedHash] = item.integrity.split("-");
+    if (!algorithm || !expectedHash) {
+      throw new IntegrityError(item.name, item.version, item.integrity, "Invalid format");
+    }
+    const hashBuffer = await crypto.subtle.digest(
+      algorithm.toUpperCase(),
+      new TextEncoder().encode(content)
+    );
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const actualHash = btoa(String.fromCharCode(...hashArray));
+    if (actualHash !== expectedHash) {
+      throw new IntegrityError(item.name, item.version, expectedHash, actualHash);
+    }
+  }
+  async executeScript(content, item) {
+    const blob = new Blob([content], { type: "application/javascript" });
+    const blobUrl = URL.createObjectURL(blob);
+    try {
+      const module2 = await import(
+        /* @vite-ignore */
+        blobUrl
+      );
+      const Component = module2.default || module2[item.name] || module2.Component;
+      if (!Component) {
+        throw new ComponentLoadError(
+          item.name,
+          item.version,
+          "Component module does not export a valid component"
+        );
+      }
+      return Component;
+    } finally {
+      URL.revokeObjectURL(blobUrl);
+    }
+  }
+  resolveUrl(entryUrl) {
+    if (entryUrl.startsWith("http://") || entryUrl.startsWith("https://")) {
+      return entryUrl;
+    }
+    return `${this.options.cdnBaseUrl}/${entryUrl.replace(/^\//, "")}`;
+  }
+  getComponentKey(name, version) {
+    return `${name}@${version}`;
+  }
+  log(level, message) {
+    if (this.options.logger) {
+      this.options.logger[level](message);
+    }
+  }
+};
+
+// src/loader/asset-loader.ts
+var AssetLoader = class {
+  constructor(options) {
+    this.preconnectedHosts = /* @__PURE__ */ new Set();
+    this.preloadedAssets = /* @__PURE__ */ new Set();
+    this.options = options;
+  }
+  /**
+   * 预连接所有域名
+   */
+  preconnectAll() {
+    const allHosts = [...this.options.cdnHosts, ...this.options.apiHosts];
+    allHosts.forEach((host) => this.preconnect(host));
+  }
+  /**
+   * 预连接单个域名
+   */
+  preconnect(host) {
+    if (this.preconnectedHosts.has(host)) return;
+    const link = document.createElement("link");
+    link.rel = "preconnect";
+    link.href = host.startsWith("http") ? host : `https://${host}`;
+    link.crossOrigin = "anonymous";
+    document.head.appendChild(link);
+    this.preconnectedHosts.add(host);
+  }
+  /**
+   * DNS 预解析
+   */
+  dnsPrefetch(host) {
+    const link = document.createElement("link");
+    link.rel = "dns-prefetch";
+    link.href = host.startsWith("http") ? host : `https://${host}`;
+    document.head.appendChild(link);
+  }
+  /**
+   * 预加载脚本
+   */
+  preloadScript(url, integrity) {
+    if (this.preloadedAssets.has(url)) return;
+    const link = document.createElement("link");
+    link.rel = "preload";
+    link.as = "script";
+    link.href = url;
+    if (integrity) {
+      link.integrity = integrity;
+      link.crossOrigin = "anonymous";
+    }
+    document.head.appendChild(link);
+    this.preloadedAssets.add(url);
+  }
+  /**
+   * 预加载样式
+   */
+  preloadStyle(url, integrity) {
+    if (this.preloadedAssets.has(url)) return;
+    const link = document.createElement("link");
+    link.rel = "preload";
+    link.as = "style";
+    link.href = url;
+    if (integrity) {
+      link.integrity = integrity;
+      link.crossOrigin = "anonymous";
+    }
+    document.head.appendChild(link);
+    this.preloadedAssets.add(url);
+  }
+  /**
+   * 预加载图片
+   */
+  preloadImage(url) {
+    if (this.preloadedAssets.has(url)) return;
+    const link = document.createElement("link");
+    link.rel = "preload";
+    link.as = "image";
+    link.href = url;
+    document.head.appendChild(link);
+    this.preloadedAssets.add(url);
+  }
+  /**
+   * 预获取资源（低优先级）
+   */
+  prefetch(url, as) {
+    const link = document.createElement("link");
+    link.rel = "prefetch";
+    link.href = url;
+    if (as) link.as = as;
+    document.head.appendChild(link);
+  }
+  /**
+   * 加载样式表
+   */
+  loadStylesheet(url, integrity) {
+    return new Promise((resolve, reject) => {
+      const link = document.createElement("link");
+      link.rel = "stylesheet";
+      link.href = url;
+      if (integrity) {
+        link.integrity = integrity;
+        link.crossOrigin = "anonymous";
+      }
+      link.onload = () => resolve();
+      link.onerror = () => reject(new Error(`Failed to load stylesheet: ${url}`));
+      document.head.appendChild(link);
+    });
+  }
+  /**
+   * 加载脚本
+   */
+  loadScript(url, integrity) {
+    return new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      script.src = url;
+      script.async = true;
+      if (integrity) {
+        script.integrity = integrity;
+        script.crossOrigin = "anonymous";
+      }
+      script.onload = () => resolve();
+      script.onerror = () => reject(new Error(`Failed to load script: ${url}`));
+      document.body.appendChild(script);
+    });
+  }
+};
+
+// src/state/state-manager.ts
+var StateManager = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.state = this.createInitialState();
+  }
+  /**
+   * 获取当前状态
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * 获取当前阶段
+   */
+  getPhase() {
+    return this.state.phase;
+  }
+  /**
+   * 设置阶段
+   */
+  setPhase(phase) {
+    this.setState({ phase });
+  }
+  /**
+   * 设置页面数据
+   */
+  setPage(page) {
+    this.setState({
+      page,
+      variables: page.pageJson.page.variables || {}
+    });
+  }
+  /**
+   * 设置错误
+   */
+  setError(error) {
+    this.setState({
+      phase: "error",
+      error
+    });
+  }
+  /**
+   * 获取变量值
+   */
+  getVariable(key) {
+    return this.state.variables[key];
+  }
+  /**
+   * 设置变量值
+   */
+  setVariable(key, value) {
+    this.setState({
+      variables: {
+        ...this.state.variables,
+        [key]: value
+      }
+    });
+  }
+  /**
+   * 批量设置变量
+   */
+  setVariables(variables) {
+    this.setState({
+      variables: {
+        ...this.state.variables,
+        ...variables
+      }
+    });
+  }
+  /**
+   * 获取查询结果
+   */
+  getQuery(queryId) {
+    return this.state.queries[queryId];
+  }
+  /**
+   * 设置查询结果
+   */
+  setQuery(queryId, data) {
+    this.setState({
+      queries: {
+        ...this.state.queries,
+        [queryId]: data
+      }
+    });
+  }
+  /**
+   * 更新组件加载状态
+   */
+  setComponentStatus(key, result) {
+    const components = new Map(this.state.components);
+    components.set(key, result);
+    this.setState({ components });
+  }
+  /**
+   * 标记为已销毁
+   */
+  setDestroyed() {
+    this.setState({ destroyed: true });
+  }
+  /**
+   * 订阅状态变更
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * 重置状态
+   */
+  reset() {
+    this.state = this.createInitialState();
+    this.notifyListeners();
+  }
+  setState(partial) {
+    this.state = { ...this.state, ...partial };
+    this.notifyListeners();
+  }
+  notifyListeners() {
+    this.listeners.forEach((listener) => {
+      try {
+        listener(this.state);
+      } catch (error) {
+        console.error("State listener error:", error);
+      }
+    });
+  }
+  createInitialState() {
+    return {
+      phase: "idle",
+      page: null,
+      variables: {},
+      queries: {},
+      components: /* @__PURE__ */ new Map(),
+      error: null,
+      destroyed: false
+    };
+  }
+};
+
+// src/events/event-bus.ts
+var EventBus = class {
+  constructor(options = {}) {
+    this.handlers = /* @__PURE__ */ new Map();
+    this.options = {
+      debug: false,
+      maxListeners: 100,
+      ...options
+    };
+  }
+  /**
+   * 发送事件
+   */
+  emit(event) {
+    if (this.options.debug) {
+      this.log("debug", `Event emitted: ${event.type}`, event);
+    }
+    const handlers = this.handlers.get(event.type);
+    if (!handlers) return;
+    handlers.forEach((handler) => {
+      try {
+        handler(event);
+      } catch (error) {
+        this.log("error", `Error in event handler for ${event.type}:`, error);
+      }
+    });
+  }
+  /**
+   * 订阅事件
+   */
+  on(type, handler) {
+    let handlers = this.handlers.get(type);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.handlers.set(type, handlers);
+    }
+    if (handlers.size >= (this.options.maxListeners ?? 100)) {
+      this.log("warn", `Max listeners (${this.options.maxListeners}) reached for event: ${type}`);
+    }
+    handlers.add(handler);
+    return () => {
+      handlers?.delete(handler);
+      if (handlers?.size === 0) {
+        this.handlers.delete(type);
+      }
+    };
+  }
+  /**
+   * 取消订阅
+   */
+  off(type, handler) {
+    const handlers = this.handlers.get(type);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.handlers.delete(type);
+      }
+    }
+  }
+  /**
+   * 一次性订阅
+   */
+  once(type, handler) {
+    const wrappedHandler = (event) => {
+      unsubscribe();
+      handler(event);
+    };
+    const unsubscribe = this.on(type, wrappedHandler);
+    return unsubscribe;
+  }
+  /**
+   * 清除所有监听器
+   */
+  clear(type) {
+    if (type) {
+      this.handlers.delete(type);
+    } else {
+      this.handlers.clear();
+    }
+  }
+  /**
+   * 获取监听器数量
+   */
+  listenerCount(type) {
+    return this.handlers.get(type)?.size ?? 0;
+  }
+  /**
+   * 创建事件
+   */
+  static createEvent(type, data, traceId) {
+    return {
+      type,
+      data,
+      timestamp: Date.now(),
+      traceId
+    };
+  }
+  log(level, message, ...args) {
+    if (this.options.logger) {
+      this.options.logger[level](message, ...args);
+    } else if (this.options.debug) {
+      console[level](`[EventBus] ${message}`, ...args);
+    }
+  }
+};
+
+// src/events/action-bridge.ts
+var ActionBridge = class {
+  constructor(options) {
+    this.debounceTimers = /* @__PURE__ */ new Map();
+    this.throttleTimers = /* @__PURE__ */ new Map();
+    this.options = options;
+  }
+  /**
+   * 处理组件事件
+   */
+  async handleEvent(event, eventData, context) {
+    if (event.enabled === false) {
+      return;
+    }
+    if (event.condition) {
+      this.log("debug", `Event condition: ${event.condition}`);
+    }
+    if (event.debounce && event.debounce > 0) {
+      await this.debounce(event.id, event.debounce);
+    }
+    if (event.throttle && event.throttle > 0) {
+      if (!this.throttle(event.id, event.throttle)) {
+        return;
+      }
+    }
+    for (const action of event.actions) {
+      if (action.enabled === false) continue;
+      try {
+        if (action.delay && action.delay > 0) {
+          await this.delay(action.delay);
+        }
+        const params = this.resolveParams(action.params, eventData, context);
+        await this.executeAction(action, params);
+      } catch (error) {
+        this.log("error", `Action ${action.type} failed:`, error);
+      }
+    }
+  }
+  /**
+   * 销毁
+   */
+  destroy() {
+    this.debounceTimers.forEach((timer) => clearTimeout(timer));
+    this.debounceTimers.clear();
+    this.throttleTimers.clear();
+  }
+  async executeAction(action, params) {
+    this.log("debug", `Executing action: ${action.type}`, params);
+    const result = await this.options.executor.execute(action.type, params);
+    this.log("debug", `Action ${action.type} completed:`, result);
+  }
+  resolveParams(params, eventData, context) {
+    return {
+      ...params,
+      __eventData: eventData,
+      __context: context
+    };
+  }
+  debounce(id, delay) {
+    return new Promise((resolve) => {
+      const existing = this.debounceTimers.get(id);
+      if (existing) {
+        clearTimeout(existing);
+      }
+      const timer = setTimeout(() => {
+        this.debounceTimers.delete(id);
+        resolve();
+      }, delay);
+      this.debounceTimers.set(id, timer);
+    });
+  }
+  throttle(id, interval) {
+    const now = Date.now();
+    const lastTime = this.throttleTimers.get(id) ?? 0;
+    if (now - lastTime < interval) {
+      return false;
+    }
+    this.throttleTimers.set(id, now);
+    return true;
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  log(level, message, ...args) {
+    if (this.options.logger) {
+      this.options.logger[level](message, ...args);
+    } else if (this.options.debug) {
+      console[level](`[ActionBridge] ${message}`, ...args);
+    }
+  }
+};
+
+// src/expression/lexer.ts
+var Lexer = class {
+  constructor(input) {
+    this.pos = 0;
+    this.tokens = [];
+    this.input = input;
+  }
+  /**
+   * 分析表达式，返回 Token 列表
+   */
+  tokenize() {
+    this.pos = 0;
+    this.tokens = [];
+    while (this.pos < this.input.length) {
+      this.skipWhitespace();
+      if (this.pos >= this.input.length) break;
+      const token = this.readToken();
+      if (token) {
+        this.tokens.push(token);
+      }
+    }
+    this.tokens.push({
+      type: "EOF",
+      value: null,
+      start: this.input.length,
+      end: this.input.length
+    });
+    return this.tokens;
+  }
+  readToken() {
+    const char = this.input[this.pos];
+    const start = this.pos;
+    if (this.isDigit(char) || char === "-" && this.isDigit(this.peek(1))) {
+      return this.readNumber();
+    }
+    if (char === '"' || char === "'") {
+      return this.readString(char);
+    }
+    if (this.isIdentifierStart(char)) {
+      return this.readIdentifier();
+    }
+    const operator = this.readOperator();
+    if (operator) {
+      return operator;
+    }
+    switch (char) {
+      case ".":
+        this.pos++;
+        return { type: "DOT", value: ".", start, end: this.pos };
+      case "[":
+        this.pos++;
+        return { type: "LBRACKET", value: "[", start, end: this.pos };
+      case "]":
+        this.pos++;
+        return { type: "RBRACKET", value: "]", start, end: this.pos };
+      case "(":
+        this.pos++;
+        return { type: "LPAREN", value: "(", start, end: this.pos };
+      case ")":
+        this.pos++;
+        return { type: "RPAREN", value: ")", start, end: this.pos };
+      case ",":
+        this.pos++;
+        return { type: "COMMA", value: ",", start, end: this.pos };
+      case "?":
+        this.pos++;
+        return { type: "QUESTION", value: "?", start, end: this.pos };
+      case ":":
+        this.pos++;
+        return { type: "COLON", value: ":", start, end: this.pos };
+    }
+    throw new Error(`Unexpected character '${char}' at position ${this.pos}`);
+  }
+  readNumber() {
+    const start = this.pos;
+    let value = "";
+    if (this.input[this.pos] === "-") {
+      value += "-";
+      this.pos++;
+    }
+    while (this.isDigit(this.input[this.pos])) {
+      value += this.input[this.pos];
+      this.pos++;
+    }
+    if (this.input[this.pos] === "." && this.isDigit(this.peek(1))) {
+      value += ".";
+      this.pos++;
+      while (this.isDigit(this.input[this.pos])) {
+        value += this.input[this.pos];
+        this.pos++;
+      }
+    }
+    return {
+      type: "NUMBER",
+      value: parseFloat(value),
+      start,
+      end: this.pos
+    };
+  }
+  readString(quote) {
+    const start = this.pos;
+    this.pos++;
+    let value = "";
+    while (this.pos < this.input.length && this.input[this.pos] !== quote) {
+      if (this.input[this.pos] === "\\") {
+        this.pos++;
+        const escaped = this.input[this.pos];
+        switch (escaped) {
+          case "n":
+            value += "\n";
+            break;
+          case "t":
+            value += "	";
+            break;
+          case "r":
+            value += "\r";
+            break;
+          case "\\":
+            value += "\\";
+            break;
+          case '"':
+            value += '"';
+            break;
+          case "'":
+            value += "'";
+            break;
+          default:
+            value += escaped;
+        }
+      } else {
+        value += this.input[this.pos];
+      }
+      this.pos++;
+    }
+    if (this.input[this.pos] !== quote) {
+      throw new Error(`Unterminated string at position ${start}`);
+    }
+    this.pos++;
+    return {
+      type: "STRING",
+      value,
+      start,
+      end: this.pos
+    };
+  }
+  readIdentifier() {
+    const start = this.pos;
+    let value = "";
+    while (this.pos < this.input.length && this.isIdentifierChar(this.input[this.pos])) {
+      value += this.input[this.pos];
+      this.pos++;
+    }
+    if (value === "true") {
+      return { type: "BOOLEAN", value: true, start, end: this.pos };
+    }
+    if (value === "false") {
+      return { type: "BOOLEAN", value: false, start, end: this.pos };
+    }
+    if (value === "null") {
+      return { type: "NULL", value: null, start, end: this.pos };
+    }
+    return { type: "IDENTIFIER", value, start, end: this.pos };
+  }
+  readOperator() {
+    const start = this.pos;
+    const twoChar = this.input.slice(this.pos, this.pos + 2);
+    const oneChar = this.input[this.pos];
+    const twoCharOps = ["==", "!=", ">=", "<=", "&&", "||", "??"];
+    if (twoCharOps.includes(twoChar)) {
+      this.pos += 2;
+      return { type: "OPERATOR", value: twoChar, start, end: this.pos };
+    }
+    const oneCharOps = ["+", "-", "*", "/", "%", ">", "<", "!"];
+    if (oneCharOps.includes(oneChar)) {
+      this.pos++;
+      return { type: "OPERATOR", value: oneChar, start, end: this.pos };
+    }
+    return null;
+  }
+  skipWhitespace() {
+    while (this.pos < this.input.length && /\s/.test(this.input[this.pos])) {
+      this.pos++;
+    }
+  }
+  isDigit(char) {
+    return /[0-9]/.test(char);
+  }
+  isIdentifierStart(char) {
+    return /[a-zA-Z_$]/.test(char);
+  }
+  isIdentifierChar(char) {
+    return /[a-zA-Z0-9_$]/.test(char);
+  }
+  peek(offset = 1) {
+    return this.input[this.pos + offset] || "";
+  }
+};
+
+// src/expression/parser.ts
+var import_contracts_types2 = require("@djvlc/contracts-types");
+var PRECEDENCE = {
+  "||": 1,
+  "??": 1,
+  "&&": 2,
+  "==": 3,
+  "!=": 3,
+  "<": 4,
+  ">": 4,
+  "<=": 4,
+  ">=": 4,
+  "+": 5,
+  "-": 5,
+  "*": 6,
+  "/": 6,
+  "%": 6
+};
+var Parser = class {
+  constructor(tokens) {
+    this.pos = 0;
+    this.tokens = tokens;
+  }
+  /**
+   * 解析表达式
+   */
+  parse() {
+    const result = this.parseExpression();
+    if (this.current().type !== "EOF") {
+      throw new Error(`Unexpected token '${this.current().value}' at position ${this.current().start}`);
+    }
+    return result;
+  }
+  parseExpression() {
+    return this.parseTernary();
+  }
+  parseTernary() {
+    const test = this.parseBinary(0);
+    if (this.current().type === "QUESTION") {
+      this.advance();
+      const consequent = this.parseExpression();
+      this.expect("COLON");
+      const alternate = this.parseExpression();
+      return {
+        type: "conditional",
+        test,
+        consequent,
+        alternate,
+        raw: void 0
+      };
+    }
+    return test;
+  }
+  parseBinary(minPrecedence) {
+    let left = this.parseUnary();
+    while (true) {
+      const token = this.current();
+      if (token.type !== "OPERATOR") break;
+      const precedence = PRECEDENCE[token.value];
+      if (precedence === void 0 || precedence < minPrecedence) break;
+      this.advance();
+      const right = this.parseBinary(precedence + 1);
+      left = {
+        type: "binary",
+        operator: token.value,
+        left,
+        right,
+        raw: void 0
+      };
+    }
+    return left;
+  }
+  parseUnary() {
+    const token = this.current();
+    if (token.type === "OPERATOR" && (token.value === "!" || token.value === "-")) {
+      this.advance();
+      const argument = this.parseUnary();
+      return {
+        type: "unary",
+        operator: token.value,
+        argument,
+        raw: void 0
+      };
+    }
+    return this.parsePostfix();
+  }
+  parsePostfix() {
+    let node = this.parsePrimary();
+    while (true) {
+      const token = this.current();
+      if (token.type === "DOT") {
+        this.advance();
+        const propToken = this.expect("IDENTIFIER");
+        node = {
+          type: "member",
+          object: node,
+          property: propToken.value,
+          computed: false,
+          raw: void 0
+        };
+      } else if (token.type === "LBRACKET") {
+        this.advance();
+        const index = this.parseExpression();
+        this.expect("RBRACKET");
+        node = {
+          type: "member",
+          object: node,
+          property: index,
+          computed: true,
+          raw: void 0
+        };
+      } else if (token.type === "LPAREN" && node.type === "identifier") {
+        const callee = node.name;
+        if (!import_contracts_types2.BUILTIN_FUNCTION_NAMES.has(callee)) {
+          throw new Error(`Unknown function '${callee}' at position ${token.start}`);
+        }
+        this.advance();
+        const args = this.parseArguments();
+        this.expect("RPAREN");
+        node = {
+          type: "call",
+          callee,
+          arguments: args,
+          raw: void 0
+        };
+      } else {
+        break;
+      }
+    }
+    return node;
+  }
+  parsePrimary() {
+    const token = this.current();
+    if (token.type === "NUMBER" || token.type === "STRING" || token.type === "BOOLEAN" || token.type === "NULL") {
+      this.advance();
+      return {
+        type: "literal",
+        value: token.value,
+        start: token.start,
+        end: token.end,
+        raw: void 0
+      };
+    }
+    if (token.type === "IDENTIFIER") {
+      this.advance();
+      return {
+        type: "identifier",
+        name: token.value,
+        start: token.start,
+        end: token.end,
+        raw: void 0
+      };
+    }
+    if (token.type === "LBRACKET") {
+      return this.parseArray();
+    }
+    if (token.type === "LPAREN") {
+      this.advance();
+      const expr = this.parseExpression();
+      this.expect("RPAREN");
+      return expr;
+    }
+    throw new Error(`Unexpected token '${token.value}' at position ${token.start}`);
+  }
+  parseArray() {
+    const start = this.current().start;
+    this.advance();
+    const elements = [];
+    while (this.current().type !== "RBRACKET") {
+      elements.push(this.parseExpression());
+      if (this.current().type === "COMMA") {
+        this.advance();
+      } else {
+        break;
+      }
+    }
+    const end = this.current().end;
+    this.expect("RBRACKET");
+    return {
+      type: "array",
+      elements,
+      start,
+      end,
+      raw: void 0
+    };
+  }
+  parseArguments() {
+    const args = [];
+    if (this.current().type !== "RPAREN") {
+      args.push(this.parseExpression());
+      while (this.current().type === "COMMA") {
+        this.advance();
+        args.push(this.parseExpression());
+      }
+    }
+    return args;
+  }
+  current() {
+    return this.tokens[this.pos];
+  }
+  advance() {
+    return this.tokens[this.pos++];
+  }
+  expect(type) {
+    const token = this.current();
+    if (token.type !== type) {
+      throw new Error(`Expected '${type}' but got '${token.type}' at position ${token.start}`);
+    }
+    return this.advance();
+  }
+};
+
+// src/expression/functions.ts
+var builtinFunctions = {
+  // ==================== 字符串函数 ====================
+  len: (value) => {
+    if (typeof value === "string" || Array.isArray(value)) {
+      return value.length;
+    }
+    return 0;
+  },
+  trim: (str) => {
+    return String(str ?? "").trim();
+  },
+  upper: (str) => {
+    return String(str ?? "").toUpperCase();
+  },
+  lower: (str) => {
+    return String(str ?? "").toLowerCase();
+  },
+  substr: (str, start, length) => {
+    const s = String(str ?? "");
+    const startNum = Number(start) || 0;
+    const lengthNum = length !== void 0 ? Number(length) : void 0;
+    return s.substring(startNum, lengthNum !== void 0 ? startNum + lengthNum : void 0);
+  },
+  concat: (...args) => {
+    return args.map((a) => String(a ?? "")).join("");
+  },
+  replace: (str, search, replacement) => {
+    return String(str ?? "").split(String(search)).join(String(replacement));
+  },
+  split: (str, separator) => {
+    return String(str ?? "").split(String(separator));
+  },
+  join: (arr, separator) => {
+    if (!Array.isArray(arr)) return "";
+    return arr.join(separator !== void 0 ? String(separator) : ",");
+  },
+  startsWith: (str, search) => {
+    return String(str ?? "").startsWith(String(search));
+  },
+  endsWith: (str, search) => {
+    return String(str ?? "").endsWith(String(search));
+  },
+  contains: (str, search) => {
+    return String(str ?? "").includes(String(search));
+  },
+  // ==================== 数字函数 ====================
+  toNumber: (value) => {
+    const num = Number(value);
+    return isNaN(num) ? 0 : num;
+  },
+  toString: (value) => {
+    return String(value ?? "");
+  },
+  toInt: (value) => {
+    return Math.trunc(Number(value) || 0);
+  },
+  toFloat: (value) => {
+    return parseFloat(String(value)) || 0;
+  },
+  round: (value, decimals) => {
+    const num = Number(value) || 0;
+    const dec = Number(decimals) || 0;
+    const factor = Math.pow(10, dec);
+    return Math.round(num * factor) / factor;
+  },
+  floor: (value) => {
+    return Math.floor(Number(value) || 0);
+  },
+  ceil: (value) => {
+    return Math.ceil(Number(value) || 0);
+  },
+  abs: (value) => {
+    return Math.abs(Number(value) || 0);
+  },
+  min: (...args) => {
+    const nums = args.map((a) => Number(a)).filter((n) => !isNaN(n));
+    return nums.length > 0 ? Math.min(...nums) : 0;
+  },
+  max: (...args) => {
+    const nums = args.map((a) => Number(a)).filter((n) => !isNaN(n));
+    return nums.length > 0 ? Math.max(...nums) : 0;
+  },
+  sum: (arr) => {
+    if (!Array.isArray(arr)) return 0;
+    return arr.reduce((acc, val) => acc + (Number(val) || 0), 0);
+  },
+  avg: (arr) => {
+    if (!Array.isArray(arr) || arr.length === 0) return 0;
+    const sum = arr.reduce((acc, val) => acc + (Number(val) || 0), 0);
+    return sum / arr.length;
+  },
+  random: () => {
+    return Math.random();
+  },
+  randomInt: (min, max) => {
+    const minNum = Math.ceil(Number(min) || 0);
+    const maxNum = Math.floor(Number(max) || 100);
+    return Math.floor(Math.random() * (maxNum - minNum + 1)) + minNum;
+  },
+  // ==================== 日期函数 ====================
+  now: () => {
+    return Date.now();
+  },
+  today: () => {
+    return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  },
+  dateFormat: (timestamp, format) => {
+    const date = new Date(Number(timestamp) || Date.now());
+    const fmt = String(format || "YYYY-MM-DD");
+    const pad = (n) => n.toString().padStart(2, "0");
+    return fmt.replace("YYYY", date.getFullYear().toString()).replace("MM", pad(date.getMonth() + 1)).replace("DD", pad(date.getDate())).replace("HH", pad(date.getHours())).replace("mm", pad(date.getMinutes())).replace("ss", pad(date.getSeconds()));
+  },
+  dateParse: (dateStr) => {
+    const date = new Date(String(dateStr));
+    return date.getTime();
+  },
+  year: (timestamp) => {
+    return new Date(Number(timestamp) || Date.now()).getFullYear();
+  },
+  month: (timestamp) => {
+    return new Date(Number(timestamp) || Date.now()).getMonth() + 1;
+  },
+  day: (timestamp) => {
+    return new Date(Number(timestamp) || Date.now()).getDate();
+  },
+  addDays: (timestamp, days) => {
+    const date = new Date(Number(timestamp) || Date.now());
+    date.setDate(date.getDate() + (Number(days) || 0));
+    return date.getTime();
+  },
+  diffDays: (timestamp1, timestamp2) => {
+    const date1 = new Date(Number(timestamp1) || Date.now());
+    const date2 = new Date(Number(timestamp2) || Date.now());
+    const diffTime = Math.abs(date2.getTime() - date1.getTime());
+    return Math.floor(diffTime / (1e3 * 60 * 60 * 24));
+  },
+  // ==================== 类型检查函数 ====================
+  isNull: (value) => {
+    return value === null || value === void 0;
+  },
+  isUndefined: (value) => {
+    return value === void 0;
+  },
+  isEmpty: (value) => {
+    if (value === null || value === void 0) return true;
+    if (typeof value === "string") return value.length === 0;
+    if (Array.isArray(value)) return value.length === 0;
+    if (typeof value === "object") return Object.keys(value).length === 0;
+    return false;
+  },
+  isArray: (value) => {
+    return Array.isArray(value);
+  },
+  isObject: (value) => {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  },
+  isString: (value) => {
+    return typeof value === "string";
+  },
+  isNumber: (value) => {
+    return typeof value === "number" && !isNaN(value);
+  },
+  isBoolean: (value) => {
+    return typeof value === "boolean";
+  },
+  typeOf: (value) => {
+    if (value === null) return "null";
+    if (Array.isArray(value)) return "array";
+    return typeof value;
+  },
+  // ==================== 默认值函数 ====================
+  default: (value, defaultValue) => {
+    return value ?? defaultValue;
+  },
+  coalesce: (...args) => {
+    for (const arg of args) {
+      if (arg !== null && arg !== void 0) return arg;
+    }
+    return null;
+  },
+  ifElse: (condition, trueValue, falseValue) => {
+    return condition ? trueValue : falseValue;
+  },
+  // ==================== 数组函数 ====================
+  first: (arr) => {
+    if (!Array.isArray(arr)) return void 0;
+    return arr[0];
+  },
+  last: (arr) => {
+    if (!Array.isArray(arr)) return void 0;
+    return arr[arr.length - 1];
+  },
+  at: (arr, index) => {
+    if (!Array.isArray(arr)) return void 0;
+    return arr[Number(index) || 0];
+  },
+  slice: (arr, start, end) => {
+    if (!Array.isArray(arr)) return [];
+    return arr.slice(Number(start) || 0, end !== void 0 ? Number(end) : void 0);
+  },
+  includes: (arr, value) => {
+    if (!Array.isArray(arr)) return false;
+    return arr.includes(value);
+  },
+  indexOf: (arr, value) => {
+    if (!Array.isArray(arr)) return -1;
+    return arr.indexOf(value);
+  },
+  reverse: (arr) => {
+    if (!Array.isArray(arr)) return [];
+    return [...arr].reverse();
+  },
+  sort: (arr) => {
+    if (!Array.isArray(arr)) return [];
+    return [...arr].sort();
+  },
+  unique: (arr) => {
+    if (!Array.isArray(arr)) return [];
+    return [...new Set(arr)];
+  },
+  flatten: (arr) => {
+    if (!Array.isArray(arr)) return [];
+    return arr.flat();
+  },
+  count: (arr) => {
+    if (!Array.isArray(arr)) return 0;
+    return arr.length;
+  },
+  // ==================== 对象函数 ====================
+  get: (obj, path, defaultValue) => {
+    if (obj === null || obj === void 0) return defaultValue;
+    const pathStr = String(path);
+    const parts = pathStr.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current === null || current === void 0) return defaultValue;
+      current = current[part];
+    }
+    return current ?? defaultValue;
+  },
+  keys: (obj) => {
+    if (typeof obj !== "object" || obj === null) return [];
+    return Object.keys(obj);
+  },
+  values: (obj) => {
+    if (typeof obj !== "object" || obj === null) return [];
+    return Object.values(obj);
+  },
+  entries: (obj) => {
+    if (typeof obj !== "object" || obj === null) return [];
+    return Object.entries(obj);
+  },
+  has: (obj, key) => {
+    if (typeof obj !== "object" || obj === null) return false;
+    return String(key) in obj;
+  },
+  merge: (...objs) => {
+    const result = {};
+    for (const obj of objs) {
+      if (typeof obj === "object" && obj !== null) {
+        Object.assign(result, obj);
+      }
+    }
+    return result;
+  },
+  // ==================== 逻辑函数 ====================
+  and: (...args) => {
+    return args.every((a) => Boolean(a));
+  },
+  or: (...args) => {
+    return args.some((a) => Boolean(a));
+  },
+  not: (value) => {
+    return !value;
+  },
+  eq: (a, b) => {
+    return a === b;
+  },
+  ne: (a, b) => {
+    return a !== b;
+  },
+  gt: (a, b) => {
+    return Number(a) > Number(b);
+  },
+  gte: (a, b) => {
+    return Number(a) >= Number(b);
+  },
+  lt: (a, b) => {
+    return Number(a) < Number(b);
+  },
+  lte: (a, b) => {
+    return Number(a) <= Number(b);
+  },
+  between: (value, min, max) => {
+    const num = Number(value);
+    return num >= Number(min) && num <= Number(max);
+  },
+  // ==================== 格式化函数 ====================
+  formatNumber: (value, decimals) => {
+    const num = Number(value) || 0;
+    const dec = Number(decimals) ?? 0;
+    return num.toLocaleString(void 0, {
+      minimumFractionDigits: dec,
+      maximumFractionDigits: dec
+    });
+  },
+  formatCurrency: (value, currency) => {
+    const num = Number(value) || 0;
+    const cur = String(currency || "CNY");
+    return num.toLocaleString("zh-CN", { style: "currency", currency: cur });
+  },
+  formatPercent: (value, decimals) => {
+    const num = Number(value) || 0;
+    const dec = Number(decimals) ?? 0;
+    return (num * 100).toFixed(dec) + "%";
+  },
+  // ==================== JSON 函数 ====================
+  jsonParse: (str) => {
+    try {
+      return JSON.parse(String(str));
+    } catch {
+      return null;
+    }
+  },
+  jsonStringify: (value) => {
+    return JSON.stringify(value);
+  }
+};
+
+// src/expression/evaluator.ts
+var Evaluator = class {
+  constructor(options = {}) {
+    this.depth = 0;
+    this.startTime = 0;
+    this.options = {
+      maxDepth: 100,
+      timeout: 1e3,
+      debug: false,
+      ...options
+    };
+  }
+  /**
+   * 求值表达式
+   */
+  evaluate(ast, context) {
+    this.depth = 0;
+    this.startTime = Date.now();
+    try {
+      const value = this.evaluateNode(ast, context);
+      return { value };
+    } catch (error) {
+      return {
+        value: void 0,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+  evaluateNode(node, context) {
+    this.checkLimits();
+    switch (node.type) {
+      case "literal":
+        return this.evaluateLiteral(node);
+      case "identifier":
+        return this.evaluateIdentifier(node, context);
+      case "member":
+        return this.evaluateMember(node, context);
+      case "call":
+        return this.evaluateCall(node, context);
+      case "binary":
+        return this.evaluateBinary(node, context);
+      case "unary":
+        return this.evaluateUnary(node, context);
+      case "conditional":
+        return this.evaluateConditional(node, context);
+      case "array":
+        return this.evaluateArray(node, context);
+      default:
+        throw new ExpressionError("", `Unknown node type: ${node.type}`);
+    }
+  }
+  evaluateLiteral(node) {
+    return node.value;
+  }
+  evaluateIdentifier(node, context) {
+    const name = node.name;
+    switch (name) {
+      case "state":
+        return context.state;
+      case "query":
+        return context.query;
+      case "context":
+        return context.context;
+      case "event":
+        return context.event;
+      case "item":
+        return context.item;
+      case "index":
+        return context.index;
+      default:
+        throw new ExpressionError(
+          "",
+          `Unknown variable '${name}'`,
+          node.start !== void 0 && node.end !== void 0 ? { start: node.start, end: node.end } : void 0
+        );
+    }
+  }
+  evaluateMember(node, context) {
+    const object = this.evaluateNode(node.object, context);
+    if (object === null || object === void 0) {
+      return void 0;
+    }
+    let property;
+    if (node.computed) {
+      const propValue = this.evaluateNode(node.property, context);
+      property = propValue;
+    } else {
+      property = node.property;
+    }
+    if (typeof object === "object" && object !== null) {
+      return object[property];
+    }
+    return void 0;
+  }
+  evaluateCall(node, context) {
+    const fn = builtinFunctions[node.callee];
+    if (!fn) {
+      throw new ExpressionError("", `Unknown function '${node.callee}'`);
+    }
+    const args = node.arguments.map((arg) => this.evaluateNode(arg, context));
+    return fn(...args);
+  }
+  evaluateBinary(node, context) {
+    const op = node.operator;
+    if (op === "&&") {
+      const left2 = this.evaluateNode(node.left, context);
+      if (!left2) return left2;
+      return this.evaluateNode(node.right, context);
+    }
+    if (op === "||") {
+      const left2 = this.evaluateNode(node.left, context);
+      if (left2) return left2;
+      return this.evaluateNode(node.right, context);
+    }
+    if (op === "??") {
+      const left2 = this.evaluateNode(node.left, context);
+      if (left2 !== null && left2 !== void 0) return left2;
+      return this.evaluateNode(node.right, context);
+    }
+    const left = this.evaluateNode(node.left, context);
+    const right = this.evaluateNode(node.right, context);
+    switch (op) {
+      case "+":
+        if (typeof left === "string" || typeof right === "string") {
+          return String(left) + String(right);
+        }
+        return left + right;
+      case "-":
+        return left - right;
+      case "*":
+        return left * right;
+      case "/":
+        return left / right;
+      case "%":
+        return left % right;
+      case "==":
+        return left === right;
+      case "!=":
+        return left !== right;
+      case "<":
+        return left < right;
+      case ">":
+        return left > right;
+      case "<=":
+        return left <= right;
+      case ">=":
+        return left >= right;
+      default:
+        throw new ExpressionError("", `Unknown operator '${op}'`);
+    }
+  }
+  evaluateUnary(node, context) {
+    const argument = this.evaluateNode(node.argument, context);
+    switch (node.operator) {
+      case "!":
+        return !argument;
+      case "-":
+        return -argument;
+      default:
+        throw new ExpressionError("", `Unknown unary operator '${node.operator}'`);
+    }
+  }
+  evaluateConditional(node, context) {
+    const test = this.evaluateNode(node.test, context);
+    if (test) {
+      return this.evaluateNode(node.consequent, context);
+    }
+    return this.evaluateNode(node.alternate, context);
+  }
+  evaluateArray(node, context) {
+    return node.elements.map((el) => this.evaluateNode(el, context));
+  }
+  checkLimits() {
+    this.depth++;
+    if (this.depth > (this.options.maxDepth ?? 100)) {
+      throw new ExpressionError("", "Maximum recursion depth exceeded");
+    }
+    const elapsed = Date.now() - this.startTime;
+    if (elapsed > (this.options.timeout ?? 1e3)) {
+      throw new ExpressionError("", "Expression evaluation timeout");
+    }
+  }
+};
+
+// src/expression/engine.ts
+var ExpressionEngine = class {
+  constructor(options = {}) {
+    this.astCache = /* @__PURE__ */ new Map();
+    this.options = {
+      cacheAST: true,
+      maxCacheSize: 1e3,
+      ...options
+    };
+    this.evaluator = new Evaluator(options);
+  }
+  /**
+   * 求值表达式
+   */
+  evaluate(expression, context) {
+    try {
+      const ast = this.parse(expression);
+      return this.evaluator.evaluate(ast, context);
+    } catch (error) {
+      return {
+        value: void 0,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+  /**
+   * 求值表达式并返回值
+   * 出错时返回 fallback 值
+   */
+  evaluateWithFallback(expression, context, fallback) {
+    const result = this.evaluate(expression, context);
+    if (result.error) {
+      this.log("warn", `Expression evaluation failed: ${result.error.message}`, expression);
+      return fallback;
+    }
+    return result.value;
+  }
+  /**
+   * 求值模板字符串
+   * 支持 ${expression} 语法
+   */
+  evaluateTemplate(template, context) {
+    return template.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+      const result = this.evaluate(expr.trim(), context);
+      if (result.error) {
+        this.log("warn", `Template expression failed: ${result.error.message}`, expr);
+        return "";
+      }
+      return String(result.value ?? "");
+    });
+  }
+  /**
+   * 解析表达式为 AST
+   */
+  parse(expression) {
+    if (this.options.cacheAST) {
+      const cached = this.astCache.get(expression);
+      if (cached) {
+        return cached;
+      }
+    }
+    try {
+      const lexer = new Lexer(expression);
+      const tokens = lexer.tokenize();
+      const parser = new Parser(tokens);
+      const ast = parser.parse();
+      if (this.options.cacheAST) {
+        if (this.astCache.size >= (this.options.maxCacheSize ?? 1e3)) {
+          const keysToDelete = Array.from(this.astCache.keys()).slice(
+            0,
+            Math.floor(this.astCache.size / 2)
+          );
+          keysToDelete.forEach((key) => this.astCache.delete(key));
+        }
+        this.astCache.set(expression, ast);
+      }
+      return ast;
+    } catch (error) {
+      throw new ExpressionError(
+        expression,
+        error instanceof Error ? error.message : "Parse error"
+      );
+    }
+  }
+  /**
+   * 校验表达式
+   */
+  validate(expression) {
+    const errors = [];
+    const warnings = [];
+    const referencedPaths = [];
+    const calledFunctions = [];
+    try {
+      const ast = this.parse(expression);
+      this.collectReferences(ast, referencedPaths, calledFunctions);
+      return {
+        valid: true,
+        errors: [],
+        warnings,
+        referencedPaths,
+        calledFunctions
+      };
+    } catch (error) {
+      errors.push({
+        type: "SYNTAX_ERROR",
+        message: error instanceof Error ? error.message : "Parse error"
+      });
+      return {
+        valid: false,
+        errors,
+        warnings,
+        referencedPaths,
+        calledFunctions
+      };
+    }
+  }
+  /**
+   * 清除 AST 缓存
+   */
+  clearCache() {
+    this.astCache.clear();
+  }
+  collectReferences(node, paths, functions) {
+    switch (node.type) {
+      case "identifier":
+        paths.push(node.name);
+        break;
+      case "member": {
+        const path = this.buildMemberPath(node);
+        if (path) paths.push(path);
+        break;
+      }
+      case "call":
+        functions.push(node.callee);
+        node.arguments.forEach((arg) => this.collectReferences(arg, paths, functions));
+        break;
+      case "binary":
+        this.collectReferences(node.left, paths, functions);
+        this.collectReferences(node.right, paths, functions);
+        break;
+      case "unary":
+        this.collectReferences(node.argument, paths, functions);
+        break;
+      case "conditional":
+        this.collectReferences(node.test, paths, functions);
+        this.collectReferences(node.consequent, paths, functions);
+        this.collectReferences(node.alternate, paths, functions);
+        break;
+      case "array":
+        node.elements.forEach((el) => this.collectReferences(el, paths, functions));
+        break;
+    }
+  }
+  buildMemberPath(node) {
+    if (node.type === "identifier") {
+      return node.name;
+    }
+    if (node.type === "member" && !node.computed) {
+      const objectPath = this.buildMemberPath(node.object);
+      if (objectPath) {
+        return `${objectPath}.${node.property}`;
+      }
+    }
+    return null;
+  }
+  log(level, message, ...args) {
+    if (this.options.logger) {
+      this.options.logger[level](message, ...args);
+    } else if (this.options.debug) {
+      console[level](`[ExpressionEngine] ${message}`, ...args);
+    }
+  }
+};
+
+// src/host-api/host-api-impl.ts
+var HostAPIImpl = class {
+  constructor(options) {
+    // ==================== 存储 ====================
+    this.storage = {
+      get: (key, options) => {
+        const fullKey = this.getStorageKey(key, options?.namespace);
+        const item = localStorage.getItem(fullKey);
+        if (!item) return void 0;
+        try {
+          const parsed = JSON.parse(item);
+          if (parsed.expires && Date.now() > parsed.expires) {
+            localStorage.removeItem(fullKey);
+            return void 0;
+          }
+          return parsed.value;
+        } catch {
+          return void 0;
+        }
+      },
+      set: (key, value, options) => {
+        const fullKey = this.getStorageKey(key, options?.namespace);
+        const item = {
+          value,
+          expires: options?.ttl ? Date.now() + options.ttl * 1e3 : void 0
+        };
+        localStorage.setItem(fullKey, JSON.stringify(item));
+      },
+      remove: (key, options) => {
+        const fullKey = this.getStorageKey(key, options?.namespace);
+        localStorage.removeItem(fullKey);
+      }
+    };
+    this.options = options;
+    this.storageNamespace = `djvlc:${options.context.pageUid}`;
+  }
+  // ==================== 数据请求 ====================
+  async requestData(queryId, params) {
+    this.log("debug", `Requesting data: ${queryId}`, params);
+    const startTime = performance.now();
+    const context = this.options.context;
+    try {
+      const response = await fetch(`${this.options.apiBaseUrl}/data/query`, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({
+          queryVersionId: queryId,
+          params: params || {},
+          context: {
+            pageVersionId: context.pageVersionId,
+            uid: context.userId
+          }
+        })
+      });
+      const result = await response.json();
+      const duration = performance.now() - startTime;
+      this.log("debug", `Data query completed in ${duration.toFixed(2)}ms`);
+      if (result.success && result.data) {
+        this.options.stateManager.setQuery(queryId, result.data);
+      }
+      return result;
+    } catch (error) {
+      this.log("error", `Data query failed: ${queryId}`, error);
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "Query failed"
+      };
+    }
+  }
+  async executeAction(actionType, params) {
+    this.log("debug", `Executing action: ${actionType}`, params);
+    const startTime = performance.now();
+    const context = this.options.context;
+    try {
+      const response = await fetch(`${this.options.apiBaseUrl}/actions/execute`, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({
+          actionType,
+          params: params || {},
+          context: {
+            pageVersionId: context.pageVersionId,
+            uid: context.userId,
+            deviceId: context.deviceId,
+            channel: context.channel
+          },
+          idempotencyKey: this.generateIdempotencyKey(actionType, params)
+        })
+      });
+      const result = await response.json();
+      const duration = performance.now() - startTime;
+      this.log("debug", `Action completed in ${duration.toFixed(2)}ms`);
+      return result;
+    } catch (error) {
+      this.log("error", `Action failed: ${actionType}`, error);
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "Action failed"
+      };
+    }
+  }
+  // ==================== 导航 ====================
+  navigate(options) {
+    this.log("debug", "Navigate:", options);
+    this.track({
+      eventName: "navigate",
+      params: { url: options.url, newTab: options.newTab }
+    });
+    let url = options.url;
+    if (options.params) {
+      const searchParams = new URLSearchParams(options.params);
+      url += (url.includes("?") ? "&" : "?") + searchParams.toString();
+    }
+    if (options.newTab) {
+      window.open(url, "_blank");
+    } else if (options.replace) {
+      window.location.replace(url);
+    } else {
+      window.location.href = url;
+    }
+  }
+  goBack() {
+    this.log("debug", "Navigate back");
+    window.history.back();
+  }
+  refresh() {
+    this.log("debug", "Refresh page");
+    window.location.reload();
+  }
+  // ==================== 对话框 ====================
+  async openDialog(options) {
+    this.log("debug", "Open dialog:", options);
+    switch (options.type) {
+      case "alert":
+        window.alert(options.content || options.title);
+        return true;
+      case "confirm":
+        return window.confirm(options.content || options.title);
+      case "prompt":
+        return window.prompt(options.content || options.title) || "";
+      case "custom":
+        this.log("warn", "Custom dialog not implemented");
+        return false;
+      default:
+        return false;
+    }
+  }
+  closeDialog() {
+    this.log("debug", "Close dialog");
+  }
+  showToast(options) {
+    this.log("debug", "Show toast:", options);
+    const toast = document.createElement("div");
+    toast.className = `djvlc-toast djvlc-toast-${options.type || "info"} djvlc-toast-${options.position || "top"}`;
+    toast.textContent = options.message;
+    Object.assign(toast.style, {
+      position: "fixed",
+      left: "50%",
+      transform: "translateX(-50%)",
+      padding: "12px 24px",
+      borderRadius: "8px",
+      color: "#fff",
+      fontSize: "14px",
+      zIndex: "10000",
+      animation: "djvlc-toast-fade-in 0.3s ease"
+    });
+    const colors = {
+      success: "#52c41a",
+      error: "#ff4d4f",
+      warning: "#faad14",
+      info: "#1890ff"
+    };
+    toast.style.backgroundColor = colors[options.type || "info"];
+    const positions = {
+      top: { top: "20px" },
+      center: { top: "50%", transform: "translate(-50%, -50%)" },
+      bottom: { bottom: "20px" }
+    };
+    Object.assign(toast.style, positions[options.position || "top"]);
+    document.body.appendChild(toast);
+    setTimeout(() => {
+      toast.style.animation = "djvlc-toast-fade-out 0.3s ease";
+      setTimeout(() => toast.remove(), 300);
+    }, options.duration || 3e3);
+  }
+  // ==================== 埋点 ====================
+  track(event) {
+    this.log("debug", "Track event:", event);
+    const context = this.options.context;
+    fetch(`${this.options.apiBaseUrl}/track`, {
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: JSON.stringify({
+        eventName: event.eventName,
+        params: event.params,
+        timestamp: event.timestamp || Date.now(),
+        context: {
+          pageVersionId: context.pageVersionId,
+          runtimeVersion: context.runtimeVersion,
+          userId: context.userId,
+          deviceId: context.deviceId,
+          channel: context.channel
+        }
+      }),
+      keepalive: true
+      // 页面关闭时也能发送
+    }).catch((error) => {
+      this.log("warn", "Track failed:", error);
+    });
+  }
+  // ==================== 剪贴板 ====================
+  async copyToClipboard(text) {
+    try {
+      await navigator.clipboard.writeText(text);
+      return { success: true, content: text };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Copy failed"
+      };
+    }
+  }
+  async readFromClipboard() {
+    try {
+      const text = await navigator.clipboard.readText();
+      return { success: true, content: text };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Read failed"
+      };
+    }
+  }
+  // ==================== 状态管理 ====================
+  getState(key) {
+    return this.options.stateManager.getVariable(key);
+  }
+  setState(key, value) {
+    this.options.stateManager.setVariable(key, value);
+  }
+  getVariable(name) {
+    return this.options.stateManager.getVariable(name);
+  }
+  // ==================== 组件通信 ====================
+  postMessage(componentId, message) {
+    this.log("debug", `Post message to ${componentId}:`, message);
+    const event = new CustomEvent(`djvlc:message:${componentId}`, {
+      detail: { message, from: this.options.context.pageUid }
+    });
+    document.dispatchEvent(event);
+  }
+  broadcast(channel, message) {
+    this.log("debug", `Broadcast to ${channel}:`, message);
+    const event = new CustomEvent(`djvlc:broadcast:${channel}`, {
+      detail: { message, from: this.options.context.pageUid }
+    });
+    document.dispatchEvent(event);
+  }
+  // ==================== 上下文信息 ====================
+  getContext() {
+    return { ...this.options.context };
+  }
+  // ==================== 私有方法 ====================
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.options.headers
+    };
+    if (this.options.authToken) {
+      headers["Authorization"] = `Bearer ${this.options.authToken}`;
+    }
+    return headers;
+  }
+  getStorageKey(key, namespace) {
+    return `${namespace || this.storageNamespace}:${key}`;
+  }
+  generateIdempotencyKey(actionType, params) {
+    const timestamp = Date.now();
+    const paramsStr = JSON.stringify(params || {});
+    return `${actionType}:${timestamp}:${this.simpleHash(paramsStr)}`;
+  }
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(36);
+  }
+  log(level, message, ...args) {
+    if (this.options.logger) {
+      this.options.logger[level](message, ...args);
+    } else if (this.options.debug) {
+      console[level](`[HostAPI] ${message}`, ...args);
+    }
+  }
+};
+
+// src/security/security-manager.ts
+var SecurityManager = class {
+  constructor(options = {}) {
+    this.blockedComponentsMap = /* @__PURE__ */ new Map();
+    this.blockedActionsSet = /* @__PURE__ */ new Set();
+    this.options = {
+      enableSRI: true,
+      cdnDomains: [],
+      apiDomains: [],
+      blockedComponents: [],
+      blockedActions: [],
+      ...options
+    };
+    this.updateBlockedList(options.blockedComponents || [], options.blockedActions || []);
+  }
+  /**
+   * 更新阻断列表
+   */
+  updateBlockedList(components, actions) {
+    this.blockedComponentsMap.clear();
+    components.forEach((c) => {
+      this.blockedComponentsMap.set(`${c.name}@${c.version}`, c);
+    });
+    this.blockedActionsSet = new Set(actions);
+  }
+  /**
+   * 检查组件是否被阻断
+   */
+  isComponentBlocked(name, version) {
+    return this.blockedComponentsMap.has(`${name}@${version}`);
+  }
+  /**
+   * 获取组件阻断信息
+   */
+  getBlockedInfo(name, version) {
+    return this.blockedComponentsMap.get(`${name}@${version}`);
+  }
+  /**
+   * 检查动作是否被阻断
+   */
+  isActionBlocked(actionType) {
+    return this.blockedActionsSet.has(actionType);
+  }
+  /**
+   * 验证组件完整性
+   */
+  async validateComponent(name, version, content, expectedIntegrity) {
+    if (!this.options.enableSRI) return;
+    const [algorithm, expectedHash] = expectedIntegrity.split("-");
+    if (!algorithm || !expectedHash) {
+      throw new IntegrityError(name, version, expectedIntegrity, "Invalid format");
+    }
+    const actualHash = await this.computeHash(content, algorithm);
+    if (actualHash !== expectedHash) {
+      throw new IntegrityError(name, version, expectedHash, actualHash);
+    }
+  }
+  /**
+   * 验证 URL 是否在白名单内
+   */
+  isAllowedUrl(url, type) {
+    const domains = type === "cdn" ? this.options.cdnDomains : this.options.apiDomains;
+    if (!domains || domains.length === 0) return true;
+    try {
+      const parsedUrl = new URL(url);
+      return domains.some((domain) => {
+        if (domain.startsWith("*.")) {
+          const suffix = domain.slice(2);
+          return parsedUrl.hostname.endsWith(suffix);
+        }
+        return parsedUrl.hostname === domain;
+      });
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 生成 CSP 策略
+   */
+  generateCSPPolicy() {
+    const cdnDomains = this.options.cdnDomains || [];
+    const apiDomains = this.options.apiDomains || [];
+    const scriptSrc = ["'self'", ...cdnDomains].join(" ");
+    const connectSrc = ["'self'", ...apiDomains].join(" ");
+    const styleSrc = ["'self'", "'unsafe-inline'", ...cdnDomains].join(" ");
+    const imgSrc = ["'self'", "data:", "blob:", ...cdnDomains].join(" ");
+    return [
+      `default-src 'self'`,
+      `script-src ${scriptSrc}`,
+      `style-src ${styleSrc}`,
+      `img-src ${imgSrc}`,
+      `connect-src ${connectSrc}`,
+      `font-src 'self' data: ${cdnDomains.join(" ")}`,
+      `frame-ancestors 'self'`,
+      `base-uri 'self'`,
+      `form-action 'self'`
+    ].join("; ");
+  }
+  /**
+   * 应用 CSP 策略
+   */
+  applyCSP() {
+    const meta = document.createElement("meta");
+    meta.httpEquiv = "Content-Security-Policy";
+    meta.content = this.generateCSPPolicy();
+    document.head.appendChild(meta);
+  }
+  /**
+   * 确保组件未被阻断
+   */
+  assertNotBlocked(name, version) {
+    const blocked = this.getBlockedInfo(name, version);
+    if (blocked) {
+      throw new ComponentBlockedError(name, version, blocked.reason);
+    }
+  }
+  /**
+   * 计算哈希值
+   */
+  async computeHash(content, algorithm) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(content);
+    const hashBuffer = await crypto.subtle.digest(
+      algorithm.toUpperCase(),
+      data
+    );
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return btoa(String.fromCharCode(...hashArray));
+  }
+  _log(level, message) {
+    if (this.options.logger) {
+      this.options.logger[level](message);
+    }
+  }
+  // 使用 _log 避免 unused 错误，后续可按需启用日志
+  get log() {
+    return this._log.bind(this);
+  }
+};
+
+// src/telemetry/telemetry-manager.ts
+var TelemetryManager = class {
+  constructor(options) {
+    this.spans = /* @__PURE__ */ new Map();
+    this.metrics = [];
+    this.errors = [];
+    this.options = {
+      enabled: true,
+      sampleRate: 1,
+      ...options
+    };
+    this.traceId = this.generateId();
+    this.shouldSample = Math.random() < (this.options.sampleRate ?? 1);
+  }
+  /**
+   * 获取 Trace ID
+   */
+  getTraceId() {
+    return this.traceId;
+  }
+  /**
+   * 获取 W3C Trace Context 格式的 traceparent
+   */
+  getTraceparent() {
+    return `00-${this.traceId}-${this.generateId().slice(0, 16)}-01`;
+  }
+  /**
+   * 开始一个 Span
+   */
+  startSpan(name, parentSpanId, attributes) {
+    const span = {
+      spanId: this.generateId().slice(0, 16),
+      traceId: this.traceId,
+      parentSpanId,
+      name,
+      startTime: performance.now(),
+      attributes
+    };
+    this.spans.set(span.spanId, span);
+    this.log("debug", `Span started: ${name} (${span.spanId})`);
+    return span;
+  }
+  /**
+   * 结束一个 Span
+   */
+  endSpan(spanId, status = "ok") {
+    const span = this.spans.get(spanId);
+    if (span) {
+      span.endTime = performance.now();
+      span.status = status;
+      this.log("debug", `Span ended: ${span.name} (${spanId}) - ${span.endTime - span.startTime}ms`);
+    }
+  }
+  /**
+   * 记录性能指标
+   */
+  recordMetric(type, name, duration, extra) {
+    const metric = {
+      type,
+      name,
+      duration,
+      startTime: performance.now() - duration,
+      extra
+    };
+    this.metrics.push(metric);
+    this.log("debug", `Metric: ${type} - ${name} - ${duration}ms`);
+    if (this.options.onMetric) {
+      this.options.onMetric(metric);
+    }
+  }
+  /**
+   * 记录错误
+   */
+  recordError(error, context) {
+    const runtimeError = {
+      type: "LOAD_ERROR",
+      message: error.message,
+      stack: error instanceof Error ? error.stack : void 0,
+      timestamp: Date.now(),
+      traceId: this.traceId,
+      ...context
+    };
+    this.errors.push(runtimeError);
+    this.log("error", `Error recorded: ${error.message}`);
+    if (this.shouldSample && this.options.enabled) {
+      this.reportError(runtimeError);
+    }
+  }
+  /**
+   * 记录页面加载时间
+   */
+  recordPageLoad(duration, extra) {
+    this.recordMetric("page_resolve", "page_load", duration, {
+      pageVersionId: this.options.pageVersionId,
+      ...extra
+    });
+  }
+  /**
+   * 记录组件加载时间
+   */
+  recordComponentLoad(name, version, duration, success) {
+    this.recordMetric("component_load", `${name}@${version}`, duration, {
+      success
+    });
+  }
+  /**
+   * 记录首次渲染时间
+   */
+  recordFirstRender(duration) {
+    this.recordMetric("first_render", "first_render", duration, {
+      pageVersionId: this.options.pageVersionId
+    });
+  }
+  /**
+   * 记录动作执行时间
+   */
+  recordActionExecute(actionType, duration, success) {
+    this.recordMetric("action_execute", actionType, duration, { success });
+  }
+  /**
+   * 记录查询执行时间
+   */
+  recordQueryExecute(queryId, duration, success, fromCache) {
+    this.recordMetric("query_execute", queryId, duration, {
+      success,
+      fromCache
+    });
+  }
+  /**
+   * 获取所有指标
+   */
+  getMetrics() {
+    return [...this.metrics];
+  }
+  /**
+   * 获取所有 Span
+   */
+  getSpans() {
+    return Array.from(this.spans.values());
+  }
+  /**
+   * 清理数据
+   */
+  clear() {
+    this.spans.clear();
+    this.metrics = [];
+    this.errors = [];
+  }
+  /**
+   * 刷新上报
+   */
+  async flush() {
+    if (!this.shouldSample || !this.options.enabled || !this.options.endpoint) {
+      return;
+    }
+    const payload = {
+      traceId: this.traceId,
+      pageVersionId: this.options.pageVersionId,
+      appId: this.options.appId,
+      spans: this.getSpans(),
+      metrics: this.metrics,
+      errors: this.errors,
+      timestamp: Date.now()
+    };
+    try {
+      await fetch(this.options.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        keepalive: true
+      });
+    } catch (error) {
+      this.log("warn", "Failed to flush telemetry:", error);
+    }
+  }
+  reportError(error) {
+    if (this.options.endpoint) {
+      fetch(`${this.options.endpoint}/errors`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(error),
+        keepalive: true
+      }).catch(() => {
+      });
+    }
+  }
+  generateId() {
+    const array = new Uint8Array(16);
+    crypto.getRandomValues(array);
+    return Array.from(array, (b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  log(level, message, ...args) {
+    if (this.options.logger) {
+      this.options.logger[level](message, ...args);
+    } else if (this.options.debug) {
+      console[level](`[Telemetry] ${message}`, ...args);
+    }
+  }
+};
+
+// src/renderer/base-renderer.ts
+var import_contracts_types3 = require("@djvlc/contracts-types");
+var BaseRenderer = class {
+  constructor(options) {
+    this.container = null;
+    this.renderedElements = /* @__PURE__ */ new Map();
+    this.expressionContext = {
+      state: {},
+      query: {},
+      context: {}
+    };
+    this.options = options;
+  }
+  /**
+   * 初始化渲染器
+   */
+  init() {
+    this.log("debug", "Renderer initialized");
+  }
+  /**
+   * 渲染页面
+   */
+  render(schema, container) {
+    this.container = container;
+    this.log("debug", "Rendering page", schema.page.id);
+    container.innerHTML = "";
+    this.applyPageStyles(schema.page.canvas);
+    const fragment = document.createDocumentFragment();
+    for (const component of schema.components) {
+      const element = this.renderComponent(component);
+      if (element) {
+        fragment.appendChild(element);
+      }
+    }
+    container.appendChild(fragment);
+    this.log("info", `Rendered ${schema.components.length} components`);
+  }
+  /**
+   * 更新组件属性
+   */
+  updateComponent(componentId, props) {
+    const element = this.renderedElements.get(componentId);
+    if (!element) {
+      this.log("warn", `Component not found: ${componentId}`);
+      return;
+    }
+    this.applyProps(element, props);
+  }
+  /**
+   * 更新表达式上下文
+   */
+  updateContext(context) {
+    this.expressionContext = {
+      ...this.expressionContext,
+      ...context
+    };
+  }
+  /**
+   * 销毁渲染器
+   */
+  destroy() {
+    this.renderedElements.forEach((element) => {
+      element.remove();
+    });
+    this.renderedElements.clear();
+    if (this.container) {
+      this.container.innerHTML = "";
+    }
+    this.log("debug", "Renderer destroyed");
+  }
+  /**
+   * 渲染单个组件
+   */
+  renderComponent(instance) {
+    const { id, type, props, style, children, visible } = instance;
+    if (visible === false) {
+      return null;
+    }
+    try {
+      const loadedComponent = this.options.components.get(type);
+      let element;
+      if (loadedComponent && customElements.get(type)) {
+        element = document.createElement(type);
+      } else {
+        element = document.createElement("div");
+        element.className = `djvlc-component djvlc-${type}`;
+        if (!loadedComponent) {
+          this.log("warn", `Component not loaded: ${type}`);
+          element.textContent = `[Component: ${type}]`;
+        }
+      }
+      element.setAttribute("data-component-id", id);
+      element.setAttribute("data-component-type", type);
+      const resolvedProps = this.resolveProps(props);
+      this.applyProps(element, resolvedProps);
+      if (style) {
+        this.applyStyles(element, style);
+      }
+      this.options.injectHostApi(element, id);
+      if (children && children.length > 0) {
+        for (const child of children) {
+          const childElement = this.renderComponent(child);
+          if (childElement) {
+            element.appendChild(childElement);
+          }
+        }
+      }
+      this.renderedElements.set(id, element);
+      return element;
+    } catch (error) {
+      this.log("error", `Failed to render component: ${id}`, error);
+      if (this.options.onRenderError) {
+        return this.options.onRenderError(id, error);
+      }
+      const fallback = document.createElement("div");
+      fallback.className = "djvlc-error-boundary";
+      fallback.textContent = `Error rendering component: ${type}`;
+      return fallback;
+    }
+  }
+  /**
+   * 解析 props 中的表达式
+   */
+  resolveProps(props) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(props)) {
+      if ((0, import_contracts_types3.isExpressionBinding)(value)) {
+        const result = this.options.expressionEngine.evaluateWithFallback(
+          value.expression,
+          this.expressionContext,
+          value.fallback
+        );
+        resolved[key] = result;
+      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        resolved[key] = this.resolveProps(value);
+      } else {
+        resolved[key] = value;
+      }
+    }
+    return resolved;
+  }
+  /**
+   * 应用 props 到元素
+   */
+  applyProps(element, props) {
+    for (const [key, value] of Object.entries(props)) {
+      if (value === null || value === void 0) continue;
+      if (element.tagName.includes("-")) {
+        element[key] = value;
+      } else {
+        if (typeof value === "boolean") {
+          if (value) {
+            element.setAttribute(key, "");
+          } else {
+            element.removeAttribute(key);
+          }
+        } else if (typeof value === "object") {
+          element.setAttribute(key, JSON.stringify(value));
+        } else {
+          element.setAttribute(key, String(value));
+        }
+      }
+    }
+  }
+  /**
+   * 应用样式到元素
+   */
+  applyStyles(element, style) {
+    for (const [key, value] of Object.entries(style)) {
+      if (value === null || value === void 0) continue;
+      let cssValue;
+      if (typeof value === "number") {
+        const unitless = ["zIndex", "opacity", "flex", "fontWeight"];
+        cssValue = unitless.includes(key) ? String(value) : `${value}px`;
+      } else {
+        cssValue = String(value);
+      }
+      const cssKey = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+      element.style.setProperty(cssKey, cssValue);
+    }
+  }
+  /**
+   * 应用页面样式
+   */
+  applyPageStyles(canvas) {
+    if (!this.container) return;
+    this.container.style.width = `${canvas.width}px`;
+    if (canvas.height) {
+      this.container.style.minHeight = `${canvas.height}px`;
+    }
+    if (canvas.background) {
+      this.container.style.background = canvas.background;
+    }
+    this.container.classList.add("djvlc-page", `djvlc-canvas-${canvas.type}`);
+  }
+  log(level, message, ...args) {
+    if (this.options.logger) {
+      this.options.logger[level](message, ...args);
+    } else if (this.options.debug) {
+      console[level](`[Renderer] ${message}`, ...args);
+    }
+  }
+};
+
+// src/renderer/fallback-component.ts
+function registerFallbackComponents() {
+  if (!customElements.get("djvlc-fallback")) {
+    customElements.define(
+      "djvlc-fallback",
+      class extends HTMLElement {
+        constructor() {
+          super();
+          const shadow = this.attachShadow({ mode: "open" });
+          shadow.innerHTML = `
+            <style>
+              :host {
+                display: block;
+                padding: 16px;
+                background: #fff2f0;
+                border: 1px solid #ffccc7;
+                border-radius: 4px;
+                color: #ff4d4f;
+                font-size: 14px;
+              }
+              .title {
+                font-weight: 600;
+                margin-bottom: 8px;
+              }
+              .message {
+                color: #666;
+              }
+            </style>
+            <div class="title">\u7EC4\u4EF6\u52A0\u8F7D\u5931\u8D25</div>
+            <div class="message"><slot>\u8BF7\u5237\u65B0\u9875\u9762\u91CD\u8BD5</slot></div>
+          `;
+        }
+        static get observedAttributes() {
+          return ["message", "component-name"];
+        }
+        attributeChangedCallback(name, _oldValue, newValue) {
+          if (name === "message" && this.shadowRoot) {
+            const message = this.shadowRoot.querySelector(".message");
+            if (message) message.textContent = newValue;
+          }
+          if (name === "component-name" && this.shadowRoot) {
+            const title = this.shadowRoot.querySelector(".title");
+            if (title) title.textContent = `\u7EC4\u4EF6 ${newValue} \u52A0\u8F7D\u5931\u8D25`;
+          }
+        }
+      }
+    );
+  }
+  if (!customElements.get("djvlc-blocked")) {
+    customElements.define(
+      "djvlc-blocked",
+      class extends HTMLElement {
+        constructor() {
+          super();
+          const shadow = this.attachShadow({ mode: "open" });
+          shadow.innerHTML = `
+            <style>
+              :host {
+                display: block;
+                padding: 16px;
+                background: #fffbe6;
+                border: 1px solid #ffe58f;
+                border-radius: 4px;
+                color: #faad14;
+                font-size: 14px;
+              }
+              .icon {
+                margin-right: 8px;
+              }
+            </style>
+            <span class="icon">\u26A0\uFE0F</span>
+            <span>\u6B64\u7EC4\u4EF6\u5DF2\u88AB\u6682\u505C\u4F7F\u7528</span>
+          `;
+        }
+      }
+    );
+  }
+  if (!customElements.get("djvlc-error-boundary")) {
+    customElements.define(
+      "djvlc-error-boundary",
+      class extends HTMLElement {
+        constructor() {
+          super();
+          const shadow = this.attachShadow({ mode: "open" });
+          shadow.innerHTML = `
+            <style>
+              :host {
+                display: block;
+                padding: 16px;
+                background: #f5f5f5;
+                border: 1px dashed #d9d9d9;
+                border-radius: 4px;
+                color: #999;
+                font-size: 14px;
+                text-align: center;
+              }
+            </style>
+            <slot>\u6E32\u67D3\u51FA\u9519</slot>
+          `;
+        }
+      }
+    );
+  }
+}
+function createFallbackElement(type, message, componentName) {
+  const tagName = `djvlc-${type === "error" ? "error-boundary" : type}`;
+  const element = document.createElement(tagName);
+  if (message) {
+    element.setAttribute("message", message);
+  }
+  if (componentName) {
+    element.setAttribute("component-name", componentName);
+  }
+  return element;
+}
+
+// src/runtime.ts
+function createRuntime(options) {
+  return new DjvlcRuntime(options);
+}
+var DjvlcRuntime = class {
+  constructor(options) {
+    this.container = null;
+    this.options = {
+      channel: "prod",
+      debug: false,
+      enableSRI: true,
+      ...options
+    };
+    this.logger = this.createLogger();
+    this.stateManager = new StateManager();
+    this.eventBus = new EventBus({ debug: options.debug, logger: this.logger });
+    this.expressionEngine = new ExpressionEngine({ debug: options.debug, logger: this.logger });
+    this.pageLoader = new PageLoader({
+      apiBaseUrl: options.apiBaseUrl,
+      channel: options.channel,
+      authToken: options.authToken,
+      previewToken: options.previewToken,
+      headers: options.headers,
+      logger: this.logger
+    });
+    this.componentLoader = new ComponentLoader({
+      cdnBaseUrl: options.cdnBaseUrl,
+      enableSRI: options.enableSRI,
+      logger: this.logger
+    });
+    this.assetLoader = new AssetLoader({
+      cdnHosts: [new URL(options.cdnBaseUrl).host],
+      apiHosts: [new URL(options.apiBaseUrl).host]
+    });
+    this.securityManager = new SecurityManager({
+      enableSRI: options.enableSRI,
+      cdnDomains: [new URL(options.cdnBaseUrl).host],
+      apiDomains: [new URL(options.apiBaseUrl).host],
+      logger: this.logger
+    });
+    this.log("info", "Runtime created");
+  }
+  /**
+   * 初始化运行时
+   */
+  async init() {
+    this.log("info", "Initializing runtime");
+    const startTime = performance.now();
+    try {
+      this.container = this.resolveContainer();
+      this.assetLoader.preconnectAll();
+      this.pageLoader.preconnect();
+      registerFallbackComponents();
+      this.stateManager.setPhase("resolving");
+      const initTime = performance.now() - startTime;
+      this.log("info", `Runtime initialized in ${initTime.toFixed(2)}ms`);
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * 加载页面
+   */
+  async load() {
+    this.log("info", "Loading page:", this.options.pageUid);
+    const startTime = performance.now();
+    try {
+      this.stateManager.setPhase("resolving");
+      const page = await this.pageLoader.resolve(this.options.pageUid, {
+        uid: this.options.userId,
+        deviceId: this.options.deviceId
+      });
+      this.stateManager.setPage(page);
+      this.telemetryManager = new TelemetryManager({
+        pageVersionId: page.pageVersionId,
+        debug: this.options.debug,
+        logger: this.logger,
+        onMetric: this.options.onMetric
+      });
+      if (page.runtimeConfig) {
+        this.securityManager.updateBlockedList(
+          page.runtimeConfig.blockedComponents || [],
+          page.runtimeConfig.killSwitches || []
+        );
+        this.componentLoader.updateBlockedList(
+          page.runtimeConfig.blockedComponents?.map((c) => `${c.name}@${c.version}`) || []
+        );
+      }
+      this.stateManager.setPhase("loading");
+      this.componentLoader.preload(page.manifest.components);
+      const componentResults = await this.componentLoader.loadAll(page.manifest);
+      componentResults.forEach((result, key) => {
+        this.stateManager.setComponentStatus(key, result);
+        this.telemetryManager.recordComponentLoad(
+          result.name,
+          result.version,
+          result.loadTime || 0,
+          result.status === "loaded"
+        );
+      });
+      this.initHostApi(page);
+      this.initRenderer();
+      const loadTime = performance.now() - startTime;
+      this.telemetryManager.recordPageLoad(loadTime);
+      this.log("info", `Page loaded in ${loadTime.toFixed(2)}ms`);
+      this.emitEvent("page:loaded", { page, loadTime });
+      return page;
+    } catch (error) {
+      this.stateManager.setPhase("error");
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * 渲染页面
+   */
+  async render() {
+    const state = this.stateManager.getState();
+    if (!state.page || !this.container) {
+      throw new PageLoadError("Page not loaded");
+    }
+    this.log("info", "Rendering page");
+    const startTime = performance.now();
+    try {
+      this.stateManager.setPhase("rendering");
+      this.renderer.updateContext({
+        state: state.variables,
+        query: state.queries,
+        context: {
+          userId: this.options.userId,
+          deviceId: this.options.deviceId,
+          channel: this.options.channel,
+          pageVersionId: state.page.pageVersionId
+        }
+      });
+      this.renderer.render(state.page.pageJson, this.container);
+      this.stateManager.setPhase("ready");
+      const renderTime = performance.now() - startTime;
+      this.telemetryManager.recordFirstRender(renderTime);
+      this.log("info", `Page rendered in ${renderTime.toFixed(2)}ms`);
+    } catch (error) {
+      this.stateManager.setPhase("error");
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * 获取 Host API
+   */
+  getHostApi() {
+    return this.hostApi;
+  }
+  /**
+   * 获取当前状态
+   */
+  getState() {
+    return this.stateManager.getState();
+  }
+  /**
+   * 订阅状态变更
+   */
+  onStateChange(listener) {
+    return this.stateManager.subscribe(listener);
+  }
+  /**
+   * 订阅事件
+   */
+  on(type, handler) {
+    return this.eventBus.on(type, handler);
+  }
+  /**
+   * 更新组件
+   */
+  updateComponent(componentId, props) {
+    this.renderer.updateComponent(componentId, props);
+  }
+  /**
+   * 设置变量
+   */
+  setVariable(key, value) {
+    this.stateManager.setVariable(key, value);
+    const state = this.stateManager.getState();
+    if (state.page && this.container) {
+      this.renderer.updateContext({
+        state: state.variables
+      });
+    }
+  }
+  /**
+   * 刷新数据
+   */
+  async refreshData(queryId) {
+    const result = await this.hostApi.requestData(queryId);
+    if (result.success) {
+      this.stateManager.setQuery(queryId, result.data);
+      const state = this.stateManager.getState();
+      this.renderer.updateContext({
+        query: state.queries
+      });
+    }
+  }
+  /**
+   * 销毁运行时
+   */
+  destroy() {
+    this.log("info", "Destroying runtime");
+    this.telemetryManager?.flush();
+    this.renderer?.destroy();
+    this.eventBus.clear();
+    this.stateManager.setDestroyed();
+    if (this.container) {
+      this.container.innerHTML = "";
+    }
+    this.log("info", "Runtime destroyed");
+  }
+  // ==================== 私有方法 ====================
+  resolveContainer() {
+    const { container } = this.options;
+    if (typeof container === "string") {
+      const element = document.querySelector(container);
+      if (!element) {
+        throw new Error(`Container not found: ${container}`);
+      }
+      return element;
+    }
+    return container;
+  }
+  initHostApi(page) {
+    const context = {
+      pageUid: page.pageUid,
+      pageVersionId: page.pageVersionId,
+      runtimeVersion: "0.1.0",
+      userId: this.options.userId,
+      deviceId: this.options.deviceId,
+      channel: this.options.channel,
+      isEditMode: false,
+      isPreviewMode: page.isPreview || false
+    };
+    this.hostApi = new HostAPIImpl({
+      apiBaseUrl: this.options.apiBaseUrl,
+      authToken: this.options.authToken,
+      headers: this.options.headers,
+      stateManager: this.stateManager,
+      eventBus: this.eventBus,
+      expressionEngine: this.expressionEngine,
+      context,
+      debug: this.options.debug,
+      logger: this.logger
+    });
+  }
+  initRenderer() {
+    const components = /* @__PURE__ */ new Map();
+    const state = this.stateManager.getState();
+    state.components.forEach((result, key) => {
+      if (result.status === "loaded" && result.component) {
+        const [name, version] = key.split("@");
+        components.set(name, {
+          name,
+          version,
+          Component: result.component,
+          loadTime: result.loadTime || 0
+        });
+      }
+    });
+    this.renderer = new BaseRenderer({
+      expressionEngine: this.expressionEngine,
+      components,
+      injectHostApi: (element, componentId) => {
+        element.hostApi = this.hostApi;
+        element.componentId = componentId;
+      },
+      debug: this.options.debug,
+      logger: this.logger,
+      onRenderError: (componentId, error) => {
+        this.log("error", `Render error in ${componentId}:`, error);
+        this.emitEvent("component:error", { componentId, error: error.message });
+        return createFallbackElement("error", error.message);
+      }
+    });
+    this.renderer.init();
+  }
+  handleError(error) {
+    const runtimeError = error instanceof DjvlcRuntimeError ? error : { type: "LOAD_ERROR", message: error.message, timestamp: Date.now() };
+    this.stateManager.setError(runtimeError);
+    this.telemetryManager?.recordError(error);
+    this.emitEvent("page:error", { error: error.message });
+    if (this.options.onError) {
+      this.options.onError(runtimeError);
+    }
+  }
+  emitEvent(type, data) {
+    const event = EventBus.createEvent(type, data, this.telemetryManager?.getTraceId());
+    this.eventBus.emit(event);
+    if (this.options.onEvent) {
+      this.options.onEvent(event);
+    }
+  }
+  createLogger() {
+    const prefix = "[DJVLC]";
+    return {
+      debug: (...args) => {
+        if (this.options.debug) console.debug(prefix, ...args);
+      },
+      info: (...args) => console.info(prefix, ...args),
+      warn: (...args) => console.warn(prefix, ...args),
+      error: (...args) => console.error(prefix, ...args)
+    };
+  }
+  log(level, message, ...args) {
+    this.logger[level](message, ...args);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionBridge,
+  ActionError,
+  AssetLoader,
+  BaseRenderer,
+  ComponentBlockedError,
+  ComponentLoadError,
+  ComponentLoader,
+  DjvlcRuntime,
+  DjvlcRuntimeError,
+  Evaluator,
+  EventBus,
+  ExpressionEngine,
+  ExpressionError,
+  HostAPIImpl,
+  IntegrityError,
+  Lexer,
+  PageLoadError,
+  PageLoader,
+  Parser,
+  QueryError,
+  RenderError,
+  SecurityManager,
+  StateManager,
+  TelemetryManager,
+  builtinFunctions,
+  createFallbackElement,
+  createRuntime,
+  registerFallbackComponents
+});