@squord/sdk 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3881 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ALL_PERMISSIONS: () => ALL_PERMISSIONS,
+  ActionRowBuilder: () => ActionRowBuilder,
+  ApplicationCommandsManager: () => ApplicationCommandsManager,
+  AuthenticationError: () => AuthenticationError,
+  BotManager: () => BotManager,
+  ButtonBuilder: () => ButtonBuilder,
+  Buttons: () => Buttons,
+  Cache: () => Cache,
+  Channel: () => Channel,
+  ChannelsManager: () => ChannelsManager,
+  CommandRegistry: () => CommandRegistry,
+  ComponentLimits: () => ComponentLimits,
+  DEFAULT_INTENTS: () => DEFAULT_INTENTS,
+  EmbedBuilder: () => EmbedBuilder,
+  EmbedLimits: () => EmbedLimits,
+  Gateway: () => Gateway,
+  GatewayError: () => GatewayError,
+  Guild: () => Guild,
+  GuildsManager: () => GuildsManager,
+  Intents: () => Intents,
+  Interaction: () => Interaction,
+  InteractionsManager: () => InteractionsManager,
+  InvalidTokenError: () => InvalidTokenError,
+  Member: () => Member,
+  MembersManager: () => MembersManager,
+  Message: () => Message,
+  MessagesManager: () => MessagesManager,
+  ModerationManager: () => ModerationManager,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  PermissionError: () => PermissionError,
+  Permissions: () => Permissions,
+  RateLimitError: () => RateLimitError,
+  RequestTimeoutError: () => RequestTimeoutError,
+  RestClient: () => RestClient,
+  Role: () => Role,
+  RolesManager: () => RolesManager,
+  SUGGESTED_MODERATION_PERMISSIONS: () => SUGGESTED_MODERATION_PERMISSIONS,
+  SUGGESTED_TEXT_BOT_PERMISSIONS: () => SUGGESTED_TEXT_BOT_PERMISSIONS,
+  SelectMenuBuilder: () => SelectMenuBuilder,
+  SquordAPIError: () => SquordAPIError,
+  SquordClient: () => SquordClient,
+  SquordError: () => SquordError,
+  SquordTypeError: () => SquordTypeError,
+  Thread: () => Thread,
+  UploadsManager: () => UploadsManager,
+  User: () => User,
+  UsersManager: () => UsersManager,
+  ValidationError: () => ValidationError,
+  assertSnowflake: () => assertSnowflake,
+  attachWebSocket: () => attachWebSocket,
+  backoffDelay: () => backoffDelay,
+  channelMention: () => channelMention,
+  collectPagination: () => collectPagination,
+  compareSnowflakes: () => compareSnowflakes,
+  createConsoleLogger: () => createConsoleLogger,
+  hasAnyPermission: () => hasAnyPermission,
+  hasPermissions: () => hasPermissions,
+  intentsValue: () => intentsValue,
+  isValidSnowflake: () => isValidSnowflake,
+  listIntents: () => listIntents,
+  loggerFromEnv: () => loggerFromEnv,
+  makeAPIError: () => makeAPIError,
+  noopLogger: () => noopLogger,
+  normalizeEmbedColor: () => normalizeEmbedColor,
+  paginate: () => paginate,
+  parsePermissions: () => parsePermissions,
+  permissionsToString: () => permissionsToString,
+  redact: () => redact,
+  resolveChannelPermissions: () => resolveChannelPermissions,
+  resolveMessagePayload: () => resolveMessagePayload,
+  roleMention: () => roleMention,
+  routeKeyOf: () => routeKeyOf,
+  sleep: () => sleep,
+  splitArguments: () => splitArguments,
+  userMention: () => userMention
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/TypedEmitter.ts
+var TypedEmitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  /** Registra um handler. Devolve uma função que o remove. */
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    return () => this.off(event, handler);
+  }
+  /** Registra um handler que é removido após a primeira chamada. */
+  once(event, handler) {
+    const wrapper = ((...args) => {
+      this.off(event, wrapper);
+      void handler(...args);
+    });
+    return this.on(event, wrapper);
+  }
+  /** Remove um handler (ou todos do evento, se omitido). */
+  off(event, handler) {
+    if (!handler) {
+      this.handlers.delete(event);
+      return;
+    }
+    this.handlers.get(event)?.delete(handler);
+  }
+  /** Remove todos os handlers de todos os eventos. */
+  removeAllListeners() {
+    this.handlers.clear();
+  }
+  /** Emite um evento. Erros síncronos de handlers propagam para `error`. */
+  emit(event, ...args) {
+    const set = this.handlers.get(event);
+    if (!set || set.size === 0) return false;
+    for (const handler of [...set]) {
+      try {
+        const result = handler(...args);
+        if (result instanceof Promise) {
+          void result.catch((err) => this.handleAsyncError(event, err));
+        }
+      } catch (err) {
+        this.handleAsyncError(event, err);
+      }
+    }
+    return true;
+  }
+  /** Quantos handlers estão registrados para um evento. */
+  listenerCount(event) {
+    return this.handlers.get(event)?.size ?? 0;
+  }
+  /** Nomes de eventos com pelo menos um handler. */
+  eventNames() {
+    return [...this.handlers.keys()].filter((k) => (this.handlers.get(k)?.size ?? 0) > 0);
+  }
+  handleAsyncError(event, err) {
+    if (event === "error") throw err;
+    const error = err instanceof Error ? err : new Error(String(err));
+    this.emit("error", error);
+  }
+};
+
+// src/managers/appCommands.ts
+var ApplicationCommandsManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  rest;
+  /** Lista os comandos globais do bot. */
+  listGlobal(signal) {
+    return this.rest.get("/bots/@me/commands", { signal });
+  }
+  /** Sobrescreve os comandos globais (idempotente por ser PUT). */
+  setGlobal(commands, signal) {
+    return this.rest.put("/bots/@me/commands", commands, { signal });
+  }
+  /** Lista os comandos de um Space. */
+  listGuild(guildId, signal) {
+    return this.rest.get(`/bots/@me/guilds/${guildId}/commands`, { signal });
+  }
+  /** Sobrescreve os comandos de um Space (o bot precisa estar instalado nele). */
+  setGuild(guildId, commands, signal) {
+    return this.rest.put(`/bots/@me/guilds/${guildId}/commands`, commands, {
+      signal
+    });
+  }
+};
+
+// src/managers/bots.ts
+var BotManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  rest;
+  /** `GET /bots/@me`: o bot na visão do dono (inclui as intents configuradas). */
+  fetchCurrent(signal) {
+    return this.rest.get("/bots/@me", { signal });
+  }
+  /** `GET /bots/{botId}`: o cartão público de um bot. */
+  fetch(botId, signal) {
+    return this.rest.get(`/bots/${botId}`, { signal });
+  }
+};
+var UsersManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  rest;
+  /** `GET /users/@me`: a própria conta (em um bot, campos privados são padrão). */
+  fetchMe(signal) {
+    return this.rest.get("/users/@me", { signal });
+  }
+};
+
+// src/managers/channels.ts
+var ChannelsManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  rest;
+  /** Busca um canal (ou uma thread, que também é canal) pelo id. */
+  fetch(channelId, signal) {
+    return this.rest.get(`/channels/${channelId}`, { signal });
+  }
+  /**
+   * Lista a árvore de canais do Space: grupos por categoria.
+   * Requer que o bot veja os canais (`VIEW_CHANNEL` do cargo dele).
+   */
+  fetchTree(guildId, signal) {
+    return this.rest.get(`/guilds/${guildId}/channels`, { signal });
+  }
+  /** Cria uma thread em um canal de texto ou de anúncios. */
+  createThread(channelId, body, options = {}) {
+    return this.rest.post(`/channels/${channelId}/threads`, body, {
+      signal: options.signal,
+      retryable: false
+    });
+  }
+  /** Cria um post em um canal de fórum (a primeira mensagem vai no corpo). */
+  createForumPost(channelId, body, options = {}) {
+    return this.rest.post(`/channels/${channelId}/threads`, body, {
+      signal: options.signal,
+      retryable: false
+    });
+  }
+  /** Cria uma thread a partir de uma mensagem de um canal de texto/anúncios. */
+  createThreadFromMessage(channelId, messageId, body, options = {}) {
+    return this.rest.post(
+      `/channels/${channelId}/messages/${messageId}/threads`,
+      body,
+      { signal: options.signal, retryable: false }
+    );
+  }
+  /** Lista uma página de threads do canal (`cursor` = `nextCursor` anterior). */
+  listThreads(channelId, params = {}, signal) {
+    return this.rest.get(`/channels/${channelId}/threads`, {
+      query: {
+        limit: params.limit,
+        cursor: params.after ?? params.before,
+        archived: params.archived,
+        tagId: params.tagId
+      },
+      signal
+    });
+  }
+};
+
+// src/errors/index.ts
+var SquordError = class extends Error {
+  /** Código estável do erro, em `SCREAMING_SNAKE`. */
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = new.target.name;
+    this.code = code;
+  }
+};
+var SquordAPIError = class extends SquordError {
+  /** Status HTTP da resposta. */
+  status;
+  /** O mesmo valor do header `x-request-id` da resposta. */
+  requestId;
+  /** Corpo bruto do erro (o envelope completo), quando disponível. */
+  responseBody;
+  /** `details` do envelope, quando existe. */
+  details;
+  constructor(body, status, requestId) {
+    super(body.code, body.message ?? `Erro da API do Squord (HTTP ${status})`);
+    this.status = status;
+    this.requestId = requestId ?? body.requestId ?? null;
+    this.details = body.details;
+    this.responseBody = body;
+  }
+};
+var AuthenticationError = class extends SquordAPIError {
+};
+var InvalidTokenError = class extends AuthenticationError {
+};
+var PermissionError = class extends SquordAPIError {
+  /** Nome da permissão que faltou, quando o erro é `MISSING_PERMISSION`. */
+  missingPermission;
+  constructor(body, status, requestId) {
+    super(body, status, requestId);
+    const details = body.details;
+    this.missingPermission = details?.permission ?? null;
+  }
+};
+var NotFoundError = class extends SquordAPIError {
+};
+var ValidationError = class extends SquordAPIError {
+  /** Os itens de validação (campo, código do item, limite violado). */
+  issues;
+  constructor(body, status, requestId) {
+    super(body, status, requestId);
+    this.issues = Array.isArray(body.details) ? body.details : [];
+  }
+};
+var RateLimitError = class extends SquordAPIError {
+  /** Segundos de espera informados pelo servidor (mínimo 1). */
+  retryAfter;
+  /** O bucket que recusou (`MESSAGE_CREATE`, `BOT_GLOBAL`, ...). */
+  bucket;
+  /** `true` quando o SDK já esgotou as retentativas automáticas. */
+  exhaustedRetries;
+  constructor(body, status, options) {
+    super(body, status, options?.requestId);
+    const details = body.details;
+    this.retryAfter = details?.retryAfter ?? 1;
+    this.bucket = details?.bucket ?? null;
+    this.exhaustedRetries = options?.exhaustedRetries ?? false;
+  }
+};
+var NetworkError = class extends SquordError {
+  constructor(message, options) {
+    super("NETWORK_ERROR", message, options);
+  }
+};
+var RequestTimeoutError = class extends SquordError {
+  /** Milissegundos configurados de timeout. */
+  timeoutMs;
+  /** Método HTTP da requisição que expirou. */
+  method;
+  /** Caminho da requisição que expirou. */
+  path;
+  constructor(method, path, timeoutMs, options) {
+    super(
+      "REQUEST_TIMEOUT",
+      `A requisi\xE7\xE3o ${method} ${path} excedeu o timeout de ${timeoutMs} ms`,
+      options
+    );
+    this.method = method;
+    this.path = path;
+    this.timeoutMs = timeoutMs;
+  }
+};
+var GatewayError = class extends SquordError {
+  /** Código de fechamento (4000+) ou `null` em falhas de rede. */
+  closeCode;
+  /** Razão textual enviada pelo servidor (informativa; use `closeCode`). */
+  reason;
+  constructor(closeCode, reason, message) {
+    super(
+      closeCode === null ? "GATEWAY_NETWORK_ERROR" : "GATEWAY_CLOSE",
+      message ?? `Gateway fechou a conex\xE3o${closeCode !== null ? ` (c\xF3digo ${closeCode})` : ""}${reason ? `: ${reason}` : ""}`,
+      { cause: void 0 }
+    );
+    this.closeCode = closeCode;
+    this.reason = reason;
+  }
+};
+var SquordTypeError = class extends SquordError {
+  constructor(message) {
+    super("SDK_INVALID_ARGUMENT", message);
+  }
+};
+function makeAPIError(body, status, requestId) {
+  switch (status) {
+    case 401:
+      return body.code === "INVALID_TOKEN" ? new InvalidTokenError(body, status, requestId) : new AuthenticationError(body, status, requestId);
+    case 403:
+      return new PermissionError(body, status, requestId);
+    case 404:
+      return new NotFoundError(body, status, requestId);
+    case 422:
+      return new ValidationError(body, status, requestId);
+    case 429:
+      return new RateLimitError(body, status, { requestId });
+    default:
+      return new SquordAPIError(body, status, requestId);
+  }
+}
+
+// src/builders/components.ts
+var ComponentLimits = {
+  RowsPerMessage: 5,
+  ButtonsPerRow: 5,
+  CustomId: 100,
+  Label: 80,
+  OptionsPerMenu: 25
+};
+var ButtonBuilder = class {
+  constructor(style, labelValue) {
+    this.style = style;
+    this.labelValue = labelValue;
+  }
+  style;
+  labelValue;
+  customIdValue;
+  urlValue;
+  disabledValue = false;
+  /** Identificador da ação; obrigatório (e único na mensagem) fora do estilo `link`. */
+  setCustomId(customId) {
+    assertCustomId(customId);
+    this.customIdValue = customId;
+    return this;
+  }
+  /** URL aberta ao clicar; obrigatória e exclusiva do estilo `link`. */
+  setURL(url) {
+    if (!/^https:\/\//.test(url)) {
+      throw new SquordTypeError(`Bot\xE3o de link exige URL https:// (recebido: ${url})`);
+    }
+    this.urlValue = url;
+    return this;
+  }
+  setDisabled(disabled) {
+    this.disabledValue = disabled;
+    return this;
+  }
+  setLabel(label) {
+    this.labelValue = label;
+    return this;
+  }
+  build() {
+    if (this.style === "link" && !this.urlValue) {
+      throw new SquordTypeError("Bot\xE3o de link exige setURL(...)");
+    }
+    if (this.style !== "link" && !this.customIdValue) {
+      throw new SquordTypeError(`Bot\xE3o de estilo ${this.style} exige setCustomId(...)`);
+    }
+    if (this.labelValue.length > ComponentLimits.Label) {
+      throw new SquordTypeError(`Label de bot\xE3o excede ${ComponentLimits.Label} caracteres`);
+    }
+    return {
+      type: "button",
+      style: this.style,
+      label: this.labelValue,
+      customId: this.style === "link" ? void 0 : this.customIdValue,
+      url: this.style === "link" ? this.urlValue : void 0,
+      disabled: this.disabledValue || void 0
+    };
+  }
+};
+var SelectMenuBuilder = class {
+  constructor(customId) {
+    this.customId = customId;
+    assertCustomId(customId);
+  }
+  customId;
+  placeholderValue;
+  minValuesValue;
+  maxValuesValue;
+  disabledValue = false;
+  optionsValue = [];
+  setPlaceholder(placeholder) {
+    if (placeholder.length > 150) {
+      throw new SquordTypeError("Placeholder de menu excede 150 caracteres");
+    }
+    this.placeholderValue = placeholder;
+    return this;
+  }
+  setMinValues(min) {
+    this.minValuesValue = min;
+    return this;
+  }
+  setMaxValues(max) {
+    this.maxValuesValue = max;
+    return this;
+  }
+  setDisabled(disabled) {
+    this.disabledValue = disabled;
+    return this;
+  }
+  addOption(option) {
+    if (this.optionsValue.length >= ComponentLimits.OptionsPerMenu) {
+      throw new SquordTypeError(`Menu aceita no m\xE1ximo ${ComponentLimits.OptionsPerMenu} op\xE7\xF5es`);
+    }
+    if (!option.label || !option.value) {
+      throw new SquordTypeError("Op\xE7\xE3o de menu exige label e value");
+    }
+    if (option.label.length > ComponentLimits.Label || option.value.length > 100) {
+      throw new SquordTypeError("Label de op\xE7\xE3o: at\xE9 80 caracteres; value: at\xE9 100");
+    }
+    this.optionsValue.push(option);
+    return this;
+  }
+  addOptions(...options) {
+    for (const option of options) this.addOption(option);
+    return this;
+  }
+  build() {
+    if (this.optionsValue.length === 0) {
+      throw new SquordTypeError("Menu de sele\xE7\xE3o precisa de ao menos uma op\xE7\xE3o");
+    }
+    const min = this.minValuesValue ?? 1;
+    const max = this.maxValuesValue ?? Math.max(1, this.optionsValue.length);
+    if (min > max) {
+      throw new SquordTypeError(`minValues (${min}) n\xE3o pode passar de maxValues (${max})`);
+    }
+    return {
+      type: "select",
+      customId: this.customId,
+      placeholder: this.placeholderValue,
+      minValues: this.minValuesValue,
+      maxValues: this.maxValuesValue,
+      disabled: this.disabledValue || void 0,
+      options: [...this.optionsValue]
+    };
+  }
+};
+var ActionRowBuilder = class {
+  components = [];
+  /** Adiciona um botão (até 5 por linha). */
+  addButton(button) {
+    if (this.components.length >= ComponentLimits.ButtonsPerRow || this.components.some((c) => c.type === "select")) {
+      throw new SquordTypeError("Uma linha aceita at\xE9 5 bot\xF5es e n\xE3o mistura bot\xF5es com menus");
+    }
+    this.components.push(button instanceof ButtonBuilder ? button.build() : button);
+    return this;
+  }
+  /** Define o menu da linha (exatamente 1, sozinho). */
+  setSelectMenu(menu) {
+    if (this.components.length > 0) {
+      throw new SquordTypeError("Um menu ocupa a linha sozinho; n\xE3o misture com bot\xF5es");
+    }
+    this.components.push(menu instanceof SelectMenuBuilder ? menu.build() : menu);
+    return this;
+  }
+  addComponents(...components) {
+    for (const component of components) {
+      if (component instanceof ButtonBuilder || "type" in component && component.type === "button") {
+        this.addButton(component);
+      } else {
+        this.setSelectMenu(component);
+      }
+    }
+    return this;
+  }
+  build() {
+    if (this.components.length === 0) {
+      throw new SquordTypeError("Linha de componentes vazia");
+    }
+    return { type: "row", components: [...this.components] };
+  }
+};
+var Buttons = {
+  primary: (label) => new ButtonBuilder("primary", label),
+  secondary: (label) => new ButtonBuilder("secondary", label),
+  danger: (label) => new ButtonBuilder("danger", label),
+  link: (label) => new ButtonBuilder("link", label)
+};
+function assertCustomId(customId) {
+  if (typeof customId !== "string" || customId.length < 1 || customId.length > ComponentLimits.CustomId) {
+    throw new SquordTypeError(
+      `customId precisa ter de 1 a ${ComponentLimits.CustomId} caracteres`
+    );
+  }
+}
+
+// src/builders/embed.ts
+var EmbedLimits = {
+  EmbedsPerMessage: 10,
+  FieldsPerEmbed: 25,
+  Title: 256,
+  Description: 4096,
+  FieldName: 256,
+  FieldValue: 1024,
+  FooterText: 2048,
+  AuthorName: 256,
+  TotalTextPerMessage: 6e3
+};
+function normalizeEmbedColor(color) {
+  if (typeof color === "number") {
+    if (!Number.isInteger(color) || color < 0 || color > 16777215) {
+      throw new SquordTypeError(
+        `Cor de embed inv\xE1lida: ${color} \u2014 use um inteiro de 0 a 16777215 ou "#rrggbb"`
+      );
+    }
+    return color;
+  }
+  const trimmed = color.trim();
+  const hex = trimmed.startsWith("#") ? trimmed.slice(1) : trimmed;
+  if (!/^[0-9a-fA-F]{6}$/.test(hex)) {
+    throw new SquordTypeError(`Cor de embed inv\xE1lida: ${JSON.stringify(color)} \u2014 use "#rrggbb"`);
+  }
+  return Number.parseInt(hex, 16);
+}
+var EmbedBuilder = class _EmbedBuilder {
+  titleValue = null;
+  descriptionValue = null;
+  urlValue = null;
+  colorValue = null;
+  timestampValue = null;
+  authorValue = null;
+  footerValue = null;
+  imageValue = null;
+  thumbnailValue = null;
+  fieldsValue = [];
+  /** Título do embed (até 256 caracteres). */
+  setTitle(title) {
+    assertLength("title", title, EmbedLimits.Title);
+    this.titleValue = title;
+    return this;
+  }
+  /** Descrição (até 4096 caracteres). */
+  setDescription(description) {
+    assertLength("description", description, EmbedLimits.Description);
+    this.descriptionValue = description;
+    return this;
+  }
+  /** URL do título (só `http://` ou `https://`). */
+  setURL(url) {
+    assertHttpUrl("url", url);
+    this.urlValue = url;
+    return this;
+  }
+  /** Cor: inteiro de 0 a 16777215 ou `#rrggbb`. */
+  setColor(color) {
+    this.colorValue = normalizeEmbedColor(color);
+    return this;
+  }
+  /** Momento exibido no rodapé. Um `Date` ou string ISO 8601 com fuso. */
+  setTimestamp(timestamp = /* @__PURE__ */ new Date()) {
+    this.timestampValue = timestamp instanceof Date ? timestamp.toISOString() : timestamp;
+    return this;
+  }
+  /** Autor exibido no topo (nome até 256 caracteres). */
+  setAuthor(author) {
+    if (author) {
+      assertLength("author.name", author.name, EmbedLimits.AuthorName);
+      if (author.url) assertHttpUrl("author.url", author.url);
+    }
+    this.authorValue = author;
+    return this;
+  }
+  /** Rodapé (texto até 2048 caracteres). */
+  setFooter(footer) {
+    if (footer) {
+      assertLength("footer.text", footer.text, EmbedLimits.FooterText);
+    }
+    this.footerValue = footer;
+    return this;
+  }
+  /** Imagem principal (baixada e hospedada pelo Squord em segundo plano). */
+  setImage(url) {
+    this.imageValue = url;
+    return this;
+  }
+  /** Miniatura. */
+  setThumbnail(url) {
+    this.thumbnailValue = url;
+    return this;
+  }
+  /** Adiciona um campo (nome até 256, valor até 1024). */
+  addField(name, value, inline = false) {
+    return this.addFields({ name, value, inline });
+  }
+  /** Adiciona vários campos. */
+  addFields(...fields) {
+    if (this.fieldsValue.length + fields.length > EmbedLimits.FieldsPerEmbed) {
+      throw new SquordTypeError(
+        `Um embed aceita no m\xE1ximo ${EmbedLimits.FieldsPerEmbed} campos`
+      );
+    }
+    for (const field of fields) {
+      assertLength("field.name", field.name, EmbedLimits.FieldName);
+      assertLength("field.value", field.value, EmbedLimits.FieldValue);
+      this.fieldsValue.push(field);
+    }
+    return this;
+  }
+  /** Remove todos os campos. */
+  clearFields() {
+    this.fieldsValue = [];
+    return this;
+  }
+  /** Payload pronto para o campo `embeds` (só campos preenchidos). */
+  build() {
+    if (!this.titleValue && !this.descriptionValue && !this.imageValue && !this.thumbnailValue && this.fieldsValue.length === 0 && !this.footerValue && !this.authorValue) {
+      throw new SquordTypeError(
+        "O embed n\xE3o tem nada vis\xEDvel: defina t\xEDtulo, descri\xE7\xE3o, campos, imagem ou rodap\xE9 (o Squord recusa embeds vazios com BLANK)"
+      );
+    }
+    const embed = {};
+    if (this.titleValue) embed.title = this.titleValue;
+    if (this.descriptionValue) embed.description = this.descriptionValue;
+    if (this.urlValue) embed.url = this.urlValue;
+    if (this.colorValue !== null) embed.color = this.colorValue;
+    if (this.timestampValue) embed.timestamp = this.timestampValue;
+    if (this.authorValue) {
+      const author = { name: this.authorValue.name };
+      if (this.authorValue.url) author.url = this.authorValue.url;
+      if (this.authorValue.iconUrl) author.icon_url = this.authorValue.iconUrl;
+      embed.author = author;
+    }
+    if (this.footerValue) {
+      const footer = { text: this.footerValue.text };
+      if (this.footerValue.iconUrl) footer.icon_url = this.footerValue.iconUrl;
+      embed.footer = footer;
+    }
+    if (this.imageValue) embed.image = { url: this.imageValue };
+    if (this.thumbnailValue) embed.thumbnail = { url: this.thumbnailValue };
+    if (this.fieldsValue.length > 0) embed.fields = [...this.fieldsValue];
+    return embed;
+  }
+  /** Soma dos textos do embed (para conferir o limite de 6000 por mensagem). */
+  get textLength() {
+    let total = 0;
+    if (this.titleValue) total += this.titleValue.length;
+    if (this.descriptionValue) total += this.descriptionValue.length;
+    if (this.footerValue) total += this.footerValue.text.length;
+    if (this.authorValue) total += this.authorValue.name.length;
+    for (const field of this.fieldsValue) {
+      total += field.name.length + field.value.length;
+    }
+    return total;
+  }
+  /** Cria um builder a partir de um payload existente. */
+  static from(embed) {
+    const builder = new _EmbedBuilder();
+    if (embed.title) builder.setTitle(embed.title);
+    if (embed.description) builder.setDescription(embed.description);
+    if (embed.url) builder.setURL(embed.url);
+    if (embed.color != null) builder.setColor(embed.color);
+    if (embed.timestamp) builder.setTimestamp(embed.timestamp);
+    if ("author" in embed && embed.author) {
+      builder.setAuthor({
+        name: embed.author.name,
+        url: "url" in embed.author ? embed.author.url ?? void 0 : void 0,
+        iconUrl: "iconUrl" in embed.author ? embed.author.iconUrl ?? void 0 : void 0
+      });
+    }
+    if ("footer" in embed && embed.footer) {
+      builder.setFooter({
+        text: embed.footer.text,
+        iconUrl: "iconUrl" in embed.footer ? embed.footer.iconUrl ?? void 0 : void 0
+      });
+    }
+    if ("fields" in embed && Array.isArray(embed.fields) && embed.fields.length > 0) {
+      builder.addFields(...embed.fields);
+    }
+    const image = "image" in embed ? embed.image : null;
+    if (image && "url" in image) builder.setImage(image.url);
+    const thumbnail = "thumbnail" in embed ? embed.thumbnail : null;
+    if (thumbnail && "url" in thumbnail) builder.setThumbnail(thumbnail.url);
+    return builder;
+  }
+};
+function assertLength(field, value, max) {
+  if (value.length > max) {
+    throw new SquordTypeError(`Embed.${field} excede ${max} caracteres (${value.length})`);
+  }
+}
+function assertHttpUrl(field, url) {
+  if (!/^https?:\/\//.test(url)) {
+    throw new SquordTypeError(`Embed.${field} precisa ser http:// ou https:// (recebido: ${url})`);
+  }
+}
+
+// src/builders/message.ts
+var SAFE_ALLOWED_MENTIONS = { users: true, roles: false, everyone: false };
+function resolveMessagePayload(payload) {
+  const source = typeof payload === "string" ? { content: payload } : payload;
+  const body = {};
+  let hasVisibleContent = false;
+  if (source.content !== void 0) {
+    if (typeof source.content !== "string") {
+      throw new SquordTypeError("content precisa ser string");
+    }
+    if (source.content.length > 4e3) {
+      throw new SquordTypeError(`content excede 4000 caracteres (${source.content.length})`);
+    }
+    body.content = source.content;
+    if (source.content.length > 0) hasVisibleContent = true;
+  }
+  if (source.embeds !== void 0) {
+    if (!Array.isArray(source.embeds) || source.embeds.length > 10) {
+      throw new SquordTypeError("embeds aceita at\xE9 10 itens");
+    }
+    body.embeds = source.embeds.map(
+      (embed) => embed instanceof EmbedBuilder ? embed.build() : embed
+    );
+    if (body.embeds.length > 0) hasVisibleContent = true;
+  }
+  if (source.components !== void 0) {
+    if (!Array.isArray(source.components) || source.components.length > 5) {
+      throw new SquordTypeError("components aceita at\xE9 5 linhas");
+    }
+    body.components = source.components.map(
+      (row) => row instanceof ActionRowBuilder ? row.build() : row
+    );
+    if (body.components.length > 0) hasVisibleContent = true;
+  }
+  body.allowedMentions = source.allowedMentions ?? SAFE_ALLOWED_MENTIONS;
+  if (source.replyToId !== void 0) {
+    body.replyToId = source.replyToId;
+  }
+  if (source.attachmentIds !== void 0) {
+    if (!Array.isArray(source.attachmentIds) || source.attachmentIds.length > 10) {
+      throw new SquordTypeError("attachmentIds aceita at\xE9 10 itens");
+    }
+    body.attachmentIds = source.attachmentIds;
+    if (body.attachmentIds.length > 0) hasVisibleContent = true;
+  }
+  if (source.nonce !== void 0) {
+    if (typeof source.nonce !== "string" || source.nonce.length > 64) {
+      throw new SquordTypeError("nonce precisa ser string de at\xE9 64 caracteres");
+    }
+    body.nonce = source.nonce;
+  }
+  if (source.ephemeral !== void 0) {
+    body.ephemeral = source.ephemeral;
+  }
+  if (!hasVisibleContent) {
+    throw new SquordTypeError(
+      "A mensagem precisa de ao menos um entre content (n\xE3o vazio), embeds, components e attachmentIds"
+    );
+  }
+  return body;
+}
+function resolveMessageEditPayload(payload) {
+  const source = typeof payload === "string" ? { content: payload } : payload;
+  const body = {};
+  let hasField = false;
+  if (source.content !== void 0) {
+    if (source.content.length > 4e3) {
+      throw new SquordTypeError(`content excede 4000 caracteres (${source.content.length})`);
+    }
+    body.content = source.content;
+    hasField = true;
+  }
+  if (source.embeds !== void 0) {
+    body.embeds = source.embeds.map(
+      (embed) => embed instanceof EmbedBuilder ? embed.build() : embed
+    );
+    hasField = true;
+  }
+  if (source.components !== void 0) {
+    body.components = source.components.map(
+      (row) => row instanceof ActionRowBuilder ? row.build() : row
+    );
+    hasField = true;
+  }
+  if (source.allowedMentions !== void 0) {
+    body.allowedMentions = source.allowedMentions;
+  }
+  if (!hasField) {
+    throw new SquordTypeError(
+      "Edi\xE7\xE3o precisa de ao menos um entre content, embeds e components (EMPTY_UPDATE)"
+    );
+  }
+  return body;
+}
+function safeAllowedMentions(allowed) {
+  return allowed ?? SAFE_ALLOWED_MENTIONS;
+}
+
+// src/managers/interactions.ts
+var InteractionsManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  rest;
+  /**
+   * Primeira resposta a uma interação (`type`: `MESSAGE`, `DEFERRED`,
+   * `UPDATE` ou `DEFERRED_UPDATE`). Resolve em `204` (sem corpo).
+   *
+   * Não é retentável automaticamente: uma repetição pode encontrar
+   * `409 INTERACTION_ALREADY_ACKNOWLEDGED`. O SDK trata esse 409 como
+   * "resposta já entregue" e resolve sem erro (veja `reply`).
+   */
+  callback(interactionId, interactionToken, body, signal) {
+    return this.rest.post(`/interactions/${interactionId}/${interactionToken}/callback`, body, {
+      auth: false,
+      signal,
+      retryable: false
+    }).then(() => void 0);
+  }
+  /**
+   * Follow-up depois da primeira resposta. Age como `MESSAGE`: cria uma
+   * mensagem (ou resposta efêmera). Responde `204`.
+   */
+  followup(interactionId, interactionToken, data, signal) {
+    return this.rest.post(`/interactions/${interactionId}/${interactionToken}/followups`, data, {
+      auth: false,
+      signal,
+      retryable: false
+    }).then(() => void 0);
+  }
+  /**
+   * Resposta `MESSAGE` com payload conveniente (string ou objeto).
+   * Um `409 INTERACTION_ALREADY_ACKNOWLEDGED` é tratado como sucesso:
+   * significa que a resposta já foi entregue (por exemplo, após um timeout
+   * de rede em que a primeira tentativa chegou ao servidor).
+   */
+  async reply(interactionId, interactionToken, payload, options = {}) {
+    const data = resolveMessagePayload(payload);
+    if (options.ephemeral) data.ephemeral = true;
+    try {
+      await this.callback(interactionId, interactionToken, { type: "MESSAGE", data }, options.signal);
+    } catch (err) {
+      if (isAlreadyAcknowledged(err)) return;
+      throw err;
+    }
+  }
+  /** `DEFERRED`: avisa que o bot está processando ("pensando"). Depois, use follow-ups. */
+  async defer(interactionId, interactionToken, options = {}) {
+    try {
+      await this.callback(
+        interactionId,
+        interactionToken,
+        { type: "DEFERRED" },
+        options.signal
+      );
+    } catch (err) {
+      if (isAlreadyAcknowledged(err)) return;
+      throw err;
+    }
+  }
+  /** `UPDATE` (só componente): edita a mensagem que tinha o componente clicado. */
+  async update(interactionId, interactionToken, payload, options = {}) {
+    const data = resolveMessagePayload(payload);
+    try {
+      await this.callback(
+        interactionId,
+        interactionToken,
+        { type: "UPDATE", data },
+        options.signal
+      );
+    } catch (err) {
+      if (isAlreadyAcknowledged(err)) return;
+      throw err;
+    }
+  }
+  /** `DEFERRED_UPDATE` (só componente): confirma o clique sem mudar nada. */
+  async acknowledgeComponent(interactionId, interactionToken, options = {}) {
+    try {
+      await this.callback(
+        interactionId,
+        interactionToken,
+        { type: "DEFERRED_UPDATE" },
+        options.signal
+      );
+    } catch (err) {
+      if (isAlreadyAcknowledged(err)) return;
+      throw err;
+    }
+  }
+};
+function isAlreadyAcknowledged(err) {
+  return typeof err === "object" && err !== null && err.status === 409 && err.code === "INTERACTION_ALREADY_ACKNOWLEDGED";
+}
+
+// src/managers/members.ts
+var GuildsManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  rest;
+  /** Busca um Space pelo id, com o bloco `self` do bot nele. */
+  fetch(guildId, signal) {
+    return this.rest.get(`/guilds/${guildId}`, { signal });
+  }
+};
+var MembersManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  rest;
+  /** Busca um membro de um Space. */
+  fetch(guildId, userId, signal) {
+    return this.rest.get(`/guilds/${guildId}/members/${userId}`, { signal });
+  }
+  /** Lista membros com paginação por cursor e filtros. */
+  list(guildId, params = {}, signal) {
+    return this.rest.get(`/guilds/${guildId}/members`, {
+      query: {
+        limit: params.limit,
+        before: params.before,
+        after: params.after,
+        roleId: params.roleId,
+        search: params.search,
+        channelId: params.channelId
+      },
+      signal
+    });
+  }
+  /**
+   * Edita um membro: apelido, cargos (substituem o conjunto), timeout,
+   * silenciamento. O bot precisa das permissões correspondentes.
+   */
+  edit(guildId, userId, body, options = {}) {
+    return this.rest.patch(`/guilds/${guildId}/members/${userId}`, body, {
+      signal: options.signal,
+      // PATCH de membro é substituição declarativa; seguro repetir.
+      retryable: true
+    });
+  }
+  /** Aplica um timeout até a data informada (`TIMEOUT_MEMBERS`). */
+  timeout(guildId, userId, until, options) {
+    return this.edit(guildId, userId, { timeoutUntil: until }, options);
+  }
+  /** Remove o timeout de um membro. */
+  removeTimeout(guildId, userId, options) {
+    return this.edit(guildId, userId, { timeoutUntil: null }, options);
+  }
+  /** Expulsa um membro (`KICK_MEMBERS`). Ele pode voltar com um novo convite. */
+  kick(guildId, userId, reason, options = {}) {
+    return this.rest.delete(`/guilds/${guildId}/members/${userId}`, {
+      body: reason ? { reason } : {},
+      signal: options.signal
+    }).then(() => void 0);
+  }
+  /** Dá um cargo a um membro (`MANAGE_ROLES`, hierarquia abaixo do bot). */
+  addRole(guildId, userId, roleId, options = {}) {
+    return this.rest.put(`/guilds/${guildId}/members/${userId}/roles/${roleId}`, void 0, {
+      signal: options.signal
+    }).then(() => void 0);
+  }
+  /** Tira um cargo de um membro. */
+  removeRole(guildId, userId, roleId, options = {}) {
+    return this.rest.delete(`/guilds/${guildId}/members/${userId}/roles/${roleId}`, {
+      signal: options.signal
+    }).then(() => void 0);
+  }
+};
+var RolesManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  rest;
+  /** Lista os cargos de um Space. */
+  list(guildId, signal) {
+    return this.rest.get(`/guilds/${guildId}/roles`, { signal });
+  }
+};
+var ModerationManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  rest;
+  /**
+   * Ban um membro (`BAN_MEMBERS`). Pode apagar até 7 dias de histórico
+   * recente com `deleteMessageSeconds`. Não é retentável por padrão.
+   */
+  ban(guildId, userId, body = {}, options = {}) {
+    return this.rest.put(`/guilds/${guildId}/bans/${userId}`, body, {
+      signal: options.signal,
+      retryable: false
+    });
+  }
+  /** Desbane (`BAN_MEMBERS`). Banimentos da plataforma não podem ser desfeitos. */
+  unban(guildId, userId, options = {}) {
+    return this.rest.delete(`/guilds/${guildId}/bans/${userId}`, { signal: options.signal }).then(() => void 0);
+  }
+};
+
+// src/utils/misc.ts
+var import_node_crypto = require("crypto");
+function newRequestId() {
+  return (0, import_node_crypto.randomUUID)();
+}
+function newNonce() {
+  return (0, import_node_crypto.randomUUID)().replace(/-/g, "").slice(0, 32);
+}
+function isBotToken(token) {
+  return typeof token === "string" && /^sqb_.+\..+/.test(token);
+}
+function stripTokenPrefix(token) {
+  return token.startsWith("Bot ") ? token.slice(4) : token;
+}
+function splitArguments(input) {
+  const args = [];
+  let current = "";
+  let inQuotes = null;
+  for (const char of input) {
+    if (inQuotes) {
+      if (char === inQuotes) {
+        inQuotes = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      inQuotes = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) args.push(current);
+  return args;
+}
+
+// src/managers/messages.ts
+var MessagesManager = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  rest;
+  /** Busca uma mensagem pelo id. */
+  fetch(channelId, messageId) {
+    return this.rest.get(
+      `/channels/${channelId}/messages/${messageId}`
+    );
+  }
+  /** Lista uma página do histórico do canal (padrão: 50, máximo 100). */
+  list(channelId, params = {}, signal) {
+    return this.rest.get(`/channels/${channelId}/messages`, {
+      query: { limit: params.limit, before: params.before, after: params.after },
+      signal
+    });
+  }
+  /**
+   * Envia uma mensagem. O SDK anexa um `nonce` automático (idempotência),
+   * então a operação pode ser repetida com segurança pelo cliente REST em
+   * falhas transitórias.
+   */
+  send(channelId, payload, options = {}) {
+    const body = resolveMessagePayload(payload);
+    const nonce = body.nonce ?? options.nonce ?? newNonce();
+    const createBody = {
+      ...body,
+      nonce,
+      allowedMentions: safeAllowedMentions(body.allowedMentions)
+    };
+    return this.rest.post(`/channels/${channelId}/messages`, createBody, {
+      signal: options.signal,
+      // Protegido por nonce: seguro repetir.
+      retryable: true
+    });
+  }
+  /** Edita uma mensagem (do próprio bot). `embeds`/`components` substituem a lista inteira. */
+  edit(channelId, messageId, payload, options = {}) {
+    const body = resolveMessageEditPayload(payload);
+    return this.rest.patch(
+      `/channels/${channelId}/messages/${messageId}`,
+      body,
+      { signal: options.signal }
+    );
+  }
+  /** Apaga uma mensagem (própria ou de outros, com `MANAGE_MESSAGES`). Responde 204. */
+  delete(channelId, messageId, options = {}) {
+    return this.rest.delete(`/channels/${channelId}/messages/${messageId}`, { signal: options.signal }).then(() => void 0);
+  }
+  /** Reage a uma mensagem (`ADD_REACTIONS`). `emoji` é o caractere ou `<:nome:id>`. */
+  react(channelId, messageId, emoji, options = {}) {
+    return this.rest.put(
+      `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`,
+      void 0,
+      { signal: options.signal }
+    ).then(() => void 0);
+  }
+  /** Remove a reação do bot. */
+  removeReaction(channelId, messageId, emoji, options = {}) {
+    return this.rest.delete(
+      `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`,
+      { signal: options.signal }
+    ).then(() => void 0);
+  }
+  /** Lista as reações de uma mensagem. */
+  listReactions(channelId, messageId, signal) {
+    return this.rest.get(
+      `/channels/${channelId}/messages/${messageId}/reactions`,
+      { signal }
+    );
+  }
+  /** Fixa uma mensagem no canal (`PIN_MESSAGES`). */
+  pin(channelId, messageId, options = {}) {
+    return this.rest.put(`/channels/${channelId}/pins/${messageId}`, void 0, { signal: options.signal }).then(() => void 0);
+  }
+  /** Desafixa uma mensagem. */
+  unpin(channelId, messageId, options = {}) {
+    return this.rest.delete(`/channels/${channelId}/pins/${messageId}`, { signal: options.signal }).then(() => void 0);
+  }
+  /** Lista as mensagens fixadas do canal. */
+  listPins(channelId, signal) {
+    return this.rest.get(`/channels/${channelId}/pins`, { signal });
+  }
+};
+
+// src/managers/uploads.ts
+var import_promises = require("fs/promises");
+
+// src/logger.ts
+var LEVEL_ORDER = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  silent: 100
+};
+function redact(input) {
+  return input.replace(/sqb_[A-Za-z0-9._-]+/g, "sqb_[REDACTED]").replace(/Bot\s+sqb_[A-Za-z0-9._-]+/gi, "Bot [REDACTED]").replace(/"token"\s*:\s*"[^"]+"/g, '"token":"[REDACTED]"');
+}
+function createConsoleLogger(options = {}) {
+  const level = options.level ?? "silent";
+  const write = options.write ?? ((line) => console.log(line));
+  const log = (lvl, prefix) => (message, meta) => {
+    if (LEVEL_ORDER[lvl] < LEVEL_ORDER[level]) return;
+    const entry = {
+      t: (/* @__PURE__ */ new Date()).toISOString(),
+      level: lvl,
+      scope: prefix || void 0,
+      msg: redact(message),
+      ...meta
+    };
+    write(redact(JSON.stringify(entry)));
+  };
+  const make = (prefix) => ({
+    debug: log("debug", prefix),
+    info: log("info", prefix),
+    warn: log("warn", prefix),
+    error: log("error", prefix),
+    child: (childPrefix) => make(prefix ? `${prefix}:${childPrefix}` : childPrefix)
+  });
+  return make("");
+}
+var noopLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  },
+  child: () => noopLogger
+};
+function loggerFromEnv() {
+  const fromEnv = (process.env.SQUORD_LOG ?? "").toLowerCase();
+  if (fromEnv in LEVEL_ORDER) {
+    return createConsoleLogger({ level: fromEnv });
+  }
+  if (process.env.SQUORD_DEBUG === "1" || process.env.SQUORD_DEBUG === "true") {
+    return createConsoleLogger({ level: "debug" });
+  }
+  return noopLogger;
+}
+
+// src/managers/uploads.ts
+var UploadsManager = class {
+  constructor(rest, logger) {
+    this.rest = rest;
+    this.logger = (logger ?? noopLogger).child("uploads");
+  }
+  rest;
+  logger;
+  /** Reserva um upload (`POST /uploads`). Não é idempotente. */
+  reserve(body, signal) {
+    return this.rest.post("/uploads", body, {
+      signal,
+      retryable: false
+    });
+  }
+  /** Confirma um upload (`POST /uploads/{id}/confirm`). Idempotente. */
+  confirm(uploadId, body = {}, signal) {
+    return this.rest.post(`/uploads/${uploadId}/confirm`, body, {
+      signal,
+      retryable: true
+    });
+  }
+  /**
+   * Fluxo completo: reserva, envia os bytes e confirma. Devolve o upload em
+   * `status: "READY"`, pronto para `attachmentIds`.
+   *
+   * Aceita caminho local (`path`), `Buffer`/`Uint8Array` ou `Readable`
+   * (informe `size`). Streams são sempre encerrados, mesmo em falha.
+   */
+  async upload(options) {
+    const { path, data, signal } = options;
+    let bytes;
+    let filename = options.filename;
+    let size = options.size;
+    if (path !== void 0) {
+      bytes = await (0, import_promises.readFile)(path).catch(() => {
+        throw new SquordTypeError(`N\xE3o foi poss\xEDvel ler o arquivo: ${path}`);
+      });
+      filename ??= basename(path);
+      size ??= bytes.length;
+    } else if (data !== void 0) {
+      if (typeof data === "string") {
+        bytes = Buffer.from(data, "utf8");
+      } else if (Buffer.isBuffer(data) || data instanceof Uint8Array) {
+        bytes = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      } else if (typeof data.read === "function") {
+        bytes = await this.collectStream(data, signal);
+      } else {
+        throw new SquordTypeError("data precisa ser Buffer, Uint8Array, string ou Readable");
+      }
+      filename ??= "arquivo";
+      size ??= bytes.length;
+    } else {
+      throw new SquordTypeError("Informe path ou data para o upload");
+    }
+    if (size === void 0 || Number.isNaN(size)) {
+      throw new SquordTypeError("Informe o size ao enviar um stream");
+    }
+    if (size <= 0) {
+      throw new SquordTypeError("O arquivo est\xE1 vazio (size 0)");
+    }
+    if (size > 524288e3) {
+      throw new SquordTypeError(
+        `O arquivo passa de 500 MB (${size} bytes); o limite real vem do plano do Space`
+      );
+    }
+    const contentType = options.contentType ?? guessContentType(filename ?? "arquivo");
+    const reservation = await this.reserve(
+      { scope: "attachments", filename: filename ?? "arquivo", contentType, size, guildId: options.guildId },
+      signal
+    );
+    const target = reservation.target;
+    const response = await this.rest.fetch(target.uploadUrl, {
+      method: "PUT",
+      headers: { ...target.headers },
+      body: new Uint8Array(bytes),
+      signal
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new NetworkError(
+        `O envio dos bytes falhou (HTTP ${response.status})${text ? `: ${text.slice(0, 200)}` : ""}`
+      );
+    }
+    const upload = await this.confirm(reservation.upload.id, {}, signal);
+    if (upload.status !== "READY") {
+      this.logger.warn("upload confirmado fora do esperado", {
+        id: upload.id,
+        status: upload.status,
+        scanStatus: upload.scanStatus
+      });
+    }
+    return upload;
+  }
+  /** Atalho: envia um arquivo e devolve o `id` pronto para `attachmentIds`. */
+  async uploadForAttachment(options) {
+    const upload = await this.upload(options);
+    return upload.id;
+  }
+  async collectStream(stream, signal) {
+    const chunks = [];
+    try {
+      for await (const chunk of stream) {
+        if (signal?.aborted) throw new DOMException("Upload cancelado", "AbortError");
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      }
+    } catch (err) {
+      stream.destroy();
+      throw err;
+    }
+    return Buffer.concat(chunks);
+  }
+};
+function basename(path) {
+  const parts = path.split(/[\\/]/);
+  return parts[parts.length - 1] || "arquivo";
+}
+function guessContentType(filename) {
+  const ext = filename.toLowerCase().split(".").pop() ?? "";
+  const table = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mp3: "audio/mpeg",
+    ogg: "audio/ogg",
+    wav: "audio/wav",
+    pdf: "application/pdf",
+    txt: "text/plain",
+    json: "application/json",
+    csv: "text/csv",
+    md: "text/markdown",
+    zip: "application/zip"
+  };
+  return table[ext] ?? "application/octet-stream";
+}
+
+// src/utils/backoff.ts
+function backoffDelay(attempt, options = {}) {
+  const { baseMs = 1e3, factor = 2, maxMs = 6e4, jitter = 0.25 } = options;
+  const bounded = Math.min(attempt, 16);
+  const exp = Math.min(baseMs * factor ** bounded, maxMs);
+  const jitterAmount = exp * jitter * (Math.random() * 2 - 1);
+  return Math.max(250, Math.round(exp + jitterAmount));
+}
+function sleep(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new DOMException("Sleep aborted", "AbortError"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/rest/RestClient.ts
+var DEFAULT_BASE_URL = "https://api.squord.com.br/api/v1";
+var DEFAULT_TIMEOUT_MS = 15e3;
+var DEFAULT_MAX_RETRIES = 3;
+var RestClient = class {
+  baseURL;
+  token;
+  timeoutMs;
+  maxRetries;
+  fetchImpl;
+  logger;
+  bucketStates = /* @__PURE__ */ new Map();
+  bucketBlockedUntil = /* @__PURE__ */ new Map();
+  globalWindow = [];
+  globalLimit;
+  destroyed = false;
+  constructor(options) {
+    this.baseURL = (options.baseURL ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.token = options.token;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.logger = (options.logger ?? noopLogger).child("rest");
+    const rps = options.globalRequestsPerSecond ?? 45;
+    this.globalLimit = rps > 0 ? rps : Number.POSITIVE_INFINITY;
+  }
+  /** GET tipado. */
+  get(path, options = {}) {
+    return this.request("GET", path, options);
+  }
+  /** Implementação de fetch em uso (exposta para uploads e testes). */
+  get fetch() {
+    return this.fetchImpl;
+  }
+  /** POST tipado. Não é retentável por padrão. */
+  post(path, body, options = {}) {
+    return this.request("POST", path, { ...options, body });
+  }
+  /** PUT tipado (idempotente). */
+  put(path, body, options = {}) {
+    return this.request("PUT", path, { ...options, body });
+  }
+  /** PATCH tipado (retentável por padrão quando idempotente pelo caller). */
+  patch(path, body, options = {}) {
+    return this.request("PATCH", path, { ...options, body });
+  }
+  /** DELETE tipado. Resposta 204 devolve `null`. */
+  delete(path, options = {}) {
+    return this.request("DELETE", path, options);
+  }
+  /** Executa uma requisição com política completa de erros, retries e rate limits. */
+  async request(method, path, options = {}) {
+    const response = await this.requestRaw(method, path, options);
+    return response.data;
+  }
+  /** Como `request`, mas devolve também status, headers e `x-request-id`. */
+  async requestRaw(method, path, options = {}) {
+    if (this.destroyed) {
+      throw new SquordAPIError(
+        { statusCode: 0, code: "SDK_DESTROYED", message: "O cliente foi destru\xEDdo" },
+        0
+      );
+    }
+    const retryable = options.retryable ?? method !== "POST";
+    const url = this.buildUrl(path, options.query);
+    const requestId = options.requestId ?? newRequestId();
+    const routeKey = routeKeyOf(method, path);
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (options.signal?.aborted) throw new DOMException("Requisi\xE7\xE3o cancelada", "AbortError");
+      await this.waitForRouteBucket(routeKey, options.signal);
+      await this.acquireGlobalSlot(options.signal);
+      const headers = {
+        "Content-Type": "application/json",
+        "x-request-id": requestId
+      };
+      if (options.auth !== false) {
+        headers.Authorization = `Bot ${this.token}`;
+      }
+      const request = new Request(url, {
+        method,
+        headers,
+        body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
+      });
+      const signals = [];
+      const timeoutController = new AbortController();
+      const timer = setTimeout(() => {
+        timeoutController.abort(new DOMException("Request timed out", "TimeoutError"));
+      }, this.timeoutMs);
+      signals.push(timeoutController.signal);
+      if (options.signal) signals.push(options.signal);
+      const compositeSignal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+      let response;
+      try {
+        response = await this.fetchImpl(request, { signal: compositeSignal });
+      } catch (err) {
+        lastError = this.toNetworkError(err, method, path);
+        const canRetry = retryable && attempt < this.maxRetries;
+        this.logger.debug("network failure", { method, path, attempt, retryable, canRetry });
+        if (!canRetry) throw lastError;
+        await sleep(backoffDelay(attempt, { baseMs: 500, maxMs: 8e3 }), options.signal);
+        continue;
+      } finally {
+        clearTimeout(timer);
+      }
+      this.recordBucketState(routeKey, response.headers);
+      if (response.ok) {
+        const data = await this.parseBody(response);
+        return {
+          data,
+          status: response.status,
+          headers: response.headers,
+          requestId: response.headers.get("x-request-id") ?? requestId,
+          request
+        };
+      }
+      const apiError = await this.toAPIError(response);
+      lastError = apiError;
+      if (apiError.status === 429 && apiError instanceof RateLimitError) {
+        if (attempt < this.maxRetries) {
+          const waitMs = apiError.retryAfter * 1e3;
+          this.logger.warn("rate limit, aguardando", {
+            bucket: apiError.bucket,
+            retryAfter: apiError.retryAfter
+          });
+          await sleep(waitMs, options.signal);
+          continue;
+        }
+        throw new RateLimitError(apiError.responseBody, 429, {
+          requestId: apiError.requestId,
+          exhaustedRetries: true
+        });
+      }
+      if (apiError.status >= 500 && retryable && attempt < this.maxRetries) {
+        const waitMs = backoffDelay(attempt, { baseMs: 500, maxMs: 8e3 });
+        this.logger.warn("erro 5xx, repetindo", { status: apiError.status, attempt, waitMs });
+        await sleep(waitMs, options.signal);
+        continue;
+      }
+      if (apiError.status === 409 && (apiError.code === "COMMANDS_CONFLICT" || apiError.code === "THREAD_CHANGED") && attempt < this.maxRetries) {
+        await sleep(250 + backoffDelay(attempt, { baseMs: 200, maxMs: 2e3 }), options.signal);
+        continue;
+      }
+      throw apiError;
+    }
+    throw lastError;
+  }
+  /** Encerra o cliente: novas requisições falham imediatamente. */
+  destroy() {
+    this.destroyed = true;
+    this.bucketStates.clear();
+    this.bucketBlockedUntil.clear();
+  }
+  /** Estado de rate limit conhecido para uma rota (diagnóstico). */
+  bucketState(method, path) {
+    return this.bucketStates.get(routeKeyOf(method, path));
+  }
+  // -----------------------------------------------------------------
+  buildUrl(path, query) {
+    let url = `${this.baseURL}${path.startsWith("/") ? path : `/${path}`}`;
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query ?? {})) {
+      if (value === void 0 || value === null) continue;
+      params.set(key, String(value));
+    }
+    const qs = params.toString();
+    if (qs) url += `?${qs}`;
+    return url;
+  }
+  async parseBody(response) {
+    if (response.status === 204) return null;
+    const text = await response.text();
+    if (!text) return null;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  async toAPIError(response) {
+    let body = {};
+    try {
+      body = await response.json();
+    } catch {
+    }
+    const enriched = {
+      statusCode: response.status,
+      code: body.code ?? `HTTP_${response.status}`,
+      message: body.message ?? response.statusText,
+      details: body.details,
+      requestId: body.requestId ?? response.headers.get("x-request-id") ?? void 0
+    };
+    return makeAPIError(enriched, response.status, enriched.requestId);
+  }
+  toNetworkError(err, method, path) {
+    if (err instanceof DOMException && err.name === "TimeoutError") {
+      return new RequestTimeoutError(method, path, this.timeoutMs, { cause: err });
+    }
+    if (err instanceof DOMException && err.name === "AbortError") {
+      return err;
+    }
+    const reason = err?.reason;
+    if (reason instanceof DOMException && reason.name === "TimeoutError") {
+      return new RequestTimeoutError(method, path, this.timeoutMs, { cause: err });
+    }
+    return new NetworkError(`Falha de rede em ${method} ${path}: ${String(err?.message ?? err)}`, {
+      cause: err
+    });
+  }
+  recordBucketState(routeKey, headers) {
+    const limit = headers.get("x-ratelimit-limit");
+    const remaining = headers.get("x-ratelimit-remaining");
+    const reset = headers.get("x-ratelimit-reset");
+    if (limit === null && remaining === null && reset === null) return;
+    const state = {
+      limit: limit !== null ? Number(limit) : null,
+      remaining: remaining !== null ? Number(remaining) : null,
+      reset: reset !== null ? Number(reset) : null
+    };
+    this.bucketStates.set(routeKey, state);
+    if (state.remaining === 0 && state.reset !== null) {
+      const blockedUntil = state.reset * 1e3;
+      this.bucketBlockedUntil.set(routeKey, blockedUntil);
+    }
+  }
+  async waitForRouteBucket(routeKey, signal) {
+    for (; ; ) {
+      const blockedUntil = this.bucketBlockedUntil.get(routeKey);
+      if (blockedUntil === void 0) return;
+      const waitMs = blockedUntil - Date.now();
+      if (waitMs <= 0) {
+        this.bucketBlockedUntil.delete(routeKey);
+        return;
+      }
+      await sleep(waitMs, signal).catch(() => {
+      });
+      if (signal?.aborted) return;
+    }
+  }
+  async acquireGlobalSlot(signal) {
+    if (this.globalLimit === Number.POSITIVE_INFINITY) return;
+    for (; ; ) {
+      const now = Date.now();
+      while (this.globalWindow.length > 0 && now - this.globalWindow[0] >= 1e3) {
+        this.globalWindow.shift();
+      }
+      if (this.globalWindow.length < this.globalLimit) {
+        this.globalWindow.push(now);
+        return;
+      }
+      const waitMs = 1e3 - (now - this.globalWindow[0]) + 10;
+      await sleep(waitMs, signal);
+    }
+  }
+};
+function routeKeyOf(method, path) {
+  const normalized = path.replace(/\/\d{5,20}\b/g, "/{id}").replace(/\/[0-9a-f]{24}\b/gi, "/{id}");
+  return `${method} ${normalized}`;
+}
+
+// src/gateway/WebSocketLike.ts
+function attachWebSocket(ws, handlers) {
+  const target = ws;
+  if (typeof target.addEventListener === "function") {
+    const onOpen = () => handlers.open();
+    const onMessage2 = (event) => {
+      const data = event.data;
+      if (typeof data === "string") handlers.message(data);
+      else if (data instanceof ArrayBuffer) handlers.message(new TextDecoder().decode(data));
+      else if (data && typeof data === "object" && "toString" in data) {
+        handlers.message(String(data));
+      }
+    };
+    const onClose2 = (event) => {
+      handlers.close({
+        code: event.code ?? 1005,
+        reason: event.reason ?? "",
+        wasClean: event.wasClean ?? false
+      });
+    };
+    const onError2 = (event) => handlers.error(event);
+    target.addEventListener("open", onOpen);
+    target.addEventListener("message", onMessage2);
+    target.addEventListener("close", onClose2);
+    target.addEventListener("error", onError2);
+    return {
+      send: (data) => target.send?.(data),
+      close: (code, reason) => target.close?.(code, reason),
+      get readyState() {
+        return target.readyState ?? 0;
+      }
+    };
+  }
+  const onMessage = (data) => {
+    if (typeof data === "string") handlers.message(data);
+    else if (Buffer.isBuffer(data)) handlers.message(data.toString("utf8"));
+    else handlers.message(String(data));
+  };
+  const onClose = (code, reason) => handlers.close({ code, reason, wasClean: true });
+  const onError = (error) => handlers.error(error);
+  target.on?.("open", handlers.open);
+  target.on?.("message", onMessage);
+  target.on?.("close", onClose);
+  target.on?.("error", onError);
+  return {
+    send: (data) => target.send?.(data),
+    close: (code, reason) => target.close?.(code, reason),
+    get readyState() {
+      return target.readyState ?? 0;
+    }
+  };
+}
+var globalWebSocketFactory = (url) => new WebSocket(url);
+
+// src/types/gateway.ts
+var GatewayCloseCodes = {
+  UnknownError: 4e3,
+  UnknownOpcode: 4001,
+  DecodeError: 4002,
+  NotAuthenticated: 4003,
+  AuthenticationFailed: 4004,
+  AlreadyAuthenticated: 4005,
+  InvalidSequence: 4007,
+  RateLimited: 4008,
+  SessionTimeout: 4009,
+  InvalidProtocolVersion: 4012,
+  AccountSuspended: 4013,
+  BotSessionLimit: 4014
+};
+
+// src/gateway/Gateway.ts
+var DEFAULT_URL = "wss://gateway.squord.com.br/gateway";
+var PROTOCOL_VERSION = 1;
+var FATAL_CLOSE_CODES = /* @__PURE__ */ new Set([
+  GatewayCloseCodes.AuthenticationFailed,
+  // 4004
+  GatewayCloseCodes.AccountSuspended,
+  // 4013
+  GatewayCloseCodes.BotSessionLimit
+  // 4014
+]);
+var BOT_BUG_CLOSE_CODES = /* @__PURE__ */ new Set([
+  GatewayCloseCodes.UnknownOpcode,
+  // 4001
+  GatewayCloseCodes.DecodeError,
+  // 4002
+  GatewayCloseCodes.AlreadyAuthenticated,
+  // 4005
+  GatewayCloseCodes.InvalidProtocolVersion
+  // 4012
+]);
+var Gateway = class extends TypedEmitter {
+  url;
+  token;
+  wsFactory;
+  handshakeTimeoutMs;
+  autoReconnect;
+  reconnectBaseMs;
+  logger;
+  ws = null;
+  statusValue = "idle";
+  reconnectAttempts = 0;
+  connectLoop = null;
+  // Estado de sessão (para resume)
+  sessionId = null;
+  resumeUrl = null;
+  lastSequence = null;
+  established = false;
+  // Handshake em curso
+  handshake = null;
+  handshakeTimer = null;
+  // Heartbeat
+  heartbeatIntervalMs = null;
+  heartbeatTimer = null;
+  awaitingAck = false;
+  lastHeartbeatSentAt = null;
+  destroyed = false;
+  closingByClient = false;
+  reconnectRequested = false;
+  /** Latência do gateway: último heartbeat até o ack, em ms. */
+  heartbeatLatencyMs = null;
+  /** Quantas reconexões ocorreram desde a criação. */
+  reconnectCount = 0;
+  /** Quantos frames de evento foram recebidos (incluindo duplicados). */
+  eventsReceived = 0;
+  /** Quantos eventos foram descartados como duplicados. */
+  eventsDropped = 0;
+  get sequence() {
+    return this.lastSequence;
+  }
+  get session() {
+    return this.sessionId;
+  }
+  get status() {
+    return this.statusValue;
+  }
+  get isReady() {
+    return this.statusValue === "ready";
+  }
+  constructor(options) {
+    super();
+    this.url = options.url ?? DEFAULT_URL;
+    this.token = options.token;
+    this.wsFactory = options.ws ?? globalWebSocketFactory;
+    this.handshakeTimeoutMs = options.handshakeTimeoutMs ?? 2e4;
+    this.autoReconnect = options.autoReconnect ?? true;
+    this.reconnectBaseMs = options.reconnectBaseMs ?? 1e3;
+    this.logger = (options.logger ?? noopLogger).child("gateway");
+  }
+  // ------------------------------------------------------------------
+  // API pública
+  // ------------------------------------------------------------------
+  /**
+   * Conecta ao gateway e resolve quando a sessão está pronta
+   * (`ready` ou `resumed`). Em quedas transitórias, segue tentando com
+   * backoff — a promise só é rejeitada em erros não retomáveis
+   * (token inválido/revogado, conta suspensa, sessões demais, erro de
+   * protocolo) ou se o gateway for destruído.
+   */
+  async connect() {
+    if (this.destroyed) throw new GatewayError(null, null, "O gateway foi destru\xEDdo");
+    if (this.isReady) {
+      throw new GatewayError(null, null, "O gateway j\xE1 est\xE1 conectado");
+    }
+    if (this.connectLoop) return this.connectLoop;
+    this.closingByClient = false;
+    this.connectLoop = this.runConnectLoop().finally(() => {
+      this.connectLoop = null;
+    });
+    return this.connectLoop;
+  }
+  /** Envia `presence.update`. O status escolhido vale também nas próximas conexões. */
+  setPresence(presence) {
+    if (!this.ws) {
+      this.emit("error", new GatewayError(null, null, "Sem conex\xE3o para atualizar a presen\xE7a"));
+      return;
+    }
+    this.sendFrame("presence.update", presence);
+  }
+  /** Fecha a conexão, encerra as reconexões e descarta o estado de sessão. */
+  async destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.closingByClient = true;
+    this.stopHeartbeat();
+    this.failHandshake(new GatewayError(null, null, "Gateway destru\xEDdo"));
+    this.setStatus("destroyed");
+    const ws = this.ws;
+    this.ws = null;
+    if (ws && ws.readyState <= 1) {
+      try {
+        ws.close(1e3, "client shutdown");
+      } catch {
+      }
+    }
+  }
+  /** Descarta o estado de sessão: a próxima conexão fará `identify` limpo. */
+  invalidateSession() {
+    this.sessionId = null;
+    this.resumeUrl = null;
+    this.lastSequence = null;
+  }
+  /** Força uma reconexão imediata (que tentará `resume`). */
+  reconnectNow() {
+    if (!this.ws) return;
+    this.reconnectRequested = true;
+    try {
+      this.ws.close(4e3, "manual reconnect");
+    } catch {
+    }
+  }
+  // ------------------------------------------------------------------
+  // Loop de conexão
+  // ------------------------------------------------------------------
+  async runConnectLoop() {
+    this.setStatus(this.sessionId ? "reconnecting" : "connecting");
+    for (; ; ) {
+      try {
+        const ready = await this.openSocketOnce(this.resumeUrl ?? this.url);
+        this.reconnectAttempts = 0;
+        return ready;
+      } catch (err) {
+        if (this.destroyed) throw err;
+        const gatewayErr = err;
+        const code = gatewayErr?.closeCode ?? null;
+        if (code !== null && (FATAL_CLOSE_CODES.has(code) || BOT_BUG_CLOSE_CODES.has(code))) {
+          this.setStatus("disconnected");
+          this.emit("error", gatewayErr);
+          throw gatewayErr;
+        }
+        if (!this.autoReconnect) {
+          this.setStatus("disconnected");
+          throw err;
+        }
+        const attempt = this.reconnectAttempts++;
+        const delayMs = backoffDelay(attempt, { baseMs: this.reconnectBaseMs });
+        this.reconnectCount++;
+        this.setStatus("reconnecting");
+        this.emit("reconnecting", {
+          attempt,
+          delayMs,
+          closeCode: code,
+          reason: gatewayErr?.reason ?? String(err?.message ?? err)
+        });
+        this.logger.info("reconectando", { attempt, delayMs });
+        await sleep(delayMs);
+        this.setStatus(this.sessionId ? "reconnecting" : "connecting");
+      }
+    }
+  }
+  /** Abre um socket e resolve no `ready`/`resumed` (handshake completo). */
+  openSocketOnce(url) {
+    return new Promise((resolve, reject) => {
+      let socket;
+      try {
+        socket = this.wsFactory(url);
+      } catch (err) {
+        reject(
+          new GatewayError(
+            null,
+            null,
+            `N\xE3o foi poss\xEDvel criar o WebSocket para ${url}: ${String(err?.message ?? err)}`
+          )
+        );
+        return;
+      }
+      this.handshake = { resolve, reject };
+      this.established = false;
+      this.handshakeTimer = setTimeout(() => {
+        this.failHandshake(
+          new GatewayError(
+            null,
+            null,
+            `Handshake do gateway excedeu ${this.handshakeTimeoutMs} ms sem ready/resumed`
+          )
+        );
+      }, this.handshakeTimeoutMs);
+      this.ws = attachWebSocket(socket, {
+        open: () => this.logger.debug("socket aberto, aguardando hello"),
+        message: (data) => this.handleMessage(data),
+        close: (event) => this.handleClose(event.code, event.reason),
+        error: (err) => this.logger.debug("erro de socket", {
+          err: String(err?.message ?? err)
+        })
+      });
+    });
+  }
+  resolveHandshake(ready) {
+    const handshake = this.handshake;
+    if (!handshake) return;
+    this.clearHandshakeTimer();
+    this.handshake = null;
+    handshake.resolve(ready);
+  }
+  failHandshake(error) {
+    const handshake = this.handshake;
+    this.clearHandshakeTimer();
+    if (!handshake) return;
+    this.handshake = null;
+    handshake.reject(error);
+  }
+  clearHandshakeTimer() {
+    if (this.handshakeTimer) {
+      clearTimeout(this.handshakeTimer);
+      this.handshakeTimer = null;
+    }
+  }
+  // ------------------------------------------------------------------
+  // Entrada de frames
+  // ------------------------------------------------------------------
+  handleMessage(data) {
+    let frame;
+    try {
+      frame = JSON.parse(data);
+    } catch {
+      this.logger.warn("frame n\xE3o-JSON recebido; ignorado");
+      return;
+    }
+    this.emit("raw", frame);
+    switch (frame.op) {
+      case "hello":
+        this.handleHello(frame.d);
+        break;
+      case "ready":
+        this.handleReady(frame.d);
+        break;
+      case "resumed":
+        this.handleResumed(frame.d);
+        break;
+      case "heartbeat.ack":
+        this.handleHeartbeatAck(frame.d);
+        break;
+      case "invalid_session":
+        this.handleInvalidSession(frame.d);
+        break;
+      case "reconnect":
+        this.handleReconnectRequest(frame.d);
+        break;
+      case "error":
+        this.handleServerError(frame.d);
+        break;
+      case "event":
+        this.handleEvent(frame);
+        break;
+      default:
+        this.logger.debug("opcode desconhecido", {
+          op: frame.op
+        });
+    }
+  }
+  handleHello(hello) {
+    this.heartbeatIntervalMs = hello.heartbeatIntervalMs;
+    this.logger.debug("hello", { heartbeatIntervalMs: hello.heartbeatIntervalMs });
+    if (this.sessionId !== null) {
+      this.sendFrame("resume", {
+        token: this.token,
+        sessionId: this.sessionId,
+        lastSequence: this.lastSequence ?? 0
+      });
+    } else {
+      this.sendFrame("identify", {
+        token: this.token,
+        protocolVersion: PROTOCOL_VERSION
+      });
+    }
+    this.startHeartbeat();
+  }
+  handleReady(ready) {
+    this.sessionId = ready.sessionId;
+    this.resumeUrl = ready.resumeGatewayUrl || this.url;
+    this.lastSequence = null;
+    this.established = true;
+    this.setStatus("ready");
+    this.logger.info("sess\xE3o pronta", {
+      sessionId: ready.sessionId,
+      guilds: ready.guilds.length
+    });
+    this.emit("ready", ready);
+    this.resolveHandshake(ready);
+  }
+  handleResumed(resumed) {
+    this.sessionId = resumed.sessionId;
+    this.established = true;
+    this.setStatus("ready");
+    this.logger.info("sess\xE3o retomada", {
+      replayed: resumed.replayed,
+      sequence: resumed.sequence
+    });
+    this.emit("resumed", resumed);
+    this.resolveHandshake({
+      sessionId: resumed.sessionId,
+      userId: "",
+      guilds: [],
+      resumeGatewayUrl: this.resumeUrl ?? this.url
+    });
+  }
+  handleHeartbeatAck(ack) {
+    this.awaitingAck = false;
+    if (this.lastHeartbeatSentAt !== null) {
+      this.heartbeatLatencyMs = Date.now() - this.lastHeartbeatSentAt;
+    }
+    this.logger.debug("heartbeat.ack", { sequence: ack.sequence });
+  }
+  handleInvalidSession(payload) {
+    this.logger.warn("resume recusado; fazendo identify", { payload });
+    this.emit("invalidSession", payload);
+    this.invalidateSession();
+    this.sendFrame("identify", {
+      token: this.token,
+      protocolVersion: PROTOCOL_VERSION
+    });
+  }
+  handleReconnectRequest(payload) {
+    this.logger.warn("servidor pediu reconex\xE3o", { payload });
+    const watchdog = setTimeout(() => {
+      if (!this.destroyed && this.ws) {
+        this.logger.warn("watchdog: fechando para reconectar");
+        try {
+          this.ws.close(4e3, "reconnect watchdog");
+        } catch {
+        }
+      }
+    }, 5e3);
+    watchdog.unref?.();
+  }
+  handleServerError(errorFrame) {
+    this.emit("serverError", errorFrame);
+    this.logger.warn("frame error do servidor", { frame: errorFrame });
+  }
+  handleEvent(frame) {
+    this.eventsReceived++;
+    if (typeof frame.s === "number") {
+      if (this.lastSequence !== null && frame.s <= this.lastSequence) {
+        this.eventsDropped++;
+        this.logger.debug("evento duplicado descartado", {
+          type: frame.type,
+          s: frame.s
+        });
+        return;
+      }
+      this.lastSequence = frame.s;
+    }
+    this.emit("event", {
+      type: frame.type,
+      d: frame.d,
+      s: frame.s,
+      timestamp: frame.timestamp
+    });
+  }
+  // ------------------------------------------------------------------
+  // Fechamento
+  // ------------------------------------------------------------------
+  handleClose(code, reason) {
+    this.stopHeartbeat();
+    this.ws = null;
+    const wasEstablished = this.established;
+    this.established = false;
+    if (this.reconnectRequested) {
+      this.reconnectRequested = false;
+      this.emit("disconnect", { code, reason, fatal: false });
+      void this.kickReconnectAfterDrop(code, reason);
+      return;
+    }
+    if (this.destroyed || this.closingByClient) {
+      this.closingByClient = false;
+      this.emit("disconnect", { code, reason, fatal: false });
+      this.failHandshake(new GatewayError(code, reason, "Conex\xE3o encerrada"));
+      return;
+    }
+    const fatal = FATAL_CLOSE_CODES.has(code);
+    const botBug = BOT_BUG_CLOSE_CODES.has(code);
+    const error = new GatewayError(
+      code,
+      reason,
+      describeClose(code, reason, fatal, botBug)
+    );
+    this.emit("disconnect", { code, reason, fatal: fatal || botBug });
+    if (fatal || botBug) {
+      this.logger.error("conex\xE3o encerrada sem retomada", { code, reason });
+      this.setStatus("disconnected");
+      this.failHandshake(error);
+      return;
+    }
+    if (wasEstablished) {
+      this.emit("error", error);
+      void this.kickReconnectAfterDrop(code, reason);
+    } else {
+      this.failHandshake(error);
+    }
+  }
+  async kickReconnectAfterDrop(code, reason) {
+    if (!this.autoReconnect || this.destroyed) {
+      this.setStatus("disconnected");
+      return;
+    }
+    const attempt = this.reconnectAttempts++;
+    const delayMs = backoffDelay(attempt, { baseMs: this.reconnectBaseMs });
+    this.reconnectCount++;
+    this.setStatus("reconnecting");
+    this.emit("reconnecting", { attempt, delayMs, closeCode: code, reason });
+    this.logger.info("reconectando ap\xF3s queda", { attempt, delayMs, code });
+    await sleep(delayMs);
+    if (this.destroyed) return;
+    this.setStatus(this.sessionId ? "reconnecting" : "connecting");
+    try {
+      await this.openSocketOnce(this.resumeUrl ?? this.url);
+      this.reconnectAttempts = 0;
+    } catch {
+      if (!this.destroyed) void this.kickReconnectAfterDrop(code, reason);
+    }
+  }
+  // ------------------------------------------------------------------
+  // Heartbeat
+  // ------------------------------------------------------------------
+  startHeartbeat() {
+    this.stopHeartbeat();
+    if (!this.heartbeatIntervalMs) return;
+    const firstDelay = Math.max(250, Math.random() * this.heartbeatIntervalMs);
+    this.heartbeatTimer = setTimeout(() => {
+      this.sendHeartbeat();
+      if (this.heartbeatIntervalMs) {
+        this.heartbeatTimer = setInterval(
+          () => this.sendHeartbeat(),
+          this.heartbeatIntervalMs
+        );
+      }
+    }, firstDelay);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    this.awaitingAck = false;
+  }
+  sendHeartbeat() {
+    if (this.destroyed || !this.ws) return;
+    if (this.awaitingAck) {
+      this.logger.warn("sem heartbeat.ack desde o \xFAltimo heartbeat; conex\xE3o zumbi, reconectando");
+      try {
+        this.ws.close(4e3, "zombie connection");
+      } catch {
+      }
+      return;
+    }
+    this.lastHeartbeatSentAt = Date.now();
+    this.sendFrame("heartbeat", { s: this.lastSequence ?? void 0 });
+    this.awaitingAck = true;
+  }
+  // ------------------------------------------------------------------
+  sendFrame(op, d) {
+    const ws = this.ws;
+    if (!ws) {
+      this.logger.debug("frame descartado: sem socket", { op });
+      return;
+    }
+    const payload = JSON.stringify({ op, d, requestId: newRequestId() });
+    if (Buffer.byteLength(payload, "utf8") > 65536) {
+      this.emit(
+        "error",
+        new GatewayError(null, null, `Frame ${op} excede 65536 bytes e n\xE3o foi enviado`)
+      );
+      return;
+    }
+    try {
+      ws.send(payload);
+    } catch (err) {
+      this.emit(
+        "error",
+        new GatewayError(null, null, `Falha ao enviar frame ${op}: ${String(err?.message ?? err)}`)
+      );
+    }
+  }
+  setStatus(status) {
+    if (this.statusValue === status) return;
+    this.statusValue = status;
+    this.emit("statusChange", status);
+  }
+};
+function describeClose(code, reason, fatal, botBug) {
+  if (fatal) {
+    if (code === GatewayCloseCodes.AuthenticationFailed) {
+      return `O token foi recusado (4004${reason ? `: ${reason}` : ""}). Ele foi trocado, revogado, ou o bot/dono foi exclu\xEDdo ou suspenso. N\xE3o reconecte com o mesmo token.`;
+    }
+    if (code === GatewayCloseCodes.BotSessionLimit) {
+      return `O bot j\xE1 tem 2 sess\xF5es simult\xE2neas (4014). Feche uma das sess\xF5es antes de reconectar.`;
+    }
+    return `A conta do bot est\xE1 suspensa (4013). N\xE3o reconecte.`;
+  }
+  if (botBug) {
+    return `Erro de protocolo do bot (c\xF3digo ${code}${reason ? `: ${reason}` : ""}). Corrija o c\xF3digo antes de tentar de novo.`;
+  }
+  return `Conex\xE3o do gateway fechou (c\xF3digo ${code}${reason ? `: ${reason}` : ""}).`;
+}
+
+// src/structures/base.ts
+var Structure = class {
+  constructor(client, raw) {
+    this.client = client;
+    this.raw = raw;
+  }
+  client;
+  raw;
+};
+
+// src/permissions.ts
+var Permissions = {
+  VIEW_CHANNEL: 1n << 0n,
+  MANAGE_CHANNELS: 1n << 1n,
+  MANAGE_GUILD: 1n << 2n,
+  MANAGE_ROLES: 1n << 3n,
+  MANAGE_INVITES: 1n << 4n,
+  VIEW_AUDIT_LOG: 1n << 5n,
+  MANAGE_EMOJIS: 1n << 6n,
+  MANAGE_WEBHOOKS: 1n << 7n,
+  KICK_MEMBERS: 1n << 8n,
+  BAN_MEMBERS: 1n << 9n,
+  TIMEOUT_MEMBERS: 1n << 10n,
+  CHANGE_NICKNAME: 1n << 11n,
+  MANAGE_NICKNAMES: 1n << 12n,
+  SEND_MESSAGES: 1n << 13n,
+  READ_MESSAGE_HISTORY: 1n << 14n,
+  MANAGE_MESSAGES: 1n << 15n,
+  ATTACH_FILES: 1n << 16n,
+  EMBED_LINKS: 1n << 17n,
+  ADD_REACTIONS: 1n << 18n,
+  MENTION_EVERYONE: 1n << 19n,
+  USE_EXTERNAL_EMOJIS: 1n << 20n,
+  PIN_MESSAGES: 1n << 21n,
+  CONNECT: 1n << 22n,
+  SPEAK: 1n << 23n,
+  VIDEO: 1n << 24n,
+  STREAM: 1n << 25n,
+  MUTE_MEMBERS: 1n << 26n,
+  DEAFEN_MEMBERS: 1n << 27n,
+  MOVE_MEMBERS: 1n << 28n,
+  PRIORITY_SPEAKER: 1n << 29n,
+  ADMINISTRATOR: 1n << 30n,
+  SEND_POLLS: 1n << 31n,
+  /** O bit 32 foi aposentado e nunca é reutilizado. */
+  CREATE_INVITE: 1n << 33n,
+  APPROVE_JOIN_REQUESTS: 1n << 34n,
+  FORWARD_MESSAGES: 1n << 35n,
+  HANDLE_REPORTS: 1n << 36n,
+  PUBLISH_ANNOUNCEMENTS: 1n << 37n,
+  BYPASS_SLOWMODE: 1n << 38n,
+  CREATE_THREADS: 1n << 39n,
+  SEND_MESSAGES_IN_THREADS: 1n << 40n,
+  MANAGE_THREADS: 1n << 41n,
+  MANAGE_EVENTS: 1n << 42n
+};
+var ALL_PERMISSIONS = Object.values(Permissions).reduce((a, b) => a | b, 0n);
+function permissionsToString(bits) {
+  return bits.toString();
+}
+function parsePermissions(value) {
+  return BigInt(value);
+}
+function hasPermissions(bits, ...flags) {
+  const b = typeof bits === "string" ? BigInt(bits) : bits;
+  return flags.every((flag) => (b & flag) === flag);
+}
+function hasAnyPermission(bits, ...flags) {
+  const b = typeof bits === "string" ? BigInt(bits) : bits;
+  return flags.some((flag) => (b & flag) === flag);
+}
+function resolveChannelPermissions(options) {
+  let base = options.everyonePermissions;
+  for (const role of options.rolePermissions) base |= role;
+  if ((base & Permissions.ADMINISTRATOR) === Permissions.ADMINISTRATOR) {
+    return ALL_PERMISSIONS;
+  }
+  const apply = (acc, overwrites) => {
+    const everyone = overwrites.find((o) => o.targetId === options.everyoneRoleId);
+    if (everyone) {
+      acc &= ~BigInt(everyone.deny);
+      acc |= BigInt(everyone.allow);
+    }
+    const roleOverwrites = overwrites.filter(
+      (o) => o.targetType === "ROLE" && options.memberRoleIds.includes(o.targetId)
+    );
+    const deny = roleOverwrites.reduce((acc2, o) => acc2 | BigInt(o.deny), 0n);
+    const allow = roleOverwrites.reduce((acc2, o) => acc2 | BigInt(o.allow), 0n);
+    acc &= ~deny;
+    acc |= allow;
+    const member = overwrites.find((o) => o.targetType === "MEMBER" && o.targetId === options.memberId);
+    if (member) {
+      acc &= ~BigInt(member.deny);
+      acc |= BigInt(member.allow);
+    }
+    return acc;
+  };
+  let result = apply(base, options.overwrites);
+  if ((result & Permissions.VIEW_CHANNEL) !== Permissions.VIEW_CHANNEL) return 0n;
+  return result;
+}
+var SUGGESTED_TEXT_BOT_PERMISSIONS = Permissions.VIEW_CHANNEL | Permissions.SEND_MESSAGES | Permissions.READ_MESSAGE_HISTORY | Permissions.EMBED_LINKS | Permissions.ATTACH_FILES | Permissions.ADD_REACTIONS;
+var SUGGESTED_MODERATION_PERMISSIONS = Permissions.KICK_MEMBERS | Permissions.BAN_MEMBERS | Permissions.TIMEOUT_MEMBERS | Permissions.MANAGE_MESSAGES;
+
+// src/types/api.ts
+var UserFlags = {
+  STAFF: 1 << 0,
+  EARLY_SUPPORTER: 1 << 1,
+  VERIFIED_BOT: 1 << 2,
+  SYSTEM: 1 << 3,
+  VERIFIED: 1 << 4,
+  BOT: 1 << 5
+};
+var GuildFlags = {
+  OFFICIAL: 1 << 0,
+  PARTNER: 1 << 1,
+  DISCOVERY_BLOCKED: 1 << 2,
+  VERIFIED: 1 << 3,
+  DISCOVERY_AGE_WAIVED: 1 << 4
+};
+function userMention(id) {
+  return `<@${id}>`;
+}
+function roleMention(id) {
+  return `<@&${id}>`;
+}
+function channelMention(id) {
+  return `<#${id}>`;
+}
+
+// src/structures/User.ts
+var User = class extends Structure {
+  constructor(client, raw) {
+    super(client, raw);
+  }
+  get data() {
+    return this.raw;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get username() {
+    return this.data.username;
+  }
+  get displayName() {
+    return this.data.displayName;
+  }
+  get avatarUrl() {
+    return this.data.avatarUrl;
+  }
+  /** `true` para contas de bot (flag `BOT`). */
+  get isBot() {
+    return (this.data.flags & UserFlags.BOT) !== 0;
+  }
+  /** `true` para bots verificados pelo Squord. */
+  get isVerifiedBot() {
+    return (this.data.flags & UserFlags.VERIFIED_BOT) !== 0;
+  }
+  get deleted() {
+    return this.data.deleted;
+  }
+  get suspended() {
+    return this.data.suspended;
+  }
+  /** Menção `<@id>` para usar no conteúdo de mensagens. */
+  get mention() {
+    return `<@${this.id}>`;
+  }
+  /** Busca o membro correspondente em um Space. */
+  member(guildId) {
+    return this.client.members.fetch(guildId, this.id).then((m) => new Member(this.client, m)).catch(() => null);
+  }
+};
+var Member = class _Member extends Structure {
+  constructor(client, raw) {
+    super(client, raw);
+  }
+  get data() {
+    return this.raw;
+  }
+  /** Id da participação (não confundir com o id da conta). */
+  get id() {
+    return this.data.id;
+  }
+  get guildId() {
+    return this.data.guildId;
+  }
+  get userId() {
+    return this.data.userId;
+  }
+  get user() {
+    return new User(this.client, this.data.user);
+  }
+  get nickname() {
+    return this.data.nickname;
+  }
+  /** Nome de exibição efetivo: apelido no Space ou `displayName`. */
+  get displayName() {
+    return this.data.nickname ?? this.data.user.displayName;
+  }
+  get roleIds() {
+    return this.data.roleIds;
+  }
+  get joinedAt() {
+    return this.data.joinedAt;
+  }
+  /** `null` ou data futura: enquanto futura, o membro está de castigo. */
+  get timeoutUntil() {
+    return this.data.timeoutUntil;
+  }
+  get isTimedOut() {
+    return this.timeoutUntil !== null && Date.parse(this.timeoutUntil) > Date.now();
+  }
+  get isBot() {
+    return this.data.type === "BOT";
+  }
+  get mention() {
+    return `<@${this.userId}>`;
+  }
+  /** Menciona o cargo do membro? Cargos não mencionáveis não notificam. */
+  get mentionNicknameOnly() {
+    return `<@!${this.userId}>`;
+  }
+  /** Recarrega o membro da API. */
+  fetch() {
+    return this.client.members.fetch(this.guildId, this.userId).then((m) => new _Member(this.client, m));
+  }
+  /** Lista os cargos do membro no Space. */
+  fetchRoles() {
+    return this.client.roles.list(this.guildId).then(
+      (roles) => roles.filter((r) => this.roleIds.includes(r.id) || r.id === this.guildId).map((r) => new Role(this.client, r))
+    );
+  }
+  /** Dá um cargo ao membro (respeita hierarquia; cargos gerenciados dão `400 ROLE_MANAGED`). */
+  addRole(roleId) {
+    return this.client.members.addRole(this.guildId, this.userId, roleId);
+  }
+  /** Tira um cargo do membro. */
+  removeRole(roleId) {
+    return this.client.members.removeRole(this.guildId, this.userId, roleId);
+  }
+  /** Muda o apelido (`MANAGE_NICKNAMES`, ou `CHANGE_NICKNAME` em si mesmo). */
+  setNickname(nickname) {
+    return this.client.members.edit(this.guildId, this.userId, { nickname }).then((m) => new _Member(this.client, m));
+  }
+  /** Aplica timeout até uma data (`TIMEOUT_MEMBERS`). */
+  timeout(until) {
+    const iso = until instanceof Date ? until.toISOString() : until;
+    return this.client.members.edit(this.guildId, this.userId, { timeoutUntil: iso }).then((m) => new _Member(this.client, m));
+  }
+  /** Remove o timeout. */
+  removeTimeout() {
+    return this.client.members.edit(this.guildId, this.userId, { timeoutUntil: null }).then((m) => new _Member(this.client, m));
+  }
+  /** Expulsa o membro (`KICK_MEMBERS`). Ele pode voltar com novo convite. */
+  kick(reason) {
+    return this.client.members.kick(this.guildId, this.userId, reason);
+  }
+  /** Bane o membro (`BAN_MEMBERS`). */
+  ban(options = {}) {
+    return this.client.moderation.ban(this.guildId, this.userId, options).then(() => void 0);
+  }
+};
+var Role = class extends Structure {
+  constructor(client, raw) {
+    super(client, raw);
+  }
+  get data() {
+    return this.raw;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get guildId() {
+    return this.data.guildId;
+  }
+  get name() {
+    return this.data.name;
+  }
+  get color() {
+    return this.data.color;
+  }
+  get position() {
+    return this.data.position;
+  }
+  /** Bits como `BigInt` (permissões trafegam como string decimal). */
+  get permissions() {
+    return parsePermissions(this.data.permissions);
+  }
+  /** Testa se o cargo concede um conjunto de permissões. */
+  has(...flags) {
+    return hasPermissions(this.permissions, ...flags);
+  }
+  get managed() {
+    return this.data.managed;
+  }
+  get managedKind() {
+    return this.data.managedKind;
+  }
+  get mentionable() {
+    return this.data.mentionable;
+  }
+  /** Menção `<@&id>`; só notifica se o cargo for mencionável. */
+  get mention() {
+    return `<@&${this.id}>`;
+  }
+  /** `true` para o cargo @everyone (o id é o próprio id do Space). */
+  get isEveryone() {
+    return this.id === this.guildId;
+  }
+};
+var Guild = class _Guild extends Structure {
+  constructor(client, raw) {
+    super(client, raw);
+  }
+  get data() {
+    return this.raw;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get name() {
+    return this.data.name;
+  }
+  get slug() {
+    return this.data.slug;
+  }
+  get ownerId() {
+    return this.data.ownerId;
+  }
+  get memberCount() {
+    return this.data.memberCount;
+  }
+  get iconUrl() {
+    return this.data.iconUrl;
+  }
+  get boostCount() {
+    return this.data.boostCount;
+  }
+  /** O bot neste Space: id de participação, cargos e permissões no nível do Space. */
+  get self() {
+    const self = this.data.self;
+    return {
+      memberId: self.memberId,
+      roleIds: self.roleIds,
+      permissions: parsePermissions(self.permissions),
+      isOwner: self.isOwner
+    };
+  }
+  /** Testa permissões do bot no nível do Space (overwrites de canal à parte). */
+  botHas(...flags) {
+    return hasPermissions(this.self.permissions, ...flags);
+  }
+  /** Recarrega o Space. */
+  fetch() {
+    return this.client.guilds.fetch(this.id).then((g) => new _Guild(this.client, g));
+  }
+  /** Árvore de canais do Space, agrupada por categorias. */
+  fetchChannelTree() {
+    return this.client.channels.fetchTree(this.id).then(
+      (nodes) => nodes.map((node) => ({
+        category: node.category ? new Channel(this.client, node.category) : null,
+        channels: node.channels.map((c) => new Channel(this.client, c))
+      }))
+    );
+  }
+  /** Lista os cargos do Space. */
+  fetchRoles() {
+    return this.client.roles.list(this.id).then((roles) => roles.map((r) => new Role(this.client, r)));
+  }
+  /** Busca um membro pelo id da conta. */
+  fetchMember(userId) {
+    return this.client.members.fetch(this.id, userId).then((m) => new Member(this.client, m));
+  }
+};
+
+// src/structures/Message.ts
+var Message = class _Message extends Structure {
+  constructor(client, raw) {
+    super(client, raw);
+  }
+  get data() {
+    return this.raw;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get guildId() {
+    return this.data.guildId;
+  }
+  get channelId() {
+    return this.data.channelId;
+  }
+  get authorId() {
+    return this.data.authorId;
+  }
+  get author() {
+    return new User(this.client, this.data.author);
+  }
+  get type() {
+    return this.data.type;
+  }
+  get content() {
+    return this.data.content;
+  }
+  get replyToId() {
+    return this.data.replyToId;
+  }
+  get pinned() {
+    return this.data.pinned;
+  }
+  get editedAt() {
+    return this.data.editedAt;
+  }
+  get moderated() {
+    return this.data.moderated;
+  }
+  get attachments() {
+    return this.data.attachments;
+  }
+  get embeds() {
+    return this.data.embeds;
+  }
+  get components() {
+    return this.data.components;
+  }
+  get reactions() {
+    return this.data.reactions;
+  }
+  get createdAt() {
+    return this.data.createdAt;
+  }
+  /** Apelido do autor no Space (quando houver). */
+  get memberNickname() {
+    return this.data.memberNickname;
+  }
+  /** Nome de exibição efetivo do autor (apelido ou displayName). */
+  get authorDisplayName() {
+    return this.data.memberNickname ?? this.data.author.displayName;
+  }
+  /** `true` se a mensagem veio do próprio bot. */
+  get fromMe() {
+    return this.client.userId !== null && this.authorId === this.client.userId;
+  }
+  /** `true` se o bot foi mencionado (`<@id>` no conteúdo). */
+  get mentionsMe() {
+    return this.client.userId !== null && this.data.mentions.userIds.includes(this.client.userId);
+  }
+  /** Ids mencionados na mensagem (só as menções que valeram). */
+  get mentionedUserIds() {
+    return this.data.mentions.userIds;
+  }
+  get mentionedRoleIds() {
+    return this.data.mentions.roleIds;
+  }
+  get mentionsEveryone() {
+    return this.data.mentions.everyone;
+  }
+  /** Recarrega a mensagem (ela pode ter sido apagada; isso lança 404). */
+  fetch() {
+    return this.client.messages.fetch(this.channelId, this.id).then((m) => new _Message(this.client, m));
+  }
+  /** Busca o canal da mensagem (uma thread também é canal). */
+  fetchChannel() {
+    return this.client.channels.fetch(this.channelId).then(
+      (channel) => channel.type === "THREAD" ? new Thread(this.client, channel) : new Channel(this.client, channel)
+    ).catch(() => null);
+  }
+  /** Responde a mensagem (usa `replyToId`). Idempotente por `nonce`. */
+  reply(payload, options) {
+    const source = typeof payload === "string" ? { content: payload } : payload;
+    return this.client.messages.send(this.channelId, { ...source, replyToId: this.id }, options).then((m) => new _Message(this.client, m));
+  }
+  /** Edita a mensagem (só mensagens do próprio bot). */
+  edit(payload, options) {
+    return this.client.messages.edit(this.channelId, this.id, payload, options).then((m) => new _Message(this.client, m));
+  }
+  /** Apaga a mensagem (a do bot sempre; de outros, com `MANAGE_MESSAGES`). */
+  delete(options) {
+    return this.client.messages.delete(this.channelId, this.id, options);
+  }
+  /** Reage com um emoji Unicode ou `<:nome:id>`. */
+  react(emoji, options) {
+    return this.client.messages.react(this.channelId, this.id, emoji, options);
+  }
+  /** Remove a reação do bot. */
+  removeReaction(emoji, options) {
+    return this.client.messages.removeReaction(this.channelId, this.id, emoji, options);
+  }
+  /** Fixa a mensagem no canal (`PIN_MESSAGES`). */
+  pin(options) {
+    return this.client.messages.pin(this.channelId, this.id, options);
+  }
+  /** Desafixa a mensagem. */
+  unpin(options) {
+    return this.client.messages.unpin(this.channelId, this.id, options);
+  }
+  /** Cria uma thread a partir desta mensagem (canais de texto e anúncios). */
+  startThread(body) {
+    return this.client.channels.createThreadFromMessage(this.channelId, this.id, body).then((t) => new Thread(this.client, t));
+  }
+};
+
+// src/structures/Channel.ts
+var Channel = class _Channel extends Structure {
+  constructor(client, raw) {
+    super(client, raw);
+  }
+  get data() {
+    return this.raw;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get guildId() {
+    return this.data.guildId;
+  }
+  get name() {
+    return this.data.name;
+  }
+  get type() {
+    return this.data.type;
+  }
+  get topic() {
+    return this.data.topic;
+  }
+  get categoryId() {
+    return this.data.categoryId;
+  }
+  get isPrivate() {
+    return this.data.isPrivate;
+  }
+  /** Modo lento em segundos (0 desligado). */
+  get rateLimitPerUser() {
+    return this.data.rateLimitPerUser;
+  }
+  get chatEnabled() {
+    return this.data.chatEnabled;
+  }
+  get lastMessageId() {
+    return this.data.lastMessageId;
+  }
+  /** Menção `<#id>`. */
+  get mention() {
+    return `<#${this.id}>`;
+  }
+  get isText() {
+    return this.data.type === "TEXT" || this.data.type === "ANNOUNCEMENT";
+  }
+  get isVoice() {
+    return this.data.type === "VOICE" || this.data.type === "STAGE";
+  }
+  get isForum() {
+    return this.data.type === "FORUM";
+  }
+  /** Recarrega o canal. */
+  fetch() {
+    return this.client.channels.fetch(this.id).then((c) => new _Channel(this.client, c));
+  }
+  /** Envia uma mensagem no canal (idempotente por `nonce`). */
+  send(payload, options) {
+    return this.client.messages.send(this.id, payload, options).then((m) => new Message(this.client, m));
+  }
+  /** Envia um arquivo como anexo do canal (fluxo completo de upload). */
+  sendFile(options, content) {
+    return this.client.uploads.uploadForAttachment({ guildId: this.guildId, ...options }).then(
+      (attachmentId) => this.send({
+        content: content || void 0,
+        attachmentIds: [attachmentId]
+      })
+    );
+  }
+  /** Busca uma mensagem do canal pelo id. */
+  fetchMessage(messageId) {
+    return this.client.messages.fetch(this.id, messageId).then((m) => new Message(this.client, m));
+  }
+  /** Lista uma página do histórico (use `client.paginate` para iterar tudo). */
+  fetchMessages(params) {
+    return this.client.messages.list(this.id, params ?? {}).then((page) => ({
+      ...page,
+      items: page.items.map((m) => new Message(this.client, m))
+    }));
+  }
+  /** Mensagens fixadas do canal. */
+  fetchPins() {
+    return this.client.messages.listPins(this.id).then((msgs) => msgs.map((m) => new Message(this.client, m)));
+  }
+  /** Cria uma thread neste canal (texto/anúncios) ou um post (fórum). */
+  createThread(body) {
+    return this.client.channels.createThread(this.id, body).then((t) => new Thread(this.client, t));
+  }
+  /** Lista as threads do canal (`cursor` = `nextCursor` da página anterior). */
+  fetchThreads(params) {
+    return this.client.channels.listThreads(this.id, { limit: params?.limit, after: params?.cursor, archived: params?.archived, tagId: params?.tagId }).then((page) => ({
+      ...page,
+      items: page.items.map((t) => new Thread(this.client, t))
+    }));
+  }
+};
+var Thread = class extends Structure {
+  constructor(client, raw) {
+    super(client, raw);
+  }
+  get data() {
+    return this.raw;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get guildId() {
+    return this.data.guildId;
+  }
+  get parentId() {
+    return this.data.parentId;
+  }
+  get name() {
+    return this.data.name;
+  }
+  get ownerId() {
+    return this.data.ownerId;
+  }
+  get isForumPost() {
+    return this.data.isForumPost;
+  }
+  get archived() {
+    return this.data.archived;
+  }
+  get locked() {
+    return this.data.locked;
+  }
+  get autoArchiveMinutes() {
+    return this.data.autoArchiveMinutes;
+  }
+  get messageCount() {
+    return this.data.messageCount;
+  }
+  get lastMessageId() {
+    return this.data.lastMessageId;
+  }
+  get lastMessageAt() {
+    return this.data.lastMessageAt;
+  }
+  get appliedTagIds() {
+    return this.data.appliedTagIds;
+  }
+  get mention() {
+    return `<#${this.id}>`;
+  }
+  /** Envia uma mensagem na thread (usa o id dela como channelId). */
+  send(payload, options) {
+    return this.client.messages.send(this.id, payload, options).then((m) => new Message(this.client, m));
+  }
+  /** Busca uma mensagem da thread. */
+  fetchMessage(messageId) {
+    return this.client.messages.fetch(this.id, messageId).then((m) => new Message(this.client, m));
+  }
+};
+
+// src/structures/Interaction.ts
+var Interaction = class extends Structure {
+  constructor(client, raw) {
+    super(client, raw);
+  }
+  get data() {
+    return this.raw;
+  }
+  get id() {
+    return this.data.id;
+  }
+  /** Credencial da interação (15 minutos de validade). Trate como segredo. */
+  get token() {
+    return this.data.token;
+  }
+  get type() {
+    return this.data.type;
+  }
+  get guildId() {
+    return this.data.guildId;
+  }
+  get channelId() {
+    return this.data.channelId;
+  }
+  /** Quem invocou o comando ou clicou no componente. */
+  get user() {
+    return new User(this.client, this.data.user);
+  }
+  /** O membro que invocou (com cargos do Space), quando disponível. */
+  get member() {
+    return this.data.member ? new Member(this.client, this.data.member) : null;
+  }
+  get createdAt() {
+    return this.data.createdAt;
+  }
+  get isCommand() {
+    return this.data.type === "COMMAND" && this.data.command !== void 0;
+  }
+  get isComponent() {
+    return this.data.type === "COMPONENT" && this.data.component !== void 0;
+  }
+  /** Dados do comando (presentes quando `isCommand`). */
+  get command() {
+    return this.data.command ?? null;
+  }
+  /** Dados do componente (presentes quando `isComponent`). */
+  get component() {
+    return this.data.component ?? null;
+  }
+  /** O `customId` do componente clicado (ou `null`). */
+  get customId() {
+    return this.component?.customId ?? null;
+  }
+  /** Os valores escolhidos em um menu (vazio em botões). */
+  get values() {
+    return this.component?.values ?? [];
+  }
+  // ------------------------------------------------------------------
+  // Acesso às opções do comando
+  // ------------------------------------------------------------------
+  /** Lista as opções preenchidas da invocação (já validadas pelo Squord). */
+  get options() {
+    return this.command?.options ?? [];
+  }
+  /** Valor bruto de uma opção pelo nome. */
+  getOption(name) {
+    return this.options.find((option) => option.name === name)?.value;
+  }
+  /** Opção `STRING`. */
+  getString(name, required = false) {
+    const value = this.getOption(name);
+    if (typeof value === "string") return value;
+    if (required) throw new Error(`A op\xE7\xE3o obrigat\xF3ria "${name}" n\xE3o veio como STRING`);
+    return void 0;
+  }
+  /** Opção `INTEGER`. */
+  getInteger(name, required = false) {
+    const value = this.getOption(name);
+    if (typeof value === "number") return value;
+    if (required) throw new Error(`A op\xE7\xE3o obrigat\xF3ria "${name}" n\xE3o veio como INTEGER`);
+    return void 0;
+  }
+  /** Opção `BOOLEAN`. */
+  getBoolean(name, required = false) {
+    const value = this.getOption(name);
+    if (typeof value === "boolean") return value;
+    if (required) throw new Error(`A op\xE7\xE3o obrigat\xF3ria "${name}" n\xE3o veio como BOOLEAN`);
+    return void 0;
+  }
+  /** Opção `USER`/`CHANNEL`/`ROLE`: o valor é o id (string). */
+  getId(name, required = false) {
+    const value = this.getOption(name);
+    if (typeof value === "string") return value;
+    if (required) throw new Error(`A op\xE7\xE3o obrigat\xF3ria "${name}" n\xE3o veio como USER/CHANNEL/ROLE`);
+    return void 0;
+  }
+  // ------------------------------------------------------------------
+  // Respostas
+  // ------------------------------------------------------------------
+  /** Primeira resposta como mensagem. `ephemeral: true` mostra só para quem invocou. */
+  reply(payload, options = {}) {
+    return this.client.interactions.reply(this.id, this.token, payload, options);
+  }
+  /** Resposta efêmera: só quem invocou vê; não é salva; só botões de link. */
+  replyEphemeral(payload, options) {
+    return this.client.interactions.reply(this.id, this.token, payload, {
+      ...options,
+      ephemeral: true
+    });
+  }
+  /** `DEFERRED`: mostra o bot "pensando" enquanto o trabalho roda. */
+  defer(options) {
+    return this.client.interactions.defer(this.id, this.token, options);
+  }
+  /**
+   * `UPDATE` (só componente): edita a mensagem que tinha o componente.
+   * O caso típico: marcar a escolha, mudar de página.
+   */
+  update(payload, options) {
+    return this.client.interactions.update(this.id, this.token, payload, options);
+  }
+  /** `DEFERRED_UPDATE` (só componente): confirma o clique sem mudar nada. */
+  acknowledge(options) {
+    return this.client.interactions.acknowledgeComponent(this.id, this.token, options);
+  }
+  /**
+   * Follow-up: mensagem extra depois da primeira resposta
+   * (o padrão para trabalho demorado é `defer()` + follow-up).
+   */
+  followup(payload, options = {}) {
+    const source = typeof payload === "string" ? { content: payload } : payload;
+    if (options.ephemeral) source.ephemeral = true;
+    return this.client.interactions.followup(
+      this.id,
+      this.token,
+      source,
+      options.signal
+    );
+  }
+  /** Busca a mensagem do componente clicado (quando `isComponent`). */
+  fetchComponentMessage() {
+    const messageId = this.component?.messageId;
+    if (!messageId) return Promise.resolve(null);
+    return this.client.messages.fetch(this.channelId, messageId).then((m) => new Message(this.client, m)).catch(() => null);
+  }
+};
+
+// src/utils/snowflake.ts
+var SNOWFLAKE_RE = /^\d{1,20}$/;
+var LEGACY_ID_RE = /^[0-9a-f]{24}$/i;
+function isValidSnowflake(id) {
+  return typeof id === "string" && (SNOWFLAKE_RE.test(id) || LEGACY_ID_RE.test(id));
+}
+function assertSnowflake(id, label = "id") {
+  if (!isValidSnowflake(id)) {
+    throw new SquordTypeError(
+      `${label} inv\xE1lido: ${JSON.stringify(id)} \u2014 ids do Squord s\xE3o strings (Snowflake decimal ou hex de 24 caracteres)`
+    );
+  }
+  return id;
+}
+function compareSnowflakes(a, b) {
+  if (!SNOWFLAKE_RE.test(a) || !SNOWFLAKE_RE.test(b)) {
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  try {
+    const ba = BigInt(a);
+    const bb = BigInt(b);
+    return ba < bb ? -1 : ba > bb ? 1 : 0;
+  } catch {
+    return a.localeCompare(b);
+  }
+}
+
+// src/cache/Cache.ts
+var Cache = class {
+  store = /* @__PURE__ */ new Map();
+  ttlMs;
+  maxSize;
+  now;
+  constructor(options = {}) {
+    this.ttlMs = options.ttlMs ?? 3e5;
+    this.maxSize = options.maxSize ?? 1e3;
+    this.now = options.now ?? (() => Date.now());
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (this.now() >= entry.expiresAt) {
+      this.store.delete(key);
+      return void 0;
+    }
+    this.store.delete(key);
+    this.store.set(key, entry);
+    return entry.value;
+  }
+  set(key, value, ttlMs) {
+    if (this.maxSize <= 0) return;
+    const ttl = ttlMs ?? this.ttlMs;
+    this.store.delete(key);
+    this.store.set(key, { value, expiresAt: ttl === Infinity ? Number.MAX_SAFE_INTEGER : this.now() + ttl, insertedAt: this.now() });
+    this.evictIfNeeded();
+  }
+  has(key) {
+    return this.get(key) !== void 0 || this.peek(key) !== void 0;
+  }
+  delete(key) {
+    return this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+  get size() {
+    this.sweep();
+    return this.store.size;
+  }
+  /** Itera itens vivos. */
+  *entries() {
+    for (const [key, entry] of [...this.store.entries()]) {
+      if (this.now() < entry.expiresAt) yield [key, entry.value];
+      else this.store.delete(key);
+    }
+  }
+  peek(key) {
+    return this.store.get(key)?.value;
+  }
+  evictIfNeeded() {
+    if (this.store.size <= this.maxSize) return;
+    const excess = this.store.size - this.maxSize;
+    const iterator = this.store.keys();
+    for (let i = 0; i < excess; i++) {
+      const oldest = iterator.next();
+      if (oldest.done) break;
+      this.store.delete(oldest.value);
+    }
+  }
+  sweep() {
+    const now = this.now();
+    for (const [key, entry] of this.store.entries()) {
+      if (now >= entry.expiresAt) this.store.delete(key);
+    }
+  }
+};
+
+// src/client/SquordClient.ts
+var SquordClient = class extends TypedEmitter {
+  rest;
+  messages;
+  channels;
+  guilds;
+  members;
+  roles;
+  moderation;
+  uploads;
+  interactions;
+  commands;
+  bot;
+  users;
+  logger;
+  /** Caches opcionais, desativados por padrão (`cache.enabled`). */
+  caches;
+  options;
+  gatewayInstance = null;
+  botInfo = null;
+  userIdValue = null;
+  shutdownSignalsBound = false;
+  destroyed = false;
+  constructor(options) {
+    super();
+    if (!options?.token || typeof options.token !== "string") {
+      throw new SquordTypeError("Informe o token do bot: new SquordClient({ token: process.env.SQUORD_BOT_TOKEN })");
+    }
+    const token = stripTokenPrefix(options.token);
+    if (!isBotToken(token)) {
+      throw new SquordTypeError(
+        "O token do bot deve come\xE7ar com sqb_ (formato sqb_<id>.<segredo>), obtido em Configura\xE7\xF5es \u2192 Desenvolvedor"
+      );
+    }
+    this.options = { ...options, token };
+    this.logger = options.logger !== void 0 && options.logger !== null ? options.logger : options.logger === null ? noopLogger : options.logLevel ? createConsoleLogger({ level: options.logLevel }) : loggerFromEnv();
+    this.rest = new RestClient({
+      baseURL: options.apiBaseURL,
+      token,
+      timeoutMs: options.restTimeoutMs,
+      maxRetries: options.restMaxRetries,
+      globalRequestsPerSecond: options.restGlobalPerSecond,
+      fetchImpl: options.fetchImpl,
+      logger: this.logger
+    });
+    this.messages = new MessagesManager(this.rest);
+    this.channels = new ChannelsManager(this.rest);
+    this.guilds = new GuildsManager(this.rest);
+    this.members = new MembersManager(this.rest);
+    this.roles = new RolesManager(this.rest);
+    this.moderation = new ModerationManager(this.rest);
+    this.uploads = new UploadsManager(this.rest, this.logger);
+    this.interactions = new InteractionsManager(this.rest);
+    this.commands = new ApplicationCommandsManager(this.rest);
+    this.bot = new BotManager(this.rest);
+    this.users = new UsersManager(this.rest);
+    const cacheOptions = options.cache?.enabled ? { ttlMs: options.cache.ttlMs, maxSize: options.cache.maxEntries } : null;
+    this.caches = cacheOptions ? {
+      guilds: new Cache(cacheOptions),
+      channels: new Cache(cacheOptions),
+      members: new Cache(cacheOptions),
+      roles: new Cache(cacheOptions)
+    } : null;
+  }
+  /** Opções com que o cliente foi criado (sem o token). */
+  get optionsSafe() {
+    const { token: _token, ...rest } = this.options;
+    return rest;
+  }
+  /** Id da conta do bot (disponível após `login()`). */
+  get userId() {
+    return this.userIdValue;
+  }
+  /** A conta do bot como `User` (após `login()`). */
+  get user() {
+    return this.botInfo ? new User(this, this.botInfo.user) : null;
+  }
+  /** O bot na visão do dono (após `login()`). */
+  get application() {
+    return this.botInfo;
+  }
+  /** O gateway, se conectado (ou em conexão). */
+  get gateway() {
+    return this.gatewayInstance;
+  }
+  /** `true` quando o gateway está autenticado e recebendo eventos. */
+  isReady() {
+    return this.gatewayInstance?.isReady ?? false;
+  }
+  /** Latência do gateway (último heartbeat → ack), em ms. */
+  get ping() {
+    return this.gatewayInstance?.heartbeatLatencyMs ?? null;
+  }
+  /**
+   * Autentica e conecta. Valida o token (`GET /bots/@me`), conecta ao
+   * gateway (a menos que `restOnly`) e resolve no `ready`.
+   */
+  async login() {
+    if (this.destroyed) throw new SquordTypeError("O cliente foi destru\xEDdo");
+    if (this.userIdValue) return;
+    this.logger.info("validando token do bot");
+    this.botInfo = await this.bot.fetchCurrent();
+    this.userIdValue = this.botInfo.user.id;
+    this.logger.info("token validado", { botId: this.botInfo.id, username: this.botInfo.user.username });
+    if (this.options.restOnly) {
+      this.logger.info("modo REST-only: sem gateway");
+      this.emit("ready", {
+        user: new User(this, this.botInfo.user),
+        sessionId: "",
+        guilds: [],
+        ping: null
+      });
+      return;
+    }
+    if (this.options.gracefulShutdown && !this.shutdownSignalsBound) {
+      this.shutdownSignalsBound = true;
+      const shutdown = () => {
+        void this.destroy().then(() => process.exit(0));
+      };
+      process.once("SIGINT", shutdown);
+      process.once("SIGTERM", shutdown);
+    }
+    const gateway = this.ensureGateway();
+    const ready = await gateway.connect();
+    this.userIdValue = ready.userId || this.userIdValue;
+    this.emit("ready", {
+      user: this.user ?? new User(this, this.botInfo.user),
+      sessionId: ready.sessionId,
+      guilds: ready.guilds,
+      ping: this.ping
+    });
+  }
+  /**
+   * Encerra o cliente: fecha o gateway, cancela requisições pendentes e
+   * remove listeners. Seguro chamar mais de uma vez.
+   */
+  async destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    if (this.gatewayInstance) {
+      await this.gatewayInstance.destroy();
+      this.gatewayInstance = null;
+    }
+    this.rest.destroy();
+    this.removeAllListeners();
+  }
+  /** Presença do bot: `ONLINE`, `IDLE`, `DND` ou `INVISIBLE`, com status personalizado. */
+  setPresence(presence) {
+    if (!this.gatewayInstance) {
+      throw new SquordTypeError("Conecte o gateway antes de mudar a presen\xE7a (login())");
+    }
+    const update = {
+      status: presence.status,
+      customStatus: presence.customStatus === void 0 ? void 0 : presence.customStatus,
+      afk: presence.afk
+    };
+    this.gatewayInstance.setPresence(update);
+  }
+  /** Força reconexão do gateway (tenta `resume`). */
+  reconnect() {
+    this.gatewayInstance?.reconnectNow();
+  }
+  /**
+   * Permissões efetivas do bot em um canal, resolvidas localmente a partir
+   * dos cargos e overwrites (com o cache, quando habilitado). O backend
+   * continua sendo a autoridade final.
+   */
+  async myPermissionsIn(channelId) {
+    assertSnowflake(channelId, "channelId");
+    const channel = this.caches?.channels.get(channelId) ?? await this.channels.fetch(channelId);
+    this.caches?.channels.set(channelId, channel);
+    const guildId = channel.guildId;
+    const guild = this.caches?.guilds.get(guildId) ?? await this.guilds.fetch(guildId);
+    this.caches?.guilds.set(guildId, guild);
+    const roles = this.caches?.roles.get(guildId) ?? await this.roles.list(guildId);
+    this.caches?.roles.set(guildId, roles);
+    const memberKey = `${guildId}:${this.userIdValue}`;
+    const me = this.caches?.members.get(memberKey) ?? await this.members.fetch(guildId, this.userIdValue);
+    this.caches?.members.set(memberKey, me);
+    const roleById = new Map(roles.map((role) => [role.id, role]));
+    const everyonePermissions = BigInt(
+      (roleById.get(guildId) ?? roles.find((r) => r.id === guildId))?.permissions ?? "0"
+    );
+    return resolveChannelPermissions({
+      everyonePermissions,
+      rolePermissions: me.roleIds.map((roleId) => roleById.get(roleId)).filter((role) => role !== void 0).map((role) => BigInt(role.permissions)),
+      overwrites: channel.overwrites,
+      memberId: me.id,
+      everyoneRoleId: guildId,
+      memberRoleIds: me.roleIds
+    });
+  }
+  /** Testa se o bot tem um conjunto de permissões em um canal. */
+  async hasPermissionsIn(channelId, ...flags) {
+    const bits = await this.myPermissionsIn(channelId);
+    return flags.every((flag) => (bits & flag) === flag);
+  }
+  /** Atalho para `Permissions` (evita import extra em código de bot). */
+  get Permissions() {
+    return Permissions;
+  }
+  // ------------------------------------------------------------------
+  ensureGateway() {
+    if (this.gatewayInstance) return this.gatewayInstance;
+    const gateway = new Gateway({
+      url: this.options.gatewayURL,
+      token: this.options.token,
+      ws: this.options.ws,
+      logger: this.logger,
+      reconnectBaseMs: this.options.gatewayReconnectBaseMs
+    });
+    gateway.on("resumed", (resumed) => {
+      this.emit("resumed", resumed);
+      this.logger.info("sess\xE3o retomada", { replayed: resumed.replayed });
+    });
+    gateway.on("reconnecting", (info) => {
+      this.emit("reconnecting", info);
+      this.logger.warn("reconectando ao gateway", info);
+    });
+    gateway.on("disconnect", (info) => {
+      this.emit("disconnect", info);
+      if (!info.fatal) this.emit("warn", `Conex\xE3o do gateway caiu (c\xF3digo ${info.code})`);
+    });
+    gateway.on("error", (error) => {
+      this.emit("error", error);
+    });
+    gateway.on("invalidSession", () => {
+      this.emit("warn", "Sess\xE3o do gateway n\xE3o p\xF4de ser retomada; refazendo identify");
+    });
+    gateway.on("raw", (frame) => {
+      this.emit("raw", frame);
+    });
+    gateway.on("event", (event) => {
+      this.dispatchGatewayEvent(event);
+    });
+    this.gatewayInstance = gateway;
+    return gateway;
+  }
+  dispatchGatewayEvent(event) {
+    const { type, d } = event;
+    const data = d;
+    try {
+      switch (type) {
+        case "message.created":
+        case "message.updated":
+          this.emit(type, new Message(this, data.message));
+          break;
+        case "member.joined":
+        case "member.updated":
+          this.emit(type, {
+            guildId: data.guildId,
+            member: new Member(this, data.member)
+          });
+          break;
+        case "guild.updated":
+          this.emit(type, new Guild(this, data.guild));
+          break;
+        case "channel.created":
+        case "channel.updated":
+          this.emit(type, new Channel(this, data.channel));
+          break;
+        case "role.created":
+        case "role.updated":
+          this.emit(type, new Role(this, data.role));
+          break;
+        case "thread.created":
+        case "thread.updated":
+          this.emit(type, new Thread(this, data.thread));
+          break;
+        case "interaction.created":
+          this.emit(type, new Interaction(this, d));
+          break;
+        default:
+          if (this.listenerCount(type) > 0) {
+            this.emit(type, d);
+          } else if (isKnownEventType(type)) {
+            this.emit(type, d);
+          } else {
+            this.emit("unknownEvent", event);
+          }
+      }
+    } catch (err) {
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+};
+var KNOWN_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "message.deleted",
+  "message.bulk_deleted",
+  "poll.vote.cast",
+  "poll.vote.removed",
+  "reaction.added",
+  "reaction.removed",
+  "member.left",
+  "member.banned",
+  "member.unbanned",
+  "guild.deleted",
+  "guild.taken_down",
+  "guild.boost.added",
+  "guild.boost.removed",
+  "channel.deleted",
+  "channel.tree.invalidated",
+  "role.deleted",
+  "thread.deleted",
+  "emoji.created",
+  "emoji.updated",
+  "emoji.deleted",
+  "sticker.created",
+  "sticker.updated",
+  "sticker.deleted",
+  "guild_event.created",
+  "guild_event.updated",
+  "guild_event.deleted",
+  "announcement.follow.created",
+  "announcement.follow.deleted",
+  "voice.state.updated",
+  "voice.room.updated",
+  "voice.member.moved",
+  "voice.e2ee.bot_key_requested",
+  "application_command.updated"
+]);
+function isKnownEventType(type) {
+  return KNOWN_EVENT_TYPES.has(type);
+}
+
+// src/commands/CommandRegistry.ts
+var CommandRegistry = class {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.options = options;
+    this.prefixResolver = options.prefix ?? "!";
+  }
+  client;
+  options;
+  textCommands = /* @__PURE__ */ new Map();
+  slashCommands = /* @__PURE__ */ new Map();
+  componentHandlers = /* @__PURE__ */ new Map();
+  cooldowns = /* @__PURE__ */ new Map();
+  prefixResolver;
+  attached = false;
+  /** Registra um comando de texto. */
+  text(definition) {
+    validateTextDefinition(definition);
+    const names = [definition.name, ...definition.aliases ?? []];
+    for (const name of names) {
+      const key = name.toLowerCase();
+      if (this.textCommands.has(key)) {
+        throw new SquordTypeError(`Comando de texto duplicado: ${name}`);
+      }
+      this.textCommands.set(key, definition);
+    }
+    this.ensureAttached();
+    return this;
+  }
+  /** Registra um comando slash. */
+  slash(definition) {
+    if (!/^[a-z0-9_-]{1,32}$/.test(definition.name)) {
+      throw new SquordTypeError(
+        `Nome de comando inv\xE1lido: ${definition.name} (use letras min\xFAsculas, n\xFAmeros, _ e -, at\xE9 32 caracteres)`
+      );
+    }
+    if (this.slashCommands.has(definition.name)) {
+      throw new SquordTypeError(`Comando slash duplicado: ${definition.name}`);
+    }
+    this.slashCommands.set(definition.name, definition);
+    this.ensureAttached();
+    return this;
+  }
+  /** Registra um handler de componente (botão ou menu). */
+  component(definition) {
+    if (!definition.customId) throw new SquordTypeError("customId \xE9 obrigat\xF3rio");
+    if (this.componentHandlers.has(definition.customId)) {
+      throw new SquordTypeError(`Handler de componente duplicado: ${definition.customId}`);
+    }
+    this.componentHandlers.set(definition.customId, definition);
+    this.ensureAttached();
+    return this;
+  }
+  /** Remove um handler de componente. */
+  removeComponent(customId) {
+    this.componentHandlers.delete(customId);
+    return this;
+  }
+  /** Definições slash prontas para o `PUT` em bloco. */
+  toCommandsInput() {
+    return [...this.slashCommands.values()].map((command) => ({
+      name: command.name,
+      description: command.description,
+      options: command.options ?? []
+    }));
+  }
+  /**
+   * Sincroniza os slash commands com o Squord (PUT em bloco, sobrescrevendo
+   * o que existir em cada escopo). Chame após `client.login()` — ou deixe o
+   * registro fazer automaticamente no `ready` (`syncOnLogin`, o padrão).
+   */
+  async sync() {
+    const global = [];
+    const guildScope = /* @__PURE__ */ new Map();
+    for (const command of this.slashCommands.values()) {
+      const input = {
+        name: command.name,
+        description: command.description,
+        options: command.options ?? []
+      };
+      const scope = command.scope ?? { kind: "global" };
+      if (scope.kind === "global") {
+        global.push(input);
+      } else {
+        for (const guildId of scope.guildIds) {
+          const list = guildScope.get(guildId) ?? [];
+          list.push(input);
+          guildScope.set(guildId, list);
+        }
+      }
+    }
+    if (global.length > 0) {
+      await this.client.commands.setGlobal(global);
+    }
+    for (const [guildId, commands] of guildScope) {
+      await this.client.commands.setGuild(guildId, commands);
+    }
+  }
+  /** Limpa os cooldowns (útil em testes). */
+  clearCooldowns() {
+    this.cooldowns.clear();
+  }
+  /** Processa manualmente uma mensagem como possível comando de texto (para testes). */
+  async handleTextMessage(message) {
+    const prefix = this.resolvePrefix(message);
+    if (prefix === null) return false;
+    const content = message.content;
+    if (!content.startsWith(prefix)) return false;
+    const line = content.slice(prefix.length).trim();
+    if (!line) return false;
+    const spaceIndex = line.search(/\s/);
+    const invokedName = (spaceIndex === -1 ? line : line.slice(0, spaceIndex)).toLowerCase();
+    const rawArgs = spaceIndex === -1 ? "" : line.slice(spaceIndex).trim();
+    const definition = this.textCommands.get(invokedName);
+    if (!definition) return false;
+    if (definition.guildIds && !definition.guildIds.includes(message.guildId ?? "")) {
+      return false;
+    }
+    if ((definition.ignoreBots ?? this.options.ignoreBots ?? true) && message.author.isBot) {
+      return false;
+    }
+    if (definition.cooldownMs && definition.cooldownMs > 0) {
+      const key = `${message.authorId}:${definition.name}`;
+      const until = this.cooldowns.get(key) ?? 0;
+      const now = Date.now();
+      if (until > now) return false;
+      this.cooldowns.set(key, now + definition.cooldownMs);
+    }
+    const args = splitArguments(rawArgs);
+    const context = {
+      client: this.client,
+      message,
+      name: invokedName,
+      command: definition,
+      args,
+      rawArgs,
+      reply: (payload) => message.reply(payload),
+      replyWithMention: (payload) => {
+        const mention = `<@${message.authorId}>`;
+        const body = typeof payload === "string" ? { content: `${mention} ${payload}` } : { ...payload };
+        if (typeof payload !== "string" && body.content) {
+          body.content = `${mention} ${body.content}`;
+        }
+        return message.reply(body);
+      },
+      react: (emoji) => message.react(emoji)
+    };
+    try {
+      if (definition.beforeExecute) {
+        const allowed = await definition.beforeExecute(context);
+        if (allowed === false) return false;
+      }
+      await definition.execute(context);
+    } catch (error) {
+      this.reportError(error, { command: definition.name, message });
+    }
+    return true;
+  }
+  /** Processa manualmente uma interação (para testes). */
+  async handleInteraction(interaction) {
+    try {
+      if (interaction.isCommand) {
+        const definition = this.slashCommands.get(interaction.command?.name ?? "");
+        if (!definition) return false;
+        await definition.execute(interaction);
+        return true;
+      }
+      if (interaction.isComponent) {
+        const handler = this.matchComponent(interaction.customId ?? "");
+        if (!handler) return false;
+        await handler.execute(interaction);
+        return true;
+      }
+    } catch (error) {
+      this.reportError(error, { interaction, command: interaction.command?.name });
+    }
+    return false;
+  }
+  matchComponent(customId) {
+    const exact = this.componentHandlers.get(customId);
+    if (exact) return exact;
+    for (const [pattern, handler] of this.componentHandlers) {
+      if (pattern.endsWith("*") && customId.startsWith(pattern.slice(0, -1))) {
+        return handler;
+      }
+    }
+    return void 0;
+  }
+  resolvePrefix(message) {
+    if (typeof this.prefixResolver === "function") {
+      return this.prefixResolver(message);
+    }
+    return this.prefixResolver;
+  }
+  ensureAttached() {
+    if (this.attached) return;
+    this.attached = true;
+    this.client.on("message.created", (message) => {
+      void this.handleTextMessage(message);
+    });
+    this.client.on("interaction.created", (interaction) => {
+      void this.handleInteraction(interaction);
+    });
+    if (this.options.syncOnLogin !== false) {
+      const runSync = () => {
+        void this.sync().catch((error) => {
+          this.reportError(error, {});
+        });
+      };
+      if (this.client.isReady()) {
+        runSync();
+      } else {
+        this.client.once("ready", runSync);
+      }
+    }
+  }
+  reportError(error, context) {
+    if (this.options.onError) {
+      this.options.onError(error, context);
+      return;
+    }
+    this.client.emit("commandError", { error, ...context });
+  }
+};
+function validateTextDefinition(definition) {
+  if (!definition.name || typeof definition.name !== "string") {
+    throw new SquordTypeError("Comando de texto precisa de name");
+  }
+  if (/\s/.test(definition.name)) {
+    throw new SquordTypeError(`Nome de comando n\xE3o pode ter espa\xE7os: ${definition.name}`);
+  }
+  if (typeof definition.execute !== "function") {
+    throw new SquordTypeError(`Comando ${definition.name} precisa de execute()`);
+  }
+}
+
+// src/rest/pagination.ts
+async function* paginate(fetchPage, firstParams = {}, direction = "before") {
+  let params = { ...firstParams };
+  const seenCursors = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    const page = await fetchPage(params);
+    for (const item of page.items) {
+      yield item;
+    }
+    if (!page.hasMore) return;
+    const nextCursor = direction === "before" ? page.prevCursor : page.nextCursor;
+    if (!nextCursor || seenCursors.has(nextCursor)) return;
+    seenCursors.add(nextCursor);
+    params = direction === "before" ? { ...params, limit: params.limit, before: nextCursor, after: void 0 } : { ...params, limit: params.limit, after: nextCursor, before: void 0 };
+  }
+}
+async function collectPagination(fetchPage, firstParams = {}, direction = "before", maxItems = 1e4) {
+  const items = [];
+  for await (const item of paginate(fetchPage, firstParams, direction)) {
+    items.push(item);
+    if (items.length >= maxItems) break;
+  }
+  return items;
+}
+
+// src/intents.ts
+var Intents = {
+  /** Space, canais, cargos, threads, emojis, stickers, eventos do Space. */
+  GUILDS: 1 << 0,
+  /** Entrada, saída, edição e ban de membros. */
+  GUILD_MEMBERS: 1 << 1,
+  /** `message.*` e votos de enquete. */
+  GUILD_MESSAGES: 1 << 2,
+  /** Reações. */
+  GUILD_MESSAGE_REACTIONS: 1 << 3,
+  /** Estado e salas de voz. */
+  GUILD_VOICE_STATES: 1 << 4,
+  /**
+   * **Privilegiada.** Não liga evento nenhum: devolve o conteúdo das
+   * mensagens. Sem ela, `content`, `embeds`, `attachments`, `components`
+   * e `poll` chegam esvaziados — exceto mensagens do próprio bot e as que
+   * o mencionam.
+   */
+  MESSAGE_CONTENT: 1 << 5
+};
+var DEFAULT_INTENTS = Intents.GUILDS | Intents.GUILD_MESSAGES | Intents.GUILD_MESSAGE_REACTIONS;
+function intentsValue(...flags) {
+  const value = flags.reduce((a, b) => a | b, 0);
+  if (value < 0 || value > 65535) {
+    throw new RangeError("As intents somam um inteiro de 0 a 65535");
+  }
+  return value;
+}
+function listIntents(value) {
+  const names = [];
+  for (const [name, flag] of Object.entries(Intents)) {
+    if ((value & flag) === flag) names.push(name);
+  }
+  return names;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALL_PERMISSIONS,
+  ActionRowBuilder,
+  ApplicationCommandsManager,
+  AuthenticationError,
+  BotManager,
+  ButtonBuilder,
+  Buttons,
+  Cache,
+  Channel,
+  ChannelsManager,
+  CommandRegistry,
+  ComponentLimits,
+  DEFAULT_INTENTS,
+  EmbedBuilder,
+  EmbedLimits,
+  Gateway,
+  GatewayError,
+  Guild,
+  GuildsManager,
+  Intents,
+  Interaction,
+  InteractionsManager,
+  InvalidTokenError,
+  Member,
+  MembersManager,
+  Message,
+  MessagesManager,
+  ModerationManager,
+  NetworkError,
+  NotFoundError,
+  PermissionError,
+  Permissions,
+  RateLimitError,
+  RequestTimeoutError,
+  RestClient,
+  Role,
+  RolesManager,
+  SUGGESTED_MODERATION_PERMISSIONS,
+  SUGGESTED_TEXT_BOT_PERMISSIONS,
+  SelectMenuBuilder,
+  SquordAPIError,
+  SquordClient,
+  SquordError,
+  SquordTypeError,
+  Thread,
+  UploadsManager,
+  User,
+  UsersManager,
+  ValidationError,
+  assertSnowflake,
+  attachWebSocket,
+  backoffDelay,
+  channelMention,
+  collectPagination,
+  compareSnowflakes,
+  createConsoleLogger,
+  hasAnyPermission,
+  hasPermissions,
+  intentsValue,
+  isValidSnowflake,
+  listIntents,
+  loggerFromEnv,
+  makeAPIError,
+  noopLogger,
+  normalizeEmbedColor,
+  paginate,
+  parsePermissions,
+  permissionsToString,
+  redact,
+  resolveChannelPermissions,
+  resolveMessagePayload,
+  roleMention,
+  routeKeyOf,
+  sleep,
+  splitArguments,
+  userMention
+});
+//# sourceMappingURL=index.cjs.map