Fix/release please fix 4 (#703)

* fix: release-please-3

* fix: release please bs v4

.github/ISSUE_TEMPLATE/bug.yml

@@ -0,0 +1,147 @@
+name: Bug Report
+description: Report a bug in Stoat — please fill out every required field to help us triage quickly.
+title: "[Bug]: "
+labels:
+  - bug
+  - unconfirmed
+
+body:
+  # ── Thank you section ────────────────────────────────────────────────────────
+  - type: markdown
+    attributes:
+      value: |
+        **Thank you for taking the time to report a bug for Stoat!**
+
+        Please follow the instructions below and provide as much detail as possible to help us understand and reproduce the issue.
+
+  # ── Pre-flight checks ────────────────────────────────────────────────────────
+  - type: checkboxes
+    id: preflight
+    attributes:
+      label: Pre-flight checklist
+      description: Please confirm all of the following before submitting.
+      options:
+        - label: I am on the latest available version of Stoat.
+          required: true
+        - label: I searched existing issues and did not find a duplicate.
+          required: true
+        - label: This is a bug report, not a support question or feature request.
+          required: true
+
+  # ── Bug description ──────────────────────────────────────────────────────────
+  - type: textarea
+    id: description
+    attributes:
+      label: Bug description
+      description: >
+        What happened? What did you expect to happen instead?
+        Keep this brief — detailed steps go in the next field.
+      placeholder: "Example: When I open a DM thread, new messages from the other person do not appear unless I reload the page."
+    validations:
+      required: true
+
+  # ── Steps to reproduce ───────────────────────────────────────────────────────
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to reproduce
+      description: >
+        Provide a numbered list of every step needed to trigger the bug.
+        The clearer this is, the faster we can fix it.
+      placeholder: |
+        1. Log in to Stoat on the web client.
+        2. Open a direct message conversation.
+        3. Ask the other person to send a message.
+        4. Observe that the message does not appear without reloading.
+    validations:
+      required: true
+
+  # ── Expected behavior ────────────────────────────────────────────────────────
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: What should have happened?
+      placeholder: "New messages should appear in real time without a page reload."
+    validations:
+      required: true
+
+  # ── Client / platform ────────────────────────────────────────────────────────
+  - type: dropdown
+    id: platform
+    attributes:
+      label: Client / platform
+      description: Which Stoat client are you using?
+      options:
+        - Web (browser)
+        - Stoat for Desktop
+        - Android
+        - iOS
+        - Self-hosted server
+    validations:
+      required: true
+
+  # ── Client version ───────────────────────────────────────────────────────────
+  - type: input
+    id: version
+    attributes:
+      label: Client version
+      description: >
+        Find this in **Settings**. For the web client, include the build
+        number shown in the footer or About page.
+      placeholder: "e.g. Stoat for Desktop 1.3.0 or 0.2.1 (2025-10-10)"
+    validations:
+      required: true
+
+  # ── OS / browser details ─────────────────────────────────────────────────────
+  - type: input
+    id: os
+    attributes:
+      label: OS / browser details
+      description: Your operating system and, for web bugs, your browser and its version.
+      placeholder: "e.g. Windows 11, Chrome 121  or  macOS 14.3, Stoat for Desktop 1.3.0  or  Android 14"
+    validations:
+      required: true
+
+  # ── Reproducibility ──────────────────────────────────────────────────────────
+  - type: dropdown
+    id: reproducibility
+    attributes:
+      label: Reproducibility
+      description: How consistently does this bug occur?
+      options:
+        - Always
+        - Usually
+        - Rarely
+        - Only once
+        - Unknown
+    validations:
+      required: true
+
+  # ── Screenshots or video ─────────────────────────────────────────────────────
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots or video
+      description: Paste images or drag-and-drop a screen recording here. GitHub accepts common image and video formats.
+    validations:
+      required: false
+
+  # ── Additional context ───────────────────────────────────────────────────────
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional context
+      description: >
+        Anything else that might help: workarounds you found, links to related issues,
+        self-hosted configuration details (Redis, MongoDB, LiveKit, SMTP), network environment, etc.
+    validations:
+      required: false
+
+  # ── Closing note ─────────────────────────────────────────────────────────────
+  - type: markdown
+    attributes:
+      value: |
+        ---
+        A maintainer will review your report. Please watch for follow-up questions — issues
+        that go unanswered are harder to resolve and may be closed after 30 days of inactivity.

.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:
@@ -20,4 +23,4 @@ jobs:
           RELEASE_URL="https://github.com/${REPOSITORY}/releases/tag/${TAG_NAME}"
           curl -X POST "$WEBHOOK_URL" \
             -H "Content-Type: application/json" \
-            -d "{\"content\": \"$RELEASE_URL\"}"
+            -d "{\"content\": \"$RELEASE_URL\"}"

.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.4"
+    ".": "0.12.0"
 }

