onyxcord 1.1.8 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07ea78b3a647f1f03a640e750eef4e5a99595f6afa66ce9be842d012c5e8e2c1
-  data.tar.gz: '08f1edd1b05510983d80766f627db7372edb8f3bce6234ba9cb4d669e9cf2070'
+  metadata.gz: 2e5d5e025fe9ad9abb42d0fca6da5fe8bf9f32bfbe527de27a2da742bfe5f262
+  data.tar.gz: e7b494fd1d4821c2c517f24ceca4a6da27720f552618b71f5a5452c5a3ef915b
 SHA512:
-  metadata.gz: '092c91e1b949b091079169f2977c44745fea551a93e2cc3d065df2b9c51b534cbb027a01519d781dfc0fe2f783c360eecccee29d46b4f0bb28cd99350bde56cf'
-  data.tar.gz: 076604ea2c7a9a6a0c9303fedfbd5e1cac58cb11cbc741d88afff80a838f80da5637a292b494a6d84ae63da4ce5fc435c8eb3548dcb833961dff588ff6b24974
+  metadata.gz: '059ec009fb6fd52704a2906bdfc8fb6a20f0e06dd2ac783e1f466ce4cfabbe71c2fa9cb269a332e69fc3a05cdef7d8e394cfc3a3e1bfb11c94c0c7d43c0dd26d'
+  data.tar.gz: c4f5fb863ec9a636d4b7591b50afe16d4a0174c28390f5d42aa84f7ff32a2e904cfe71de4104b4425a7661cb82e71a9b114abc6b874888c52d8ad74683f14d58

data/.gitignore

@@ -9,6 +9,7 @@
 /profiles/
 /tmp/
 /.idea/
+/obsidian/
 .DS_Store
 *.gem
 **.sw*

data/CHANGELOG.md

@@ -1,5 +1,64 @@
 # Changelog
 
