@tachui/core 0.7.0-alpha1 → 0.7.1-alpha

package/dist/modifiers/responsive/index.d.ts

@@ -14,15 +14,16 @@ export * from './layout-patterns';
 export * from './performance';
 export * from './advanced-utilities';
 export * from './dev-tools';
-export type { ResponsiveValue, BreakpointKey, ResponsiveStyleConfig } from './types';
+export type { ResponsiveValue, BreakpointKey, ResponsiveStyleConfig, } from './types';
 export type { ResponsiveModifierBuilder } from './responsive-builder';
-export { configureBreakpoints, initializeResponsiveSystem, getCurrentBreakpointConfig, getCurrentBreakpoint, getViewportDimensions, createBreakpointContext, generateMediaQuery, BreakpointPresets } from './breakpoints';
-export { createResponsiveModifier, createMediaQueryModifier, createResponsivePropertyModifier, createResponsiveLayoutModifier } from './responsive-modifier';
-export { useBreakpoint, useMediaQuery, useResponsiveValue, withResponsive } from './utilities';
+export { ResponsiveModifierBuilderImpl, withResponsive, createResponsiveBuilder, } from './responsive-builder';
+export { configureBreakpoints, initializeResponsiveSystem, getCurrentBreakpointConfig, getCurrentBreakpoint, getViewportDimensions, createBreakpointContext, generateMediaQuery, BreakpointPresets, } from './breakpoints';
+export { createResponsiveModifier, createMediaQueryModifier, createResponsivePropertyModifier, createResponsiveLayoutModifier, } from './responsive-modifier';
+export { useBreakpoint, useMediaQuery, useResponsiveValue } from './utilities';
 export { DEFAULT_BREAKPOINTS } from './types';
-export { MediaQueries, enableResponsiveDebugOverlay, logResponsiveState } from './utilities';
-export { ResponsiveGridPatterns, ResponsiveFlexPatterns, ResponsiveContainerPatterns, ResponsiveVisibilityPatterns, ResponsiveSpacingPatterns, ResponsiveTypographyPatterns, LayoutPatterns, ResponsiveGrid, Flex, Container, Visibility, Spacing, ResponsiveTypography } from './layout-patterns';
-export { AdvancedBreakpointUtils, ResponsiveHooks, ResponsiveTargeting, ResponsiveDataUtils, ResponsiveAdvanced } from './advanced-utilities';
-export { OptimizedCSSGenerator, ResponsivePerformanceMonitor, cssRuleCache } from './performance';
-export { ResponsiveDevTools, BrowserCompatibility, useResponsiveInspector } from './dev-tools';
+export { MediaQueries, enableResponsiveDebugOverlay, logResponsiveState, } from './utilities';
+export { ResponsiveGridPatterns, ResponsiveFlexPatterns, ResponsiveContainerPatterns, ResponsiveVisibilityPatterns, ResponsiveSpacingPatterns, ResponsiveTypographyPatterns, LayoutPatterns, ResponsiveGrid, Flex, Container, Visibility, Spacing, ResponsiveTypography, } from './layout-patterns';
+export { AdvancedBreakpointUtils, ResponsiveHooks, ResponsiveTargeting, ResponsiveDataUtils, ResponsiveAdvanced, } from './advanced-utilities';
+export { OptimizedCSSGenerator, ResponsivePerformanceMonitor, cssRuleCache, } from './performance';
+export { ResponsiveDevTools, BrowserCompatibility, useResponsiveInspector, } from './dev-tools';
 //# sourceMappingURL=index.d.ts.map