CHANGELOG.md

@@ -1,5 +1,49 @@
 # 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)
+
+
+### Reverts
+
+* disable user update events ([#593](https://github.com/stoatchat/stoatchat/issues/593)) ([1c98ead](https://github.com/stoatchat/stoatchat/commit/1c98ead69579b4700be0b51c9020bb8402336cc6))
+
 ## [0.11.4](https://github.com/stoatchat/stoatchat/compare/v0.11.3...v0.11.4) (2026-02-16)
 
 

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",
@@ -6798,7 +6798,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-autumn"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "axum",
  "axum-macros",
@@ -6824,6 +6824,7 @@ dependencies = [
  "simdutf8",
  "strum_macros",
  "tempfile",
+ "thumbhash",
  "tokio 1.49.0",
  "tower-http 0.5.2",
  "tracing",
@@ -6836,7 +6837,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-bonfire"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "async-channel 2.5.0",
  "async-std",
@@ -6867,7 +6868,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-coalesced"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "indexmap 2.13.0",
  "lru 0.16.3",
@@ -6876,7 +6877,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-config"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "async-std",
  "cached",
@@ -6893,7 +6894,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-crond"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "log",
  "revolt-config",
@@ -6905,7 +6906,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-database"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "amqprs",
  "async-lock 2.8.0",
@@ -6955,7 +6956,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-delta"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "amqprs",
  "async-channel 1.9.0",
@@ -7005,7 +7006,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-files"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "aes-gcm",
  "anyhow",
@@ -7033,7 +7034,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-gifbox"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "axum",
  "axum-extra",
@@ -7056,7 +7057,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-january"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "async-recursion",
  "axum",
@@ -7084,7 +7085,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-models"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "indexmap 1.9.3",
  "iso8601-timestamp",
@@ -7103,14 +7104,14 @@ dependencies = [
 
 [[package]]
 name = "revolt-parser"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "logos",
 ]
 
 [[package]]
 name = "revolt-permissions"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "async-std",
  "async-trait",
@@ -7125,7 +7126,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-presence"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "async-std",
  "log",
@@ -7137,7 +7138,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-pushd"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "amqprs",
  "anyhow",
@@ -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",
@@ -7165,7 +7169,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-ratelimits"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "async-trait",
  "authifier",
@@ -7182,7 +7186,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-result"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "axum",
  "log",
@@ -7198,7 +7202,7 @@ dependencies = [
 
 [[package]]
 name = "revolt-voice-ingress"
-version = "0.11.4"
+version = "0.12.0"
 dependencies = [
  "amqprs",
  "async-std",
@@ -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)
+  [![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/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/network/members)
+  [![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/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/pulls)
+  [![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/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/issues)
+  [![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/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/graphs/contributors)
+  [![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/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/blob/main/LICENSE)
+  [![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
+git clone https://github.com/stoatchat/stoatchat stoat-backend
-cd revolt-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
+git clone --recursive https://github.com/stoatchat/for-web stoat-web
-cd revite
+cd stoat-web
-yarn
+# refer to stoat-web/README.md for startup, creating an account and loging in
-yarn build:deps
-echo "VITE_API_URL=http://local.revolt.chat:14702" > .env.local
-yarn dev --port 14701
 ```
 
-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.4"
+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())
@@ -399,27 +401,32 @@ impl State {
 
     /// Push presence change to the user and all associated server topics
     pub async fn broadcast_presence_change(&self, target: bool) {
-        // if if let Some(status) = &self.cache.users.get(&self.cache.user_id).unwrap().status {
+        let config = revolt_config::config().await;
-        //     status.presence != Some(Presence::Invisible)
+        if config.disable_events_dont_use {
-        // } else {
+            return;
-        //     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()),
-        //     };
 
-        //     for server in self.cache.servers.keys() {
+        if if let Some(status) = &self.cache.users.get(&self.cache.user_id).unwrap().status {
-        //         event.clone().p(server.clone()).await;
+            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,8 +465,38 @@ async fn worker(
                 };
 
                 match payload {
-                    ClientMessage::BeginTyping { .. } => {}
+                    ClientMessage::BeginTyping { channel } => {
-                    ClientMessage::EndTyping { .. } => {}
+                        if revolt_config.disable_events_dont_use {
+                            continue;
+                        }
+
+                        if !subscribed.read().await.contains(&channel) {
+                            continue;
+                        }
+
+                        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.4"
+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.4"
+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.4", 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
 
@@ -244,7 +254,7 @@ voice_quality = 16000
 # Whether the user can use video streams in voice calls
 video = true
 
-# Mamimum resolution (width, height) of video streams in voice calls
+# Maximum resolution (width, height) of video streams in voice calls
 video_resolution = [1080, 720]
 
 # Minimum and maximum aspect ratio of video streams in voice calls
@@ -283,8 +293,8 @@ voice_quality = 16000
 # Whether the user can use video streams in voice calls
 video = true
 
-# Mamimum resolution (width, height) of video streams in voice calls
+# Maximum resolution (width, height) of video streams in voice calls
-video_resolution = [1080, 720]
+video_resolution = [1280, 720]
 
 # Minimum and maximum aspect ratio of video streams in voice calls
 video_aspect_ratio = [0.3, 2.5]
@@ -312,4 +322,4 @@ files = ""
 proxy = ""
 pushd = ""
 crond = ""
-gifbox = ""
+gifbox = ""

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.4"
+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.4", path = "../config", features = [
+revolt-config = { version = "0.12.0", path = "../config", features = [
     "report-macros",
 ] }
-revolt-result = { version = "0.11.4", path = "../result" }
+revolt-result = { version = "0.12.0", path = "../result" }
-revolt-models = { version = "0.11.4", path = "../models", features = [
+revolt-models = { version = "0.12.0", path = "../models", features = [
     "validator",
 ] }
-revolt-presence = { version = "0.11.4", path = "../presence" }
+revolt-presence = { version = "0.12.0", path = "../presence" }
-revolt-permissions = { version = "0.11.4", path = "../permissions", features = [
+revolt-permissions = { version = "0.12.0", path = "../permissions", features = [
     "serde",
     "bson",
 ] }
-revolt-parser = { version = "0.11.4", 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,
+    events::client::EventV1, util::permissions::DatabasePermissionQuery, Channel, Database, File,
-    Database, File, Server, SystemMessage, User,
+    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/models/users/model.rs

@@ -653,14 +653,14 @@ impl User {
         self.apply_options(partial.clone());
         db.update_user(&self.id, &partial, remove.clone()).await?;
 
-        // EventV1::UserUpdate {
+        EventV1::UserUpdate {
-        //     id: self.id.clone(),
+            id: self.id.clone(),
-        //     data: partial.into(),
+            data: partial.into(),
-        //     clear: remove.into_iter().map(|v| v.into()).collect(),
+            clear: remove.into_iter().map(|v| v.into()).collect(),
-        //     event_id: Some(Ulid::new().to_string()),
+            event_id: Some(Ulid::new().to_string()),
-        // }
+        }
-        // .p_user(self.id.clone(), db)
+        .p_user(self.id.clone(), db)
-        // .await;
+        .await;
 
         Ok(())
     }

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};
@@ -16,16 +22,18 @@ mod voice_client;
 pub use voice_client::VoiceClient;
 
 async fn get_connection() -> Result<Conn> {
-    _get_connection().await.map_err(|_| create_error!(InternalError))
+    _get_connection()
+        .await
+        .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()?
         {
@@ -43,23 +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 get_user_voice_channels(user_id: &str) -> Result<Vec<String>> {
+pub async fn delete_channel_node(channel_id: &str) -> Result<()> {
+    get_connection()
+        .await?
+        .del(format!("node:{channel_id}"))
+        .await
+        .to_internal_error()
+}
+
+pub async fn get_user_voice_channels(user_id: &str) -> Result<Vec<UserVoiceChannel>> {
     get_connection()
         .await?
         .smembers(format!("vc:{user_id}"))
@@ -68,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,
+    old_channel_id: &str,
-    new_channel: &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,
         )
@@ -92,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,
+    new_channel_id: &str,
-    old_channel: &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}"))
@@ -111,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()
 }
@@ -148,12 +171,15 @@ pub fn get_allowed_sources(
 }
 
 pub async fn create_voice_state(
-    channel_id: &str,
+    channel: &UserVoiceChannel,
-    server_id: Option<&str>,
     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,
@@ -165,9 +191,9 @@ pub async fn create_voice_state(
     };
 
     Pipeline::new()
-        .sadd(format!("vc_members:{channel_id}"), user_id)
+        .sadd(format!("vc_members:{}", &channel.id), user_id)
-        .sadd(format!("vc:{user_id}"), channel_id)
+        .sadd(format!("vc:{user_id}"), channel)
-        .set(&unique_key, channel_id)
+        .set(&unique_key, &channel.id)
         .set(
             format!("joined_at:{unique_key}"),
             joined_at
@@ -194,16 +220,16 @@ pub async fn create_voice_state(
     Ok(voice_state)
 }
 
-pub async fn delete_voice_state(
+pub async fn delete_voice_state(channel: &UserVoiceChannel, user_id: &str) -> Result<()> {
-    channel_id: &str,
+    let unique_key = format!(
-    server_id: Option<&str>,
+        "{}:{}",
-    user_id: &str,
+        &user_id,
-) -> Result<()> {
+        channel.server_id.as_ref().unwrap_or(&channel.id)
-    let unique_key = format!("{}:{}", &user_id, server_id.unwrap_or(channel_id));
+    );
 
     Pipeline::new()
-        .srem(format!("vc_members:{channel_id}"), user_id)
+        .srem(format!("vc_members:{}", &channel.id), user_id)
-        .srem(format!("vc:{user_id}"), channel_id)
+        .srem(format!("vc:{user_id}"), channel)
         .del(&[
             format!("joined_at:{unique_key}"),
             format!("is_publishing:{unique_key}"),
@@ -218,19 +244,19 @@ pub async fn delete_voice_state(
 }
 
 pub async fn delete_channel_voice_state(
-    channel_id: &str,
+    channel: &UserVoiceChannel,
-    server_id: Option<&str>,
     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!("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}"),
@@ -247,8 +273,7 @@ pub async fn delete_channel_voice_state(
 }
 
 pub async fn update_voice_state_tracks(
-    channel_id: &str,
+    channel: &UserVoiceChannel,
-    server_id: Option<&str>,
     user_id: &str,
     added: bool,
     track: i32,
@@ -273,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,
+    channel: &UserVoiceChannel,
-    server_id: Option<&str>,
     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();
 
@@ -310,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,
+    channel: &UserVoiceChannel,
-    server_id: Option<&str>,
     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?
@@ -365,21 +396,21 @@ pub async fn get_voice_state(
     }
 }
 
-pub async fn get_channel_voice_state(channel: &Channel) -> Result<Option<v0::ChannelVoiceState>> {
+pub async fn get_channel_voice_state(
-    let members = get_voice_channel_members(channel.id()).await?;
+    channel: &UserVoiceChannel,
-
+) -> Result<Option<v0::ChannelVoiceState>> {
-    let server = channel.server();
+    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?;
             }
         }
 
@@ -387,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 {
@@ -395,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:{from_channel_id}"),
-            format!("vc-members-{to}"),
+            format!("vc_members:{to_channel_id}"),
             user,
         )
         .await
@@ -414,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()
@@ -458,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(());
         };
 
@@ -489,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(
@@ -567,34 +602,95 @@ pub async fn get_call_notification_recipients(
         .to_internal_error()
 }
 
-pub async fn remove_user_from_voice_channels(db: &Database, voice_client: &VoiceClient, user_id: &str) -> Result<()> {
+pub async fn remove_user_from_voice_channels(
-    for channel_id in get_user_voice_channels(user_id).await? {
+    voice_client: &VoiceClient,
-        remove_user_from_voice_channel(db, voice_client, &channel_id, user_id).await?;
+    user_id: &str,
-    };
+) -> Result<()> {
-
+    for channel in get_user_voice_channels(user_id).await? {
-    Ok(())
+        remove_user_from_voice_channel(voice_client, &channel, user_id).await?;
-}
-
-pub async fn remove_user_from_voice_channel(db: &Database, voice_client: &VoiceClient, channel_id: &str, 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;
     }
 
-    let channel = Reference::from_unchecked(channel_id).as_channel(db).await?;
+    Ok(())
+}
 
-    delete_voice_state(channel_id, channel.server(), user_id).await?;
+pub async fn remove_user_from_voice_channel(
+    voice_client: &VoiceClient,
+    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;
+    }
+
+    delete_voice_state(channel, user_id).await?;
 
     Ok(())
 }
 
-pub async fn delete_voice_channel(voice_client: &VoiceClient, channel_id: &str, server_id: Option<&str>) -> Result<()> {
+pub async fn delete_voice_channel(
-    if let Some(users) = get_voice_channel_members(channel_id).await? {
+    voice_client: &VoiceClient,
-        let node = get_channel_node(channel_id).await?.unwrap();
+    channel: &UserVoiceChannel,
+) -> Result<()> {
+    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, &users).await?;
-
-        delete_channel_voice_state(channel_id, server_id, &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.4"
+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.4", path = "../config", features = [
+revolt-config = { version = "0.12.0", path = "../config", features = [
     "report-macros",
 ] }
-revolt-result = { version = "0.11.4", 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.4"
+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.4", path = "../config" }
+revolt-config = { version = "0.12.0", path = "../config" }
-revolt-permissions = { version = "0.11.4", path = "../permissions" }
+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
+        /// File is an image with specific dimensions, and may be animated
-        Image { width: usize, height: usize },
+        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.4"
+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::CodeblockMarker(_) => {}
-            MessageToken::UserMention(id) => { results.user_mentions.insert(id.to_string()); },
+            MessageToken::UserMention(id) => {
-            MessageToken::RoleMention(id) => { results.role_mentions.insert(id.to_string()); },
+                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.len(), 6);
-        assert_eq!(output[0], MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3"));
+        assert_eq!(
-        assert_eq!(output[1], MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3"));
+            output[0],
-        assert_eq!(output[2], MessageToken::MentionEveryone);
+            MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3")
-        assert_eq!(output[3], MessageToken::MentionOnline);
+        );
+        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.len(), 6);
-        assert_eq!(output[0], MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3"));
+        assert_eq!(
-        assert_eq!(output[1], MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3"));
+            output[0],
-        assert_eq!(output[2], MessageToken::MentionEveryone);
+            MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3")
-        assert_eq!(output[3], MessageToken::MentionOnline);
+        );
+        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!(
-        assert_eq!(output[2], MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3"));
+            output[1],
-        assert_eq!(output[3], MessageToken::MentionEveryone);
+            MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3")
-        assert_eq!(output[4], MessageToken::MentionOnline);
+        );
+        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!(
-        assert_eq!(output[2], MessageToken::RoleMention("01FD58YK5W7QRV5H3D64KTQYX3"));
+            output[1],
-        assert_eq!(output[3], MessageToken::MentionEveryone);
+            MessageToken::UserMention("01FD58YK5W7QRV5H3D64KTQYX3")
-        assert_eq!(output[4], MessageToken::MentionOnline);
+        );
+        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.4"
+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.4", 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.4"
+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.4", 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.4"
+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.4", path = "../database" }
+revolt-database = { version = "0.12.0", path = "../database" }
-revolt-result = { version = "0.11.4", path = "../result" }
+revolt-result = { version = "0.12.0", path = "../result" }
-revolt-config = { version = "0.11.4", path = "../config" }
+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.4"
+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
+        self.map_err(|e| {
-            .map_err(|e| {
+            log::error!("{e:?}");
-                log::error!("{e:?}");
+            #[cfg(feature = "sentry")]
-                #[cfg(feature = "sentry")]
+            sentry::capture_error(&e);
-                sentry::capture_error(&e);
 
-                Error {
+            Error {
-                    error_type: ErrorType::InternalError,
+                error_type: ErrorType::InternalError,
-                    location: format!("{}:{}:{}", loc.file(), loc.line(), loc.column())
+                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(|| {
+        self.ok_or_else(|| Error {
-            Error {
+            error_type: ErrorType::InternalError,
-                error_type: ErrorType::InternalError,
+            location: format!("{}:{}:{}", loc.file(), loc.line(), loc.column()),
-                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.4"
+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.4", path = "../../core/database" }
+revolt-database = { version = "0.12.0", path = "../../core/database" }
-revolt-result = { version = "0.11.4", path = "../../core/result" }
+revolt-result = { version = "0.12.0", path = "../../core/result" }
-revolt-config = { version = "0.11.4", path = "../../core/config" }
+revolt-config = { version = "0.12.0", path = "../../core/config" }
-revolt-files = { version = "0.11.4", path = "../../core/files" }
+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.4"
+version = "0.12.0"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 publish = false
 
 [dependencies]
-revolt-result = { version = "0.11.4", path = "../../core/result" }
+revolt-result = { version = "0.12.0", path = "../../core/result" }
-revolt-config = { version = "0.11.4", path = "../../core/config", features = [
+revolt-config = { version = "0.12.0", path = "../../core/config", features = [
     "report-macros",
     "anyhow",
 ] }
-revolt-database = { version = "0.11.4", path = "../../core/database" }
+revolt-database = { version = "0.12.0", path = "../../core/database" }
-revolt-models = { version = "0.11.4", path = "../../core/models", features = [
+revolt-models = { version = "0.12.0", path = "../../core/models", features = [
     "validator",
 ] }
-revolt-presence = { version = "0.11.4", path = "../../core/presence", features = [
+revolt-presence = { version = "0.12.0", path = "../../core/presence", features = [
     "redis-is-patched",
 ] }
+revolt-parser = { version = "0.12.0", 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/dm_call.rs

@@ -128,7 +128,7 @@ impl DmCallConsumer {
                                 config.pushd.vapid.queue.as_str(),
                             )
                             .finish();
-                            sendable.extras.insert("p265dh".to_string(), sub.p256dh);
+                            sendable.extras.insert("p256dh".to_string(), sub.p256dh);
                             sendable
                                 .extras
                                 .insert("endpoint".to_string(), sub.endpoint.clone());

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

@@ -101,7 +101,7 @@ impl FRAcceptedConsumer {
                             config.pushd.vapid.queue.as_str(),
                         )
                         .finish();
-                        sendable.extras.insert("p265dh".to_string(), sub.p256dh);
+                        sendable.extras.insert("p256dh".to_string(), sub.p256dh);
                         sendable
                             .extras
                             .insert("endpoint".to_string(), sub.endpoint.clone());

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

@@ -101,7 +101,7 @@ impl FRReceivedConsumer {
                             config.pushd.vapid.queue.as_str(),
                         )
                         .finish();
-                        sendable.extras.insert("p265dh".to_string(), sub.p256dh);
+                        sendable.extras.insert("p256dh".to_string(), sub.p256dh);
                         sendable
                             .extras
                             .insert("endpoint".to_string(), sub.endpoint.clone());

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

@@ -107,7 +107,7 @@ impl GenericConsumer {
                             config.pushd.vapid.queue.as_str(),
                         )
                         .finish();
-                        sendable.extras.insert("p265dh".to_string(), sub.p256dh);
+                        sendable.extras.insert("p256dh".to_string(), sub.p256dh);
                         sendable
                             .extras
                             .insert("endpoint".to_string(), sub.endpoint.clone());

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)]
@@ -104,7 +105,7 @@ impl MassMessageConsumer {
                             config.pushd.vapid.queue.as_str(),
                         )
                         .finish();
-                        sendable.extras.insert("p265dh".to_string(), sub.p256dh);
+                        sendable.extras.insert("p256dh".to_string(), sub.p256dh);
                         sendable
                             .extras
                             .insert("endpoint".to_string(), sub.endpoint.clone());
@@ -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");
 
@@ -107,7 +116,7 @@ impl MessageConsumer {
                             config.pushd.vapid.queue.as_str(),
                         )
                         .finish();
-                        sendable.extras.insert("p265dh".to_string(), sub.p256dh);
+                        sendable.extras.insert("p256dh".to_string(), sub.p256dh);
                         sendable
                             .extras
                             .insert("endpoint".to_string(), sub.endpoint.clone());

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.4"
+version = "0.12.0"
 license = "AGPL-3.0-or-later"
 edition = "2021"
 publish = false

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

@@ -5,9 +5,9 @@ use revolt_database::{
     iso8601_timestamp::{Duration, Timestamp},
     util::reference::Reference,
     voice::{
-        create_voice_state, delete_voice_state,
+        create_voice_state, delete_channel_voice_state, delete_voice_state,
-        get_user_moved_from_voice, get_user_moved_to_voice,
+        get_user_moved_from_voice, get_user_moved_to_voice, update_voice_state_tracks,
-        update_voice_state_tracks, VoiceClient,
+        RoomMetadata, UserVoiceChannel, VoiceClient,
     },
     Database, AMQP,
 };
@@ -51,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 server_id = room_metadata.to_internal_error()?.server;
-            let channel = Reference::from_unchecked(channel_id).as_channel(db).await?;
+            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 =
+            let voice_state = create_voice_state(&channel, user_id, joined_at).await?;
-                create_voice_state(channel_id, channel.server(), 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,
                 }
@@ -136,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, user_id).await?;
-
-            delete_voice_state(channel_id, channel.server(), user_id).await?;
 
             // Dont send leave event when a user is moved
             if get_user_moved_from_voice(channel_id, user_id)
@@ -203,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 server_id = room_metadata.to_internal_error()?.server;
-            let channel = Reference::from_unchecked(channel_id).as_channel(db).await?;
+            let channel = UserVoiceChannel {
+                id: channel_id.clone(),
+                server_id: server_id.clone(),
+            };
 
             let user = Reference::from_unchecked(user_id).as_user(db).await?;
 
@@ -244,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,
-                channel.server(),
                 user_id,
                 event.event == "track_published" || event.event == "track_unmuted", // to avoid duplicating this entire case twice
                 track.source,
@@ -267,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.4"
+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::{
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
-        VoiceClient, delete_voice_channel, is_in_voice_channel, remove_user_from_voice_channel
+    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? {
+            let user_voice_channel = UserVoiceChannel::from_channel(&channel);
-                remove_user_from_voice_channel(db, voice_client, channel.id(), &user.id).await?;
+
+            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,
+    AMQP, Channel, Database, User, util::reference::Reference, voice::{UserVoiceChannel, VoiceClient, is_in_voice_channel, remove_user_from_voice_channel}
-    voice::{is_in_voice_channel, remove_user_from_voice_channel, VoiceClient},
-    Channel, Database, User, AMQP,
 };
 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<'_>,
+    group_id: Reference<'_>,
-    member: 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? {
+    let user_voice_channel = UserVoiceChannel::from_channel(&channel);
-        remove_user_from_voice_channel(db, voice_client, channel.id(), &member.id).await?;
+
+    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, 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)
@@ -60,6 +63,7 @@ pub async fn call(
     }
 
     let existing_node = get_channel_node(channel.id()).await?;
+    let has_existing_node = existing_node.is_some(); // we move existing_node in the next statement so this is the quickest way to know if we need to set it.
 
     let node = existing_node
         .or(node)
@@ -78,20 +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? {
+        for previous_channel in get_user_voice_channels(&user.id).await? {
-            if let Some(node) = get_channel_node(&channel_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)
+            delete_voice_state(&previous_channel, &user.id).await?;
-                .as_channel(db)
-                .await?;
-
-            delete_voice_state(&channel_id, channel.server(), &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
@@ -100,6 +102,10 @@ pub async fn call(
 
     let room = voice_client.create_room(&node, &channel).await?;
 
+    if !has_existing_node {
+        set_channel_node(channel.id(), &node).await?;
+    }
+
     log::debug!("Created room {}", room.name);
 
     if let Some(recipients) = recipients {

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)
+    if get_voice_state(
-        .await?
+        &UserVoiceChannel {
-        .is_none()
+            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

@@ -2,6 +2,7 @@ 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)]
@@ -54,6 +55,87 @@ pub struct RevoltFeatures {
     pub january: Feature,
     /// Voice server configuration
     pub livekit: VoiceFeature,
+    /// Limits
+    pub limits: LimitsConfig,
+}
+
+/// # Limits For Users
+#[derive(Serialize, JsonSchema, Debug)]
+pub struct LimitsConfig {
+    /// Global Limits
+    pub global: GlobalLimits,
+    /// New User Limits
+    pub new_user: UserLimits,
+    /// Default User Limits
+    pub default: UserLimits,
+}
+
+/// # Global limits
+#[derive(Serialize, JsonSchema, Debug)]
+pub struct GlobalLimits {
+    /// max group size
+    group_size: i64,
+    /// max message embeds
+    message_embeds: i64,
+    /// max replies
+    message_replies: i64,
+    /// max reactions per message
+    message_reactions: i64,
+    /// max server emoji
+    server_emoji: i64,
+    /// max server roles
+    server_roles: i64,
+    /// 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
+#[derive(Serialize, JsonSchema, Debug)]
+pub struct UserLimits {
+    /// Max Outgoing Friend Requests
+    pub outgoing_friend_requests: i64,
+    /// Max Owned Bots
+    pub bots: i64,
+    /// Max message content length
+    pub message_length: i64,
+    /// max message attachments
+    pub message_attachments: i64,
+    /// max servers
+    pub servers: i64,
+    /// max audio quality
+    pub voice_quality: i64,
+    /// video streaming enabled
+    pub video: bool,
+    /// max video resolution (vertical, horizontal)
+    pub video_resolution: [i64; 2],
+    /// min/max aspect ratios
+    pub video_aspect_ratio: [f64; 2],
+    pub file_upload_size_limits: HashMap<String, usize>,
+}
+
+impl UserLimits {
+    fn from_feature_limits(fl: revolt_config::FeaturesLimits) -> UserLimits {
+        UserLimits {
+            outgoing_friend_requests: fl.outgoing_friend_requests as i64,
+            bots: fl.bots as i64,
+            message_length: fl.message_length as i64,
+            message_attachments: fl.message_attachments as i64,
+            servers: fl.servers as i64,
+            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,
+            ],
+            file_upload_size_limits: fl.file_upload_size_limit,
+        }
+    }
 }
 
 /// # Build Information
@@ -134,6 +216,25 @@ pub async fn root() -> Result<Json<RevoltConfig>> {
                     })
                     .collect(),
             },
+            limits: LimitsConfig {
+                global: GlobalLimits {
+                    group_size: config.features.limits.global.group_size as i64,
+                    message_embeds: config.features.limits.global.message_embeds as i64,
+                    message_replies: config.features.limits.global.message_replies as i64,
+                    message_reactions: config.features.limits.global.message_reactions as i64,
+                    server_emoji: config.features.limits.global.server_emoji as i64,
+                    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},
+    voice::{
-    Database, RemovalIntention, ServerBan, User,
+        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? {
+        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?;
+            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::{
+use revolt_permissions::{calculate_channel_permissions, calculate_server_permissions, ChannelPermission, UserPermission};
-    calculate_channel_permissions, calculate_server_permissions, ChannelPermission,
-};
 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<'_>,
+    server_id: Reference<'_>,
-    member: 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 mut server = server_id.as_server(db).await?;
-    let target_user = member.as_user(db).await?;
+    let target_user = member_id.as_user(db).await?;
-    let mut member = member.as_member(db, &server.id).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?;
+            let new_user_voice_channel = UserVoiceChannel::from_channel(&new_voice_channel);
-            set_user_moved_to_voice(new_voice_channel.id(), &channel, &target_user.id).await?;
+            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<'_>,
+    server_id: Reference<'_>,
-    member: 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<'_>,
+    server_id: Reference<'_>,
-    member: 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? {
+    if let Some(channel_id) = get_user_voice_channel_in_server(member_id.id, &server.id).await? {
-        remove_user_from_voice_channel(db, voice_client, &channel_id, &target.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 {
+fn shorten_single_line_text(text: &str, length: usize) -> String {
-    if text.len() < length {
+    if text.contains('\n') {
-        text.to_string()
+        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.4"
+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.4", path = "../../core/files" }
+revolt-files = { version = "0.12.0", path = "../../core/files" }
-revolt-config = { version = "0.11.4", path = "../../core/config" }
+revolt-config = { version = "0.12.0", path = "../../core/config" }
-revolt-database = { version = "0.11.4", path = "../../core/database", features = [
+revolt-database = { version = "0.12.0", path = "../../core/database", features = [
     "axum-impl",
 ] }
-revolt-result = { version = "0.11.4", path = "../../core/result", features = [
+revolt-result = { version = "0.12.0", path = "../../core/result", features = [
     "utoipa",
     "axum",
 ] }
-revolt-ratelimits = { version = "0.11.4", 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.4"
+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.4", path = "../../core/config" }
+revolt-config = { version = "0.12.0", path = "../../core/config" }
-revolt-models = { version = "0.11.4", path = "../../core/models" }
+revolt-models = { version = "0.12.0", path = "../../core/models" }
-revolt-result = { version = "0.11.4", path = "../../core/result", features = [
+revolt-result = { version = "0.12.0", path = "../../core/result", features = [
     "utoipa",
     "axum",
 ] }
-revolt-coalesced = { version = "0.11.4", path = "../../core/coalesced", features = [
+revolt-coalesced = { version = "0.12.0", path = "../../core/coalesced", features = [
     "queue",
 ] }
-revolt-database = { version = "0.11.4", path = "../../core/database", features = [
+revolt-database = { version = "0.12.0", path = "../../core/database", features = [
     "axum-impl",
 ] }
-revolt-ratelimits = { version = "0.11.4", 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.4"
+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.4", path = "../../core/config" }
+revolt-config = { version = "0.12.0", path = "../../core/config" }
-revolt-models = { version = "0.11.4", path = "../../core/models" }
+revolt-models = { version = "0.12.0", path = "../../core/models" }
-revolt-result = { version = "0.11.4", path = "../../core/result", features = [
+revolt-result = { version = "0.12.0", path = "../../core/result", features = [
     "utoipa",
     "axum",
 ] }
-revolt-files = { version = "0.11.4", 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                 |
+| URL                           |  Release   | Description                        |
-| ----------------------------- | :--------: | --------------------------- |
+| ----------------------------- | :--------: | ---------------------------------- |
-| `https://api.revolt.chat`     | Production | Primary API endpoint        |
+| `https://api.stoat.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 |
 
 You can connect to the events server on the following URLs:
 
-| URL                            |  Release   | Description                    |
+| URL                            |  Release   | Description                           |
-| ------------------------------ | :--------: | ------------------------------ |
+| ------------------------------ | :--------: | ------------------------------------- |
-| `wss://ws.revolt.chat`         | Production | Primary events endpoint        |
+| `wss://events.stoat.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 |

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.