@shoru/kitten 0.0.4 → 0.0.5

package/package.json

@@ -1,41 +1,42 @@
-{
-  "name": "@shoru/kitten",
-  "type": "module",
-  "version": "0.0.4",
-  "description": "A powerful Node.js framework to simplify making WhatsApp Bots",
-  "main": "src/index.js",
-  "repository": {
-    "url": "git+https://github.com/Mangaka-bot/kitten-wa.git"
-  },
-  "scripts": {
-    "start": "node --no-warnings src/index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "imports": {
-    "#utils.js": "./src/utils/index.js",
-    "#auth.js": "./src/auth/index.js",
-    "#internals.js": "./src/internals/index.js",
-    "#client.js": "./src/client/index.js",
-    "#formatter.js": "./src/formatter/index.js"
-  },
-  "exports": {
-    ".": "./src/index.js"
-  },
-  "author": "Aymane Shoru",
-  "license": "MIT",
-  "dependencies": {
-    "@hapi/boom": "^10.0.1",
-    "@inquirer/prompts": "^8.1.0",
-    "@shoru/spindle": "^1.0.6",
-    "async-mutex": "^0.5.0",
-    "baileys": "^7.0.0-rc.9",
-    "chalk": "^5.6.2",
-    "chokidar": "^5.0.0",
-    "cosmiconfig": "^9.0.0",
-    "defu": "^6.1.4",
-    "lmdb": "^3.4.4",
-    "pino": "^10.1.0",
-    "pino-pretty": "^13.1.3",
-    "qrcode-terminal": "^0.12.0"
-  }
-}
+{
+  "name": "@shoru/kitten",
+  "type": "module",
+  "version": "0.0.5",
+  "description": "A powerful Node.js framework to simplify making WhatsApp Bots",
+  "main": "src/index.js",
+  "repository": {
+    "url": "git+https://github.com/Mangaka-bot/kitten-wa.git"
+  },
+  "scripts": {
+    "start": "node --no-warnings src/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "imports": {
+    "#utils.js": "./src/utils/index.js",
+    "#auth.js": "./src/auth/index.js",
+    "#internals.js": "./src/internals/index.js",
+    "#client.js": "./src/client/index.js",
+    "#formatter.js": "./src/formatter/index.js",
+    "#plugins.js": "./src/plugins/index.js"
+  },
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "author": "Aymane Shoru",
+  "license": "MIT",
+  "dependencies": {
+    "@hapi/boom": "^10.0.1",
+    "@inquirer/prompts": "^8.1.0",
+    "@shoru/spindle": "^1.0.6",
+    "async-mutex": "^0.5.0",
+    "baileys": "^7.0.0-rc.9",
+    "chalk": "^5.6.2",
+    "chokidar": "^5.0.0",
+    "cosmiconfig": "^9.0.0",
+    "defu": "^6.1.4",
+    "lmdb": "^3.4.4",
+    "pino": "^10.1.0",
+    "pino-pretty": "^13.1.3",
+    "qrcode-terminal": "^0.12.0"
+  }
+}

package/src/client/client.js

@@ -2,7 +2,8 @@ import { DisconnectReason } from 'baileys';
 import { Boom } from '@hapi/boom';
 import qrcode from 'qrcode-terminal';
 import chalk from 'chalk';
-import { logger, pino, pluginManager } from '#internals.js';
+import { pluginManager } from '#plugins.js';
+import { logger, pino } from '#internals.js';
 import { initSession, listSessions } from '#auth.js';
 import { getConnectionConfig } from './getConnectionConfig.js';
 

package/src/plugins/config.js

@@ -0,0 +1,25 @@
+import { getConfig } from '#internals.js';
+import path from 'path';
+
+const config = await getConfig();
+
+export const {
+  dir,
+  defaultEvent,
+  prefixes: PREFIXES,
+  hmr: {
+    enable: HMREnabled,
+    debounce: debounceMs,
+    debug: isDebug
+  }
+} = config.plugins;
+
+export const PLUGIN_DIR = path.join(process.cwd(), dir);
+
+export const EVENTS = Object.freeze(new Set([
+  'messaging-history.set', 'chats.upsert', 'chats.update', 'chats.delete',
+  'contacts.upsert', 'contacts.update', 'messages.upsert', 'messages.update',
+  'messages.delete', 'messages.reaction', 'message-receipt.update',
+  'groups.update', 'group-participants.update', 'connection.update',
+  'creds.update', 'presence.update', 'blocklist.set', 'blocklist.update', 'call',
+]));

package/src/plugins/handle-error.js

@@ -0,0 +1,8 @@
+import { logger } from '#internals.js';
+import { isDebug } from './config.js';
+
+export function handleError(context, err) {
+  if (isDebug) {
+    logger.warn(`${context} ${err?.message ?? 'Unknown error'}`);
+  }
+}