package/dist/modifiers/responsive/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modifiers/responsive/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,SAAS,CAAA;AAGvB,cAAc,eAAe,CAAA;AAG7B,cAAc,iBAAiB,CAAA;AAG/B,cAAc,uBAAuB,CAAA;AAGrC,cAAc,sBAAsB,CAAA;AAGpC,cAAc,aAAa,CAAA;AAG3B,cAAc,mBAAmB,CAAA;AAGjC,cAAc,eAAe,CAAA;AAG7B,cAAc,sBAAsB,CAAA;AAGpC,cAAc,aAAa,CAAA;AAG3B,YAAY,EACV,eAAe,EACf,aAAa,EACb,qBAAqB,EACtB,MAAM,SAAS,CAAA;AAEhB,YAAY,EACV,yBAAyB,EAC1B,MAAM,sBAAsB,CAAA;AAG7B,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,0BAA0B,EAC1B,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,eAAe,CAAA;AAEtB,OAAO,EACL,wBAAwB,EACxB,wBAAwB,EACxB,gCAAgC,EAChC,8BAA8B,EAC/B,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EACL,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,cAAc,EACf,MAAM,aAAa,CAAA;AAEpB,OAAO,EACL,mBAAmB,EACpB,MAAM,SAAS,CAAA;AAEhB,OAAO,EACL,YAAY,EACZ,4BAA4B,EAC5B,kBAAkB,EACnB,MAAM,aAAa,CAAA;AAEpB,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,2BAA2B,EAC3B,4BAA4B,EAC5B,yBAAyB,EACzB,4BAA4B,EAC5B,cAAc,EACd,cAAc,EACd,IAAI,EACJ,SAAS,EACT,UAAU,EACV,OAAO,EACP,oBAAoB,EACrB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EACL,uBAAuB,EACvB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EACL,qBAAqB,EACrB,4BAA4B,EAC5B,YAAY,EACb,MAAM,eAAe,CAAA;AAEtB,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modifiers/responsive/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,SAAS,CAAA;AAGvB,cAAc,eAAe,CAAA;AAG7B,cAAc,iBAAiB,CAAA;AAG/B,cAAc,uBAAuB,CAAA;AAGrC,cAAc,sBAAsB,CAAA;AAGpC,cAAc,aAAa,CAAA;AAG3B,cAAc,mBAAmB,CAAA;AAGjC,cAAc,eAAe,CAAA;AAG7B,cAAc,sBAAsB,CAAA;AAGpC,cAAc,aAAa,CAAA;AAG3B,YAAY,EACV,eAAe,EACf,aAAa,EACb,qBAAqB,GACtB,MAAM,SAAS,CAAA;AAEhB,YAAY,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAA;AAErE,OAAO,EACL,6BAA6B,EAC7B,cAAc,EACd,uBAAuB,GACxB,MAAM,sBAAsB,CAAA;AAG7B,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,0BAA0B,EAC1B,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,eAAe,CAAA;AAEtB,OAAO,EACL,wBAAwB,EACxB,wBAAwB,EACxB,gCAAgC,EAChC,8BAA8B,GAC/B,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAE9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAE7C,OAAO,EACL,YAAY,EACZ,4BAA4B,EAC5B,kBAAkB,GACnB,MAAM,aAAa,CAAA;AAEpB,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,2BAA2B,EAC3B,4BAA4B,EAC5B,yBAAyB,EACzB,4BAA4B,EAC5B,cAAc,EACd,cAAc,EACd,IAAI,EACJ,SAAS,EACT,UAAU,EACV,OAAO,EACP,oBAAoB,GACrB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EACL,uBAAuB,EACvB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EACL,qBAAqB,EACrB,4BAA4B,EAC5B,YAAY,GACb,MAAM,eAAe,CAAA;AAEtB,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,aAAa,CAAA"}

package/dist/plugins/index.js