+## 2.0.5 - 2026-06-28
+
+### Async Runtime (Infraestrutura nao-bloqueante)
+
+- **`OnyxCord::AsyncRuntime`**: modulo central que gerencia o reactor `async` com `run`, `async` e `sleep`, reaproveitando reactor existente quando disponivel.
+- **`EventExecutor::AsyncPool`**: novo pool de workers baseado em `Async::Queue` e fibers, sem threads.
+- **Gateway**: `run_async` nao cria mais `Thread.new` — usa `@task = AsyncRuntime.async { run }`. Todos os `sleep` trocados por `AsyncRuntime.sleep`.
+- **WebSocket**: usa `AsyncRuntime.async` em vez de `Async do` solto na classe.
+- **API REST**: `request` agora delega para `request_async` automaticamente quando dentro de um reactor. `request_async` usa rate limiter async, `AsyncRuntime.sleep`, e retry com limite em 502.
+- **Rate Limiter Async**: novo `OnyxCord::RateLimiter::AsyncRest` que evita `mutex.synchronize { sleep }` bloqueante.
+- **Bot**: `run`/`stop`/`join` refatorados para o runtime async. `send_temporary_message` e `voice_connect` usam sleeps async.
+- Compatibilidade sync mantida: a API publica continua funcionando de forma sincrona quando chamada fora de um reactor.
+
+### Modern Application Commands DSL
+
+- **`bot.slash`, `bot.user_command`, `bot.message_command`**: nova DSL para comandos modernos com definicao e handler unificados.
+- **`bot.sync_application_commands!`**: sincroniza todos os commands registrados com a API do Discord de uma vez.
+- **`bot.bulk_overwrite_global_application_commands`** e **`bot.bulk_overwrite_guild_application_commands`**: wrappers para bulk overwrite.
+- **`ApplicationCommands::Context`**: wrapper com `respond`, `defer`, `edit_original`, `delete_original`, `followup` e acesso a `options`, `guild`, `channel`, `user`.
+- **`Interaction#edit_original`**, **`Interaction#delete_original`**, **`Interaction#followup`**: novos aliases dos metodos originais.
+- API legacy (`register_application_command` + `application_command`) mantida com compatibilidade total.
+
+### Exemplo da nova DSL
+
+```ruby
+bot.slash :ban, description: "Bane um membro", default_member_permissions: [:ban_members] do
+  user :member, "Membro que sera banido", required: true
+  string :reason, "Motivo do banimento", max_length: 512
+
+  execute do |ctx|
+    ctx.defer(ephemeral: true)
+    member = ctx.options[:member]
+    reason = ctx.options[:reason] || "Sem motivo informado"
+    ctx.guild.ban(member, reason: reason)
+    ctx.edit_original(content: "Membro banido com sucesso.")
+  end
+end
+
+bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
+```
+
+### Validacao
+
+- `bundle exec rspec`: 460 exemplos, 0 falhas, 3 pendentes.
+- `ruby -c lib/onyxcord/**/*.rb`: todos os arquivos com sintaxe OK.
+- `gem build onyxcord.gemspec`: sucesso.
+
+## 2.0.0 - 2026-06-28
+
+### Arquitetura & Performance (Major Refactoring)
+
+- **Runtime 100% Async**: A infraestrutura de threads (`Thread.new`) foi substituída pelo modelo de fibers do Ruby usando a gem `async`. Gateway, heartbeats, fila REST, worker de eventos e comandos agora executam de forma não-bloqueante no reator Async.
+- **REST Moderno via HTTPX**: Substituída a gem legada `rest-client` pela `httpx`, trazendo suporte nativo a conexões persistentes (Keep-Alive), HTTP/2, multipart uploads nativos e retries automáticos em erros 502.
+- **Gateway via Async-WebSocket**: Substituída a implementação de raw TCP sockets + `websocket-client-simple` por `async-websocket`, proporcionando um event loop de gateway extremamente rápido e escalável.
+- **Parse JSON via Oj**: A gem `oj` foi integrada em modo de compatibilidade (`mode: :compat`), acelerando transparentemente todas as serializações e deserializações de pacotes do Discord na lib inteira.
+- **Cache Inteligente LRU**: Os caches em memória (usuários, canais, servidores, membros) agora utilizam `LruRedux::ThreadSafeCache`. Os tamanhos padrão foram aumentados (`users: 50_000`, `channels: 10_000`, `servers: 1_000`, `members: 100_000`) e podem ser customizados via `OnyxCord.configure { |c| c.cache_sizes.users = 100_000 }`.
+- **Fusão do Webhooks**: A funcionalidade da gem separada `onyxcord-webhooks` foi integrada diretamente no núcleo da gem `onyxcord`. A gem `onyxcord-webhooks` agora atua apenas como um shim de transição deprecado.
+- **Alvo Ruby ≥ 3.4**: Atualizada a versão mínima requerida do Ruby para aproveitar as otimizações modernas do interpretador e fibras.
+
 ## 1.1.8 - 2026-06-28
 
 ### Correcoes
@@ -10,6 +69,7 @@
 ### Validacao
 
 - `bundle exec rspec spec/components_v2_spec.rb`: sucesso.
+- `bundle exec rspec`: 460 exemplos, 0 falhas, 3 pendentes.
 - `ruby -c lib/onyxcord/data/component.rb`: sucesso.
 - `ruby -c spec/components_v2_spec.rb`: sucesso.
 - `gem build onyxcord.gemspec`: sucesso.

data/Gemfile

@@ -4,4 +4,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in onyxcord.gemspec
 gemspec name: 'onyxcord'
-gemspec name: 'onyxcord-webhooks', development_group: 'webhooks'

data/README.md

@@ -22,6 +22,8 @@ Simple to start, deep enough to control.
 - Friendly Ruby API for Discord bots.
 - Traditional object events for productivity.
 - Raw gateway events for performance and lower allocation.
