Fix: release please bs 2 electric boogaloo (#701)

* fix: update release (me from this) please

* fix: add dep to release please

* Revert "fix: update release (me from this) please"

This reverts commit 0618c492c7.

.github/workflows/git-town.yml

@@ -1,3 +1,6 @@
+# DO NOT EDIT DIRECTLY IN REPOSITORY
+# Managed in Terraform templates
+
 name: Git Town
 
 on:
@@ -8,7 +11,7 @@ jobs:
     name: Display the branch stack
     runs-on: ubuntu-slim
 
-    if: ${{ !startsWith(github.head_ref, 'release-please--') }}
+    if: ${{ github.event.pull_request.head.repo.full_name == github.repository && !startsWith(github.head_ref, 'release-please--') }}
 
     permissions:
       contents: read
@@ -17,3 +20,4 @@ jobs:
     steps:
       - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
       - uses: stoatchat/action-git-town@4bc5c942e4603bffa0806b51d5fe5f0bc5deb0ac
+        continue-on-error: true

.github/workflows/release-webhook.yml

@@ -1,3 +1,6 @@
+# DO NOT EDIT DIRECTLY IN REPOSITORY
+# Managed in Terraform templates
+
 name: Release Webhook
 
 on:

.github/workflows/validate-pr-title.yml

@@ -1,3 +1,6 @@
+# DO NOT EDIT DIRECTLY IN REPOSITORY
+# Managed in Terraform templates
+
 name: "Lint PR"
 
 on:
@@ -15,6 +18,6 @@ jobs:
     permissions:
       pull-requests: read
     steps:
-      - uses: amannn/action-semantic-pull-request@v6
+      - uses: amannn/action-semantic-pull-request@48f256284bd46cdaab1048c3721360e808335d50 # v6.1.1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "0.11.5"
+    ".": "0.12.0"
 }

CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## [0.12.0](https://github.com/stoatchat/stoatchat/compare/v0.11.5...v0.12.0) (2026-03-28)
+
+
+### Features
+
+* add bug report template for issue tracking ([#627](https://github.com/stoatchat/stoatchat/issues/627)) ([f777e28](https://github.com/stoatchat/stoatchat/commit/f777e2863c6ca50057c8b5d0a5be14915d287724))
+* Add slowmode functionality to text channels ([#680](https://github.com/stoatchat/stoatchat/issues/680)) ([6107f24](https://github.com/stoatchat/stoatchat/commit/6107f242fd3ebaff71a15f9a16330ffbcb4f2d7b))
+* Allow restricting server creation to specific users ([#685](https://github.com/stoatchat/stoatchat/issues/685)) ([edfa97d](https://github.com/stoatchat/stoatchat/commit/edfa97db108c9c81828547f98a1db5315cb5ba4a))
+* compute thumbhash for images ([#596](https://github.com/stoatchat/stoatchat/issues/596)) ([c2d4369](https://github.com/stoatchat/stoatchat/commit/c2d4369e160f32d79bce0a0b0f14677f89de3669))
+* Detect animation in image files for fetch_preview ([#574](https://github.com/stoatchat/stoatchat/issues/574)) ([3fa0abf](https://github.com/stoatchat/stoatchat/commit/3fa0abf47f5f42ddd8ee041fe4c44fbc5ba800c1))
+* expose global and user limits in root API response ([#644](https://github.com/stoatchat/stoatchat/issues/644)) ([0b522eb](https://github.com/stoatchat/stoatchat/commit/0b522ebddc17f2e3f792ff5e2347793e9849fa23))
+* implement time based message sweep on user ban ([#670](https://github.com/stoatchat/stoatchat/issues/670)) ([98c7b1b](https://github.com/stoatchat/stoatchat/commit/98c7b1b5a5b9fdac5c0ab83be10f0e23114dbfc9))
+* load config from env vars ([#576](https://github.com/stoatchat/stoatchat/issues/576)) ([5191bd1](https://github.com/stoatchat/stoatchat/commit/5191bd16b2a905b8409838e34eb0baca96f08580))
+* parse message push notification content and replace internal formatting ([#693](https://github.com/stoatchat/stoatchat/issues/693)) ([d1e72ce](https://github.com/stoatchat/stoatchat/commit/d1e72cee42c54e16f4e49af569897528b10a28ca))
+* Transfer ownership ([#396](https://github.com/stoatchat/stoatchat/issues/396)) ([735d644](https://github.com/stoatchat/stoatchat/commit/735d644e043793cb86e74aab5b88bb4b8bc17ba2))
+* update livekit ([#698](https://github.com/stoatchat/stoatchat/issues/698)) ([f181edc](https://github.com/stoatchat/stoatchat/commit/f181edc8f2ff3ce4b6d48938dfc73931ecfa2279))
+
+
+### Bug Fixes
+
+* add flag for disabling events instead of commenting them out ([#695](https://github.com/stoatchat/stoatchat/issues/695)) ([a5cd08a](https://github.com/stoatchat/stoatchat/commit/a5cd08a655dece4269f3ac84fa2387ae356709a5))
+* add masquerade permission to default direct message settings ([#665](https://github.com/stoatchat/stoatchat/issues/665)) ([ab52569](https://github.com/stoatchat/stoatchat/commit/ab525699bd6663333f0e9fed6d2455e482e6a09f))
+* Check for appropriate permission for removing other users avatar ([#657](https://github.com/stoatchat/stoatchat/issues/657)) ([d56135e](https://github.com/stoatchat/stoatchat/commit/d56135e0cbc713884c9378832952f7ad490fa315))
+* default video resolution is a non-existent size ([#601](https://github.com/stoatchat/stoatchat/issues/601)) ([0698e11](https://github.com/stoatchat/stoatchat/commit/0698e115e8d003d615e468c4fb9654e6bbc9107f)), closes [#588](https://github.com/stoatchat/stoatchat/issues/588)
+* **docs:** Update GitHub links ([#647](https://github.com/stoatchat/stoatchat/issues/647)) ([b830631](https://github.com/stoatchat/stoatchat/commit/b830631bd25a546844b7bdd30386084bb365e4de))
+* don't use a bitop for OR ([#676](https://github.com/stoatchat/stoatchat/issues/676)) ([5701b5c](https://github.com/stoatchat/stoatchat/commit/5701b5c18c513f796af365169ceaea372a22638c))
+* Fix typo for p256dh in vapid notification flow ([#622](https://github.com/stoatchat/stoatchat/issues/622)) ([a80ad1c](https://github.com/stoatchat/stoatchat/commit/a80ad1cbe58b8af5e45751e51d94d93c1cea1c9f))
+* improve generated openapi.json ([#584](https://github.com/stoatchat/stoatchat/issues/584)) ([52ed510](https://github.com/stoatchat/stoatchat/commit/52ed5100c2446e0b261085639e123e7e124cab2c))
+* no node state set on channel creation ([#653](https://github.com/stoatchat/stoatchat/issues/653)) ([24d0d2b](https://github.com/stoatchat/stoatchat/commit/24d0d2b7266f6f8a692d0a52704acfecf517674c))
+* only show first line on commit messages ([#696](https://github.com/stoatchat/stoatchat/issues/696)) ([91783b9](https://github.com/stoatchat/stoatchat/commit/91783b906697fc85305dee683f7c15dda55f0c50))
+* pass &str to Reference ([#697](https://github.com/stoatchat/stoatchat/issues/697)) ([ccda6f5](https://github.com/stoatchat/stoatchat/commit/ccda6f5c53ee043705f7ff6b5f6c393f020781de))
+* redis_url vs redis_uri in config ([#666](https://github.com/stoatchat/stoatchat/issues/666)) ([b0b728f](https://github.com/stoatchat/stoatchat/commit/b0b728fb0dbc9ee28360301de1c3ea501bbbff1d))
+* replace some links and Revolt mentions to current Stoat ([#515](https://github.com/stoatchat/stoatchat/issues/515)) ([d629e89](https://github.com/stoatchat/stoatchat/commit/d629e89304be2f0011e189293b278f07d346aa7d))
+* send push notifications for DM and group messages ([#660](https://github.com/stoatchat/stoatchat/issues/660)) ([52c0d2f](https://github.com/stoatchat/stoatchat/commit/52c0d2f266b76d8975bba2d5e75c62bb30149c45))
+* store server id in redis and in room metadata to be able to delete voice state in all scenarios ([#656](https://github.com/stoatchat/stoatchat/issues/656)) ([49c6289](https://github.com/stoatchat/stoatchat/commit/49c628958070e4f0a5edc764d3b48158589219d9))
+* uname is missing from crond ([#675](https://github.com/stoatchat/stoatchat/issues/675)) ([dc4438b](https://github.com/stoatchat/stoatchat/commit/dc4438bc3c7b2cad8d442b3cd438afb9ed566a5e))
+
 ## [0.11.5](https://github.com/stoatchat/stoatchat/compare/v0.11.4...v0.11.5) (2026-02-17)
 
 

Cargo.lock

@@ -6660,9 +6660,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.11.2"
+version = "1.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23d7fd106d8c02486a8d64e778353d1cffe08ce79ac2e82f540c86d0facf6912"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -6672,9 +6672,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.10"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b9458fa0bfeeac22b5ca447c63aaf45f28439a709ccd244698632f9aa6394d6"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -6824,6 +6824,7 @@ dependencies = [
  "simdutf8",
  "strum_macros",
  "tempfile",
+ "thumbhash",
  "tokio 1.49.0",
  "tower-http 0.5.2",
  "tracing",
@@ -7149,9 +7150,12 @@ dependencies = [
  "iso8601-timestamp",
  "log",
  "pretty_env_logger",
+ "redis-kiss",
+ "regex",
  "revolt-config",
  "revolt-database",
  "revolt-models",
+ "revolt-parser",
  "revolt-presence",
  "revolt-result",
  "revolt_a2",
@@ -8832,6 +8836,12 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "thumbhash"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b7726e0245a7331bd0c9a1fb4fd99fd695bcd478ca569f0eda2ff2cb14e7a00"
+
 [[package]]
 name = "tiff"
 version = "0.10.3"

README.md

@@ -2,14 +2,14 @@
 <h1>
   Stoat Backend
   
-  [![Stars](https://img.shields.io/github/stars/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/stargazers)
-  [![Forks](https://img.shields.io/github/forks/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/network/members)
-  [![Pull Requests](https://img.shields.io/github/issues-pr/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/pulls)
-  [![Issues](https://img.shields.io/github/issues/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/issues)
-  [![Contributors](https://img.shields.io/github/contributors/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/graphs/contributors)
-  [![License](https://img.shields.io/github/license/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/blob/main/LICENSE)
+  [![Stars](https://img.shields.io/github/stars/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/stargazers)
+  [![Forks](https://img.shields.io/github/forks/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/network/members)
+  [![Pull Requests](https://img.shields.io/github/issues-pr/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/pulls)
+  [![Issues](https://img.shields.io/github/issues/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/issues)
+  [![Contributors](https://img.shields.io/github/contributors/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/graphs/contributors)
+  [![License](https://img.shields.io/github/license/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/blob/main/LICENSE)
 </h1>
-The services and libraries that power the Revolt service.<br/>
+The services and libraries that power the Stoat service.<br/>
 <br/>
 
 | Crate              | Path                                               | Description                         |                                                                                                                                                                                                                                                                                                           |
@@ -39,7 +39,7 @@ Rust 1.86.0 or higher.
 
 ## Development Guide
 
-Before contributing, make yourself familiar with [our contribution guidelines](https://developers.revolt.chat/contrib.html) and the [technical documentation for this project](https://revoltchat.github.io/backend/).
+Before contributing, make yourself familiar with [our contribution guidelines](https://developers.stoat.chat/developing/contrib/) and the [technical documentation for this project](https://developers.stoat.chat/).
 
 Before getting started, you'll want to install:
 
@@ -70,8 +70,9 @@ As a heads-up, the development environment uses the following ports:
 Now you can clone and build the project:
 
 ```bash
-git clone https://github.com/revoltchat/backend revolt-backend
-cd revolt-backend
+git clone https://github.com/stoatchat/stoatchat stoat-backend
+cd stoat-backend
+mise install
 mise build
 ```
 
@@ -130,9 +131,6 @@ Then continue:
 # start other necessary services
 docker compose up -d
 
-# run everything together
-./scripts/start.sh
-# .. or individually
 # run the API server
 cargo run --bin revolt-delta
 # run the events server
@@ -158,16 +156,11 @@ You can start a web client by doing the following:
 corepack enable
 
 # clone the web client and run it:
-git clone --recursive https://github.com/revoltchat/revite
-cd revite
-yarn
-yarn build:deps
-echo "VITE_API_URL=http://local.revolt.chat:14702" > .env.local
-yarn dev --port 14701
+git clone --recursive https://github.com/stoatchat/for-web stoat-web
+cd stoat-web
+# refer to stoat-web/README.md for startup, creating an account and loging in
 ```
 
-Then go to http://local.revolt.chat:14701 to create an account/login.
-
 When signing up, go to http://localhost:14080 to find confirmation/password reset emails.
 
 ## Deployment Guide
@@ -198,7 +191,7 @@ Tag and push a new release by running:
 just release
 ```
 
-If you have bumped the crate versions, proceed to [GitHub releases](https://github.com/revoltchat/backend/releases/new) to create a changelog.
+If you have bumped the crate versions, proceed to [GitHub releases](https://github.com/stoatchat/stoatchat/releases/new) to create a changelog.
 
 ## Testing
 
@@ -217,6 +210,6 @@ TEST_DB=MONGODB cargo nextest run
 
 ## License
 
-The Revolt backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/revoltchat/backend/blob/master/LICENSE).
+The Stoat backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/stoatchat/stoatchat/blob/main/LICENSE).
 
 **Individual crates may supply their own licenses!**

Revolt.toml

@@ -15,7 +15,7 @@ host = "127.0.0.1"
 [hosts]
 # Web locations of various services
 # Defaults assume all services are reverse-proxied
-# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
+# See https://github.com/stoatchat/self-hosted/blob/main/Caddyfile
 #
 # Remember to change these to https/wss where appropriate in production!
 app = "http://local.revolt.chat:14701"

compose.yml

@@ -70,8 +70,8 @@ services:
       MAILDEV_INCOMING_PASS: smtp
 
   livekit:
-    image: ghcr.io/stoatchat/livekit-server:v1.9.9
+    image: ghcr.io/stoatchat/livekit-server:v1.9.13
     command: --config /etc/livekit.yml
     network_mode: "host"
     volumes:
-      - ./livekit.yml:/etc/livekit.yml
+      - ./livekit.yml:/etc/livekit.yml

crates/bonfire/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-bonfire"
-version = "0.11.5"
+version = "0.12.0"
 license = "AGPL-3.0-or-later"
 edition = "2021"
 publish = false

crates/bonfire/src/events/impl.rs

@@ -4,7 +4,7 @@ use futures::future::join_all;
 use revolt_database::{
     events::client::{EventV1, ReadyPayloadFields},
     util::permissions::DatabasePermissionQuery,
-    voice::get_channel_voice_state,
+    voice::{get_channel_voice_state, UserVoiceChannel},
     Channel, Database, Member, MemberCompositeKey, Presence, RelationshipStatus,
 };
 use revolt_models::v0;
@@ -167,7 +167,9 @@ impl State {
                         | Channel::TextChannel { voice: Some(_), .. }
                 )
             }) {
-                if let Ok(Some(voice_state)) = get_channel_voice_state(channel).await {
+                if let Ok(Some(voice_state)) =
+                    get_channel_voice_state(&UserVoiceChannel::from_channel(channel)).await
+                {
                     if let Some(server) = channel.server() {
                         let set = voice_state_server_members
                             .entry(server.to_string())
@@ -398,29 +400,33 @@ impl State {
     }
 
     /// Push presence change to the user and all associated server topics
-    pub async fn broadcast_presence_change(&self, _target: bool) {
-        // disabled events
-        // if if let Some(status) = &self.cache.users.get(&self.cache.user_id).unwrap().status {
-        //     status.presence != Some(Presence::Invisible)
-        // } else {
-        //     true
-        // } {
-        //     let event = EventV1::UserUpdate {
-        //         id: self.cache.user_id.clone(),
-        //         data: v0::PartialUser {
-        //             online: Some(target),
-        //             ..Default::default()
-        //         },
-        //         clear: vec![],
-        //         event_id: Some(ulid::Ulid::new().to_string()),
-        //     };
+    pub async fn broadcast_presence_change(&self, target: bool) {
+        let config = revolt_config::config().await;
+        if config.disable_events_dont_use {
+            return;
+        }
 
-        //     for server in self.cache.servers.keys() {
-        //         event.clone().p(server.clone()).await;
-        //     }
+        if if let Some(status) = &self.cache.users.get(&self.cache.user_id).unwrap().status {
+            status.presence != Some(Presence::Invisible)
+        } else {
+            true
+        } {
+            let event = EventV1::UserUpdate {
+                id: self.cache.user_id.clone(),
+                data: v0::PartialUser {
+                    online: Some(target),
+                    ..Default::default()
+                },
+                clear: vec![],
+                event_id: Some(ulid::Ulid::new().to_string()),
+            };
 
-        //     event.p(self.cache.user_id.clone()).await;
-        // }
+            for server in self.cache.servers.keys() {
+                event.clone().p(server.clone()).await;
+            }
+
+            event.p(self.cache.user_id.clone()).await;
+        }
     }
 
     /// Handle an incoming event for protocol version 1

crates/bonfire/src/websocket.rs

@@ -428,6 +428,8 @@ async fn worker(
     mut read: WsReader,
     write: &Mutex<WsWriter>,
 ) {
+    let revolt_config = revolt_config::config().await;
+
     loop {
         let t1 = read.try_next().fuse();
         let t2 = kill_signal_r.recv().fuse();
@@ -463,31 +465,38 @@ async fn worker(
                 };
 
                 match payload {
-                    // disabled events
-                    // ClientMessage::BeginTyping { channel } => {
-                    //     if !subscribed.read().await.contains(&channel) {
-                    //         continue;
-                    //     }
+                    ClientMessage::BeginTyping { channel } => {
+                        if revolt_config.disable_events_dont_use {
+                            continue;
+                        }
 
-                    //     EventV1::ChannelStartTyping {
-                    //         id: channel.clone(),
-                    //         user: user_id.clone(),
-                    //     }
-                    //     .p(channel.clone())
-                    //     .await;
-                    // }
-                    // ClientMessage::EndTyping { channel } => {
-                    //     if !subscribed.read().await.contains(&channel) {
-                    //         continue;
-                    //     }
+                        if !subscribed.read().await.contains(&channel) {
+                            continue;
+                        }
 
-                    //     EventV1::ChannelStopTyping {
-                    //         id: channel.clone(),
-                    //         user: user_id.clone(),
-                    //     }
-                    //     .p(channel.clone())
-                    //     .await;
-                    // }
+                        EventV1::ChannelStartTyping {
+                            id: channel.clone(),
+                            user: user_id.clone(),
+                        }
+                        .p(channel.clone())
+                        .await;
+                    }
+                    ClientMessage::EndTyping { channel } => {
+                        if revolt_config.disable_events_dont_use {
+                            continue;
+                        }
+
+                        if !subscribed.read().await.contains(&channel) {
+                            continue;
+                        }
+
+                        EventV1::ChannelStopTyping {
+                            id: channel.clone(),
+                            user: user_id.clone(),
+                        }
+                        .p(channel.clone())
+                        .await;
+                    }
                     ClientMessage::Subscribe { server_id } => {
                         let mut servers = active_servers.lock().await;
                         let has_item = servers.contains_key(&server_id);

crates/core/coalesced/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-coalesced"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>", "Zomatree <me@zomatree.live>"]

crates/core/config/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-config"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -38,4 +38,4 @@ sentry = { version = "0.31.5", optional = true }
 sentry-anyhow = { version = "0.38.1", optional = true }
 
 # Core
-revolt-result = { version = "0.11.5", path = "../result", optional = true }
+revolt-result = { version = "0.12.0", path = "../result", optional = true }

crates/core/config/Revolt.toml

@@ -1,4 +1,5 @@
 production = false
+disable_events_dont_use = false
 
 [database]
 # MongoDB connection URL
@@ -11,7 +12,7 @@ redis = "redis://redis/"
 [hosts]
 # Web locations of various services
 # Defaults assume all services are reverse-proxied
-# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
+# See https://github.com/stoatchat/self-hosted/blob/main/Caddyfile
 #
 # Remember to change these to https/wss where appropriate in production!
 app = "http://local.revolt.chat"
@@ -34,7 +35,7 @@ password = "rabbitpass"
 
 [api.registration]
 # Whether an invite should be required for registration
-# See https://github.com/revoltchat/self-hosted#making-your-instance-invite-only
+# See https://github.com/stoatchat/self-hosted#making-your-instance-invite-only
 invite_only = false
 
 [api.smtp]
@@ -88,6 +89,11 @@ production = true
 # Increasing this will resolve mentions faster, but will consume more memory while resolving.
 mass_mention_chunk_size = 200
 
+# How long pushd will cache resolved names for rendered message notifications.
+# Increasing this will result in lower database usage, but may result in a situation where a user/channel/role name changes 
+# and the notifications still resolve to the old name.
+render_cache_time = 60
+
 # none of these should need changing
 exchange = "revolt.notifications"
 message_queue = "notifications.origin.message"
@@ -220,6 +226,10 @@ new_user_hours = 72
 # (should be greater than any one file upload limit)
 body_limit_size = 20_000_000
 
+# If any userids are entered here, only those users will be able to create servers.
+# Leave empty to allow all users to create servers
+restrict_server_creation = []
+
 [features.limits.new_user]
 # Limits imposed on new users
 

crates/core/config/src/lib.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, path::Path};
 
 use cached::proc_macro::cached;
-use config::{Config, File, FileFormat};
+use config::{Config, Environment, File, FileFormat};
 use futures_locks::RwLock;
 use once_cell::sync::Lazy;
 use serde::Deserialize;
@@ -109,6 +109,8 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
             cwd = path.parent();
         }
 
+        builder = builder.add_source(Environment::with_prefix("REVOLT").separator("__"));
+
         builder.build().unwrap()
     })
 });
@@ -246,6 +248,7 @@ pub struct Pushd {
     pub production: bool,
     pub exchange: String,
     pub mass_mention_chunk_size: usize,
+    pub render_cache_time: usize,
 
     // Queues
     pub message_queue: String,
@@ -342,6 +345,8 @@ pub struct GlobalLimits {
     pub new_user_hours: usize,
 
     pub body_limit_size: usize,
+
+    pub restrict_server_creation: Vec<String>,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -419,6 +424,7 @@ pub struct Settings {
     pub features: Features,
     pub sentry: Sentry,
     pub production: bool,
+    pub disable_events_dont_use: bool,
 }
 
 impl Settings {
@@ -449,12 +455,14 @@ pub async fn config() -> Settings {
     let mut config = read().await.try_deserialize::<Settings>().unwrap();
 
     // inject REDIS_URI for redis-kiss library
-    if std::env::var("REDIS_URL").is_err() {
+    if std::env::var("REDIS_URI").is_err() {
         std::env::set_var("REDIS_URI", config.database.redis.clone());
     }
 
     // auto-detect production nodes
-    if config.hosts.api.contains("https") && config.hosts.api.contains("revolt.chat") {
+    if config.hosts.api.contains("https")
+        && (config.hosts.api.contains("revolt.chat") || config.hosts.api.contains("stoat.chat"))
+    {
         config.production = true;
     }
 

crates/core/database/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-database"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -32,19 +32,19 @@ default = ["mongodb", "async-std-runtime", "tasks"]
 
 [dependencies]
 # Core
-revolt-config = { version = "0.11.5", path = "../config", features = [
+revolt-config = { version = "0.12.0", path = "../config", features = [
     "report-macros",
 ] }
-revolt-result = { version = "0.11.5", path = "../result" }
-revolt-models = { version = "0.11.5", path = "../models", features = [
+revolt-result = { version = "0.12.0", path = "../result" }
+revolt-models = { version = "0.12.0", path = "../models", features = [
     "validator",
 ] }
-revolt-presence = { version = "0.11.5", path = "../presence" }
-revolt-permissions = { version = "0.11.5", path = "../permissions", features = [
+revolt-presence = { version = "0.12.0", path = "../presence" }
+revolt-permissions = { version = "0.12.0", path = "../permissions", features = [
     "serde",
     "bson",
 ] }
-revolt-parser = { version = "0.11.5", path = "../parser" }
+revolt-parser = { version = "0.12.0", path = "../parser" }
 
 # Utility
 log = "0.4"

crates/core/database/src/models/channels/model.rs

@@ -110,6 +110,10 @@ auto_derived!(
             /// Voice Information for when this channel is also a voice channel
             #[serde(skip_serializing_if = "Option::is_none")]
             voice: Option<VoiceInformation>,
+
+            /// The channel's slowmode delay in seconds
+            #[serde(skip_serializing_if = "Option::is_none")]
+            slowmode: Option<u64>,
         },
     }
 
@@ -146,6 +150,8 @@ auto_derived!(
         pub last_message_id: Option<String>,
         #[serde(skip_serializing_if = "Option::is_none")]
         pub voice: Option<VoiceInformation>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub slowmode: Option<u64>,
     }
 
     /// Optional fields on channel object
@@ -206,6 +212,7 @@ impl Channel {
                 role_permissions: HashMap::new(),
                 nsfw: data.nsfw.unwrap_or(false),
                 voice: data.voice.map(|voice| voice.into()),
+                slowmode: None
             },
             v0::LegacyServerChannelType::Voice => Channel::TextChannel {
                 id: id.clone(),
@@ -218,6 +225,7 @@ impl Channel {
                 role_permissions: HashMap::new(),
                 nsfw: data.nsfw.unwrap_or(false),
                 voice: Some(data.voice.unwrap_or_default().into()),
+                slowmode: None
             },
         };
 

crates/core/database/src/models/file_hashes/model.rs

@@ -45,7 +45,9 @@ auto_derived!(
         Image {
             width: isize,
             height: isize,
-            // animated: bool // TODO: https://docs.rs/image/latest/image/trait.AnimationDecoder.html for APNG support
+            thumbhash: Option<Vec<u8>>,
+            #[serde(default)]
+            animated: bool,
         },
         /// File is a video with specific dimensions
         Video { width: isize, height: isize },

crates/core/database/src/models/messages/model.rs

@@ -1,5 +1,3 @@
-use std::{collections::HashSet, hash::RandomState};
-
 use indexmap::{IndexMap, IndexSet};
 use iso8601_timestamp::Timestamp;
 use revolt_config::{config, FeaturesLimits};
@@ -9,6 +7,8 @@ use revolt_models::v0::{
 };
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission, PermissionValue};
 use revolt_result::{ErrorType, Result};
+use std::time::SystemTime;
+use std::{collections::HashSet, hash::RandomState};
 use ulid::Ulid;
 use validator::Validate;
 
@@ -388,6 +388,7 @@ impl Message {
             mut role_mentions,
             mut mentions_everyone,
             mut mentions_online,
+            ..
         } = message_mentions;
 
         if allow_mass_mentions && server_id.is_some() && !role_mentions.is_empty() {
@@ -497,7 +498,7 @@ impl Message {
                     user_mentions.retain(|m| recipients_hash.contains(m));
                     role_mentions.clear();
                 }
-                Channel::TextChannel { ref server, .. }=> {
+                Channel::TextChannel { ref server, .. } => {
                     let mentions_vec = Vec::from_iter(user_mentions.iter().cloned());
 
                     let valid_members = db.fetch_members(server.as_str(), &mentions_vec[..]).await;
@@ -687,8 +688,13 @@ impl Message {
         )
         .await?;
 
+        let is_dm_or_group = matches!(
+            channel,
+            Channel::DirectMessage { .. } | Channel::Group { .. }
+        );
+
         if !self.has_suppressed_notifications()
-            && (self.mentions.is_some() || self.contains_mass_push_mention())
+            && (is_dm_or_group || self.mentions.is_some() || self.contains_mass_push_mention())
         {
             // send Push notifications
             #[cfg(feature = "tasks")]
@@ -1029,6 +1035,31 @@ impl Message {
         Ok(())
     }
 
+    /// Bulk delete messages by an author since a given time
+    pub async fn bulk_delete_by_author_since(
+        db: &Database,
+        channels: &[String],
+        author: &str,
+        since: SystemTime,
+    ) -> Result<()> {
+        let deleted_groups = db
+            .delete_messages_by_author_since(channels, author, since)
+            .await?;
+
+        for (channel_id, message_ids) in deleted_groups {
+            if !message_ids.is_empty() {
+                EventV1::BulkMessageDelete {
+                    channel: channel_id.clone(),
+                    ids: message_ids,
+                }
+                .p(channel_id)
+                .await;
+            }
+        }
+
+        Ok(())
+    }
+
     /// Remove a reaction from a message
     pub async fn remove_reaction(&self, db: &Database, user: &str, emoji: &str) -> Result<()> {
         // Check if it actually exists

crates/core/database/src/models/messages/ops.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+use std::time::SystemTime;
 use revolt_result::Result;
 
 use crate::{AppendMessage, FieldsMessage, Message, MessageQuery, PartialMessage};
@@ -40,4 +42,12 @@ pub trait AbstractMessages: Sync + Send {
 
     /// Delete messages from a channel by their ids and corresponding channel id
     async fn delete_messages(&self, channel: &str, ids: &[String]) -> Result<()>;
+
+    /// Delete all messages from a specific author in a server from a certain ULID onwards
+    async fn delete_messages_by_author_since(
+        &self,
+        channels: &[String],
+        author: &str,
+        since: SystemTime
+    ) -> Result<HashMap<String, Vec<String>>>;
 }

crates/core/database/src/models/messages/ops/mongodb.rs

@@ -1,8 +1,12 @@
 use bson::{to_bson, Document};
 use futures::try_join;
+use futures::StreamExt;
 use mongodb::options::FindOptions;
 use revolt_models::v0::MessageSort;
 use revolt_result::Result;
+use std::collections::{HashMap, HashSet};
+use std::time::SystemTime;
+use ulid::Ulid;
 
 use crate::{
     AppendMessage, DocumentId, FieldsMessage, IntoDocumentPath, Message, MessageQuery,
@@ -306,6 +310,112 @@ impl AbstractMessages for MongoDb {
             .map(|_| ())
             .map_err(|_| create_database_error!("delete_many", COL))
     }
+
+    /// Delete all messages from a specific author in a server from a certain ULID onwards
+    async fn delete_messages_by_author_since(
+        &self,
+        channels: &[String],
+        author: &str,
+        since: SystemTime,
+    ) -> Result<HashMap<String, Vec<String>>> {
+        let threshold_ulid = Ulid::from_datetime(since).to_string();
+
+        let filter = doc! {
+            "author": author,
+            "channel": { "$in": channels },
+            "_id": { "$gte": &threshold_ulid }
+        };
+
+        let pipeline = vec![
+            doc! { "$match": filter.clone() },
+            doc! {
+                "$project": {
+                    "channel": 1_i32,
+                    "message_id": "$_id",
+                    "attachment_ids": {
+                        "$map": {
+                            "input": { "$ifNull": ["$attachments", Vec::<bson::Bson>::new()] },
+                            "as": "a",
+                            "in": "$$a._id"
+                        }
+                    }
+                }
+            },
+            doc! {
+                "$group": {
+                    "_id": "$channel",
+                    "message_ids": { "$push": "$message_id" },
+                    "attachment_ids_nested": { "$push": "$attachment_ids" }
+                }
+            },
+            doc! {
+                "$project": {
+                    "message_ids": 1_i32,
+                    "attachment_ids": {
+                        "$reduce": {
+                            "input": "$attachment_ids_nested",
+                            "initialValue": Vec::<bson::Bson>::new(),
+                            "in": { "$setUnion": ["$$value", "$$this"] }
+                        }
+                    }
+                }
+            },
+        ];
+
+        #[derive(serde::Deserialize)]
+        struct AggregatedChannel {
+            #[serde(rename = "_id")]
+            channel: String,
+            message_ids: Vec<String>,
+            #[serde(default)]
+            attachment_ids: Vec<String>,
+        }
+
+        let mut cursor = self
+            .col::<Document>(COL)
+            .aggregate(pipeline)
+            .await
+            .map_err(|_| create_database_error!("aggregate", COL))?
+            .with_type::<AggregatedChannel>();
+
+        let mut deleted_messages: HashMap<String, Vec<String>> = HashMap::new();
+        let mut attachment_ids: HashSet<String> = HashSet::new();
+
+        while let Some(result) = cursor.next().await {
+            if let Ok(item) = result {
+                for id in item.attachment_ids {
+                    attachment_ids.insert(id);
+                }
+                deleted_messages.insert(item.channel, item.message_ids);
+            }
+        }
+
+        // Mark attachments as deleted before deleting messages
+        if !attachment_ids.is_empty() {
+            self.col::<Document>("attachments")
+                .update_many(
+                    doc! {
+                        "_id": {
+                            "$in": attachment_ids.into_iter().collect::<Vec<String>>()
+                        }
+                    },
+                    doc! {
+                        "$set": {
+                            "deleted": true
+                        }
+                    },
+                )
+                .await
+                .map_err(|_| create_database_error!("update_many", "attachments"))?;
+        }
+
+        self.col::<Document>(COL)
+            .delete_many(filter)
+            .await
+            .map_err(|_| create_database_error!("delete_many", COL))?;
+
+        Ok(deleted_messages)
+    }
 }
 
 impl IntoDocumentPath for FieldsMessage {

crates/core/database/src/models/messages/ops/reference.rs

@@ -1,7 +1,9 @@
+use std::collections::HashMap;
 use futures::future::try_join_all;
 use indexmap::IndexSet;
 use revolt_result::Result;
-
+use std::time::SystemTime;
+use ulid::Ulid;
 use crate::{AppendMessage, FieldsMessage, Message, MessageQuery, PartialMessage, ReferenceDb};
 
 use super::AbstractMessages;
@@ -286,4 +288,63 @@ impl AbstractMessages for ReferenceDb {
 
         Ok(())
     }
+
+    /// Delete all messages from a specific author in a list of channels from a certain ULID onwards
+    async fn delete_messages_by_author_since(
+        &self,
+        channels: &[String],
+        author: &str,
+        since: SystemTime
+    ) -> Result<HashMap<String, Vec<String>>> {
+        let threshold_ulid = Ulid::from_datetime(since).to_string();
+        let mut deleted_messages: HashMap<String, Vec<String>> = HashMap::new();
+        let mut attachment_ids: Vec<String> = Vec::new();
+
+        let messages = self.messages.lock().await;
+
+        // First pass: collect attachment IDs and message IDs to delete
+        for (id, message) in messages.iter() {
+            let should_delete = message.author == author
+                && channels.contains(&message.channel)
+                && id.as_str() >= threshold_ulid.as_str();
+
+            if should_delete {
+                // Collect attachment IDs
+                if let Some(attachments) = &message.attachments {
+                    for attachment in attachments {
+                        attachment_ids.push(attachment.id.clone());
+                    }
+                }
+
+                deleted_messages
+                    .entry(message.channel.clone())
+                    .or_default()
+                    .push(id.clone());
+            }
+        }
+        drop(messages);
+
+        // Mark attachments as deleted
+        if !attachment_ids.is_empty() {
+            let mut files = self.files.lock().await;
+            for attachment_id in attachment_ids {
+                if let Some(file) = files.get_mut(&attachment_id) {
+                    file.deleted = Some(true);
+                }
+            }
+        }
+
+        // Delete the messages
+        self.messages
+            .lock()
+            .await
+            .retain(|id, message| {
+                let should_keep = !(message.author == author
+                    && channels.contains(&message.channel)
+                    && id.as_str() >= threshold_ulid.as_str());
+                should_keep
+            });
+
+        Ok(deleted_messages)
+    }
 }

crates/core/database/src/models/server_members/model.rs

@@ -3,8 +3,8 @@ use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
 use revolt_result::{create_error, Result};
 
 use crate::{
-    events::client::EventV1, util::permissions::DatabasePermissionQuery, Channel,
-    Database, File, Server, SystemMessage, User,
+    events::client::EventV1, util::permissions::DatabasePermissionQuery, Channel, Database, File,
+    Server, SystemMessage, User,
 };
 
 fn default_true() -> bool {
@@ -45,7 +45,6 @@ auto_derived_partial!(
         /// Whether the member is server-wide voice deafened
         #[serde(skip_serializing_if = "is_true", default = "default_true")]
         pub can_receive: bool,
-        
         // This value only exists in the database, not the models.
         // If it is not-None, the database layer should return None to member fetching queries.
         // pub pending_deletion_at: Option<Timestamp>
@@ -153,7 +152,11 @@ impl Member {
 
         #[cfg(feature = "voice")]
         for channel in &channels {
-            if let Ok(Some(voice_state)) = crate::voice::get_channel_voice_state(channel).await {
+            if let Ok(Some(voice_state)) = crate::voice::get_channel_voice_state(
+                &crate::voice::UserVoiceChannel::from_channel(channel),
+            )
+            .await
+            {
                 voice_states.push(voice_state)
             }
         }
@@ -175,7 +178,7 @@ impl Member {
                 .map(|channel| channel.into())
                 .collect(),
             emojis: emojis.into_iter().map(|emoji| emoji.into()).collect(),
-            voice_states
+            voice_states,
         }
         .private(user.id.clone())
         .await;
@@ -225,14 +228,14 @@ impl Member {
 
     pub fn remove_field(&mut self, field: &FieldsMember) {
         match field {
-            FieldsMember::JoinedAt => {},
+            FieldsMember::JoinedAt => {}
             FieldsMember::Avatar => self.avatar = None,
             FieldsMember::Nickname => self.nickname = None,
             FieldsMember::Roles => self.roles.clear(),
             FieldsMember::Timeout => self.timeout = None,
             FieldsMember::CanReceive => self.can_receive = true,
             FieldsMember::CanPublish => self.can_publish = true,
-            FieldsMember::VoiceChannel => {},
+            FieldsMember::VoiceChannel => {}
         }
     }
 

crates/core/database/src/util/bridge/v0.rs

@@ -190,6 +190,7 @@ impl From<crate::Channel> for Channel {
                 role_permissions,
                 nsfw,
                 voice,
+                slowmode
             } => Channel::TextChannel {
                 id,
                 server,
@@ -201,6 +202,7 @@ impl From<crate::Channel> for Channel {
                 role_permissions,
                 nsfw,
                 voice: voice.map(|voice| voice.into()),
+                slowmode
             },
         }
     }
@@ -254,6 +256,7 @@ impl From<Channel> for crate::Channel {
                 role_permissions,
                 nsfw,
                 voice,
+                slowmode
             } => crate::Channel::TextChannel {
                 id,
                 server,
@@ -265,6 +268,7 @@ impl From<Channel> for crate::Channel {
                 role_permissions,
                 nsfw,
                 voice: voice.map(|voice| voice.into()),
+                slowmode
             },
         }
     }
@@ -283,7 +287,8 @@ impl From<crate::PartialChannel> for PartialChannel {
             role_permissions: value.role_permissions,
             default_permissions: value.default_permissions,
             last_message_id: value.last_message_id,
-            voice: value.voice.map(|voice| voice.into())
+            voice: value.voice.map(|voice| voice.into()),
+            slowmode: value.slowmode,
         }
     }
 }
@@ -301,7 +306,8 @@ impl From<PartialChannel> for crate::PartialChannel {
             role_permissions: value.role_permissions,
             default_permissions: value.default_permissions,
             last_message_id: value.last_message_id,
-            voice: value.voice.map(|voice| voice.into())
+            voice: value.voice.map(|voice| voice.into()),
+            slowmode: value.slowmode
         }
     }
 }
@@ -406,9 +412,16 @@ impl From<crate::Metadata> for Metadata {
         match value {
             crate::Metadata::File => Metadata::File,
             crate::Metadata::Text => Metadata::Text,
-            crate::Metadata::Image { width, height } => Metadata::Image {
+            crate::Metadata::Image {
+                width,
+                height,
+                thumbhash,
+                animated,
+            } => Metadata::Image {
                 width: width as usize,
                 height: height as usize,
+                thumbhash,
+                animated,
             },
             crate::Metadata::Video { width, height } => Metadata::Video {
                 width: width as usize,
@@ -424,9 +437,16 @@ impl From<Metadata> for crate::Metadata {
         match value {
             Metadata::File => crate::Metadata::File,
             Metadata::Text => crate::Metadata::Text,
-            Metadata::Image { width, height } => crate::Metadata::Image {
+            Metadata::Image {
+                width,
+                height,
+                thumbhash,
+                animated,
+            } => crate::Metadata::Image {
                 width: width as isize,
                 height: height as isize,
+                thumbhash,
+                animated,
             },
             Metadata::Video { width, height } => crate::Metadata::Video {
                 width: width as isize,
@@ -515,7 +535,9 @@ impl From<crate::SystemMessage> for SystemMessage {
             crate::SystemMessage::UserRemove { id, by } => Self::UserRemove { id, by },
             crate::SystemMessage::MessagePinned { id, by } => Self::MessagePinned { id, by },
             crate::SystemMessage::MessageUnpinned { id, by } => Self::MessageUnpinned { id, by },
-            crate::SystemMessage::CallStarted { by, finished_at } => Self::CallStarted { by, finished_at }
+            crate::SystemMessage::CallStarted { by, finished_at } => {
+                Self::CallStarted { by, finished_at }
+            }
         }
     }
 }
@@ -1382,7 +1404,7 @@ impl From<FieldsMessage> for crate::FieldsMessage {
 impl From<VoiceInformation> for crate::VoiceInformation {
     fn from(value: VoiceInformation) -> Self {
         crate::VoiceInformation {
-            max_users: value.max_users
+            max_users: value.max_users,
         }
     }
 }
@@ -1390,7 +1412,7 @@ impl From<VoiceInformation> for crate::VoiceInformation {
 impl From<crate::VoiceInformation> for VoiceInformation {
     fn from(value: crate::VoiceInformation) -> Self {
         VoiceInformation {
-            max_users: value.max_users
+            max_users: value.max_users,
         }
     }
-}
+}

crates/core/database/src/voice/mod.rs

@@ -1,3 +1,5 @@
+use std::fmt::{Display, Write};
+
 use crate::{
     events::client::EventV1,
     models::{Channel, User},
@@ -6,7 +8,11 @@ use crate::{
 };
 use iso8601_timestamp::{Duration, Timestamp};
 use livekit_protocol::ParticipantPermission;
-use redis_kiss::{get_connection as _get_connection, redis::Pipeline, AsyncCommands, Conn};
+use redis_kiss::{
+    get_connection as _get_connection,
+    redis::{FromRedisValue, Pipeline, RedisError, RedisWrite, ToRedisArgs, Value},
+    AsyncCommands, Conn,
+};
 use revolt_config::FeaturesLimits;
 use revolt_models::v0::{self, PartialUserVoiceState, UserVoiceState};
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission, PermissionValue};
@@ -21,13 +27,13 @@ async fn get_connection() -> Result<Conn> {
         .map_err(|_| create_error!(InternalError))
 }
 
-pub async fn raise_if_in_voice(user: &User, channel_id: &str) -> Result<()> {
+pub async fn raise_if_in_voice(user: &User, channel: &UserVoiceChannel) -> Result<()> {
     let mut conn = get_connection().await?;
 
     if user.bot.is_some() {
         // bots can be in as many voice channels as it wants so we just check if its already connected to the one its trying to connect to
         if conn
-            .sismember(format!("vc:{}", &user.id), channel_id)
+            .sismember(format!("vc:{}", &user.id), channel)
             .await
             .to_internal_error()?
         {
@@ -45,31 +51,31 @@ pub async fn raise_if_in_voice(user: &User, channel_id: &str) -> Result<()> {
     Ok(())
 }
 
-pub async fn set_channel_node(channel: &str, node: &str) -> Result<()> {
+pub async fn set_channel_node(channel_id: &str, node: &str) -> Result<()> {
     get_connection()
         .await?
-        .set(format!("node:{channel}"), node)
+        .set(format!("node:{channel_id}"), node)
         .await
         .to_internal_error()
 }
 
-pub async fn get_channel_node(channel: &str) -> Result<Option<String>> {
+pub async fn get_channel_node(channel_id: &str) -> Result<Option<String>> {
     get_connection()
         .await?
-        .get(format!("node:{channel}"))
+        .get(format!("node:{channel_id}"))
         .await
         .to_internal_error()
 }
 
-pub async fn delete_channel_node(channel: &str) -> Result<()> {
+pub async fn delete_channel_node(channel_id: &str) -> Result<()> {
     get_connection()
         .await?
-        .del(format!("node:{channel}"))
+        .del(format!("node:{channel_id}"))
         .await
         .to_internal_error()
 }
 
-pub async fn get_user_voice_channels(user_id: &str) -> Result<Vec<String>> {
+pub async fn get_user_voice_channels(user_id: &str) -> Result<Vec<UserVoiceChannel>> {
     get_connection()
         .await?
         .smembers(format!("vc:{user_id}"))
@@ -78,14 +84,14 @@ pub async fn get_user_voice_channels(user_id: &str) -> Result<Vec<String>> {
 }
 
 pub async fn set_user_moved_from_voice(
-    old_channel: &str,
-    new_channel: &str,
+    old_channel_id: &str,
+    new_channel: &UserVoiceChannel,
     user_id: &str,
 ) -> Result<()> {
     get_connection()
         .await?
         .set_ex(
-            format!("moved_from:{user_id}:{old_channel}"),
+            format!("moved_from:{user_id}:{old_channel_id}"),
             new_channel,
             10,
         )
@@ -102,18 +108,25 @@ pub async fn get_user_moved_from_voice(channel_id: &str, user_id: &str) -> Resul
 }
 
 pub async fn set_user_moved_to_voice(
-    new_channel: &str,
-    old_channel: &str,
+    new_channel_id: &str,
+    old_channel: &UserVoiceChannel,
     user_id: &str,
 ) -> Result<()> {
     get_connection()
         .await?
-        .set_ex(format!("moved_to:{user_id}:{new_channel}"), old_channel, 10)
+        .set_ex(
+            format!("moved_to:{user_id}:{new_channel_id}"),
+            old_channel,
+            10,
+        )
         .await
         .to_internal_error()
 }
 
-pub async fn get_user_moved_to_voice(channel_id: &str, user_id: &str) -> Result<Option<String>> {
+pub async fn get_user_moved_to_voice(
+    channel_id: &str,
+    user_id: &str,
+) -> Result<Option<UserVoiceChannel>> {
     get_connection()
         .await?
         .get_del(format!("moved_to:{user_id}:{channel_id}"))
@@ -121,10 +134,10 @@ pub async fn get_user_moved_to_voice(channel_id: &str, user_id: &str) -> Result<
         .to_internal_error()
 }
 
-pub async fn is_in_voice_channel(user_id: &str, channel_id: &str) -> Result<bool> {
+pub async fn is_in_voice_channel(user_id: &str, channel: &UserVoiceChannel) -> Result<bool> {
     get_connection()
         .await?
-        .sismember(format!("vc:{user_id}"), channel_id)
+        .sismember(format!("vc:{user_id}"), channel)
         .await
         .to_internal_error()
 }
@@ -158,12 +171,15 @@ pub fn get_allowed_sources(
 }
 
 pub async fn create_voice_state(
-    channel_id: &str,
-    server_id: Option<&str>,
+    channel: &UserVoiceChannel,
     user_id: &str,
     joined_at: Timestamp,
 ) -> Result<UserVoiceState> {
-    let unique_key = format!("{}:{}", &user_id, server_id.unwrap_or(channel_id));
+    let unique_key = format!(
+        "{}:{}",
+        &user_id,
+        channel.server_id.as_ref().unwrap_or(&channel.id)
+    );
 
     let voice_state = UserVoiceState {
         joined_at,
@@ -175,9 +191,9 @@ pub async fn create_voice_state(
     };
 
     Pipeline::new()
-        .sadd(format!("vc_members:{channel_id}"), user_id)
-        .sadd(format!("vc:{user_id}"), channel_id)
-        .set(&unique_key, channel_id)
+        .sadd(format!("vc_members:{}", &channel.id), user_id)
+        .sadd(format!("vc:{user_id}"), channel)
+        .set(&unique_key, &channel.id)
         .set(
             format!("joined_at:{unique_key}"),
             joined_at
@@ -204,16 +220,16 @@ pub async fn create_voice_state(
     Ok(voice_state)
 }
 
-pub async fn delete_voice_state(
-    channel_id: &str,
-    server_id: Option<&str>,
-    user_id: &str,
-) -> Result<()> {
-    let unique_key = format!("{}:{}", &user_id, server_id.unwrap_or(channel_id));
+pub async fn delete_voice_state(channel: &UserVoiceChannel, user_id: &str) -> Result<()> {
+    let unique_key = format!(
+        "{}:{}",
+        &user_id,
+        channel.server_id.as_ref().unwrap_or(&channel.id)
+    );
 
     Pipeline::new()
-        .srem(format!("vc_members:{channel_id}"), user_id)
-        .srem(format!("vc:{user_id}"), channel_id)
+        .srem(format!("vc_members:{}", &channel.id), user_id)
+        .srem(format!("vc:{user_id}"), channel)
         .del(&[
             format!("joined_at:{unique_key}"),
             format!("is_publishing:{unique_key}"),
@@ -228,20 +244,19 @@ pub async fn delete_voice_state(
 }
 
 pub async fn delete_channel_voice_state(
-    channel_id: &str,
-    server_id: Option<&str>,
+    channel: &UserVoiceChannel,
     user_ids: &[String],
 ) -> Result<()> {
-    let parent_id = server_id.unwrap_or(channel_id);
+    let parent_id = channel.server_id.as_ref().unwrap_or(&channel.id);
 
     let mut pipeline = Pipeline::new();
-    pipeline.del(format!("vc_members:{channel_id}"));
-    pipeline.del(format!("node:{channel_id}"));
+    pipeline.del(format!("vc_members:{}", &channel.id));
+    pipeline.del(format!("node:{}", &channel.id));
 
     for user_id in user_ids {
         let unique_key = format!("{user_id}:{parent_id}");
 
-        pipeline.srem(format!("vc:{user_id}"), channel_id).del(&[
+        pipeline.srem(format!("vc:{user_id}"), channel).del(&[
             format!("joined_at:{unique_key}"),
             format!("is_publishing:{unique_key}"),
             format!("is_receiving:{unique_key}"),
@@ -258,8 +273,7 @@ pub async fn delete_channel_voice_state(
 }
 
 pub async fn update_voice_state_tracks(
-    channel_id: &str,
-    server_id: Option<&str>,
+    channel: &UserVoiceChannel,
     user_id: &str,
     added: bool,
     track: i32,
@@ -284,18 +298,21 @@ pub async fn update_voice_state_tracks(
         _ => unreachable!(),
     };
 
-    update_voice_state(channel_id, server_id, user_id, &partial).await?;
+    update_voice_state(channel, user_id, &partial).await?;
 
     Ok(partial)
 }
 
 pub async fn update_voice_state(
-    channel_id: &str,
-    server_id: Option<&str>,
+    channel: &UserVoiceChannel,
     user_id: &str,
     partial: &PartialUserVoiceState,
 ) -> Result<()> {
-    let unique_key = format!("{}:{}", &user_id, server_id.unwrap_or(channel_id));
+    let unique_key = format!(
+        "{}:{}",
+        &user_id,
+        channel.server_id.as_ref().unwrap_or(&channel.id)
+    );
 
     let mut pipeline = Pipeline::new();
 
@@ -321,21 +338,24 @@ pub async fn update_voice_state(
         .to_internal_error()
 }
 
-pub async fn get_voice_channel_members(channel_id: &str) -> Result<Option<Vec<String>>> {
+pub async fn get_voice_channel_members(channel: &UserVoiceChannel) -> Result<Option<Vec<String>>> {
     get_connection()
         .await?
-        .smembers::<_, Option<Vec<String>>>(format!("vc_members:{channel_id}"))
+        .smembers::<_, Option<Vec<String>>>(format!("vc_members:{}", &channel.id))
         .await
         .to_internal_error()
         .map(|opt| opt.and_then(|v| if v.is_empty() { None } else { Some(v) }))
 }
 
 pub async fn get_voice_state(
-    channel_id: &str,
-    server_id: Option<&str>,
+    channel: &UserVoiceChannel,
     user_id: &str,
 ) -> Result<Option<UserVoiceState>> {
-    let unique_key = format!("{}:{}", user_id, server_id.unwrap_or(channel_id));
+    let unique_key = format!(
+        "{}:{}",
+        &user_id,
+        channel.server_id.as_ref().unwrap_or(&channel.id)
+    );
 
     let (joined_at, is_publishing, is_receiving, screensharing, camera) = get_connection()
         .await?
@@ -376,21 +396,21 @@ pub async fn get_voice_state(
     }
 }
 
-pub async fn get_channel_voice_state(channel: &Channel) -> Result<Option<v0::ChannelVoiceState>> {
-    let members = get_voice_channel_members(channel.id()).await?;
-
-    let server = channel.server();
+pub async fn get_channel_voice_state(
+    channel: &UserVoiceChannel,
+) -> Result<Option<v0::ChannelVoiceState>> {
+    let members = get_voice_channel_members(channel).await?;
 
     if let Some(members) = members {
         let mut participants = Vec::with_capacity(members.len());
 
         for user_id in members {
-            if let Some(voice_state) = get_voice_state(channel.id(), server, &user_id).await? {
+            if let Some(voice_state) = get_voice_state(channel, &user_id).await? {
                 participants.push(voice_state);
             } else {
                 log::info!("Voice state not found but member in voice channel members, removing.");
 
-                delete_voice_state(channel.id(), server, &user_id).await?;
+                delete_voice_state(channel, &user_id).await?;
             }
         }
 
@@ -398,7 +418,7 @@ pub async fn get_channel_voice_state(channel: &Channel) -> Result<Option<v0::Cha
         participants.shrink_to_fit();
 
         Ok(Some(v0::ChannelVoiceState {
-            id: channel.id().to_string(),
+            id: channel.id.clone(),
             participants,
         }))
     } else {
@@ -406,12 +426,12 @@ pub async fn get_channel_voice_state(channel: &Channel) -> Result<Option<v0::Cha
     }
 }
 
-pub async fn move_user(user: &str, from: &str, to: &str) -> Result<()> {
+pub async fn move_user(user: &str, from_channel_id: &str, to_channel_id: &str) -> Result<()> {
     get_connection()
         .await?
         .smove(
-            format!("vc-members-{from}"),
-            format!("vc-members-{to}"),
+            format!("vc_members:{from_channel_id}"),
+            format!("vc_members:{to_channel_id}"),
             user,
         )
         .await
@@ -425,11 +445,13 @@ pub async fn sync_voice_permissions(
     server: Option<&Server>,
     role_id: Option<&str>,
 ) -> Result<()> {
+    let user_voice_channel = UserVoiceChannel::from_channel(channel);
+
     let Some(node) = get_channel_node(channel.id()).await? else {
         return Ok(());
     };
 
-    for user_id in get_voice_channel_members(channel.id())
+    for user_id in get_voice_channel_members(&user_voice_channel)
         .await?
         .iter()
         .flatten()
@@ -469,7 +491,9 @@ pub async fn sync_user_voice_permissions(
             .as_ref()
             .is_none_or(|member| member.roles.iter().any(|r| r == role_id))
     }) {
-        let Some(voice_state) = get_voice_state(channel_id, server_id, &user.id).await? else {
+        let user_voice_channel = UserVoiceChannel::from_channel(channel);
+
+        let Some(voice_state) = get_voice_state(&user_voice_channel, &user.id).await? else {
             return Ok(());
         };
 
@@ -500,7 +524,7 @@ pub async fn sync_user_voice_permissions(
         update_event.screensharing = voice_state.screensharing.then_some(can_video);
         update_event.is_publishing = voice_state.is_publishing.then_some(can_speak);
 
-        update_voice_state(channel_id, server_id, &user.id, &update_event).await?;
+        update_voice_state(&user_voice_channel, &user.id, &update_event).await?;
 
         voice_client
             .update_permissions(
@@ -579,46 +603,94 @@ pub async fn get_call_notification_recipients(
 }
 
 pub async fn remove_user_from_voice_channels(
-    db: &Database,
     voice_client: &VoiceClient,
     user_id: &str,
 ) -> Result<()> {
-    for channel_id in get_user_voice_channels(user_id).await? {
-        remove_user_from_voice_channel(db, voice_client, &channel_id, user_id).await?;
+    for channel in get_user_voice_channels(user_id).await? {
+        remove_user_from_voice_channel(voice_client, &channel, user_id).await?;
     }
 
     Ok(())
 }
 
 pub async fn remove_user_from_voice_channel(
-    db: &Database,
     voice_client: &VoiceClient,
-    channel_id: &str,
+    channel: &UserVoiceChannel,
     user_id: &str,
 ) -> Result<()> {
-    if let Some(node) = get_channel_node(channel_id).await? {
-        let _ = voice_client.remove_user(&node, user_id, channel_id).await;
+    if let Some(node) = get_channel_node(&channel.id).await? {
+        let _ = voice_client.remove_user(&node, user_id, &channel.id).await;
     }
 
-    let channel = Reference::from_unchecked(channel_id).as_channel(db).await?;
-
-    delete_voice_state(channel_id, channel.server(), user_id).await?;
+    delete_voice_state(channel, user_id).await?;
 
     Ok(())
 }
 
 pub async fn delete_voice_channel(
     voice_client: &VoiceClient,
-    channel_id: &str,
-    server_id: Option<&str>,
+    channel: &UserVoiceChannel,
 ) -> Result<()> {
-    if let Some(users) = get_voice_channel_members(channel_id).await? {
-        let node = get_channel_node(channel_id).await?.unwrap();
+    if let Some(users) = get_voice_channel_members(channel).await? {
+        let node = get_channel_node(&channel.id).await?.unwrap();
+        voice_client.delete_room(&node, &channel.id).await?;
 
-        voice_client.delete_room(&node, channel_id).await?;
-
-        delete_channel_voice_state(channel_id, server_id, &users).await?;
+        delete_channel_voice_state(channel, &users).await?;
     };
 
     Ok(())
 }
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RoomMetadata {
+    pub server: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UserVoiceChannel {
+    pub id: String,
+    pub server_id: Option<String>,
+}
+
+impl UserVoiceChannel {
+    pub fn from_string(input: String) -> Self {
+        let mut parts = input.splitn(2, '-');
+
+        Self {
+            id: parts.next().unwrap().to_string(),
+            server_id: parts.next().map(ToString::to_string),
+        }
+    }
+
+    pub fn from_channel(channel: &Channel) -> Self {
+        Self {
+            id: channel.id().to_string(),
+            server_id: channel.server().map(ToString::to_string),
+        }
+    }
+}
+
+impl Display for UserVoiceChannel {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.id)?;
+
+        if let Some(server_id) = &self.server_id {
+            f.write_char('-')?;
+            f.write_str(server_id)?
+        };
+
+        Ok(())
+    }
+}
+
+impl ToRedisArgs for UserVoiceChannel {
+    fn write_redis_args<W: ?Sized + RedisWrite>(&self, out: &mut W) {
+        out.write_arg_fmt(self);
+    }
+}
+
+impl FromRedisValue for UserVoiceChannel {
+    fn from_redis_value(v: &Value) -> Result<Self, RedisError> {
+        String::from_redis_value(v).map(UserVoiceChannel::from_string)
+    }
+}

crates/core/database/src/voice/voice_client.rs

@@ -1,5 +1,6 @@
 use crate::{
     models::{Channel, User},
+    voice::RoomMetadata,
     Database,
 };
 use livekit_api::{
@@ -102,11 +103,16 @@ impl VoiceClient {
     pub async fn create_room(&self, node: &str, channel: &Channel) -> Result<Room> {
         let room = self.get_node(node)?;
 
+        let metadata = RoomMetadata {
+            server: channel.server().map(|id| id.to_string()),
+        };
+
         room.client
             .create_room(
                 channel.id(),
                 CreateRoomOptions {
                     empty_timeout: 5 * 60, // 5 minutes,
+                    metadata: serde_json::to_string(&metadata).to_internal_error()?,
                     ..Default::default()
                 },
             )

crates/core/database/templates/deletion.whitelabel.txt

@@ -6,4 +6,4 @@ This email is intended for {{email}}
 
 This email has no association with Stoat or Revolt Platforms Ltd.
 Learn more about third party instances here:
-https://developers.stoat.chat/faq.html
+https://developers.stoat.chat/faq/

crates/core/database/templates/reset.whitelabel.txt

@@ -6,4 +6,4 @@ This email is intended for {{email}}
 
 This email has no association with Stoat or Revolt Platforms Ltd.
 Learn more about third party instances here:
-https://developers.revolt.chat/faq.html
+https://developers.stoat.chat/faq/

crates/core/database/templates/suspension.html

@@ -107,7 +107,7 @@
                                     <p class="" style="line-height: 24px; font-size: 16px; width: 100%; margin: 0;" align="left">
                                       Further violations may result in a permanent ban depending on
                                       severity, please abide by the
-                                      <a href="https://revolt.chat/aup" style="color: #0d6efd;">Acceptable Usage Policy</a>.
+                                      <a href="https://stoat.chat/legal/community-guidelines" style="color: #0d6efd;">Community Guidelines</a>.
                                     </p>
                                     <table class="s-4 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">
                                       <tbody>

crates/core/database/templates/suspension.txt

@@ -3,7 +3,7 @@ Your account has been suspended, for one or more reasons:
 
 You will be able to use your account again in {{duration}} days.
 
-Further violations may result in a permanent ban depending on severity, please abide by the Acceptable Usage Policy (https://revolt.chat/aup).
+Further violations may result in a permanent ban depending on severity, please abide by the Community Guidelines (https://stoat.chat/legal/community-guidelines).
 
 Ban evasion is prohibited and will be dealt with accordingly.
 

crates/core/database/templates/suspension.whitelabel.txt

@@ -3,6 +3,6 @@ Your account has been suspended, for one or more reasons:
 
 This email is intended for {{email}}
 
-This email has no association with Revolt or Revolt Platforms Ltd.
+This email has no association with Stoat or Revolt Platforms Ltd.
 Learn more about third party instances here:
-https://developers.revolt.chat/faq.html
+https://developers.stoat.chat/faq/

crates/core/database/templates/verify.whitelabel.txt

@@ -7,4 +7,4 @@ This email is intended for {{email}}
 
 This email has no association with Stoat or Revolt Platforms Ltd.
 Learn more about third party instances here:
-https://developers.revolt.chat/faq.html
+https://developers.stoat.chat/faq/

crates/core/files/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-files"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -27,10 +27,10 @@ typenum = "1.17.0"
 aws-config = "1.5.5"
 aws-sdk-s3 = { version = "1.46.0", features = ["behavior-version-latest"] }
 
-revolt-config = { version = "0.11.5", path = "../config", features = [
+revolt-config = { version = "0.12.0", path = "../config", features = [
     "report-macros",
 ] }
-revolt-result = { version = "0.11.5", path = "../result" }
+revolt-result = { version = "0.12.0", path = "../result" }
 
 # image processing
 jxl-oxide = { workspace = true }

crates/core/files/src/implementation/media_impl.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use image::{DynamicImage, ImageBuffer, ImageReader};
+use image::{AnimationDecoder, DynamicImage, ImageBuffer, ImageReader};
 use jxl_oxide::integration::JxlDecoder;
 use revolt_config::report_internal_error;
 use std::io::{BufRead, Read, Seek};
@@ -35,6 +35,31 @@ impl MediaRepository for MediaImpl {
         }
     }
 
+    fn is_animated(&self, f: &NamedTempFile, mime: &str) -> Option<bool> {
+        match mime {
+            // Current behaviour is to assume GIFs are animated, this checks for at least 2 frames
+            "image/gif" => {
+                let file = std::fs::File::open(f.path()).ok()?;
+                let reader = std::io::BufReader::new(file);
+                let decoder = image::codecs::gif::GifDecoder::new(reader).ok()?;
+                Some(decoder.into_frames().take(2).count() > 1)
+            }
+            "image/png" => {
+                let file = std::fs::File::open(f.path()).ok()?;
+                let reader = std::io::BufReader::new(file);
+                let decoder = image::codecs::png::PngDecoder::new(reader).ok()?;
+                decoder.is_apng().ok()
+            }
+            "image/webp" => {
+                let file = std::fs::File::open(f.path()).ok()?;
+                let reader = std::io::BufReader::new(file);
+                let decoder = image::codecs::webp::WebPDecoder::new(reader).ok()?;
+                Some(decoder.has_animation())
+            }
+            _ => Some(false),
+        }
+    }
+
     fn image_size_vec(&self, v: &[u8], mime: &str) -> Option<(usize, usize)> {
         match mime {
             "image/svg+xml" => {
@@ -171,9 +196,9 @@ impl MediaRepository for MediaImpl {
 
 #[cfg(test)]
 mod tests {
-    use std::io::Cursor;
-
     use crate::{MediaImpl, MediaRepository};
+    use std::io::{Cursor, Write};
+    use tempfile::NamedTempFile;
 
     #[tokio::test]
     async fn asset_test_jpeg() {
@@ -186,6 +211,15 @@ mod tests {
         media.create_thumbnail(image, "attachments");
     }
 
+    #[tokio::test]
+    async fn asset_test_jpeg_is_not_animated() {
+        let media = MediaImpl::from_config().await;
+        let mut f = NamedTempFile::new().unwrap();
+        f.write_all(include_bytes!("../../tests/assets/test.jpeg"))
+            .unwrap();
+        assert_eq!(media.is_animated(&f, "image/jpeg"), Some(false));
+    }
+
     #[tokio::test]
     async fn asset_test_jpeg_extra_bytes() {
         let media = MediaImpl::from_config().await;
@@ -212,6 +246,15 @@ mod tests {
         media.create_thumbnail(image, "emojis");
     }
 
+    #[tokio::test]
+    async fn asset_test_png_is_not_animated() {
+        let media = MediaImpl::from_config().await;
+        let mut f = NamedTempFile::new().unwrap();
+        f.write_all(include_bytes!("../../tests/assets/test.png"))
+            .unwrap();
+        assert_eq!(media.is_animated(&f, "image/png"), Some(false));
+    }
+
     #[tokio::test]
     async fn asset_test_png_extra_bytes() {
         let media = MediaImpl::from_config().await;
@@ -259,6 +302,15 @@ mod tests {
         media.create_thumbnail(image, "attachments");
     }
 
+    #[tokio::test]
+    async fn asset_test_animated_png_is_animated() {
+        let media = MediaImpl::from_config().await;
+        let mut f = NamedTempFile::new().unwrap();
+        f.write_all(include_bytes!("../../tests/assets/anim-icos.apng"))
+            .unwrap();
+        assert_eq!(media.is_animated(&f, "image/png"), Some(true));
+    }
+
     #[tokio::test]
     async fn asset_test_jxl() {
         let media = MediaImpl::from_config().await;
@@ -292,6 +344,15 @@ mod tests {
         media.create_thumbnail(image, "attachments");
     }
 
+    #[tokio::test]
+    async fn asset_test_webp_is_not_animated() {
+        let media = MediaImpl::from_config().await;
+        let mut f = NamedTempFile::new().unwrap();
+        f.write_all(include_bytes!("../../tests/assets/dice.webp"))
+            .unwrap();
+        assert_eq!(media.is_animated(&f, "image/webp"), Some(false));
+    }
+
     #[tokio::test]
     async fn asset_test_animated_webp() {
         let media = MediaImpl::from_config().await;
@@ -303,6 +364,15 @@ mod tests {
         media.create_thumbnail(image, "attachments");
     }
 
+    #[tokio::test]
+    async fn asset_test_animated_webp_is_animated() {
+        let media = MediaImpl::from_config().await;
+        let mut f = NamedTempFile::new().unwrap();
+        f.write_all(include_bytes!("../../tests/assets/anim-icos.webp"))
+            .unwrap();
+        assert_eq!(media.is_animated(&f, "image/webp"), Some(true));
+    }
+
     #[tokio::test]
     async fn asset_test_animated_gif() {
         let media = MediaImpl::from_config().await;
@@ -313,4 +383,13 @@ mod tests {
         let image = media.decode_image(&mut reader, "image/gif").unwrap();
         media.create_thumbnail(image, "attachments");
     }
+
+    #[tokio::test]
+    async fn asset_test_animated_gif_is_animated() {
+        let media = MediaImpl::from_config().await;
+        let mut f = NamedTempFile::new().unwrap();
+        f.write_all(include_bytes!("../../tests/assets/anim-icos.gif"))
+            .unwrap();
+        assert_eq!(media.is_animated(&f, "image/gif"), Some(true));
+    }
 }

crates/core/files/src/lib.rs

@@ -91,6 +91,34 @@ pub fn image_size_vec(v: &[u8], mime: &str) -> Option<(usize, usize)> {
     media.image_size_vec(v, mime)
 }
 
+/// Check whether an image file contains animation data
+pub fn is_animated(f: &NamedTempFile, mime: &str) -> Option<bool> {
+    let media = MediaImpl::new(Files {
+        blocked_mime_types: Default::default(),
+        clamd_host: Default::default(),
+        encryption_key: Default::default(),
+        limit: FilesLimit {
+            max_mega_pixels: 0,
+            max_pixel_side: 0,
+            min_file_size: 0,
+            min_resolution: [0, 0],
+        },
+        preview: Default::default(),
+        s3: FilesS3 {
+            access_key_id: Default::default(),
+            default_bucket: Default::default(),
+            endpoint: Default::default(),
+            path_style_buckets: Default::default(),
+            region: Default::default(),
+            secret_access_key: Default::default(),
+        },
+        scan_mime_types: Default::default(),
+        webp_quality: Default::default(),
+    });
+
+    media.is_animated(f, mime)
+}
+
 /// Determine size of video at temp file
 pub fn video_size(f: &NamedTempFile) -> Option<(i64, i64)> {
     let media = MediaImpl::new(Files {

crates/core/files/src/repositories/media_repository.rs

@@ -6,6 +6,9 @@ use thiserror::Error;
 
 pub trait MediaRepository: Send + Sync + 'static {
     fn image_size(&self, f: &NamedTempFile) -> Option<(usize, usize)>;
+
+    fn is_animated(&self, f: &NamedTempFile, mime: &str) -> Option<bool>;
+
     fn image_size_vec(&self, v: &[u8], mime: &str) -> Option<(usize, usize)>;
 
     fn decode_image<R: Read + BufRead + Seek>(

crates/core/models/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-models"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -21,8 +21,8 @@ default = ["serde", "partials", "rocket"]
 
 [dependencies]
 # Core
-revolt-config = { version = "0.11.5", path = "../config" }
-revolt-permissions = { version = "0.11.5", path = "../permissions" }
+revolt-config = { version = "0.12.0", path = "../config" }
+revolt-permissions = { version = "0.12.0", path = "../permissions" }
 
 # Utility
 regex = "1.11"

crates/core/models/src/v0/channels.rs

@@ -112,6 +112,10 @@ auto_derived!(
             /// Voice Information for when this channel is also a voice channel
             #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
             voice: Option<VoiceInformation>,
+
+            /// The channel's slowmode delay in seconds
+            #[serde(skip_serializing_if = "Option::is_none")]
+            slowmode: Option<u64>,
         },
     }
 
@@ -150,6 +154,8 @@ auto_derived!(
         pub last_message_id: Option<String>,
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub voice: Option<VoiceInformation>,
+        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+        pub slowmode: Option<u64>,
     }
 
     /// Optional fields on channel object
@@ -189,6 +195,10 @@ auto_derived!(
         /// Voice Information for voice channels
         pub voice: Option<VoiceInformation>,
 
+        /// The channel's slow mode delay in seconds, up to 6 hours
+        #[cfg_attr(feature = "validator", validate(range(min = 0, max = 21600)))]
+        pub slowmode: Option<u64>,
+
         /// Fields to remove from channel
         #[cfg_attr(feature = "serde", serde(default))]
         pub remove: Vec<FieldsChannel>,

crates/core/models/src/v0/files.rs

@@ -46,8 +46,13 @@ auto_derived!(
         File,
         /// File contains textual data and should be displayed as such
         Text,
-        /// File is an image with specific dimensions
-        Image { width: usize, height: usize },
+        /// File is an image with specific dimensions, and may be animated
+        Image {
+            width: usize,
+            height: usize,
+            thumbhash: Option<Vec<u8>>,
+            animated: bool,
+        },
         /// File is a video with specific dimensions
         Video { width: usize, height: usize },
         /// File is audio

crates/core/models/src/v0/messages.rs

@@ -133,7 +133,10 @@ auto_derived!(
         #[serde(rename = "message_unpinned")]
         MessageUnpinned { id: String, by: String },
         #[serde(rename = "call_started")]
-        CallStarted { by: String, finished_at: Option<Timestamp> },
+        CallStarted {
+            by: String,
+            finished_at: Option<Timestamp>,
+        },
     }
 
     /// Name and / or avatar override information
@@ -201,6 +204,9 @@ auto_derived!(
         pub image: Option<String>,
         /// Message content or system message information
         pub body: String,
+        /// The raw body, if the body has been rendered
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub raw_body: Option<String>,
         /// Unique tag, usually the channel ID
         pub tag: String,
         /// Timestamp at which this notification was created
@@ -508,6 +514,7 @@ impl PushNotification {
             icon,
             image,
             body,
+            raw_body: None,
             tag: channel.id().to_string(),
             timestamp,
             url: format!("{}/channel/{}/{}", config.hosts.app, channel.id(), msg.id),

crates/core/models/src/v0/server_bans.rs

@@ -19,6 +19,9 @@ auto_derived!(
         /// Ban reason
         #[cfg_attr(feature = "validator", validate(length(min = 0, max = 1024)))]
         pub reason: Option<String>,
+        /// Messages to delete in seconds
+        #[cfg_attr(feature = "validator", validate(range(min = 0, max = 604800)))]
+        pub delete_message_seconds: Option<i64>,
     }
 
     /// Just enough information to list a ban

crates/core/models/src/v0/servers.rs

@@ -252,6 +252,9 @@ auto_derived!(
         /// Must be enabled in order to show up on [Revolt Discover](https://rvlt.gg).
         pub analytics: Option<bool>,
 
+        /// User id of the new owner
+        pub owner: Option<String>,
+
         /// Fields to remove from server object
         #[cfg_attr(feature = "serde", serde(default))]
         pub remove: Vec<FieldsServer>,

crates/core/parser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-parser"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "MIT"
 authors = ["Zomatree <me@zomatree.live>", "Paul Makles <me@insrt.uk>"]

crates/core/parser/src/lib.rs

@@ -16,23 +16,29 @@ pub enum MessageToken<'a> {
     UserMention(&'a str),
     #[regex("<%(?&id)>", |lex| &lex.slice()[2..lex.slice().len() - 1],)]
     RoleMention(&'a str),
+    #[regex("<#(?&id)>", |lex| &lex.slice()[2..lex.slice().len() - 1],)]
+    ChannelMention(&'a str),
+    #[regex(":(?&id):", |lex| &lex.slice()[1..lex.slice().len() - 1],)]
+    Emoji(&'a str),
     #[token("@everyone")]
     MentionEveryone,
     #[token("@online")]
-    MentionOnline
+    MentionOnline,
 }
 
 #[derive(Debug, Clone, PartialEq, Default)]
 pub struct MessageResults {
     pub user_mentions: HashSet<String>,
     pub role_mentions: HashSet<String>,
+    pub channel_mentions: HashSet<String>,
+    pub emojis: HashSet<String>,
     pub mentions_everyone: bool,
-    pub mentions_online: bool
+    pub mentions_online: bool,
 }
 
 struct MessageParserIterator<'a, I> {
     inner: I,
-    temp: VecDeque<MessageToken<'a>>
+    temp: VecDeque<MessageToken<'a>>,
 }
 
 impl<'a, I: Iterator<Item = MessageToken<'a>>> Iterator for MessageParserIterator<'a, I> {
@@ -55,11 +61,11 @@ impl<'a, I: Iterator<Item = MessageToken<'a>>> Iterator for MessageParserIterato
                     if next_token == Some(MessageToken::CodeblockMarker(ty)) {
                         self.temp.clear();
                         self.temp.push_back(MessageToken::CodeblockMarker(ty));
-                        break next_token
+                        break next_token;
                     } else if let Some(token) = next_token {
                         self.temp.push_back(token);
                     } else {
-                        break Some(MessageToken::CodeblockMarker(ty))
+                        break Some(MessageToken::CodeblockMarker(ty));
                     }
                 }
             } else {
@@ -69,10 +75,10 @@ impl<'a, I: Iterator<Item = MessageToken<'a>>> Iterator for MessageParserIterato
     }
 }
 
-pub fn parse_message_iter(text: &str) -> impl Iterator<Item = MessageToken> + '_ {
+pub fn parse_message_iter(text: &str) -> impl Iterator<Item = MessageToken<'_>> + '_ {
     MessageParserIterator {
         inner: MessageToken::lexer(text).flatten(),
-        temp: VecDeque::new()
+        temp: VecDeque::new(),
     }
 }
 
@@ -82,13 +88,23 @@ pub fn parse_message(text: &str) -> MessageResults {
     for token in parse_message_iter(text) {
         match token {
             MessageToken::Escape => {}
-            MessageToken::CodeblockMarker(_) => {},
-            MessageToken::UserMention(id) => { results.user_mentions.insert(id.to_string()); },
-            MessageToken::RoleMention(id) => { results.role_mentions.insert(id.to_string()); },
+            MessageToken::CodeblockMarker(_) => {}
+            MessageToken::UserMention(id) => {
+                results.user_mentions.insert(id.to_string());
+            }
+            MessageToken::RoleMention(id) => {
+                results.role_mentions.insert(id.to_string());
+            }
+            MessageToken::ChannelMention(id) => {
+                results.channel_mentions.insert(id.to_string());
+            }
+            MessageToken::Emoji(id) => {
+                results.emojis.insert(id.to_string());
+            }
             MessageToken::MentionEveryone => results.mentions_everyone = true,
             MessageToken::MentionOnline => results.mentions_online = true,
         };
-    };
+    }
 
     results
 }
@@ -109,7 +125,10 @@ mod tests {
         let output = parse_message_iter("Hello <@01FD58YK5W7QRV5H3D64KTQYX3>.").collect::<Vec<_>>();
 
         assert_eq!(output.len(), 1);
-        assert_eq!(output[0], MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3"));
+        assert_eq!(
+            output[0],
+            MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
     }
 
     #[test]
@@ -117,7 +136,10 @@ mod tests {
         let output = parse_message_iter("Hello <%01FD58YK5W7QRV5H3D64KTQYX3>.").collect::<Vec<_>>();
 
         assert_eq!(output.len(), 1);
-        assert_eq!(output[0], MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3"));
+        assert_eq!(
+            output[0],
+            MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
     }
 
     #[test]
@@ -138,29 +160,57 @@ mod tests {
 
     #[test]
     fn test_everything() {
-        let output = parse_message_iter("Hello <@01FD58YK5W7QRV5H3D64KTQYX3>, <%01FD58YK5W7QRV5H3D64KTQYX3>, @everyone and @online.").collect::<Vec<_>>();
+        let output = parse_message_iter("Hello <@01FD58YK5W7QRV5H3D64KTQYX3>, <%01FD58YK5W7QRV5H3D64KTQYX3>, <#01FD58YK5W7QRV5H3D64KTQYX3> @everyone and @online. :01FD58YK5W7QRV5H3D64KTQYX3:").collect::<Vec<_>>();
 
-        assert_eq!(output.len(), 4);
-        assert_eq!(output[0], MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3"));
-        assert_eq!(output[1], MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3"));
-        assert_eq!(output[2], MessageToken::MentionEveryone);
-        assert_eq!(output[3], MessageToken::MentionOnline);
+        assert_eq!(output.len(), 6);
+        assert_eq!(
+            output[0],
+            MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
+        assert_eq!(
+            output[1],
+            MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
+        assert_eq!(
+            output[2],
+            MessageToken::ChannelMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
+        assert_eq!(output[3], MessageToken::MentionEveryone);
+        assert_eq!(output[4], MessageToken::MentionOnline);
+        assert_eq!(output[5], MessageToken::Emoji("01FD58YK5W7QRV5H3D64KTQYX3"));
     }
 
     #[test]
     fn test_everything_no_spaces() {
-        let output = parse_message_iter("<@01FD58YK5W7QRV5H3D64KTQYX3><%01FD58YK5W7QRV5H3D64KTQYX3>@everyone@online").collect::<Vec<_>>();
+        let output = parse_message_iter(
+            "<@01FD58YK5W7QRV5H3D64KTQYX3><%01FD58YK5W7QRV5H3D64KTQYX3><#01FD58YK5W7QRV5H3D64KTQYX3>@everyone@online:01FD58YK5W7QRV5H3D64KTQYX3:",
+        )
+        .collect::<Vec<_>>();
 
-        assert_eq!(output.len(), 4);
-        assert_eq!(output[0], MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3"));
-        assert_eq!(output[1], MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3"));
-        assert_eq!(output[2], MessageToken::MentionEveryone);
-        assert_eq!(output[3], MessageToken::MentionOnline);
+        assert_eq!(output.len(), 6);
+        assert_eq!(
+            output[0],
+            MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
+        assert_eq!(
+            output[1],
+            MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
+        assert_eq!(
+            output[2],
+            MessageToken::ChannelMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
+        assert_eq!(output[3], MessageToken::MentionEveryone);
+        assert_eq!(output[4], MessageToken::MentionOnline);
+        assert_eq!(output[5], MessageToken::Emoji("01FD58YK5W7QRV5H3D64KTQYX3"));
     }
 
     #[test]
     fn test_codeblock_no_mentions() {
-        let output = parse_message_iter("```\n<@01FD58YK5W7QRV5H3D64KTQYX3><%01FD58YK5W7QRV5H3D64KTQYX3>@everyone@online\n```").collect::<Vec<_>>();
+        let output = parse_message_iter(
+            "```\n<@01FD58YK5W7QRV5H3D64KTQYX3><%01FD58YK5W7QRV5H3D64KTQYX3><#01FD58YK5W7QRV5H3D64KTQYX3>@everyone@online:01FD58YK5W7QRV5H3D64KTQYX3:\n```",
+        )
+        .collect::<Vec<_>>();
 
         assert_eq!(output.len(), 2);
         assert_eq!(output[0], MessageToken::CodeblockMarker(3));
@@ -169,19 +219,36 @@ mod tests {
 
     #[test]
     fn test_uncontained_codeblock_should_mention() {
-        let output = parse_message_iter("```\n<@01FD58YK5W7QRV5H3D64KTQYX3><%01FD58YK5W7QRV5H3D64KTQYX3>@everyone@online").collect::<Vec<_>>();
+        let output = parse_message_iter(
+            "```\n<@01FD58YK5W7QRV5H3D64KTQYX3><%01FD58YK5W7QRV5H3D64KTQYX3><#01FD58YK5W7QRV5H3D64KTQYX3>@everyone@online:01FD58YK5W7QRV5H3D64KTQYX3:",
+        )
+        .collect::<Vec<_>>();
 
-        assert_eq!(output.len(), 5);
+        assert_eq!(output.len(), 7);
         assert_eq!(output[0], MessageToken::CodeblockMarker(3));
-        assert_eq!(output[1], MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3"));
-        assert_eq!(output[2], MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3"));
-        assert_eq!(output[3], MessageToken::MentionEveryone);
-        assert_eq!(output[4], MessageToken::MentionOnline);
+        assert_eq!(
+            output[1],
+            MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
+        assert_eq!(
+            output[2],
+            MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
+        assert_eq!(
+            output[3],
+            MessageToken::ChannelMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
+        assert_eq!(output[4], MessageToken::MentionEveryone);
+        assert_eq!(output[5], MessageToken::MentionOnline);
+        assert_eq!(output[6], MessageToken::Emoji("01FD58YK5W7QRV5H3D64KTQYX3"));
     }
 
     #[test]
     fn test_inline_codeblock_no_mentions() {
-        let output = parse_message_iter("`<@01FD58YK5W7QRV5H3D64KTQYX3><%01FD58YK5W7QRV5H3D64KTQYX3>@everyone@online`").collect::<Vec<_>>();
+        let output = parse_message_iter(
+            "`<@01FD58YK5W7QRV5H3D64KTQYX3><%01FD58YK5W7QRV5H3D64KTQYX3><#01FD58YK5W7QRV5H3D64KTQYX3>@everyone@online:01FD58YK5W7QRV5H3D64KTQYX3:`",
+        )
+        .collect::<Vec<_>>();
 
         assert_eq!(output.len(), 2);
         assert_eq!(output[0], MessageToken::CodeblockMarker(1));
@@ -190,19 +257,33 @@ mod tests {
 
     #[test]
     fn test_uncontained_inline_codeblock_should_mention() {
-        let output = parse_message_iter("`<@01FD58YK5W7QRV5H3D64KTQYX3><%01FD58YK5W7QRV5H3D64KTQYX3>@everyone@online").collect::<Vec<_>>();
+        let output = parse_message_iter(
+            "`<@01FD58YK5W7QRV5H3D64KTQYX3><%01FD58YK5W7QRV5H3D64KTQYX3><#01FD58YK5W7QRV5H3D64KTQYX3>@everyone@online:01FD58YK5W7QRV5H3D64KTQYX3:",
+        )
+        .collect::<Vec<_>>();
 
-        assert_eq!(output.len(), 5);
+        assert_eq!(output.len(), 6);
         assert_eq!(output[0], MessageToken::CodeblockMarker(1));
-        assert_eq!(output[1], MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3"));
-        assert_eq!(output[2], MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3"));
-        assert_eq!(output[3], MessageToken::MentionEveryone);
-        assert_eq!(output[4], MessageToken::MentionOnline);
+        assert_eq!(
+            output[1],
+            MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
+        assert_eq!(
+            output[2],
+            MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
+        assert_eq!(
+            output[3],
+            MessageToken::ChannelMention("01FD58YK5W7QRV5H3D64KTQYX3")
+        );
+        assert_eq!(output[4], MessageToken::MentionEveryone);
+        assert_eq!(output[5], MessageToken::MentionOnline);
+        assert_eq!(output[6], MessageToken::Emoji("01FD58YK5W7QRV5H3D64KTQYX3"));
     }
 
     #[test]
     fn test_codeblock_with_language_no_mentions() {
-        let output = parse_message_iter("```rust\n<@01FD58YK5W7QRV5H3D64KTQYX3><%01FD58YK5W7QRV5H3D64KTQYX3>@everyone@online```").collect::<Vec<_>>();
+        let output = parse_message_iter("```rust\n<@01FD58YK5W7QRV5H3D64KTQYX3><%01FD58YK5W7QRV5H3D64KTQYX3><#01FD58YK5W7QRV5H3D64KTQYX3>@everyone@online:01FD58YK5W7QRV5H3D64KTQYX3:```").collect::<Vec<_>>();
 
         assert_eq!(output.len(), 2);
         assert_eq!(output[0], MessageToken::CodeblockMarker(3));
@@ -220,7 +301,8 @@ mod tests {
 
     #[test]
     fn test_double_inline_codeblock_with_backticks_inside() {
-        let output = parse_message_iter("``this `should` not `ping` @everyone``").collect::<Vec<_>>();
+        let output =
+            parse_message_iter("``this `should` not `ping` @everyone``").collect::<Vec<_>>();
 
         assert_eq!(output.len(), 2);
         assert_eq!(output[0], MessageToken::CodeblockMarker(2));
@@ -238,7 +320,8 @@ mod tests {
 
     #[test]
     fn test_escaped_codeblock() {
-        let output = parse_message_iter("i am ~~not~~ pinging \\`@everyone` ok.").collect::<Vec<_>>();
+        let output =
+            parse_message_iter("i am ~~not~~ pinging \\`@everyone` ok.").collect::<Vec<_>>();
 
         assert_eq!(output.len(), 3);
         assert_eq!(output[0], MessageToken::Escape);
@@ -253,4 +336,4 @@ mod tests {
         assert_eq!(output.len(), 1);
         assert_eq!(output[0], MessageToken::Escape);
     }
-}
+}

crates/core/permissions/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-permissions"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -22,7 +22,7 @@ async-std = { version = "1.8.0", features = ["attributes"] }
 
 [dependencies]
 # Core
-revolt-result = { version = "0.11.5", path = "../result" }
+revolt-result = { version = "0.12.0", path = "../result" }
 
 # Utility
 auto_ops = "0.3.0"

crates/core/permissions/src/models/channel.rs

@@ -75,6 +75,8 @@ pub enum ChannelPermission {
     Masquerade = 1 << 28,
     /// React to messages with emojis
     React = 1 << 29,
+    /// Bypass slowmode
+    BypassSlowmode = 1 << 39,
 
     // * Voice permissions
     /// Connect to a voice channel
@@ -99,7 +101,7 @@ pub enum ChannelPermission {
     MentionRoles = 1 << 38,
 
     // * Misc. permissions
-    // % Bits 38 to 52: free area
+    // % Bits 39 to 52: free area
     // % Bits 53 to 64: do not use
 
     // * Grant all permissions
@@ -141,7 +143,7 @@ pub static DEFAULT_PERMISSION: Lazy<u64> = Lazy::new(|| {
 pub static DEFAULT_PERMISSION_SAVED_MESSAGES: u64 = ChannelPermission::GrantAllSafe as u64;
 
 pub static DEFAULT_PERMISSION_DIRECT_MESSAGE: Lazy<u64> = Lazy::new(|| {
-    DEFAULT_PERMISSION.add(ChannelPermission::ManageChannel + ChannelPermission::React)
+    DEFAULT_PERMISSION.add(ChannelPermission::ManageChannel + ChannelPermission::React + ChannelPermission::Masquerade)
 });
 
 pub static DEFAULT_PERMISSION_SERVER: Lazy<u64> = Lazy::new(|| {

crates/core/presence/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-presence"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
@@ -17,7 +17,7 @@ redis-is-patched = []
 async-std = { version = "1.8.0", features = ["attributes"] }
 
 # Config for loading Redis URI
-revolt-config = { version = "0.11.5", path = "../config" }
+revolt-config = { version = "0.12.0", path = "../config" }
 
 [dependencies]
 # Utility

crates/core/ratelimits/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-ratelimits"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2024"
 license = "MIT"
 authors = ["Zomatree <me@zomatree.live>", "Paul Makles <me@insrt.uk>"]
@@ -18,9 +18,9 @@ axum = ["dep:axum", "revolt-database/axum-impl"]
 default = ["rocket", "axum"]
 
 [dependencies]
-revolt-database = { version = "0.11.5", path = "../database" }
-revolt-result = { version = "0.11.5", path = "../result" }
-revolt-config = { version = "0.11.5", path = "../config" }
+revolt-database = { version = "0.12.0", path = "../database" }
+revolt-result = { version = "0.12.0", path = "../result" }
+revolt-config = { version = "0.12.0", path = "../config" }
 
 rocket = { version = "0.5.1", optional = true }
 revolt_rocket_okapi = { version = "0.10.0", optional = true }

crates/core/result/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-result"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]

crates/core/result/src/axum.rs

@@ -36,7 +36,11 @@ impl IntoResponse for Error {
             ErrorType::NotInGroup => StatusCode::NOT_FOUND,
             ErrorType::AlreadyPinned => StatusCode::BAD_REQUEST,
             ErrorType::NotPinned => StatusCode::BAD_REQUEST,
+            ErrorType::InSlowmode {
+                retry_after: _,
+            } => StatusCode::TOO_MANY_REQUESTS,
 
+            ErrorType::CantCreateServers => StatusCode::FORBIDDEN,
             ErrorType::UnknownServer => StatusCode::NOT_FOUND,
             ErrorType::InvalidRole => StatusCode::NOT_FOUND,
             ErrorType::Banned => StatusCode::FORBIDDEN,

crates/core/result/src/lib.rs

@@ -1,5 +1,5 @@
-use std::panic::Location;
 use std::fmt::Display;
+use std::panic::Location;
 
 #[cfg(feature = "serde")]
 #[macro_use]
@@ -102,8 +102,12 @@ pub enum ErrorType {
     NotInGroup,
     AlreadyPinned,
     NotPinned,
+    InSlowmode {
+        retry_after: u64,
+    },
 
     // ? Server related errors
+    CantCreateServers,
     UnknownServer,
     InvalidRole,
     Banned,
@@ -232,17 +236,16 @@ impl<T, E: std::fmt::Debug + std::error::Error> ToRevoltError<T> for Result<T, E
     fn to_internal_error(self) -> Result<T, Error> {
         let loc = Location::caller();
 
-        self
-            .map_err(|e| {
-                log::error!("{e:?}");
-                #[cfg(feature = "sentry")]
-                sentry::capture_error(&e);
+        self.map_err(|e| {
+            log::error!("{e:?}");
+            #[cfg(feature = "sentry")]
+            sentry::capture_error(&e);
 
-                Error {
-                    error_type: ErrorType::InternalError,
-                    location: format!("{}:{}:{}", loc.file(), loc.line(), loc.column())
-                }
-            })
+            Error {
+                error_type: ErrorType::InternalError,
+                location: format!("{}:{}:{}", loc.file(), loc.line(), loc.column()),
+            }
+        })
     }
 }
 
@@ -251,11 +254,9 @@ impl<T> ToRevoltError<T> for Option<T> {
     fn to_internal_error(self) -> Result<T, Error> {
         let loc = Location::caller();
 
-        self.ok_or_else(|| {
-            Error {
-                error_type: ErrorType::InternalError,
-                location: format!("{}:{}:{}", loc.file(), loc.line(), loc.column())
-            }
+        self.ok_or_else(|| Error {
+            error_type: ErrorType::InternalError,
+            location: format!("{}:{}:{}", loc.file(), loc.line(), loc.column()),
         })
     }
 }

crates/core/result/src/rocket.rs

@@ -42,8 +42,12 @@ impl<'r> Responder<'r, 'static> for Error {
             ErrorType::NotInGroup => Status::NotFound,
             ErrorType::AlreadyPinned => Status::BadRequest,
             ErrorType::NotPinned => Status::BadRequest,
+            ErrorType::InSlowmode {
+                retry_after: _,
+            } => Status::TooManyRequests,
             ErrorType::InvalidFlagValue => Status::BadRequest,
 
+            ErrorType::CantCreateServers => Status::Forbidden,
             ErrorType::UnknownServer => Status::NotFound,
             ErrorType::InvalidRole => Status::NotFound,
             ErrorType::Banned => Status::Forbidden,

crates/daemons/crond/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-crond"
-version = "0.11.5"
+version = "0.12.0"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
 edition = "2021"
@@ -17,7 +17,7 @@ log = "0.4"
 tokio = { version = "1" }
 
 # Core
-revolt-database = { version = "0.11.5", path = "../../core/database" }
-revolt-result = { version = "0.11.5", path = "../../core/result" }
-revolt-config = { version = "0.11.5", path = "../../core/config" }
-revolt-files = { version = "0.11.5", path = "../../core/files" }
+revolt-database = { version = "0.12.0", path = "../../core/database" }
+revolt-result = { version = "0.12.0", path = "../../core/result" }
+revolt-config = { version = "0.12.0", path = "../../core/config" }
+revolt-files = { version = "0.12.0", path = "../../core/files" }

crates/daemons/crond/Dockerfile

@@ -5,6 +5,7 @@ FROM debian:12 AS debian
 # Bundle Stage
 FROM gcr.io/distroless/cc-debian12:nonroot
 COPY --from=builder /home/rust/src/target/release/revolt-crond ./
+COPY --from=debian /usr/bin/uname /usr/bin/uname
 
 USER nonroot
 CMD ["./revolt-crond"]

crates/daemons/pushd/Cargo.toml

@@ -1,23 +1,24 @@
 [package]
 name = "revolt-pushd"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 publish = false
 
 [dependencies]
-revolt-result = { version = "0.11.5", path = "../../core/result" }
-revolt-config = { version = "0.11.5", path = "../../core/config", features = [
+revolt-result = { version = "0.12.0", path = "../../core/result" }
+revolt-config = { version = "0.12.0", path = "../../core/config", features = [
     "report-macros",
     "anyhow",
 ] }
-revolt-database = { version = "0.11.5", path = "../../core/database" }
-revolt-models = { version = "0.11.5", path = "../../core/models", features = [
+revolt-database = { version = "0.12.0", path = "../../core/database" }
+revolt-models = { version = "0.12.0", path = "../../core/models", features = [
     "validator",
 ] }
-revolt-presence = { version = "0.11.5", path = "../../core/presence", features = [
+revolt-presence = { version = "0.12.0", path = "../../core/presence", features = [
     "redis-is-patched",
 ] }
+revolt-parser = { version = "0.11.5", path = "../../core/parser" }
 
 anyhow = { version = "1.0.98" }
 
@@ -26,6 +27,7 @@ fcm_v1 = "0.3.0"
 web-push = "0.10.0"
 isahc = { optional = true, version = "1.7", features = ["json"] }
 revolt_a2 = { version = "0.10", default-features = false, features = ["ring"] }
+redis-kiss = "0.1.4"
 tokio = "1.39.2"
 async-trait = "0.1.81"
 ulid = "1.0.0"
@@ -35,6 +37,8 @@ authifier = "1.0.16"
 log = "0.4.11"
 pretty_env_logger = "0.4.0"
 
+regex = "1.12.3"
+
 #serialization
 serde_json = "1"
 revolt_optional_struct = "0.2.0"

crates/daemons/pushd/src/consumers/inbound/mass_mention.rs

@@ -3,7 +3,7 @@ use std::{
     hash::RandomState,
 };
 
-use crate::consumers::inbound::internal::*;
+use crate::{consumers::inbound::internal::*, utils};
 use amqprs::{
     channel::{BasicPublishArguments, Channel},
     connection::Connection,
@@ -17,6 +17,7 @@ use revolt_database::{
     MessageFlagsValue,
 };
 use revolt_models::v0::{MessageFlags, PushNotification};
+use revolt_result::ToRevoltError;
 
 pub struct MassMessageConsumer {
     #[allow(dead_code)]
@@ -129,7 +130,17 @@ impl MassMessageConsumer {
     ) -> Result<()> {
         let config = revolt_config::config().await;
         let content = String::from_utf8(content)?;
-        let payload: MassMessageSentPayload = serde_json::from_str(content.as_str())?;
+        let mut payload: MassMessageSentPayload = serde_json::from_str(content.as_str())?;
+
+        for push in payload.notifications.iter_mut() {
+            if let Ok(body) = utils::render_notification_content(push, &self.db)
+                .await
+                .to_internal_error()
+            {
+                push.raw_body = Some(push.body.clone());
+                push.body = body;
+            }
+        }
 
         debug!("Received mass message event");
 

crates/daemons/pushd/src/consumers/inbound/message.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::consumers::inbound::internal::*;
+use crate::{consumers::inbound::internal::*, utils};
 use amqprs::{
     channel::{BasicPublishArguments, Channel},
     connection::Connection,
@@ -11,6 +11,7 @@ use anyhow::Result;
 use async_trait::async_trait;
 use log::debug;
 use revolt_database::{events::rabbit::*, Database};
+use revolt_result::ToRevoltError;
 
 pub struct MessageConsumer {
     #[allow(dead_code)]
@@ -64,7 +65,15 @@ impl MessageConsumer {
         content: Vec<u8>,
     ) -> Result<()> {
         let content = String::from_utf8(content)?;
-        let payload: MessageSentPayload = serde_json::from_str(content.as_str())?;
+        let mut payload: MessageSentPayload = serde_json::from_str(content.as_str())?;
+
+        if let Ok(body) = utils::render_notification_content(&payload.notification, &self.db)
+            .await
+            .to_internal_error()
+        {
+            payload.notification.raw_body = Some(payload.notification.body);
+            payload.notification.body = body;
+        }
 
         debug!("Received message event on origin");
 

crates/daemons/pushd/src/main.rs

@@ -14,6 +14,7 @@ use revolt_config::{config, Settings};
 use tokio::sync::Notify;
 
 mod consumers;
+mod utils;
 use consumers::{
     inbound::{
         ack::AckConsumer, dm_call::DmCallConsumer, fr_accepted::FRAcceptedConsumer,

crates/daemons/pushd/src/utils/mod.rs

@@ -0,0 +1,2 @@
+mod renderer;
+pub use renderer::render_notification_content;

crates/daemons/pushd/src/utils/renderer.rs

@@ -0,0 +1,272 @@
+use redis_kiss::{get_connection as _get_conn, AsyncCommands, Conn};
+use regex::Regex;
+use revolt_config::config;
+use revolt_database::{Channel, Database};
+use revolt_models::v0::PushNotification;
+use revolt_parser::parse_message;
+use revolt_result::{create_error, Result, ToRevoltError};
+use std::{
+    borrow::Cow,
+    collections::{HashMap, HashSet},
+};
+use tokio::join;
+
+async fn get_connection() -> Result<Conn> {
+    _get_conn().await.map_err(|_| create_error!(InternalError))
+}
+
+pub async fn render_notification_content(
+    notification: &PushNotification,
+    db: &Database,
+) -> Result<String> {
+    let parsed = parse_message(&notification.body);
+
+    let user_mentions: HashMap<String, String>;
+    let channel_mentions: HashMap<String, String>;
+    let emojis: HashMap<String, String>;
+    let roles: HashMap<String, String>;
+
+    let server_id: Option<String> = get_channel_server_id(notification.channel.id(), db)
+        .await
+        .map(Some)
+        .or(Ok(None))?;
+
+    if server_id.is_some() {
+        (user_mentions, channel_mentions, emojis, roles) = join!(
+            get_items(
+                parsed.user_mentions,
+                server_id.as_deref(),
+                db,
+                get_user_display_name,
+                "Unknown User".to_string()
+            ),
+            get_items(
+                parsed.channel_mentions,
+                server_id.as_deref(),
+                db,
+                get_channel_name,
+                "Unknown Channel".to_string()
+            ),
+            get_items(
+                parsed.emojis,
+                server_id.as_deref(),
+                db,
+                get_emoji_name,
+                "Unknown Emoji".to_string()
+            ),
+            get_items(
+                parsed.role_mentions,
+                server_id.as_deref(),
+                db,
+                get_role_name,
+                "Unknown Role".to_string()
+            ),
+        );
+    } else {
+        roles = HashMap::default();
+
+        (user_mentions, channel_mentions, emojis) = join!(
+            get_items(
+                parsed.user_mentions,
+                server_id.as_deref(),
+                db,
+                get_user_display_name,
+                "Unknown User".to_string()
+            ),
+            get_items(
+                parsed.channel_mentions,
+                server_id.as_deref(),
+                db,
+                get_channel_name,
+                "Unknown Channel".to_string()
+            ),
+            get_items(
+                parsed.emojis,
+                server_id.as_deref(),
+                db,
+                get_emoji_name,
+                "Unknown Emoji".to_string()
+            ),
+        );
+    }
+
+    let mut body = Cow::Borrowed(notification.body.as_str());
+
+    for (uid, name) in user_mentions {
+        replace_all_in_place(
+            Regex::new(format!("<@{uid}>").as_str()).unwrap(),
+            &mut body,
+            format!("@{name}").as_str(),
+        );
+    }
+
+    for (uid, name) in channel_mentions {
+        replace_all_in_place(
+            Regex::new(format!("<#{uid}>").as_str()).unwrap(),
+            &mut body,
+            format!("#{name}").as_str(),
+        );
+    }
+
+    for (uid, name) in roles {
+        replace_all_in_place(
+            Regex::new(format!("<%{uid}>").as_str()).unwrap(),
+            &mut body,
+            format!("%{name}").as_str(),
+        );
+    }
+
+    for (uid, name) in emojis {
+        replace_all_in_place(
+            Regex::new(format!(":{uid}:").as_str()).unwrap(),
+            &mut body,
+            format!(":{name}:").as_str(),
+        );
+    }
+
+    Ok(body.to_string())
+}
+
+async fn get_items<F>(
+    items: HashSet<String>,
+    server_id: Option<&str>,
+    db: &Database,
+    getter: F,
+    invalid_string: String,
+) -> HashMap<String, String>
+where
+    F: AsyncFn(&str, Option<&str>, &Database) -> Result<String>,
+{
+    let mut resp = HashMap::default();
+
+    for obj_id in items {
+        resp.insert(
+            obj_id.clone(),
+            getter(&obj_id, server_id, db)
+                .await
+                .unwrap_or(invalid_string.clone()),
+        );
+    }
+
+    resp
+}
+
+// Getters
+
+async fn get_user_display_name(id: &str, server: Option<&str>, db: &Database) -> Result<String> {
+    let config = config().await;
+
+    let mut conn = get_connection().await?;
+    let key = format!("pushd-user-cache:{}:{id}", server.unwrap_or("GLOBAL"));
+
+    if let Ok(name) = conn.get(key.clone()).await {
+        return Ok(name);
+    }
+
+    if let Some(server) = server {
+        let member = db.fetch_member(server, id).await?;
+        if let Some(nickname) = member.nickname {
+            conn.set_ex::<_, _, ()>(key, nickname.clone(), config.pushd.render_cache_time)
+                .await
+                .to_internal_error()?;
+            return Ok(nickname);
+        }
+    }
+
+    let user = db.fetch_user(id).await?;
+    let name = user.display_name.unwrap_or(user.username);
+
+    conn.set_ex::<_, _, ()>(key, name.clone(), config.pushd.render_cache_time)
+        .await
+        .to_internal_error()?;
+
+    Ok(name)
+}
+
+async fn get_channel_name(id: &str, _server: Option<&str>, db: &Database) -> Result<String> {
+    let config = config().await;
+
+    let mut conn = get_connection().await?;
+    let key = format!("pushd-channel-cache:{id}");
+
+    if let Ok(name) = conn.get(key.clone()).await {
+        return Ok(name);
+    }
+
+    let channel = db.fetch_channel(id).await?;
+    let name = match channel {
+        Channel::DirectMessage { .. } => "DM Channel".to_string(),
+        Channel::Group { name, .. } | Channel::TextChannel { name, .. } => name,
+        Channel::SavedMessages { .. } => "Err".to_string(),
+    };
+
+    conn.set_ex::<_, _, ()>(key, name.clone(), config.pushd.render_cache_time)
+        .await
+        .to_internal_error()?;
+
+    Ok(name)
+}
+
+async fn get_role_name(id: &str, server: Option<&str>, db: &Database) -> Result<String> {
+    let server = server.unwrap(); // Must be passed, but the interface must stay the same as the other getters
+    let config: revolt_config::Settings = config().await;
+
+    let mut conn = get_connection().await?;
+    let key = format!("pushd-role-cache:{server}:{id}");
+
+    if let Ok(name) = conn.get(key.clone()).await {
+        return Ok(name);
+    }
+
+    let server = db.fetch_server(server).await?;
+    let name = server
+        .roles
+        .get(id)
+        .ok_or_else(|| create_error!(NotFound))?
+        .name
+        .clone();
+
+    conn.set_ex::<_, _, ()>(key, name.clone(), config.pushd.render_cache_time)
+        .await
+        .to_internal_error()?;
+
+    Ok(name)
+}
+
+async fn get_emoji_name(id: &str, _server: Option<&str>, db: &Database) -> Result<String> {
+    let config: revolt_config::Settings = config().await;
+
+    let mut conn = get_connection().await?;
+    let key = format!("pushd-emoji-cache:{id}");
+
+    if let Ok(name) = conn.get(key.clone()).await {
+        return Ok(name);
+    }
+
+    let emoji = db.fetch_emoji(id).await?;
+    let name = emoji.name;
+
+    conn.set_ex::<_, _, ()>(key, name.clone(), config.pushd.render_cache_time)
+        .await
+        .to_internal_error()?;
+
+    Ok(name)
+}
+
+// utility
+
+async fn get_channel_server_id(channel_id: &str, db: &Database) -> Result<String> {
+    match db.fetch_channel(channel_id).await? {
+        Channel::DirectMessage { .. } | Channel::Group { .. } | Channel::SavedMessages { .. } => {
+            Err(create_error!(NotFound))
+        }
+        Channel::TextChannel { server, .. } => Ok(server),
+    }
+}
+
+fn replace_all_in_place<R: regex::Replacer>(regex: Regex, s: &mut Cow<'_, str>, replacer: R) {
+    let new = regex.replace_all(s, replacer);
+    if let Cow::Owned(o) = new {
+        *s = Cow::Owned(o);
+    }
+}

crates/daemons/voice-ingress/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-voice-ingress"
-version = "0.11.5"
+version = "0.12.0"
 license = "AGPL-3.0-or-later"
 edition = "2021"
 publish = false

crates/daemons/voice-ingress/src/api.rs

@@ -5,8 +5,9 @@ use revolt_database::{
     iso8601_timestamp::{Duration, Timestamp},
     util::reference::Reference,
     voice::{
-        create_voice_state, delete_channel_node, delete_voice_state, get_user_moved_from_voice,
-        get_user_moved_to_voice, get_voice_channel_members, update_voice_state_tracks, VoiceClient,
+        create_voice_state, delete_channel_voice_state, delete_voice_state,
+        get_user_moved_from_voice, get_user_moved_to_voice, update_voice_state_tracks,
+        RoomMetadata, UserVoiceChannel, VoiceClient,
     },
     Database, AMQP,
 };
@@ -50,27 +51,34 @@ pub async fn ingress(
 
     let channel_id = event.room.as_ref().map(|r| &r.name);
     let user_id = event.participant.as_ref().map(|r| &r.identity);
+    let room_metadata = if let Some(room) = event.room.as_ref() {
+        Some(serde_json::from_str::<RoomMetadata>(&room.metadata).to_internal_error()?)
+    } else {
+        None
+    };
 
     match event.event.as_str() {
         // User joined a channel
         "participant_joined" => {
             let channel_id = channel_id.to_internal_error()?;
             let user_id = user_id.to_internal_error()?;
-
-            let channel = Reference::from_unchecked(channel_id).as_channel(db).await?;
+            let server_id = room_metadata.to_internal_error()?.server;
+            let channel = UserVoiceChannel {
+                id: channel_id.clone(),
+                server_id: server_id.clone(),
+            };
 
             let joined_at = Timestamp::UNIX_EPOCH
                 .checked_add(Duration::seconds(event.created_at))
                 .unwrap();
 
-            let voice_state =
-                create_voice_state(channel_id, channel.server(), user_id, joined_at).await?;
+            let voice_state = create_voice_state(&channel, user_id, joined_at).await?;
 
             // Only publish one event when a user is moved from one channel to another.
             if let Some(moved_from) = get_user_moved_to_voice(channel_id, user_id).await? {
                 EventV1::VoiceChannelMove {
                     user: user_id.to_string(),
-                    from: moved_from,
+                    from: moved_from.id,
                     to: channel_id.to_string(),
                     state: voice_state,
                 }
@@ -135,10 +143,13 @@ pub async fn ingress(
         "participant_left" => {
             let channel_id = channel_id.to_internal_error()?;
             let user_id = user_id.to_internal_error()?;
+            let server_id = room_metadata.to_internal_error()?.server;
+            let channel = UserVoiceChannel {
+                id: channel_id.clone(),
+                server_id: server_id.clone(),
+            };
 
-            let channel = Reference::from_unchecked(channel_id).as_channel(db).await?;
-
-            delete_voice_state(channel_id, channel.server(), user_id).await?;
+            delete_voice_state(&channel, user_id).await?;
 
             // Dont send leave event when a user is moved
             if get_user_moved_from_voice(channel_id, user_id)
@@ -159,8 +170,6 @@ pub async fn ingress(
             // let members = get_voice_channel_members(channel_id).await?;
 
             // if members.is_none_or(|m| m.is_empty()) {
-            //     delete_channel_node(channel_id).await?;
-            //
             //     // The channel is empty so send out an "end" message for ringing
             //     if let Err(e) = amqp
             //         .dm_call_updated(user_id, channel_id, None, true, None)
@@ -204,8 +213,11 @@ pub async fn ingress(
             let channel_id = channel_id.to_internal_error()?;
             let user_id = user_id.to_internal_error()?;
             let track = event.track.as_ref().to_internal_error()?;
-
-            let channel = Reference::from_unchecked(channel_id).as_channel(db).await?;
+            let server_id = room_metadata.to_internal_error()?.server;
+            let channel = UserVoiceChannel {
+                id: channel_id.clone(),
+                server_id: server_id.clone(),
+            };
 
             let user = Reference::from_unchecked(user_id).as_user(db).await?;
 
@@ -245,15 +257,14 @@ pub async fn ingress(
                     log::debug!("Removing user {user_id} from channel {channel_id} {event:?} due to forbidden track.");
 
                     let _ = voice_client.remove_user(node, user_id, channel_id).await;
-                    delete_voice_state(channel_id, channel.server(), user_id).await?;
+                    delete_voice_state(&channel, user_id).await?;
 
                     return Ok(EmptyResponse);
                 };
             };
 
             let partial = update_voice_state_tracks(
-                channel_id,
-                channel.server(),
+                &channel,
                 user_id,
                 event.event == "track_published" || event.event == "track_unmuted", // to avoid duplicating this entire case twice
                 track.source,
@@ -268,6 +279,16 @@ pub async fn ingress(
             .p(channel_id.clone())
             .await;
         }
+        "room_finished" => {
+            let channel_id = channel_id.to_internal_error()?;
+            let server_id = room_metadata.to_internal_error()?.server;
+            let channel = UserVoiceChannel {
+                id: channel_id.clone(),
+                server_id: server_id.clone(),
+            };
+
+            delete_channel_voice_state(&channel, &[]).await?;
+        }
         _ => {}
     };
 

crates/delta/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-delta"
-version = "0.11.5"
+version = "0.12.0"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <paulmakles@gmail.com>"]
 edition = "2018"

crates/delta/src/routes/bots/delete.rs

@@ -1,4 +1,8 @@
-use revolt_database::{Database, User, util::reference::Reference, voice::{VoiceClient, remove_user_from_voice_channels}};
+use revolt_database::{
+    util::reference::Reference,
+    voice::{remove_user_from_voice_channels, VoiceClient},
+    Database, User,
+};
 use revolt_result::{create_error, Result};
 use rocket::State;
 use rocket_empty::EmptyResponse;
@@ -7,21 +11,21 @@ use rocket_empty::EmptyResponse;
 ///
 /// Delete a bot by its id.
 #[openapi(tag = "Bots")]
-#[delete("/<target>")]
+#[delete("/<bot_id>")]
 pub async fn delete_bot(
     db: &State<Database>,
     voice_client: &State<VoiceClient>,
     user: User,
-    target: Reference<'_>,
+    bot_id: Reference<'_>,
 ) -> Result<EmptyResponse> {
-    let bot = target.as_bot(db).await?;
+    let bot = bot_id.as_bot(db).await?;
     if bot.owner != user.id {
         return Err(create_error!(NotFound));
     }
 
     bot.delete(db).await?;
 
-    remove_user_from_voice_channels(db, voice_client, &bot.id).await?;
+    remove_user_from_voice_channels(voice_client, &bot.id).await?;
 
     Ok(EmptyResponse)
 }

crates/delta/src/routes/bots/edit.rs

@@ -10,11 +10,11 @@ use validator::Validate;
 ///
 /// Edit bot details by its id.
 #[openapi(tag = "Bots")]
-#[patch("/<target>", data = "<data>")]
+#[patch("/<bot_id>", data = "<data>")]
 pub async fn edit_bot(
     db: &State<Database>,
     user: User,
-    target: Reference<'_>,
+    bot_id: Reference<'_>,
     data: Json<DataEditBot>,
 ) -> Result<Json<v0::BotWithUserResponse>> {
     let data = data.into_inner();
@@ -24,7 +24,7 @@ pub async fn edit_bot(
         })
     })?;
 
-    let mut bot = target.as_bot(db).await?;
+    let mut bot = bot_id.as_bot(db).await?;
     if bot.owner != user.id {
         return Err(create_error!(NotFound));
     }

crates/delta/src/routes/bots/fetch.rs

@@ -7,17 +7,17 @@ use rocket::{serde::json::Json, State};
 ///
 /// Fetch details of a bot you own by its id.
 #[openapi(tag = "Bots")]
-#[get("/<bot>")]
+#[get("/<bot_id>")]
 pub async fn fetch_bot(
     db: &State<Database>,
     user: User,
-    bot: Reference<'_>,
+    bot_id: Reference<'_>,
 ) -> Result<Json<FetchBotResponse>> {
     if user.bot.is_some() {
         return Err(create_error!(IsBot));
     }
 
-    let bot = bot.as_bot(db).await?;
+    let bot = bot_id.as_bot(db).await?;
     if bot.owner != user.id {
         return Err(create_error!(NotFound));
     }

crates/delta/src/routes/channels/channel_delete.rs

@@ -1,7 +1,10 @@
 use revolt_database::{
-    AMQP, Channel, Database, PartialChannel, User, util::{permissions::DatabasePermissionQuery, reference::Reference}, voice::{
-        VoiceClient, delete_voice_channel, is_in_voice_channel, remove_user_from_voice_channel
-    }
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    voice::{
+        delete_voice_channel, is_in_voice_channel, remove_user_from_voice_channel,
+        UserVoiceChannel, VoiceClient,
+    },
+    Channel, Database, PartialChannel, User, AMQP,
 };
 use revolt_models::v0;
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
@@ -54,15 +57,17 @@ pub async fn delete(
                 )
                 .await?;
 
-            if is_in_voice_channel(&user.id, channel.id()).await? {
-                remove_user_from_voice_channel(db, voice_client, channel.id(), &user.id).await?;
+            let user_voice_channel = UserVoiceChannel::from_channel(&channel);
+
+            if is_in_voice_channel(&user.id, &user_voice_channel).await? {
+                remove_user_from_voice_channel(voice_client, &user_voice_channel, &user.id).await?;
             };
         }
         Channel::TextChannel { .. } => {
             permissions.throw_if_lacking_channel_permission(ChannelPermission::ManageChannel)?;
             channel.delete(db).await?;
 
-            delete_voice_channel(voice_client, channel.id(), channel.server()).await?;
+            delete_voice_channel(voice_client, &UserVoiceChannel::from_channel(&channel)).await?;
         }
     };
 

crates/delta/src/routes/channels/channel_edit.rs

@@ -1,6 +1,6 @@
 use revolt_database::{
     util::{permissions::DatabasePermissionQuery, reference::Reference},
-    voice::{delete_voice_channel, VoiceClient},
+    voice::{delete_voice_channel, UserVoiceChannel, VoiceClient},
     Channel, Database, File, PartialChannel, SystemMessage, User, AMQP,
 };
 use revolt_models::v0;
@@ -41,6 +41,7 @@ pub async fn edit(
         && data.nsfw.is_none()
         && data.owner.is_none()
         && data.voice.is_none()
+        && data.slowmode.is_none()
         && data.remove.is_empty()
     {
         return Ok(Json(channel.into()));
@@ -200,6 +201,7 @@ pub async fn edit(
             icon,
             nsfw,
             voice,
+            slowmode,
             ..
         } => {
             if data.remove.contains(&v0::FieldsChannel::Icon) {
@@ -247,6 +249,11 @@ pub async fn edit(
                 *voice = Some(new_voice.clone().into());
                 partial.voice = Some(new_voice.into());
             }
+
+            if let Some(new_slowmode) = data.slowmode {
+                *slowmode = Some(new_slowmode);
+                partial.slowmode = Some(new_slowmode);
+            }
         }
         _ => return Err(create_error!(InvalidOperation)),
     };
@@ -260,7 +267,7 @@ pub async fn edit(
         .await?;
 
     if channel.voice().is_none() {
-        delete_voice_channel(voice_client, channel.id(), channel.server()).await?;
+        delete_voice_channel(voice_client, &UserVoiceChannel::from_channel(&channel)).await?;
     }
 
     Ok(Json(channel.into()))

crates/delta/src/routes/channels/group_remove_member.rs

@@ -1,7 +1,5 @@
 use revolt_database::{
-    util::reference::Reference,
-    voice::{is_in_voice_channel, remove_user_from_voice_channel, VoiceClient},
-    Channel, Database, User, AMQP,
+    AMQP, Channel, Database, User, util::reference::Reference, voice::{UserVoiceChannel, VoiceClient, is_in_voice_channel, remove_user_from_voice_channel}
 };
 use revolt_permissions::ChannelPermission;
 use revolt_result::{create_error, Result};
@@ -13,20 +11,20 @@ use rocket_empty::EmptyResponse;
 ///
 /// Removes a user from the group.
 #[openapi(tag = "Groups")]
-#[delete("/<target>/recipients/<member>")]
+#[delete("/<group_id>/recipients/<member_id>")]
 pub async fn remove_member(
     db: &State<Database>,
     voice_client: &State<VoiceClient>,
     amqp: &State<AMQP>,
     user: User,
-    target: Reference<'_>,
-    member: Reference<'_>,
+    group_id: Reference<'_>,
+    member_id: Reference<'_>,
 ) -> Result<EmptyResponse> {
     if user.bot.is_some() {
         return Err(create_error!(IsBot));
     }
 
-    let channel = target.as_channel(db).await?;
+    let channel = group_id.as_channel(db).await?;
 
     if let Channel::Group {
         owner, recipients, ..
@@ -38,7 +36,7 @@ pub async fn remove_member(
             }));
         }
 
-        let member = member.as_user(db).await?;
+        let member = member_id.as_user(db).await?;
         if user.id == member.id {
             return Err(create_error!(CannotRemoveYourself));
         }
@@ -54,8 +52,10 @@ pub async fn remove_member(
         return Err(create_error!(InvalidOperation));
     };
 
-    if is_in_voice_channel(&member.id, channel.id()).await? {
-        remove_user_from_voice_channel(db, voice_client, channel.id(), &member.id).await?;
+    let user_voice_channel = UserVoiceChannel::from_channel(&channel);
+
+    if is_in_voice_channel(member_id.id, &user_voice_channel).await? {
+        remove_user_from_voice_channel(voice_client, &user_voice_channel, member_id.id).await?;
     };
 
     Ok(EmptyResponse)

crates/delta/src/routes/channels/message_send.rs

@@ -1,9 +1,10 @@
 use chrono::{Duration, Utc};
+use redis_kiss::{get_connection, redis, AsyncCommands};
 use revolt_database::util::permissions::DatabasePermissionQuery;
 use revolt_database::{
     util::idempotency::IdempotencyKey, util::reference::Reference, Database, User,
 };
-use revolt_database::{Interactions, Message, AMQP};
+use revolt_database::{Channel, Interactions, Message, AMQP};
 use revolt_models::v0;
 use revolt_permissions::PermissionQuery;
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
@@ -57,6 +58,50 @@ pub async fn message_send(
         permissions.throw_if_lacking_channel_permission(ChannelPermission::UploadFiles)?;
     }
 
+    if !permissions.has_channel_permission(ChannelPermission::BypassSlowmode) {
+        if let Channel::TextChannel {
+            slowmode: Some(channel_slowmode),
+            id: channel_id,
+            ..
+        } = &channel
+        {
+            if *channel_slowmode > 0 {
+                if let Ok(conn) = get_connection().await {
+                    let mut conn = conn.into_inner();
+
+                    let slowmode_key = format!("slowmode:{}:{}", user.id, channel_id);
+
+                    // Atomic check-and-set: only set if absent and apply expiry in one command.
+                    let set_result: Option<String> = conn
+                        .set_options(
+                            &slowmode_key,
+                            "1", // The value doesn't matter, only the key's existence
+                            redis::SetOptions::default()
+                                .conditional_set(redis::ExistenceCheck::NX)
+                                .with_expiration(redis::SetExpiry::EX(*channel_slowmode as usize)),
+                        )
+                        .await
+                        .unwrap_or(None);
+
+                    // If `set_result` is None, the `NX` condition failed because the key already exists.
+                    // This means the user is currently in slowmode.
+                    if set_result.is_none() {
+                        // Fetch the remaining TTL to accurately populate the retry_after field
+                        let ttl: i64 = conn.ttl(&slowmode_key).await.unwrap_or(0);
+
+                        // Redis returns positive integers for valid TTLs
+                        if ttl > 0 {
+                            return Err(create_error!(InSlowmode {
+                                retry_after: ttl as u64
+                            }));
+                        }
+                    }
+                }
+                // If Redis connection fails, just skip the slowmode check
+            }
+        }
+    }
+
     // Ensure interactions information is correct
     if let Some(interactions) = &data.interactions {
         let interactions: Interactions = interactions.clone().into();
@@ -186,6 +231,7 @@ mod test {
             }),
             last_message_id: None,
             voice: None,
+            slowmode: None,
         };
         locked_channel
             .update(&harness.db, partial, vec![])

crates/delta/src/routes/channels/voice_join.rs

@@ -3,7 +3,8 @@ use revolt_database::{
     util::{permissions::perms, reference::Reference},
     voice::{
         delete_voice_state, get_channel_node, get_user_voice_channels, get_voice_channel_members,
-        raise_if_in_voice, set_call_notification_recipients, set_channel_node, VoiceClient,
+        raise_if_in_voice, set_call_notification_recipients, set_channel_node, UserVoiceChannel,
+        VoiceClient,
     },
     Database, User,
 };
@@ -50,7 +51,9 @@ pub async fn call(
     let current_permissions = calculate_channel_permissions(&mut permissions).await;
     current_permissions.throw_if_lacking_channel_permission(ChannelPermission::Connect)?;
 
-    if get_voice_channel_members(channel.id())
+    let user_voice_channel = UserVoiceChannel::from_channel(&channel);
+
+    if get_voice_channel_members(&user_voice_channel)
         .await?
         .zip(voice_info.max_users)
         .is_some_and(|(ms, max_users)| ms.len() >= max_users)
@@ -79,22 +82,18 @@ pub async fn call(
         // Finds and disconnects any existing voice connections by the user,
         // should only ever loop once but just to cover our backs.
 
-        for channel_id in get_user_voice_channels(&user.id).await? {
-            if let Some(node) = get_channel_node(&channel_id).await? {
+        for previous_channel in get_user_voice_channels(&user.id).await? {
+            if let Some(node) = get_channel_node(&previous_channel.id).await? {
                 // if this errors its just a mismatching state - ignore and proceed to still delete our state
-                let _ = voice_client.remove_user(&node, &user.id, &channel_id).await;
+                let _ = voice_client
+                    .remove_user(&node, &user.id, &previous_channel.id)
+                    .await;
             };
 
-            let channel = Reference::from_unchecked(&channel_id)
-                .as_channel(db)
-                .await;
-
-            if channel.is_ok() {
-                delete_voice_state(&channel_id, channel.unwrap().server(), &user.id).await?;
-            }
+            delete_voice_state(&previous_channel, &user.id).await?;
         }
     } else {
-        raise_if_in_voice(&user, channel.id()).await?;
+        raise_if_in_voice(&user, &user_voice_channel).await?;
     }
 
     let token = voice_client

crates/delta/src/routes/channels/voice_stop_ring.rs

@@ -1,6 +1,6 @@
 use revolt_database::{
     util::reference::Reference,
-    voice::{get_voice_state, VoiceClient},
+    voice::{get_voice_state, UserVoiceChannel, VoiceClient},
     Channel, Database, User, AMQP,
 };
 use revolt_result::{create_error, Result, ToRevoltError};
@@ -32,9 +32,15 @@ pub async fn stop_ring(
         return Err(create_error!(NoEffect));
     }
 
-    if get_voice_state(channel.id(), None, &user.id)
-        .await?
-        .is_none()
+    if get_voice_state(
+        &UserVoiceChannel {
+            id: channel.id().to_string(),
+            server_id: None,
+        },
+        &user.id,
+    )
+    .await?
+    .is_none()
     {
         return Err(create_error!(NotConnected));
     }
@@ -46,7 +52,7 @@ pub async fn stop_ring(
         _ => return Err(create_error!(NoEffect)),
     };
 
-    if members.iter().any(|m| &target_user.id == m) {
+    if members.iter().any(|m| target_user.id == m) {
         if let Err(e) = amqp
             .dm_call_updated(
                 &user.id,

crates/delta/src/routes/channels/webhook_create.rs

@@ -15,11 +15,11 @@ use validator::Validate;
 ///
 /// Creates a webhook which 3rd party platforms can use to send messages
 #[openapi(tag = "Webhooks")]
-#[post("/<target>/webhooks", data = "<data>")]
+#[post("/<channel_id>/webhooks", data = "<data>")]
 pub async fn create_webhook(
     db: &State<Database>,
     user: User,
-    target: Reference<'_>,
+    channel_id: Reference<'_>,
     data: Json<v0::CreateWebhookBody>,
 ) -> Result<Json<v0::Webhook>> {
     let data = data.into_inner();
@@ -29,7 +29,7 @@ pub async fn create_webhook(
         })
     })?;
 
-    let channel = target.as_channel(db).await?;
+    let channel = channel_id.as_channel(db).await?;
 
     if !matches!(channel, Channel::TextChannel { .. } | Channel::Group { .. }) {
         return Err(create_error!(InvalidOperation));

crates/delta/src/routes/customisation/emoji_create.rs

@@ -11,11 +11,11 @@ use rocket::{serde::json::Json, State};
 ///
 /// Create an emoji by its Autumn upload id.
 #[openapi(tag = "Emojis")]
-#[put("/emoji/<id>", data = "<data>")]
+#[put("/emoji/<emoji_id>", data = "<data>")]
 pub async fn create_emoji(
     db: &State<Database>,
     user: User,
-    id: String,
+    emoji_id: String,
     data: Json<v0::DataCreateEmoji>,
 ) -> Result<Json<v0::Emoji>> {
     let config = config().await;
@@ -50,11 +50,11 @@ pub async fn create_emoji(
     };
 
     // Find the relevant attachment
-    let attachment = File::use_emoji(db, &id, &id, &user.id).await?;
+    let attachment = File::use_emoji(db, &emoji_id, &emoji_id, &user.id).await?;
 
     // Create the emoji object
     let emoji = Emoji {
-        id,
+        id: emoji_id,
         parent: data.parent.into(),
         creator_id: user.id,
         name: data.name,

crates/delta/src/routes/mod.rs

@@ -216,7 +216,7 @@ fn custom_openapi_spec() -> OpenApi {
             }),
             license: Some(License {
                 name: "AGPLv3".to_owned(),
-                url: Some("https://github.com/revoltchat/delta/blob/master/LICENSE".to_owned()),
+                url: Some("https://github.com/stoatchat/stoatchat/blob/main/crates/delta/LICENSE".to_owned()),
                 ..Default::default()
             }),
             version: env!("CARGO_PKG_VERSION").to_string(),

crates/delta/src/routes/root.rs

@@ -1,8 +1,8 @@
-use std::collections::HashMap;
 use revolt_config::config;
 use revolt_result::Result;
 use rocket::serde::json::Json;
 use serde::Serialize;
+use std::collections::HashMap;
 
 /// # hCaptcha Configuration
 #[derive(Serialize, JsonSchema, Debug)]
@@ -88,6 +88,10 @@ pub struct GlobalLimits {
     /// max server channels
     server_channels: i64,
     body_limit_size: i64,
+
+    /// restrict server creation to these users.
+    /// if blank, all users can create servers
+    pub restrict_server_creation: Vec<String>,
 }
 
 /// # User Limits
@@ -125,7 +129,10 @@ impl UserLimits {
             voice_quality: fl.voice_quality as i64,
             video: fl.video,
             video_resolution: [fl.video_resolution[0] as i64, fl.video_resolution[1] as i64],
-            video_aspect_ratio: [fl.video_aspect_ratio[0] as f64, fl.video_aspect_ratio[1] as f64],
+            video_aspect_ratio: [
+                fl.video_aspect_ratio[0] as f64,
+                fl.video_aspect_ratio[1] as f64,
+            ],
             file_upload_size_limits: fl.file_upload_size_limit,
         }
     }
@@ -219,10 +226,15 @@ pub async fn root() -> Result<Json<RevoltConfig>> {
                     server_roles: config.features.limits.global.server_roles as i64,
                     server_channels: config.features.limits.global.server_channels as i64,
                     body_limit_size: config.features.limits.global.body_limit_size as i64,
+                    restrict_server_creation: config
+                        .features
+                        .limits
+                        .global
+                        .restrict_server_creation,
                 },
                 new_user: UserLimits::from_feature_limits(config.features.limits.new_user),
                 default: UserLimits::from_feature_limits(config.features.limits.default),
-            }
+            },
         },
         ws: config.hosts.events,
         app: config.hosts.app,

crates/delta/src/routes/servers/ban_create.rs

@@ -1,13 +1,19 @@
 use revolt_database::{
     util::{permissions::DatabasePermissionQuery, reference::Reference},
-    voice::{get_user_voice_channel_in_server, remove_user_from_voice_channel, VoiceClient},
-    Database, RemovalIntention, ServerBan, User,
+    voice::{
+        get_user_voice_channel_in_server, remove_user_from_voice_channel, UserVoiceChannel,
+        VoiceClient,
+    },
+    Database, Message, RemovalIntention, ServerBan, User,
 };
 use revolt_models::v0;
+use std::time::{Duration, SystemTime};
 
+use revolt_database::events::client::EventV1;
 use revolt_permissions::{calculate_server_permissions, ChannelPermission};
 use revolt_result::{create_error, Result};
 use rocket::{serde::json::Json, State};
+use ulid::Ulid;
 use validator::Validate;
 
 /// # Ban User
@@ -58,11 +64,27 @@ pub async fn ban(
             .await?;
 
         // If the member is in a voice channel while banned kick them from the voice channel
-        if let Some(channel_id) = get_user_voice_channel_in_server(&target.id, &server.id).await? {
-            remove_user_from_voice_channel(db, voice_client, &channel_id, &target.id).await?;
+        if let Some(channel_id) = get_user_voice_channel_in_server(target.id, &server.id).await? {
+            remove_user_from_voice_channel(
+                voice_client,
+                &UserVoiceChannel {
+                    id: channel_id,
+                    server_id: Some(server.id.clone()),
+                },
+                target.id,
+            )
+            .await?;
         }
     }
+    // We do this outside the member check so we can sweep hit-and-run spammers who already left.
+    if let Some(seconds) = data.delete_message_seconds {
+        if seconds > 0 {
+            let threshold_time = SystemTime::now() - Duration::from_secs(seconds as u64);
 
+            Message::bulk_delete_by_author_since(db, &server.channels, target.id, threshold_time)
+                .await?;
+        }
+    }
     ServerBan::create(db, &server, target.id, data.reason)
         .await
         .map(Into::into)

crates/delta/src/routes/servers/member_edit.rs

@@ -9,15 +9,13 @@ use revolt_database::{
     voice::{
         get_channel_node, get_user_voice_channel_in_server, set_channel_node,
         set_user_moved_from_voice, set_user_moved_to_voice, sync_user_voice_permissions,
-        VoiceClient,
+        UserVoiceChannel, VoiceClient,
     },
     Database, File, PartialMember, User,
 };
 use revolt_models::v0::{self, FieldsMember};
 
-use revolt_permissions::{
-    calculate_channel_permissions, calculate_server_permissions, ChannelPermission,
-};
+use revolt_permissions::{calculate_channel_permissions, calculate_server_permissions, ChannelPermission, UserPermission};
 use revolt_result::{create_error, Result};
 use rocket::{form::validate::Contains, serde::json::Json, State};
 use validator::Validate;
@@ -26,13 +24,13 @@ use validator::Validate;
 ///
 /// Edit a member by their id.
 #[openapi(tag = "Server Members")]
-#[patch("/<server>/members/<member>", data = "<data>")]
+#[patch("/<server_id>/members/<member_id>", data = "<data>")]
 pub async fn edit(
     db: &State<Database>,
     voice_client: &State<VoiceClient>,
     user: User,
-    server: Reference<'_>,
-    member: Reference<'_>,
+    server_id: Reference<'_>,
+    member_id: Reference<'_>,
     data: Json<v0::DataMemberEdit>,
 ) -> Result<Json<v0::Member>> {
     let data = data.into_inner();
@@ -43,16 +41,18 @@ pub async fn edit(
     })?;
 
     // Fetch server and member
-    let mut server = server.as_server(db).await?;
-    let target_user = member.as_user(db).await?;
-    let mut member = member.as_member(db, &server.id).await?;
+    let mut server = server_id.as_server(db).await?;
+    let target_user = member_id.as_user(db).await?;
+    let mut member = member_id.as_member(db, &server.id).await?;
 
     // Fetch our currrent permissions
     let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
     let permissions = calculate_server_permissions(&mut query).await;
 
     // Fetch target permissions
-    let mut target_query = DatabasePermissionQuery::new(db, &target_user).server(&server).member(&member);
+    let mut target_query = DatabasePermissionQuery::new(db, &target_user)
+        .server(&server)
+        .member(&member);
     let target_permissions = calculate_server_permissions(&mut target_query).await;
 
     // Check permissions in server
@@ -67,8 +67,10 @@ pub async fn edit(
     if data.avatar.is_some() || data.remove.contains(&v0::FieldsMember::Avatar) {
         if user.id == member.id.user {
             permissions.throw_if_lacking_channel_permission(ChannelPermission::ChangeAvatar)?;
+        } else if data.remove.contains(&v0::FieldsMember::Avatar) {
+            permissions.throw_if_lacking_channel_permission(ChannelPermission::RemoveAvatars)?;
         } else {
-            return Err(create_error!(InvalidOperation));
+            return Err(create_error!(InvalidOperation))
         }
     }
 
@@ -83,7 +85,7 @@ pub async fn edit(
             }
 
             if target_permissions.has_channel_permission(ChannelPermission::TimeoutMembers) {
-                return Err(create_error!(IsElevated))
+                return Err(create_error!(IsElevated));
             }
         }
 
@@ -99,7 +101,7 @@ pub async fn edit(
     }
 
     if data.voice_channel.is_some() && data.remove.contains(&FieldsMember::VoiceChannel) {
-        return Err(create_error!(InvalidOperation))
+        return Err(create_error!(InvalidOperation));
     }
 
     if data.voice_channel.is_some() || data.remove.contains(&FieldsMember::VoiceChannel) {
@@ -217,8 +219,19 @@ pub async fn edit(
                 }
             };
 
-            set_user_moved_from_voice(&channel, new_voice_channel.id(), &target_user.id).await?;
-            set_user_moved_to_voice(new_voice_channel.id(), &channel, &target_user.id).await?;
+            let new_user_voice_channel = UserVoiceChannel::from_channel(&new_voice_channel);
+            let old_user_voice_channel = UserVoiceChannel {
+                id: channel.clone(),
+                server_id: new_user_voice_channel.server_id.clone(),
+            };
+
+            set_user_moved_from_voice(&channel, &new_user_voice_channel, &target_user.id).await?;
+            set_user_moved_to_voice(
+                new_voice_channel.id(),
+                &old_user_voice_channel,
+                &target_user.id,
+            )
+            .await?;
 
             let mut query = perms(db, &target_user).channel(&new_voice_channel);
             let permissions = calculate_channel_permissions(&mut query).await;

crates/delta/src/routes/servers/member_fetch.rs

@@ -11,21 +11,21 @@ use rocket::{serde::json::Json, State};
 ///
 /// Retrieve a member.
 #[openapi(tag = "Server Members")]
-#[get("/<target>/members/<member>?<roles>")]
+#[get("/<server_id>/members/<member_id>?<roles>")]
 pub async fn fetch(
     db: &State<Database>,
     user: User,
-    target: Reference<'_>,
-    member: Reference<'_>,
+    server_id: Reference<'_>,
+    member_id: Reference<'_>,
     roles: Option<bool>,
 ) -> Result<Json<v0::MemberResponse>> {
-    let server = target.as_server(db).await?;
+    let server = server_id.as_server(db).await?;
     let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
     if !query.are_we_a_member().await {
         return Err(create_error!(NotFound));
     }
 
-    let member = member.as_member(db, &server.id).await?;
+    let member = member_id.as_member(db, &server.id).await?;
     if let Some(true) = roles {
         Ok(Json(v0::MemberResponse::MemberWithRoles {
             roles: server

crates/delta/src/routes/servers/member_remove.rs

@@ -1,6 +1,9 @@
 use revolt_database::{
     util::{permissions::DatabasePermissionQuery, reference::Reference},
-    voice::{get_user_voice_channel_in_server, remove_user_from_voice_channel, VoiceClient},
+    voice::{
+        get_user_voice_channel_in_server, remove_user_from_voice_channel, UserVoiceChannel,
+        VoiceClient,
+    },
     Database, RemovalIntention, User,
 };
 use revolt_permissions::{calculate_server_permissions, ChannelPermission};
@@ -12,21 +15,21 @@ use rocket_empty::EmptyResponse;
 ///
 /// Removes a member from the server.
 #[openapi(tag = "Server Members")]
-#[delete("/<target>/members/<member>")]
+#[delete("/<server_id>/members/<member_id>")]
 pub async fn kick(
     db: &State<Database>,
     voice_client: &State<VoiceClient>,
     user: User,
-    target: Reference<'_>,
-    member: Reference<'_>,
+    server_id: Reference<'_>,
+    member_id: Reference<'_>,
 ) -> Result<EmptyResponse> {
-    let server = target.as_server(db).await?;
+    let server = server_id.as_server(db).await?;
 
-    if member.id == user.id {
+    if member_id.id == user.id {
         return Err(create_error!(CannotRemoveYourself));
     }
 
-    if member.id == server.owner {
+    if member_id.id == server.owner {
         return Err(create_error!(InvalidOperation));
     }
 
@@ -35,7 +38,7 @@ pub async fn kick(
         .await
         .throw_if_lacking_channel_permission(ChannelPermission::KickMembers)?;
 
-    let member = member.as_member(db, &server.id).await?;
+    let member = member_id.as_member(db, &server.id).await?;
     if member.get_ranking(query.server_ref().as_ref().unwrap())
         <= query.get_member_rank().unwrap_or(i64::MIN)
     {
@@ -46,8 +49,16 @@ pub async fn kick(
         .remove(db, &server, RemovalIntention::Kick, false)
         .await?;
 
-    if let Some(channel_id) = get_user_voice_channel_in_server(&target.id, &server.id).await? {
-        remove_user_from_voice_channel(db, voice_client, &channel_id, &target.id).await?;
+    if let Some(channel_id) = get_user_voice_channel_in_server(member_id.id, &server.id).await? {
+        remove_user_from_voice_channel(
+            voice_client,
+            &UserVoiceChannel {
+                id: channel_id,
+                server_id: Some(server.id.clone()),
+            },
+            member_id.id,
+        )
+        .await?;
     };
 
     Ok(EmptyResponse)

crates/delta/src/routes/servers/server_create.rs

@@ -1,3 +1,4 @@
+use revolt_config::config;
 use revolt_database::{Database, Member, Server, User};
 use revolt_models::v0;
 use revolt_result::{create_error, Result};
@@ -20,6 +21,24 @@ pub async fn create_server(
         return Err(create_error!(IsBot));
     }
 
+    let config = config().await;
+
+    if !config
+        .features
+        .limits
+        .global
+        .restrict_server_creation
+        .is_empty()
+        && !config
+            .features
+            .limits
+            .global
+            .restrict_server_creation
+            .contains(&user.id)
+    {
+        return Err(create_error!(CantCreateServers));
+    }
+
     let data = data.into_inner();
     data.validate().map_err(|error| {
         create_error!(FailedValidation {

crates/delta/src/routes/servers/server_delete.rs

@@ -2,7 +2,7 @@ use revolt_database::{
     util::reference::Reference,
     voice::{
         delete_voice_channel, get_user_voice_channel_in_server, remove_user_from_voice_channel,
-        VoiceClient,
+        UserVoiceChannel, VoiceClient,
     },
     Database, RemovalIntention, User,
 };
@@ -29,13 +29,28 @@ pub async fn delete(
 
     if server.owner == user.id {
         for channel_id in &server.channels {
-            delete_voice_channel(voice_client, channel_id, Some(&server.id)).await?;
+            delete_voice_channel(
+                voice_client,
+                &UserVoiceChannel {
+                    id: channel_id.clone(),
+                    server_id: Some(server.id.clone()),
+                },
+            )
+            .await?;
         }
 
         server.delete(db).await
     } else {
         if let Some(channel_id) = get_user_voice_channel_in_server(&user.id, &server.id).await? {
-            remove_user_from_voice_channel(db, voice_client, &channel_id, &user.id).await?;
+            remove_user_from_voice_channel(
+                voice_client,
+                &UserVoiceChannel {
+                    id: channel_id,
+                    server_id: Some(server.id.clone()),
+                },
+                &user.id,
+            )
+            .await?;
         };
 
         member

crates/delta/src/routes/servers/server_edit.rs

@@ -1,5 +1,6 @@
 use std::collections::HashSet;
 
+use authifier::models::{totp::Totp, Account, ValidatedTicket};
 use revolt_database::{
     util::{permissions::DatabasePermissionQuery, reference::Reference},
     Database, File, PartialServer, User,
@@ -7,7 +8,7 @@ use revolt_database::{
 use revolt_models::v0;
 use revolt_permissions::{calculate_server_permissions, ChannelPermission};
 use revolt_result::{create_error, Result};
-use rocket::{serde::json::Json, State};
+use rocket::{serde::json::Json, Request, State};
 use validator::Validate;
 
 /// # Edit Server
@@ -17,9 +18,11 @@ use validator::Validate;
 #[patch("/<target>", data = "<data>")]
 pub async fn edit(
     db: &State<Database>,
+    account: Account,
     user: User,
     target: Reference<'_>,
     data: Json<v0::DataEditServer>,
+    validated_ticket: Option<ValidatedTicket>,
 ) -> Result<Json<v0::Server>> {
     let data = data.into_inner();
     data.validate().map_err(|error| {
@@ -43,6 +46,7 @@ pub async fn edit(
         && data.flags.is_none()
         && data.analytics.is_none()
         && data.discoverable.is_none()
+        && data.owner.is_none()
         && data.remove.is_empty()
     {
         return Ok(Json(server.into()));
@@ -57,6 +61,17 @@ pub async fn edit(
         permissions.throw_if_lacking_channel_permission(ChannelPermission::ManageServer)?;
     }
 
+    // Check we are the server owner or privileged if changing sensitive fields
+    if data.owner.is_some() {
+        if user.id != server.owner && !user.privileged {
+            return Err(create_error!(NotOwner));
+        }
+
+        if validated_ticket.is_none() {
+            return Err(create_error!(InvalidCredentials));
+        }
+    }
+
     // Check we are privileged if changing sensitive fields
     if (data.flags.is_some() /*|| data.nsfw.is_some()*/ || data.discoverable.is_some())
         && !user.privileged
@@ -80,6 +95,7 @@ pub async fn edit(
         // nsfw,
         discoverable,
         analytics,
+        owner,
         remove,
     } = data;
 
@@ -92,6 +108,7 @@ pub async fn edit(
         // nsfw,
         discoverable,
         analytics,
+        owner: owner.clone(),
         ..Default::default()
     };
 
@@ -146,6 +163,21 @@ pub async fn edit(
         server.banner = partial.banner.clone();
     }
 
+    // 5. Transfer ownership
+    if let Some(owner) = owner {
+        let owner_reference = Reference::from_unchecked(&owner);
+        // Check if member exists
+        owner_reference.as_member(db, &server.id).await?;
+        let owner_user = owner_reference.as_user(db).await?;
+
+        if owner_user.bot.is_some() {
+            return Err(create_error!(InvalidOperation));
+        }
+
+        server.owner = owner;
+        partial.owner = Some(server.owner.clone());
+    }
+
     server
         .update(db, partial, remove.into_iter().map(Into::into).collect())
         .await?;

crates/delta/src/routes/webhooks/webhook_execute_github.rs

@@ -688,11 +688,23 @@ const LIGHT_ORANGE: &str = "#d9916d";
 // for future use
 // const WHITE: &str = "#c3e1c3";
 
-fn shorten_text(text: &str, length: usize) -> String {
-    if text.len() < length {
-        text.to_string()
+fn shorten_single_line_text(text: &str, length: usize) -> String {
+    if text.contains('\n') {
+        let text = text.split('\n').next().unwrap();
+
+        format!("{}...", &text[..text.len().min(length) - 3])
+    } else if text.len() > length {
+        format!("{}...", &text[..length - 3])
     } else {
-        format!("{}...", &text[0..length])
+        text.to_string()
+    }
+}
+
+fn shorten_text(text: &str, length: usize) -> String {
+    if text.len() >= length {
+        format!("{}...", &text[..length - 3])
+    } else {
+        text.to_string()
     }
 }
 
@@ -823,7 +835,7 @@ pub async fn webhook_execute_github(
                                 "[`{}`]({}) {} - {}",
                                 &commit.id[0..=7],
                                 commit.url,
-                                shorten_text(&commit.message, 50),
+                                shorten_single_line_text(&commit.message, 50),
                                 commit.author.name
                             )
                         })

crates/services/autumn/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-autumn"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 publish = false
@@ -17,6 +17,7 @@ jxl-oxide = "0.8.1"
 kamadak-exif = "0.5.4"
 # revolt_little_exif = "0.5.1"
 image = { version = "0.25.2" } # avif encode requires dav1d system library: features = ["avif-native"]
+thumbhash = "0.1.0"
 
 # File processing
 revolt_clamav-client = { version = "0.1.5" }
@@ -44,16 +45,16 @@ tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
 # Core crates
-revolt-files = { version = "0.11.5", path = "../../core/files" }
-revolt-config = { version = "0.11.5", path = "../../core/config" }
-revolt-database = { version = "0.11.5", path = "../../core/database", features = [
+revolt-files = { version = "0.12.0", path = "../../core/files" }
+revolt-config = { version = "0.12.0", path = "../../core/config" }
+revolt-database = { version = "0.12.0", path = "../../core/database", features = [
     "axum-impl",
 ] }
-revolt-result = { version = "0.11.5", path = "../../core/result", features = [
+revolt-result = { version = "0.12.0", path = "../../core/result", features = [
     "utoipa",
     "axum",
 ] }
-revolt-ratelimits = { version = "0.11.5", path = "../../core/ratelimits", features = ["axum"] }
+revolt-ratelimits = { version = "0.12.0", path = "../../core/ratelimits", features = ["axum"] }
 
 # Axum / web server
 tempfile = "3.12.0"

crates/services/autumn/src/api.rs

@@ -380,7 +380,7 @@ async fn fetch_preview(
 
     let hash = file.as_hash(&db).await?;
 
-    let is_animated = hash.content_type == "image/gif"; // TODO: extract this data from files
+    let is_animated = matches!(hash.metadata, Metadata::Image { animated: true, .. });
 
     // Only process image files and don't process GIFs if not avatar or icon
     if !matches!(hash.metadata, Metadata::Image { .. })

crates/services/autumn/src/exif.rs

@@ -16,7 +16,12 @@ pub async fn strip_metadata(
     mime: &str,
 ) -> Result<(Vec<u8>, Metadata)> {
     match &metadata {
-        Metadata::Image { width, height } => match mime {
+        Metadata::Image {
+            width,
+            height,
+            thumbhash,
+            animated,
+        } => match mime {
             // // little_exif does not appear to parse JPEGs correctly? had 2/2 files fail
             // "image/jpeg" | "image/png" => {
             //     // use little_exif to strip metadata except for orientation and colour profile
@@ -93,7 +98,15 @@ pub async fn strip_metadata(
                     _ => (*width, *height),
                 };
 
-                Ok((bytes, Metadata::Image { width, height }))
+                Ok((
+                    bytes,
+                    Metadata::Image {
+                        width,
+                        height,
+                        thumbhash: thumbhash.clone(),
+                        animated: *animated,
+                    },
+                ))
             }
             // JXLs store EXIF data but we don't have the ability to write them
             "image/jxl" => Ok((buf, metadata)),

crates/services/autumn/src/metadata.rs

@@ -1,7 +1,8 @@
 use std::io::Cursor;
 
+use image::{GenericImageView, ImageError, ImageReader};
 use revolt_database::Metadata;
-use revolt_files::{image_size, video_size};
+use revolt_files::{image_size, is_animated, video_size};
 use tempfile::NamedTempFile;
 
 /// Intersection of what infer can detect and what image-rs supports
@@ -26,6 +27,17 @@ pub fn generate_metadata(f: &NamedTempFile, mime_type: &str) -> Metadata {
             .map(|(width, height)| Metadata::Image {
                 width: width as isize,
                 height: height as isize,
+                thumbhash: ImageReader::open(f)
+                    .and_then(|r| r.with_guessed_format())
+                    .map_err(ImageError::from)
+                    .and_then(|r| r.decode())
+                    .map(|img| img.thumbnail(100, 100))
+                    .map(|img| (img.dimensions(), img.to_rgba8().into_raw()))
+                    .map(|((width, height), rgba)| {
+                        thumbhash::rgba_to_thumb_hash(width as usize, height as usize, &rgba)
+                    })
+                    .ok(),
+                animated: is_animated(f, mime_type).unwrap_or(false),
             })
             .unwrap_or_default()
     } else if mime_type.starts_with("video/") {

crates/services/gifbox/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-gifbox"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 publish = false
@@ -17,19 +17,19 @@ tokio = { version = "1.0", features = ["full"] }
 reqwest = { version = "0.12", features = ["json"] }
 
 # Core crates
-revolt-config = { version = "0.11.5", path = "../../core/config" }
-revolt-models = { version = "0.11.5", path = "../../core/models" }
-revolt-result = { version = "0.11.5", path = "../../core/result", features = [
+revolt-config = { version = "0.12.0", path = "../../core/config" }
+revolt-models = { version = "0.12.0", path = "../../core/models" }
+revolt-result = { version = "0.12.0", path = "../../core/result", features = [
     "utoipa",
     "axum",
 ] }
-revolt-coalesced = { version = "0.11.5", path = "../../core/coalesced", features = [
+revolt-coalesced = { version = "0.12.0", path = "../../core/coalesced", features = [
     "queue",
 ] }
-revolt-database = { version = "0.11.5", path = "../../core/database", features = [
+revolt-database = { version = "0.12.0", path = "../../core/database", features = [
     "axum-impl",
 ] }
-revolt-ratelimits = { version = "0.11.5", path = "../../core/ratelimits", features = [
+revolt-ratelimits = { version = "0.12.0", path = "../../core/ratelimits", features = [
     "axum",
 ] }
 

crates/services/january/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-january"
-version = "0.11.5"
+version = "0.12.0"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 publish = false
@@ -33,13 +33,13 @@ tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
 # Core crates
-revolt-config = { version = "0.11.5", path = "../../core/config" }
-revolt-models = { version = "0.11.5", path = "../../core/models" }
-revolt-result = { version = "0.11.5", path = "../../core/result", features = [
+revolt-config = { version = "0.12.0", path = "../../core/config" }
+revolt-models = { version = "0.12.0", path = "../../core/models" }
+revolt-result = { version = "0.12.0", path = "../../core/result", features = [
     "utoipa",
     "axum",
 ] }
-revolt-files = { version = "0.11.5", path = "../../core/files" }
+revolt-files = { version = "0.12.0", path = "../../core/files" }
 
 # Axum / web server
 axum = { version = "0.7.5" }

docs/README.md

@@ -5,13 +5,13 @@ This website is built using [Docusaurus](https://docusaurus.io/), a modern stati
 ## Installation
 
 ```bash
-yarn
+pnpm install
 ```
 
 ## Local Development
 
 ```bash
-yarn start
+pnpm start
 ```
 
 This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
@@ -19,7 +19,7 @@ This command starts a local development server and opens up a browser window. Mo
 ## Build
 
 ```bash
-yarn build
+pnpm build
 ```
 
 This command generates static content into the `build` directory and can be served using any static contents hosting service.
@@ -29,13 +29,13 @@ This command generates static content into the `build` directory and can be serv
 Using SSH:
 
 ```bash
-USE_SSH=true yarn deploy
+USE_SSH=true pnpm run deploy
 ```
 
 Not using SSH:
 
 ```bash
-GIT_USER=<Your GitHub username> yarn deploy
+GIT_USER=<Your GitHub username> pnpm run deploy
 ```
 
 If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.

docs/docs/developers/endpoints.md

@@ -8,16 +8,12 @@ sidebar_position: 1
 
 You can connect to the API on the following URLs:
 
-| URL                           |  Release   | Description                 |
-| ----------------------------- | :--------: | --------------------------- |
-| `https://api.revolt.chat`     | Production | Primary API endpoint        |
-| `https://app.revolt.chat/api` | Production | API endpoint for old client |
-| `https://revolt.chat/api`     |  Staging   | API endpoint for new client |
+| URL                           |  Release   | Description                        |
+| ----------------------------- | :--------: | ---------------------------------- |
+| `https://api.stoat.chat`      | Production | Primary API endpoint               |
 
 You can connect to the events server on the following URLs:
 
-| URL                            |  Release   | Description                    |
-| ------------------------------ | :--------: | ------------------------------ |
-| `wss://ws.revolt.chat`         | Production | Primary events endpoint        |
-| `wss://app.revolt.chat/events` | Production | Events endpoint for old client |
-| `wss://revolt.chat/events`     |  Staging   | Events endpoint for new client |
+| URL                            |  Release   | Description                           |
+| ------------------------------ | :--------: | ------------------------------------- |
+| `wss://events.stoat.chat`      | Production | Primary events endpoint               |

docs/docs/developers/legacy-plugin-api.md

@@ -10,7 +10,7 @@ The Plugin API is very powerful. **Tread carefully.**
 **Zero guarantees or sandboxes are provided.** Your code is run as-is.
 :::
 
-This document details the very experimental plugin API available in [Revite](https://github.com/revoltchat/revite).
+This document details the very experimental plugin API available in [Revite](https://github.com/stoatchat/for-legacy-web).
 
 This is more or less a proof of concept but can be used to achieve some simple client modifications.
 

docs/docs/developing/backend/new_features.md

@@ -4,12 +4,12 @@ New API features must be documented where appropriate, this document aims to cov
 
 Before writing new API features, generally a good idea to:
 
-- Consult with other developers in the [Revolt Developers space](https://rvlt.gg/API)
+- Consult with other developers in the [Stoat Developers space](https://stt.gg/API)
 - If it's a relatively big feature, also [write an RFC](https://github.com/revoltchat/rfcs)
 
 When your feature is ready to release, ensure to:
 
 - Update backend documentation (what you're reading now!) if applicable
-- Update the [developers documentation](https://github.com/revoltchat/wiki) if applicable
+- Update the [developers documentation](https://github.com/stoatchat/stoatchat/tree/main/docs) if applicable
 - Update the Feature Matrix (or ask someone that can to do so)
 - Ensure it is properly listed in the backend release changelog

docs/docs/developing/contrib.md

@@ -12,14 +12,18 @@ This is the contribution guide for developers wanting to help out with Stoat.
 
 - Sign-off your commits ([Git flag](https://git-scm.com/docs/git-commit#Documentation/git-commit.txt---signoff)), [read here about DCO obligations](https://developercertificate.org/).
 - Sign commits where possible, [learn more about that here](https://docs.github.com/en/authentication/managing-commit-signature-verification/signing-commits).
-- Prefer to use [Conventional Commit style](https://www.conventionalcommits.org/en/v1.0.0-beta.2/).
+- Prefer using [Conventional Commit style](https://www.conventionalcommits.org/en/v1.0.0-beta.2/).
 - If present, e.g. `prettier`, `cargo fmt`, use the formatter.
 - Try to keep each PR bound to a single feature or change, multiple bug fixes may be fine in some cases.
   This is to avoid your PR getting stuck due to parts of it having conflicts or other issues.
 
 ### Merging Pull Requests
 
-All PR titles must use use [Conventional Commit style](https://www.conventionalcommits.org/en/v1.0.0-beta.2/) and will be squash merged!
+All PR titles must use use [Conventional Commit style](https://www.conventionalcommits.org/en/v1.0.0-beta.2/) and will be squash merged.
+
+### Use of generative AI
+
+Please do not open PRs generated with LLMs.
 
 ## What can I help with?
 

docs/docs/help.md

@@ -13,7 +13,7 @@ We want to hear what you think and appreciate and await your feature suggestions
 
 Typically, you can open issues on the relevant [GitHub repositories](https://github.com/stoatchat).
 
-<!-- Within the Stoat app, you can navigate to the [**feedback tab**](https://app.revolt.chat/settings/feedback), or you can open an issue on the relevant [GitHub repo](https://github.com/revoltchat). -->
+<!-- Within the Stoat app, you can navigate to the [**feedback tab**](https://app.revolt.chat/settings/feedback), or you can open an issue on the relevant [GitHub repo](https://github.com/stoatchat). -->
 
 ### 2. Translate
 

release-please-config.json

@@ -205,6 +205,11 @@
                     "path": "crates/daemons/pushd/Cargo.toml",
                     "jsonpath": "$.dependencies['revolt-presence'].version"
                 },
+                {
+                    "type": "toml",
+                    "path": "crates/daemons/pushd/Cargo.toml",
+                    "jsonpath": "$.dependencies['revolt-parser'].version"
+                },
                 {
                     "type": "toml",
                     "path": "crates/daemons/voice-ingress/Cargo.toml",

version.txt

@@ -1 +1 @@
-0.11.5
+0.12.0