package/src/plugins/handlers.js

@@ -0,0 +1,85 @@
+import { formatter } from '#formatter.js';
+import { getBucket } from './registry.js';
+import { test } from './matcher.js';
+import { handleError } from './handle-error.js';
+
+export function createHandler(event, sock, isDestroyed, execute) {
+  const bucket = getBucket(event);
+
+  const dispatch = (ctx) => {
+    if (isDestroyed() || !ctx) return;
+
+    // Execute auto-triggered plugins
+    for (const [id, plugin] of bucket.auto) {
+      execute(id, plugin, sock, ctx, event, null);
+    }
+
+    // Execute pattern-matched plugins
+    if (bucket.match.size && ctx.body) {
+      for (const [id, plugin] of bucket.match) {
+        const matchers = plugin._meta?.matchers;
+        if (!matchers) continue;
+
+        const result = test(matchers, ctx.body);
+        if (result) {
+          execute(id, plugin, sock, ctx, event, result);
+        }
+      }
+    }
+  };
+
+  switch (event) {
+    case 'messages.upsert':
+      return ({ messages, type }) => {
+        if (type !== 'notify') return;
+
+        for (const msg of messages) {
+          if (!msg?.key?.remoteJid || msg.key.remoteJid === 'status@broadcast') {
+            continue;
+          }
+
+          try {
+            dispatch(formatter(sock, msg, event));
+          } catch (err) {
+            handleError('[PluginManager] Format error:', err);
+          }
+        }
+      };
+
+    case 'messages.update':
+      return (updates) => {
+        for (const { key, update } of updates) {
+          if (key?.remoteJid) {
+            dispatch({ key, update, jid: key.remoteJid });
+          }
+        }
+      };
+
+    case 'messages.reaction':
+      return (reactions) => {
+        for (const { key, reaction } of reactions) {
+          if (key?.remoteJid) {
+            dispatch({
+              key,
+              reaction,
+              jid: key.remoteJid,
+              emoji: reaction?.text
+            });
+          }
+        }
+      };
+
+    case 'group-participants.update':
+    case 'connection.update':
+      return (update) => dispatch(update);
+
+    case 'creds.update':
+      return (creds) => dispatch({ creds });
+
+    case 'call':
+      return (calls) => calls.forEach(c => dispatch(c));
+
+    default:
+      return (data) => dispatch({ data });
+  }
+}

package/src/plugins/index.js