+- **Modern async runtime** built on `async` gem with non-blocking gateway, REST and event dispatch.
+- **New modern slash command DSL** with `bot.slash`, `execute`, and `bot.sync_application_commands!`.
 - Components V2 support with `Text Display`, `Container`, `Section`, `Media Gallery`, `File`, `Separator`, and `Thumbnail`.
 - Modern modal components, including `Label`, `Text Display`, modal selects, file upload, radio group, checkbox group, and checkbox.
 - Webhooks with embeds, files, and components.
@@ -112,6 +114,25 @@ bot.application_command(:feedback) do |event|
 end
 ```
 
+### Modern Command DSL
+
+```ruby
+bot.slash :ban, description: 'Ban a member', default_member_permissions: [:ban_members] do
+  user :member, 'Member to ban', required: true
+  string :reason, 'Ban reason', max_length: 512
+
+  execute do |ctx|
+    ctx.defer(ephemeral: true)
+    member = ctx.options[:member]
+    reason = ctx.options[:reason] || 'No reason provided'
+    ctx.guild.ban(member, reason: reason)
+    ctx.edit_original(content: 'Member banned.')
+  end
+end
+
+bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
+```
+
 ### Community
 
 Join the Discord server for support, updates, examples, and feedback: https://discord.gg/Jy2tpCUtzM
@@ -131,6 +152,8 @@ Simples para comecar, profundo para controlar.
 - API Ruby amigavel para bots do Discord.
 - Eventos tradicionais com objetos para quem quer produtividade.
 - Eventos raw para quem quer performance e menos alocacao.
+- **Runtime async moderno** baseado na gem `async`: gateway, REST e dispatch de eventos nao-bloqueantes.
+- **Nova DSL moderna de slash commands** com `bot.slash`, `execute` e `bot.sync_application_commands!`.
 - Components V2 com `Text Display`, `Container`, `Section`, `Media Gallery`, `File`, `Separator` e `Thumbnail`.
 - Novos componentes de modal, incluindo `Label`, `Text Display`, selects em modal, upload, radio group, checkbox group e checkbox.
 - Webhooks com embeds, arquivos e componentes.
@@ -221,6 +244,25 @@ bot.application_command(:feedback) do |event|
 end
 ```
 
+### DSL Moderna de Comandos
+
+```ruby
+bot.slash :ban, description: 'Bane um membro', default_member_permissions: [:ban_members] do
+  user :member, 'Membro que sera banido', required: true
+  string :reason, 'Motivo do banimento', max_length: 512
+
+  execute do |ctx|
+    ctx.defer(ephemeral: true)
+    member = ctx.options[:member]
+    reason = ctx.options[:reason] || 'Sem motivo informado'
+    ctx.guild.ban(member, reason: reason)
+    ctx.edit_original(content: 'Membro banido com sucesso.')
+  end
+end
+
+bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
+```
+
 ### Comunidade
 
 Entre no servidor do Discord para suporte, atualizacoes, exemplos e feedback: https://discord.gg/Jy2tpCUtzM
@@ -237,9 +279,11 @@ Simple para empezar, profundo para controlar.
 
 ### Caracteristicas
 
-- API Ruby amigable para bots de Discord.
+- API Ruby amigavel para bots de Discord.
 - Eventos tradicionales con objetos para productividad.
 - Eventos raw para rendimiento y menos asignaciones.
+- **Runtime async moderno** basado en la gem `async`: gateway, REST y dispatch de eventos no bloqueantes.
+- **Nueva DSL moderna de slash commands** con `bot.slash`, `execute` y `bot.sync_application_commands!`.
 - Components V2 con `Text Display`, `Container`, `Section`, `Media Gallery`, `File`, `Separator` y `Thumbnail`.
 - Componentes modernos de modal, incluyendo `Label`, `Text Display`, selects en modal, subida de archivos, radio group, checkbox group y checkbox.
 - Webhooks con embeds, archivos y componentes.
