@djvlc/runtime-web 1.0.0

package/dist/runtime.esm.js

@@ -0,0 +1,3841 @@
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2[ErrorCode2["UNKNOWN"] = 1e3] = "UNKNOWN";
+  ErrorCode2[ErrorCode2["INVALID_REQUEST"] = 1001] = "INVALID_REQUEST";
+  ErrorCode2[ErrorCode2["UNAUTHORIZED"] = 1002] = "UNAUTHORIZED";
+  ErrorCode2[ErrorCode2["FORBIDDEN"] = 1003] = "FORBIDDEN";
+  ErrorCode2[ErrorCode2["NOT_FOUND"] = 1004] = "NOT_FOUND";
+  ErrorCode2[ErrorCode2["RATE_LIMITED"] = 1005] = "RATE_LIMITED";
+  ErrorCode2[ErrorCode2["VALIDATION_ERROR"] = 1006] = "VALIDATION_ERROR";
+  ErrorCode2[ErrorCode2["INTERNAL_ERROR"] = 1007] = "INTERNAL_ERROR";
+  ErrorCode2[ErrorCode2["SERVICE_UNAVAILABLE"] = 1008] = "SERVICE_UNAVAILABLE";
+  ErrorCode2[ErrorCode2["TIMEOUT"] = 1009] = "TIMEOUT";
+  ErrorCode2[ErrorCode2["ACTION_NOT_FOUND"] = 2001] = "ACTION_NOT_FOUND";
+  ErrorCode2[ErrorCode2["ACTION_INVALID_PARAMS"] = 2002] = "ACTION_INVALID_PARAMS";
+  ErrorCode2[ErrorCode2["ACTION_EXECUTION_FAILED"] = 2003] = "ACTION_EXECUTION_FAILED";
+  ErrorCode2[ErrorCode2["ACTION_IDEMPOTENCY_CONFLICT"] = 2004] = "ACTION_IDEMPOTENCY_CONFLICT";
+  ErrorCode2[ErrorCode2["ACTION_BLOCKED"] = 2005] = "ACTION_BLOCKED";
+  ErrorCode2[ErrorCode2["ACTION_RISK_REJECTED"] = 2006] = "ACTION_RISK_REJECTED";
+  ErrorCode2[ErrorCode2["ACTION_EXPIRED"] = 2007] = "ACTION_EXPIRED";
+  ErrorCode2[ErrorCode2["ACTION_QUOTA_EXCEEDED"] = 2008] = "ACTION_QUOTA_EXCEEDED";
+  ErrorCode2[ErrorCode2["QUERY_NOT_FOUND"] = 3001] = "QUERY_NOT_FOUND";
+  ErrorCode2[ErrorCode2["QUERY_INVALID_PARAMS"] = 3002] = "QUERY_INVALID_PARAMS";
+  ErrorCode2[ErrorCode2["QUERY_EXECUTION_FAILED"] = 3003] = "QUERY_EXECUTION_FAILED";
+  ErrorCode2[ErrorCode2["QUERY_FIELD_NOT_ALLOWED"] = 3004] = "QUERY_FIELD_NOT_ALLOWED";
+  ErrorCode2[ErrorCode2["QUERY_TIMEOUT"] = 3005] = "QUERY_TIMEOUT";
+  ErrorCode2[ErrorCode2["QUERY_DISABLED"] = 3006] = "QUERY_DISABLED";
+  ErrorCode2[ErrorCode2["COMPONENT_NOT_FOUND"] = 4001] = "COMPONENT_NOT_FOUND";
+  ErrorCode2[ErrorCode2["COMPONENT_VERSION_NOT_FOUND"] = 4002] = "COMPONENT_VERSION_NOT_FOUND";
+  ErrorCode2[ErrorCode2["COMPONENT_BLOCKED"] = 4003] = "COMPONENT_BLOCKED";
+  ErrorCode2[ErrorCode2["COMPONENT_INTEGRITY_MISMATCH"] = 4004] = "COMPONENT_INTEGRITY_MISMATCH";
+  ErrorCode2[ErrorCode2["COMPONENT_INCOMPATIBLE"] = 4005] = "COMPONENT_INCOMPATIBLE";
+  ErrorCode2[ErrorCode2["COMPONENT_LOAD_FAILED"] = 4006] = "COMPONENT_LOAD_FAILED";
+  ErrorCode2[ErrorCode2["COMPONENT_RENDER_ERROR"] = 4007] = "COMPONENT_RENDER_ERROR";
+  ErrorCode2[ErrorCode2["PAGE_NOT_FOUND"] = 5001] = "PAGE_NOT_FOUND";
+  ErrorCode2[ErrorCode2["PAGE_VERSION_NOT_FOUND"] = 5002] = "PAGE_VERSION_NOT_FOUND";
+  ErrorCode2[ErrorCode2["PAGE_SCHEMA_INVALID"] = 5003] = "PAGE_SCHEMA_INVALID";
+  ErrorCode2[ErrorCode2["PAGE_MANIFEST_INVALID"] = 5004] = "PAGE_MANIFEST_INVALID";
+  ErrorCode2[ErrorCode2["PAGE_PUBLISH_FAILED"] = 5005] = "PAGE_PUBLISH_FAILED";
+  ErrorCode2[ErrorCode2["PAGE_ROLLBACK_FAILED"] = 5006] = "PAGE_ROLLBACK_FAILED";
+  ErrorCode2[ErrorCode2["ACTIVITY_NOT_FOUND"] = 6001] = "ACTIVITY_NOT_FOUND";
+  ErrorCode2[ErrorCode2["ACTIVITY_NOT_STARTED"] = 6002] = "ACTIVITY_NOT_STARTED";
+  ErrorCode2[ErrorCode2["ACTIVITY_ENDED"] = 6003] = "ACTIVITY_ENDED";
+  ErrorCode2[ErrorCode2["ACTIVITY_ALREADY_CLAIMED"] = 6004] = "ACTIVITY_ALREADY_CLAIMED";
+  ErrorCode2[ErrorCode2["ACTIVITY_ALREADY_SIGNED"] = 6005] = "ACTIVITY_ALREADY_SIGNED";
+  ErrorCode2[ErrorCode2["ACTIVITY_LIMIT_EXCEEDED"] = 6006] = "ACTIVITY_LIMIT_EXCEEDED";
+  ErrorCode2[ErrorCode2["ACTIVITY_DISABLED"] = 6007] = "ACTIVITY_DISABLED";
+  ErrorCode2[ErrorCode2["EXPRESSION_SYNTAX_ERROR"] = 7001] = "EXPRESSION_SYNTAX_ERROR";
+  ErrorCode2[ErrorCode2["EXPRESSION_UNKNOWN_FUNCTION"] = 7002] = "EXPRESSION_UNKNOWN_FUNCTION";
+  ErrorCode2[ErrorCode2["EXPRESSION_INVALID_ARGUMENT"] = 7003] = "EXPRESSION_INVALID_ARGUMENT";
+  ErrorCode2[ErrorCode2["EXPRESSION_UNKNOWN_VARIABLE"] = 7004] = "EXPRESSION_UNKNOWN_VARIABLE";
+  ErrorCode2[ErrorCode2["EXPRESSION_TYPE_MISMATCH"] = 7005] = "EXPRESSION_TYPE_MISMATCH";
+  ErrorCode2[ErrorCode2["EXPRESSION_ACCESS_DENIED"] = 7006] = "EXPRESSION_ACCESS_DENIED";
+  ErrorCode2[ErrorCode2["SCHEMA_VERSION_MISMATCH"] = 8001] = "SCHEMA_VERSION_MISMATCH";
+  ErrorCode2[ErrorCode2["MIGRATION_FAILED"] = 8002] = "MIGRATION_FAILED";
+  ErrorCode2[ErrorCode2["MIGRATION_NOT_FOUND"] = 8003] = "MIGRATION_NOT_FOUND";
+  ErrorCode2[ErrorCode2["VERSION_INCOMPATIBLE"] = 8004] = "VERSION_INCOMPATIBLE";
+  return ErrorCode2;
+})(ErrorCode || {});
+var ErrorMessages = {
+  // 通用错误
+  [
+    1e3
+    /* UNKNOWN */
+  ]: "未知错误",
+  [
+    1001
+    /* INVALID_REQUEST */
+  ]: "请求参数无效",
+  [
+    1002
+    /* UNAUTHORIZED */
+  ]: "未授权访问",
+  [
+    1003
+    /* FORBIDDEN */
+  ]: "禁止访问",
+  [
+    1004
+    /* NOT_FOUND */
+  ]: "资源不存在",
+  [
+    1005
+    /* RATE_LIMITED */
+  ]: "请求频率超限",
+  [
+    1006
+    /* VALIDATION_ERROR */
+  ]: "数据校验失败",
+  [
+    1007
+    /* INTERNAL_ERROR */
+  ]: "服务内部错误",
+  [
+    1008
+    /* SERVICE_UNAVAILABLE */
+  ]: "服务暂不可用",
+  [
+    1009
+    /* TIMEOUT */
+  ]: "请求超时",
+  // Action 错误
+  [
+    2001
+    /* ACTION_NOT_FOUND */
+  ]: "动作不存在",
+  [
+    2002
+    /* ACTION_INVALID_PARAMS */
+  ]: "动作参数无效",
+  [
+    2003
+    /* ACTION_EXECUTION_FAILED */
+  ]: "动作执行失败",
+  [
+    2004
+    /* ACTION_IDEMPOTENCY_CONFLICT */
+  ]: "重复请求",
+  [
+    2005
+    /* ACTION_BLOCKED */
+  ]: "动作已被禁用",
+  [
+    2006
+    /* ACTION_RISK_REJECTED */
+  ]: "风控拒绝",
+  [
+    2007
+    /* ACTION_EXPIRED */
+  ]: "动作已过期",
+  [
+    2008
+    /* ACTION_QUOTA_EXCEEDED */
+  ]: "配额已用尽",
+  // Data Query 错误
+  [
+    3001
+    /* QUERY_NOT_FOUND */
+  ]: "查询不存在",
+  [
+    3002
+    /* QUERY_INVALID_PARAMS */
+  ]: "查询参数无效",
+  [
+    3003
+    /* QUERY_EXECUTION_FAILED */
+  ]: "查询执行失败",
+  [
+    3004
+    /* QUERY_FIELD_NOT_ALLOWED */
+  ]: "字段访问被拒绝",
+  [
+    3005
+    /* QUERY_TIMEOUT */
+  ]: "查询超时",
+  [
+    3006
+    /* QUERY_DISABLED */
+  ]: "查询已禁用",
+  // 组件错误
+  [
+    4001
+    /* COMPONENT_NOT_FOUND */
+  ]: "组件不存在",
+  [
+    4002
+    /* COMPONENT_VERSION_NOT_FOUND */
+  ]: "组件版本不存在",
+  [
+    4003
+    /* COMPONENT_BLOCKED */
+  ]: "组件已被禁用",
+  [
+    4004
+    /* COMPONENT_INTEGRITY_MISMATCH */
+  ]: "组件完整性校验失败",
+  [
+    4005
+    /* COMPONENT_INCOMPATIBLE */
+  ]: "组件版本不兼容",
+  [
+    4006
+    /* COMPONENT_LOAD_FAILED */
+  ]: "组件加载失败",
+  [
+    4007
+    /* COMPONENT_RENDER_ERROR */
+  ]: "组件渲染错误",
+  // 页面错误
+  [
+    5001
+    /* PAGE_NOT_FOUND */
+  ]: "页面不存在",
+  [
+    5002
+    /* PAGE_VERSION_NOT_FOUND */
+  ]: "页面版本不存在",
+  [
+    5003
+    /* PAGE_SCHEMA_INVALID */
+  ]: "页面 Schema 无效",
+  [
+    5004
+    /* PAGE_MANIFEST_INVALID */
+  ]: "页面 Manifest 无效",
+  [
+    5005
+    /* PAGE_PUBLISH_FAILED */
+  ]: "页面发布失败",
+  [
+    5006
+    /* PAGE_ROLLBACK_FAILED */
+  ]: "页面回滚失败",
+  // 活动错误
+  [
+    6001
+    /* ACTIVITY_NOT_FOUND */
+  ]: "活动不存在",
+  [
+    6002
+    /* ACTIVITY_NOT_STARTED */
+  ]: "活动未开始",
+  [
+    6003
+    /* ACTIVITY_ENDED */
+  ]: "活动已结束",
+  [
+    6004
+    /* ACTIVITY_ALREADY_CLAIMED */
+  ]: "已领取过",
+  [
+    6005
+    /* ACTIVITY_ALREADY_SIGNED */
+  ]: "今日已签到",
+  [
+    6006
+    /* ACTIVITY_LIMIT_EXCEEDED */
+  ]: "超出领取限制",
+  [
+    6007
+    /* ACTIVITY_DISABLED */
+  ]: "活动已禁用",
+  // 表达式错误
+  [
+    7001
+    /* EXPRESSION_SYNTAX_ERROR */
+  ]: "表达式语法错误",
+  [
+    7002
+    /* EXPRESSION_UNKNOWN_FUNCTION */
+  ]: "未知函数",
+  [
+    7003
+    /* EXPRESSION_INVALID_ARGUMENT */
+  ]: "无效参数",
+  [
+    7004
+    /* EXPRESSION_UNKNOWN_VARIABLE */
+  ]: "未知变量",
+  [
+    7005
+    /* EXPRESSION_TYPE_MISMATCH */
+  ]: "类型不匹配",
+  [
+    7006
+    /* EXPRESSION_ACCESS_DENIED */
+  ]: "访问被拒绝",
+  // 版本/迁移错误
+  [
+    8001
+    /* SCHEMA_VERSION_MISMATCH */
+  ]: "Schema 版本不匹配",
+  [
+    8002
+    /* MIGRATION_FAILED */
+  ]: "迁移失败",
+  [
+    8003
+    /* MIGRATION_NOT_FOUND */
+  ]: "迁移脚本不存在",
+  [
+    8004
+    /* VERSION_INCOMPATIBLE */
+  ]: "版本不兼容"
+};
+var BUILTIN_FUNCTIONS = [
+  // 字符串函数
+  {
+    name: "len",
+    description: "获取字符串或数组长度",
+    params: [{ name: "value", type: "any", required: true }],
+    returnType: "number",
+    examples: ['len("hello")', "len([1,2,3])"]
+  },
+  {
+    name: "trim",
+    description: "去除字符串首尾空格",
+    params: [{ name: "str", type: "string", required: true }],
+    returnType: "string",
+    examples: ['trim("  hello  ")']
+  },
+  {
+    name: "upper",
+    description: "转为大写",
+    params: [{ name: "str", type: "string", required: true }],
+    returnType: "string",
+    examples: ['upper("hello")']
+  },
+  {
+    name: "lower",
+    description: "转为小写",
+    params: [{ name: "str", type: "string", required: true }],
+    returnType: "string",
+    examples: ['lower("HELLO")']
+  },
+  {
+    name: "substr",
+    description: "截取子字符串",
+    params: [
+      { name: "str", type: "string", required: true },
+      { name: "start", type: "number", required: true },
+      { name: "length", type: "number", required: false }
+    ],
+    returnType: "string",
+    examples: ['substr("hello", 0, 2)']
+  },
+  {
+    name: "concat",
+    description: "连接字符串",
+    params: [
+      { name: "values", type: "any", required: true, description: "可变参数" }
+    ],
+    returnType: "string",
+    examples: ['concat("a", "b", "c")']
+  },
+  {
+    name: "replace",
+    description: "替换字符串",
+    params: [
+      { name: "str", type: "string", required: true },
+      { name: "search", type: "string", required: true },
+      { name: "replacement", type: "string", required: true }
+    ],
+    returnType: "string",
+    examples: ['replace("hello", "l", "x")']
+  },
+  {
+    name: "split",
+    description: "分割字符串",
+    params: [
+      { name: "str", type: "string", required: true },
+      { name: "separator", type: "string", required: true }
+    ],
+    returnType: "array",
+    examples: ['split("a,b,c", ",")']
+  },
+  {
+    name: "join",
+    description: "连接数组为字符串",
+    params: [
+      { name: "arr", type: "array", required: true },
+      { name: "separator", type: "string", required: false, defaultValue: "," }
+    ],
+    returnType: "string",
+    examples: ['join(["a","b","c"], "-")']
+  },
+  // 数字函数
+  {
+    name: "toNumber",
+    description: "转为数字",
+    params: [{ name: "value", type: "any", required: true }],
+    returnType: "number",
+    examples: ['toNumber("123")']
+  },
+  {
+    name: "toString",
+    description: "转为字符串",
+    params: [{ name: "value", type: "any", required: true }],
+    returnType: "string",
+    examples: ["toString(123)"]
+  },
+  {
+    name: "round",
+    description: "四舍五入",
+    params: [
+      { name: "value", type: "number", required: true },
+      { name: "decimals", type: "number", required: false, defaultValue: 0 }
+    ],
+    returnType: "number",
+    examples: ["round(3.14159, 2)"]
+  },
+  {
+    name: "floor",
+    description: "向下取整",
+    params: [{ name: "value", type: "number", required: true }],
+    returnType: "number",
+    examples: ["floor(3.7)"]
+  },
+  {
+    name: "ceil",
+    description: "向上取整",
+    params: [{ name: "value", type: "number", required: true }],
+    returnType: "number",
+    examples: ["ceil(3.2)"]
+  },
+  {
+    name: "abs",
+    description: "绝对值",
+    params: [{ name: "value", type: "number", required: true }],
+    returnType: "number",
+    examples: ["abs(-5)"]
+  },
+  {
+    name: "min",
+    description: "最小值",
+    params: [
+      { name: "values", type: "number", required: true, description: "可变参数" }
+    ],
+    returnType: "number",
+    examples: ["min(1, 2, 3)"]
+  },
+  {
+    name: "max",
+    description: "最大值",
+    params: [
+      { name: "values", type: "number", required: true, description: "可变参数" }
+    ],
+    returnType: "number",
+    examples: ["max(1, 2, 3)"]
+  },
+  // 日期函数
+  {
+    name: "now",
+    description: "当前时间戳（毫秒）",
+    params: [],
+    returnType: "number",
+    examples: ["now()"]
+  },
+  {
+    name: "dateFormat",
+    description: "格式化日期",
+    params: [
+      { name: "timestamp", type: "number", required: true },
+      { name: "format", type: "string", required: false, defaultValue: "YYYY-MM-DD" }
+    ],
+    returnType: "string",
+    examples: ['dateFormat(now(), "YYYY-MM-DD HH:mm:ss")']
+  },
+  {
+    name: "dateParse",
+    description: "解析日期字符串",
+    params: [
+      { name: "dateStr", type: "string", required: true },
+      { name: "format", type: "string", required: false }
+    ],
+    returnType: "number",
+    examples: ['dateParse("2024-01-01")']
+  },
+  // 数组函数
+  {
+    name: "first",
+    description: "获取数组第一个元素",
+    params: [{ name: "arr", type: "array", required: true }],
+    returnType: "any",
+    examples: ["first([1,2,3])"]
+  },
+  {
+    name: "last",
+    description: "获取数组最后一个元素",
+    params: [{ name: "arr", type: "array", required: true }],
+    returnType: "any",
+    examples: ["last([1,2,3])"]
+  },
+  {
+    name: "includes",
+    description: "检查数组是否包含元素",
+    params: [
+      { name: "arr", type: "array", required: true },
+      { name: "value", type: "any", required: true }
+    ],
+    returnType: "boolean",
+    examples: ["includes([1,2,3], 2)"]
+  },
+  {
+    name: "slice",
+    description: "截取数组",
+    params: [
+      { name: "arr", type: "array", required: true },
+      { name: "start", type: "number", required: true },
+      { name: "end", type: "number", required: false }
+    ],
+    returnType: "array",
+    examples: ["slice([1,2,3,4], 1, 3)"]
+  },
+  // 条件函数
+  {
+    name: "default",
+    description: "提供默认值",
+    params: [
+      { name: "value", type: "any", required: true },
+      { name: "defaultValue", type: "any", required: true }
+    ],
+    returnType: "any",
+    examples: ['default(null, "fallback")']
+  },
+  {
+    name: "ifElse",
+    description: "条件判断",
+    params: [
+      { name: "condition", type: "boolean", required: true },
+      { name: "trueValue", type: "any", required: true },
+      { name: "falseValue", type: "any", required: true }
+    ],
+    returnType: "any",
+    examples: ['ifElse(age > 18, "成年", "未成年")']
+  },
+  {
+    name: "isEmpty",
+    description: "检查是否为空",
+    params: [{ name: "value", type: "any", required: true }],
+    returnType: "boolean",
+    examples: ['isEmpty("")', "isEmpty([])"]
+  },
+  {
+    name: "isNull",
+    description: "检查是否为 null 或 undefined",
+    params: [{ name: "value", type: "any", required: true }],
+    returnType: "boolean",
+    examples: ["isNull(null)"]
+  },
+  // JSON 函数
+  {
+    name: "jsonParse",
+    description: "解析 JSON 字符串",
+    params: [{ name: "str", type: "string", required: true }],
+    returnType: "any",
+    examples: [`jsonParse('{"a":1}')`]
+  },
+  {
+    name: "jsonStringify",
+    description: "序列化为 JSON",
+    params: [{ name: "value", type: "any", required: true }],
+    returnType: "string",
+    examples: ["jsonStringify({a:1})"]
+  }
+];
+var BUILTIN_FUNCTION_NAMES = new Set(BUILTIN_FUNCTIONS.map((f) => f.name));
+function isExpressionBinding(value) {
+  return value !== null && typeof value === "object" && value.__isExpression === true && typeof value.expression === "string";
+}
+var migrations = [];
+function registerMigration(migration) {
+  const exists = migrations.some(
+    (m) => m.from === migration.from && m.to === migration.to
+  );
+  if (exists) {
+    throw new Error(`Migration from ${migration.from} to ${migration.to} already exists`);
+  }
+  migrations.push(migration);
+}
+registerMigration({
+  from: "1.0.0",
+  to: "1.1.0",
+  description: "添加 Definition 版本绑定字段",
+  migrate: (data) => {
+    return {
+      ...data,
+      actionDefVersionIds: data.actionDefVersionIds || [],
+      dataQueryVersionIds: data.dataQueryVersionIds || []
+    };
+  }
+});
+registerMigration({
+  from: "1.1.0",
+  to: "2.0.0",
+  description: "重构组件事件结构",
+  breaking: true,
+  migrate: (data) => {
+    return {
+      ...data,
+      components: data.components.map((component) => {
+        var _a;
+        return {
+          ...component,
+          // 示例：将 events 数组中的 actions 结构标准化
+          events: (_a = component.events) == null ? void 0 : _a.map((event) => ({
+            ...event,
+            // 确保 enabled 字段存在
+            enabled: event.enabled ?? true
+          }))
+        };
+      })
+    };
+  }
+});
+var DjvlcRuntimeError = class extends Error {
+  constructor(code, message, details, traceId) {
+    super(message || 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(ErrorCode.PAGE_NOT_FOUND, message, details, traceId);
+    this.name = "PageLoadError";
+  }
+};
+var ComponentLoadError = class extends DjvlcRuntimeError {
+  constructor(componentName, componentVersion, message, code = 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(
+      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(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(ErrorCode.UNKNOWN, message, { ...details, expression, position });
+    this.name = "ExpressionError";
+    this.expression = expression;
+    this.position = position;
+  }
+};
+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) {
+    var _a, _b;
+    const cacheKey = this.getCacheKey(pageUid, params);
+    if ((_a = this.options.cache) == null ? void 0 : _a.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 ((_b = this.options.cache) == null ? void 0 : _b.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 == null ? void 0 : params.uid) {
+      url.searchParams.set("uid", params.uid);
+    }
+    if (params == null ? void 0 : 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 == null ? void 0 : params.uid) parts.push(params.uid);
+    if (params == null ? void 0 : params.deviceId) parts.push(params.deviceId);
+    return parts.join(":");
+  }
+  isCacheValid(timestamp) {
+    var _a;
+    const maxAge = (((_a = this.options.cache) == null ? void 0 : _a.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);
+    }
+  }
+};
+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 module = await import(
+        /* @vite-ignore */
+        blobUrl
+      );
+      const Component = module.default || module[item.name] || module.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);
+    }
+  }
+};
+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);
+    });
+  }
+};
+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
+    };
+  }
+};
+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 == null ? void 0 : handlers.delete(handler);
+      if ((handlers == null ? void 0 : 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) {
+    var _a;
+    return ((_a = this.handlers.get(type)) == null ? void 0 : _a.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);
+    }
+  }
+};
+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] || "";
+  }
+};
+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 index2 = this.parseExpression();
+        this.expect("RBRACKET");
+        node = {
+          type: "member",
+          object: node,
+          property: index2,
+          computed: true,
+          raw: void 0
+        };
+      } else if (token.type === "LPAREN" && node.type === "identifier") {
+        const callee = node.name;
+        if (!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();
+  }
+};
+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, index2) => {
+    if (!Array.isArray(arr)) return void 0;
+    return arr[Number(index2) || 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);
+  }
+};
+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");
+    }
+  }
+};
+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);
+    }
+  }
+};
+var HostAPIImpl = class {
+  constructor(options) {
+    this.storage = {
+      get: (key, options2) => {
+        const fullKey = this.getStorageKey(key, options2 == null ? void 0 : options2.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, options2) => {
+        const fullKey = this.getStorageKey(key, options2 == null ? void 0 : options2.namespace);
+        const item = {
+          value,
+          expires: (options2 == null ? void 0 : options2.ttl) ? Date.now() + options2.ttl * 1e3 : void 0
+        };
+        localStorage.setItem(fullKey, JSON.stringify(item));
+      },
+      remove: (key, options2) => {
+        const fullKey = this.getStorageKey(key, options2 == null ? void 0 : options2.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);
+    }
+  }
+};
+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);
+  }
+};
+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);
+    }
+  }
+};
+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 (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);
+    }
+  }
+};
+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">组件加载失败</div>
+            <div class="message"><slot>请刷新页面重试</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 = `组件 ${newValue} 加载失败`;
+          }
+        }
+      }
+    );
+  }
+  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">⚠️</span>
+            <span>此组件已被暂停使用</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>渲染出错</slot>
+          `;
+        }
+      }
+    );
+  }
+}
+function createFallbackElement(type, message, componentName) {
+  const tagName = `djvlc-${"error-boundary"}`;
+  const element = document.createElement(tagName);
+  if (message) {
+    element.setAttribute("message", message);
+  }
+  return element;
+}
+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() {
+    var _a;
+    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(
+          ((_a = page.runtimeConfig.blockedComponents) == null ? void 0 : _a.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() {
+    var _a, _b;
+    this.log("info", "Destroying runtime");
+    (_a = this.telemetryManager) == null ? void 0 : _a.flush();
+    (_b = this.renderer) == null ? void 0 : _b.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) {
+    var _a;
+    const runtimeError = error instanceof DjvlcRuntimeError ? error : { type: "LOAD_ERROR", message: error.message, timestamp: Date.now() };
+    this.stateManager.setError(runtimeError);
+    (_a = this.telemetryManager) == null ? void 0 : _a.recordError(error);
+    this.emitEvent("page:error", { error: error.message });
+    if (this.options.onError) {
+      this.options.onError(runtimeError);
+    }
+  }
+  emitEvent(type, data) {
+    var _a;
+    const event = EventBus.createEvent(type, data, (_a = this.telemetryManager) == null ? void 0 : _a.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);
+  }
+};
+const RUNTIME_VERSION = "0.1.0";
+async function mount(container, options) {
+  var _a, _b;
+  const runtimeOptions = {
+    container,
+    pageUid: options.pageUid,
+    apiBaseUrl: options.apiBaseUrl,
+    cdnBaseUrl: options.cdnBaseUrl,
+    channel: options.channel,
+    userId: options.userId,
+    deviceId: options.deviceId,
+    authToken: options.authToken,
+    previewToken: options.previewToken,
+    debug: options.debug,
+    enableSRI: options.enableSRI,
+    headers: options.headers,
+    onError: options.onError ? (error) => {
+      var _a2;
+      return (_a2 = options.onError) == null ? void 0 : _a2.call(options, new Error(error.message));
+    } : void 0,
+    onMetric: options.onMetric
+  };
+  const runtime = createRuntime(runtimeOptions);
+  try {
+    await runtime.init();
+    await runtime.load();
+    await runtime.render();
+    (_a = options.onLoad) == null ? void 0 : _a.call(options, runtime.getState());
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    (_b = options.onError) == null ? void 0 : _b.call(options, err);
+    throw err;
+  }
+  return {
+    runtime,
+    destroy: () => runtime.destroy()
+  };
+}
+function preconnect(hosts) {
+  hosts.forEach((host) => {
+    const link = document.createElement("link");
+    link.rel = "preconnect";
+    link.href = host.startsWith("http") ? host : `https://${host}`;
+    link.crossOrigin = "anonymous";
+    document.head.appendChild(link);
+  });
+}
+function preloadAssets(cdnBaseUrl, version = RUNTIME_VERSION) {
+  const assets = [
+    `${cdnBaseUrl}/runtime/${version}/runtime.esm.js`,
+    `${cdnBaseUrl}/runtime/${version}/runtime.css`
+  ];
+  assets.forEach((href) => {
+    const link = document.createElement("link");
+    link.rel = "preload";
+    link.href = href;
+    link.as = href.endsWith(".js") ? "script" : "style";
+    if (href.endsWith(".js")) {
+      link.crossOrigin = "anonymous";
+    }
+    document.head.appendChild(link);
+  });
+}
+function getDeviceId() {
+  const key = "djv_device_id";
+  let deviceId = localStorage.getItem(key);
+  if (!deviceId) {
+    deviceId = `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+    try {
+      localStorage.setItem(key, deviceId);
+    } catch {
+    }
+  }
+  return deviceId;
+}
+function generateTraceId() {
+  const randomHex = (len) => Array.from({ length: len }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+  return randomHex(32);
+}
+function generateSpanId() {
+  const randomHex = (len) => Array.from({ length: len }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+  return randomHex(16);
+}
+function generateTraceparent() {
+  const traceId = generateTraceId();
+  const spanId = generateSpanId();
+  return `00-${traceId}-${spanId}-01`;
+}
+const index = {
+  mount,
+  preconnect,
+  preloadAssets,
+  getDeviceId,
+  generateTraceId,
+  generateSpanId,
+  generateTraceparent,
+  createRuntime,
+  RUNTIME_VERSION
+};
+export {
+  RUNTIME_VERSION,
+  createRuntime,
+  index as default,
+  generateSpanId,
+  generateTraceId,
+  generateTraceparent,
+  getDeviceId,
+  mount,
+  preconnect,
+  preloadAssets
+};
+//# sourceMappingURL=runtime.esm.js.map