@@ -1,34 +1,545 @@
-import { SimplifiedPluginManager as i } from "./simplified-plugin-manager.js";
-import { SimplifiedComponentRegistry as l } from "./simplified-component-registry.js";
-import { SimplifiedTachUIInstance as n, globalTachUIInstance as t, installPlugin as g, registerComponent as m, registerService as p } from "./simplified-tachui-instance.js";
-import { PluginError as u } from "./simplified-types.js";
-import { PluginDevUtils as f, compareSemver as c, normalizePluginName as s, validatePluginName as L, validateSemver as x } from "./simplified-utils.js";
-import { OptimizedLazyPluginLoader as z, OptimizedLazyPluginLoader as S, createLazyPlugin as v } from "./simplified-lazy-loader.js";
-import { ErrorRecoveryUtils as I, OptimizedPluginErrorHandler as U, SimplifiedPluginErrorHandler as H, globalPluginErrorHandler as O } from "./simplified-error-handler.js";
-import { adaptPlugin as h, createLegacyPluginAdapter as C, isLegacyPlugin as N } from "./legacy-adapter.js";
+var E = Object.defineProperty, y = (t, e, r) => e in t ? E(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, f = (t, e, r) => y(t, typeof e != "symbol" ? e + "" : e, r);
+let d = class extends Error {
+  constructor(e, r) {
+    super(e), this.code = r, this.name = "PluginError";
+  }
+};
+class $ {
+  constructor(e) {
+    f(this, "plugins", /* @__PURE__ */ new Map()), f(this, "instance"), this.instance = e;
+  }
+  async install(e) {
+    this.validatePluginBasics(e), await e.install(this.instance), this.plugins.set(e.name, e), console.log(`✅ Plugin "${e.name}" v${e.version} installed successfully`);
+  }
+  async uninstall(e) {
+    const r = this.plugins.get(e);
+    if (!r)
+      throw new d(`Plugin "${e}" is not installed`);
+    this.plugins.delete(e);
+    try {
+      r.uninstall && await r.uninstall(), console.log(`🗑️ Plugin "${e}" uninstalled successfully`);
+    } catch (s) {
+      throw console.log(`🗑️ Plugin "${e}" uninstalled successfully (cleanup failed)`), s;
+    }
+  }
+  isInstalled(e) {
+    return this.plugins.has(e);
+  }
+  getInstalledPlugins() {
+    return Array.from(this.plugins.keys());
+  }
+  getPlugin(e) {
+    return this.plugins.get(e);
+  }
+  getAllPlugins() {
+    return Array.from(this.plugins.values());
+  }
+  validatePluginBasics(e) {
+    if (!e.name || typeof e.name != "string")
+      throw new d("Plugin must have a valid name string", "INVALID_NAME");
+    if (!e.version || typeof e.version != "string")
+      throw new d("Plugin must have a valid version string", "INVALID_VERSION");
+    if (!e.install || typeof e.install != "function")
+      throw new d("Plugin must have an install function", "INVALID_INSTALL");
+    this.plugins.has(e.name) && console.warn(`Plugin "${e.name}" is already installed, overwriting`);
+  }
+}
+var _ = Object.defineProperty, M = (t, e, r) => e in t ? _(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, T = (t, e, r) => M(t, e + "", r);
+class b {
+  constructor() {
+    T(this, "components", /* @__PURE__ */ new Map());
+  }
+  register(e) {
+    if (!e.name || typeof e.name != "string")
+      throw new Error("Component registration must have a valid name");
+    if (!e.component || typeof e.component != "function")
+      throw new Error("Component registration must have a valid component function");
+    this.components.has(e.name) && console.warn(`Component ${e.name} already registered, overwriting`), this.components.set(e.name, e), console.log(`📦 Component "${e.name}" registered${e.category ? ` (${e.category})` : ""}`);
+  }
+  get(e) {
+    return this.components.get(e);
+  }
+  getComponent(e) {
+    return this.components.get(e)?.component;
+  }
+  has(e) {
+    return this.components.has(e);
+  }
+  list() {
+    return Array.from(this.components.values());
+  }
+  listByCategory(e) {
+    return this.list().filter((r) => r.category === e);
+  }
+  listByPlugin(e) {
+    return this.list().filter((r) => r.plugin === e);
+  }
+  unregister(e) {
+    const r = this.components.has(e);
+    return this.components.delete(e), r && console.log(`🗑️ Component "${e}" unregistered`), r;
+  }
+  unregisterByPlugin(e) {
+    const r = [];
+    for (const [s, i] of this.components.entries())
+      i.plugin === e && (this.components.delete(s), r.push(s));
+    return r.length > 0 && console.log(`🗑️ Unregistered ${r.length} components from plugin "${e}": ${r.join(", ")}`), r;
+  }
+  clear() {
+    const e = this.components.size;
+    this.components.clear(), console.log(`🗑️ Cleared ${e} registered components`);
+  }
+  getStats() {
+    const e = {
+      totalComponents: this.components.size,
+      categories: /* @__PURE__ */ new Map(),
+      plugins: /* @__PURE__ */ new Map(),
+      tags: /* @__PURE__ */ new Map()
+    };
+    for (const r of this.components.values()) {
+      const s = r.category || "uncategorized";
+      e.categories.set(s, (e.categories.get(s) || 0) + 1);
+      const i = r.plugin || "core";
+      if (e.plugins.set(i, (e.plugins.get(i) || 0) + 1), r.tags)
+        for (const n of r.tags)
+          e.tags.set(n, (e.tags.get(n) || 0) + 1);
+    }
+    return {
+      totalComponents: e.totalComponents,
+      categories: Object.fromEntries(e.categories),
+      plugins: Object.fromEntries(e.plugins),
+      tags: Object.fromEntries(e.tags)
+    };
+  }
+}
+var C = Object.defineProperty, O = (t, e, r) => e in t ? C(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, h = (t, e, r) => O(t, typeof e != "symbol" ? e + "" : e, r);
+class B {
+  constructor() {
+    h(this, "plugins"), h(this, "components"), h(this, "services"), h(this, "currentInstallingPlugin", null), this.components = new b(), this.services = /* @__PURE__ */ new Map(), this.plugins = new $(this);
+  }
+  registerComponent(e, r, s) {
+    this.components.register({
+      name: e,
+      component: r,
+      category: s?.category,
+      tags: s?.tags,
+      plugin: this.currentInstallingPlugin || void 0
+    });
+  }
+  registerService(e, r) {
+    this.services.has(e) && !this.services.get(e) && console.warn(`Service "${e}" already registered, overwriting`), this.services.set(e, r), console.log(`⚙️ Service "${e}" registered`);
+  }
+  getService(e) {
+    return this.services.get(e);
+  }
+  hasService(e) {
+    return this.services.has(e);
+  }
+  unregisterService(e) {
+    const r = this.services.has(e);
+    return this.services.delete(e), r && console.log(`🗑️ Service "${e}" unregistered`), r;
+  }
+  async installPlugin(e) {
+    this.currentInstallingPlugin = e.name;
+    try {
+      await this.plugins.install(e);
+    } finally {
+      this.currentInstallingPlugin = null;
+    }
+  }
+  async uninstallPlugin(e) {
+    this.components.unregisterByPlugin(e), await this.plugins.uninstall(e);
+  }
+  isPluginInstalled(e) {
+    return this.plugins.isInstalled(e);
+  }
+  getInstalledPlugins() {
+    return this.plugins.getInstalledPlugins();
+  }
+  getStats() {
+    return {
+      plugins: {
+        installed: this.plugins.getInstalledPlugins().length,
+        list: this.plugins.getInstalledPlugins()
+      },
+      components: this.components.getStats(),
+      services: {
+        registered: this.services.size,
+        list: Array.from(this.services.keys())
+      }
+    };
+  }
+  async reset() {
+    const e = this.getInstalledPlugins();
+    for (const r of e)
+      try {
+        await this.uninstallPlugin(r);
+      } catch (s) {
+        console.error(`Failed to uninstall plugin "${r}":`, s);
+      }
+    this.components.clear(), this.services.clear(), console.log("🔄 TachUI instance reset completed");
+  }
+}
+const m = new B();
+function k(t) {
+  return m.installPlugin(t);
+}
+function F(t, e, r) {
+  return m.registerComponent(t, e, r);
+}
+function Q(t, e) {
+  return m.registerService(t, e);
+}
+class a extends Error {
+  constructor(e, r) {
+    super(e), this.code = r, this.name = "PluginError";
+  }
+}
+function g(t) {
+  return !t || typeof t != "string" ? !1 : /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/.test(t);
+}
+function N(t, e) {
+  if (!g(t) || !g(e))
+    throw new Error("Invalid semantic version format");
+  const r = (n) => {
+    const [o, c] = n.split("-"), [v, w, P] = o.split(".").map(Number);
+    return { major: v, minor: w, patch: P, prerelease: c };
+  }, s = r(t), i = r(e);
+  return s.major !== i.major ? s.major < i.major ? -1 : 1 : s.minor !== i.minor ? s.minor < i.minor ? -1 : 1 : s.patch !== i.patch ? s.patch < i.patch ? -1 : 1 : s.prerelease && i.prerelease ? s.prerelease < i.prerelease ? -1 : s.prerelease > i.prerelease ? 1 : 0 : s.prerelease && !i.prerelease ? -1 : !s.prerelease && i.prerelease ? 1 : 0;
+}
+function H(t) {
+  return !t || typeof t != "string" ? !1 : /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(t);
+}
+function j(t) {
+  return t.replace(/^@[^/]+\//, "");
+}
+const U = {
+  /**
+   * Logs plugin debug information in development mode
+   */
+  log(t, e, r) {
+    process.env.NODE_ENV === "development" && (console.group(`🔌 [${t}]`), console.log(e), r && console.log("Data:", r), console.groupEnd());
+  },
+  /**
+   * Creates a development-only warning
+   */
+  warn(t, e) {
+    process.env.NODE_ENV === "development" && console.warn(`⚠️  [${t}] ${e}`);
+  }
+};
+var z = Object.defineProperty, I = (t, e, r) => e in t ? z(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, u = (t, e, r) => I(t, typeof e != "symbol" ? e + "" : e, r);
+class q {
+  constructor() {
+    u(this, "loadPromises", /* @__PURE__ */ new Map()), u(this, "loadedPlugins", /* @__PURE__ */ new Map()), u(this, "loadMetrics", /* @__PURE__ */ new Map()), u(this, "maxRetries", 3), u(this, "baseRetryDelay", 100);
+  }
+  // ms
+  async loadPlugin(e) {
+    if (this.loadedPlugins.has(e))
+      return this.recordCacheHit(e), this.loadedPlugins.get(e);
+    if (this.loadPromises.has(e))
+      return this.loadPromises.get(e);
+    const r = this.doLoadPluginWithRetry(e);
+    this.loadPromises.set(e, r);
+    try {
+      const s = await r;
+      return this.loadedPlugins.set(e, s), s;
+    } catch (s) {
+      throw this.loadPromises.delete(e), s;
+    }
+  }
+  async doLoadPluginWithRetry(e, r = 1) {
+    const s = {
+      startTime: performance.now(),
+      attempts: r,
+      success: !1,
+      cacheHit: !1
+    };
+    this.loadMetrics.set(e, s);
+    try {
+      const i = await this.doLoadPlugin(e);
+      return s.endTime = performance.now(), s.duration = s.endTime - s.startTime, s.success = !0, process.env.NODE_ENV === "development" && console.log(`🚀 Plugin "${e}" loaded in ${s.duration.toFixed(2)}ms (attempt ${r})`), i;
+    } catch (i) {
+      if (s.endTime = performance.now(), s.duration = s.endTime - s.startTime, r < this.maxRetries) {
+        const n = this.baseRetryDelay * Math.pow(2, r - 1);
+        return process.env.NODE_ENV === "development" && console.warn(`⚠️ Plugin "${e}" load failed (attempt ${r}), retrying in ${n}ms...`), await this.delay(n), this.doLoadPluginWithRetry(e, r + 1);
+      }
+      throw process.env.NODE_ENV === "development" && console.error(`❌ Plugin "${e}" failed to load after ${r} attempts`), new a(`Failed to load plugin "${e}" after ${r} attempts: ${i}`);
+    }
+  }
+  async doLoadPlugin(e) {
+    try {
+      const r = await import(
+        /* webpackChunkName: "plugin-[request]" */
+        e
+      ), s = r.default || r;
+      if (!s || typeof s != "object")
+        throw new a(`Plugin "${e}" must export a plugin object`);
+      if (!s.name || !s.version || typeof s.install != "function")
+        throw new a(`Plugin "${e}" must have name, version, and install method`);
+      return s;
+    } catch (r) {
+      throw new a(`Dynamic import failed for "${e}": ${r}`);
+    }
+  }
+  recordCacheHit(e) {
+    if (this.loadMetrics.has(e)) {
+      const r = this.loadMetrics.get(e);
+      r.cacheHit = !0;
+    }
+    process.env.NODE_ENV === "development" && console.log(`💾 Plugin "${e}" served from cache`);
+  }
+  delay(e) {
+    return new Promise((r) => setTimeout(r, e));
+  }
+  // Performance monitoring methods
+  isLoading(e) {
+    return this.loadPromises.has(e) && !this.loadedPlugins.has(e);
+  }
+  isLoaded(e) {
+    return this.loadedPlugins.has(e);
+  }
+  getLoadMetrics(e) {
+    return this.loadMetrics.get(e);
+  }
+  getAllMetrics() {
+    return Array.from(this.loadMetrics.entries()).map(([e, r]) => ({
+      plugin: e,
+      metrics: r
+    }));
+  }
+  getPerformanceStats() {
+    const e = this.getAllMetrics(), r = e.filter((o) => o.metrics.success), s = e.filter((o) => !o.metrics.success), i = r.reduce((o, c) => o + (c.metrics.duration || 0), 0), n = r.length > 0 ? i / r.length : 0;
+    return {
+      totalPlugins: e.length,
+      successful: r.length,
+      failed: s.length,
+      cached: this.loadedPlugins.size,
+      averageLoadTime: n,
+      totalLoadTime: i,
+      cacheHitRate: r.length > 0 ? r.filter((o) => o.metrics.cacheHit).length / r.length : 0
+    };
+  }
+  clearCache(e) {
+    e ? (this.loadPromises.delete(e), this.loadedPlugins.delete(e), this.loadMetrics.delete(e)) : (this.loadPromises.clear(), this.loadedPlugins.clear(), this.loadMetrics.clear());
+  }
+  // Memory management
+  unloadPlugin(e) {
+    this.loadPromises.delete(e), this.loadedPlugins.delete(e), process.env.NODE_ENV === "development" && console.log(`🗑️ Plugin "${e}" unloaded from memory`);
+  }
+  getMemoryUsage() {
+    return {
+      loadedPlugins: this.loadedPlugins.size,
+      pendingLoads: this.loadPromises.size,
+      metricsEntries: this.loadMetrics.size,
+      estimatedMemoryKB: this.loadedPlugins.size * 5 + this.loadMetrics.size * 1
+      // rough estimate
+    };
+  }
+}
+function Z(t) {
+  return async () => {
+    try {
+      const e = await t(), r = "default" in e ? e.default : e;
+      if (!r || typeof r != "object")
+        throw new a("Plugin module must export a plugin object");
+      if (!r.name || !r.version || typeof r.install != "function")
+        throw new a("Plugin must have name, version, and install method");
+      return r;
+    } catch (e) {
+      throw new a(`Failed to load plugin: ${e}`);
+    }
+  };
+}
+var L = Object.defineProperty, D = (t, e, r) => e in t ? L(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, l = (t, e, r) => D(t, typeof e != "symbol" ? e + "" : e, r);
+class p {
+  constructor() {
+    l(this, "errorMetrics", /* @__PURE__ */ new Map()), l(this, "circuitBreakers", /* @__PURE__ */ new Map()), l(this, "errorQueue", []), l(this, "batchTimer"), l(this, "maxFailuresBeforeCircuitBreak", 3), l(this, "circuitBreakerResetTime", 3e4), l(this, "errorBatchSize", 10), l(this, "errorBatchTimeout", 1e3), l(this, "maxErrorHistory", 100);
+  }
+  handleInstallError(e, r) {
+    const s = `install:${e.name}`;
+    if (this.recordError(s, r), this.isCircuitOpen(s)) {
+      process.env.NODE_ENV === "development" && console.warn(`🚫 Circuit breaker open for plugin ${e.name}, skipping detailed error handling`);
+      return;
+    }
+    process.env.NODE_ENV === "development" && console.error(`❌ Failed to install plugin ${e.name}:`, r), r instanceof a && (this.recordErrorType(s, `plugin-error-${r.code}`), process.env.NODE_ENV === "development" && console.warn(`Plugin ${e.name} installation failed with code: ${r.code}`)), r.message.includes("dependencies") && (this.recordErrorType(s, "dependency-error"), process.env.NODE_ENV === "development" && console.warn(`Plugin ${e.name} has unmet dependencies`)), this.queueError("plugin-install-failed", { plugin: { name: e.name, version: e.version }, error: r.message });
+  }
+  handleRuntimeError(e, r) {
+    const s = `runtime:${e}`;
+    this.recordError(s, r), !this.isCircuitOpen(s) && (process.env.NODE_ENV === "development" && console.error(`❌ Runtime error in plugin ${e}:`, r), r instanceof a && r.code === "CRITICAL" ? (this.recordErrorType(s, "critical-error"), process.env.NODE_ENV === "development" && console.warn(`Plugin ${e} encountered a critical error`), this.queueError("plugin-critical-error", { pluginName: e, error: r.message })) : (this.recordErrorType(s, "runtime-error"), this.queueError("plugin-runtime-error", { pluginName: e, error: r.message })));
+  }
+  handleUninstallError(e, r) {
+    const s = `uninstall:${e}`;
+    this.recordError(s, r), process.env.NODE_ENV === "development" && (console.error(`❌ Failed to uninstall plugin ${e}:`, r), console.warn(`Plugin ${e} may not have cleaned up properly`)), this.queueError("plugin-uninstall-error", { pluginName: e, error: r.message });
+  }
+  recordError(e, r) {
+    const s = performance.now();
+    this.errorMetrics.has(e) || this.errorMetrics.set(e, {
+      count: 0,
+      lastOccurrence: s,
+      firstOccurrence: s,
+      errorTypes: /* @__PURE__ */ new Map(),
+      resolved: !1
+    });
+    const i = this.errorMetrics.get(e);
+    i.count++, i.lastOccurrence = s, i.resolved = !1, this.updateCircuitBreaker(e);
+  }
+  recordErrorType(e, r) {
+    const s = this.errorMetrics.get(e);
+    if (s) {
+      const i = s.errorTypes.get(r) || 0;
+      s.errorTypes.set(r, i + 1);
+    }
+  }
+  updateCircuitBreaker(e) {
+    this.circuitBreakers.has(e) || this.circuitBreakers.set(e, {
+      isOpen: !1,
+      failureCount: 0,
+      lastFailureTime: 0
+    });
+    const r = this.circuitBreakers.get(e);
+    r.failureCount++, r.lastFailureTime = performance.now(), r.failureCount >= this.maxFailuresBeforeCircuitBreak && !r.isOpen && (r.isOpen = !0, process.env.NODE_ENV === "development" && console.warn(`🚫 Circuit breaker opened for ${e} after ${r.failureCount} failures`), r.resetTimeout = window.setTimeout(() => {
+      this.resetCircuitBreaker(e);
+    }, this.circuitBreakerResetTime));
+  }
+  isCircuitOpen(e) {
+    const r = this.circuitBreakers.get(e);
+    return r ? r.isOpen : !1;
+  }
+  resetCircuitBreaker(e) {
+    const r = this.circuitBreakers.get(e);
+    r && (r.isOpen = !1, r.failureCount = 0, r.resetTimeout && (clearTimeout(r.resetTimeout), r.resetTimeout = void 0), process.env.NODE_ENV === "development" && console.log(`🔄 Circuit breaker reset for ${e}`));
+  }
+  queueError(e, r) {
+    this.errorQueue.push({
+      type: e,
+      data: r,
+      timestamp: performance.now()
+    }), this.errorQueue.length > this.maxErrorHistory && (this.errorQueue = this.errorQueue.slice(-this.maxErrorHistory)), this.errorQueue.length >= this.errorBatchSize ? this.flushErrorQueue() : this.batchTimer || (this.batchTimer = window.setTimeout(() => {
+      this.flushErrorQueue();
+    }, this.errorBatchTimeout));
+  }
+  flushErrorQueue() {
+    if (this.errorQueue.length === 0) return;
+    const e = [...this.errorQueue];
+    this.errorQueue = [], this.batchTimer && (clearTimeout(this.batchTimer), this.batchTimer = void 0);
+    for (const r of e)
+      this.emitError(r.type, r.data);
+    process.env.NODE_ENV === "development" && e.length > 1 && console.log(`📦 Processed ${e.length} batched errors`);
+  }
+  emitError(e, r) {
+    typeof window < "u" ? window.dispatchEvent(new CustomEvent(`tachui:${e}`, { detail: r })) : typeof process < "u" && process.emit && process.emit(`tachui:${e}`, r);
+  }
+  // Performance monitoring methods
+  getErrorMetrics(e) {
+    return e ? this.errorMetrics.get(e) || {
+      count: 0,
+      lastOccurrence: 0,
+      firstOccurrence: 0,
+      errorTypes: /* @__PURE__ */ new Map(),
+      resolved: !0
+    } : new Map(this.errorMetrics);
+  }
+  getCircuitBreakerStatus(e) {
+    return e ? this.circuitBreakers.get(e) || {
+      isOpen: !1,
+      failureCount: 0,
+      lastFailureTime: 0
+    } : new Map(this.circuitBreakers);
+  }
+  getPerformanceStats() {
+    const e = Array.from(this.errorMetrics.entries()), r = e.reduce((n, [, o]) => n + o.count, 0), s = Array.from(this.circuitBreakers.values()).filter((n) => n.isOpen).length, i = /* @__PURE__ */ new Map();
+    for (const [, n] of e)
+      for (const [o, c] of n.errorTypes)
+        i.set(o, (i.get(o) || 0) + c);
+    return {
+      totalErrors: r,
+      uniqueErrorKeys: this.errorMetrics.size,
+      activeCircuitBreakers: s,
+      queuedErrors: this.errorQueue.length,
+      errorsByType: Object.fromEntries(i),
+      memoryUsage: {
+        errorMetrics: this.errorMetrics.size,
+        circuitBreakers: this.circuitBreakers.size,
+        queuedErrors: this.errorQueue.length,
+        estimatedMemoryKB: this.errorMetrics.size * 2 + this.circuitBreakers.size * 1 + this.errorQueue.length * 0.5
+      }
+    };
+  }
+  markErrorResolved(e) {
+    const r = this.errorMetrics.get(e);
+    r && (r.resolved = !0, this.resetCircuitBreaker(e));
+  }
+  clearErrorHistory(e) {
+    e ? (this.errorMetrics.delete(e), this.circuitBreakers.delete(e)) : (this.errorMetrics.clear(), this.circuitBreakers.clear(), this.errorQueue = [], this.batchTimer && (clearTimeout(this.batchTimer), this.batchTimer = void 0));
+  }
+}
+const S = new p(), W = p, A = {
+  /**
+   * Safely execute plugin operation with error handling
+   */
+  async safeExecute(t, e, r) {
+    try {
+      return await r();
+    } catch (s) {
+      console.error(`❌ [${t}] ${e} failed:`, s), S.handleRuntimeError(t, s);
+      return;
+    }
+  },
+  /**
+   * Create an error boundary for plugin operations
+   */
+  createErrorBoundary(t) {
+    return {
+      async exec(e) {
+        return A.safeExecute(t, "operation", e);
+      }
+    };
+  }
+};
+function V(t) {
+  if (!t.metadata)
+    throw new a("Legacy plugin must have metadata property");
+  if (!t.metadata.name || !t.metadata.version)
+    throw new a("Legacy plugin metadata must include name and version");
+  return {
+    name: t.metadata.name,
+    version: t.metadata.version,
+    description: t.metadata.description,
+    async install(e) {
+      process.env.NODE_ENV === "development" && console.warn(`⚠️  Using legacy adapter for plugin "${t.metadata.name}". Consider updating to simplified API.`), await t.initialize(e);
+    },
+    async uninstall() {
+      t.cleanup && await t.cleanup();
+    }
+  };
+}
+function x(t) {
+  return t && typeof t == "object" && t.metadata && typeof t.metadata.name == "string" && typeof t.metadata.version == "string" && typeof t.initialize == "function";
+}
+function G(t) {
+  return x(t) ? V(t) : t;
+}
 export {
-  I as ErrorRecoveryUtils,
-  z as OptimizedLazyPluginLoader,
-  U as OptimizedPluginErrorHandler,
-  f as PluginDevUtils,
-  u as PluginError,
-  l as SimplifiedComponentRegistry,
-  S as SimplifiedLazyPluginLoader,
-  H as SimplifiedPluginErrorHandler,
-  i as SimplifiedPluginManager,
-  n as SimplifiedTachUIInstance,
-  h as adaptPlugin,
-  c as compareSemver,
-  v as createLazyPlugin,
-  C as createLegacyPluginAdapter,
-  O as globalPluginErrorHandler,
-  t as globalTachUIInstance,
-  g as installPlugin,
-  N as isLegacyPlugin,
-  s as normalizePluginName,
-  m as registerComponent,
-  p as registerService,
-  L as validatePluginName,
-  x as validateSemver
+  A as ErrorRecoveryUtils,
+  q as OptimizedLazyPluginLoader,
+  p as OptimizedPluginErrorHandler,
+  U as PluginDevUtils,
+  a as PluginError,
+  b as SimplifiedComponentRegistry,
+  q as SimplifiedLazyPluginLoader,
+  W as SimplifiedPluginErrorHandler,
+  $ as SimplifiedPluginManager,
+  B as SimplifiedTachUIInstance,
+  G as adaptPlugin,
+  N as compareSemver,
+  Z as createLazyPlugin,
+  V as createLegacyPluginAdapter,
+  S as globalPluginErrorHandler,
+  m as globalTachUIInstance,
+  k as installPlugin,
+  x as isLegacyPlugin,
+  j as normalizePluginName,
+  F as registerComponent,
+  Q as registerService,
+  H as validatePluginName,
+  g as validateSemver
 };
-//# sourceMappingURL=index.js.map