@whanext/core 0.3.0

package/dist/index.js

@@ -0,0 +1,1988 @@
+// src/cache/memory-cache.ts
+var MemoryCache = class {
+  #entries = /* @__PURE__ */ new Map();
+  async get(key) {
+    const entry = this.#entries.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) {
+      this.#entries.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttlMs) {
+    const entry = { value };
+    if (ttlMs !== void 0) {
+      entry.expiresAt = Date.now() + ttlMs;
+    }
+    this.#entries.set(key, entry);
+  }
+  async delete(key) {
+    this.#entries.delete(key);
+  }
+  async clear() {
+    this.#entries.clear();
+  }
+};
+
+// src/errors/error.ts
+var WhaNextError = class extends Error {
+  code;
+  context;
+  recoverable;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "WhaNextError";
+    this.code = code;
+    this.context = options.context ?? {};
+    this.recoverable = options.recoverable ?? false;
+  }
+};
+function toWhaNextError(error, context) {
+  if (error instanceof WhaNextError) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : "An unknown error occurred.";
+  return new WhaNextError("UNKNOWN_ERROR", message, {
+    cause: error,
+    ...context ? { context } : {}
+  });
+}
+
+// src/models/identity.ts
+function normalizeIdentity(identity) {
+  const value = identity.trim().toLowerCase();
+  const separator = value.lastIndexOf("@");
+  if (separator === -1) {
+    return value.replace(/\D/g, "");
+  }
+  const user = value.slice(0, separator).replace(/:\d+$/, "");
+  const rawServer = value.slice(separator + 1);
+  const server = rawServer === "c.us" ? "s.whatsapp.net" : rawServer;
+  return `${user}@${server}`;
+}
+function identityUsername(identity) {
+  const normalized = normalizeIdentity(identity);
+  const separator = normalized.lastIndexOf("@");
+  return separator === -1 ? normalized : normalized.slice(0, separator);
+}
+function identityPhoneNumber(identity) {
+  const normalized = normalizeIdentity(identity);
+  if (normalized.endsWith("@lid")) {
+    return void 0;
+  }
+  const username = identityUsername(normalized);
+  return /^\d+$/.test(username) ? username : void 0;
+}
+function identitiesMatch(left, right) {
+  return normalizeIdentity(left) === normalizeIdentity(right);
+}
+function uniqueIdentities(identities) {
+  const values = identities.filter((identity) => Boolean(identity));
+  return [...new Map(values.map((identity) => [normalizeIdentity(identity), identity])).values()];
+}
+
+// src/models/user.ts
+var User = class _User {
+  id;
+  identities;
+  jid;
+  lid;
+  phoneNumber;
+  name;
+  constructor(data) {
+    const identities = uniqueIdentities([
+      data.id,
+      data.jid,
+      data.lid,
+      data.phoneNumber,
+      ...data.identities ?? []
+    ]);
+    this.jid = data.jid ?? identities.find((identity) => identity.endsWith("@s.whatsapp.net") || identity.endsWith("@c.us"));
+    this.lid = data.lid ?? identities.find((identity) => identity.endsWith("@lid"));
+    this.phoneNumber = data.phoneNumber ?? this.jid;
+    this.name = data.name;
+    this.id = this.jid ?? this.phoneNumber ?? this.lid ?? data.id;
+    this.identities = identities;
+  }
+  get mentionId() {
+    return this.jid ?? this.phoneNumber ?? this.lid ?? this.id;
+  }
+  get mention() {
+    return `@${this.username}`;
+  }
+  get phone() {
+    return this.phoneNumber ? identityPhoneNumber(this.phoneNumber) : void 0;
+  }
+  get username() {
+    return identityUsername(this.mentionId);
+  }
+  get displayName() {
+    return this.name ?? this.mention;
+  }
+  matches(identity) {
+    const candidates = typeof identity === "string" ? [identity] : identity.identities;
+    return this.identities.some((ownIdentity) => candidates.some((candidate) => identitiesMatch(ownIdentity, candidate)));
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      identities: this.identities,
+      ...this.jid ? { jid: this.jid } : {},
+      ...this.lid ? { lid: this.lid } : {},
+      ...this.phoneNumber ? { phoneNumber: this.phoneNumber } : {},
+      ...this.name ? { name: this.name } : {}
+    };
+  }
+  static fromIdentities(identities) {
+    const [id] = identities;
+    if (!id) {
+      throw new TypeError("A user requires at least one identity.");
+    }
+    return new _User({ id, identities });
+  }
+  static fromPhoneNumber(phoneNumber) {
+    const normalized = phoneNumber.replace(/\D/g, "");
+    if (normalized.length < 8) {
+      throw new TypeError("A user phone number must include country and area codes.");
+    }
+    return _User.fromIdentities([`${normalized}@s.whatsapp.net`]);
+  }
+};
+
+// src/commands/args-parser.ts
+var ArgsParser = class {
+  #values;
+  #cursor = 0;
+  constructor(values) {
+    this.#values = [...values];
+  }
+  get remaining() {
+    return this.#values.length - this.#cursor;
+  }
+  peek() {
+    return this.#values[this.#cursor];
+  }
+  skip(count = 1) {
+    this.#cursor = Math.min(this.#values.length, this.#cursor + Math.max(0, count));
+    return this;
+  }
+  string(name = "argument", options = {}) {
+    return this.#consume(name, options);
+  }
+  number(name = "number", options = {}) {
+    const raw = this.#consume(name, options);
+    if (raw === void 0) {
+      return void 0;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+      throw new WhaNextError("ARGUMENT_INVALID", `The argument "${name}" must be a number.`, {
+        context: { name, received: raw }
+      });
+    }
+    return value;
+  }
+  boolean(name = "boolean", options = {}) {
+    const raw = this.#consume(name, options);
+    if (raw === void 0) {
+      return void 0;
+    }
+    const normalized = raw.toLowerCase();
+    const truthy = /* @__PURE__ */ new Set(["true", "on", "yes", "sim", "1"]);
+    const falsy = /* @__PURE__ */ new Set(["false", "off", "no", "n\xE3o", "nao", "0"]);
+    if (truthy.has(normalized)) {
+      return true;
+    }
+    if (falsy.has(normalized)) {
+      return false;
+    }
+    throw new WhaNextError("ARGUMENT_INVALID", `The argument "${name}" must be a boolean.`, {
+      context: { name, received: raw }
+    });
+  }
+  enum(values, name = "option", options = {}) {
+    const raw = this.#consume(name, options);
+    if (raw === void 0) {
+      return void 0;
+    }
+    if (!values.includes(raw)) {
+      throw new WhaNextError(
+        "ARGUMENT_INVALID",
+        `The argument "${name}" must be one of: ${values.join(", ")}.`,
+        {
+          context: { name, received: raw, expected: values }
+        }
+      );
+    }
+    return raw;
+  }
+  user(name = "user", options = {}) {
+    const raw = this.#consume(name, options);
+    if (raw === void 0) {
+      return void 0;
+    }
+    const normalized = raw.replace(/^@/, "").replace(/\D/g, "");
+    if (normalized.length < 8) {
+      throw new WhaNextError(
+        "ARGUMENT_INVALID",
+        `The argument "${name}" must be a mention or phone number.`,
+        {
+          context: { name, received: raw }
+        }
+      );
+    }
+    return User.fromPhoneNumber(normalized);
+  }
+  duration(name = "duration", options = {}) {
+    const raw = this.#consume(name, options);
+    if (raw === void 0) {
+      return void 0;
+    }
+    const normalized = raw.toLowerCase();
+    const permanent = /* @__PURE__ */ new Set([
+      "forever",
+      "indefinido",
+      "permanent",
+      "permanente",
+      "sempre"
+    ]);
+    if (permanent.has(normalized)) {
+      return void 0;
+    }
+    const match = /^(\d+)(ms|s|m|h|d)$/.exec(normalized);
+    if (!match) {
+      throw new WhaNextError(
+        "ARGUMENT_INVALID",
+        `The argument "${name}" must be a duration such as 30s or 5m.`,
+        {
+          context: { name, received: raw }
+        }
+      );
+    }
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const multiplier = { ms: 1, s: 1e3, m: 6e4, h: 36e5, d: 864e5 }[unit];
+    return amount * multiplier;
+  }
+  rest() {
+    const value = this.#values.slice(this.#cursor).join(" ");
+    this.#cursor = this.#values.length;
+    return value;
+  }
+  #consume(name, options) {
+    const value = this.#values[this.#cursor];
+    if (value === void 0) {
+      if (options.optional) {
+        return void 0;
+      }
+      throw new WhaNextError("ARGUMENT_MISSING", `The argument "${name}" is required.`, {
+        context: { name, position: this.#cursor }
+      });
+    }
+    this.#cursor += 1;
+    return value;
+  }
+};
+
+// src/commands/router.ts
+var CommandRouter = class {
+  #commands = /* @__PURE__ */ new Map();
+  #prefix;
+  #group;
+  #onError;
+  constructor(group, options = {}) {
+    this.#group = group;
+    this.#prefix = options.prefix ?? "!";
+    this.#onError = options.onError;
+    if (this.#prefix.length === 0 || /\s/.test(this.#prefix)) {
+      throw new WhaNextError(
+        "ARGUMENT_INVALID",
+        "The command prefix cannot be empty or contain whitespace.",
+        {
+          context: { prefix: this.#prefix }
+        }
+      );
+    }
+  }
+  command(definition) {
+    const names = [definition.name, ...definition.aliases ?? []];
+    for (const name of names) {
+      const normalized = name.toLowerCase();
+      if (this.#commands.has(normalized)) {
+        throw new WhaNextError(
+          "ARGUMENT_INVALID",
+          `The command "${normalized}" is already registered.`
+        );
+      }
+      this.#commands.set(normalized, definition);
+    }
+    return this;
+  }
+  async dispatch(message) {
+    const text = message.text?.trim();
+    if (!text?.startsWith(this.#prefix)) {
+      return false;
+    }
+    const tokens = tokenize(text.slice(this.#prefix.length));
+    const name = tokens.shift()?.toLowerCase();
+    if (!name) {
+      return false;
+    }
+    const command = this.#commands.get(name);
+    if (!command) {
+      return false;
+    }
+    try {
+      await this.#authorize(command, message);
+      await command.execute(message, new ArgsParser(tokens));
+      return true;
+    } catch (error) {
+      const normalized = toWhaNextError(error, { command: command.name, messageId: message.id });
+      if (this.#onError) {
+        await this.#onError(normalized, message);
+        return true;
+      }
+      throw normalized;
+    }
+  }
+  async #authorize(command, message) {
+    if (command.onlyGroup && !message.isGroup) {
+      throw new WhaNextError("COMMAND_NOT_ALLOWED", "This command can only be used in groups.");
+    }
+    if (command.onlyPrivate && message.isGroup) {
+      throw new WhaNextError(
+        "COMMAND_NOT_ALLOWED",
+        "This command can only be used in private chats."
+      );
+    }
+    if (command.onlyAdmin && !await this.#group.isAdmin(message.chatId, message.senderIds)) {
+      throw new WhaNextError(
+        "COMMAND_NOT_ALLOWED",
+        "This command can only be used by group administrators."
+      );
+    }
+    if (command.botMustBeAdmin && !await this.#group.isCurrentUserAdmin(message.chatId)) {
+      throw new WhaNextError(
+        "BOT_NOT_ADMIN",
+        "The connected WhatsApp account must be a group administrator."
+      );
+    }
+  }
+};
+function tokenize(input) {
+  return input.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((token) => token.replace(/^(["'])(.*)\1$/, "$2")) ?? [];
+}
+
+// src/logger/logger.ts
+var priorities = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  silent: Number.POSITIVE_INFINITY
+};
+var defaultRedactions = [
+  "auth",
+  "pairingcode",
+  "password",
+  "phone",
+  "secret",
+  "session",
+  "token"
+];
+var Logger = class _Logger {
+  #state;
+  #scope;
+  #writer;
+  #redactions;
+  constructor(config = "info") {
+    const options = typeof config === "string" ? { level: config } : config;
+    const level = options.level ?? "info";
+    assertLevel(level);
+    if (options.writer !== void 0 && typeof options.writer !== "function") {
+      throw new WhaNextError(
+        "ARGUMENT_INVALID",
+        "Logger writer must be a function."
+      );
+    }
+    if (options.format !== void 0 && !["pretty", "json"].includes(options.format)) {
+      throw new WhaNextError(
+        "ARGUMENT_INVALID",
+        'Logger format must be "pretty" or "json".',
+        { context: { format: options.format } }
+      );
+    }
+    this.#state = { level };
+    this.#scope = options.scope ?? "whanext";
+    this.#redactions = new Set(
+      [...defaultRedactions, ...options.redact ?? []].map((key) => key.toLowerCase())
+    );
+    this.#writer = options.writer ?? consoleWriter(options.format ?? "pretty");
+  }
+  get level() {
+    return this.#state.level;
+  }
+  setLevel(level) {
+    assertLevel(level);
+    this.#state.level = level;
+    return this;
+  }
+  isEnabled(level) {
+    return priorities[level] >= priorities[this.#state.level];
+  }
+  child(scope) {
+    const childScope = this.#scope ? `${this.#scope}:${scope}` : scope;
+    const child = new _Logger({
+      level: this.#state.level,
+      scope: childScope,
+      writer: this.#writer,
+      redact: [...this.#redactions]
+    });
+    child.#state = this.#state;
+    return child;
+  }
+  debug(message, context = {}) {
+    this.#write("debug", message, context);
+  }
+  info(message, context = {}) {
+    this.#write("info", message, context);
+  }
+  warn(message, context = {}) {
+    this.#write("warn", message, context);
+  }
+  error(message, context = {}) {
+    this.#write("error", message, context);
+  }
+  #write(level, message, context) {
+    if (!this.isEnabled(level)) {
+      return;
+    }
+    try {
+      const entry = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        scope: this.#scope,
+        message,
+        context: normalizeContext(context, this.#redactions)
+      };
+      const result = this.#writer(entry);
+      if (result instanceof Promise) {
+        void result.catch(() => void 0);
+      }
+    } catch {
+      return;
+    }
+  }
+};
+function assertLevel(level) {
+  if (!(level in priorities)) {
+    throw new WhaNextError(
+      "ARGUMENT_INVALID",
+      "Logger level must be debug, info, warn, error or silent.",
+      { context: { level } }
+    );
+  }
+}
+function consoleWriter(format) {
+  return (entry) => {
+    const method = entry.level === "debug" ? console.debug : entry.level === "info" ? console.info : entry.level === "warn" ? console.warn : console.error;
+    if (format === "json") {
+      method(JSON.stringify(entry));
+      return;
+    }
+    const details = Object.keys(entry.context).length > 0 ? ` ${JSON.stringify(entry.context)}` : "";
+    method(
+      `[${entry.timestamp}] ${entry.level.toUpperCase()} ${entry.scope} ${entry.message}${details}`
+    );
+  };
+}
+function normalizeContext(context, redactions) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return Object.fromEntries(
+    Object.entries(context).map(([key, value]) => [
+      key,
+      normalizeValue(value, key, redactions, seen)
+    ])
+  );
+}
+function normalizeValue(value, key, redactions, seen) {
+  if (isRedactedKey(key, redactions)) {
+    return "[REDACTED]";
+  }
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === void 0) {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      ..."code" in value ? { code: value.code } : {}
+    };
+  }
+  if (typeof value !== "object") {
+    return String(value);
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeValue(item, "", redactions, seen));
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([nestedKey, nestedValue]) => [
+      nestedKey,
+      normalizeValue(nestedValue, nestedKey, redactions, seen)
+    ])
+  );
+}
+function isRedactedKey(key, redactions) {
+  const normalized = key.toLowerCase();
+  return [...redactions].some((redaction) => normalized === redaction || normalized.startsWith(redaction) || normalized.endsWith(redaction));
+}
+
+// src/mute/mute-service.ts
+var MuteService = class {
+  #provider;
+  #store;
+  constructor(provider, store) {
+    this.#provider = provider;
+    this.#store = store;
+  }
+  get enabled() {
+    return this.#store !== void 0;
+  }
+  async add(groupId, user, options = {}) {
+    const store = this.#requireStore();
+    const now = Date.now();
+    if (options.durationMs !== void 0 && options.durationMs <= 0) {
+      throw new WhaNextError("ARGUMENT_INVALID", "Mute duration must be greater than zero.");
+    }
+    const current = await this.#findActive(groupId, user.identities);
+    if (current && current.expiresAt === null && options.durationMs === void 0) {
+      return {
+        ok: true,
+        changed: false,
+        state: "already_muted",
+        record: this.#record(current)
+      };
+    }
+    const stored = {
+      key: normalizeIdentity(user.id),
+      groupId,
+      user: user.toJSON(),
+      identities: user.identities,
+      createdAt: now,
+      expiresAt: options.durationMs === void 0 ? null : now + options.durationMs
+    };
+    await this.#storage(
+      "upsert",
+      () => store.upsert(stored),
+      { groupId, userId: user.id }
+    );
+    return {
+      ok: true,
+      changed: true,
+      state: current ? "updated" : "muted",
+      record: this.#record(stored)
+    };
+  }
+  async remove(groupId, user) {
+    const store = this.#requireStore();
+    const changed = await this.#storage(
+      "delete",
+      () => store.delete(groupId, user.identities),
+      { groupId, userId: user.id }
+    );
+    if (changed) {
+      return {
+        ok: true,
+        changed: true,
+        state: "unmuted"
+      };
+    }
+    return {
+      ok: true,
+      changed: false,
+      state: "already_unmuted"
+    };
+  }
+  async get(groupId, user) {
+    this.#requireStore();
+    const stored = await this.#findActive(groupId, user.identities);
+    return stored ? this.#record(stored) : void 0;
+  }
+  async isMuted(groupId, user) {
+    return await this.get(groupId, user) !== void 0;
+  }
+  async enforce(message) {
+    if (!this.#store || !message.isGroup || message.keys.fromMe) {
+      return void 0;
+    }
+    const stored = await this.#findActive(message.chatId, message.sender.identities);
+    if (!stored) {
+      return void 0;
+    }
+    try {
+      await this.#provider.deleteMessage(message.keys);
+    } catch (error) {
+      throw new WhaNextError(
+        "PROVIDER_ERROR",
+        "Could not delete a message sent by a muted member.",
+        {
+          cause: error,
+          context: {
+            groupId: message.chatId,
+            messageId: message.id,
+            userId: message.sender.id
+          },
+          recoverable: true
+        }
+      );
+    }
+    return {
+      message,
+      record: this.#record(stored)
+    };
+  }
+  async purgeExpired() {
+    const store = this.#requireStore();
+    return this.#storage(
+      "purge",
+      () => store.purgeExpired(Date.now())
+    );
+  }
+  async close() {
+    if (this.#store?.close) {
+      await this.#storage("close", () => this.#store?.close?.());
+    }
+  }
+  #record(stored) {
+    return {
+      groupId: stored.groupId,
+      user: new User(stored.user),
+      createdAt: new Date(stored.createdAt),
+      expiresAt: stored.expiresAt === null ? null : new Date(stored.expiresAt)
+    };
+  }
+  async #findActive(groupId, identities) {
+    const stored = await this.#storage(
+      "find",
+      () => this.#store?.find(groupId, identities),
+      { groupId }
+    );
+    if (!stored) {
+      return void 0;
+    }
+    if (stored.expiresAt !== null && stored.expiresAt <= Date.now()) {
+      await this.#storage(
+        "delete_expired",
+        () => this.#store?.delete(groupId, stored.identities),
+        { groupId }
+      );
+      return void 0;
+    }
+    return stored;
+  }
+  #requireStore() {
+    if (!this.#store) {
+      throw new WhaNextError(
+        "MUTE_DISABLED",
+        "Mute is disabled. Enable it in create({ mute: { enabled: true } })."
+      );
+    }
+    return this.#store;
+  }
+  async #storage(action, operation, context = {}) {
+    try {
+      return await operation();
+    } catch (error) {
+      throw new WhaNextError(
+        "STORAGE_ERROR",
+        `Mute storage operation "${action}" failed.`,
+        {
+          cause: error,
+          context: { action, ...context },
+          recoverable: true
+        }
+      );
+    }
+  }
+};
+
+// src/mute/sqlite-mute-store.ts
+import { mkdirSync } from "fs";
+import { createRequire } from "module";
+import {
+  dirname,
+  resolve
+} from "path";
+var SqliteMuteStore = class {
+  #database;
+  constructor(path = "./data/whanext.sqlite") {
+    const databasePath = path === ":memory:" ? path : resolve(path);
+    if (databasePath !== ":memory:") {
+      mkdirSync(dirname(databasePath), { recursive: true });
+    }
+    let database;
+    try {
+      const require2 = createRequire(import.meta.url);
+      const sqlite = require2("node:sqlite");
+      database = new sqlite.DatabaseSync(databasePath);
+      database.exec("PRAGMA journal_mode = WAL");
+      database.exec("PRAGMA busy_timeout = 5000");
+      database.exec(`
+        CREATE TABLE IF NOT EXISTS whanext_mutes (
+          group_id TEXT NOT NULL,
+          identity TEXT NOT NULL,
+          mute_key TEXT NOT NULL,
+          user_json TEXT NOT NULL,
+          created_at INTEGER NOT NULL,
+          expires_at INTEGER,
+          PRIMARY KEY (group_id, identity)
+        ) STRICT;
+        CREATE INDEX IF NOT EXISTS whanext_mutes_expiration
+          ON whanext_mutes (expires_at);
+        CREATE INDEX IF NOT EXISTS whanext_mutes_key
+          ON whanext_mutes (group_id, mute_key);
+      `);
+    } catch (error) {
+      database?.close();
+      throw new WhaNextError(
+        "STORAGE_ERROR",
+        "Could not initialize the SQLite mute store.",
+        {
+          cause: error,
+          context: { database: databasePath }
+        }
+      );
+    }
+    this.#database = database;
+  }
+  upsert(mute) {
+    const identities = this.#identities(mute.identities);
+    const existingKeys = this.#matchingKeys(mute.groupId, identities);
+    this.#transaction(() => {
+      for (const key of existingKeys) {
+        this.#database.prepare(
+          "DELETE FROM whanext_mutes WHERE group_id = ? AND mute_key = ?"
+        ).run(mute.groupId, key);
+      }
+      const insert = this.#database.prepare(`
+        INSERT OR REPLACE INTO whanext_mutes (
+          group_id,
+          identity,
+          mute_key,
+          user_json,
+          created_at,
+          expires_at
+        ) VALUES (?, ?, ?, ?, ?, ?)
+      `);
+      for (const identity of identities) {
+        insert.run(
+          mute.groupId,
+          identity,
+          mute.key,
+          JSON.stringify(mute.user),
+          mute.createdAt,
+          mute.expiresAt
+        );
+      }
+    });
+  }
+  find(groupId, identities) {
+    const normalized = this.#identities(identities);
+    if (normalized.length === 0) {
+      return void 0;
+    }
+    const placeholders = normalized.map(() => "?").join(", ");
+    const row = this.#database.prepare(`
+      SELECT mute_key, group_id, user_json, created_at, expires_at
+      FROM whanext_mutes
+      WHERE group_id = ? AND identity IN (${placeholders})
+      LIMIT 1
+    `).get(groupId, ...normalized);
+    if (!row) {
+      return void 0;
+    }
+    if (row.expires_at !== null && row.expires_at <= Date.now()) {
+      this.#database.prepare(
+        "DELETE FROM whanext_mutes WHERE group_id = ? AND mute_key = ?"
+      ).run(groupId, row.mute_key);
+      return void 0;
+    }
+    const identityRows = this.#database.prepare(`
+      SELECT identity
+      FROM whanext_mutes
+      WHERE group_id = ? AND mute_key = ?
+    `).all(groupId, row.mute_key);
+    return {
+      key: row.mute_key,
+      groupId: row.group_id,
+      user: JSON.parse(row.user_json),
+      identities: identityRows.map(({ identity }) => identity),
+      createdAt: row.created_at,
+      expiresAt: row.expires_at
+    };
+  }
+  delete(groupId, identities) {
+    const keys = this.#matchingKeys(groupId, this.#identities(identities));
+    if (keys.length === 0) {
+      return false;
+    }
+    this.#transaction(() => {
+      const statement = this.#database.prepare(
+        "DELETE FROM whanext_mutes WHERE group_id = ? AND mute_key = ?"
+      );
+      for (const key of keys) {
+        statement.run(groupId, key);
+      }
+    });
+    return true;
+  }
+  purgeExpired(now) {
+    const result = this.#database.prepare(`
+      DELETE FROM whanext_mutes
+      WHERE expires_at IS NOT NULL AND expires_at <= ?
+    `).run(now);
+    return Number(result.changes);
+  }
+  close() {
+    this.#database.close();
+  }
+  #matchingKeys(groupId, identities) {
+    if (identities.length === 0) {
+      return [];
+    }
+    const placeholders = identities.map(() => "?").join(", ");
+    const rows = this.#database.prepare(`
+      SELECT DISTINCT mute_key
+      FROM whanext_mutes
+      WHERE group_id = ? AND identity IN (${placeholders})
+    `).all(groupId, ...identities);
+    return rows.map(({ mute_key }) => mute_key);
+  }
+  #identities(identities) {
+    return [...new Set(identities.map(normalizeIdentity).filter(Boolean))];
+  }
+  #transaction(operation) {
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      operation();
+      this.#database.exec("COMMIT");
+    } catch (error) {
+      this.#database.exec("ROLLBACK");
+      throw error;
+    }
+  }
+};
+
+// src/provider/event-emitter.ts
+var TypedEventEmitter = class {
+  #listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    const listeners = this.#listeners.get(event) ?? /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    this.#listeners.set(event, listeners);
+    return () => listeners.delete(listener);
+  }
+  async emit(event, payload) {
+    const listeners = this.#listeners.get(event);
+    if (!listeners) {
+      return;
+    }
+    await Promise.all([...listeners].map((listener) => listener(payload)));
+  }
+};
+
+// src/services/chat-service.ts
+var ChatService = class {
+  #provider;
+  constructor(provider) {
+    this.#provider = provider;
+  }
+  typing(chatId) {
+    return this.#provider.setPresence(chatId, "typing");
+  }
+  recording(chatId) {
+    return this.#provider.setPresence(chatId, "recording");
+  }
+  stop(chatId) {
+    return this.#provider.setPresence(chatId, "paused");
+  }
+  stopTyping(chatId) {
+    return this.stop(chatId);
+  }
+};
+
+// src/services/group-service.ts
+var GroupService = class {
+  #provider;
+  #cache;
+  #ttlMs;
+  constructor(provider, cache, ttlMs = 3e5) {
+    this.#provider = provider;
+    this.#cache = cache;
+    this.#ttlMs = ttlMs;
+  }
+  async open(groupId) {
+    const group = await this.metadata(groupId);
+    if (group.access === "open") {
+      return { ok: true, changed: false, state: "already_open" };
+    }
+    await this.#provider.setGroupAccess(groupId, "open");
+    await this.invalidate(groupId);
+    return { ok: true, changed: true, state: "open" };
+  }
+  async close(groupId) {
+    const group = await this.metadata(groupId);
+    if (group.access === "closed") {
+      return { ok: true, changed: false, state: "already_closed" };
+    }
+    await this.#provider.setGroupAccess(groupId, "closed");
+    await this.invalidate(groupId);
+    return { ok: true, changed: true, state: "closed" };
+  }
+  async invite(groupId) {
+    const code = await this.#provider.getGroupInviteCode(groupId);
+    return { ok: true, code, url: `https://chat.whatsapp.com/${code}` };
+  }
+  async revokeInvite(groupId) {
+    const code = await this.#provider.revokeGroupInvite(groupId);
+    return { ok: true, code, url: `https://chat.whatsapp.com/${code}` };
+  }
+  async pin(groupId, key) {
+    await this.#provider.setMessagePin(groupId, key, true);
+    return { ok: true, changed: true, state: "pinned" };
+  }
+  async unpin(groupId, key) {
+    await this.#provider.setMessagePin(groupId, key, false);
+    return { ok: true, changed: true, state: "unpinned" };
+  }
+  async metadata(groupId, refresh = false) {
+    const key = this.#key(groupId);
+    if (!refresh) {
+      const cached = await this.#cache.get(key);
+      if (cached) {
+        return cached;
+      }
+    }
+    const group = await this.#provider.getGroup(groupId);
+    await this.#cache.set(key, group, this.#ttlMs);
+    return group;
+  }
+  async isAdmin(groupId, memberIds) {
+    if (!groupId.endsWith("@g.us")) {
+      return false;
+    }
+    const group = await this.metadata(groupId);
+    const identities = typeof memberIds === "string" ? [memberIds] : memberIds;
+    const participant = group.participants.find((item) => this.#matchesParticipant(item, identities));
+    return participant?.role === "admin" || participant?.role === "owner";
+  }
+  async isCurrentUserAdmin(groupId) {
+    const ids = this.#provider.getCurrentUserIds();
+    if (ids.length === 0 || !groupId.endsWith("@g.us")) {
+      return false;
+    }
+    const group = await this.metadata(groupId);
+    return group.participants.some((participant) => this.#matchesParticipant(participant, ids) && (participant.role === "admin" || participant.role === "owner"));
+  }
+  async resolveUser(groupId, user) {
+    if (!groupId.endsWith("@g.us")) {
+      return user;
+    }
+    const group = await this.metadata(groupId);
+    const participant = group.participants.find((item) => this.#matchesParticipant(item, user.identities));
+    if (!participant) {
+      return user;
+    }
+    return new User({
+      id: participant.id,
+      identities: [
+        participant.id,
+        ...participant.lid ? [participant.lid] : [],
+        ...participant.phoneNumber ? [participant.phoneNumber] : []
+      ],
+      ...participant.lid ? { lid: participant.lid } : {},
+      ...participant.phoneNumber ? {
+        jid: participant.phoneNumber,
+        phoneNumber: participant.phoneNumber
+      } : {},
+      ...user.name ? { name: user.name } : {}
+    });
+  }
+  invalidate(groupId) {
+    return this.#cache.delete(this.#key(groupId));
+  }
+  #key(groupId) {
+    return `group:${groupId}`;
+  }
+  #matchesParticipant(participant, identities) {
+    const participantIds = [participant.id, participant.lid, participant.phoneNumber].filter((identity) => identity !== void 0);
+    return identities.some((identity) => participantIds.some((participantId) => identitiesMatch(identity, participantId)));
+  }
+};
+
+// src/services/media-service.ts
+var MediaService = class {
+  #provider;
+  constructor(provider) {
+    this.#provider = provider;
+  }
+  image(chatId, content) {
+    return this.#provider.sendMessage(chatId, content);
+  }
+  video(chatId, content) {
+    return this.#provider.sendMessage(chatId, content);
+  }
+  audio(chatId, content) {
+    return this.#provider.sendMessage(chatId, content);
+  }
+};
+
+// src/services/member-service.ts
+var MemberService = class {
+  #provider;
+  #group;
+  constructor(provider, group) {
+    this.#provider = provider;
+    this.#group = group;
+  }
+  async remove(groupId, member) {
+    const { group, participant } = await this.#participant(groupId, member);
+    if (!participant) {
+      return { ok: true, changed: false, state: "already_removed" };
+    }
+    await this.#update(groupId, this.#actionId(group, participant), "remove");
+    await this.#group.invalidate(groupId);
+    return { ok: true, changed: true, state: "removed" };
+  }
+  async promote(groupId, member) {
+    const { group, participant } = await this.#participant(groupId, member);
+    if (!participant) {
+      return { ok: true, changed: false, state: "not_in_group" };
+    }
+    if (participant.role === "admin" || participant.role === "owner") {
+      return { ok: true, changed: false, state: "already_admin" };
+    }
+    await this.#update(groupId, this.#actionId(group, participant), "promote");
+    await this.#group.invalidate(groupId);
+    return { ok: true, changed: true, state: "promoted" };
+  }
+  async demote(groupId, member) {
+    const { group, participant } = await this.#participant(groupId, member);
+    if (!participant) {
+      return { ok: true, changed: false, state: "not_in_group" };
+    }
+    if (participant.role === "member") {
+      return { ok: true, changed: false, state: "not_admin" };
+    }
+    await this.#update(groupId, this.#actionId(group, participant), "demote");
+    await this.#group.invalidate(groupId);
+    return { ok: true, changed: true, state: "demoted" };
+  }
+  async #participant(groupId, member) {
+    const group = await this.#group.metadata(groupId);
+    const memberIds = typeof member === "string" ? [member] : member.identities;
+    const participant = group.participants.find((item) => [item.id, item.lid, item.phoneNumber].filter((identity) => identity !== void 0).some((identity) => memberIds.some((memberId) => identitiesMatch(identity, memberId))));
+    return { group, participant };
+  }
+  #actionId(group, participant) {
+    if (group.addressingMode === "lid") {
+      return participant.lid ?? (participant.id.endsWith("@lid") ? participant.id : participant.phoneNumber ?? participant.id);
+    }
+    return participant.phoneNumber ?? (participant.id.endsWith("@s.whatsapp.net") ? participant.id : participant.lid ?? participant.id);
+  }
+  async #update(groupId, memberId, action) {
+    const result = await this.#provider.updateParticipant(groupId, memberId, action);
+    if (!result.success) {
+      throw new WhaNextError(
+        "PROVIDER_ERROR",
+        `WhatsApp rejected the member action with status ${result.status}.`,
+        {
+          context: { groupId, memberId, action, status: result.status },
+          recoverable: true
+        }
+      );
+    }
+  }
+};
+
+// src/services/message-service.ts
+var MessageService = class {
+  #provider;
+  constructor(provider) {
+    this.#provider = provider;
+  }
+  send(chatId, content) {
+    return this.#provider.sendMessage(chatId, content);
+  }
+  reply(message, content) {
+    return this.#provider.sendMessage(message.chatId, content, message.keys);
+  }
+  edit(message, text) {
+    const key = "keys" in message ? message.keys : message;
+    return this.#provider.editMessage(key, text);
+  }
+  delete(message) {
+    const key = "keys" in message ? message.keys : message;
+    return this.#provider.deleteMessage(key);
+  }
+  text(chatId, text, mentions) {
+    const content = { text };
+    if (mentions !== void 0) {
+      content.mentions = mentions;
+    }
+    return this.send(chatId, content);
+  }
+};
+
+// src/services/user-service.ts
+var UserService = class {
+  #group;
+  constructor(group) {
+    this.#group = group;
+  }
+  async resolve(message, args) {
+    const mentioned = message.mentionedUsers[0];
+    let user;
+    if (mentioned) {
+      if (args.peek()?.startsWith("@")) {
+        args.skip();
+      }
+      user = mentioned;
+    } else if (message.quoted?.sender) {
+      user = message.quoted.sender;
+    } else {
+      user = args.user("membro");
+    }
+    return this.#group.resolveUser(message.chatId, user);
+  }
+  from(identity) {
+    if (!identity.includes("@")) {
+      return User.fromPhoneNumber(identity);
+    }
+    return User.fromIdentities([identity]);
+  }
+};
+
+// src/app/whanext-app.ts
+var WhaNextApp = class {
+  message;
+  media;
+  group;
+  member;
+  chat;
+  user;
+  mute;
+  logger;
+  #provider;
+  #phone;
+  #events = new TypedEventEmitter();
+  #router;
+  #startedAt = Date.now();
+  #state = "idle";
+  constructor(provider, options = {}, logger = new Logger(options.logger)) {
+    this.#provider = provider;
+    this.#phone = options.phone;
+    this.logger = logger;
+    const cache = options.cache?.store ?? new MemoryCache();
+    this.group = new GroupService(provider, cache, options.cache?.groupTtlMs);
+    this.member = new MemberService(provider, this.group);
+    this.message = new MessageService(provider);
+    this.media = new MediaService(provider);
+    this.chat = new ChatService(provider);
+    this.user = new UserService(this.group);
+    const muteEnabled = options.mute?.enabled === true || options.mute?.store !== void 0;
+    const muteStore = muteEnabled ? options.mute?.store ?? new SqliteMuteStore(options.mute?.database) : void 0;
+    this.mute = new MuteService(provider, muteStore);
+    this.#router = new CommandRouter(this.group, {
+      ...options.router,
+      ...options.prefix !== void 0 ? { prefix: options.prefix } : {}
+    });
+    this.#bind();
+    this.logger.debug("Application initialized", {
+      muteEnabled: this.mute.enabled,
+      prefix: options.prefix ?? "!"
+    });
+  }
+  get state() {
+    return this.#state;
+  }
+  get isReady() {
+    return this.#state === "connected";
+  }
+  health() {
+    return {
+      status: this.#healthStatus(),
+      state: this.#state,
+      ready: this.isReady,
+      uptimeMs: Date.now() - this.#startedAt,
+      timestamp: /* @__PURE__ */ new Date(),
+      muteEnabled: this.mute.enabled,
+      logLevel: this.logger.level
+    };
+  }
+  router() {
+    return this.#router;
+  }
+  on(event, listener) {
+    return this.#events.on(event, listener);
+  }
+  async login(options = {}) {
+    if (this.#state === "connected") {
+      return;
+    }
+    this.logger.info("Login started");
+    let unsubscribe = () => void 0;
+    let timer;
+    const connected = new Promise((resolve2, reject) => {
+      unsubscribe = this.#provider.on("connection", (update) => {
+        if (update.state === "connected") resolve2();
+        if (update.state === "closed") {
+          reject(
+            new WhaNextError(
+              "CONNECTION_FAILED",
+              "WhatsApp closed the connection before login completed.",
+              {
+                cause: update.error,
+                recoverable: true
+              }
+            )
+          );
+        }
+      });
+      timer = setTimeout(() => {
+        reject(
+          new WhaNextError(
+            "CONNECTION_FAILED",
+            "WhatsApp login timed out.",
+            { recoverable: true }
+          )
+        );
+      }, options.timeoutMs ?? 3e5);
+    });
+    try {
+      await this.#provider.connect();
+      if (this.#phone) {
+        const code = await this.#provider.requestPairingCode(this.#phone);
+        if (code) {
+          this.logger.info("Pairing code generated");
+          if (options.onCode) {
+            await options.onCode(code);
+          }
+        }
+      }
+      await connected;
+    } finally {
+      unsubscribe();
+      if (timer) clearTimeout(timer);
+    }
+  }
+  async disconnect() {
+    this.logger.info("Disconnecting application");
+    try {
+      await this.#provider.disconnect();
+    } finally {
+      await this.mute.close();
+    }
+  }
+  #bind() {
+    this.#provider.on("connection", async (update) => {
+      this.#state = update.state;
+      this.#logConnection(update);
+      await this.#events.emit("connection", update);
+    });
+    this.#provider.on("groupChanged", ({ groupId }) => this.group.invalidate(groupId));
+    this.#provider.on("message", async (message) => {
+      try {
+        const enforcement = await this.mute.enforce(message);
+        if (enforcement) {
+          this.logger.info("Muted message deleted", {
+            groupId: message.chatId,
+            messageId: message.id,
+            userId: message.sender.id
+          });
+          await this.#events.emit("mute", enforcement);
+          return;
+        }
+      } catch (error) {
+        await this.#reportError(error, { messageId: message.id });
+        return;
+      }
+      try {
+        this.logger.debug("Message received", {
+          chatId: message.chatId,
+          messageId: message.id,
+          senderId: message.sender.id
+        });
+        await this.#events.emit("message", message);
+        const dispatched = await this.#router.dispatch(message);
+        if (dispatched) {
+          this.logger.debug("Command dispatched", {
+            chatId: message.chatId,
+            messageId: message.id
+          });
+        }
+      } catch (error) {
+        await this.#reportError(error, { messageId: message.id });
+      }
+    });
+  }
+  #healthStatus() {
+    if (this.#state === "connected") {
+      return "ready";
+    }
+    if (this.#state === "closed") {
+      return "stopped";
+    }
+    if (this.#state === "connecting" || this.#state === "reconnecting") {
+      return "starting";
+    }
+    return "idle";
+  }
+  #logConnection(update) {
+    const context = {
+      ...update.attempt !== void 0 ? { attempt: update.attempt } : {},
+      ...update.error ? { error: update.error } : {}
+    };
+    if (update.state === "connected") {
+      this.logger.info("WhatsApp connected");
+    } else if (update.state === "reconnecting") {
+      this.logger.warn("WhatsApp reconnecting", context);
+    } else if (update.state === "closed" && update.error) {
+      this.logger.warn("WhatsApp connection closed", context);
+    } else if (update.state === "closed") {
+      this.logger.info("WhatsApp connection closed");
+    } else {
+      this.logger.debug("WhatsApp connecting", context);
+    }
+  }
+  async #reportError(error, context) {
+    const normalized = toWhaNextError(error, context);
+    this.logger.error(normalized.message, {
+      code: normalized.code,
+      ...normalized.context
+    });
+    await this.#events.emit("error", normalized);
+  }
+};
+
+// src/auth/browser.ts
+var Browser = /* @__PURE__ */ ((Browser2) => {
+  Browser2["Windows"] = "windows";
+  Browser2["MacOS"] = "macos";
+  Browser2["Ubuntu"] = "ubuntu";
+  return Browser2;
+})(Browser || {});
+
+// src/provider/baileys/baileys-provider.ts
+import {
+  Browsers,
+  DisconnectReason,
+  makeWASocket,
+  proto,
+  useMultiFileAuthState
+} from "@whiskeysockets/baileys";
+
+// src/provider/baileys/baileys-logger.ts
+function createBaileysLogger(logger) {
+  return {
+    level: logger.level,
+    child(context) {
+      const name = typeof context.class === "string" ? context.class : "internal";
+      return createBaileysLogger(logger.child(name));
+    },
+    trace(value, message) {
+      logger.debug(resolveMessage(value, message, "Provider trace"), safeContext(value));
+    },
+    debug(value, message) {
+      logger.debug(resolveMessage(value, message, "Provider debug"), safeContext(value));
+    },
+    info(value, message) {
+      logger.debug(resolveMessage(value, message, "Provider info"), safeContext(value));
+    },
+    warn(value, message) {
+      logger.warn(resolveMessage(value, message, "Provider warning"), safeContext(value));
+    },
+    error(value, message) {
+      logger.error(resolveMessage(value, message, "Provider error"), safeContext(value));
+    }
+  };
+}
+function resolveMessage(value, message, fallback) {
+  if (message) {
+    return message;
+  }
+  return typeof value === "string" ? value : fallback;
+}
+function safeContext(value) {
+  if (value instanceof Error) {
+    return { error: value };
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return {};
+  }
+  const source = value;
+  const allowed = [
+    "location",
+    "reason",
+    "status",
+    "statusCode",
+    "type"
+  ];
+  return Object.fromEntries(
+    allowed.filter((key) => source[key] !== void 0).map((key) => [key, source[key]])
+  );
+}
+
+// src/provider/baileys/normalize-message.ts
+import {
+  extractMessageContent,
+  getContentType,
+  normalizeMessageContent
+} from "@whiskeysockets/baileys";
+function normalizeBaileysMessage(input) {
+  const chatId = input.key.remoteJid;
+  const id = input.key.id;
+  if (!chatId || !id || !input.message) {
+    return void 0;
+  }
+  const normalized = normalizeMessageContent(input.message);
+  const content = extractMessageContent(normalized);
+  if (!content) {
+    return void 0;
+  }
+  const type = getContentType(content);
+  const node = type ? content[type] : void 0;
+  const context = getContextInfo(node);
+  const senderIds = uniqueIdentities([
+    input.key.participant,
+    input.key.participantAlt,
+    input.key.participantUsername?.includes("@") ? input.key.participantUsername : void 0
+  ]);
+  const senderJid = senderIds.find((identity) => identity.endsWith("@s.whatsapp.net") || identity.endsWith("@c.us"));
+  const senderLid = senderIds.find((identity) => identity.endsWith("@lid"));
+  const senderId = senderJid ?? senderLid ?? senderIds[0] ?? chatId;
+  const sender = new User({
+    id: senderId,
+    identities: senderIds.length > 0 ? senderIds : [senderId],
+    ...input.pushName ? { name: input.pushName } : {}
+  });
+  const mentionedUsers = (context?.mentionedJid ?? []).map((identity) => User.fromIdentities([identity]));
+  const media = getMedia(type, node, Boolean(input.key.isViewOnce));
+  const text = getText(content);
+  const caption = getCaption(content);
+  const quoted = getQuoted(context, chatId);
+  const message = {
+    id,
+    jid: chatId,
+    chatId,
+    senderId,
+    senderIds: senderIds.length > 0 ? senderIds : [senderId],
+    sender,
+    keys: normalizeKey(input.key),
+    mentions: [...context?.mentionedJid ?? []],
+    mentionedUsers,
+    timestamp: toDate(input.messageTimestamp),
+    isGroup: chatId.endsWith("@g.us"),
+    isReply: quoted !== void 0,
+    isViewOnce: media?.viewOnce ?? false,
+    hasMedia: media !== void 0
+  };
+  if (senderJid !== void 0) message.senderJid = senderJid;
+  if (senderLid !== void 0) {
+    message.lid = senderLid;
+    message.senderLid = senderLid;
+  }
+  if (text !== void 0) message.text = text;
+  if (caption !== void 0) message.caption = caption;
+  if (media !== void 0) message.media = media;
+  if (quoted !== void 0) message.quoted = quoted;
+  return message;
+}
+function normalizeKey(key) {
+  const normalized = {
+    id: key.id ?? "",
+    chatId: key.remoteJid ?? "",
+    fromMe: key.fromMe ?? false
+  };
+  const participantId = key.participant ?? key.participantAlt;
+  if (participantId !== null && participantId !== void 0) {
+    normalized.participantId = participantId;
+  }
+  return normalized;
+}
+function getText(content) {
+  return content.conversation ?? content.extendedTextMessage?.text ?? content.buttonsResponseMessage?.selectedDisplayText ?? content.listResponseMessage?.title ?? void 0;
+}
+function getCaption(content) {
+  return content.imageMessage?.caption ?? content.videoMessage?.caption ?? content.documentMessage?.caption ?? void 0;
+}
+function getContextInfo(node) {
+  if (typeof node !== "object" || node === null || !("contextInfo" in node)) {
+    return void 0;
+  }
+  return node.contextInfo;
+}
+function getMedia(type, node, keyViewOnce) {
+  const mapping = {
+    imageMessage: "image",
+    videoMessage: "video",
+    audioMessage: "audio",
+    documentMessage: "document",
+    stickerMessage: "sticker"
+  };
+  const kind = type ? mapping[type] : void 0;
+  if (!kind || typeof node !== "object" || node === null) {
+    return void 0;
+  }
+  const value = node;
+  const media = {
+    kind,
+    viewOnce: keyViewOnce || value.viewOnce === true
+  };
+  if (value.mimetype) media.mimetype = value.mimetype;
+  if (value.fileName) media.fileName = value.fileName;
+  if (value.seconds !== void 0 && value.seconds !== null) media.seconds = Number(value.seconds);
+  return media;
+}
+function getQuoted(context, chatId) {
+  if (!context?.stanzaId) {
+    return void 0;
+  }
+  const quoted = context.quotedMessage;
+  const normalized = normalizeMessageContent(quoted);
+  const content = extractMessageContent(normalized);
+  const result = {
+    key: {
+      id: context.stanzaId,
+      chatId: context.remoteJid ?? chatId,
+      fromMe: false
+    },
+    hasMedia: Boolean(
+      content && getMedia(
+        getContentType(content),
+        content[getContentType(content) ?? "conversation"],
+        false
+      )
+    )
+  };
+  if (context.participant) {
+    result.senderId = context.participant;
+    result.sender = User.fromIdentities([context.participant]);
+    result.key.participantId = context.participant;
+  }
+  if (content) {
+    const text = getText(content) ?? getCaption(content);
+    if (text !== void 0) result.text = text;
+  }
+  return result;
+}
+function toDate(value) {
+  const seconds = value === null || value === void 0 ? Date.now() / 1e3 : Number(value);
+  return new Date(seconds * 1e3);
+}
+
+// src/provider/baileys/baileys-provider.ts
+var BaileysProvider = class {
+  #options;
+  #events = new TypedEventEmitter();
+  #logger;
+  #messageStore = /* @__PURE__ */ new Map();
+  #socket;
+  #saveCredentials;
+  #saveQueue = Promise.resolve();
+  #intentionalClose = false;
+  #reconnectAttempt = 0;
+  #reconnectTimer;
+  #registered = false;
+  constructor(options) {
+    this.#options = options;
+    this.#logger = options.logger ?? new Logger("silent");
+  }
+  on(event, listener) {
+    return this.#events.on(event, listener);
+  }
+  async connect() {
+    if (this.#socket) {
+      return;
+    }
+    this.#intentionalClose = false;
+    await this.#events.emit("connection", {
+      state: this.#reconnectAttempt > 0 ? "reconnecting" : "connecting",
+      attempt: this.#reconnectAttempt
+    });
+    try {
+      const { state, saveCreds } = await useMultiFileAuthState(this.#options.auth);
+      this.#registered = state.creds.registered;
+      this.#saveCredentials = saveCreds;
+      const socket = makeWASocket({
+        auth: state,
+        browser: this.#browserDescription(),
+        logger: createBaileysLogger(this.#logger.child("baileys")),
+        markOnlineOnConnect: false,
+        enableAutoSessionRecreation: true,
+        enableRecentMessageCache: true,
+        getMessage: async (key) => key.id ? this.#messageStore.get(key.id) : void 0
+      });
+      this.#socket = socket;
+      this.#bind(socket);
+    } catch (error) {
+      this.#socket = void 0;
+      throw new WhaNextError("CONNECTION_FAILED", "Could not start the WhatsApp connection.", {
+        cause: error,
+        recoverable: true
+      });
+    }
+  }
+  async disconnect() {
+    this.#intentionalClose = true;
+    if (this.#reconnectTimer) clearTimeout(this.#reconnectTimer);
+    const socket = this.#socket;
+    this.#socket = void 0;
+    if (socket) {
+      await socket.end(void 0);
+    }
+    await this.#events.emit("connection", { state: "closed" });
+  }
+  getCurrentUserIds() {
+    const user = this.#socket?.user;
+    if (!user) {
+      return [];
+    }
+    return [user.id, user.lid, user.phoneNumber].filter((id) => Boolean(id)).filter((id, index, ids) => ids.indexOf(id) === index);
+  }
+  async requestPairingCode(phone) {
+    const normalized = phone.replace(/\D/g, "");
+    if (normalized.length < 10) {
+      throw new WhaNextError(
+        "AUTH_INVALID_PHONE",
+        "The phone number must include its country code."
+      );
+    }
+    if (this.#registered) {
+      return "";
+    }
+    const socket = this.#requireSocket();
+    try {
+      await socket.waitForConnectionUpdate(async (update) => Boolean(update.qr), 6e4);
+      if (socket !== this.#socket) {
+        throw new WhaNextError(
+          "CONNECTION_CLOSED",
+          "The WhatsApp socket changed while preparing the pairing code.",
+          {
+            recoverable: true
+          }
+        );
+      }
+      return await socket.requestPairingCode(normalized);
+    } catch (error) {
+      if (error instanceof WhaNextError) {
+        throw error;
+      }
+      throw new WhaNextError(
+        "CONNECTION_FAILED",
+        "Could not request the pairing code after the authentication challenge.",
+        {
+          cause: error,
+          context: { statusCode: this.#statusCode(error) },
+          recoverable: this.#statusCode(error) === DisconnectReason.connectionClosed
+        }
+      );
+    }
+  }
+  async sendMessage(chatId, content, replyTo) {
+    const socket = this.#requireSocket();
+    const options = replyTo ? {
+      quoted: {
+        key: this.#toWaKey(replyTo),
+        message: { conversation: "" }
+      }
+    } : void 0;
+    const result = await socket.sendMessage(chatId, this.#toContent(content), options);
+    return this.#sent(result);
+  }
+  async editMessage(key, content) {
+    const result = await this.#requireSocket().sendMessage(key.chatId, {
+      text: content,
+      edit: this.#toWaKey(key)
+    });
+    return this.#sent(result);
+  }
+  async deleteMessage(key) {
+    await this.#requireSocket().sendMessage(key.chatId, { delete: this.#toWaKey(key) });
+  }
+  async getGroup(groupId) {
+    const metadata = await this.#requireSocket().groupMetadata(groupId);
+    return {
+      id: metadata.id,
+      subject: metadata.subject,
+      access: metadata.announce ? "closed" : "open",
+      addressingMode: metadata.addressingMode === "lid" ? "lid" : "pn",
+      fetchedAt: /* @__PURE__ */ new Date(),
+      participants: metadata.participants.map((participant) => ({
+        id: participant.id,
+        ...participant.lid ? { lid: participant.lid } : {},
+        ...participant.phoneNumber ? { phoneNumber: participant.phoneNumber } : {},
+        role: participant.admin === "superadmin" || participant.isSuperAdmin ? "owner" : participant.admin === "admin" || participant.isAdmin ? "admin" : "member"
+      }))
+    };
+  }
+  async setGroupAccess(groupId, access) {
+    const setting = access === "closed" ? "announcement" : "not_announcement";
+    await this.#requireSocket().groupSettingUpdate(groupId, setting);
+  }
+  async getGroupInviteCode(groupId) {
+    const code = await this.#requireSocket().groupInviteCode(groupId);
+    if (!code) {
+      throw new WhaNextError(
+        "PROVIDER_ERROR",
+        "WhatsApp did not return a group invite code."
+      );
+    }
+    return code;
+  }
+  async revokeGroupInvite(groupId) {
+    const code = await this.#requireSocket().groupRevokeInvite(groupId);
+    if (!code) {
+      throw new WhaNextError(
+        "PROVIDER_ERROR",
+        "WhatsApp did not return a new group invite code."
+      );
+    }
+    return code;
+  }
+  async setMessagePin(groupId, key, pinned) {
+    await this.#requireSocket().sendMessage(groupId, {
+      pin: this.#toWaKey(key),
+      type: pinned ? proto.PinInChat.Type.PIN_FOR_ALL : proto.PinInChat.Type.UNPIN_FOR_ALL,
+      ...pinned ? { time: 604800 } : {}
+    });
+  }
+  async updateParticipant(groupId, memberId, action) {
+    const [result] = await this.#requireSocket().groupParticipantsUpdate(groupId, [memberId], action);
+    const status = result?.status ?? "unknown";
+    return {
+      success: status === "200",
+      status,
+      ...result?.jid ? { memberId: result.jid } : {}
+    };
+  }
+  async setPresence(chatId, state) {
+    const socket = this.#requireSocket();
+    await socket.presenceSubscribe(chatId);
+    const presence = state === "typing" ? "composing" : state === "recording" ? "recording" : "paused";
+    await socket.sendPresenceUpdate(presence, chatId);
+  }
+  #bind(socket) {
+    socket.ev.on("creds.update", (update) => {
+      if (update.registered !== void 0) {
+        this.#registered = update.registered;
+      }
+      this.#saveQueue = this.#saveQueue.then(() => this.#saveCredentials?.()).then(() => void 0);
+    });
+    socket.ev.on("messages.upsert", ({ messages, type }) => {
+      if (type !== "notify") return;
+      for (const raw of messages) {
+        if (raw.key.id && raw.message) this.#remember(raw.key.id, raw.message);
+        const message = normalizeBaileysMessage(raw);
+        if (message) void this.#events.emit("message", message);
+      }
+    });
+    socket.ev.on("groups.update", (groups) => {
+      for (const group of groups) {
+        if (group.id) void this.#events.emit("groupChanged", { groupId: group.id });
+      }
+    });
+    socket.ev.on("group-participants.update", ({ id }) => {
+      void this.#events.emit("groupChanged", { groupId: id });
+    });
+    socket.ev.on("connection.update", (update) => {
+      void this.#handleConnectionUpdate(socket, update.connection, update.lastDisconnect?.error);
+    });
+  }
+  async #handleConnectionUpdate(socket, connection, error) {
+    if (socket !== this.#socket || !connection) return;
+    if (connection === "open") {
+      this.#reconnectAttempt = 0;
+      await this.#events.emit("connection", { state: "connected" });
+      return;
+    }
+    if (connection === "connecting") {
+      await this.#events.emit("connection", {
+        state: "connecting",
+        attempt: this.#reconnectAttempt
+      });
+      return;
+    }
+    this.#socket = void 0;
+    if (this.#intentionalClose || this.#isTerminal(error)) {
+      await this.#events.emit("connection", { state: "closed", ...error ? { error } : {} });
+      return;
+    }
+    await this.#scheduleReconnect(error);
+  }
+  async #scheduleReconnect(error) {
+    const options = this.#options.reconnect;
+    const maxAttempts = options?.maxAttempts ?? 10;
+    if (options?.enabled === false || this.#reconnectAttempt >= maxAttempts) {
+      await this.#events.emit("connection", { state: "closed", ...error ? { error } : {} });
+      return;
+    }
+    this.#reconnectAttempt += 1;
+    await this.#events.emit("connection", {
+      state: "reconnecting",
+      attempt: this.#reconnectAttempt,
+      ...error ? { error } : {}
+    });
+    const initial = options?.initialDelayMs ?? 1e3;
+    const maximum = options?.maxDelayMs ?? 3e4;
+    const delay = Math.min(maximum, initial * 2 ** (this.#reconnectAttempt - 1));
+    this.#reconnectTimer = setTimeout(
+      () => void this.connect(),
+      delay + Math.floor(Math.random() * 250)
+    );
+  }
+  #browserDescription() {
+    if (this.#options.browser === "macos" /* MacOS */) return Browsers.macOS("Chrome");
+    if (this.#options.browser === "ubuntu" /* Ubuntu */) return Browsers.ubuntu("Chrome");
+    return Browsers.windows("Chrome");
+  }
+  #isTerminal(error) {
+    const statusCode = this.#statusCode(error);
+    return statusCode === DisconnectReason.loggedOut || statusCode === DisconnectReason.badSession || statusCode === DisconnectReason.connectionReplaced;
+  }
+  #statusCode(error) {
+    return error?.output?.statusCode;
+  }
+  #requireSocket() {
+    if (!this.#socket) {
+      throw new WhaNextError(
+        "CONNECTION_CLOSED",
+        "WhatsApp is not connected.",
+        { recoverable: true }
+      );
+    }
+    return this.#socket;
+  }
+  #toContent(content) {
+    if ("text" in content) {
+      return {
+        text: content.text,
+        ...content.mentions ? { mentions: this.#mentions(content.mentions) } : {}
+      };
+    }
+    if ("image" in content) {
+      return {
+        image: this.#media(content.image),
+        ...content.caption !== void 0 ? { caption: content.caption } : {},
+        ...content.mentions ? { mentions: this.#mentions(content.mentions) } : {},
+        ...content.viewOnce !== void 0 ? { viewOnce: content.viewOnce } : {}
+      };
+    }
+    if ("video" in content) {
+      return {
+        video: this.#media(content.video),
+        ...content.caption !== void 0 ? { caption: content.caption } : {},
+        ...content.mentions ? { mentions: this.#mentions(content.mentions) } : {},
+        ...content.viewOnce !== void 0 ? { viewOnce: content.viewOnce } : {},
+        ...content.gif !== void 0 ? { gifPlayback: content.gif } : {}
+      };
+    }
+    return {
+      audio: this.#media(content.audio),
+      ...content.mimetype ? { mimetype: content.mimetype } : {},
+      ...content.voice !== void 0 ? { ptt: content.voice } : {}
+    };
+  }
+  #media(source) {
+    if (source instanceof Uint8Array) {
+      return Buffer.from(source);
+    }
+    if ("url" in source) {
+      return { url: source.url };
+    }
+    return { url: source.path };
+  }
+  #mentions(mentions) {
+    return mentions.map((mention) => typeof mention === "string" ? mention : mention.mentionId);
+  }
+  #toWaKey(key) {
+    return {
+      id: key.id,
+      remoteJid: key.chatId,
+      fromMe: key.fromMe,
+      ...key.participantId ? { participant: key.participantId } : {}
+    };
+  }
+  #sent(message) {
+    if (!message?.key.id || !message.key.remoteJid) {
+      throw new WhaNextError("PROVIDER_ERROR", "WhatsApp did not confirm the sent message.");
+    }
+    if (message.message) this.#remember(message.key.id, message.message);
+    return {
+      id: message.key.id,
+      chatId: message.key.remoteJid,
+      keys: normalizeKey(message.key),
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  #remember(id, message) {
+    this.#messageStore.set(id, message);
+    if (this.#messageStore.size > 500) {
+      const oldest = this.#messageStore.keys().next().value;
+      if (oldest) this.#messageStore.delete(oldest);
+    }
+  }
+};
+
+// src/app/create.ts
+async function create(options = {}) {
+  const logger = new Logger(options.logger);
+  const provider = options.provider ?? new BaileysProvider({
+    auth: options.auth ?? "./session",
+    browser: options.browser ?? "windows" /* Windows */,
+    logger: logger.child("provider"),
+    ...options.reconnect ? { reconnect: options.reconnect } : {}
+  });
+  return new WhaNextApp(provider, {
+    ...options.phone ? { phone: options.phone } : {},
+    ...options.prefix !== void 0 ? { prefix: options.prefix } : {},
+    ...options.cache ? { cache: options.cache } : {},
+    ...options.logger ? { logger: options.logger } : {},
+    ...options.mute ? { mute: options.mute } : {},
+    ...options.router ? { router: options.router } : {}
+  }, logger);
+}
+
+// src/commands/command.ts
+function defineCommand(command) {
+  return command;
+}
+export {
+  ArgsParser,
+  Browser,
+  CommandRouter,
+  Logger,
+  MemoryCache,
+  MuteService,
+  SqliteMuteStore,
+  User,
+  WhaNextApp,
+  WhaNextError,
+  create,
+  defineCommand,
+  toWhaNextError
+};
+//# sourceMappingURL=index.js.map