@lytjs/core 5.0.0 → 6.0.0

package/dist/index.cjs

@@ -1 +1,3482 @@
-"use strict";var E=Object.defineProperty;var $=Object.getOwnPropertyDescriptor;var q=Object.getOwnPropertyNames;var X=Object.prototype.hasOwnProperty;var Y=(n,e)=>{for(var t in e)E(n,t,{get:e[t],enumerable:!0})},O=(n,e,t,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of q(e))!X.call(n,o)&&o!==t&&E(n,o,{get:()=>e[o],enumerable:!(i=$(e,o))||i.enumerable});return n},A=(n,e,t)=>(O(n,e,"default"),t&&O(t,e,"default"));var K=n=>O(E({},"__esModule",{value:!0}),n);var v={};Y(v,{Fragment:()=>x.Fragment,ShapeFlags:()=>L,createApp:()=>S,h:()=>R});module.exports=K(v);var y=require("@lytjs/common"),x=require("@lytjs/vdom");var L=(s=>(s[s.ELEMENT=1]="ELEMENT",s[s.FUNCTIONAL_COMPONENT=2]="FUNCTIONAL_COMPONENT",s[s.STATEFUL_COMPONENT=4]="STATEFUL_COMPONENT",s[s.TEXT_CHILDREN=8]="TEXT_CHILDREN",s[s.ARRAY_CHILDREN=16]="ARRAY_CHILDREN",s[s.SLOTS_CHILDREN=32]="SLOTS_CHILDREN",s))(L||{});function Z(n,e){if(e!=null)if((0,y.isStringOrNumber)(e))n.children=String(e),n.shapeFlag|=8;else if((0,y.isArray)(e)){let t=[];for(let i=0;i<e.length;i++){let o=e[i];if(!(o==null||typeof o=="boolean"))if((0,y.isArray)(o))for(let p=0;p<o.length;p++){let s=o[p];s!=null&&typeof s!="boolean"&&t.push((0,y.isVNode)(s)?s:j(String(s)))}else(0,y.isVNode)(o)?t.push(o):t.push(j(String(o)))}n.children=t,n.shapeFlag|=16}else typeof e=="object"&&(n.children=e,n.shapeFlag|=32)}function j(n,e=null,t=null){var u,f;let i=0;typeof n=="string"?i=1:n===x.Fragment?i=0:typeof n=="function"?i=2:typeof n=="object"&&n!==null&&(n.setup||n.__vccOpts||n.render)&&(i=4);let o=(u=e==null?void 0:e.key)!=null?u:null,p=(f=e==null?void 0:e.ref)!=null?f:null,s=e;if(e){let{key:C,ref:d,...b}=e;s=b}let P={type:n,props:s,children:null,key:o,ref:p,shapeFlag:i,el:null,component:null};return t!=null&&Z(P,t),P}function R(n,e,t){return j(n,e||null,t||null)}var k=require("@lytjs/common");function w(n){return Object.create(n||null)}function D(n){return n!==null&&typeof n=="object"&&typeof n.install=="function"}function V(n){return typeof n=="function"}function _(n,e,...t){if(D(e)){let i=e.onBeforeInstall?e.onBeforeInstall(n,...t):void 0;if((0,k.isPromise)(i))return i.then(()=>{let o=e.install(n,...t);if((0,k.isPromise)(o))return o.then(()=>{if(e.onInstalled)return e.onInstalled(n,...t)});if(e.onInstalled)return e.onInstalled(n,...t)});{let o=e.install(n,...t);if((0,k.isPromise)(o))return o.then(()=>{if(e.onInstalled)return e.onInstalled(n,...t)});if(e.onInstalled)return e.onInstalled(n,...t)}}else if(V(e))return e(n,...t)}function F(n,e){if(D(e)){if(typeof e.uninstall=="function")return e.uninstall(n)}else V(e)}var T=require("@lytjs/reactivity"),H=require("@lytjs/compiler"),c=require("@lytjs/component"),M=require("@lytjs/renderer"),G=100,g=new Map;function J(n){let e=g.get(n);if(e)return g.delete(n),g.set(n,e),e;let{code:t}=(0,H.compile)(n);if(e=new Function("h","_ctx",`return ${t}`),g.size>=G){let i=g.keys().next().value;i!==void 0&&g.delete(i)}return g.set(n,e),e}function Q(n){let e={...n};if(n.state&&typeof n.state!="function"){let t=n.state;e.state=()=>({...t})}if(typeof n.render=="function"){let t=n.render;e.render=(i,o)=>t(i)}if(n.computed){let t={};for(let i of Object.keys(n.computed)){let o=n.computed[i];typeof o=="function"?t[i]={get:o}:t[i]=o}e.computed=t}if(typeof n.init=="function"){let t=n.init;e.init=function(i,o){return t.call(this,i)}}return e}function W(){return{createElement(n){return document.createElement(n)},createText(n){return document.createTextNode(n)},createComment(n){return document.createComment(n)},setAttribute(n,e,t){n.setAttribute(e,String(t))},removeAttribute(n,e){n.removeAttribute(e)},setStyle(n,e){if(typeof e=="string")n.style.cssText=e;else if(e&&typeof e=="object")for(let t in e)n.style[t]=e[t]},setClass(n,e){if(typeof e=="string")n.className=e;else if(e&&typeof e=="object"){let t=[];for(let[i,o]of Object.entries(e))o&&t.push(i);n.className=t.join(" ")}else n.className=""},insert(n,e,t){t!=null?n.insertBefore(e,t):n.appendChild(e)},remove(n){n.parentNode&&n.parentNode.removeChild(n)},replace(n,e,t){n.replaceChild(t,e)},addEventListener(n,e,t,i){n.addEventListener(e,t,i)},removeEventListener(n,e,t){n.removeEventListener(e,t)},nextTick(n){Promise.resolve().then(n)},parentNode(n){return n.parentNode},nextSibling(n){return n.nextSibling},querySelector(n){return document.querySelector(n)}}}function S(n,e){let t=new Set,i={},o={},p=w(),s={},P={},u=null,f=null,C=null,d=null,b=!1,B=Q(typeof n=="function"?{render:n}:n),U=(0,c.defineComponent)(B),r={config:s,globalProperties:P,get _instance(){return u},mount(l){if(b)return r;let a;if(typeof l=="string"){let I=document.querySelector(l);if(!I)throw new Error(`[Lyt] \u6302\u8F7D\u76EE\u6807 "${l}" \u672A\u627E\u5230`);a=I}else a=l;d=a;let m=W();f=(0,M.createRenderer)(m),u=(0,c.createComponentInstance)(U),(0,c.setupComponent)(u,e||{},null);let N=u.type;if(!N.render&&N.template){let I=J(N.template);N.render=(h,z)=>I(h,z.renderProxy)}return(0,c.mountComponent)(u,R),u.subTree&&f.mount(u.subTree,a),C=(0,T.effect)(()=>{if(!(!u||!u.isMounted||!f)&&((0,c.updateComponent)(u,R),u.subTree&&d)){let I=d.firstChild,h=u.subTree;for(;d.firstChild;)d.removeChild(d.firstChild);f.mount(h,d)}},{lazy:!0}),b=!0,r},unmount(){if(b){if(C&&((0,T.stop)(C),C=null),u&&(0,c.unmountComponent)(u),d)for(;d.firstChild;)d.removeChild(d.firstChild);u=null,f=null,d=null,b=!1}},use(l,...a){if(t.has(l))return r;t.add(l);let m=_({use:r.use.bind(r),unuse:r.unuse.bind(r),isInstalled:r.isInstalled.bind(r),provide:r.provide.bind(r),inject:r.inject.bind(r),config:s,globalProperties:P},l,...a);return m instanceof Promise?m.then(()=>r):r},unuse(l){if(!t.has(l))return r;t.delete(l);let a=F({use:r.use.bind(r),unuse:r.unuse.bind(r),isInstalled:r.isInstalled.bind(r),provide:r.provide.bind(r),inject:r.inject.bind(r),config:s,globalProperties:P},l);return a instanceof Promise?a.then(()=>r):r},isInstalled(l){return t.has(l)},provide(l,a){return p[l]=a,r},inject(l,a){let m=p[l];return m!==void 0?m:a},component(l,a){return a?(i[l]=a,r):i[l]},directive(l,a){return a?(o[l]=a,r):o[l]}};return r}A(v,require("@lytjs/common"),module.exports);
+'use strict';
+
+var component = require('@lytjs/component');
+var commonError = require('@lytjs/common-error');
+var vdom = require('@lytjs/vdom');
+var reactivity = require('@lytjs/reactivity');
+var commonScheduler = require('@lytjs/common-scheduler');
+var commonIs = require('@lytjs/common-is');
+var scope = require('@lytjs/reactivity/scope');
+var renderer = require('@lytjs/renderer');
+var commonObject = require('@lytjs/common-object');
+var compiler = require('@lytjs/compiler');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function createAppContext() {
+  return {
+    ...component.createAppContext(),
+    config: {
+      performance: false,
+      globalProperties: {}
+    },
+    renderer: null,
+    _vnode: null,
+    _container: null,
+    _instance: null
+  };
+}
+function createContextConfig(context) {
+  return new Proxy({}, {
+    get(_, key) {
+      if (key === "globalProperties") {
+        return context.config.globalProperties;
+      }
+      return context.config[key];
+    },
+    set(_, key, value) {
+      if (key === "globalProperties") {
+        context.config.globalProperties = value;
+        return true;
+      }
+      context.config[key] = value;
+      return true;
+    },
+    ownKeys() {
+      return Reflect.ownKeys(context.config);
+    },
+    has(_, key) {
+      return key in context.config;
+    },
+    getOwnPropertyDescriptor(_, key) {
+      return Object.getOwnPropertyDescriptor(context.config, key);
+    }
+  });
+}
+var init_app_context = __esm({
+  "src/app-context.ts"() {
+  }
+});
+exports.PluginRegistry = void 0;
+var init_plugin_registry = __esm({
+  "src/plugin-registry.ts"() {
+    exports.PluginRegistry = class {
+      constructor() {
+        /** 已注册插件映射（name → RegisteredPlugin） */
+        this.plugins = /* @__PURE__ */ new Map();
+        /** 事件监听器映射 */
+        this.listeners = /* @__PURE__ */ new Map();
+      }
+      /**
+       * 注册插件
+       * @param plugin - 插件实例（EnhancedPlugin 或基础 Plugin）
+       * @param options - 安装选项
+       * @returns 注册结果
+       */
+      register(plugin, options = void 0) {
+        const name = this.getPluginName(plugin);
+        if (!name) {
+          const result = {
+            success: false,
+            name: "anonymous",
+            error: "Plugin must have a name property. Use EnhancedPlugin interface for full support."
+          };
+          this.emit("error", result);
+          return result;
+        }
+        if (this.plugins.has(name)) {
+          const result = {
+            success: false,
+            name,
+            error: `Plugin "${name}" is already registered.`
+          };
+          this.emit("error", result);
+          return result;
+        }
+        if (this.isEnhancedPlugin(plugin)) {
+          const conflict = this.checkConflicts(plugin);
+          if (conflict) {
+            const result = {
+              success: false,
+              name,
+              error: `Plugin "${name}" conflicts with: ${conflict.join(", ")}`
+            };
+            this.emit("error", result);
+            return result;
+          }
+        }
+        this.emit("before:register", { name, plugin });
+        const registered = {
+          plugin: this.normalizePlugin(plugin),
+          options,
+          installed: false,
+          registeredAt: Date.now()
+        };
+        this.plugins.set(name, registered);
+        this.emit("after:register", { name, plugin });
+        return { success: true, name };
+      }
+      /**
+       * 注销插件
+       * @param name - 插件名称
+       * @returns 是否成功注销
+       */
+      unregister(name) {
+        const registered = this.plugins.get(name);
+        if (!registered) {
+          return false;
+        }
+        this.emit("before:unregister", { name, plugin: registered.plugin });
+        if (registered.installed && registered.plugin.cleanup) {
+          try {
+            const cleanupResult = registered.plugin.cleanup();
+            if (cleanupResult instanceof Promise) {
+              cleanupResult.catch((err) => {
+                commonError.error(
+                  `Plugin "${name}" async cleanup failed: ${err instanceof Error ? err.message : String(err)}`
+                );
+              });
+            }
+          } catch (err) {
+            commonError.error(
+              `Plugin "${name}" cleanup failed: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        this.plugins.delete(name);
+        this.emit("after:unregister", { name });
+        return true;
+      }
+      /**
+       * 获取已注册插件信息
+       * @param name - 插件名称
+       * @returns 插件注册信息，如果未找到则返回 undefined
+       */
+      get(name) {
+        return this.plugins.get(name);
+      }
+      /**
+       * 获取已注册的插件实例
+       * @param name - 插件名称
+       * @returns 插件实例，如果未找到则返回 undefined
+       */
+      getPlugin(name) {
+        return this.plugins.get(name)?.plugin;
+      }
+      /**
+       * 检查插件是否已注册
+       * @param name - 插件名称
+       */
+      has(name) {
+        return this.plugins.has(name);
+      }
+      /**
+       * 获取所有已注册插件名称
+       */
+      getNames() {
+        return Array.from(this.plugins.keys());
+      }
+      /**
+       * 获取所有已注册插件信息
+       */
+      getAll() {
+        return Array.from(this.plugins.values());
+      }
+      /**
+       * 获取已安装插件列表
+       */
+      getInstalled() {
+        return this.getAll().filter((p) => p.installed);
+      }
+      /**
+       * 标记插件为已安装
+       * @param name - 插件名称
+       */
+      markInstalled(name) {
+        const registered = this.plugins.get(name);
+        if (registered) {
+          registered.installed = true;
+          registered.installedAt = Date.now();
+        }
+      }
+      /**
+       * 标记插件为未安装
+       * @param name - 插件名称
+       */
+      markUninstalled(name) {
+        const registered = this.plugins.get(name);
+        if (registered) {
+          registered.installed = false;
+          registered.installedAt = void 0;
+        }
+      }
+      /**
+       * 检查插件依赖是否满足
+       * @param plugin - 要检查的插件
+       * @returns 依赖检查结果
+       */
+      checkDependencies(plugin) {
+        const result = {
+          satisfied: true,
+          missing: [],
+          missingOptional: [],
+          versionMismatch: []
+        };
+        if (!this.isEnhancedPlugin(plugin)) {
+          return result;
+        }
+        if (plugin.dependencies) {
+          for (const dep of plugin.dependencies) {
+            const registered = this.plugins.get(dep.name);
+            if (!registered) {
+              result.satisfied = false;
+              result.missing.push({ name: dep.name, version: dep.version });
+            } else if (dep.version && registered.plugin.version) {
+              if (!this.satisfiesVersion(registered.plugin.version, dep.version)) {
+                result.satisfied = false;
+                result.versionMismatch.push({
+                  name: dep.name,
+                  expected: dep.version,
+                  actual: registered.plugin.version
+                });
+              }
+            }
+          }
+        }
+        if (plugin.optionalDependencies) {
+          for (const dep of plugin.optionalDependencies) {
+            const registered = this.plugins.get(dep.name);
+            if (!registered) {
+              result.missingOptional.push({ name: dep.name, version: dep.version });
+            } else if (dep.version && registered.plugin.version) {
+              if (!this.satisfiesVersion(registered.plugin.version, dep.version)) {
+                result.versionMismatch.push({
+                  name: dep.name,
+                  expected: dep.version,
+                  actual: registered.plugin.version
+                });
+              }
+            }
+          }
+        }
+        return result;
+      }
+      /**
+       * 解析插件加载顺序（拓扑排序）
+       * @description 根据依赖关系计算正确的安装顺序
+       * @returns 排序后的插件列表
+       * @throws 如果存在循环依赖则抛出错误
+       */
+      resolveLoadOrder() {
+        const visited = /* @__PURE__ */ new Set();
+        const visiting = /* @__PURE__ */ new Set();
+        const result = [];
+        const visit = (name) => {
+          if (visited.has(name)) return;
+          if (visiting.has(name)) {
+            throw new Error(`Circular dependency detected involving plugin "${name}"`);
+          }
+          visiting.add(name);
+          const registered = this.plugins.get(name);
+          if (registered && this.isEnhancedPlugin(registered.plugin)) {
+            if (registered.plugin.dependencies) {
+              for (const dep of registered.plugin.dependencies) {
+                if (this.plugins.has(dep.name)) {
+                  visit(dep.name);
+                }
+              }
+            }
+          }
+          visiting.delete(name);
+          visited.add(name);
+          if (registered) {
+            result.push(registered.plugin);
+          }
+        };
+        for (const name of this.plugins.keys()) {
+          visit(name);
+        }
+        return result;
+      }
+      /**
+       * 获取插件数量
+       */
+      get size() {
+        return this.plugins.size;
+      }
+      /**
+       * 清空所有已注册插件
+       */
+      clear() {
+        for (const [name, registered] of this.plugins) {
+          if (registered.installed && registered.plugin.cleanup) {
+            try {
+              registered.plugin.cleanup();
+            } catch (err) {
+              commonError.error(
+                `Plugin "${name}" cleanup failed during clear: ${err instanceof Error ? err.message : String(err)}`
+              );
+            }
+          }
+        }
+        this.plugins.clear();
+      }
+      // ==================== 事件系统 ====================
+      /**
+       * 注册事件监听器
+       * @param event - 事件类型
+       * @param handler - 事件处理函数
+       * @returns 取消监听的函数
+       */
+      on(event, handler) {
+        if (!this.listeners.has(event)) {
+          this.listeners.set(event, /* @__PURE__ */ new Set());
+        }
+        this.listeners.get(event).add(handler);
+        return () => {
+          this.listeners.get(event)?.delete(handler);
+        };
+      }
+      /**
+       * 触发事件
+       * @param event - 事件类型
+       * @param data - 事件数据
+       */
+      emit(event, data) {
+        const handlers = this.listeners.get(event);
+        if (handlers) {
+          for (const handler of handlers) {
+            try {
+              handler(event, data);
+            } catch (err) {
+              commonError.error(
+                `Plugin event handler error for "${event}": ${err instanceof Error ? err.message : String(err)}`
+              );
+            }
+          }
+        }
+      }
+      /**
+       * 移除事件监听器
+       * @param event - 事件类型
+       * @param handler - 事件处理函数
+       */
+      off(event, handler) {
+        this.listeners.get(event)?.delete(handler);
+      }
+      // ==================== 内部工具方法 ====================
+      /**
+       * 获取插件名称
+       */
+      getPluginName(plugin) {
+        if (this.isEnhancedPlugin(plugin)) {
+          return plugin.name;
+        }
+        return plugin.name;
+      }
+      /**
+       * 检查是否为 EnhancedPlugin
+       */
+      isEnhancedPlugin(plugin) {
+        return "name" in plugin && typeof plugin.name === "string";
+      }
+      /**
+       * 将基础 Plugin 标准化为 EnhancedPlugin
+       */
+      normalizePlugin(plugin) {
+        if (this.isEnhancedPlugin(plugin)) {
+          return plugin;
+        }
+        const anonymousName = `anonymous-plugin-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        return {
+          install: plugin.install,
+          name: anonymousName
+        };
+      }
+      /**
+       * 检查插件冲突
+       */
+      checkConflicts(plugin) {
+        if (!plugin.conflicts || plugin.conflicts.length === 0) {
+          return null;
+        }
+        const conflicts = [];
+        for (const conflictName of plugin.conflicts) {
+          if (this.plugins.has(conflictName)) {
+            conflicts.push(conflictName);
+          }
+        }
+        return conflicts.length > 0 ? conflicts : null;
+      }
+      /**
+       * 简单的 semver 版本比较
+       * @description 支持 ^, ~, >=, >, <, <=, = 前缀
+       */
+      satisfiesVersion(actual, expected) {
+        const actualVersion = this.parseVersion(actual);
+        if (!actualVersion) return false;
+        const range = expected.trim();
+        let prefix = "";
+        let expectedVersion = range;
+        if (range.startsWith("^") || range.startsWith("~") || range.startsWith(">") || range.startsWith("<") || range.startsWith("=")) {
+          const firstChar = range[0];
+          prefix = firstChar;
+          expectedVersion = range.slice(1).trim();
+          if (range.startsWith(">=") || range.startsWith("<=")) {
+            prefix = range.slice(0, 2);
+            expectedVersion = range.slice(2).trim();
+          }
+        }
+        const expectedParsed = this.parseVersion(expectedVersion);
+        if (!expectedParsed) return false;
+        switch (prefix) {
+          case "":
+          case "=":
+            return actualVersion.major === expectedParsed.major && actualVersion.minor === expectedParsed.minor && actualVersion.patch === expectedParsed.patch;
+          case "^":
+            return actualVersion.major === expectedParsed.major && (actualVersion.minor > expectedParsed.minor || actualVersion.minor === expectedParsed.minor && actualVersion.patch >= expectedParsed.patch);
+          case "~":
+            return actualVersion.major === expectedParsed.major && actualVersion.minor === expectedParsed.minor && actualVersion.patch >= expectedParsed.patch;
+          case ">":
+            return this.compareVersions(actualVersion, expectedParsed) > 0;
+          case ">=":
+            return this.compareVersions(actualVersion, expectedParsed) >= 0;
+          case "<":
+            return this.compareVersions(actualVersion, expectedParsed) < 0;
+          case "<=":
+            return this.compareVersions(actualVersion, expectedParsed) <= 0;
+          default:
+            return false;
+        }
+      }
+      /**
+       * 解析版本号字符串
+       */
+      parseVersion(version) {
+        const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+        if (!match) return null;
+        return {
+          major: parseInt(match[1], 10),
+          minor: parseInt(match[2], 10),
+          patch: parseInt(match[3], 10)
+        };
+      }
+      /**
+       * 比较两个版本号
+       * @returns 正数表示 a > b，负数表示 a < b，0 表示相等
+       */
+      compareVersions(a, b) {
+        if (a.major !== b.major) return a.major - b.major;
+        if (a.minor !== b.minor) return a.minor - b.minor;
+        return a.patch - b.patch;
+      }
+    };
+  }
+});
+
+// src/plugin-validator.ts
+exports.PluginValidator = void 0;
+var init_plugin_validator = __esm({
+  "src/plugin-validator.ts"() {
+    exports.PluginValidator = class {
+      constructor() {
+        /** 内置验证规则列表 */
+        this.rules = [];
+        /** 已知插件名称集合（用于跨插件验证） */
+        this.knownPlugins = /* @__PURE__ */ new Set();
+        this.rules = [
+          this.validateStructure.bind(this),
+          this.validateName.bind(this),
+          this.validateVersion.bind(this),
+          this.validateDependencies.bind(this),
+          this.validateConflicts.bind(this),
+          this.validatePeerRequirements.bind(this),
+          this.validateLifecycleHooks.bind(this)
+        ];
+      }
+      /**
+       * 验证插件
+       * @param plugin - 要验证的插件
+       * @returns 验证报告
+       */
+      validate(plugin) {
+        const pluginName = this.getPluginName(plugin) ?? "anonymous";
+        const context = {
+          knownPlugins: this.knownPlugins
+        };
+        const issues = [];
+        for (const rule of this.rules) {
+          try {
+            const ruleIssues = rule(plugin, context);
+            issues.push(...ruleIssues);
+          } catch (err) {
+            issues.push({
+              level: "error",
+              rule: "rule-execution",
+              message: `Validation rule execution failed: ${err instanceof Error ? err.message : String(err)}`
+            });
+          }
+        }
+        const errorCount = issues.filter((i) => i.level === "error").length;
+        const warningCount = issues.filter((i) => i.level === "warning").length;
+        const infoCount = issues.filter((i) => i.level === "info").length;
+        return {
+          valid: errorCount === 0,
+          pluginName,
+          issues,
+          errorCount,
+          warningCount,
+          infoCount
+        };
+      }
+      /**
+       * 批量验证多个插件
+       * @param plugins - 要验证的插件列表
+       * @returns 验证报告列表
+       */
+      validateAll(plugins) {
+        return plugins.map((plugin) => this.validate(plugin));
+      }
+      /**
+       * 注册已知插件名称（用于跨插件验证）
+       * @param names - 插件名称列表
+       */
+      registerKnownPlugins(names) {
+        for (const name of names) {
+          this.knownPlugins.add(name);
+        }
+      }
+      /**
+       * 添加自定义验证规则
+       * @param rule - 验证规则函数
+       */
+      addRule(rule) {
+        this.rules.push(rule);
+      }
+      /**
+       * 移除验证规则
+       * @param rule - 要移除的验证规则函数
+       */
+      removeRule(rule) {
+        const index = this.rules.indexOf(rule);
+        if (index !== -1) {
+          this.rules.splice(index, 1);
+        }
+      }
+      // ==================== 内置验证规则 ====================
+      /**
+       * 规则：验证插件基本结构
+       * @description 确保插件有 install 方法
+       */
+      validateStructure(plugin) {
+        const issues = [];
+        if (!plugin || typeof plugin !== "object") {
+          issues.push({
+            level: "error",
+            rule: "validate-structure",
+            message: "Plugin must be an object."
+          });
+          return issues;
+        }
+        if (typeof plugin.install !== "function") {
+          issues.push({
+            level: "error",
+            rule: "validate-structure",
+            message: 'Plugin must have an "install" method that is a function.'
+          });
+        }
+        return issues;
+      }
+      /**
+       * 规则：验证插件名称
+       * @description 确保名称有效且不冲突
+       */
+      validateName(plugin) {
+        const issues = [];
+        if (!plugin || typeof plugin !== "object") {
+          return issues;
+        }
+        const name = this.getPluginName(plugin);
+        if (name === void 0) {
+          issues.push({
+            level: "warning",
+            rule: "validate-name",
+            message: 'Plugin has no name. It is recommended to use EnhancedPlugin with a "name" property for better debugging and dependency management.'
+          });
+          return issues;
+        }
+        if (typeof name !== "string") {
+          issues.push({
+            level: "error",
+            rule: "validate-name",
+            message: `Plugin name must be a string, got ${typeof name}.`
+          });
+          return issues;
+        }
+        if (name.trim().length === 0) {
+          issues.push({
+            level: "error",
+            rule: "validate-name",
+            message: "Plugin name must not be empty."
+          });
+          return issues;
+        }
+        const validNamePattern = /^[a-z][a-z0-9-]*$/;
+        if (!validNamePattern.test(name)) {
+          issues.push({
+            level: "warning",
+            rule: "validate-name",
+            message: `Plugin name "${name}" does not follow kebab-case convention (e.g., "my-plugin").`
+          });
+        }
+        if (name.length > 100) {
+          issues.push({
+            level: "warning",
+            rule: "validate-name",
+            message: `Plugin name "${name}" is too long (max 100 characters).`
+          });
+        }
+        return issues;
+      }
+      /**
+       * 规则：验证版本号格式
+       * @description 确保版本号符合 semver 格式
+       */
+      validateVersion(plugin) {
+        const issues = [];
+        if (!this.isEnhancedPlugin(plugin)) {
+          return issues;
+        }
+        if (plugin.version !== void 0) {
+          if (typeof plugin.version !== "string") {
+            issues.push({
+              level: "error",
+              rule: "validate-version",
+              message: `Plugin version must be a string, got ${typeof plugin.version}.`
+            });
+          } else {
+            const semverPattern = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?(\+[a-zA-Z0-9.]+)?$/;
+            if (!semverPattern.test(plugin.version)) {
+              issues.push({
+                level: "warning",
+                rule: "validate-version",
+                message: `Plugin version "${plugin.version}" does not follow semver format (e.g., "1.0.0").`
+              });
+            }
+          }
+        } else {
+          issues.push({
+            level: "info",
+            rule: "validate-version",
+            message: "Plugin has no version. It is recommended to provide a version for compatibility checks."
+          });
+        }
+        return issues;
+      }
+      /**
+       * 规则：验证依赖声明
+       * @description 检查依赖格式和已知性
+       */
+      validateDependencies(plugin) {
+        const issues = [];
+        if (!this.isEnhancedPlugin(plugin)) {
+          return issues;
+        }
+        if (plugin.dependencies) {
+          if (!Array.isArray(plugin.dependencies)) {
+            issues.push({
+              level: "error",
+              rule: "validate-dependencies",
+              message: 'Plugin "dependencies" must be an array.'
+            });
+          } else {
+            issues.push(...this.validateDependencyArray(plugin.dependencies, "dependencies", false));
+          }
+        }
+        if (plugin.optionalDependencies) {
+          if (!Array.isArray(plugin.optionalDependencies)) {
+            issues.push({
+              level: "error",
+              rule: "validate-dependencies",
+              message: 'Plugin "optionalDependencies" must be an array.'
+            });
+          } else {
+            issues.push(
+              ...this.validateDependencyArray(
+                plugin.optionalDependencies,
+                "optionalDependencies",
+                true
+              )
+            );
+          }
+        }
+        if (plugin.dependencies && plugin.name) {
+          for (const dep of plugin.dependencies) {
+            if (dep.name === plugin.name) {
+              issues.push({
+                level: "error",
+                rule: "validate-dependencies",
+                message: `Plugin "${plugin.name}" cannot depend on itself.`
+              });
+            }
+          }
+        }
+        return issues;
+      }
+      /**
+       * 验证依赖数组
+       */
+      validateDependencyArray(deps, field, isOptional) {
+        const issues = [];
+        const seenNames = /* @__PURE__ */ new Set();
+        for (const dep of deps) {
+          if (!dep.name || typeof dep.name !== "string") {
+            issues.push({
+              level: "error",
+              rule: "validate-dependencies",
+              message: `Each dependency in "${field}" must have a valid "name" string.`
+            });
+            continue;
+          }
+          if (seenNames.has(dep.name)) {
+            issues.push({
+              level: "warning",
+              rule: "validate-dependencies",
+              message: `Duplicate dependency "${dep.name}" in "${field}".`
+            });
+          }
+          seenNames.add(dep.name);
+          if (dep.version !== void 0 && typeof dep.version !== "string") {
+            issues.push({
+              level: "error",
+              rule: "validate-dependencies",
+              message: `Dependency "${dep.name}" version must be a string.`
+            });
+          }
+          if (dep.optional && !isOptional) {
+            issues.push({
+              level: "info",
+              rule: "validate-dependencies",
+              message: `Dependency "${dep.name}" has "optional: true" but is in required "${field}". Consider moving it to "optionalDependencies".`
+            });
+          }
+        }
+        return issues;
+      }
+      /**
+       * 规则：验证冲突声明
+       * @description 检查冲突列表格式
+       */
+      validateConflicts(plugin) {
+        const issues = [];
+        if (!this.isEnhancedPlugin(plugin)) {
+          return issues;
+        }
+        if (plugin.conflicts) {
+          if (!Array.isArray(plugin.conflicts)) {
+            issues.push({
+              level: "error",
+              rule: "validate-conflicts",
+              message: 'Plugin "conflicts" must be an array of plugin name strings.'
+            });
+          } else {
+            for (const conflict of plugin.conflicts) {
+              if (typeof conflict !== "string") {
+                issues.push({
+                  level: "error",
+                  rule: "validate-conflicts",
+                  message: `Each conflict entry must be a string, got ${typeof conflict}.`
+                });
+              }
+            }
+            if (plugin.name && plugin.conflicts.includes(plugin.name)) {
+              issues.push({
+                level: "error",
+                rule: "validate-conflicts",
+                message: `Plugin "${plugin.name}" cannot conflict with itself.`
+              });
+            }
+          }
+        }
+        return issues;
+      }
+      /**
+       * 规则：验证 peerRequirements
+       * @description 检查宿主框架版本要求格式
+       */
+      validatePeerRequirements(plugin) {
+        const issues = [];
+        if (!this.isEnhancedPlugin(plugin)) {
+          return issues;
+        }
+        if (plugin.peerRequirements) {
+          if (typeof plugin.peerRequirements !== "object" || plugin.peerRequirements === null) {
+            issues.push({
+              level: "error",
+              rule: "validate-peer-requirements",
+              message: 'Plugin "peerRequirements" must be an object.'
+            });
+            return issues;
+          }
+          const { lytjs, node } = plugin.peerRequirements;
+          if (lytjs !== void 0 && typeof lytjs !== "string") {
+            issues.push({
+              level: "error",
+              rule: "validate-peer-requirements",
+              message: "peerRequirements.lytjs must be a version range string."
+            });
+          }
+          if (node !== void 0 && typeof node !== "string") {
+            issues.push({
+              level: "error",
+              rule: "validate-peer-requirements",
+              message: "peerRequirements.node must be a version range string."
+            });
+          }
+        }
+        return issues;
+      }
+      /**
+       * 规则：验证生命周期钩子
+       * @description 确保生命周期钩子是函数
+       */
+      validateLifecycleHooks(plugin) {
+        const issues = [];
+        if (!this.isEnhancedPlugin(plugin)) {
+          return issues;
+        }
+        const hooks = [
+          { name: "beforeInstall", value: plugin.beforeInstall },
+          { name: "afterInstall", value: plugin.afterInstall },
+          { name: "beforeMount", value: plugin.beforeMount },
+          { name: "afterMount", value: plugin.afterMount },
+          { name: "cleanup", value: plugin.cleanup }
+        ];
+        for (const hook of hooks) {
+          if (hook.value !== void 0 && typeof hook.value !== "function") {
+            issues.push({
+              level: "error",
+              rule: "validate-lifecycle-hooks",
+              message: `Plugin lifecycle hook "${hook.name}" must be a function, got ${typeof hook.value}.`
+            });
+          }
+        }
+        return issues;
+      }
+      // ==================== 工具方法 ====================
+      /**
+       * 获取插件名称
+       */
+      getPluginName(plugin) {
+        if (this.isEnhancedPlugin(plugin)) {
+          return plugin.name;
+        }
+        if (plugin == null || typeof plugin !== "object") {
+          return void 0;
+        }
+        const rawName = plugin.name;
+        return typeof rawName === "string" ? rawName : void 0;
+      }
+      /**
+       * 检查是否为 EnhancedPlugin
+       */
+      isEnhancedPlugin(plugin) {
+        return plugin != null && typeof plugin === "object" && "name" in plugin && typeof plugin.name === "string";
+      }
+    };
+  }
+});
+async function getSignalRenderer() {
+  if (!createSignalRenderer) {
+    const renderer = await import('@lytjs/renderer');
+    createSignalRenderer = renderer.createSignalRenderer;
+  }
+  return createSignalRenderer;
+}
+async function getDOMRenderer() {
+  if (!createDOMRenderer) {
+    const renderer = await import('@lytjs/renderer');
+    createDOMRenderer = renderer.createDOMRenderer;
+  }
+  return createDOMRenderer;
+}
+function createApp(rootComponent, rootProps = null, options) {
+  const context = createAppContext();
+  const installedPlugins = /* @__PURE__ */ new Set();
+  const pluginRegistry = new exports.PluginRegistry();
+  const pluginValidator = new exports.PluginValidator();
+  let _isUnmounted = false;
+  const _globalListeners = [];
+  const rendererMode = options?.rendererMode ?? "vnode";
+  const effectiveMode = rendererMode === "vapor" ? "signal" : rendererMode;
+  let signalRenderer = null;
+  const app = {
+    config: createContextConfig(context),
+    use(plugin, ...options2) {
+      if (installedPlugins.has(plugin)) return app;
+      try {
+        if (typeof plugin !== "function" && "name" in plugin && typeof plugin.name === "string") {
+          const enhancedPlugin = plugin;
+          const report = pluginValidator.validate(enhancedPlugin);
+          if (!report.valid) {
+            const errorMessages = report.issues.filter((i) => i.level === "error").map((i) => `[${i.rule}] ${i.message}`).join("; ");
+            throw new Error(`Plugin "${enhancedPlugin.name}" validation failed: ${errorMessages}`);
+          }
+          const regResult = pluginRegistry.register(enhancedPlugin, options2);
+          if (!regResult.success) {
+            throw new Error(regResult.error);
+          }
+          const depResult = pluginRegistry.checkDependencies(enhancedPlugin);
+          if (!depResult.satisfied && depResult.missing.length > 0) {
+            const missingNames = depResult.missing.map((d) => d.name).join(", ");
+            throw new Error(
+              `Plugin "${enhancedPlugin.name}" has unsatisfied dependencies: ${missingNames}`
+            );
+          }
+          if (enhancedPlugin.beforeInstall) {
+            const shouldContinue = enhancedPlugin.beforeInstall(app);
+            if (shouldContinue instanceof Promise) {
+              throw new Error(
+                "Plugin beforeInstall hook cannot be async when using synchronous app.use(). Use await app.use() for async plugins."
+              );
+            }
+            if (shouldContinue === false) {
+              pluginRegistry.unregister(enhancedPlugin.name);
+              return app;
+            }
+          }
+          plugin.install(app, ...options2);
+          pluginRegistry.markInstalled(enhancedPlugin.name);
+          if (enhancedPlugin.afterInstall) {
+            enhancedPlugin.afterInstall(app);
+          }
+        } else {
+          if (typeof plugin === "function") {
+            plugin(app, ...options2);
+          } else {
+            plugin.install(app, ...options2);
+          }
+        }
+        installedPlugins.add(plugin);
+      } catch (err) {
+        commonError.error(
+          `Plugin failed to install: ${typeof plugin === "function" ? plugin.name || "anonymous function" : plugin.install?.name || "plugin"}: ${err}`
+        );
+        throw err;
+      }
+      return app;
+    },
+    /**
+     * 获取插件注册表实例
+     * @description 提供对 PluginRegistry 的访问，用于高级插件管理
+     */
+    get _pluginRegistry() {
+      return pluginRegistry;
+    },
+    /**
+     * 获取插件验证器实例
+     * @description 提供对 PluginValidator 的访问，用于自定义验证
+     */
+    get _pluginValidator() {
+      return pluginValidator;
+    },
+    async mount(rootContainer) {
+      if (_isUnmounted) {
+        throw new Error(
+          `[LytJS] App has been unmounted and cannot be remounted. Create a new app instance instead.`
+        );
+      }
+      if (!rootComponent) {
+        return null;
+      }
+      if (context._container) {
+        throw new Error(
+          `[LytJS] App is already mounted. Call app.unmount() first before mounting again.`
+        );
+      }
+      const container = typeof rootContainer === "string" ? document.querySelector(rootContainer) : rootContainer;
+      if (!container) {
+        throw new Error(
+          `[LytJS] Failed to mount app: cannot find element matching selector "${rootContainer}". Make sure the target element exists in the DOM before calling app.mount().`
+        );
+      }
+      context._container = container;
+      try {
+        if (effectiveMode === "signal") {
+          return mountWithSignalMode(container);
+        }
+        return await mountWithVNodeMode(container);
+      } catch (err) {
+        if (app.errorHandler) {
+          app.errorHandler(err, null, "mount");
+        } else {
+          commonError.error(`[LytJS] Failed to mount app: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        throw err;
+      }
+    },
+    unmount() {
+      for (const listener of _globalListeners) {
+        try {
+          listener.target.removeEventListener(listener.event, listener.handler, listener.options);
+        } catch (err) {
+        }
+      }
+      _globalListeners.length = 0;
+      for (const plugin of installedPlugins) {
+        const pluginWithCleanup = plugin;
+        if (typeof pluginWithCleanup?.cleanup === "function") {
+          try {
+            pluginWithCleanup.cleanup();
+          } catch (err) {
+            const pluginName = pluginWithCleanup.name ?? (typeof plugin === "function" ? plugin.name : "unknown");
+            commonError.error(
+              `Plugin cleanup failed for "${pluginName}": ${err instanceof Error ? err.message : String(err)}. This may cause memory leaks.`
+            );
+          }
+        }
+      }
+      installedPlugins.clear();
+      if (effectiveMode === "signal") {
+        const componentOptions = rootComponent;
+        if (componentOptions != null && typeof componentOptions === "object") {
+          const beforeUnmount = componentOptions.beforeUnmount;
+          if (typeof beforeUnmount === "function") {
+            beforeUnmount.call(componentOptions);
+          }
+        }
+        if (signalRenderer) {
+          signalRenderer.unmount();
+          signalRenderer = null;
+        }
+        if (context._container) {
+          const container = context._container;
+          while (container.firstChild) {
+            container.removeChild(container.firstChild);
+          }
+        }
+        const unmounted = componentOptions.unmounted;
+        if (typeof unmounted === "function") {
+          unmounted.call(componentOptions);
+        }
+      } else {
+        if (!context.renderer || !context._vnode) return;
+        const instance = context._instance;
+        if (instance) {
+          component.callUnmountedHook(instance);
+        }
+        context.renderer.unmount(context._vnode);
+        context._vnode = null;
+      }
+      _isUnmounted = true;
+      context._container = null;
+      context.mixins.length = 0;
+      context.components = {};
+      context.directives = {};
+      context.provides = {};
+      context.config.globalProperties = {};
+      context._instance = null;
+      context.renderer = null;
+    },
+    provide(key, value) {
+      context.provides[key] = value;
+      return app;
+    },
+    inject(key) {
+      return context.provides[key];
+    },
+    component(name, component) {
+      if (component != null && typeof component !== "object" && typeof component !== "function") {
+        return app;
+      }
+      context.components[name] = component;
+      return app;
+    },
+    directive(name, directive) {
+      context.directives[name] = directive;
+      return app;
+    },
+    mixin(mixin) {
+      context.mixins.push(mixin);
+      return app;
+    },
+    /**
+     * Register a global event listener that will be automatically cleaned up on unmount.
+     * This ensures no leaked event listeners when the app is destroyed.
+     */
+    on(target, event, handler, options2) {
+      target.addEventListener(event, handler, options2);
+      _globalListeners.push({ target, event, handler, options: options2 });
+      return app;
+    },
+    /**
+     * Remove a previously registered global event listener.
+     * FIX: P2-v11-06 off() 使用引用相等性匹配 handler，
+     * 这意味着传入的 handler 必须与 on() 注册时使用同一个函数引用。
+     * 如果使用匿名函数或箭头函数，将无法匹配。请保存函数引用后再传入。
+     */
+    off(target, event, handler, options2) {
+      target.removeEventListener(event, handler, options2);
+      const idx = _globalListeners.findIndex(
+        (l) => l.target === target && l.event === event && l.handler === handler
+      );
+      if (idx !== -1) {
+        _globalListeners.splice(idx, 1);
+      }
+      return app;
+    }
+  };
+  async function mountWithVNodeMode(container) {
+    const rootVNode = vdom.createVNode(rootComponent, rootProps);
+    const instance = component.createComponentInstance(rootVNode, null);
+    instance.appContext = context;
+    if (context.provides) {
+      const rootProvides = instance.provides;
+      for (const key of Object.keys(context.provides)) {
+        if (!(key in rootProvides)) {
+          rootProvides[key] = context.provides[key];
+        }
+      }
+    }
+    component.setupComponent(instance);
+    rootVNode.component = instance;
+    context._instance = instance;
+    if (effectiveMode !== "vnode") {
+      throw new Error("[LytJS] Invalid renderer mode");
+    }
+    const domRendererFn = await getDOMRenderer();
+    const renderer = domRendererFn({
+      setupChildComponent(childVNode, parentComponent) {
+        const childInstance = component.createComponentInstance(childVNode, parentComponent);
+        if (parentComponent) {
+          childInstance.appContext = parentComponent.appContext;
+        } else {
+          childInstance.appContext = context;
+        }
+        component.setupComponent(childInstance);
+        childVNode.component = childInstance;
+      },
+      normalizeProps(inst, rawProps) {
+        component.initProps(inst, rawProps);
+      }
+    });
+    context.renderer = renderer;
+    context._vnode = rootVNode;
+    renderer.mount(rootVNode, container);
+    const publicInstance = component.createComponentPublicInstance(instance);
+    return publicInstance;
+  }
+  async function mountWithSignalMode(container) {
+    if (!rootComponent || typeof rootComponent !== "object") {
+      throw new Error(
+        `[LytJS] Signal mode requires rootComponent to be a valid component options object.`
+      );
+    }
+    const componentOptions = rootComponent;
+    const template = componentOptions.template;
+    if (!template) {
+      throw new Error(
+        `[LytJS] Signal mode requires a template string in the root component. Provide a 'template' property in your component options.`
+      );
+    }
+    const ctx = { ...rootProps };
+    if (typeof componentOptions.data === "function") {
+      try {
+        const dataResult = componentOptions.data();
+        Object.assign(ctx, dataResult);
+      } catch (e) {
+        const enhancedError = new Error(
+          `[LytJS] Failed to execute data() in Signal mode: ${e instanceof Error ? e.message : String(e)}. Component: ${rootComponent.name ?? "anonymous"}`
+        );
+        enhancedError.cause = e;
+        commonError.error(enhancedError.message);
+        throw enhancedError;
+      }
+    }
+    if (typeof componentOptions.setup === "function") {
+      try {
+        const setupResult = componentOptions.setup(rootProps ?? {}, {});
+        if (setupResult && typeof setupResult === "object") {
+          Object.assign(ctx, setupResult);
+        }
+      } catch (e) {
+        const enhancedError = new Error(
+          `[LytJS] Failed to execute setup() in Signal mode: ${e instanceof Error ? e.message : String(e)}. Component: ${rootComponent.name ?? "anonymous"}`
+        );
+        enhancedError.cause = e;
+        commonError.error(enhancedError.message);
+        throw enhancedError;
+      }
+    }
+    const beforeMount = componentOptions.beforeMount;
+    if (typeof beforeMount === "function") {
+      beforeMount.call(ctx);
+    }
+    const signalRendererFn = await getSignalRenderer();
+    signalRenderer = await signalRendererFn(template, ctx);
+    signalRenderer.render(container);
+    const mounted = componentOptions.mounted;
+    if (typeof mounted === "function") {
+      mounted.call(ctx);
+    }
+    return new Proxy({}, {
+      get(_, key) {
+        if (key === "$el") return container;
+        if (key === "$options") return componentOptions;
+        return ctx[key];
+      },
+      set(_, key, value) {
+        ctx[key] = value;
+        return true;
+      }
+    });
+  }
+  return app;
+}
+var createSignalRenderer, createDOMRenderer;
+var init_create_app = __esm({
+  "src/create-app.ts"() {
+    init_app_context();
+    init_plugin_registry();
+    init_plugin_validator();
+    createSignalRenderer = null;
+    createDOMRenderer = null;
+  }
+});
+function h(type, props, ...children) {
+  if (props == null) {
+    props = vdom.EMPTY_OBJ;
+  }
+  const flatChildren = children.length > 1 ? children.flat(Infinity) : Array.isArray(children[0]) ? children[0].flat(Infinity) : children[0];
+  return vdom.createVNode(type, props, flatChildren);
+}
+var init_h = __esm({
+  "src/h.ts"() {
+  }
+});
+function defineAsyncComponent(source) {
+  if (typeof source === "function") {
+    source = { loader: source };
+  }
+  const { loader, loadingComponent, errorComponent, delay = 200, timeout, onError } = source;
+  const loadedComponent = reactivity.shallowRef(void 0);
+  const error3 = reactivity.ref(void 0);
+  const loading = reactivity.ref(false);
+  let retries = 0;
+  let showLoading = false;
+  let delayTimer = null;
+  let loadingPromise = null;
+  const MAX_RETRIES = 3;
+  const retry = () => {
+    if (retries >= MAX_RETRIES) {
+      error3.value = new Error(
+        `[lytjs/core] AsyncComponent: max retries (${MAX_RETRIES}) exceeded.`
+      );
+      return Promise.reject(error3.value);
+    }
+    retries++;
+    loadedComponent.value = void 0;
+    error3.value = void 0;
+    loadingPromise = null;
+    startTimeout();
+    return load();
+  };
+  const load = () => {
+    if (loadingPromise) return loadingPromise;
+    loading.value = true;
+    showLoading = false;
+    if (delayTimer) clearTimeout(delayTimer);
+    delayTimer = setTimeout(() => {
+      showLoading = true;
+    }, delay);
+    return loadingPromise = Promise.resolve(loader()).then((comp2) => {
+      if (comp2 == null || typeof comp2 !== "object" && typeof comp2 !== "function") {
+        throw new Error(
+          `[lytjs/core] AsyncComponent: loader() returned an invalid component value: ${String(comp2)}. Expected a component options object or function.`
+        );
+      }
+      loadedComponent.value = comp2;
+      error3.value = void 0;
+      loading.value = false;
+      loadingPromise = null;
+      if (delayTimer) {
+        clearTimeout(delayTimer);
+        delayTimer = null;
+      }
+      showLoading = false;
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      return comp2;
+    }).catch((err) => {
+      error3.value = err;
+      loading.value = false;
+      if (onError) {
+        return new Promise((resolve, reject) => {
+          let settled = false;
+          const ON_ERROR_TIMEOUT = DEFAULT_ON_ERROR_TIMEOUT;
+          const timer = setTimeout(() => {
+            if (!settled) {
+              settled = true;
+              reject(
+                new Error(
+                  `[lytjs/core] AsyncComponent: onError callback did not call retry() or reject() within ${ON_ERROR_TIMEOUT / 1e3}s.`
+                )
+              );
+            }
+          }, ON_ERROR_TIMEOUT);
+          onError(
+            err,
+            () => {
+              if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                const result = retry();
+                if (result) resolve(result);
+              }
+            },
+            (reason) => {
+              if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                reject(reason ?? err);
+              }
+            },
+            retries
+          );
+        });
+      }
+      return Promise.reject(err);
+    });
+  };
+  let timeoutId = null;
+  const startTimeout = () => {
+    if (timeout == null) return;
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      if (!loadedComponent.value && !error3.value) {
+        error3.value = new Error(`[lytjs/core] AsyncComponent timed out after ${timeout}ms.`);
+        loading.value = false;
+      }
+    }, timeout);
+  };
+  startTimeout();
+  const comp = {
+    name: "AsyncComponent",
+    setup() {
+      const instance = {
+        resolved: loadedComponent,
+        loading,
+        error: error3,
+        delay,
+        timeout
+      };
+      component.onBeforeUnmount(() => {
+        if (timeoutId !== null) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+        if (delayTimer !== null) {
+          clearTimeout(delayTimer);
+          delayTimer = null;
+        }
+      });
+      if (!loadedComponent.value && !error3.value && !loading.value) {
+        load();
+      }
+      return instance;
+    },
+    render() {
+      if (loadedComponent.value) {
+        return h(loadedComponent.value);
+      }
+      if (error3.value && errorComponent) {
+        return h(errorComponent);
+      }
+      if (showLoading && loadingComponent) {
+        return h(loadingComponent);
+      }
+      return null;
+    }
+  };
+  return comp;
+}
+var DEFAULT_ON_ERROR_TIMEOUT; exports.defineComponent = void 0;
+var init_define_component = __esm({
+  "src/define-component.ts"() {
+    init_h();
+    DEFAULT_ON_ERROR_TIMEOUT = 3e4;
+    exports.defineComponent = component.defineComponent;
+  }
+});
+var init_next_tick = __esm({
+  "src/next-tick.ts"() {
+  }
+});
+function resolveComponent(name) {
+  const instance = component.getCurrentInstance();
+  if (!instance) {
+    return void 0;
+  }
+  const components = instance.type?.components;
+  if (components && components[name]) {
+    return components[name];
+  }
+  const globalComponents = instance.appContext?.components;
+  if (globalComponents && globalComponents[name]) {
+    return globalComponents[name];
+  }
+  return void 0;
+}
+function resolveDirective(name) {
+  const instance = component.getCurrentInstance();
+  if (!instance) {
+    return void 0;
+  }
+  const directives = instance.type?.directives;
+  if (directives && directives[name]) {
+    return directives[name];
+  }
+  const globalDirectives = instance.appContext?.directives;
+  if (globalDirectives && globalDirectives[name]) {
+    return globalDirectives[name];
+  }
+  return void 0;
+}
+function resolveDynamicComponent(tag) {
+  if (typeof tag === "string") {
+    const resolved = resolveComponent(tag);
+    return resolved ?? tag;
+  }
+  return tag;
+}
+var init_resolve = __esm({
+  "src/resolve.ts"() {
+  }
+});
+function withDirectives(vnode, directives) {
+  const dirVNode = vdom.cloneVNode(vnode);
+  const normalizedDirectives = directives.map(
+    ([dir, value, arg, modifiers]) => [
+      dir,
+      value,
+      arg,
+      modifiers || {}
+    ]
+  );
+  dirVNode._directives = normalizedDirectives.map(
+    ([dir, value, arg, modifiers]) => ({
+      dir,
+      value,
+      arg,
+      modifiers: modifiers ?? {}
+    })
+  );
+  for (const dirEntry of dirVNode._directives) {
+    const dirObj = dirEntry;
+    if (dirObj.dir.deep) {
+      applyDirectiveDeep(dirVNode, [
+        dirObj.dir,
+        dirObj.value,
+        dirObj.arg,
+        dirObj.modifiers
+      ]);
+    }
+  }
+  return dirVNode;
+}
+function applyDirectiveDeep(vnode, directive) {
+  const children = vnode.children;
+  if (!children) return;
+  const visited = /* @__PURE__ */ new Set();
+  visited.add(vnode);
+  const childArray = commonIs.isArray(children) ? children : [children];
+  for (const child of childArray) {
+    if (!child || typeof child !== "object") continue;
+    const childVNode = child;
+    if (visited.has(childVNode)) continue;
+    visited.add(childVNode);
+    if (!childVNode._directives) {
+      childVNode._directives = [];
+    }
+    childVNode._directives.push(directive);
+    applyDirectiveDeep(childVNode, directive);
+  }
+}
+function withMemo(memo, render, cache, index) {
+  if (index < 0 || index >= cache.length) {
+    const result2 = render();
+    cache[index] = { memo, result: result2 };
+    return result2;
+  }
+  const cached = cache[index];
+  if (cached && isMemoSame(cached.memo, memo)) {
+    return cached.result;
+  }
+  const result = render();
+  cache[index] = { memo, result };
+  return result;
+}
+function isMemoSame(prev, next) {
+  if (prev.length !== next.length) return false;
+  for (let i = 0; i < prev.length; i++) {
+    if (prev[i] !== next[i]) return false;
+  }
+  return true;
+}
+var init_directives = __esm({
+  "src/directives.ts"() {
+  }
+});
+function useSlots() {
+  const instance = component.getCurrentInstance();
+  if (!instance) {
+    return {};
+  }
+  return instance.slots || {};
+}
+function useAttrs() {
+  const instance = component.getCurrentInstance();
+  if (!instance) {
+    return {};
+  }
+  return instance.attrs || {};
+}
+function useModel(props, key) {
+  const instance = component.getCurrentInstance();
+  if (!instance) {
+    return reactivity.computed({
+      get() {
+        return void 0;
+      },
+      set() {
+      }
+    });
+  }
+  return reactivity.computed({
+    get() {
+      return props[key];
+    },
+    set(newValue) {
+      instance.emit(`update:${key}`, newValue);
+    }
+  });
+}
+function defineModel(name, options) {
+  const instance = component.getCurrentInstance();
+  const modelName = name ?? "modelValue";
+  if (!instance) {
+    return reactivity.computed({
+      get() {
+        return options?.default;
+      },
+      set() {
+      }
+    });
+  }
+  const props = instance.props;
+  return reactivity.computed({
+    get() {
+      const value = props[modelName];
+      if (value === void 0) {
+        return options?.default;
+      }
+      return value;
+    },
+    set(newValue) {
+      const emitValue = options?.transform ? options.transform(newValue) : newValue;
+      instance.emit(`update:${modelName}`, emitValue);
+    }
+  });
+}
+function useTemplateRef(key) {
+  const instance = component.getCurrentInstance();
+  const ref3 = reactivity.shallowRef(null);
+  if (instance) {
+    const stop = reactivity.watch(
+      () => instance.refs[key] ?? null,
+      (newVal) => {
+        ref3.value = newVal;
+      },
+      { immediate: true, flush: "pre" }
+    );
+    scope.onScopeDispose(stop);
+  }
+  return ref3;
+}
+function generateIdSuffix() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID().slice(0, 8);
+  }
+  return Math.random().toString(36).slice(2, 10);
+}
+function useId() {
+  const instance = component.getCurrentInstance();
+  const id = reactivity.shallowRef("");
+  if (instance) {
+    const prefix = `lyt-${instance.uid}`;
+    let map = instanceIdMap.get(instance);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      instanceIdMap.set(instance, map);
+    }
+    const counter = (map.get("useId") ?? 0) + 1;
+    map.set("useId", counter);
+    id.value = `${prefix}-${counter}-${generateIdSuffix()}`;
+  } else {
+    id.value = `lyt-${generateIdSuffix()}`;
+  }
+  return reactivity.readonly(id);
+}
+function useCssModule(name = "$style") {
+  const instance = component.getCurrentInstance();
+  if (!instance) {
+    return {};
+  }
+  const modules = instanceCssModulesMap.get(instance);
+  return modules?.[name] ?? {};
+}
+function useCssVars(vars) {
+  const instance = component.getCurrentInstance();
+  if (!instance) {
+    return;
+  }
+  const updateStyle = () => {
+    const el = instance.vnode?.el;
+    if (!el) return;
+    const varsObj = vars();
+    for (const [key, value] of Object.entries(varsObj)) {
+      const cssVar = key.startsWith("--") ? key : `--${key}`;
+      el.style.setProperty(cssVar, value);
+    }
+  };
+  component.onMounted(updateStyle);
+  const stop = reactivity.watchEffect(updateStyle);
+  scope.onScopeDispose(() => {
+    stop();
+    const el = instance.vnode?.el;
+    if (el) {
+      const varsObj = vars();
+      for (const key of Object.keys(varsObj)) {
+        const cssVar = key.startsWith("--") ? key : `--${key}`;
+        el.style.removeProperty(cssVar);
+      }
+    }
+  });
+}
+var instanceIdMap, instanceCssModulesMap;
+var init_composition = __esm({
+  "src/composition.ts"() {
+    instanceIdMap = /* @__PURE__ */ new WeakMap();
+    instanceCssModulesMap = /* @__PURE__ */ new WeakMap();
+  }
+});
+function getElementContext(host) {
+  let ctx = elementContextMap.get(host);
+  if (!ctx) {
+    ctx = { shadowRoot: null, host, slotCallback: null };
+    elementContextMap.set(host, ctx);
+  }
+  return ctx;
+}
+function getCurrentContext() {
+  const host = setupStack[setupStack.length - 1];
+  return host ? elementContextMap.get(host) : void 0;
+}
+function extractObservedAttributes(propsOptions) {
+  const attributes = [];
+  for (const key in propsOptions) {
+    const attrName = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+    attributes.push(attrName);
+  }
+  return attributes;
+}
+function attrToProp(attrName) {
+  return attrName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function deserializeValue(value, propOptions) {
+  if (value === null) return void 0;
+  const options = propOptions;
+  if (options === true || options === void 0) {
+    return value;
+  }
+  const type = options.type;
+  if (type === Number) {
+    const num = Number(value);
+    return isNaN(num) ? value : num;
+  }
+  if (type === Boolean) {
+    return value !== "false" && value !== "0" && value !== "";
+  }
+  return value;
+}
+function defineCustomElement(componentOptions, options) {
+  const useShadowDOM = options?.shadowRoot !== false;
+  const tagName = options?.name || (componentOptions.name ? componentOptions.name.replace(/([A-Z])/g, "-$1").toLowerCase() : "lyt-component");
+  const css = options?.css || "";
+  const propsOptions = componentOptions.props || {};
+  const observedAttributes = extractObservedAttributes(propsOptions);
+  class LytCustomElement extends HTMLElement {
+    constructor() {
+      super();
+      this._instance = null;
+      this._renderer = null;
+      this._vnode = null;
+      this._slotObserver = null;
+      if (useShadowDOM) {
+        this._root = this.attachShadow({ mode: "open" });
+        if (css) {
+          const style = document.createElement("style");
+          style.textContent = css;
+          this._root.appendChild(style);
+        }
+      } else {
+        this._root = this;
+      }
+      this._appContext = component.createAppContext();
+    }
+    static get observedAttributes() {
+      return observedAttributes;
+    }
+    connectedCallback() {
+      const ctx = getElementContext(this);
+      ctx.shadowRoot = useShadowDOM ? this._root : null;
+      ctx.host = this;
+      setupStack.push(this);
+      try {
+        const props = {};
+        for (const attr of observedAttributes) {
+          const propKey = attrToProp(attr);
+          const value = this.getAttribute(attr);
+          props[propKey] = deserializeValue(value, propsOptions[propKey]);
+        }
+        const vnode = vdom.createVNode(componentOptions, props);
+        this._vnode = vnode;
+        const instance = component.createComponentInstance(vnode, null);
+        instance.appContext = this._appContext;
+        this._instance = instance;
+        component.setupComponent(instance);
+        const renderer$1 = renderer.createDOMRenderer();
+        this._renderer = renderer$1;
+        renderer$1.mount(vnode, this._root);
+        this._setupSlotObserver();
+      } finally {
+        setupStack.pop();
+      }
+    }
+    disconnectedCallback() {
+      if (this._instance) {
+        component.callUnmountedHook(this._instance);
+      }
+      if (this._renderer && this._vnode) {
+        this._renderer.unmount(this._vnode);
+      }
+      if (this._slotObserver) {
+        this._slotObserver.disconnect();
+        this._slotObserver = null;
+      }
+      elementContextMap.delete(this);
+      this._instance = null;
+      this._renderer = null;
+      this._vnode = null;
+    }
+    attributeChangedCallback(name, _oldValue, newValue) {
+      if (!this._instance || !this._vnode) return;
+      const propKey = attrToProp(name);
+      if (!(propKey in propsOptions)) return;
+      const deserializedValue = deserializeValue(newValue, propsOptions[propKey]);
+      if (this._instance.props[propKey] === deserializedValue) return;
+      this._instance.props[propKey] = deserializedValue;
+      this._vnode.props[propKey] = deserializedValue;
+      if (this._renderer && this._vnode) {
+        if (this._renderer.patch) {
+          const newVNode = { ...this._vnode, props: { ...this._vnode.props } };
+          this._renderer.patch(this._vnode, newVNode, this._root);
+          this._vnode = newVNode;
+        } else if (this._renderer.render) {
+          this._renderer.render(this._vnode, this._root);
+        }
+      }
+    }
+    _setupSlotObserver() {
+      this._slotObserver = new MutationObserver(() => {
+        const ctx = elementContextMap.get(this);
+        if (ctx?.slotCallback) {
+          ctx.slotCallback();
+        }
+      });
+      this._slotObserver.observe(this, {
+        childList: true,
+        subtree: true,
+        characterData: true
+      });
+    }
+  }
+  try {
+    customElements.define(tagName, LytCustomElement);
+  } catch (e) {
+  }
+  return LytCustomElement;
+}
+function useShadowRoot() {
+  const ctx = getCurrentContext();
+  return ctx?.shadowRoot ?? null;
+}
+function useHost() {
+  const ctx = getCurrentContext();
+  return ctx?.host ?? null;
+}
+function useWebComponentSlots(onChange) {
+  const ctx = getCurrentContext();
+  if (ctx) {
+    ctx.slotCallback = onChange;
+  }
+}
+function injectChildStyles(styles) {
+  const ctx = getCurrentContext();
+  const shadowRoot = ctx?.shadowRoot ?? null;
+  if (!shadowRoot) {
+    return;
+  }
+  const style = document.createElement("style");
+  style.textContent = styles;
+  shadowRoot.appendChild(style);
+}
+var elementContextMap, setupStack;
+var init_web_component = __esm({
+  "src/web-component.ts"() {
+    elementContextMap = /* @__PURE__ */ new WeakMap();
+    setupStack = [];
+  }
+});
+var init_lifecycle = __esm({
+  "src/lifecycle.ts"() {
+  }
+});
+
+// src/config-validator.ts
+function validateConfig(value, schema) {
+  const validator = new exports.ConfigValidator();
+  return validator.validate(value, schema);
+}
+exports.ConfigValidator = void 0;
+var init_config_validator = __esm({
+  "src/config-validator.ts"() {
+    exports.ConfigValidator = class {
+      constructor() {
+        /** 自定义验证规则 */
+        this.rules = [];
+      }
+      /**
+       * 验证配置值
+       * @param value - 要验证的值
+       * @param schema - 配置 Schema
+       * @param path - 当前路径（用于错误报告）
+       * @returns 验证报告
+       */
+      validate(value, schema, path = "") {
+        const errors = [];
+        const context = { path, root: value };
+        if (value === null) {
+          if (!schema.nullable && schema.default === void 0) {
+            errors.push(this.createError(path, "type_error", "Value cannot be null"));
+          }
+          return { valid: errors.length === 0, errors, errorCount: errors.length, warningCount: 0 };
+        }
+        if (value === void 0) {
+          if (schema.required) {
+            errors.push(this.createError(path, "required", "Value is required"));
+          } else if (schema.default !== void 0) ;
+          return { valid: errors.length === 0, errors, errorCount: errors.length, warningCount: 0 };
+        }
+        if (schema.validate) {
+          const result = schema.validate(value, context);
+          if (!result.valid) {
+            errors.push(this.createError(path, "custom_error", result.message || "Custom validation failed"));
+          }
+        }
+        switch (schema.type) {
+          case "string":
+            errors.push(...this.validateString(value, schema, path));
+            break;
+          case "number":
+            errors.push(...this.validateNumber(value, schema, path));
+            break;
+          case "boolean":
+            errors.push(...this.validateBoolean(value, schema, path));
+            break;
+          case "object":
+            errors.push(...this.validateObject(value, schema, path));
+            break;
+          case "array":
+            errors.push(...this.validateArray(value, schema, path));
+            break;
+          case "enum":
+            errors.push(...this.validateEnum(value, schema, path));
+            break;
+          case "union":
+            errors.push(...this.validateUnion(value, schema, path));
+            break;
+        }
+        for (const rule of this.rules) {
+          const error3 = rule(value, schema, context);
+          if (error3) {
+            errors.push(error3);
+          }
+        }
+        return {
+          valid: errors.length === 0,
+          errors,
+          errorCount: errors.length,
+          warningCount: 0
+        };
+      }
+      /**
+       * 验证字符串值
+       */
+      validateString(value, schema, path) {
+        const errors = [];
+        if (typeof value !== "string") {
+          errors.push(this.createError(path, "type_error", `Expected string, got ${typeof value}`, "string", value));
+          return errors;
+        }
+        const stringSchema = schema.string || {};
+        if (stringSchema.minLength !== void 0 && value.length < stringSchema.minLength) {
+          errors.push(this.createError(
+            path,
+            "min_length",
+            `String must be at least ${stringSchema.minLength} characters`,
+            `minLength: ${stringSchema.minLength}`,
+            value.length
+          ));
+        }
+        if (stringSchema.maxLength !== void 0 && value.length > stringSchema.maxLength) {
+          errors.push(this.createError(
+            path,
+            "max_length",
+            `String must be at most ${stringSchema.maxLength} characters`,
+            `maxLength: ${stringSchema.maxLength}`,
+            value.length
+          ));
+        }
+        if (stringSchema.pattern) {
+          const pattern = typeof stringSchema.pattern === "string" ? new RegExp(stringSchema.pattern) : stringSchema.pattern;
+          if (!pattern.test(value)) {
+            errors.push(this.createError(
+              path,
+              "pattern_mismatch",
+              `String does not match pattern: ${stringSchema.pattern}`,
+              String(stringSchema.pattern),
+              value
+            ));
+          }
+        }
+        if (stringSchema.format && this.isStringType(value)) {
+          const formatError = this.validateFormat(value, stringSchema.format);
+          if (formatError) {
+            errors.push(this.createError(path, "format_error", formatError, stringSchema.format, value));
+          }
+        }
+        if (stringSchema.enum && !stringSchema.enum.includes(value)) {
+          errors.push(this.createError(
+            path,
+            "enum_mismatch",
+            `Value must be one of: ${stringSchema.enum.join(", ")}`,
+            stringSchema.enum.join(" | "),
+            value
+          ));
+        }
+        return errors;
+      }
+      /**
+       * 验证数字值
+       */
+      validateNumber(value, schema, path) {
+        const errors = [];
+        if (typeof value !== "number" || Number.isNaN(value)) {
+          errors.push(this.createError(path, "type_error", `Expected number, got ${typeof value}`, "number", value));
+          return errors;
+        }
+        const numberSchema = schema.number || {};
+        if (numberSchema.integer && !Number.isInteger(value)) {
+          errors.push(this.createError(path, "type_error", "Value must be an integer", "integer", value));
+        }
+        if (numberSchema.minimum !== void 0 && value < numberSchema.minimum) {
+          errors.push(this.createError(
+            path,
+            "minimum",
+            `Value must be >= ${numberSchema.minimum}`,
+            `minimum: ${numberSchema.minimum}`,
+            value
+          ));
+        }
+        if (numberSchema.maximum !== void 0 && value > numberSchema.maximum) {
+          errors.push(this.createError(
+            path,
+            "maximum",
+            `Value must be <= ${numberSchema.maximum}`,
+            `maximum: ${numberSchema.maximum}`,
+            value
+          ));
+        }
+        if (numberSchema.exclusiveMinimum !== void 0 && value <= numberSchema.exclusiveMinimum) {
+          errors.push(this.createError(
+            path,
+            "minimum",
+            `Value must be > ${numberSchema.exclusiveMinimum}`,
+            `exclusiveMinimum: ${numberSchema.exclusiveMinimum}`,
+            value
+          ));
+        }
+        if (numberSchema.exclusiveMaximum !== void 0 && value >= numberSchema.exclusiveMaximum) {
+          errors.push(this.createError(
+            path,
+            "maximum",
+            `Value must be < ${numberSchema.exclusiveMaximum}`,
+            `exclusiveMaximum: ${numberSchema.exclusiveMaximum}`,
+            value
+          ));
+        }
+        if (numberSchema.enum && !numberSchema.enum.includes(value)) {
+          errors.push(this.createError(
+            path,
+            "enum_mismatch",
+            `Value must be one of: ${numberSchema.enum.join(", ")}`,
+            numberSchema.enum.join(" | "),
+            value
+          ));
+        }
+        return errors;
+      }
+      /**
+       * 验证布尔值
+       */
+      validateBoolean(value, _schema, path) {
+        const errors = [];
+        if (typeof value !== "boolean") {
+          errors.push(this.createError(path, "type_error", `Expected boolean, got ${typeof value}`, "boolean", value));
+        }
+        return errors;
+      }
+      /**
+       * 验证对象值
+       */
+      validateObject(value, schema, path) {
+        const errors = [];
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+          errors.push(this.createError(path, "type_error", `Expected object, got ${typeof value}`, "object", value));
+          return errors;
+        }
+        const objectSchema = schema.object;
+        if (!objectSchema) return errors;
+        const obj = value;
+        const keys = Object.keys(obj);
+        if (objectSchema.maxProperties !== void 0 && keys.length > objectSchema.maxProperties) {
+          errors.push(this.createError(
+            path,
+            "max_items",
+            `Object must have at most ${objectSchema.maxProperties} properties`,
+            `maxProperties: ${objectSchema.maxProperties}`,
+            keys.length
+          ));
+        }
+        if (objectSchema.minProperties !== void 0 && keys.length < objectSchema.minProperties) {
+          errors.push(this.createError(
+            path,
+            "min_items",
+            `Object must have at least ${objectSchema.minProperties} properties`,
+            `minProperties: ${objectSchema.minProperties}`,
+            keys.length
+          ));
+        }
+        for (const [key, propertySchema] of Object.entries(objectSchema.properties || {})) {
+          const propertyPath = path ? `${path}.${key}` : key;
+          const propertyValue = obj[key];
+          if (propertyValue !== void 0) {
+            const propertyReport = this.validate(propertyValue, propertySchema, propertyPath);
+            errors.push(...propertyReport.errors);
+          } else if (propertySchema.required) {
+            errors.push(this.createError(propertyPath, "required", `Property "${key}" is required`));
+          }
+        }
+        const definedKeys = new Set(Object.keys(objectSchema.properties || {}));
+        if (!objectSchema.additionalProperties) {
+          for (const key of keys) {
+            if (!definedKeys.has(key)) {
+              let matchesPattern = false;
+              if (objectSchema.patternProperties) {
+                for (const pattern of Object.keys(objectSchema.patternProperties)) {
+                  const regex = new RegExp(pattern);
+                  if (regex.test(key)) {
+                    matchesPattern = true;
+                    break;
+                  }
+                }
+              }
+              if (!matchesPattern) {
+                errors.push(this.createError(
+                  `${path}.${key}`,
+                  "additional_properties",
+                  `Additional property "${key}" is not allowed`,
+                  key,
+                  key
+                ));
+              }
+            }
+          }
+        }
+        return errors;
+      }
+      /**
+       * 验证数组值
+       */
+      validateArray(value, schema, path) {
+        const errors = [];
+        if (!Array.isArray(value)) {
+          errors.push(this.createError(path, "type_error", `Expected array, got ${typeof value}`, "array", value));
+          return errors;
+        }
+        const arraySchema = schema.array || {};
+        if (arraySchema.minItems !== void 0 && value.length < arraySchema.minItems) {
+          errors.push(this.createError(
+            path,
+            "min_items",
+            `Array must have at least ${arraySchema.minItems} items`,
+            `minItems: ${arraySchema.minItems}`,
+            value.length
+          ));
+        }
+        if (arraySchema.maxItems !== void 0 && value.length > arraySchema.maxItems) {
+          errors.push(this.createError(
+            path,
+            "max_items",
+            `Array must have at most ${arraySchema.maxItems} items`,
+            `maxItems: ${arraySchema.maxItems}`,
+            value.length
+          ));
+        }
+        if (arraySchema.uniqueItems) {
+          const seen = /* @__PURE__ */ new Set();
+          for (let i = 0; i < value.length; i++) {
+            const item = value[i];
+            const key = JSON.stringify(item);
+            if (seen.has(key)) {
+              errors.push(this.createError(
+                `${path}[${i}]`,
+                "unique_items",
+                `Duplicate item found at index ${i}`,
+                "uniqueItems",
+                item
+              ));
+            }
+            seen.add(key);
+          }
+        }
+        if (arraySchema.items) {
+          for (let i = 0; i < value.length; i++) {
+            const itemPath = `${path}[${i}]`;
+            const itemReport = this.validate(value[i], arraySchema.items, itemPath);
+            errors.push(...itemReport.errors);
+          }
+        }
+        if (arraySchema.tuple) {
+          for (let i = 0; i < Math.min(value.length, arraySchema.tuple.length); i++) {
+            const itemPath = `${path}[${i}]`;
+            const itemReport = this.validate(value[i], arraySchema.tuple[i], itemPath);
+            errors.push(...itemReport.errors);
+          }
+          if (value.length !== arraySchema.tuple.length) {
+            errors.push(this.createError(
+              path,
+              "max_items",
+              `Tuple must have exactly ${arraySchema.tuple.length} items, got ${value.length}`,
+              `tuple length: ${arraySchema.tuple.length}`,
+              value.length
+            ));
+          }
+        }
+        return errors;
+      }
+      /**
+       * 验证枚举值
+       */
+      validateEnum(value, schema, path) {
+        const errors = [];
+        const enumSchema = schema.enum;
+        if (!enumSchema.values.includes(value)) {
+          errors.push(this.createError(
+            path,
+            "enum_mismatch",
+            `Value must be one of: ${enumSchema.values.map((v) => JSON.stringify(v)).join(", ")}`,
+            enumSchema.values.map((v) => JSON.stringify(v)).join(" | "),
+            value
+          ));
+        }
+        return errors;
+      }
+      /**
+       * 验证联合类型
+       */
+      validateUnion(value, schema, path) {
+        const errors = [];
+        const unionSchema = schema.union;
+        if (unionSchema.anyOf) {
+          let matched = false;
+          for (const subSchema of unionSchema.anyOf) {
+            const report = this.validate(value, subSchema, path);
+            if (report.valid) {
+              matched = true;
+              break;
+            }
+          }
+          if (!matched) {
+            errors.push(this.createError(
+              path,
+              "type_error",
+              "Value does not match any of the allowed types",
+              "union",
+              value
+            ));
+          }
+        }
+        if (unionSchema.oneOf) {
+          let matchCount = 0;
+          for (const subSchema of unionSchema.oneOf) {
+            const report = this.validate(value, subSchema, path);
+            if (report.valid) {
+              matchCount++;
+            }
+          }
+          if (matchCount !== 1) {
+            errors.push(this.createError(
+              path,
+              "type_error",
+              `Value must match exactly one of the allowed types, matched ${matchCount}`,
+              "oneOf",
+              value
+            ));
+          }
+        }
+        return errors;
+      }
+      /**
+       * 验证字符串格式
+       */
+      validateFormat(value, format) {
+        switch (format) {
+          case "date":
+            if (!/^\d{4}-\d{2}-\d{2}$/.test(value) || isNaN(Date.parse(value))) {
+              return `Invalid date format, expected YYYY-MM-DD`;
+            }
+            return null;
+          case "time":
+            if (!/^\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:\d{2})?$/.test(value)) {
+              return `Invalid time format`;
+            }
+            return null;
+          case "date-time":
+            if (isNaN(Date.parse(value))) {
+              return `Invalid ISO 8601 date-time format`;
+            }
+            return null;
+          case "email":
+            if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+              return `Invalid email format`;
+            }
+            return null;
+          case "url":
+          case "uri":
+            try {
+              new URL(value);
+              return null;
+            } catch {
+              return `Invalid URL format`;
+            }
+          case "uuid":
+            if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
+              return `Invalid UUID format`;
+            }
+            return null;
+          case "semver":
+            if (!/^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?(\+[a-zA-Z0-9.]+)?$/.test(value)) {
+              return `Invalid semver format, expected MAJOR.MINOR.PATCH`;
+            }
+            return null;
+          default:
+            return null;
+        }
+      }
+      /**
+       * 创建验证错误
+       */
+      createError(path, code, message, expected, actual) {
+        return { path, code, message, expected, actual };
+      }
+      /**
+       * 添加自定义验证规则
+       */
+      addRule(rule) {
+        this.rules.push(rule);
+      }
+      /**
+       * 移除自定义验证规则
+       */
+      removeRule(rule) {
+        const index = this.rules.indexOf(rule);
+        if (index !== -1) {
+          this.rules.splice(index, 1);
+        }
+      }
+      // ==================== 类型守卫 ====================
+      isStringType(value) {
+        return typeof value === "string";
+      }
+    };
+  }
+});
+
+// src/config-transformer.ts
+function transformConfig(value, schema) {
+  const transformer = new exports.ConfigTransformer();
+  return transformer.transform(value, schema);
+}
+function mergeConfig(defaults, overrides, schema) {
+  const transformer = new exports.ConfigTransformer();
+  return transformer.merge(defaults, overrides, schema);
+}
+exports.ConfigTransformer = void 0;
+var init_config_transformer = __esm({
+  "src/config-transformer.ts"() {
+    init_config_validator();
+    exports.ConfigTransformer = class {
+      constructor() {
+        this.validator = new exports.ConfigValidator();
+      }
+      /**
+       * 转换并验证配置
+       * @param value - 原始配置值
+       * @param schema - 配置 Schema
+       * @param path - 当前路径
+       * @returns 转换报告
+       */
+      transform(value, schema, path = "") {
+        const warnings = [];
+        const transforms = [];
+        const errors = [];
+        let transformed = value;
+        if (transformed === void 0) {
+          if (schema.default !== void 0) {
+            transformed = schema.default;
+            transforms.push(`Applied default value: ${JSON.stringify(schema.default)}`);
+          } else if (schema.required) {
+            errors.push({
+              path,
+              code: "required",
+              message: "Value is required"
+            });
+            return { config: void 0, success: false, errors, warnings, transforms };
+          }
+        }
+        if (transformed === null) {
+          if (schema.nullable) ; else if (schema.default !== void 0) {
+            transformed = schema.default;
+            transforms.push(`Applied default value for null: ${JSON.stringify(schema.default)}`);
+            warnings.push("Null value was replaced with default");
+          } else {
+            errors.push({
+              path,
+              code: "type_error",
+              message: "Value cannot be null"
+            });
+            return { config: null, success: false, errors, warnings, transforms };
+          }
+        }
+        if (transformed !== void 0 && transformed !== null) {
+          if (schema.transform) {
+            try {
+              const original = transformed;
+              transformed = schema.transform(transformed);
+              if (original !== transformed) {
+                transforms.push(`Applied transform function`);
+              }
+            } catch (err) {
+              errors.push({
+                path,
+                code: "custom_error",
+                message: `Transform failed: ${err instanceof Error ? err.message : String(err)}`
+              });
+              return { config: transformed, success: false, errors, warnings, transforms };
+            }
+          }
+        }
+        if (schema.type === "object" && schema.object && typeof transformed === "object" && transformed !== null) {
+          const objectResult = this.transformObject(transformed, schema, path);
+          transformed = objectResult.value;
+          errors.push(...objectResult.errors);
+          warnings.push(...objectResult.warnings);
+          transforms.push(...objectResult.transforms);
+        } else if (schema.type === "array" && schema.array && Array.isArray(transformed)) {
+          const arrayResult = this.transformArray(transformed, schema, path);
+          transformed = arrayResult.value;
+          errors.push(...arrayResult.errors);
+          warnings.push(...arrayResult.warnings);
+          transforms.push(...arrayResult.transforms);
+        }
+        if (transformed !== void 0 && transformed !== null) {
+          const validationReport = this.validator.validate(transformed, schema, path);
+          errors.push(...validationReport.errors);
+        }
+        return {
+          config: transformed,
+          success: errors.length === 0,
+          errors,
+          warnings,
+          transforms
+        };
+      }
+      /**
+       * 转换对象配置
+       */
+      transformObject(obj, schema, path) {
+        const result = {};
+        const errors = [];
+        const warnings = [];
+        const transforms = [];
+        const objectSchema = schema.object;
+        const definedKeys = new Set(Object.keys(objectSchema.properties || {}));
+        for (const [key, propertySchema] of Object.entries(objectSchema.properties || {})) {
+          const propertyPath = path ? `${path}.${key}` : key;
+          const propertyValue = obj[key];
+          if (propertyValue !== void 0) {
+            const propertyResult = this.transform(propertyValue, propertySchema, propertyPath);
+            result[key] = propertyResult.config;
+            errors.push(...propertyResult.errors);
+            warnings.push(...propertyResult.warnings);
+            transforms.push(...propertyResult.transforms);
+          } else if (propertySchema.default !== void 0) {
+            result[key] = propertySchema.default;
+            transforms.push(`Applied default for "${key}": ${JSON.stringify(propertySchema.default)}`);
+          } else if (propertySchema.required) {
+            errors.push({
+              path: propertyPath,
+              code: "required",
+              message: `Property "${key}" is required`
+            });
+          }
+        }
+        if (objectSchema.patternProperties) {
+          for (const key of Object.keys(obj)) {
+            if (!definedKeys.has(key)) {
+              for (const [pattern, patternSchema] of Object.entries(objectSchema.patternProperties)) {
+                const regex = new RegExp(pattern);
+                if (regex.test(key)) {
+                  const propertyPath = `${path}.${key}`;
+                  const propertyResult = this.transform(obj[key], patternSchema, propertyPath);
+                  result[key] = propertyResult.config;
+                  errors.push(...propertyResult.errors);
+                  warnings.push(...propertyResult.warnings);
+                  transforms.push(...propertyResult.transforms);
+                }
+              }
+            }
+          }
+        }
+        if (!objectSchema.additionalProperties) {
+          for (const key of Object.keys(obj)) {
+            if (!definedKeys.has(key)) {
+              let matchesPattern = false;
+              if (objectSchema.patternProperties) {
+                for (const pattern of Object.keys(objectSchema.patternProperties)) {
+                  const regex = new RegExp(pattern);
+                  if (regex.test(key)) {
+                    matchesPattern = true;
+                    break;
+                  }
+                }
+              }
+              if (!matchesPattern) {
+                warnings.push(`Additional property "${key}" will be ignored`);
+              }
+            }
+          }
+        }
+        return { value: result, errors, warnings, transforms };
+      }
+      /**
+       * 转换数组配置
+       */
+      transformArray(arr, schema, path) {
+        const result = [];
+        const errors = [];
+        const warnings = [];
+        const transforms = [];
+        const arraySchema = schema.array;
+        for (let i = 0; i < arr.length; i++) {
+          const itemPath = `${path}[${i}]`;
+          const itemResult = this.transform(arr[i], arraySchema.items, itemPath);
+          result.push(itemResult.config);
+          errors.push(...itemResult.errors);
+          warnings.push(...itemResult.warnings);
+          transforms.push(...itemResult.transforms);
+        }
+        if (arraySchema.tuple) {
+          for (let i = arr.length; i < arraySchema.tuple.length; i++) {
+            const itemSchema = arraySchema.tuple[i];
+            if (itemSchema && itemSchema.default !== void 0) {
+              result.push(itemSchema.default);
+              transforms.push(`Applied default for tuple[${i}]: ${JSON.stringify(itemSchema.default)}`);
+            }
+          }
+        }
+        return { value: result, errors, warnings, transforms };
+      }
+      /**
+       * 合并多个配置（用户配置覆盖默认配置）
+       * @param defaults - 默认配置
+       * @param overrides - 用户配置
+       * @param schema - 配置 Schema
+       * @returns 合并后的配置
+       */
+      merge(defaults, overrides, schema) {
+        const merged = this.deepMerge(defaults, overrides);
+        return this.transform(merged, schema);
+      }
+      /**
+       * 深度合并两个对象
+       */
+      deepMerge(target, source) {
+        const result = { ...target };
+        for (const [key, value] of Object.entries(source)) {
+          if (value !== void 0) {
+            if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+              result[key] = this.deepMerge(result[key], value);
+            } else {
+              result[key] = value;
+            }
+          }
+        }
+        return result;
+      }
+      /**
+       * 从配置中提取指定字段
+       * @param config - 完整配置
+       * @param schema - 配置 Schema
+       * @param keys - 要提取的键
+       * @returns 提取的配置子集
+       */
+      extract(config, schema, keys) {
+        const result = {};
+        const configObj = config;
+        for (const key of keys) {
+          if (key in configObj) {
+            const propertySchema = schema.object?.properties?.[key];
+            if (propertySchema) {
+              const propertyReport = this.transform(configObj[key], propertySchema, String(key));
+              if (propertyReport.success) {
+                result[key] = propertyReport.config;
+              }
+            } else {
+              result[key] = configObj[key];
+            }
+          }
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/plugin-sdk.ts
+function definePlugin(config) {
+  const { name, version, description, author, keywords, schema, install } = config;
+  const plugin = {
+    name,
+    version,
+    meta: {
+      description,
+      author,
+      keywords
+    },
+    configSchema: schema,
+    install: async (app, ...options) => {
+      const rawOptions = options[0];
+      if (schema) {
+        const transformer = new exports.ConfigTransformer();
+        const report = transformer.transform(rawOptions, schema);
+        if (!report.success) {
+          const errors = report.errors.map((e) => `${e.path}: ${e.message}`).join(", ");
+          throw new Error(`Plugin "${name}" configuration validation failed: ${errors}`);
+        }
+        await install(app, report.config);
+      } else {
+        await install(app, rawOptions);
+      }
+    }
+  };
+  return plugin;
+}
+function validatePluginConfig(plugin, userConfig) {
+  if (!plugin.configSchema) {
+    return { valid: true, errors: [], errorCount: 0, warningCount: 0 };
+  }
+  return validateConfig(userConfig, plugin.configSchema);
+}
+function transformPluginConfig(plugin, userConfig) {
+  if (!plugin.configSchema) {
+    return {
+      config: userConfig,
+      success: true,
+      errors: [],
+      warnings: [],
+      transforms: []
+    };
+  }
+  return transformConfig(userConfig, plugin.configSchema);
+}
+function mergePluginConfig(plugin, defaults, overrides) {
+  if (!plugin.configSchema) {
+    const merged = { ...defaults, ...overrides };
+    return {
+      config: merged,
+      success: true,
+      errors: [],
+      warnings: [],
+      transforms: []
+    };
+  }
+  const transformer = new exports.ConfigTransformer();
+  return transformer.merge(defaults, overrides, plugin.configSchema);
+}
+function createPluginTester(options) {
+  return new PluginTester(options);
+}
+async function testPluginInstall(plugin, options, testerOptions) {
+  const tester = createPluginTester(testerOptions);
+  try {
+    await tester.installPlugin(plugin, options);
+    return { success: true, app: tester.getApp() };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err : new Error(String(err)) };
+  } finally {
+    tester.cleanup();
+  }
+}
+var PluginTester;
+var init_plugin_sdk = __esm({
+  "src/plugin-sdk.ts"() {
+    init_config_transformer();
+    init_config_validator();
+    PluginTester = class {
+      constructor(options = {}) {
+        this.app = null;
+        this.installedPlugins = /* @__PURE__ */ new Set();
+        this.options = {
+          appConfig: options.appConfig || {},
+          debug: options.debug || false,
+          onValidationError: options.onValidationError || (() => {
+          }),
+          onBeforeInstall: options.onBeforeInstall || (() => {
+          }),
+          onAfterInstall: options.onAfterInstall || (() => {
+          }),
+          onCleanup: options.onCleanup || (() => {
+          })
+        };
+      }
+      /**
+       * 创建测试 App
+       */
+      async createApp() {
+        const { createApp: createApp2, h: h2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+        const app = createApp2({
+          render: () => h2("div")
+        });
+        this.app = app;
+        return app;
+      }
+      /**
+       * 安装插件进行测试
+       */
+      async installPlugin(plugin, options) {
+        if (!this.app) {
+          await this.createApp();
+        }
+        if (plugin.configSchema) {
+          const report = validatePluginConfig(plugin, options);
+          if (!report.valid) {
+            this.options.onValidationError(report);
+            if (this.options.debug) {
+              console.error("[PluginTester] Validation errors:", report.errors);
+            }
+          }
+        }
+        this.options.onBeforeInstall(this.app);
+        if (this.options.debug) {
+          console.log(`[PluginTester] Installing plugin: ${plugin.name}`);
+        }
+        this.app.use(plugin, options);
+        this.installedPlugins.add(plugin.name);
+        this.options.onAfterInstall(this.app);
+      }
+      /**
+       * 卸载插件进行测试
+       */
+      uninstallPlugin(name) {
+        if (!this.app || !this.installedPlugins.has(name)) {
+          return;
+        }
+        if (this.options.debug) {
+          console.log(`[PluginTester] Uninstalling plugin: ${name}`);
+        }
+        this.app._pluginRegistry.unregister(name);
+        this.installedPlugins.delete(name);
+      }
+      /**
+       * 运行清理
+       */
+      cleanup() {
+        if (this.app) {
+          this.app.unmount();
+        }
+        this.app = null;
+        this.installedPlugins.clear();
+        this.options.onCleanup();
+      }
+      /**
+       * 获取已安装插件列表
+       */
+      getInstalledPlugins() {
+        return Array.from(this.installedPlugins);
+      }
+      /**
+       * 获取 App 实例
+       */
+      getApp() {
+        return this.app;
+      }
+    };
+  }
+});
+function getGlobalConfig() {
+  if (!globalConfigManager) {
+    globalConfigManager = new exports.ConfigManager(defaultGlobalConfig);
+  }
+  return globalConfigManager;
+}
+function setGlobalConfig(config, merge = true) {
+  if (merge) {
+    getGlobalConfig().merge(config);
+  } else {
+    getGlobalConfig().reset(config);
+  }
+}
+function getConfig(path, defaultValue) {
+  return getGlobalConfig().get(path, defaultValue);
+}
+function setConfig(path, value) {
+  return getGlobalConfig().set(path, value);
+}
+function watchConfig(path, callback) {
+  return getGlobalConfig().watch(path, callback);
+}
+function applyConfigPreset(preset) {
+  const config = exports.configPresets[preset]();
+  setGlobalConfig(config, true);
+}
+exports.ConfigManager = void 0; var defaultGlobalConfig, globalConfigManager; exports.configPresets = void 0;
+var init_config = __esm({
+  "src/config.ts"() {
+    exports.ConfigManager = class {
+      constructor(initialConfig = {}, options = {}) {
+        this.config = {};
+        this.listeners = /* @__PURE__ */ new Map();
+        this.globalListeners = /* @__PURE__ */ new Set();
+        this.options = {
+          mutable: true,
+          deepMerge: true,
+          ...options
+        };
+        this.config = this.options.deepMerge ? commonObject.deepClone(initialConfig) : { ...initialConfig };
+      }
+      /**
+       * 获取配置值
+       *
+       * @param path - 配置路径（支持点号分隔，如 'api.baseURL'）
+       * @param defaultValue - 默认值
+       * @returns 配置值或默认值
+       *
+       * @example
+       * ```ts
+       * config.get('api.baseURL') // '/api'
+       * config.get('api.timeout', 5000) // 5000 (如果不存在)
+       * config.get('theme.colors.primary') // 嵌套值
+       * ```
+       */
+      get(path, defaultValue) {
+        const keys = path.split(".");
+        let value = this.config;
+        for (const key of keys) {
+          if (commonIs.isObject(value) && key in value) {
+            value = value[key];
+          } else {
+            return defaultValue;
+          }
+        }
+        return value;
+      }
+      /**
+       * 设置配置值
+       *
+       * @param path - 配置路径
+       * @param value - 新值
+       * @returns 是否设置成功
+       *
+       * @example
+       * ```ts
+       * config.set('api.timeout', 10000)
+       * config.set('theme.colors.primary', '#ff0000')
+       * ```
+       */
+      set(path, value) {
+        if (!this.options.mutable) {
+          console.warn("[ConfigManager] Configuration is immutable");
+          return false;
+        }
+        const keys = path.split(".");
+        const lastKey = keys.pop();
+        let target = this.config;
+        for (const key of keys) {
+          if (!commonIs.isObject(target[key])) {
+            target[key] = {};
+          }
+          target = target[key];
+        }
+        const oldValue = target[lastKey];
+        if (!commonIs.hasChanged(value, oldValue)) {
+          return false;
+        }
+        const parentOldValues = /* @__PURE__ */ new Map();
+        const parentParts = path.split(".");
+        while (parentParts.length > 1) {
+          parentParts.pop();
+          const parentPath = parentParts.join(".");
+          const parentVal = this.get(parentPath);
+          parentOldValues.set(
+            parentPath,
+            parentVal !== null && typeof parentVal === "object" ? commonObject.deepClone(parentVal) : parentVal
+          );
+        }
+        target[lastKey] = value;
+        this.notify(path, value, oldValue, parentOldValues);
+        return true;
+      }
+      /**
+       * 批量设置配置
+       *
+       * @param config - 配置对象
+       * @param merge - 是否合并（true）或替换（false）
+       *
+       * @example
+       * ```ts
+       * config.setMultiple({
+       *   'api.timeout': 10000,
+       *   'theme.primary': '#ff0000'
+       * })
+       * ```
+       */
+      setMultiple(config, merge = true) {
+        if (!this.options.mutable) {
+          console.warn("[ConfigManager] Configuration is immutable");
+          return;
+        }
+        if (!merge) {
+          this.config = {};
+        }
+        Object.entries(config).forEach(([path, value]) => {
+          this.set(path, value);
+        });
+      }
+      /**
+       * 检查配置是否存在
+       *
+       * @param path - 配置路径
+       * @returns 是否存在
+       */
+      has(path) {
+        const keys = path.split(".");
+        let value = this.config;
+        for (const key of keys) {
+          if (commonIs.isObject(value) && key in value) {
+            value = value[key];
+          } else {
+            return false;
+          }
+        }
+        return true;
+      }
+      /**
+       * 删除配置
+       *
+       * @param path - 配置路径
+       * @returns 是否删除成功
+       */
+      delete(path) {
+        if (!this.options.mutable) {
+          console.warn("[ConfigManager] Configuration is immutable");
+          return false;
+        }
+        const keys = path.split(".");
+        const lastKey = keys.pop();
+        let target = this.config;
+        for (const key of keys) {
+          if (commonIs.isObject(target) && key in target) {
+            target = target[key];
+          } else {
+            return false;
+          }
+        }
+        if (commonIs.isObject(target) && lastKey in target) {
+          const oldValue = target[lastKey];
+          delete target[lastKey];
+          this.notify(path, void 0, oldValue);
+          return true;
+        }
+        return false;
+      }
+      /**
+       * 合并配置
+       *
+       * @param config - 要合并的配置
+       * @param deep - 是否深度合并
+       *
+       * @example
+       * ```ts
+       * config.merge({
+       *   api: { timeout: 10000 },
+       *   newKey: 'value'
+       * })
+       * ```
+       */
+      merge(config, deep = true) {
+        if (!this.options.mutable) {
+          console.warn("[ConfigManager] Configuration is immutable");
+          return;
+        }
+        const mergedKeys = [];
+        if (deep) {
+          this.deepMergeNotify(this.config, config, "", mergedKeys);
+        } else {
+          for (const key of Object.keys(config)) {
+            const oldValue = this.config[key];
+            this.config[key] = config[key];
+            if (commonIs.hasChanged(this.config[key], oldValue)) {
+              this.notify(key, this.config[key], oldValue);
+              mergedKeys.push(key);
+            }
+          }
+        }
+        this.globalListeners.forEach((cb) => cb(this.config, this.config, ""));
+      }
+      /**
+       * 深度合并对象，并在值变更时通知监听器
+       * FIX: P2-v11-08 替代原 deepMerge，在合并过程中收集变更的键并通知监听器
+       */
+      deepMergeNotify(target, source, prefix, mergedKeys) {
+        Object.entries(source).forEach(([key, value]) => {
+          const fullPath = prefix ? `${prefix}.${key}` : key;
+          if (commonIs.isObject(target[key]) && commonIs.isObject(value)) {
+            this.deepMergeNotify(
+              target[key],
+              value,
+              fullPath,
+              mergedKeys
+            );
+          } else {
+            const oldValue = target[key];
+            target[key] = commonIs.isObject(value) ? commonObject.deepClone(value) : value;
+            if (commonIs.hasChanged(target[key], oldValue)) {
+              this.notify(fullPath, target[key], oldValue);
+              mergedKeys.push(fullPath);
+            }
+          }
+        });
+      }
+      /**
+       * 获取所有配置
+       *
+       * @returns 配置对象的深拷贝
+       */
+      getAll() {
+        return commonObject.deepClone(this.config);
+      }
+      /**
+       * 重置配置
+       *
+       * @param newConfig - 新的配置对象
+       */
+      reset(newConfig = {}) {
+        if (!this.options.mutable) {
+          console.warn("[ConfigManager] Configuration is immutable");
+          return;
+        }
+        const oldConfig = this.config;
+        this.config = this.options.deepMerge ? commonObject.deepClone(newConfig) : { ...newConfig };
+        this.globalListeners.forEach((cb) => cb(this.config, oldConfig, ""));
+      }
+      /**
+       * 清空配置
+       */
+      clear() {
+        this.reset({});
+      }
+      /**
+       * 监听配置变更
+       *
+       * @param path - 配置路径（空字符串表示监听所有变更）
+       * @param callback - 变更回调
+       * @returns 取消监听函数
+       *
+       * @example
+       * ```ts
+       * // 监听特定路径
+       * const unwatch = config.watch('api.timeout', (newVal, oldVal) => {
+       *   console.log(`timeout 从 ${oldVal} 变为 ${newVal}`)
+       * })
+       *
+       * // 监听所有变更
+       * config.watch('', (newConfig) => {
+       *   console.log('配置已更新:', newConfig)
+       * })
+       * ```
+       */
+      watch(path, callback) {
+        if (path === "") {
+          this.globalListeners.add(callback);
+          return () => {
+            this.globalListeners.delete(callback);
+          };
+        }
+        if (!this.listeners.has(path)) {
+          this.listeners.set(path, /* @__PURE__ */ new Set());
+        }
+        this.listeners.get(path).add(callback);
+        return () => {
+          this.listeners.get(path)?.delete(callback);
+        };
+      }
+      /**
+       * 通知监听器
+       */
+      // FIX: P1-10 增加 parentOldValues 参数，由调用方在修改值之前收集父路径旧值快照
+      notify(path, newValue, oldValue, parentOldValues) {
+        const specificListeners = this.listeners.get(path);
+        if (specificListeners) {
+          specificListeners.forEach((cb) => cb(newValue, oldValue, path));
+        }
+        const parts = path.split(".");
+        while (parts.length > 1) {
+          parts.pop();
+          const parentPath = parts.join(".");
+          const parentListeners = this.listeners.get(parentPath);
+          if (parentListeners) {
+            const parentValue = this.get(parentPath);
+            const parentOldValue = parentOldValues?.get(parentPath);
+            parentListeners.forEach((cb) => cb(parentValue, parentOldValue, path));
+          }
+        }
+        if (this.options.onChange) {
+          this.options.onChange(newValue, oldValue, path);
+        }
+        this.globalListeners.forEach((cb) => cb(newValue, oldValue, path));
+      }
+      /**
+       * 设置可变性
+       *
+       * @param mutable - 是否可变
+       */
+      setMutable(mutable) {
+        this.options.mutable = mutable;
+      }
+      /**
+       * 检查是否可变
+       * FIX: P2-v11-09 简化 isMutable()：mutable 在构造函数中已设置默认值为 true，
+       * 不可能为 undefined，因此 ?? true 是冗余的
+       */
+      isMutable() {
+        return this.options.mutable ?? true;
+      }
+    };
+    defaultGlobalConfig = {
+      // 开发配置
+      dev: {
+        warnOnImmutable: true,
+        logLevel: "warn"
+      },
+      // 性能配置
+      performance: {
+        asyncComponentTimeout: 5e3,
+        keepAliveMax: 10,
+        transitionDuration: 300
+      },
+      // 编译配置
+      compiler: {
+        comments: false,
+        sourceMap: true,
+        optimize: true
+      },
+      // 运行时配置
+      runtime: {
+        errorHandler: null,
+        warnHandler: null,
+        globalProperties: {}
+      }
+    };
+    globalConfigManager = null;
+    exports.configPresets = {
+      /**
+       * 开发环境预设
+       */
+      development: () => ({
+        dev: {
+          warnOnImmutable: true,
+          logLevel: "debug"
+        },
+        compiler: {
+          comments: true,
+          sourceMap: true,
+          optimize: false
+        }
+      }),
+      /**
+       * 生产环境预设
+       */
+      production: () => ({
+        dev: {
+          warnOnImmutable: false,
+          logLevel: "error"
+        },
+        compiler: {
+          comments: false,
+          sourceMap: false,
+          optimize: true
+        }
+      }),
+      /**
+       * 测试环境预设
+       */
+      test: () => ({
+        dev: {
+          warnOnImmutable: true,
+          logLevel: "silent"
+        },
+        performance: {
+          asyncComponentTimeout: 1e3,
+          keepAliveMax: 5,
+          transitionDuration: 0
+        }
+      })
+    };
+  }
+});
+
+// src/common-integration.ts
+function registerIntegrations(integrations) {
+  _integrations = { ..._integrations, ...integrations };
+}
+function getHttpClient() {
+  return _integrations.http;
+}
+function getQueryUtils() {
+  return _integrations.query;
+}
+function getSecurityUtils() {
+  return _integrations.security;
+}
+function getCacheUtils() {
+  return _integrations.cache;
+}
+function safeEscapeHtml(str) {
+  const security = getSecurityUtils();
+  if (security) {
+    return security.escapeHtml(str);
+  }
+  return str.replace(/\\/g, "&#92;").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function safeParseQueryString(str) {
+  const query = getQueryUtils();
+  if (query) {
+    return query.parseQueryString(str);
+  }
+  const result = {};
+  if (!str) return result;
+  const searchParams = new URLSearchParams(str.startsWith("?") ? str.slice(1) : str);
+  for (const [key, value] of searchParams) {
+    result[key] = value;
+  }
+  return result;
+}
+var _integrations;
+var init_common_integration = __esm({
+  "src/common-integration.ts"() {
+    _integrations = {};
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Comment: () => vdom.Comment,
+  ConfigManager: () => exports.ConfigManager,
+  ConfigTransformer: () => exports.ConfigTransformer,
+  ConfigValidator: () => exports.ConfigValidator,
+  Fragment: () => vdom.Fragment,
+  PluginRegistry: () => exports.PluginRegistry,
+  PluginValidator: () => exports.PluginValidator,
+  Text: () => vdom.Text,
+  applyConfigPreset: () => applyConfigPreset,
+  cloneVNode: () => vdom.cloneVNode,
+  compile: () => compiler.compile,
+  computed: () => reactivity.computed,
+  configPresets: () => exports.configPresets,
+  createApp: () => createApp,
+  createElement: () => h,
+  createPluginTester: () => createPluginTester,
+  createVNode: () => vdom.createVNode,
+  defineAsyncComponent: () => defineAsyncComponent,
+  defineComponent: () => exports.defineComponent,
+  defineCustomElement: () => defineCustomElement,
+  defineModel: () => defineModel,
+  definePlugin: () => definePlugin,
+  effect: () => reactivity.effect,
+  getCacheUtils: () => getCacheUtils,
+  getConfig: () => getConfig,
+  getGlobalConfig: () => getGlobalConfig,
+  getHttpClient: () => getHttpClient,
+  getQueryUtils: () => getQueryUtils,
+  getSecurityUtils: () => getSecurityUtils,
+  h: () => h,
+  injectChildStyles: () => injectChildStyles,
+  mergeConfig: () => mergeConfig,
+  mergePluginConfig: () => mergePluginConfig,
+  mergeProps: () => vdom.mergeProps,
+  nextTick: () => commonScheduler.nextTick,
+  onActivated: () => component.onActivated,
+  onBeforeMount: () => component.onBeforeMount,
+  onBeforeUnmount: () => component.onBeforeUnmount,
+  onBeforeUpdate: () => component.onBeforeUpdate,
+  onDeactivated: () => component.onDeactivated,
+  onErrorCaptured: () => component.onErrorCaptured,
+  onMounted: () => component.onMounted,
+  onRenderTracked: () => component.onRenderTracked,
+  onRenderTriggered: () => component.onRenderTriggered,
+  onUnmounted: () => component.onUnmounted,
+  onUpdated: () => component.onUpdated,
+  reactive: () => reactivity.reactive,
+  ref: () => reactivity.ref,
+  registerIntegrations: () => registerIntegrations,
+  resolveComponent: () => resolveComponent,
+  resolveDirective: () => resolveDirective,
+  resolveDynamicComponent: () => resolveDynamicComponent,
+  safeEscapeHtml: () => safeEscapeHtml,
+  safeParseQueryString: () => safeParseQueryString,
+  setConfig: () => setConfig,
+  setGlobalConfig: () => setGlobalConfig,
+  testPluginInstall: () => testPluginInstall,
+  transformConfig: () => transformConfig,
+  transformPluginConfig: () => transformPluginConfig,
+  useAttrs: () => useAttrs,
+  useCssModule: () => useCssModule,
+  useCssVars: () => useCssVars,
+  useHost: () => useHost,
+  useId: () => useId,
+  useModel: () => useModel,
+  useShadowRoot: () => useShadowRoot,
+  useSlots: () => useSlots,
+  useTemplateRef: () => useTemplateRef,
+  useWebComponentSlots: () => useWebComponentSlots,
+  validateConfig: () => validateConfig,
+  validatePluginConfig: () => validatePluginConfig,
+  watch: () => reactivity.watch,
+  watchConfig: () => watchConfig,
+  watchEffect: () => reactivity.watchEffect,
+  withDirectives: () => withDirectives,
+  withMemo: () => withMemo
+});
+var init_src = __esm({
+  "src/index.ts"() {
+    init_create_app();
+    init_h();
+    init_define_component();
+    init_next_tick();
+    init_resolve();
+    init_directives();
+    init_composition();
+    init_web_component();
+    init_lifecycle();
+    init_plugin_registry();
+    init_plugin_validator();
+    init_config_validator();
+    init_config_transformer();
+    init_plugin_sdk();
+    init_config();
+    init_common_integration();
+  }
+});
+init_src();
+
+Object.defineProperty(exports, "onActivated", {
+  enumerable: true,
+  get: function () { return component.onActivated; }
+});
+Object.defineProperty(exports, "onBeforeMount", {
+  enumerable: true,
+  get: function () { return component.onBeforeMount; }
+});
+Object.defineProperty(exports, "onBeforeUnmount", {
+  enumerable: true,
+  get: function () { return component.onBeforeUnmount; }
+});
+Object.defineProperty(exports, "onBeforeUpdate", {
+  enumerable: true,
+  get: function () { return component.onBeforeUpdate; }
+});
+Object.defineProperty(exports, "onDeactivated", {
+  enumerable: true,
+  get: function () { return component.onDeactivated; }
+});
+Object.defineProperty(exports, "onErrorCaptured", {
+  enumerable: true,
+  get: function () { return component.onErrorCaptured; }
+});
+Object.defineProperty(exports, "onMounted", {
+  enumerable: true,
+  get: function () { return component.onMounted; }
+});
+Object.defineProperty(exports, "onRenderTracked", {
+  enumerable: true,
+  get: function () { return component.onRenderTracked; }
+});
+Object.defineProperty(exports, "onRenderTriggered", {
+  enumerable: true,
+  get: function () { return component.onRenderTriggered; }
+});
+Object.defineProperty(exports, "onUnmounted", {
+  enumerable: true,
+  get: function () { return component.onUnmounted; }
+});
+Object.defineProperty(exports, "onUpdated", {
+  enumerable: true,
+  get: function () { return component.onUpdated; }
+});
+Object.defineProperty(exports, "Comment", {
+  enumerable: true,
+  get: function () { return vdom.Comment; }
+});
+Object.defineProperty(exports, "Fragment", {
+  enumerable: true,
+  get: function () { return vdom.Fragment; }
+});
+Object.defineProperty(exports, "Text", {
+  enumerable: true,
+  get: function () { return vdom.Text; }
+});
+Object.defineProperty(exports, "cloneVNode", {
+  enumerable: true,
+  get: function () { return vdom.cloneVNode; }
+});
+Object.defineProperty(exports, "createVNode", {
+  enumerable: true,
+  get: function () { return vdom.createVNode; }
+});
+Object.defineProperty(exports, "mergeProps", {
+  enumerable: true,
+  get: function () { return vdom.mergeProps; }
+});
+Object.defineProperty(exports, "computed", {
+  enumerable: true,
+  get: function () { return reactivity.computed; }
+});
+Object.defineProperty(exports, "effect", {
+  enumerable: true,
+  get: function () { return reactivity.effect; }
+});
+Object.defineProperty(exports, "reactive", {
+  enumerable: true,
+  get: function () { return reactivity.reactive; }
+});
+Object.defineProperty(exports, "ref", {
+  enumerable: true,
+  get: function () { return reactivity.ref; }
+});
+Object.defineProperty(exports, "watch", {
+  enumerable: true,
+  get: function () { return reactivity.watch; }
+});
+Object.defineProperty(exports, "watchEffect", {
+  enumerable: true,
+  get: function () { return reactivity.watchEffect; }
+});
+Object.defineProperty(exports, "nextTick", {
+  enumerable: true,
+  get: function () { return commonScheduler.nextTick; }
+});
+Object.defineProperty(exports, "compile", {
+  enumerable: true,
+  get: function () { return compiler.compile; }
+});
+exports.applyConfigPreset = applyConfigPreset;
+exports.createApp = createApp;
+exports.createElement = h;
+exports.createPluginTester = createPluginTester;
+exports.defineAsyncComponent = defineAsyncComponent;
+exports.defineCustomElement = defineCustomElement;
+exports.defineModel = defineModel;
+exports.definePlugin = definePlugin;
+exports.getCacheUtils = getCacheUtils;
+exports.getConfig = getConfig;
+exports.getGlobalConfig = getGlobalConfig;
+exports.getHttpClient = getHttpClient;
+exports.getQueryUtils = getQueryUtils;
+exports.getSecurityUtils = getSecurityUtils;
+exports.h = h;
+exports.injectChildStyles = injectChildStyles;
+exports.mergeConfig = mergeConfig;
+exports.mergePluginConfig = mergePluginConfig;
+exports.registerIntegrations = registerIntegrations;
+exports.resolveComponent = resolveComponent;
+exports.resolveDirective = resolveDirective;
+exports.resolveDynamicComponent = resolveDynamicComponent;
+exports.safeEscapeHtml = safeEscapeHtml;
+exports.safeParseQueryString = safeParseQueryString;
+exports.setConfig = setConfig;
+exports.setGlobalConfig = setGlobalConfig;
+exports.testPluginInstall = testPluginInstall;
+exports.transformConfig = transformConfig;
+exports.transformPluginConfig = transformPluginConfig;
+exports.useAttrs = useAttrs;
+exports.useCssModule = useCssModule;
+exports.useCssVars = useCssVars;
+exports.useHost = useHost;
+exports.useId = useId;
+exports.useModel = useModel;
+exports.useShadowRoot = useShadowRoot;
+exports.useSlots = useSlots;
+exports.useTemplateRef = useTemplateRef;
+exports.useWebComponentSlots = useWebComponentSlots;
+exports.validateConfig = validateConfig;
+exports.validatePluginConfig = validatePluginConfig;
+exports.watchConfig = watchConfig;
+exports.withDirectives = withDirectives;
+exports.withMemo = withMemo;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map