@@ -0,0 +1,166 @@
+import { logger } from '#internals.js';
+import { HMREnabled, isDebug } from './config.js';
+import { handleError } from './handle-error.js';
+import {
+  getPlugin,
+  getAllPlugins,
+  getPluginCount,
+  getEventCounts,
+  clear as clearRegistry
+} from './registry.js';
+import { loadAll, clearLocks } from './loader.js';
+import { initWatcher, closeWatcher, clearTimers, onSync } from './watcher.js';
+import { createHandler } from './handlers.js';
+
+const instances = new Set();
+
+let ready = false;
+
+function syncAllInstances() {
+  for (const instance of instances) {
+    instance._syncListeners();
+  }
+}
+
+function cleanup() {
+  closeWatcher();
+  clearTimers();
+  clearLocks();
+  clearRegistry();
+  ready = false;
+}
+
+export class PluginManager {
+  #sock;
+  #handlers = new Map();
+  #destroyed = false;
+
+  constructor(sock) {
+    if (!sock?.ev) {
+      throw new TypeError('Invalid socket: missing ev property');
+    }
+    this.#sock = sock;
+  }
+
+  async init() {
+    if (this.#destroyed) {
+      throw new Error('Cannot reinitialize destroyed instance');
+    }
+
+    instances.add(this);
+
+    if (!ready) {
+      await loadAll();
+
+      if (HMREnabled) {
+        initWatcher();
+        onSync(syncAllInstances);
+      }
+
+      ready = true;
+    }
+
+    this._syncListeners();
+
+    if (isDebug) {
+      logger.debug(
+        `[PluginManager] Init (sockets: ${instances.size}, plugins: ${getPluginCount()})`
+      );
+    }
+
+    return this;
+  }
+
+  destroy() {
+    if (this.#destroyed) return;
+    this.#destroyed = true;
+
+    for (const [event, handler] of this.#handlers) {
+      this.#sock.ev.off(event, handler);
+    }
+
+    this.#handlers.clear();
+    instances.delete(this);
+
+    if (instances.size === 0) {
+      cleanup();
+    }
+  }
+
+  _syncListeners() {
+    if (this.#destroyed) return;
+
+    const eventCounts = getEventCounts();
+    const activeEvents = new Set();
+
+    for (const [event, count] of eventCounts) {
+      if (count > 0) activeEvents.add(event);
+    }
+
+    // Remove inactive events
+    for (const [event, handler] of this.#handlers) {
+      if (!activeEvents.has(event)) {
+        this.#sock.ev.off(event, handler);
+        this.#handlers.delete(event);
+        if (isDebug) logger.debug(`[Events] (-) ${event}`);
+      }
+    }
+
+    // Add active events
+    for (const event of activeEvents) {
+      if (!this.#handlers.has(event)) {
+        const handler = createHandler(
+          event,
+          this.#sock,
+          () => this.#destroyed,
+          this.#execute.bind(this)
+        );
+
+        this.#sock.ev.on(event, handler);
+        this.#handlers.set(event, handler);
+        if (isDebug) logger.debug(`[Events] (+) ${event}`);
+      }
+    }
+  }
+
+  async #execute(id, plugin, sock, ctx, event, match) {
+    if (this.#destroyed) return;
+
+    try {
+      const context = match ? { ...ctx, _match: match } : ctx;
+      await plugin(sock, context, event);
+    } catch (err) {
+      handleError(`[Plugin:${id}]`, err);
+    }
+  }
+
+  get(id) {
+    return getPlugin(id);
+  }
+
+  get all() {
+    return new Map(getAllPlugins());
+  }
+
+  get events() {
+    return [...this.#handlers.keys()];
+  }
+
+  get destroyed() {
+    return this.#destroyed;
+  }
+
+  static get instances() {
+    return instances.size;
+  }
+
+  static get count() {
+    return getPluginCount();
+  }
+}
+
+export async function pluginManager(sock) {
+  const manager = new PluginManager(sock);
+  await manager.init();
+  return manager;
+}

package/src/plugins/loader.js

@@ -0,0 +1,132 @@
+import { Mutex } from 'async-mutex';
+import { logger } from '#internals.js';
+import fs from 'fs/promises';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { PLUGIN_DIR, EVENTS, defaultEvent } from './config.js';
+import { handleError } from './handle-error.js';
+import { compile } from './matcher.js';
+import { setPlugin, registerToBuckets } from './registry.js';
+
+const fileLocks = new Map();
+
+export function getLock(filePath) {
+  let lock = fileLocks.get(filePath);
+  if (!lock) {
+    lock = new Mutex();
+    fileLocks.set(filePath, lock);
+  }
+  return lock;
+}
+
+export function deleteLockIfUnused(filePath) {
+  const lock = fileLocks.get(filePath);
+  if (lock && !lock.isLocked()) {
+    fileLocks.delete(filePath);
+  }
+}
+
+export function clearLocks() {
+  fileLocks.clear();
+}
+
+export function getParentFolder(dirPath) {
+  return path.relative(PLUGIN_DIR, dirPath).split(path.sep)[0] || null;
+}
+
+function normalize(value) {
+  if (typeof value === 'function') return value;
+
+  if (typeof value?.default === 'function') {
+    const { default: fn, ...rest } = value;
+    return Object.assign(fn, rest);
+  }
+
+  return null;
+}
+
+export async function loadFile(filePath, parent, shouldRegister = true) {
+  const execute = async () => {
+    const { mtimeMs } = await fs.stat(filePath);
+    const mod = await import(`${pathToFileURL(filePath)}?v=${Math.trunc(mtimeMs)}`);
+    const loaded = new Map();
+
+    for (const [name, value] of Object.entries(mod)) {
+      const plugin = normalize(value);
+      if (!plugin || plugin.enabled === false) continue;
+
+      const id = path.relative(PLUGIN_DIR, filePath)
+        .replace(/\.[jt]s$/, '')
+        .replaceAll(path.sep, '/') + ':' + name;
+
+      const events = (Array.isArray(plugin.events) ? plugin.events : [])
+        .filter(e => EVENTS.has(e));
+
+      plugin._meta = {
+        parent,
+        filePath,
+        id,
+        events: events.length ? events : [defaultEvent],
+        matchers: compile(plugin.match, plugin.prefix),
+      };
+
+      if (shouldRegister) {
+        setPlugin(id, plugin);
+        registerToBuckets(id, plugin);
+      }
+
+      loaded.set(id, plugin);
+    }
+
+    return loaded;
+  };
+
+  return shouldRegister
+    ? getLock(filePath).runExclusive(execute)
+    : execute();
+}
+
+export async function loadAll() {
+  await fs.mkdir(PLUGIN_DIR, { recursive: true }).catch(() => {});
+
+  const entries = await fs.readdir(PLUGIN_DIR, {
+    withFileTypes: true,
+    recursive: true
+  }).catch(() => []);
+
+  const files = entries
+    .filter(e =>
+      e.isFile() &&
+      /(?<!\.d)\.[jt]s$/.test(e.name) &&
+      !e.name.startsWith('_')
+    )
+    .map(e => {
+      const dirPath = e.parentPath ?? e.path;
+      return {
+        path: path.join(dirPath, e.name),
+        parent: getParentFolder(dirPath)
+      };
+    });
+
+  const results = await Promise.allSettled(
+    files.map(({ path: p, parent }) => loadFile(p, parent))
+  );
+
+  let loaded = 0;
+  let failed = 0;
+
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result.status === 'fulfilled') {
+      loaded += result.value?.size ?? 0;
+    } else {
+      failed++;
+      const rel = path.relative(PLUGIN_DIR, files[i].path);
+      handleError(`[PluginManager:${rel}] Failed to load:`, result.reason);
+    }
+  }
+
+  logger.info(
+    `[PluginManager] Loaded ${loaded} plugins${failed ? ` (${failed} failed)` : ''}`
+  );
+}

package/src/plugins/matcher.js

@@ -0,0 +1,59 @@
+import { PREFIXES } from './config.js';
+
+export function compile(match, prefixOpt = PREFIXES) {
+  if (!Array.isArray(match) || !match.length) return null;
+
+  const strings = match
+    .filter(m => typeof m === 'string')
+    .map(s => s.toLowerCase());
+
+  const regexes = match.filter(m => m instanceof RegExp);
+
+  const prefixes = prefixOpt === false
+    ? null
+    : new Set([prefixOpt ?? PREFIXES].flat());
+
+  return {
+    strings,
+    set: strings.length ? new Set(strings) : null,
+    regexes,
+    prefixes,
+  };
+}
+
+export function test(matchers, body) {
+  if (!body || typeof body !== 'string') return null;
+
+  const text = body.toLowerCase();
+
+  if (matchers.set) {
+    const prefix = text[0];
+    const prefixValid = !matchers.prefixes || matchers.prefixes.has(prefix);
+
+    if (prefixValid) {
+      const rest = text.slice(1);
+      const idx = rest.indexOf(' ');
+      const cmd = idx < 0 ? rest : rest.slice(0, idx);
+
+      if (cmd) {
+        if (matchers.set.has(cmd)) {
+          return { match: cmd, prefix };
+        }
+
+        for (const s of matchers.strings) {
+          if (cmd.length > s.length && cmd.startsWith(s)) {
+            return { match: s, prefix };
+          }
+        }
+      }
+    }
+  }
+
+  for (const re of matchers.regexes) {
+    re.lastIndex = 0;
+    const m = re.exec(body);
+    if (m) return { match: m, prefix: null };
+  }
+
+  return null;
+}

package/src/plugins/registry.js

@@ -0,0 +1,95 @@
+import { EVENTS } from './config.js';
+
+const plugins = new Map();
+
+const eventCounts = new Map([...EVENTS].map(e => [e, 0]));
+
+const buckets = Object.fromEntries(
+  [...EVENTS].map(e => [e, { auto: new Map(), match: new Map() }])
+);
+
+// Plugin Map Operations
+
+export function getPlugin(id) {
+  return plugins.get(id);
+}
+
+export function setPlugin(id, plugin) {
+  plugins.set(id, plugin);
+}
+
+export function deletePlugin(id) {
+  plugins.delete(id);
+}
+
+export function getAllPlugins() {
+  return plugins;
+}
+
+export function getPluginCount() {
+  return plugins.size;
+}
+
+// Bucket Operations
+
+export function getBucket(event) {
+  return buckets[event];
+}
+
+export function getEventCounts() {
+  return eventCounts;
+}
+
+export function registerToBuckets(id, plugin) {
+  const key = plugin._meta.matchers ? 'match' : 'auto';
+
+  for (const event of plugin._meta.events) {
+    const bucket = buckets[event]?.[key];
+    if (bucket && !bucket.has(id)) {
+      bucket.set(id, plugin);
+      eventCounts.set(event, (eventCounts.get(event) ?? 0) + 1);
+    }
+  }
+}
+
+export function unregisterFromBuckets(id) {
+  const plugin = plugins.get(id);
+  const events = plugin?._meta?.events ?? [];
+
+  for (const event of events) {
+    const bucket = buckets[event];
+    if (bucket?.auto.delete(id) || bucket?.match.delete(id)) {
+      eventCounts.set(event, Math.max(0, (eventCounts.get(event) ?? 1) - 1));
+    }
+  }
+}
+
+export function unloadByFilePath(filePath) {
+  const idsToUnload = [];
+
+  for (const [id, plugin] of plugins) {
+    if (plugin._meta?.filePath === filePath) {
+      idsToUnload.push(id);
+    }
+  }
+
+  for (const id of idsToUnload) {
+    unregisterFromBuckets(id);
+    plugins.delete(id);
+  }
+
+  return idsToUnload.length;
+}
+
+export function clear() {
+  plugins.clear();
+
+  for (const bucket of Object.values(buckets)) {
+    bucket.auto.clear();
+    bucket.match.clear();
+  }
+
+  for (const event of EVENTS) {
+    eventCounts.set(event, 0);
+  }
+}

package/src/plugins/watcher.js

@@ -0,0 +1,99 @@
+import { watch } from 'chokidar';
+import { logger } from '#internals.js';
+import path from 'path';
+import { PLUGIN_DIR, debounceMs } from './config.js';
+import { handleError } from './handle-error.js';
+import { loadFile, getLock, getParentFolder, deleteLockIfUnused } from './loader.js';
+import { setPlugin, registerToBuckets, unloadByFilePath } from './registry.js';
+
+let watcher = null;
+
+const debounceTimers = new Map();
+
+let syncCallback = null;
+
+export function onSync(callback) {
+  syncCallback = callback;
+}
+
+export function initWatcher() {
+  if (watcher) return;
+
+  watcher = watch(PLUGIN_DIR, {
+    persistent: true,
+    ignoreInitial: true,
+    ignored: [
+      /(^|[/\\])_/,
+      /\.d\.[jt]s$/,
+      /node_modules/,
+      /(^|[/\\])\../
+    ],
+    awaitWriteFinish: {
+      stabilityThreshold: 100,
+      pollInterval: 20
+    },
+  })
+    .on('add', p => scheduleHMR(p, 'add'))
+    .on('change', p => scheduleHMR(p, 'change'))
+    .on('unlink', p => scheduleHMR(p, 'unlink'))
+    .on('error', err => handleError('[Watcher]', err));
+}
+
+export function closeWatcher() {
+  watcher?.close();
+  watcher = null;
+}
+
+export function clearTimers() {
+  debounceTimers.forEach(clearTimeout);
+  debounceTimers.clear();
+}
+
+function scheduleHMR(filePath, type) {
+  clearTimeout(debounceTimers.get(filePath));
+
+  debounceTimers.set(
+    filePath,
+    setTimeout(() => {
+      debounceTimers.delete(filePath);
+      executeHMR(filePath, type);
+    }, debounceMs)
+  );
+}
+
+async function executeHMR(filePath, type) {
+  const rel = path.relative(PLUGIN_DIR, filePath);
+
+  try {
+    await getLock(filePath).runExclusive(async () => {
+      if (type === 'unlink') {
+        const count = unloadByFilePath(filePath);
+        logger.info(`[HMR] Unloaded: ${rel} (${count})`);
+      } else {
+        // Load new plugins without registering
+        const parent = getParentFolder(path.dirname(filePath));
+        const loaded = await loadFile(filePath, parent, false);
+
+        // Remove old plugins for this file
+        unloadByFilePath(filePath);
+
+        // Register newly loaded plugins
+        for (const [id, plugin] of loaded) {
+          setPlugin(id, plugin);
+          registerToBuckets(id, plugin);
+        }
+
+        const action = type === 'add' ? 'Added' : 'Reloaded';
+        logger.info(`[HMR] ${action}: ${rel} (${loaded.size})`);
+      }
+
+      syncCallback?.();
+    });
+  } catch (err) {
+    handleError(`[HMR:${rel}] Failed:`, err);
+  } finally {
+    if (type === 'unlink') {
+      deleteLockIfUnused(filePath);
+    }
+  }
+}

package/src/internals/plugin-manager.js

@@ -1,477 +0,0 @@
-import { Mutex } from 'async-mutex';
-import { getConfig, logger } from '#internals.js';
-import { watch } from 'chokidar';
-import fs from 'fs/promises';
-import path from 'path';
-import { pathToFileURL } from 'url';
-import { formatter } from '#formatter.js';
-
-const config = await getConfig();
-
-const {
-  dir,
-  defaultEvent,
-  prefixes: PREFIXES,
-  hmr: {
-    enable: HMREnabled,
-    debounce: debounceMs,
-    debug: isDebug
-  }
-} = config.plugins;
-
-const PLUGIN_DIR = path.join(process.cwd(), dir);
-
-const EVENTS = new Set([
-  'messaging-history.set', 'chats.upsert', 'chats.update', 'chats.delete',
-  'contacts.upsert', 'contacts.update', 'messages.upsert', 'messages.update',
-  'messages.delete', 'messages.reaction', 'message-receipt.update',
-  'groups.update', 'group-participants.update', 'connection.update',
-  'creds.update', 'presence.update', 'blocklist.set', 'blocklist.update', 'call',
-]);
-
-const createBuckets = () => Object.fromEntries(
-  [...EVENTS].map(e => [e, { auto: new Map(), match: new Map() }])
-);
-
-export class PluginManager {
-  static #plugins = new Map();
-  static #watcher = null;
-  static #ready = false;
-  static #debounceTimers = new Map();
-  static #instances = new Set();
-  static #fileLocks = new Map();
-  static #buckets = createBuckets();
-  static #eventCounts = new Map([...EVENTS].map(e => [e, 0]));
-
-  #sock;
-  #handlers = new Map();
-  #destroyed = false;
-
-  constructor(sock) {
-    if (!sock?.ev) throw new TypeError('Invalid socket: missing ev property');
-    this.#sock = sock;
-  }
-
-  static #getLock(filePath) {
-    return PluginManager.#fileLocks.get(filePath)
-      ?? PluginManager.#fileLocks.set(filePath, new Mutex()).get(filePath);
-  }
-
-  static #handleError(context, err) {
-    if (isDebug) {
-      logger.warn(`${context} ${err?.message ?? 'Unknown error'}`);
-    }
-  }
-
-  async init() {
-    if (this.#destroyed) throw new Error('Cannot reinitialize destroyed instance');
-
-    PluginManager.#instances.add(this);
-
-    if (!PluginManager.#ready) {
-      await fs.mkdir(PLUGIN_DIR, { recursive: true }).catch(() => {});
-      await PluginManager.#loadAll();
-      if (HMREnabled) PluginManager.#initWatcher();
-      PluginManager.#ready = true;
-    }
-
-    this.#syncListeners();
-    if (isDebug) {
-      logger.debug(`[PluginManager] Init (sockets: ${PluginManager.#instances.size}, plugins: ${PluginManager.#plugins.size})`);
-    }
-    return this;
-  }
-
-  destroy() {
-    if (this.#destroyed) return;
-    this.#destroyed = true;
-
-    for (const [event, handler] of this.#handlers) {
-      this.#sock.ev.off(event, handler);
-    }
-    this.#handlers.clear();
-    PluginManager.#instances.delete(this);
-
-    if (PluginManager.#instances.size === 0) {
-      PluginManager.#cleanup();
-    }
-  }
-
-  static #cleanup() {
-    PluginManager.#watcher?.close();
-    PluginManager.#watcher = null;
-    PluginManager.#ready = false;
-    PluginManager.#debounceTimers.forEach(clearTimeout);
-    PluginManager.#debounceTimers.clear();
-    PluginManager.#fileLocks.clear();
-    PluginManager.#plugins.clear();
-
-    for (const bucket of Object.values(PluginManager.#buckets)) {
-      bucket.auto.clear();
-      bucket.match.clear();
-    }
-
-    for (const event of EVENTS) {
-      PluginManager.#eventCounts.set(event, 0);
-    }
-  }
-
-  static #getParent(dirPath) {
-    return path.relative(PLUGIN_DIR, dirPath).split(path.sep)[0] || null;
-  }
-
-  static async #loadAll() {
-    const entries = await fs.readdir(PLUGIN_DIR, { withFileTypes: true, recursive: true }).catch(() => []);
-
-    const files = entries
-      .filter(e => e.isFile() && /(?<!\.d)\.[jt]s$/.test(e.name) && !e.name.startsWith('_'))
-      .map(e => {
-        const dirPath = e.parentPath ?? e.path;
-        const parent = PluginManager.#getParent(dirPath);
-        const filePath = path.join(dirPath, e.name);
-        return { path: filePath, parent };
-      });
-
-    const results = await Promise.allSettled(
-      files.map(({ path: p, parent }) => PluginManager.#loadFile(p, parent))
-    );
-
-    let loaded = 0;
-    let failed = 0;
-    
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i];
-      if (result.status === 'fulfilled') {
-        loaded += result.value?.size ?? 0;
-      } else {
-        failed++;
-        const rel = path.relative(PLUGIN_DIR, files[i].path);
-        PluginManager.#handleError(`[PluginManager:${rel}] Failed to load:`, result.reason);
-      }
-    }
-
-    logger.info(`[PluginManager] Loaded ${loaded} plugins${failed ? ` (${failed} failed)` : ''}`);
-  }
-
-  static async #loadFile(filePath, parent, register = true) {
-    const exec = async () => {
-      const { mtimeMs } = await fs.stat(filePath);
-      const mod = await import(`${pathToFileURL(filePath)}?v=${Math.trunc(mtimeMs)}`);
-      const loaded = new Map();
-
-      for (const [name, value] of Object.entries(mod)) {
-        const plugin = PluginManager.#normalize(value);
-        if (!plugin || plugin.enabled === false) continue;
-
-        const id = path.relative(PLUGIN_DIR, filePath)
-          .replace(/\.[jt]s$/, '')
-          .replaceAll(path.sep, '/') + ':' + name;
-
-        const events = (Array.isArray(plugin.events) ? plugin.events : [])
-          .filter(e => EVENTS.has(e));
-
-        plugin._meta = {
-          parent,
-          filePath,
-          id,
-          events: events.length ? events : [defaultEvent],
-          matchers: PluginManager.#compile(plugin.match, plugin.prefix),
-        };
-
-        if (register) {
-          PluginManager.#plugins.set(id, plugin);
-          PluginManager.#register(id, plugin);
-        }
-        loaded.set(id, plugin);
-      }
-      return loaded;
-    };
-
-    return register ? PluginManager.#getLock(filePath).runExclusive(exec) : exec();
-  }
-
-  static #normalize(value) {
-    if (typeof value === 'function') return value;
-    if (typeof value?.default === 'function') {
-      const { default: fn, ...rest } = value;
-      return Object.assign(fn, rest);
-    }
-    return null;
-  }
-
-  static #compile(match, prefixOpt = PREFIXES) {
-    if (!Array.isArray(match) || !match.length) return null;
-
-    const strings = match.filter(m => typeof m === 'string').map(s => s.toLowerCase());
-    const regexes = match.filter(m => m instanceof RegExp);
-
-    const prefixes = prefixOpt === false
-      ? null
-      : new Set([prefixOpt ?? PREFIXES].flat());
-
-    return {
-      strings,
-      set: strings.length ? new Set(strings) : null,
-      regexes,
-      prefixes,
-    };
-  }
-
-  static #test(matchers, body) {
-    if (!body || typeof body !== 'string') return null;
-
-    const text = body.toLowerCase();
-
-    if (matchers.set) {
-      const prefix = text[0];
-      const prefixValid = !matchers.prefixes || matchers.prefixes.has(prefix);
-
-      if (prefixValid) {
-        const rest = text.slice(1);
-        const idx = rest.indexOf(' ');
-        const cmd = idx < 0 ? rest : rest.slice(0, idx);
-
-        if (cmd) {
-          if (matchers.set.has(cmd)) {
-            return { match: cmd, prefix };
-          }
-
-          for (const s of matchers.strings) {
-            if (cmd.length > s.length && cmd.startsWith(s)) {
-              return { match: s, prefix };
-            }
-          }
-        }
-      }
-    }
-
-    for (const re of matchers.regexes) {
-      re.lastIndex = 0;
-      const m = re.exec(body);
-      if (m) return { match: m, prefix: null };
-    }
-
-    return null;
-  }
-
-  static #register(id, plugin) {
-    const key = plugin._meta.matchers ? 'match' : 'auto';
-    for (const e of plugin._meta.events) {
-      const bucket = PluginManager.#buckets[e]?.[key];
-      if (bucket && !bucket.has(id)) {
-        bucket.set(id, plugin);
-        PluginManager.#eventCounts.set(e, (PluginManager.#eventCounts.get(e) ?? 0) + 1);
-      }
-    }
-  }
-
-  static #unregister(id) {
-    const events = PluginManager.#plugins.get(id)?._meta?.events ?? [];
-    for (const e of events) {
-      const bucket = PluginManager.#buckets[e];
-      if (bucket?.auto.delete(id) || bucket?.match.delete(id)) {
-        PluginManager.#eventCounts.set(e, Math.max(0, (PluginManager.#eventCounts.get(e) ?? 1) - 1));
-      }
-    }
-  }
-
-  #syncListeners() {
-    if (this.#destroyed) return;
-
-    const active = new Set();
-    for (const [event, count] of PluginManager.#eventCounts) {
-      if (count > 0) active.add(event);
-    }
-
-    for (const [event, handler] of this.#handlers) {
-      if (!active.has(event)) {
-        this.#sock.ev.off(event, handler);
-        this.#handlers.delete(event);
-        if (isDebug) logger.debug(`[Events] (-) ${event}`);
-      }
-    }
-
-    for (const event of active) {
-      if (!this.#handlers.has(event)) {
-        const handler = this.#createHandler(event);
-        this.#sock.ev.on(event, handler);
-        this.#handlers.set(event, handler);
-        if (isDebug) logger.debug(`[Events] (+) ${event}`);
-      }
-    }
-  }
-
-  static #syncAll() {
-    for (const instance of PluginManager.#instances) {
-      instance.#syncListeners();
-    }
-  }
-
-  #createHandler(event) {
-    const bucket = PluginManager.#buckets[event];
-    const sock = this.#sock;
-    const dispatch = (ctx, event) => this.#dispatch(sock, ctx, bucket, event);
-
-    const handlers = {
-      'messages.upsert': ({ messages, type }) => {
-        if (type !== 'notify') return;
-        for (const msg of messages) {
-          if (!msg?.key?.remoteJid || msg.key.remoteJid === 'status@broadcast') continue;
-          try {
-            dispatch(formatter(sock, msg, event));
-          } catch (err) {
-            PluginManager.#handleError('[PluginManager] Format error:', err);
-          }
-        }
-      },
-
-      'messages.update': (updates) => {
-        for (const { key, update } of updates) {
-          if (key?.remoteJid) dispatch({ key, update, jid: key.remoteJid }, event);
-        }
-      },
-
-      'messages.reaction': (reactions) => {
-        for (const { key, reaction } of reactions) {
-          if (key?.remoteJid) dispatch({ key, reaction, jid: key.remoteJid, emoji: reaction?.text }, event);
-        }
-      },
-
-      'group-participants.update': (u) => dispatch(u, event),
-      'connection.update': (u) => dispatch(u, event),
-      'creds.update': (creds) => dispatch({ creds }, event),
-      'call': (calls) => calls.forEach(c => dispatch(c, event)),
-    };
-
-    return handlers[event] ?? ((data) => dispatch({ data }, event));
-  }
-
-  #dispatch(sock, ctx, bucket, event) {
-    if (this.#destroyed || !ctx) return;
-
-    for (const [id, plugin] of bucket.auto) {
-      this.#execute(id, plugin, sock, ctx, event);
-    }
-
-    if (bucket.match.size && ctx.body) {
-      for (const [id, plugin] of bucket.match) {
-        const matchers = plugin._meta?.matchers;
-        if (!matchers) continue;
-
-        const result = PluginManager.#test(matchers, ctx.body);
-        if (result) this.#execute(id, plugin, sock, ctx, event, result);
-      }
-    }
-  }
-
-  async #execute(id, plugin, sock, ctx, event, match) {
-    if (this.#destroyed) return;
-    try {
-      await plugin(sock, match ? { ...ctx, _match: match } : ctx, event);
-    } catch (err) {
-      PluginManager.#handleError(`[Plugin:${id}]`, err);
-    }
-  }
-
-  static #initWatcher() {
-    if (PluginManager.#watcher) return;
-
-    PluginManager.#watcher = watch(PLUGIN_DIR, {
-      persistent: true,
-      ignoreInitial: true,
-      ignored: [/(^|[/\\])_/, /\.d\.[jt]s$/, /node_modules/, /(^|[/\\])\../],
-      awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 20 },
-    })
-      .on('add', p => PluginManager.#debounce(p, 'add'))
-      .on('change', p => PluginManager.#debounce(p, 'change'))
-      .on('unlink', p => PluginManager.#debounce(p, 'unlink'))
-      .on('error', e => PluginManager.#handleError('[Watcher]', e));
-  }
-
-  static #debounce(filePath, type) {
-    clearTimeout(PluginManager.#debounceTimers.get(filePath));
-    PluginManager.#debounceTimers.set(
-      filePath,
-      setTimeout(() => {
-        PluginManager.#debounceTimers.delete(filePath);
-        PluginManager.#hmr(filePath, type);
-      }, debounceMs)
-    );
-  }
-
-  static async #hmr(filePath, type) {
-    const rel = path.relative(PLUGIN_DIR, filePath);
-
-    try {
-      await PluginManager.#getLock(filePath).runExclusive(async () => {
-        if (type === 'unlink') {
-          const n = PluginManager.#unloadFile(filePath);
-          logger.info(`[HMR] Unloaded: ${rel} (${n})`);
-        } else {
-          const parent = PluginManager.#getParent(path.dirname(filePath));
-          const plugins = await PluginManager.#loadFile(filePath, parent, false);
-
-          PluginManager.#unloadFile(filePath);
-
-          for (const [id, plugin] of plugins) {
-            PluginManager.#plugins.set(id, plugin);
-            PluginManager.#register(id, plugin);
-          }
-
-          logger.info(`[HMR] ${type === 'add' ? 'Added' : 'Reloaded'}: ${rel} (${plugins.size})`);
-        }
-
-        PluginManager.#syncAll();
-      });
-    } catch (err) {
-      PluginManager.#handleError(`[HMR:${rel}] Failed:`, err);
-    } finally {
-      if (type === 'unlink') {
-        const lock = PluginManager.#fileLocks.get(filePath);
-        if (lock && !lock.isLocked()) PluginManager.#fileLocks.delete(filePath);
-      }
-    }
-  }
-
-  static #unloadFile(filePath) {
-    let count = 0;
-    for (const [id, plugin] of PluginManager.#plugins) {
-      if (plugin._meta?.filePath === filePath) {
-        PluginManager.#unregister(id);
-        PluginManager.#plugins.delete(id);
-        count++;
-      }
-    }
-    return count;
-  }
-
-  get(id) {
-    return PluginManager.#plugins.get(id);
-  }
-
-  get all() {
-    return new Map(PluginManager.#plugins);
-  }
-
-  get events() {
-    return [...this.#handlers.keys()];
-  }
-
-  get destroyed() {
-    return this.#destroyed;
-  }
-
-  static get instances() {
-    return PluginManager.#instances.size;
-  }
-
-  static get count() {
-    return PluginManager.#plugins.size;
-  }
-}
-
-export const pluginManager = async (sock) => {
-  const manager = new PluginManager(sock);
-  await manager.init();
-  return manager;
-}