@therealtinhtute/baroiplayer 1.1.0 → 1.2.0

package/dist/{core-plugins-CROGvQUy.js → core-plugins-DSBWcTuX.js}

@@ -1,72 +1,401 @@
-var f = Object.defineProperty;
-var p = (r, t, e) => t in r ? f(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
-var o = (r, t, e) => p(r, typeof t != "symbol" ? t + "" : t, e);
-import { E as y } from "./core-events-DunPHKRE.js";
+var y = Object.defineProperty;
+var v = (r, t, e) => t in r ? y(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var a = (r, t, e) => v(r, typeof t != "symbol" ? t + "" : t, e);
+import { E as w } from "./core-events-DunPHKRE.js";
 class l extends Error {
   constructor(t, e, i, n) {
     super(`Plugin '${t}' failed during ${e}: ${i}`), this.pluginName = t, this.phase = e, this.originalError = n, this.name = "PluginError";
   }
 }
-class v extends l {
+class h extends l {
   constructor(t, e) {
     super(t, "initialize", `Missing dependencies: ${e.join(", ")}`), this.missingDependencies = e, this.name = "PluginDependencyError";
   }
 }
-class w extends l {
+class f extends l {
   constructor(t, e) {
     super(t, "activate", `Conflicts with active plugins: ${e.join(", ")}`), this.conflictingPlugins = e, this.name = "PluginConflictError";
   }
 }
+class d {
+  constructor(t = "[Plugin]") {
+    a(this, "prefix");
+    this.prefix = t;
+  }
+  info(t, e) {
+    e ? console.info(`${this.prefix} ${t}`, e) : console.info(`${this.prefix} ${t}`);
+  }
+  warn(t, e) {
+    e ? console.warn(`${this.prefix} ${t}`, e) : console.warn(`${this.prefix} ${t}`);
+  }
+  error(t, e) {
+    e ? console.error(`${this.prefix} ${t}`, e) : console.error(`${this.prefix} ${t}`);
+  }
+  debug(t, e) {
+    process.env.NODE_ENV === "development" && (e ? console.debug(`${this.prefix} ${t}`, e) : console.debug(`${this.prefix} ${t}`));
+  }
+}
 class b {
+  static validateMetadata(t) {
+    const { metadata: e } = t;
+    if (!e.name || typeof e.name != "string")
+      throw new Error("Plugin metadata must include a valid name");
+    if (!e.version || typeof e.version != "string")
+      throw new Error("Plugin metadata must include a valid version");
+    if (!e.description || typeof e.description != "string")
+      throw new Error("Plugin metadata must include a valid description");
+    if (!e.category)
+      throw new Error("Plugin metadata must include a valid category");
+    if (!e.priority)
+      throw new Error("Plugin metadata must include a valid priority");
+    return !0;
+  }
+  static validateConfig(t, e) {
+    if (!e) return !0;
+    for (const [i, n] of Object.entries(e)) {
+      const s = t[i];
+      if (n.required && s == null)
+        throw new Error(`Configuration property '${i}' is required`);
+      if (s !== void 0 && n.type && typeof s !== n.type)
+        throw new Error(`Configuration property '${i}' must be of type '${n.type}'`);
+      if (n.enum && !n.enum.includes(s))
+        throw new Error(`Configuration property '${i}' must be one of: ${n.enum.join(", ")}`);
+      if (n.min !== void 0 && typeof s == "number" && s < n.min)
+        throw new Error(`Configuration property '${i}' must be at least ${n.min}`);
+      if (n.max !== void 0 && typeof s == "number" && s > n.max)
+        throw new Error(`Configuration property '${i}' must be at most ${n.max}`);
+    }
+    return !0;
+  }
+}
+class P {
+  constructor() {
+    a(this, "metrics", /* @__PURE__ */ new Map());
+  }
+  measure(t, e, i) {
+    const n = `${t}.${e}`, s = performance.now(), o = () => {
+      const u = performance.now(), p = u - s, g = this.metrics.get(n) || {
+        calls: 0,
+        totalTime: 0,
+        averageTime: 0,
+        lastCall: 0
+      };
+      g.calls++, g.totalTime += p, g.averageTime = g.totalTime / g.calls, g.lastCall = u, this.metrics.set(n, g);
+    }, c = i();
+    return c instanceof Promise ? c.then(
+      (u) => (o(), u),
+      (u) => {
+        throw o(), u;
+      }
+    ) : (o(), c);
+  }
+  getMetrics(t) {
+    if (t) {
+      const e = {};
+      for (const [i, n] of this.metrics.entries())
+        if (i.startsWith(`${t}.`)) {
+          const s = i.substring(t.length + 1);
+          e[s] = n;
+        }
+      return e;
+    }
+    return Object.fromEntries(this.metrics.entries());
+  }
+  reset(t) {
+    if (t)
+      for (const e of this.metrics.keys())
+        e.startsWith(`${t}.`) && this.metrics.delete(e);
+    else
+      this.metrics.clear();
+  }
+}
+const k = {
+  // Create a mock plugin context for testing
+  createMockContext() {
+    return {
+      state: {
+        isPlaying: !1,
+        currentTime: 0,
+        duration: 0,
+        volume: 1,
+        isMuted: !1,
+        isLoading: !1,
+        error: null
+      },
+      controls: {
+        play: () => Promise.resolve(),
+        pause: () => Promise.resolve(),
+        seek: (r) => Promise.resolve(),
+        setVolume: (r) => Promise.resolve(),
+        mute: () => Promise.resolve(),
+        unmute: () => Promise.resolve(),
+        toggleMute: () => Promise.resolve()
+      },
+      plugins: {
+        get: () => {
+        },
+        getAll: () => [],
+        isEnabled: () => !1
+      },
+      emit: () => {
+      },
+      on: () => () => {
+      },
+      element: null,
+      logger: new d("[MockPlugin]")
+    };
+  },
+  // Create a test plugin for development
+  createTestPlugin(r, t = {}) {
+    return {
+      metadata: {
+        name: r,
+        version: "1.0.0",
+        description: `Test plugin: ${r}`,
+        category: "ui",
+        priority: "medium"
+      },
+      initialize: async () => {
+      },
+      activate: async () => {
+      },
+      deactivate: async () => {
+      },
+      destroy: async () => {
+      },
+      healthCheck: () => !0,
+      ...t
+    };
+  },
+  // Plugin timing utilities
+  time: {
+    async: async (r, t) => {
+      console.time(r);
+      try {
+        const e = await t();
+        return console.timeEnd(r), e;
+      } catch (e) {
+        throw console.timeEnd(r), e;
+      }
+    },
+    sync: (r, t) => {
+      console.time(r);
+      try {
+        const e = t();
+        return console.timeEnd(r), e;
+      } catch (e) {
+        throw console.timeEnd(r), e;
+      }
+    }
+  }
+};
+class x {
+  constructor(t) {
+    a(this, "prefix");
+    this.prefix = `baroi-plugin-${t}`;
+  }
+  get(t, e) {
+    try {
+      const i = localStorage.getItem(`${this.prefix}-${t}`);
+      return i ? JSON.parse(i) : e;
+    } catch {
+      return e;
+    }
+  }
+  set(t, e) {
+    try {
+      localStorage.setItem(`${this.prefix}-${t}`, JSON.stringify(e));
+    } catch (i) {
+      console.warn(`Failed to store plugin data for key: ${t}`, i);
+    }
+  }
+  remove(t) {
+    try {
+      localStorage.removeItem(`${this.prefix}-${t}`);
+    } catch (e) {
+      console.warn(`Failed to remove plugin data for key: ${t}`, e);
+    }
+  }
+  clear() {
+    try {
+      Object.keys(localStorage).filter((e) => e.startsWith(`${this.prefix}-`)).forEach((e) => localStorage.removeItem(e));
+    } catch (t) {
+      console.warn("Failed to clear plugin data", t);
+    }
+  }
+}
+const z = new d(), A = new P();
+class I {
   constructor(t) {
-    o(this, "plugins", /* @__PURE__ */ new Map());
-    o(this, "pluginConfigs", /* @__PURE__ */ new Map());
-    o(this, "enabledPlugins", /* @__PURE__ */ new Set());
-    o(this, "eventBus", new y());
-    o(this, "logger");
-    this.logger = t;
-  }
-  // Register a plugin factory
-  async register(t, e = {}) {
+    a(this, "plugins", /* @__PURE__ */ new Map());
+    a(this, "pluginConfigs", /* @__PURE__ */ new Map());
+    a(this, "pluginContexts", /* @__PURE__ */ new Map());
+    a(this, "enabledPlugins", /* @__PURE__ */ new Set());
+    a(this, "eventBus", new w());
+    a(this, "logger");
+    this.logger = t || new d("[PluginRegistry]");
+  }
+  register(t, e, i = {}) {
+    let n, s, o = {};
     try {
-      const i = t(e), { name: n, dependencies: s = [], conflicts: c = [] } = i.metadata;
+      if (typeof t == "string")
+        n = t, s = e, o = i;
+      else {
+        const c = t;
+        o = e || {}, s = c(o), n = s?.metadata?.name;
+      }
+      if (!n || !s)
+        throw new l("unknown", "initialize", "Invalid plugin registration payload");
       if (this.plugins.has(n))
         throw new l(n, "initialize", "Plugin already registered");
-      const u = s.filter((h) => !this.plugins.has(h));
-      if (u.length > 0)
-        throw new v(n, u);
-      const a = c.filter((h) => this.enabledPlugins.has(h));
-      if (a.length > 0)
-        throw new w(n, a);
-      this.plugins.set(n, i), this.pluginConfigs.set(n, e), this.logger.info(`Plugin '${n}' registered successfully`), this.eventBus.emit("plugin:registered", { name: n, plugin: i });
-    } catch (i) {
-      const n = t({}).metadata.name;
-      throw this.logger.error(`Failed to register plugin '${n}'`, i), this.eventBus.emit("plugin:error", { name: n, error: i }), i;
+      this.plugins.set(n, s), this.pluginConfigs.set(n, o), this.logger.info(`Plugin '${n}' registered successfully`), this.eventBus.emit("plugin:registered", { name: n, plugin: s });
+    } catch (c) {
+      const u = n || s?.metadata?.name || "unknown";
+      throw this.logger.error(`Failed to register plugin '${u}'`, c), this.eventBus.emit("plugin:error", { name: u, error: c }), c;
     }
   }
-  // Unregister a plugin
-  async unregister(t) {
-    if (!this.plugins.get(t))
+  async unregister(t, e) {
+    const i = this.plugins.get(t);
+    if (!i)
       throw new l(t, "destroy", "Plugin not found");
     try {
-      this.enabledPlugins.has(t) && await this.disable(t), this.plugins.delete(t), this.pluginConfigs.delete(t), this.logger.info(`Plugin '${t}' unregistered successfully`);
-    } catch (i) {
-      throw this.logger.error(`Failed to unregister plugin '${t}'`, i), i;
+      const n = e || this.pluginContexts.get(t) || this.createPluginContext(t);
+      this.enabledPlugins.has(t) && await this.deactivate(t, n), i.isInitialized && await i.destroy(n), this.plugins.delete(t), this.pluginConfigs.delete(t), this.pluginContexts.delete(t), this.enabledPlugins.delete(t), this.logger.info(`Plugin '${t}' unregistered successfully`);
+    } catch (n) {
+      throw this.logger.error(`Failed to unregister plugin '${t}'`, n), n;
     }
   }
-  // Get a plugin by name
   get(t) {
     return this.plugins.get(t);
   }
-  // Get all plugins sorted by priority
+  has(t) {
+    return this.plugins.has(t);
+  }
   getAll() {
     return Array.from(this.plugins.values()).sort(this.sortByPriority);
   }
-  // Check if plugin is enabled
+  getByCategory(t) {
+    return this.getAll().filter((e) => e.metadata.category === t);
+  }
+  getActive() {
+    return Array.from(this.enabledPlugins).map((t) => this.plugins.get(t)).filter((t) => !!t).sort(this.sortByPriority);
+  }
   isEnabled(t) {
     return this.enabledPlugins.has(t);
   }
-  // Enable a plugin
+  async initialize(t, e, i = {}) {
+    const n = this.plugins.get(t);
+    if (!n)
+      throw new l(t, "initialize", "Plugin not found");
+    this.ensureDependenciesExist(t);
+    const s = { ...this.pluginConfigs.get(t) || {}, ...i };
+    this.pluginConfigs.set(t, s), this.pluginContexts.set(t, e);
+    try {
+      await n.initialize(e, s);
+    } catch (o) {
+      throw this.logger.error(`Failed to initialize plugin '${t}'`, o), this.eventBus.emit("plugin:error", { name: t, error: o }), o;
+    }
+  }
+  async activate(t, e) {
+    const i = this.plugins.get(t);
+    if (!i)
+      throw new l(t, "activate", "Plugin not found");
+    this.ensureDependenciesActive(t), this.ensureNoActiveConflicts(t), this.pluginContexts.set(t, e);
+    try {
+      await i.activate(e), this.enabledPlugins.add(t), this.eventBus.emit("plugin:enabled", { name: t, plugin: i });
+    } catch (n) {
+      throw this.logger.error(`Failed to activate plugin '${t}'`, n), this.eventBus.emit("plugin:error", { name: t, error: n }), n;
+    }
+  }
+  async deactivate(t, e) {
+    const i = this.plugins.get(t);
+    if (!i)
+      throw new l(t, "deactivate", "Plugin not found");
+    this.pluginContexts.set(t, e);
+    try {
+      await i.deactivate(e), this.enabledPlugins.delete(t), this.eventBus.emit("plugin:disabled", { name: t, plugin: i });
+    } catch (n) {
+      throw this.logger.error(`Failed to deactivate plugin '${t}'`, n), this.eventBus.emit("plugin:error", { name: t, error: n }), n;
+    }
+  }
+  async initializeAll(t) {
+    this.validateDependencies();
+    const e = this.getAll().map((i) => this.findPluginKey(i)).filter(Boolean);
+    for (const i of e)
+      await this.initialize(i, t);
+  }
+  async activateAll(t) {
+    const e = this.getAll().map((i) => this.findPluginKey(i)).filter(Boolean);
+    for (const i of e) {
+      const n = this.plugins.get(i);
+      n && (n.isInitialized || await this.initialize(i, t), await this.activate(i, t));
+    }
+  }
+  async deactivateAll(t) {
+    const e = this.getAll().map((i) => this.findPluginKey(i)).filter(Boolean).reverse();
+    for (const i of e)
+      this.enabledPlugins.has(i) && await this.deactivate(i, t);
+  }
+  async destroyAll(t) {
+    await this.deactivateAll(t);
+    const e = Array.from(this.plugins.keys());
+    for (const i of e) {
+      const n = this.plugins.get(i);
+      n && n.isInitialized && await n.destroy(t);
+    }
+    this.plugins.clear(), this.pluginConfigs.clear(), this.pluginContexts.clear(), this.enabledPlugins.clear();
+  }
+  validateDependencies() {
+    for (const [n, s] of this.plugins.entries()) {
+      const o = (s.metadata.dependencies || []).filter(
+        (c) => !this.plugins.has(c)
+      );
+      if (o.length > 0)
+        throw new h(n, o);
+    }
+    const t = /* @__PURE__ */ new Set(), e = /* @__PURE__ */ new Set(), i = (n) => {
+      if (t.has(n)) return;
+      if (e.has(n))
+        throw new l(n, "initialize", "Circular dependency detected");
+      e.add(n);
+      const s = this.plugins.get(n);
+      if (s) {
+        for (const o of s.metadata.dependencies || [])
+          i(o);
+        e.delete(n), t.add(n);
+      }
+    };
+    for (const n of this.plugins.keys())
+      i(n);
+  }
+  validateConflicts() {
+    for (const [t, e] of this.plugins.entries()) {
+      const i = (e.metadata.conflicts || []).filter(
+        (n) => this.plugins.has(n)
+      );
+      if (i.length > 0)
+        throw new f(t, i);
+    }
+  }
+  healthCheck(t) {
+    if (typeof t == "string") {
+      const e = this.plugins.get(t);
+      if (!e) return !1;
+      try {
+        const i = e.onInitializeCalled;
+        return typeof i == "boolean" ? i : e.healthCheck ? !!e.healthCheck() : typeof e.isInitialized == "boolean" ? e.isInitialized : !1;
+      } catch {
+        return !1;
+      }
+    }
+    return this.healthCheckEnabledPlugins();
+  }
+  healthCheckAll() {
+    const t = {};
+    for (const e of this.plugins.keys())
+      t[e] = this.healthCheck(e);
+    return t;
+  }
   async enable(t) {
     const e = this.plugins.get(t);
     if (!e)
@@ -75,14 +404,9 @@ class b {
       this.logger.warn(`Plugin '${t}' is already enabled`);
       return;
     }
-    try {
-      const i = this.createPluginContext(t), n = this.pluginConfigs.get(t);
-      await e.initialize(i, n), await e.activate(i), this.enabledPlugins.add(t), this.logger.info(`Plugin '${t}' enabled successfully`), this.eventBus.emit("plugin:enabled", { name: t, plugin: e });
-    } catch (i) {
-      throw this.logger.error(`Failed to enable plugin '${t}'`, i), this.eventBus.emit("plugin:error", { name: t, error: i }), i;
-    }
+    const i = this.pluginContexts.get(t) || this.createPluginContext(t);
+    e.isInitialized || await this.initialize(t, i), await this.activate(t, i);
   }
-  // Disable a plugin
   async disable(t) {
     const e = this.plugins.get(t);
     if (!e)
@@ -91,14 +415,9 @@ class b {
       this.logger.warn(`Plugin '${t}' is already disabled`);
       return;
     }
-    try {
-      const i = this.createPluginContext(t);
-      await e.deactivate(i), await e.destroy(i), this.enabledPlugins.delete(t), this.logger.info(`Plugin '${t}' disabled successfully`), this.eventBus.emit("plugin:disabled", { name: t, plugin: e });
-    } catch (i) {
-      throw this.logger.error(`Failed to disable plugin '${t}'`, i), this.eventBus.emit("plugin:error", { name: t, error: i }), i;
-    }
+    const i = this.pluginContexts.get(t) || this.createPluginContext(t);
+    await this.deactivate(t, i), await e.destroy(i);
   }
-  // Configure a plugin
   async configure(t, e) {
     const i = this.plugins.get(t);
     if (!i)
@@ -109,41 +428,67 @@ class b {
       throw this.logger.error(`Failed to configure plugin '${t}'`, n), this.eventBus.emit("plugin:error", { name: t, error: n }), n;
     }
   }
-  // Enable multiple plugins with dependency resolution
   async enablePlugins(t) {
     const e = this.resolveDependencies(t);
     for (const i of e)
       this.enabledPlugins.has(i) || await this.enable(i);
   }
-  // Disable multiple plugins
   async disablePlugins(t) {
     const e = [...t].reverse();
     for (const i of e)
       this.enabledPlugins.has(i) && await this.disable(i);
   }
-  // Get enabled plugins
   getEnabledPlugins() {
-    return Array.from(this.enabledPlugins).map((t) => this.plugins.get(t)).filter(Boolean).sort(this.sortByPriority);
+    return this.getActive();
+  }
+  on(t, e) {
+    return this.eventBus.on(t, e), () => this.eventBus.off(t, e);
   }
-  // Health check for all enabled plugins
-  async healthCheck() {
+  async healthCheckEnabledPlugins() {
     const t = [];
     for (const e of this.enabledPlugins) {
       const i = this.plugins.get(e);
-      try {
-        const n = i.healthCheck ? await i.healthCheck() : !0;
-        t.push({ name: e, healthy: n });
-      } catch (n) {
-        t.push({ name: e, healthy: !1, error: n });
-      }
+      if (i)
+        try {
+          const n = i.healthCheck ? i.healthCheck() : !0, s = n instanceof Promise ? await n : !!n;
+          t.push({ name: e, healthy: s });
+        } catch (n) {
+          t.push({ name: e, healthy: !1, error: n });
+        }
     }
     return t;
   }
-  // Event handling
-  on(t, e) {
-    return this.eventBus.on(t, e), () => this.eventBus.off(t, e);
+  findPluginKey(t) {
+    for (const [e, i] of this.plugins.entries())
+      if (i === t) return e;
+  }
+  ensureDependenciesExist(t) {
+    const e = this.plugins.get(t);
+    if (!e) return;
+    const i = (e.metadata.dependencies || []).filter(
+      (n) => !this.plugins.has(n)
+    );
+    if (i.length > 0)
+      throw new h(t, i);
+  }
+  ensureDependenciesActive(t) {
+    const e = this.plugins.get(t);
+    if (!e) return;
+    const i = (e.metadata.dependencies || []).filter(
+      (n) => !this.enabledPlugins.has(n)
+    );
+    if (i.length > 0)
+      throw new h(t, i);
+  }
+  ensureNoActiveConflicts(t) {
+    const e = this.plugins.get(t);
+    if (!e) return;
+    const i = (e.metadata.conflicts || []).filter(
+      (n) => this.enabledPlugins.has(n)
+    );
+    if (i.length > 0)
+      throw new f(t, i);
   }
-  // Create plugin context (will be implemented when we have the full context)
   createPluginContext(t) {
     return {
       state: {},
@@ -155,7 +500,6 @@ class b {
       logger: this.createPluginLogger(t)
     };
   }
-  // Create plugin-specific logger
   createPluginLogger(t) {
     return {
       info: (e, i) => this.logger.info(`[${t}] ${e}`, i),
@@ -164,41 +508,40 @@ class b {
       debug: (e, i) => this.logger.debug(`[${t}] ${e}`, i)
     };
   }
-  // Resolve plugin dependencies
   resolveDependencies(t) {
     const e = [], i = /* @__PURE__ */ new Set(), n = (s) => {
       if (e.includes(s)) return;
       if (i.has(s))
         throw new l(s, "initialize", "Circular dependency detected");
       i.add(s);
-      const c = this.plugins.get(s);
-      if (!c)
+      const o = this.plugins.get(s);
+      if (!o)
         throw new l(s, "initialize", "Plugin not found");
-      for (const u of c.metadata.dependencies || [])
-        n(u);
+      for (const c of o.metadata.dependencies || [])
+        n(c);
       i.delete(s), e.push(s);
     };
     for (const s of t)
       n(s);
     return e;
   }
-  // Sort plugins by priority
   sortByPriority(t, e) {
     const i = {
       high: 3,
       medium: 2,
+      normal: 2,
       low: 1
-    };
-    return i[e.metadata.priority] - i[t.metadata.priority];
+    }, n = i[t.metadata.priority] || 1;
+    return (i[e.metadata.priority] || 1) - n;
   }
 }
 class m {
   constructor(t) {
-    o(this, "metadata");
-    o(this, "context");
-    o(this, "config", {});
-    o(this, "initialized", !1);
-    o(this, "active", !1);
+    a(this, "metadata");
+    a(this, "context");
+    a(this, "config", {});
+    a(this, "initialized", !1);
+    a(this, "active", !1);
     this.metadata = {
       version: "1.0.0",
       ...t
@@ -309,10 +652,10 @@ class m {
     return this.active;
   }
 }
-function k(r) {
+function B(r) {
   return (t) => new r(t);
 }
-class P extends m {
+class C extends m {
   constructor(e) {
     super({
       name: "analytics",
@@ -321,10 +664,10 @@ class P extends m {
       priority: "low",
       author: "BaroiPlayer Team"
     });
-    o(this, "events", []);
-    o(this, "analyticsConfig");
-    o(this, "cleanupFunctions", []);
-    o(this, "reportTimer");
+    a(this, "events", []);
+    a(this, "analyticsConfig");
+    a(this, "cleanupFunctions", []);
+    a(this, "reportTimer");
   }
   onInitialize() {
     if (this.analyticsConfig = this.createConfig({
@@ -456,231 +799,23 @@ class P extends m {
     return this.events.length < 1e3;
   }
 }
-const x = (r) => new P(r);
-class d {
-  constructor(t = "[Plugin]") {
-    o(this, "prefix");
-    this.prefix = t;
-  }
-  info(t, e) {
-    e ? console.info(`${this.prefix} ${t}`, e) : console.info(`${this.prefix} ${t}`);
-  }
-  warn(t, e) {
-    e ? console.warn(`${this.prefix} ${t}`, e) : console.warn(`${this.prefix} ${t}`);
-  }
-  error(t, e) {
-    e ? console.error(`${this.prefix} ${t}`, e) : console.error(`${this.prefix} ${t}`);
-  }
-  debug(t, e) {
-    process.env.NODE_ENV === "development" && (e ? console.debug(`${this.prefix} ${t}`, e) : console.debug(`${this.prefix} ${t}`));
-  }
-}
-class z {
-  static validateMetadata(t) {
-    const { metadata: e } = t;
-    if (!e.name || typeof e.name != "string")
-      throw new Error("Plugin metadata must include a valid name");
-    if (!e.version || typeof e.version != "string")
-      throw new Error("Plugin metadata must include a valid version");
-    if (!e.description || typeof e.description != "string")
-      throw new Error("Plugin metadata must include a valid description");
-    if (!e.category)
-      throw new Error("Plugin metadata must include a valid category");
-    if (!e.priority)
-      throw new Error("Plugin metadata must include a valid priority");
-    return !0;
-  }
-  static validateConfig(t, e) {
-    if (!e) return !0;
-    for (const [i, n] of Object.entries(e)) {
-      const s = t[i];
-      if (n.required && s == null)
-        throw new Error(`Configuration property '${i}' is required`);
-      if (s !== void 0 && n.type && typeof s !== n.type)
-        throw new Error(`Configuration property '${i}' must be of type '${n.type}'`);
-      if (n.enum && !n.enum.includes(s))
-        throw new Error(`Configuration property '${i}' must be one of: ${n.enum.join(", ")}`);
-      if (n.min !== void 0 && typeof s == "number" && s < n.min)
-        throw new Error(`Configuration property '${i}' must be at least ${n.min}`);
-      if (n.max !== void 0 && typeof s == "number" && s > n.max)
-        throw new Error(`Configuration property '${i}' must be at most ${n.max}`);
-    }
-    return !0;
-  }
-}
-class $ {
-  constructor() {
-    o(this, "metrics", /* @__PURE__ */ new Map());
-  }
-  measure(t, e, i) {
-    const n = `${t}.${e}`, s = performance.now(), c = () => {
-      const a = performance.now(), h = a - s, g = this.metrics.get(n) || {
-        calls: 0,
-        totalTime: 0,
-        averageTime: 0,
-        lastCall: 0
-      };
-      g.calls++, g.totalTime += h, g.averageTime = g.totalTime / g.calls, g.lastCall = a, this.metrics.set(n, g);
-    }, u = i();
-    return u instanceof Promise ? u.then(
-      (a) => (c(), a),
-      (a) => {
-        throw c(), a;
-      }
-    ) : (c(), u);
-  }
-  getMetrics(t) {
-    if (t) {
-      const e = {};
-      for (const [i, n] of this.metrics.entries())
-        if (i.startsWith(`${t}.`)) {
-          const s = i.substring(t.length + 1);
-          e[s] = n;
-        }
-      return e;
-    }
-    return Object.fromEntries(this.metrics.entries());
-  }
-  reset(t) {
-    if (t)
-      for (const e of this.metrics.keys())
-        e.startsWith(`${t}.`) && this.metrics.delete(e);
-    else
-      this.metrics.clear();
-  }
-}
-const F = {
-  // Create a mock plugin context for testing
-  createMockContext() {
-    return {
-      state: {
-        isPlaying: !1,
-        currentTime: 0,
-        duration: 0,
-        volume: 1,
-        isMuted: !1,
-        isLoading: !1,
-        error: null
-      },
-      controls: {
-        play: () => Promise.resolve(),
-        pause: () => Promise.resolve(),
-        seek: (r) => Promise.resolve(),
-        setVolume: (r) => Promise.resolve(),
-        mute: () => Promise.resolve(),
-        unmute: () => Promise.resolve(),
-        toggleMute: () => Promise.resolve()
-      },
-      plugins: {
-        get: () => {
-        },
-        getAll: () => [],
-        isEnabled: () => !1
-      },
-      emit: () => {
-      },
-      on: () => () => {
-      },
-      element: null,
-      logger: new d("[MockPlugin]")
-    };
-  },
-  // Create a test plugin for development
-  createTestPlugin(r, t = {}) {
-    return {
-      metadata: {
-        name: r,
-        version: "1.0.0",
-        description: `Test plugin: ${r}`,
-        category: "ui",
-        priority: "medium"
-      },
-      initialize: async () => {
-      },
-      activate: async () => {
-      },
-      deactivate: async () => {
-      },
-      destroy: async () => {
-      },
-      healthCheck: () => !0,
-      ...t
-    };
-  },
-  // Plugin timing utilities
-  time: {
-    async: async (r, t) => {
-      console.time(r);
-      try {
-        const e = await t();
-        return console.timeEnd(r), e;
-      } catch (e) {
-        throw console.timeEnd(r), e;
-      }
-    },
-    sync: (r, t) => {
-      console.time(r);
-      try {
-        const e = t();
-        return console.timeEnd(r), e;
-      } catch (e) {
-        throw console.timeEnd(r), e;
-      }
-    }
-  }
-};
-class I {
-  constructor(t) {
-    o(this, "prefix");
-    this.prefix = `baroi-plugin-${t}`;
-  }
-  get(t, e) {
-    try {
-      const i = localStorage.getItem(`${this.prefix}-${t}`);
-      return i ? JSON.parse(i) : e;
-    } catch {
-      return e;
-    }
-  }
-  set(t, e) {
-    try {
-      localStorage.setItem(`${this.prefix}-${t}`, JSON.stringify(e));
-    } catch (i) {
-      console.warn(`Failed to store plugin data for key: ${t}`, i);
-    }
-  }
-  remove(t) {
-    try {
-      localStorage.removeItem(`${this.prefix}-${t}`);
-    } catch (e) {
-      console.warn(`Failed to remove plugin data for key: ${t}`, e);
-    }
-  }
-  clear() {
-    try {
-      Object.keys(localStorage).filter((e) => e.startsWith(`${this.prefix}-`)).forEach((e) => localStorage.removeItem(e));
-    } catch (t) {
-      console.warn("Failed to clear plugin data", t);
-    }
-  }
-}
-const B = new d(), M = new $(), T = "1.0.0";
+const F = (r) => new C(r), D = "1.0.0";
 export {
-  P as A,
+  C as A,
   m as B,
   d as C,
-  b as P,
-  T as a,
+  I as P,
+  D as a,
   l as b,
-  v as c,
-  w as d,
-  k as e,
-  x as f,
-  z as g,
-  $ as h,
-  F as i,
-  I as j,
-  B as k,
-  M as l
+  h as c,
+  f as d,
+  B as e,
+  F as f,
+  b as g,
+  P as h,
+  k as i,
+  x as j,
+  z as k,
+  A as l
 };
-//# sourceMappingURL=core-plugins-CROGvQUy.js.map
+//# sourceMappingURL=core-plugins-DSBWcTuX.js.map