@@ -330,6 +374,25 @@ bot.application_command(:feedback) do |event|
 end
 ```
 
+### DSL Moderna de Comandos
+
+```ruby
+bot.slash :ban, description: 'Banear a un miembro', default_member_permissions: [:ban_members] do
+  user :member, 'Miembro a banear', required: true
+  string :reason, 'Motivo del baneo', max_length: 512
+
+  execute do |ctx|
+    ctx.defer(ephemeral: true)
+    member = ctx.options[:member]
+    reason = ctx.options[:reason] || 'Sin motivo'
+    ctx.guild.ban(member, reason: reason)
+    ctx.edit_original(content: 'Miembro baneado.')
+  end
+end
+
+bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
+```
+
 ### Comunidad
 
 Unete al servidor de Discord para soporte, actualizaciones, ejemplos y feedback: https://discord.gg/Jy2tpCUtzM

data/lib/onyxcord/api/channel.rb

@@ -23,7 +23,6 @@ module OnyxCord::API::Channel
     { **files, payload_json: body.to_json }
   end
 
-
   # Get a channel's data
   # https://discord.com/developers/docs/resources/channel#get-channel
   def resolve(token, channel_id)
@@ -111,7 +110,7 @@ module OnyxCord::API::Channel
   # @param attachments [Array<File>, nil] Attachments to use with `attachment://` in embeds. See
   #   https://discord.com/developers/docs/resources/channel#create-message-using-attachments-within-embeds
   def create_message(token, channel_id, message, tts = false, embeds = nil, nonce = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = nil, enforce_nonce = false, poll = nil)
-    tts = false unless tts == true || tts == false
+    tts = false unless [true, false].include?(tts)
     components = OnyxCord::MessageComponents.payload(components) unless components.nil?
     flags = OnyxCord::MessageComponents.apply_v2_flag(flags, components)
     body = { content: message, tts: tts == true, embeds: embeds, nonce: nonce, allowed_mentions: allowed_mentions, message_reference: message_reference, components: components, attachments: attachments ? attachment_payload(attachments) : nil, flags: flags, enforce_nonce: enforce_nonce, poll: poll }.compact
@@ -132,11 +131,6 @@ module OnyxCord::API::Channel
       body,
       **headers
     )
-  rescue RestClient::BadRequest => e
-    parsed = JSON.parse(e.response.body)
-    raise OnyxCord::Errors::MessageTooLong, "Message over the character limit (#{message.length} > 2000)" if parsed['content'].is_a?(Array) && parsed['content'].first == 'Must be 2000 or fewer in length.'
-
-    raise
   end
 
   # Send a file as a message to a channel
@@ -425,12 +419,6 @@ module OnyxCord::API::Channel
       Authorization: token,
       content_type: :json
     )
-  rescue RestClient::InternalServerError
-    raise 'Attempted to add self as a new group channel recipient!'
-  rescue RestClient::NoContent
-    raise 'Attempted to create a group channel with the PM channel recipient!'
-  rescue RestClient::Forbidden
-    raise 'Attempted to add a user to group channel without permission!'
   end
 
   # Add a user to a group channel.

data/lib/onyxcord/api/webhook.rb

@@ -62,7 +62,7 @@ module OnyxCord::API::Webhook
            end
 
     headers = { content_type: :json } unless file || attachments
-    with_components = components&.any? ? true : nil
+    with_components = components&.any? || nil
     query = URI.encode_www_form({ wait: wait, with_components: with_components }.compact)
 
     OnyxCord::API.request(

data/lib/onyxcord/api.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
-require 'rest-client'
-require 'json'
+require 'onyxcord/http'
+require 'onyxcord/json'
+require 'onyxcord/async/runtime'
 require 'time'
 
 require 'onyxcord/errors'
 require 'onyxcord/rate_limiter/rest'
+require 'onyxcord/rate_limiter/async_rest'
 
 # List of methods representing endpoints in Discord's API
 module OnyxCord::API
@@ -55,22 +57,31 @@ module OnyxCord::API
     required = "DiscordBot (https://github.com/kruldevb/OnyxCord, v#{OnyxCord::VERSION})"
     @bot_name ||= ''
 
-    "#{required} rest-client/#{RestClient::VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION}p#{RUBY_PATCHLEVEL} onyxcord/#{OnyxCord::VERSION} #{@bot_name}"
+    "#{required} httpx/#{HTTPX::VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION}p#{RUBY_PATCHLEVEL} onyxcord/#{OnyxCord::VERSION} #{@bot_name}"
   end
 
   # Resets all rate limit mutexes
   def reset_mutexes
     @rate_limiter = OnyxCord::RateLimiter::Rest.new
+    @async_rate_limiter = OnyxCord::RateLimiter::AsyncRest.new
   end
 
   def rate_limiter
     @rate_limiter ||= OnyxCord::RateLimiter::Rest.new
   end
 
+  def async_rate_limiter
+    @async_rate_limiter ||= OnyxCord::RateLimiter::AsyncRest.new
+  end
+
   def rate_limiter_stats
     rate_limiter.stats
   end
 
+  def async_rate_limiter_stats
+    async_rate_limiter.stats
+  end
+
   # Wait a specified amount of time synchronised with the specified mutex.
   def sync_wait(time, mutex)
     mutex.synchronize { sleep time }
@@ -82,80 +93,125 @@ module OnyxCord::API
     mutex.unlock
   end
 
-  # Performs a RestClient request.
+  # Performs a raw HTTP request using HTTPX.
   # @param type [Symbol] The type of HTTP request to use.
-  # @param attributes [Array] The attributes for the request.
-  def raw_request(type, attributes)
-    RestClient.send(type, *attributes)
-  rescue RestClient::Forbidden => e
-    # HACK: for #request, dynamically inject restclient's response into NoPermission - this allows us to rate limit
-    noprm = OnyxCord::Errors::NoPermission.new
-    noprm.define_singleton_method(:_rc_response) { e.response }
-    raise noprm, "The bot doesn't have the required permission to do this!"
-  rescue RestClient::BadGateway
-    OnyxCord::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')
-    retry
+  # @param url [String] The URL to request.
+  # @param body [String, Hash, nil] The request body.
+  # @param headers [Hash] Additional headers.
+  # @return [OnyxCord::HTTP::Response]
+  def raw_request(type, url, body = nil, **headers)
+    headers[:user_agent] = user_agent
+
+    response = OnyxCord::HTTP.request(type, url, body, **headers)
+
+    if response.code == 403
+      noprm = OnyxCord::Errors::NoPermission.new
+      noprm.define_singleton_method(:_response) { response }
+      raise noprm, "The bot doesn't have the required permission to do this!"
+    end
+
+    # Retry on 502 Bad Gateway
+    if response.code == 502
+      OnyxCord::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')
+      return raw_request(type, url, body, **headers)
+    end
+
+    response
   end
 
   # Make an API request, including rate limit handling.
   def request(key, major_parameter, type, *attributes)
-    # Add a custom user agent
-    attributes.last[:user_agent] = user_agent if attributes.last.is_a? Hash
+    if Async::Task.current?
+      request_async(key, major_parameter, type, *attributes)
+    else
+      OnyxCord::AsyncRuntime.run { request_async(key, major_parameter, type, *attributes) }
+    end
+  end
+
+  # Async version of request.
+  def request_async(key, major_parameter, type, *attributes)
+    url = attributes.shift
+    headers_or_body = attributes
+
+    body = nil
+    headers = {}
+
+    headers_or_body.each do |arg|
+      if arg.is_a?(Hash)
+        headers.merge!(arg)
+      elsif body.nil?
+        body = arg
+      end
+    end
+
+    content_type = headers.delete(:content_type)
+    headers['content-type'] = 'application/json' if content_type == :json
+
+    headers['user-agent'] = user_agent
+
+    retries = 0
+    max_retries = key == :gateway ? 0 : 3
 
     begin
-      rate_limiter.before_request(key, major_parameter)
+      async_rate_limiter.before_request(key, major_parameter)
 
       response = nil
-      begin
-        response = raw_request(type, attributes)
-      rescue RestClient::Exception => e
-        response = e.response
+      loop do
+        response = OnyxCord::HTTP.request(type, url, body, **headers)
+        break unless response.code == 502
 
-        if response.body && !e.is_a?(RestClient::TooManyRequests)
-          data = JSON.parse(response.body)
-          err_klass = OnyxCord::Errors.error_class_for(data['code'] || 0)
-          e = err_klass.new(data['message'], data['errors'])
+        retries += 1
+        break unless retries < max_retries
 
-          OnyxCord::LOGGER.error(e.full_message)
-        end
+        OnyxCord::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')
+        OnyxCord::AsyncRuntime.sleep(retries * 0.5)
+      end
 
-        raise e
-      rescue OnyxCord::Errors::NoPermission => e
-        if e.respond_to?(:_rc_response)
-          response = e._rc_response
-        else
-          OnyxCord::LOGGER.warn("NoPermission doesn't respond_to? _rc_response!")
+      if response.code == 403
+        noprm = OnyxCord::Errors::NoPermission.new
+        noprm.define_singleton_method(:_response) { response }
+        raise noprm, "The bot doesn't have the required permission to do this!"
+      end
+
+      if response.code >= 400 && response.code != 429
+        data = begin
+          JSON.parse(response.body)
+        rescue StandardError
+          nil
         end
 
+        raise "HTTP #{response.code}: #{response.body}" unless data
+
+        err_klass = OnyxCord::Errors.error_class_for(data['code'] || 0)
+        e = err_klass.new(data['message'], data['errors'])
+        OnyxCord::LOGGER.error(e.full_message)
         raise e
-      ensure
-        if response
-          rate_limiter.record_response(key, major_parameter, response.headers)
-        else
-          OnyxCord::LOGGER.ratelimit('Response was nil before trying to preemptively rate limit!')
-        end
       end
-    rescue RestClient::TooManyRequests => e
-      trace("429 #{key} #{major_parameter}")
-      rate_limiter.handle_rate_limit(key, major_parameter, e.response)
+    rescue OnyxCord::Errors::NoPermission => e
+      async_rate_limiter.record_response(key, major_parameter, e._response.headers) if e.respond_to?(:_response)
+      raise e
+    else
+      async_rate_limiter.record_response(key, major_parameter, response.headers)
+    end
 
-      retry
+    if response.code == 429
+      trace("429 #{key} #{major_parameter}")
+      async_rate_limiter.handle_rate_limit(key, major_parameter, response)
+      return request_async(key, major_parameter, type, url, body, headers)
     end
 
-    # Endpoints that use Elasticsearch can return a 202 when the index isn't ready yet. Wait the
-    # amount of time indicated by the response body, and then recursively retry and return the request.
-    if response&.code == 202 && response&.body
-      body = JSON.parse(response.body)
+    if response.code == 202 && response.body
+      body_data = JSON.parse(response.body)
 
-      if body['code'] == 110_000
-        case body['retry_after']
+      if body_data['code'] == 110_000
+        case body_data['retry_after']
         when 0, 1, nil
-          sleep(rand(4.5..5.0))
+          OnyxCord::AsyncRuntime.sleep(rand(4.5..5.0))
         else
-          sleep(body['retry_after'])
+          OnyxCord::AsyncRuntime.sleep(body_data['retry_after'])
         end
 
-        return request(key, major_parameter, type, *attributes)
+        return request_async(key, major_parameter, type, url, body, headers)
       end
     end
 

data/lib/onyxcord/bot.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rest-client'
+require 'onyxcord/http'
 require 'zlib'
 
 require 'onyxcord/configuration'
@@ -33,6 +33,7 @@ require 'onyxcord/api/invite'
 require 'onyxcord/api/interaction'
 require 'onyxcord/api/application'
 
+require 'onyxcord/async/runtime'
 require 'onyxcord/errors'
 require 'onyxcord/message_components'
 require 'onyxcord/data'
@@ -42,6 +43,7 @@ require 'onyxcord/websocket'
 require 'onyxcord/cache'
 require 'onyxcord/gateway'
 
+require 'onyxcord/application_commands'
 require 'onyxcord/voice/voice_bot'
 
 module OnyxCord
@@ -309,28 +311,27 @@ module OnyxCord
     #   this. If you need a way to safely run code after the bot is fully
     #   connected, use a {#ready} event handler instead.
     def run(background = false)
-      @gateway.run_async
-      return if background
+      if background
+        @run_task = OnyxCord::AsyncRuntime.async { run_forever }
+        return @run_task
+      end
+
+      OnyxCord::AsyncRuntime.run { run_forever }
+    end
 
-      debug('Oh wait! Not exiting yet as run was run synchronously.')
-      @gateway.sync
+    def run_forever
+      @gateway.run
     end
 
-    # Joins the bot's connection thread with the current thread.
-    # This blocks execution until the websocket stops, which should only happen
-    # manually triggered. or due to an error. This is necessary to have a
-    # continuously running bot.
     def join
-      @gateway.sync
+      @run_task&.wait
     end
     alias_method :sync, :join
 
-    # Stops the bot gracefully, disconnecting the websocket without immediately killing the thread. This means that
-    # Discord is immediately aware of the closed connection and makes the bot appear offline instantly.
-    # @note This method no longer takes an argument as of 3.4.0
     def stop(_no_sync = nil)
       @gateway.stop
       @event_executor.shutdown
+      @run_task&.stop if @run_task.respond_to?(:stop)
       nil
     end
 
@@ -411,7 +412,7 @@ module OnyxCord
 
       debug('Voice channel init packet sent! Now waiting.')
 
-      sleep(0.05) until @voices[server_id]
+      OnyxCord::AsyncRuntime.sleep(0.05) until @voices[server_id]
       debug('Voice connect succeeded!')
       @voices[server_id]
     end
@@ -477,11 +478,9 @@ module OnyxCord
     # @param enforce_nonce [true, false] Whether the nonce should be enforced and used for message de-duplication.
     # @param poll [Hash, Poll::Builder, Poll, nil] The poll that should be attached to this message.
     def send_temporary_message(channel, content, timeout, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0, nonce = nil, enforce_nonce = false, poll = nil)
-      Thread.new do
-        Thread.current[:onyxcord_name] = "#{@current_thread}-temp-msg"
-
+      OnyxCord::AsyncRuntime.async do
         message = send_message(channel, content, tts, embeds, attachments, allowed_mentions, message_reference, components, flags, nonce, enforce_nonce, poll)
-        sleep(timeout)
+        OnyxCord::AsyncRuntime.sleep(timeout)
         message.delete
       end
 
@@ -504,7 +503,6 @@ module OnyxCord
           filename ||= File.basename(file.path)
           filename = "SPOILER_#{filename}" unless filename.start_with? 'SPOILER_'
         end
-        # https://github.com/rest-client/rest-client/blob/v2.0.2/lib/restclient/payload.rb#L160
         file.define_singleton_method(:original_filename) { filename } if filename
         file.define_singleton_method(:path) { filename } if filename
       end
@@ -867,6 +865,37 @@ module OnyxCord
       ApplicationCommand.new(JSON.parse(resp), self, server_id)
     end
 
+    # @return [OnyxCord::ApplicationCommands::Registry]
+    def commands
+      @modern_command_registry ||= OnyxCord::ApplicationCommands::Registry.new(self)
+    end
+
+    def slash(name, description: nil, **attributes, &block)
+      commands.slash(name, description: description, **attributes, &block)
+    end
+
+    def user_command(name, **attributes, &block)
+      commands.user(name, **attributes, &block)
+    end
+
+    def message_command(name, **attributes, &block)
+      commands.message(name, **attributes, &block)
+    end
+
+    def sync_application_commands!(server_id: nil, delete_unknown: false)
+      commands.sync!(server_id: server_id, delete_unknown: delete_unknown)
+    end
+
+    def bulk_overwrite_global_application_commands(commands)
+      response = API::Application.bulk_overwrite_global_commands(@token, profile.id, commands)
+      JSON.parse(response).map { |data| ApplicationCommand.new(data, self) }
+    end
+
+    def bulk_overwrite_guild_application_commands(server_id, commands)
+      response = API::Application.bulk_overwrite_guild_commands(@token, profile.id, server_id.resolve_id, commands)
+      JSON.parse(response).map { |data| ApplicationCommand.new(data, self, server_id) }
+    end
+
     # @yieldparam [OptionBuilder]
     # @yieldparam [PermissionBuilder]
     # @example

data/lib/onyxcord/cache.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'lru_redux'
 require 'onyxcord/api'
 require 'onyxcord/api/server'
 require 'onyxcord/api/invite'
@@ -26,17 +27,15 @@ module OnyxCord
     # Initializes this cache
     def init_cache
       @cache_policy ||= OnyxCord.configuration.normalize_cache(:full)
+      sizes = OnyxCord.configuration.cache_sizes
 
-      @users = cache_enabled?(:users) ? {} : nil
-
+      @users = cache_enabled?(:users) ? LruRedux::ThreadSafeCache.new(sizes.users) : nil
       @voice_regions = cache_enabled?(:voice_regions) ? {} : nil
-
-      @servers = cache_enabled?(:servers) ? {} : nil
-
-      @channels = cache_enabled?(:channels) ? {} : nil
-      @pm_channels = cache_enabled?(:pm_channels) ? {} : nil
-      @thread_members = cache_enabled?(:thread_members) ? {} : nil
-      @server_previews = cache_enabled?(:server_previews) ? {} : nil
+      @servers = cache_enabled?(:servers) ? LruRedux::ThreadSafeCache.new(sizes.servers) : nil
+      @channels = cache_enabled?(:channels) ? LruRedux::ThreadSafeCache.new(sizes.channels) : nil
+      @pm_channels = cache_enabled?(:pm_channels) ? LruRedux::ThreadSafeCache.new(sizes.pm_channels) : nil
+      @thread_members = cache_enabled?(:thread_members) ? LruRedux::ThreadSafeCache.new(sizes.thread_members) : nil
+      @server_previews = cache_enabled?(:server_previews) ? LruRedux::ThreadSafeCache.new(sizes.server_previews) : nil
     end
 
     def cache_enabled?(key)
@@ -46,7 +45,7 @@ module OnyxCord
     def cache_stats
       CACHE_STORES.each_with_object({}) do |(key, ivar), stats|
         store = instance_variable_get(ivar)
-        stats[key] = store.respond_to?(:size) ? store.size : 0
+        stats[key] = store.respond_to?(:count) ? store.count : 0
       end
     end
 
@@ -56,7 +55,7 @@ module OnyxCord
       keys.each_with_object({}) do |key, pruned|
         ivar = CACHE_STORES.fetch(key)
         store = instance_variable_get(ivar)
-        pruned[key] = store.respond_to?(:size) ? store.size : 0
+        pruned[key] = store.respond_to?(:count) ? store.count : 0
         store&.clear
       end
     end