fix: manually specify params

Merge remote-tracking branch 'origin/main' into chore/utoipa
chore: update routes to use utoipa
2026-07-08 03:56:54 +00:00 · 2025-11-18 14:57:34 +00:00 · 2025-11-17 23:11:21 +00:00 · 2025-11-17 22:13:07 +00:00 · 2025-11-13 23:06:41 +00:00
321 changed files with 8244 additions and 14874 deletions
--- a/.github/ISSUE_TEMPLATE/bug.yml
+++ b/.github/ISSUE_TEMPLATE/bug.yml
@@ -1,147 +0,0 @@
-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.
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,24 +0,0 @@
-<!-- Describe your changes -->
-
-Fixes # (issue)
-
-## How was this PR tested?
-
-<!-- What did you do to test your changes? -->
-
- [ ] Test A
- [ ] Test B
-
-## Checklist:
-
- [ ] I have carefully read [the contributing guidelines](https://developers.stoat.chat/developing/contrib/)
- [ ] I have performed a self-review of my own code
- [ ] I have made corresponding changes to the documentation if applicable
- [ ] I have no unrelated changes in the PR
- [ ] I have confirmed that any new dependencies are strictly necessary
- [ ] I have written tests for new code (if applicable)
- [ ] I have followed naming conventions/patterns in the surrounding code
-
-## Please declare, if any, LLM usage involved in creating this PR
-
-...
--- a/.github/workflows/docker-cleanup.yaml
+++ b/.github/workflows/docker-cleanup.yaml
@@ -1,46 +0,0 @@
-name: Docker PR Image Cleanup
-
-on:
-  pull_request:
-    types:
-      - closed
-
-permissions:
-  contents: read
-  packages: write
-
-concurrency:
-  group: docker-cleanup-${{ github.event.pull_request.number }}
-  cancel-in-progress: false
-
-jobs:
-  cleanup:
-    runs-on: ubuntu-latest
-    if: ${{ !github.event.pull_request.head.repo.fork }}
-    strategy:
-      fail-fast: false
-      matrix:
-        package:
-          - base
-          - api
-          - events
-          - file-server
-          - proxy
-          - gifbox
-          - crond
-          - pushd
-          - voice-ingress
-    steps:
-      - env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          ORG: stoatchat
-          PACKAGE: ${{ matrix.package }}
-          TAG: pr-${{ github.event.pull_request.number }}
-        run: |
-          set -euo pipefail
-          gh api --paginate \
-            "/orgs/${ORG}/packages/container/${PACKAGE}/versions" \
-            --jq ".[] | select(.metadata.container.tags | index(\"${TAG}\")) | .id" \
-          | while read -r id; do
-              gh api -X DELETE "/orgs/${ORG}/packages/container/${PACKAGE}/versions/${id}"
-            done
--- a/.github/workflows/docker.yaml
+++ b/.github/workflows/docker.yaml
@@ -5,21 +5,22 @@ on:
    tags:
      - "*"
  pull_request:
-  workflow_dispatch:
+    paths:
+      - "Dockerfile"

 permissions:
  contents: read
  packages: write

-concurrency:
-  group: ${{ github.head_ref || github.ref }}
+concurrency: 
+  group: ${{ github.head_ref }}
  cancel-in-progress: true

 jobs:
  base:
-    name: Test base image build (fork)
-    runs-on: arc-runner-set
-    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork
+    name: Test base image build
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request'
    steps:
      # Configure build environment
      - name: Checkout
@@ -39,8 +40,8 @@ jobs:
          cache-to: type=gha,scope=buildx-base-multi-arch,mode=max

  publish:
-    runs-on: arc-runner-set
-    if: ${{ github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork }}
+    runs-on: self-hosted
+    if: github.event_name != 'pull_request'
    name: Publish Docker images
    steps:
      # Configure build environment
@@ -57,15 +58,6 @@ jobs:
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

-      - name: Determine base image tag
-        id: base
-        run: |
-          if [ "${{ github.event_name }}" = "pull_request" ]; then
-            echo "tag=pr-${{ github.event.number }}" >> "$GITHUB_OUTPUT"
-          else
-            echo "tag=latest" >> "$GITHUB_OUTPUT"
-          fi
-
      # Build the image
      - name: Build base image
        uses: docker/build-push-action@v4
@@ -73,9 +65,7 @@ jobs:
          context: .
          push: true
          platforms: linux/amd64,linux/arm64
-          tags: ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
-          cache-from: type=gha,scope=buildx-base-multi-arch
-          cache-to: type=gha,scope=buildx-base-multi-arch,mode=max
+          tags: ghcr.io/${{ github.repository_owner }}/base:latest

      # stoatchat/api
      - name: Docker meta
@@ -93,7 +83,7 @@ jobs:
          file: crates/delta/Dockerfile
          tags: ${{ steps.meta-delta.outputs.tags }}
          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
          labels: ${{ steps.meta-delta.outputs.labels }}

      # stoatchat/events
@@ -112,7 +102,7 @@ jobs:
          file: crates/bonfire/Dockerfile
          tags: ${{ steps.meta-bonfire.outputs.tags }}
          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
          labels: ${{ steps.meta-bonfire.outputs.labels }}

      # stoatchat/file-server
@@ -131,7 +121,7 @@ jobs:
          file: crates/services/autumn/Dockerfile
          tags: ${{ steps.meta-autumn.outputs.tags }}
          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
          labels: ${{ steps.meta-autumn.outputs.labels }}

      # stoatchat/proxy
@@ -150,7 +140,7 @@ jobs:
          file: crates/services/january/Dockerfile
          tags: ${{ steps.meta-january.outputs.tags }}
          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
          labels: ${{ steps.meta-january.outputs.labels }}

      # stoatchat/gifbox
@@ -169,7 +159,7 @@ jobs:
          file: crates/services/gifbox/Dockerfile
          tags: ${{ steps.meta-gifbox.outputs.tags }}
          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
          labels: ${{ steps.meta-gifbox.outputs.labels }}

      # stoatchat/crond
@@ -188,7 +178,7 @@ jobs:
          file: crates/daemons/crond/Dockerfile
          tags: ${{ steps.meta-crond.outputs.tags }}
          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
          labels: ${{ steps.meta-crond.outputs.labels }}

      # stoatchat/pushd
@@ -207,7 +197,7 @@ jobs:
          file: crates/daemons/pushd/Dockerfile
          tags: ${{ steps.meta-pushd.outputs.tags }}
          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
          labels: ${{ steps.meta-pushd.outputs.labels }}

      # stoatchat/voice-ingress
@@ -226,5 +216,5 @@ jobs:
          file: crates/daemons/voice-ingress/Dockerfile
          tags: ${{ steps.meta-voice-ingress.outputs.tags }}
          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
          labels: ${{ steps.meta-voice-ingress.outputs.labels }}
--- a/.github/workflows/docs-test.yml
+++ b/.github/workflows/docs-test.yml
@@ -14,10 +14,16 @@ jobs:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
-
-      - name: Setup Mise
-        uses: immich-app/devtools/actions/use-mise@cd24790a7f5f6439ac32cc94f5523cb2de8bfa8c # use-mise-action-v1.1.0
+      - uses: pnpm/action-setup@v4
        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-        
-      - run: mise docs:build
+          package_json_file: ./docs/package.json
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+          cache: pnpm
+          cache-dependency-path: ./docs/pnpm-lock.yaml
+
+      - name: Install dependencies
+        run: pnpm install
+      - name: Test build website
+        run: pnpm run build
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -16,13 +16,19 @@ jobs:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
-
-      - name: Setup Mise
-        uses: immich-app/devtools/actions/use-mise@cd24790a7f5f6439ac32cc94f5523cb2de8bfa8c # use-mise-action-v1.1.0
+      - uses: pnpm/action-setup@v4
        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-        
-      - run: mise docs:build
+          package_json_file: ./docs/package.json
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+          cache: pnpm
+          cache-dependency-path: ./docs/pnpm-lock.yaml
+
+      - name: Install dependencies
+        run: pnpm install
+      - name: Build website
+        run: pnpm run build

      - name: Upload Build Artifact
        uses: actions/upload-pages-artifact@v3
--- a/.github/workflows/git-town.yml
+++ b/.github/workflows/git-town.yml
@@ -1,23 +0,0 @@
-# DO NOT EDIT DIRECTLY IN REPOSITORY
-# Managed in Terraform templates
-
-name: Git Town
-
-on:
-  pull_request:
-
-jobs:
-  git-town:
-    name: Display the branch stack
-    runs-on: ubuntu-slim
-
-    if: ${{ github.event.pull_request.head.repo.full_name == github.repository && !startsWith(github.head_ref, 'release-please--') }}
-
-    permissions:
-      contents: read
-      pull-requests: write
-
-    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-      - uses: stoatchat/action-git-town@4bc5c942e4603bffa0806b51d5fe5f0bc5deb0ac
-        continue-on-error: true
--- a/.github/workflows/publish-crates.yml
+++ b/.github/workflows/publish-crates.yml
@@ -1,26 +0,0 @@
-name: Publish Crates
-
-on:
-  workflow_dispatch:
-  release:
-    types: [published]
-
-jobs:
-  publish:
-    name: Publish Crates
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-        with:
-          persist-credentials: false
-
-      - name: Setup Mise
-        uses: immich-app/devtools/actions/use-mise@cd24790a7f5f6439ac32cc94f5523cb2de8bfa8c # use-mise-action-v1.1.0
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Publish
-        env:
-          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
-        run: mise publish --workspace
--- a/.github/workflows/release-please.yml
+++ b/.github/workflows/release-please.yml
@@ -1,63 +0,0 @@
-name: Release Please
-
-on:
-  push:
-    branches: [main] # updates/opens the release PR when commits land on main
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  pull-requests: write
-  id-token: write
-
-concurrency:
-  group: release-please
-  cancel-in-progress: true
-
-jobs:
-  release-please:
-    name: Release Please
-    runs-on: ubuntu-latest
-    outputs:
-      release_created: ${{ steps.rp.outputs.release_created }}
-      tag_name: ${{ steps.rp.outputs.tag_name }}
-    steps:
-      - id: app-token
-        uses: actions/create-github-app-token@v2
-        with:
-          app-id: ${{ secrets.GH_STOAT_RELEASE_APP_ID }}
-          private-key: ${{ secrets.GH_STOAT_RELEASE_APP_PRIVATE_KEY }}
-      - id: rp
-        uses: googleapis/release-please-action@v4
-        with:
-          token: ${{ steps.app-token.outputs.token }}
-          config-file: release-please-config.json
-
-      - name: Install latest stable
-        uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
-        with:
-          toolchain: stable
-
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-        with:
-          token: ${{ steps.app-token.outputs.token }}
-      - name: Update Cargo.lock
-        if: ${{ steps.rp.outputs.prs_created == 'true' || steps.rp.outputs.prs_updated == 'true' }}
-        env:
-          GH_TOKEN: ${{ steps.app-token.outputs.token }}
-          RP_PR_OUTPUT_JSON: ${{ steps.rp.outputs.prs }}
-        run: |
-          PR_NUMBER=$(echo "$RP_PR_OUTPUT_JSON" | jq -r '.[0].number')
-          gh pr checkout "$PR_NUMBER"
-          
-          cargo update -w
-          
-          if git diff --quiet Cargo.lock; then
-            echo "No changes to Cargo.lock"
-          else
-            git config user.name "github-actions[bot]"
-            git config user.email "github-actions[bot]@users.noreply.github.com"
-            git add Cargo.lock
-            git commit -s -m "chore: update Cargo.lock"
-            git push
-          fi
--- a/.github/workflows/release-webhook.yml
+++ b/.github/workflows/release-webhook.yml
@@ -1,26 +0,0 @@
-# DO NOT EDIT DIRECTLY IN REPOSITORY
-# Managed in Terraform templates
-
-name: Release Webhook
-
-on:
-  workflow_dispatch:
-  release:
-    types: [published]
-
-jobs:
-  release-webhook:
-    name: Send Release Webhook
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Send release notification webhook
-        env:
-          TAG_NAME: ${{ github.event.release.tag_name }}
-          REPOSITORY: ${{ github.repository }}
-          WEBHOOK_URL: ${{ secrets.STOAT_WEBHOOK_UPDATES_URL }}
-        run: |
-          RELEASE_URL="https://github.com/${REPOSITORY}/releases/tag/${TAG_NAME}"
-          curl -X POST "$WEBHOOK_URL" \
-            -H "Content-Type: application/json" \
-            -d "{\"content\": \"$RELEASE_URL\"}"
--- a/.github/workflows/rust.yaml
+++ b/.github/workflows/rust.yaml
@@ -5,8 +5,8 @@ on:
    branches: [main]
  pull_request:

-concurrency:
-  group: ${{ github.head_ref || github.ref }}
+concurrency: 
+  group: ${{ github.head_ref }}
  cancel-in-progress: true

 env:
@@ -15,56 +15,63 @@ env:
 jobs:
  check:
    name: Rust project
-    runs-on: arc-runner-set
+    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      - uses: actions/checkout@v2
+      - name: Free up disk space
+        run: |
+          sudo rm -rf /usr/local/lib/android /usr/share/dotnet /opt/ghc
+
+      - name: Install latest stable
+        uses: actions-rs/toolchain@v1
        with:
-          persist-credentials: false
-
-      # Using our own runners for now:
-      # - name: Free up disk space
-      #   run: |
-      #     sudo rm -rf /usr/local/lib/android /usr/share/dotnet /opt/ghc
-
-      - name: Setup Mise
-        uses: immich-app/devtools/actions/use-mise@cd24790a7f5f6439ac32cc94f5523cb2de8bfa8c # use-mise-action-v1.1.0
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
+      - name: Install cargo-nextest
+        uses: baptiste0928/cargo-install@v1
        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
+          crate: cargo-nextest
+          args: --locked

-      - run: mise build
-      - run: mise docker:start
-    
-      - name: Reference Test
+      - name: Run cargo build
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+
+      - name: Run services in background
+        run: |
+          docker compose -f compose.yml up -d
+
+      - name: Run cargo test
        env:
          TEST_DB: REFERENCE
-        continue-on-error: ${{ github.ref_name == 'main' }}
        run: |
-          mise test
+          cargo nextest run

-      - name: MongoDB Test
+      - name: Run cargo test (with MongoDB)
        env:
          TEST_DB: MONGODB
          MONGODB: mongodb://localhost
-        continue-on-error: ${{ github.ref_name == 'main' }}
        run: |
-          mise test
+          cargo nextest run

      - name: Start API in background
        if: github.event_name != 'pull_request' && github.ref_name == 'main'
        env:
          TEST_DB: REFERENCE
        run: |
-          mise build --bin revolt-delta && (mise service:api &)
+          cargo build --bin revolt-delta && (cargo run --bin revolt-delta &)

      - name: Wait for API to go up
        if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        uses: nev7n/wait_for_response@7fef3c1a6e8939d0b09062f14fec50d3c5d15fa1 # v1.0.1
+        uses: nev7n/wait_for_response@v1
        with:
          url: "http://localhost:14702/"

      - name: Checkout API repository
        if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v3
        with:
          repository: stoatchat/javascript-client-api
          path: api
@@ -76,10 +83,10 @@ jobs:

      - name: Commit changes
        if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        uses: EndBug/add-and-commit@a94899bca583c204427a224a7af87c02f9b325d5 # v9.1.4
+        uses: EndBug/add-and-commit@v4
        with:
          cwd: "api"
          add: "*.json"
-          author_name: Stoat CI
-          author_email: stoat-ci@users.noreply.github.com
+          author_name: Revolt CI
+          author_email: revolt-ci@users.noreply.github.com
          message: "chore: generate OpenAPI specification"
--- a/.github/workflows/validate-pr-title.yml
+++ b/.github/workflows/validate-pr-title.yml
@@ -1,6 +1,3 @@
-# DO NOT EDIT DIRECTLY IN REPOSITORY
-# Managed in Terraform templates
-
 name: "Lint PR"

 on:
@@ -18,6 +15,6 @@ jobs:
    permissions:
      pull-requests: read
    steps:
-      - uses: amannn/action-semantic-pull-request@48f256284bd46cdaab1048c3721360e808335d50 # v6.1.1
+      - uses: amannn/action-semantic-pull-request@v6
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.mise/config.toml
+++ b/.mise/config.toml
@@ -1,28 +0,0 @@
-[tools]
-node = "25.4.0"
-pnpm = "10.28.1"
-
-gh = "2.25.0"
-
-rust = "1.92.0"
-"cargo:cargo-nextest" = "0.9.122"
-
-"github:git-town/git-town" = "22.4.0"
-
-[settings]
-experimental = true
-idiomatic_version_file_enable_tools = ["rust"]
-
-[tasks.start]
-description = "Run all services"
-depends = ["docker:start", "build"]
-wait_for = ["docker:start", "build"]
-run = [{ task = "service:*" }]
-
-[env]
-BUILDER = "cargo"
-DOCKER_NETWORK_NAME = "stoatchat_default"
-DATABASE_PORT = "27017"
-RABBIT_PORT = "5672"
-REDIS_PORT = "6379"
-_.file = { path = ".env", tools = true }
--- a/.mise/tasks/build
+++ b/.mise/tasks/build
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Build project"
-set -e
-
-${BUILDER} build "$@"
--- a/.mise/tasks/check
+++ b/.mise/tasks/check
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Check project with clippy"
-set -e
-
-cargo clippy
--- a/.mise/tasks/docker/start
+++ b/.mise/tasks/docker/start
@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Start Docker containers"
-set -e
-
-docker compose up -d
-
-docker run \
--network=${DOCKER_NETWORK_NAME} \
--name wait \
--rm dokku/wait  -c \
-rabbit:${RABBIT_PORT},\
-database:${DATABASE_PORT},\
-redis:${REDIS_PORT}
--- a/.mise/tasks/docker/stop
+++ b/.mise/tasks/docker/stop
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Stop Docker containers"
-set -e
-
-docker compose down
--- a/.mise/tasks/docs/_default
+++ b/.mise/tasks/docs/_default
@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Start the Stoat Developers website"
-#MISE depends=["docs:install"]
-#MISE dir="{{config_root}}/docs"
-set -e
-
-pnpm build
--- a/.mise/tasks/docs/build
+++ b/.mise/tasks/docs/build
@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Build the Stoat Developers website"
-#MISE depends=["docs:install"]
-#MISE dir="{{config_root}}/docs"
-set -e
-
-pnpm build
--- a/.mise/tasks/docs/install
+++ b/.mise/tasks/docs/install
@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Install dependencies for docs site"
-#MISE dir="{{config_root}}/docs"
-set -e
-
-pnpm i --frozen-lockfile
--- a/.mise/tasks/publish
+++ b/.mise/tasks/publish
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Publish project"
-set -e
-
-cargo publish "$@"
--- a/.mise/tasks/service/api
+++ b/.mise/tasks/service/api
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run API server"
-set -e
-
-cargo run --bin revolt-delta
--- a/.mise/tasks/service/crond
+++ b/.mise/tasks/service/crond
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run cron daemon"
-set -e
-
-cargo run --bin revolt-crond
--- a/.mise/tasks/service/events
+++ b/.mise/tasks/service/events
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run events server"
-set -e
-
-cargo run --bin revolt-bonfire
--- a/.mise/tasks/service/files
+++ b/.mise/tasks/service/files
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run file server"
-set -e
-
-cargo run --bin revolt-autumn
--- a/.mise/tasks/service/gifbox
+++ b/.mise/tasks/service/gifbox
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run GIF proxy server"
-set -e
-
-cargo run --bin revolt-gifbox
--- a/.mise/tasks/service/proxy
+++ b/.mise/tasks/service/proxy
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run proxy server"
-set -e
-
-cargo run --bin revolt-january
--- a/.mise/tasks/service/pushd
+++ b/.mise/tasks/service/pushd
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run push daemon"
-set -e
-
-cargo run --bin revolt-pushd
--- a/.mise/tasks/test
+++ b/.mise/tasks/test
@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Test project"
-set -e
-
-: "${TEST_DB:=REFERENCE}"
-export TEST_DB
-
-cargo nextest run
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +0,0 @@
-{
-    ".": "0.13.7"
-}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,288 +0,0 @@
-# Changelog
-
-## [0.13.7](https://github.com/stoatchat/stoatchat/compare/v0.13.6...v0.13.7) (2026-05-21)
-
-
-### Bug Fixes
-
-* sanitize emoji input to handle variation selectors ([#774](https://github.com/stoatchat/stoatchat/issues/774)) ([2d308e0](https://github.com/stoatchat/stoatchat/commit/2d308e03d58c19f27b5b4d65dc2a15ef20b56190))
-* update mention count badge for channel acks ([#769](https://github.com/stoatchat/stoatchat/issues/769)) ([0d9ae50](https://github.com/stoatchat/stoatchat/commit/0d9ae508d9d2199f0e408b8ca634d20489be6f61))
-
-## [0.13.6](https://github.com/stoatchat/stoatchat/compare/v0.13.5...v0.13.6) (2026-05-18)
-
-
-### Features
-
-* Update FCM payload for android notifications ([#766](https://github.com/stoatchat/stoatchat/issues/766)) ([acbc087](https://github.com/stoatchat/stoatchat/commit/acbc087982e9aeb05cabc5ab4c9b1291f67490ad))
-* user slowmode events ([#760](https://github.com/stoatchat/stoatchat/issues/760)) ([af0d8aa](https://github.com/stoatchat/stoatchat/commit/af0d8aad14dc68d88159d0e1c714077d362e21e4))
-
-
-### Bug Fixes
-
-* include `minio` region as tests need it ([#761](https://github.com/stoatchat/stoatchat/issues/761)) ([298742d](https://github.com/stoatchat/stoatchat/commit/298742dbad4eafae356f976c56b9db23904b0c3a))
-* set env var for publishing crates ([#768](https://github.com/stoatchat/stoatchat/issues/768)) ([018afaf](https://github.com/stoatchat/stoatchat/commit/018afaf38f6330d92dad2a68b640c0cb3f6b639a))
-* Use proper headers to determine IP when not behind cloudflare ([#764](https://github.com/stoatchat/stoatchat/issues/764)) ([494c8b7](https://github.com/stoatchat/stoatchat/commit/494c8b7cabaae2a51039a7a5b559d5e2e5279554))
-* voice ingress crashing due to new Result in AMQP::new_auto() ([#765](https://github.com/stoatchat/stoatchat/issues/765)) ([2871632](https://github.com/stoatchat/stoatchat/commit/2871632382395cb20cbe0047c542d3ac31ff3f03))
-
-
-### Miscellaneous Chores
-
-* switch to lapin ([#767](https://github.com/stoatchat/stoatchat/issues/767)) ([5b19853](https://github.com/stoatchat/stoatchat/commit/5b1985381ae829a92c80a19e91a414cd9dc4de93))
-
-## [0.13.5](https://github.com/stoatchat/stoatchat/compare/v0.13.4...v0.13.5) (2026-05-17)
-
-
-### Bug Fixes
-
-* dont panic on hash missing when deleting files ([#755](https://github.com/stoatchat/stoatchat/issues/755)) ([c902077](https://github.com/stoatchat/stoatchat/commit/c902077cf51076fee11712eb732dc8a8f786fc4b))
-
-## [0.13.4](https://github.com/stoatchat/stoatchat/compare/v0.13.3...v0.13.4) (2026-05-16)
-
-
-### Bug Fixes
-
-* add TLS feature to livekit-api crate ([#753](https://github.com/stoatchat/stoatchat/issues/753)) ([6cfee1f](https://github.com/stoatchat/stoatchat/commit/6cfee1f601c1e084df7c8f1e7a5e8a560d1dd514))
-
-## [0.13.3](https://github.com/stoatchat/stoatchat/compare/v0.13.2...v0.13.3) (2026-05-15)
-
-
-### Bug Fixes
-
-* don't automatically set up rabbitmq in delta ([#749](https://github.com/stoatchat/stoatchat/issues/749)) ([7647cfc](https://github.com/stoatchat/stoatchat/commit/7647cfc8d93aba99f5faef13eb3d970097540d76))
-* don't declare queues which seem to cause the backend to crash in prod ([7647cfc](https://github.com/stoatchat/stoatchat/commit/7647cfc8d93aba99f5faef13eb3d970097540d76))
-
-## [0.13.2](https://github.com/stoatchat/stoatchat/compare/v0.13.1...v0.13.2) (2026-05-11)
-
-
-### Bug Fixes
-
-* update default exchange to `revolt.default` ([#746](https://github.com/stoatchat/stoatchat/issues/746)) ([fcb8091](https://github.com/stoatchat/stoatchat/commit/fcb8091cd7a00d7f26c798daa33aae4b923b2a8b))
-
-## [0.13.1](https://github.com/stoatchat/stoatchat/compare/v0.13.0...v0.13.1) (2026-05-10)
-
-
-### Bug Fixes
-
-* amqprs startup bug ([#744](https://github.com/stoatchat/stoatchat/issues/744)) ([1100eaf](https://github.com/stoatchat/stoatchat/commit/1100eaf46f849f2509ae01ac497556ca33bde778))
-
-## [0.13.0](https://github.com/stoatchat/stoatchat/compare/v0.12.1...v0.13.0) (2026-05-08)
-
-
-### Features
-
-* add embed support for YouTube Shorts ([#734](https://github.com/stoatchat/stoatchat/issues/734)) ([d46c7f7](https://github.com/stoatchat/stoatchat/commit/d46c7f7f3c04524c0639c3e0a122626f8e0b3bf7))
-* add emoji rename endpoint ([#714](https://github.com/stoatchat/stoatchat/issues/714)) ([23ad135](https://github.com/stoatchat/stoatchat/commit/23ad1359834bb7d07a460b8678d6a6ebffc73eb0))
-* add legal links to root payload ([#733](https://github.com/stoatchat/stoatchat/issues/733)) ([21d8201](https://github.com/stoatchat/stoatchat/commit/21d82018cf84ab0fdd10613d254b9562aea8eea3))
-* add role icon support ([#724](https://github.com/stoatchat/stoatchat/issues/724)) ([841985d](https://github.com/stoatchat/stoatchat/commit/841985d3b994df1c6eefab2fc7ecbd77ab22c493))
-* Add webhook endpoints for editing and deleting messages ([#682](https://github.com/stoatchat/stoatchat/issues/682)) ([6f3441c](https://github.com/stoatchat/stoatchat/commit/6f3441cf4acac2a8e6e1bf07a279a153b80f7956))
-* automatically sanitise usernames on create/update ([#689](https://github.com/stoatchat/stoatchat/issues/689)) ([e937697](https://github.com/stoatchat/stoatchat/commit/e93769786c7669485a659ee471630740d3cea702))
-* blacklist private ip ranges and add january domain blocklist ([#731](https://github.com/stoatchat/stoatchat/issues/731)) ([6b41db9](https://github.com/stoatchat/stoatchat/commit/6b41db984bb491b2e58324309cc70d8c14e0b814))
-* Rewrite acks ([#741](https://github.com/stoatchat/stoatchat/issues/741)) ([ab5bd47](https://github.com/stoatchat/stoatchat/commit/ab5bd47a39ee889de0b5ae6e7b560620853daead))
-
-
-### Bug Fixes
-
-* add new_user_hours to configuration limits ([#729](https://github.com/stoatchat/stoatchat/issues/729)) ([279f5d5](https://github.com/stoatchat/stoatchat/commit/279f5d5fd7af2df55902c706859ec07f569cdb1e))
-* add reconnection policy to Redis subscriber to prevent ghost state ([#708](https://github.com/stoatchat/stoatchat/issues/708)) ([057f2bb](https://github.com/stoatchat/stoatchat/commit/057f2bb8b359f8b942741a30ff54eeb8fbe3e0b1))
-* docker compose file had personal url in it ([#742](https://github.com/stoatchat/stoatchat/issues/742)) ([0719985](https://github.com/stoatchat/stoatchat/commit/0719985ac5636590f91e6f9ec4b68f3eded70c13))
-* don't strip ICC from exif ([#735](https://github.com/stoatchat/stoatchat/issues/735)) ([d76a711](https://github.com/stoatchat/stoatchat/commit/d76a71141f3e508f6308ba52fa28eaeb56fb3438))
-* dont send notification in fcm ([#721](https://github.com/stoatchat/stoatchat/issues/721)) ([89171e9](https://github.com/stoatchat/stoatchat/commit/89171e9bd0f15711157e78c6eec0fe7b480de93a))
-* encode filenames in redirects ([#737](https://github.com/stoatchat/stoatchat/issues/737)) ([9fd7128](https://github.com/stoatchat/stoatchat/commit/9fd7128f800badbd184baf943d4f799e601201e4))
-* january ip redirects & domain resolver ([#738](https://github.com/stoatchat/stoatchat/issues/738)) ([356491e](https://github.com/stoatchat/stoatchat/commit/356491e934b274f9e895df883dd63ef0b3123510))
-* update message length validation to remove upper limit ([#723](https://github.com/stoatchat/stoatchat/issues/723)) ([ed4fd5e](https://github.com/stoatchat/stoatchat/commit/ed4fd5ebfe6d0ea534a0898da4afdc1f4e2cd6c5))
-* use correct response for NoEffect errors ([#732](https://github.com/stoatchat/stoatchat/issues/732)) ([5378cd2](https://github.com/stoatchat/stoatchat/commit/5378cd22b4c7d85f44c31a6af0dda00941b80d5c))
-
-## [0.12.1](https://github.com/stoatchat/stoatchat/compare/v0.12.0...v0.12.1) (2026-04-10)
-
-
-### Bug Fixes
-
-* add migration to update existing files to be animated ([#705](https://github.com/stoatchat/stoatchat/issues/705)) ([f2c056a](https://github.com/stoatchat/stoatchat/commit/f2c056a1515be493b195f3f5db5886c2ddf36700))
-* don't send self dm notifications ([#706](https://github.com/stoatchat/stoatchat/issues/706)) ([f30b729](https://github.com/stoatchat/stoatchat/commit/f30b729ca90d0be6853c57ab4935694e5e59ae56))
-* mise start + missing docker image ([#564](https://github.com/stoatchat/stoatchat/issues/564)) ([fb8fe16](https://github.com/stoatchat/stoatchat/commit/fb8fe1655776791421284a6a093e86f0320c258a))
-* test failure due to wrong assertion ([#707](https://github.com/stoatchat/stoatchat/issues/707)) ([f81e329](https://github.com/stoatchat/stoatchat/commit/f81e3291bdd57af9ceedb2987b111acc7051d69c))
-
-## [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)
-
-
-### Bug Fixes
-
-* add separate config option for redis events replica url ([#590](https://github.com/stoatchat/stoatchat/issues/590)) ([a75e4ea](https://github.com/stoatchat/stoatchat/commit/a75e4eabfc4b34aba7620c82ba77558a32d9e10a))
-
-## [0.11.3](https://github.com/stoatchat/stoatchat/compare/v0.11.2...v0.11.3) (2026-02-13)
-
-
-### Bug Fixes
-
-* cut presence traffic too while we engineer a new events architecture ([#561](https://github.com/stoatchat/stoatchat/issues/561)) ([1f8ea96](https://github.com/stoatchat/stoatchat/commit/1f8ea963ad742f693f405e6438f1c343c81e6579))
-
-## [0.11.2](https://github.com/stoatchat/stoatchat/compare/v0.11.1...v0.11.2) (2026-02-13)
-
-
-### Bug Fixes
-
-* cut events traffic while we engineer a new events architecture ([#559](https://github.com/stoatchat/stoatchat/issues/559)) ([a11986b](https://github.com/stoatchat/stoatchat/commit/a11986ba1ad16b672ff1080913a684567d88adbb))
-
-## [0.11.1](https://github.com/stoatchat/stoatchat/compare/v0.11.0...v0.11.1) (2026-02-13)
-
-
-### Bug Fixes
-
-* bots in multiple voice channel logic ([#544](https://github.com/stoatchat/stoatchat/issues/544)) ([94cb916](https://github.com/stoatchat/stoatchat/commit/94cb916231b9b8befb2e94065917ff40815bec52))
-
-## [0.11.0](https://github.com/stoatchat/stoatchat/compare/v0.10.3...v0.11.0) (2026-02-10)
-
-
-### Features
-
-* appeal to the almighty Spamhaus ([#524](https://github.com/stoatchat/stoatchat/issues/524)) ([5132270](https://github.com/stoatchat/stoatchat/commit/5132270f2edd6df25ce414daa42ed1b2aa6fa7a9))
-
-## [0.10.3](https://github.com/stoatchat/stoatchat/compare/v0.10.2...v0.10.3) (2026-02-07)
-
-
-### Bug Fixes
-
-* update `Revolt` -&gt; `Stoat` in email titles/desc. ([#508](https://github.com/stoatchat/stoatchat/issues/508)) ([84483ce](https://github.com/stoatchat/stoatchat/commit/84483cee7af3e5dfa16f7fe13e334c4d9f5abd60))
-
-## [0.10.2](https://github.com/stoatchat/stoatchat/compare/v0.10.1...v0.10.2) (2026-01-25)
-
-
-### Bug Fixes
-
-* thumbnailification requires rgb8/rgba8 ([#505](https://github.com/stoatchat/stoatchat/issues/505)) ([413aa04](https://github.com/stoatchat/stoatchat/commit/413aa04dcaf8bff3935ed1e5f31432e11a03ce6f))
-
-## [0.10.1](https://github.com/stoatchat/stoatchat/compare/v0.10.0...v0.10.1) (2026-01-25)
-
-
-### Bug Fixes
-
-* use Rust 1.92.0 for Docker build ([#503](https://github.com/stoatchat/stoatchat/issues/503)) ([98da8a2](https://github.com/stoatchat/stoatchat/commit/98da8a28a0aa2fee4e8eee1d86bd7c49e3187477))
-
-## [0.10.0](https://github.com/stoatchat/stoatchat/compare/v0.9.4...v0.10.0) (2026-01-25)
-
-
-### Features
-
-* allow kicking members from voice channels ([#495](https://github.com/stoatchat/stoatchat/issues/495)) ([0dc5442](https://github.com/stoatchat/stoatchat/commit/0dc544249825a49c793309edee5ec1838458a6da))
-* repository architecture for files crate w. added tests ([#498](https://github.com/stoatchat/stoatchat/issues/498)) ([01ded20](https://github.com/stoatchat/stoatchat/commit/01ded209c62208fc906d6aab9b08c04e860e10ef))
-
-
-### Bug Fixes
-
-* expose ratelimit headers via cors ([#496](https://github.com/stoatchat/stoatchat/issues/496)) ([a1a2125](https://github.com/stoatchat/stoatchat/commit/a1a21252d0ad58937e41f16e5fb86f96bebd2a51))
-
-## [0.9.4](https://github.com/stoatchat/stoatchat/compare/v0.9.3...v0.9.4) (2026-01-10)
-
-
-### Bug Fixes
-
-* checkout repo. before bumping lock ([#490](https://github.com/stoatchat/stoatchat/issues/490)) ([b2da2a8](https://github.com/stoatchat/stoatchat/commit/b2da2a858787853be43136fd526a0bd72baf78ef))
-* persist credentials for git repo ([#492](https://github.com/stoatchat/stoatchat/issues/492)) ([c674a9f](https://github.com/stoatchat/stoatchat/commit/c674a9fd4e0abbd51569870e4b38074d4a1de03c))
-
-## [0.9.3](https://github.com/stoatchat/stoatchat/compare/v0.9.2...v0.9.3) (2026-01-10)
-
-
-### Bug Fixes
-
-* pipeline fixes ([#487](https://github.com/stoatchat/stoatchat/issues/487)) ([aeeafeb](https://github.com/stoatchat/stoatchat/commit/aeeafebefc36a43a656cf797c9251ca50292733c))
-
-## [0.9.2](https://github.com/stoatchat/stoatchat/compare/v0.9.1...v0.9.2) (2026-01-10)
-
-
-### Bug Fixes
-
-* disable publish for services ([#485](https://github.com/stoatchat/stoatchat/issues/485)) ([d13609c](https://github.com/stoatchat/stoatchat/commit/d13609c37279d6a40445dcd99564e5c3dd03bac1))
-
-## [0.9.1](https://github.com/stoatchat/stoatchat/compare/v0.9.0...v0.9.1) (2026-01-10)
-
-
-### Bug Fixes
-
-* **ci:** pipeline fixes (marked as fix to force release) ([#483](https://github.com/stoatchat/stoatchat/issues/483)) ([303e52b](https://github.com/stoatchat/stoatchat/commit/303e52b476585eea81c33837f1b01506ce387684))
-
-## [0.9.0](https://github.com/stoatchat/stoatchat/compare/v0.8.8...v0.9.0) (2026-01-10)
-
-
-### Features
-
-* add id field to role ([#470](https://github.com/stoatchat/stoatchat/issues/470)) ([2afea56](https://github.com/stoatchat/stoatchat/commit/2afea56e56017f02de98e67316b4457568ad5b26))
-* add ratelimits to gifbox ([1542047](https://github.com/stoatchat/stoatchat/commit/154204742d21cbeff6e2577b00f50b495ea44631))
-* include groups and dms in fetch mutuals ([caa8607](https://github.com/stoatchat/stoatchat/commit/caa86074680d46223cebc20f41e9c91c41ec825d))
-* include member payload in ServerMemberJoin event ([480f210](https://github.com/stoatchat/stoatchat/commit/480f210ce85271e13d1dac58a5dae08de108579d))
-* initial work on tenor gif searching ([b0c977b](https://github.com/stoatchat/stoatchat/commit/b0c977b324b8144c1152589546eb8fec5954c3e7))
-* make message lexer use unowned string ([1561481](https://github.com/stoatchat/stoatchat/commit/1561481eb4cdc0f385fbf0a81e4950408050e11f))
-* ready payload field customisation ([db57706](https://github.com/stoatchat/stoatchat/commit/db577067948f13e830b5fb773034e9713a1abaff))
-* require auth for search ([b5cd5e3](https://github.com/stoatchat/stoatchat/commit/b5cd5e30ef7d5e56e8964fb7c543965fa6bf5a4a))
-* trending and categories routes ([5885e06](https://github.com/stoatchat/stoatchat/commit/5885e067a627b8fff1c8ce2bf9e852ff8cf3f07a))
-* voice chats v2 ([#414](https://github.com/stoatchat/stoatchat/issues/414)) ([d567155](https://github.com/stoatchat/stoatchat/commit/d567155f124e4da74115b1a8f810062f7c6559d9))
-
-
-### Bug Fixes
-
-* add license to revolt-parser ([5335124](https://github.com/stoatchat/stoatchat/commit/53351243064cac8d499dd74284be73928fa78a43))
-* allow for disabling default features ([65fbd36](https://github.com/stoatchat/stoatchat/commit/65fbd3662462aed1333b79e59155fa6377e83fcc))
-* apple music to use original url instead of metadata url ([bfe4018](https://github.com/stoatchat/stoatchat/commit/bfe4018e436a4075bae780dd4d35a9b58315e12f))
-* apply uname fix to january and autumn ([8f9015a](https://github.com/stoatchat/stoatchat/commit/8f9015a6ff181d208d9269ab8691bd417d39811a))
-* **ci:** publish images under stoatchat and remove docker hub ([d65c1a1](https://github.com/stoatchat/stoatchat/commit/d65c1a1ab3bdc7e5684b03f280af77d881661a3d))
-* correct miniz_oxide in lockfile ([#478](https://github.com/stoatchat/stoatchat/issues/478)) ([5d27a91](https://github.com/stoatchat/stoatchat/commit/5d27a91e901dd2ea3e860aeaed8468db6c5f3214))
-* correct shebang for try-tag-and-release ([050ba16](https://github.com/stoatchat/stoatchat/commit/050ba16d4adad5d0fb247867aa3e94e3d42bd12d))
-* correct string_cache in lockfile ([#479](https://github.com/stoatchat/stoatchat/issues/479)) ([0b178fc](https://github.com/stoatchat/stoatchat/commit/0b178fc791583064bf9ca94b1d39b42d021e1d79))
-* don't remove timeouts when a member leaves a server ([#409](https://github.com/stoatchat/stoatchat/issues/409)) ([e635bc2](https://github.com/stoatchat/stoatchat/commit/e635bc23ec857d648d5705e1a3875d7bc3402b0d))
-* don't update the same field while trying to remove it ([f4ee35f](https://github.com/stoatchat/stoatchat/commit/f4ee35fb093ca49f0a64ff4b17fd61587df28145)), closes [#392](https://github.com/stoatchat/stoatchat/issues/392)
-* github webhook incorrect payload and formatting ([#468](https://github.com/stoatchat/stoatchat/issues/468)) ([dc9c82a](https://github.com/stoatchat/stoatchat/commit/dc9c82aa4e9667ea6639256c65ac8de37a24d1f7))
-* implement Serialize to ClientMessage ([dea0f67](https://github.com/stoatchat/stoatchat/commit/dea0f675dde7a63c7a59b38d469f878b7a8a3af4))
-* newly created roles should be ranked the lowest ([947eb15](https://github.com/stoatchat/stoatchat/commit/947eb15771ed6785b3dcd16c354c03ded5e4cbe0))
-* permit empty `remove` array in edit requests ([6ad3da5](https://github.com/stoatchat/stoatchat/commit/6ad3da5f35f989a2e7d8e29718b98374248e76af))
-* preserve order of replies in message ([#447](https://github.com/stoatchat/stoatchat/issues/447)) ([657a3f0](https://github.com/stoatchat/stoatchat/commit/657a3f08e5d652814bbf0647e089ed9ebb139bbf))
-* prevent timing out members which have TimeoutMembers permission ([e36fc97](https://github.com/stoatchat/stoatchat/commit/e36fc9738bac0de4f3fcbccba521f1e3754f7ae7))
-* relax settings name regex ([3a34159](https://github.com/stoatchat/stoatchat/commit/3a3415915f0d0fdce1499d47a2b7fa097f5946ea))
-* remove authentication tag bytes from attachment download ([32e6600](https://github.com/stoatchat/stoatchat/commit/32e6600272b885c595c094f0bc69459250220dcb))
-* rename openapi operation ids ([6048587](https://github.com/stoatchat/stoatchat/commit/6048587d348fbca0dc3a9b47690c56df8fece576)), closes [#406](https://github.com/stoatchat/stoatchat/issues/406)
-* respond with 201 if no body in requests ([#465](https://github.com/stoatchat/stoatchat/issues/465)) ([24fedf8](https://github.com/stoatchat/stoatchat/commit/24fedf8c4d9cd3160bdec97aa451520f8beaa739))
-* swap to using reqwest for query building ([38dd4d1](https://github.com/stoatchat/stoatchat/commit/38dd4d10797b3e6e397fc219e818f379bdff19f2))
-* use `trust_cloudflare` config value instead of env var ([cc7a796](https://github.com/stoatchat/stoatchat/commit/cc7a7962a882e1627fcd0bc75858a017415e8cfc))
-* use our own result types instead of tenors types ([a92152d](https://github.com/stoatchat/stoatchat/commit/a92152d86da136997817e797c7af8e38731cdde8))
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace]
-resolver = "3"
+resolver = "2"

 members = [
    "crates/delta",
@@ -11,193 +11,13 @@ members = [

 [patch.crates-io]
 redis23 = { package = "redis", version = "0.23.3", git = "https://github.com/revoltchat/redis-rs", rev = "523b2937367e17bd0073722bf6e23d06042cb4e4" }
-#authifier = { package = "authifier", version = "1.0.10", path = "../authifier/crates/authifier" }
-#rocket_authifier = { package = "rocket_authifier", version = "1.0.10", path = "../authifier/crates/rocket_authifier" }
+authifier = { package = "authifier", version = "1.0.10", path = "../authifier/crates/authifier" }
+rocket_authifier = { package = "rocket_authifier", version = "1.0.10", path = "../authifier/crates/rocket_authifier" }
+iso8601-timestamp = { path = "../iso8601-timestamp" }

+# I'm 99% sure this is overloading the GitHub worker
+# hence builds have been failing since, let's just
+# disable it for now. In the future, we could use this
+# if we were rolling our own CI (that is now).
 [profile.release]
 lto = true
-
-[workspace.dependencies]
-# Async
-async-trait = "0.1.89"
-tokio = "1.49.0"
-async-channel = "2.3.1"
-futures = "0.3.32"
-async-std = "1.8.0"
-async-tungstenite = "0.17.0"
-futures-locks = "0.7.1"
-async-lock = "2.8.0"
-async-recursion = "1.0.4"
-
-# Error Handling
-anyhow = "1.0.100"
-thiserror = "2.0.18"
-sentry = "0.31.5"
-sentry-anyhow = "0.38.1"
-
-# Data Validation
-regex = "1.12.3"
-validator = "0.16"
-
-# Data Types
-uuid = "1.19.0"
-ulid = "1.2.1"
-nanoid = "0.4.0"
-typenum = "1.17.0"
-num_enum = "0.6.1"
-bitfield = "0.13.2"
-
-# Time
-chrono = "0.4.15"
-iso8601-timestamp = "0.2.10"
-
-# Data Collections
-lru = "0.16.3"
-indexmap = "2.13.1"
-dashmap = "5.2.0"
-moka = "0.12.8"
-lru_time_cache = "0.11.11"
-deadqueue = "0.2.4"
-
-# Web scraping
-scraper = "0.20.0"
-encoding_rs = "0.8.34"
-
-# Mail
-lettre = "0.10.0-alpha.4"
-
-# HTTP Requests
-reqwest = "0.13.2"
-isahc = "1.7"
-
-# Notifications
-fcm_v1 = "0.3.0"
-web-push = "0.10.0"
-revolt_a2 = "0.10"
-
-# Parsing
-logos = "0.15"
-
-# SVG rendering
-usvg = "0.44.0"
-resvg = "0.44.0"
-tiny-skia = "0.11.4"
-
-# Logging
-log = "0.4.29"
-pretty_env_logger = "0.4.0"
-
-# Redis
-redis-kiss = "0.1.4"
-fred = "8.0.1"
-
-# Serialisation
-bincode = "1.3.3"
-serde_json = "1.0.79"
-rmp-serde = "1.0.0"
-serde = { version = "1", features = ["derive"] }
-strum_macros = "0.26.4"
-
-# MongoDB
-bson = { version = "2.1.0" }
-mongodb = { version = "3.1.0" }
-
-# S3
-aws-config = "1.5.5"
-aws-sdk-s3 = "1.46.0"
-
-# Axum (HTTP server)
-axum-macros = "0.4.1"
-axum_typed_multipart = "0.12.1"
-axum = "0.7.5"
-axum-extra = "0.9"
-tower-http = "0.5.2"
-
-# Rocket (HTTP server)
-rocket = "0.5.1"
-rocket_empty = "0.1.1"
-revolt_rocket_okapi = "0.10.0"
-rocket_cors = { git = "https://github.com/lawliet89/rocket_cors", rev = "072d90359b23e9b291df6b672c07c93de9c46011" }
-rocket_authifier = "1.0.16"
-rocket_prometheus = "0.10.0-rc.3"
-
-# Spec Generation
-utoipa = "4.2.3"
-revolt_okapi = "0.9.1"
-schemars = "0.8.8"
-utoipa-scalar = "0.1.0"
-
-# Image Processing
-jxl-oxide = "0.12.5"
-sha2 = "0.10.8"
-kamadak-exif = "0.5.4"
-webp = "0.3.0"
-image = "0.25.2"  # avif encode requires dav1d system library: features = ["avif-native"]
-thumbhash = "0.1.0"
-lcms2 = "6.1.1" # for color profile processing
-
-# File processing
-revolt_clamav-client = "0.1.5"
-simdutf8 = "0.1.4"
-
-# Content type processing
-infer = "0.16.0"
-ffprobe = "0.4.0"
-imagesize = "0.13.0"
-
-# OpenTelemetry
-tracing = "0.1.44"
-tracing-subscriber = { version = "0.3.22", features = [
-    "env-filter",
-] } # consider https://crates.io/crates/better-tracing
-opentelemetry = { version = "0.31.0", features = ["logs"] }
-opentelemetry_sdk = { version = "0.31.0", features = ["logs"] }
-opentelemetry-otlp = { version = "0.31.0", features = ["logs"] }
-opentelemetry-appender-tracing = "0.31.1"
-
-# Authifier
-authifier = "1.0.16"
-
-# RabbitMQ
-lapin = "4.7.1"
-
-# Voice
-livekit-api = "0.4.4"
-livekit-protocol = "0.7.4"
-livekit-runtime = "0.4.0"
-
-# Other Utilities
-once_cell = "1.9.0"
-config = "0.13.3"
-cached = "0.44.0"
-rand = "0.8.5"
-base64 = "0.21.3"
-decancer = "3.3.3"
-linkify = "0.8.1"
-url-escape = "0.1.1"
-revolt_optional_struct = "0.2.0"
-unicode-segmentation = "1.10.1"
-querystring = "1.1.0"
-tempfile = "3.12.0"
-aes-gcm = "0.10.3"
-auto_ops = "0.3.0"
-url = "2.2.2"
-impl_ops = "0.1.1"
-lazy_static = "1.5.0"
-mime = "0.3.17"
-futures-lite = "2.6.1"
-
-# Build Dependencies
-vergen = "7.5.0"
-
-# Local packages
-revolt-coalesced = { version = "0.13.7", path = "crates/core/coalesced" }
-revolt-config = { version = "0.13.7", path = "crates/core/config" }
-revolt-database = { version = "0.13.7", path = "crates/core/database" }
-revolt-files = { version = "0.13.7", path = "crates/core/files" }
-revolt-models = { version = "0.13.7", path = "crates/core/models" }
-revolt-parser = { version = "0.13.7", path = "crates/core/parser" }
-revolt-permissions = { version = "0.13.7", path = "crates/core/permissions" }
-revolt-presence = { version = "0.13.7", path = "crates/core/presence" }
-revolt-ratelimits = { version = "0.13.7", path = "crates/core/ratelimits" }
-revolt-result = { version = "0.13.7", path = "crates/core/result" }
--- a/2
+++ b/2
@@ -1,5 +1,5 @@
 # Build Stage
-FROM --platform="${BUILDPLATFORM}" rust:1.92.0-slim-bookworm
+FROM --platform="${BUILDPLATFORM}" rust:1.86.0-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src

--- a/Dockerfile.useCurrentArch
+++ b/Dockerfile.useCurrentArch
@@ -1,5 +1,5 @@
 # Build Stage
-FROM rust:1.92.0-slim-bookworm
+FROM rust:1.86.0-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src

--- a/README.md
+++ b/README.md
@@ -1,15 +1,15 @@
 <div align="center">
 <h1>
-  Stoat Backend
+  Revolt Backend
  
-  [![Stars](https://img.shields.io/github/stars/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/stargazers)
-  [![Forks](https://img.shields.io/github/forks/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/network/members)
-  [![Pull Requests](https://img.shields.io/github/issues-pr/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/pulls)
-  [![Issues](https://img.shields.io/github/issues/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/issues)
-  [![Contributors](https://img.shields.io/github/contributors/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/graphs/contributors)
-  [![License](https://img.shields.io/github/license/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/blob/main/LICENSE)
+  [![Stars](https://img.shields.io/github/stars/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/stargazers)
+  [![Forks](https://img.shields.io/github/forks/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/network/members)
+  [![Pull Requests](https://img.shields.io/github/issues-pr/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/pulls)
+  [![Issues](https://img.shields.io/github/issues/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/issues)
+  [![Contributors](https://img.shields.io/github/contributors/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/graphs/contributors)
+  [![License](https://img.shields.io/github/license/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/blob/main/LICENSE)
 </h1>
-The services and libraries that power the Stoat service.<br/>
+The services and libraries that power the Revolt service.<br/>
 <br/>

 | Crate              | Path                                               | Description                         |                                                                                                                                                                                                                                                                                                           |
@@ -37,19 +37,22 @@ The services and libraries that power the Stoat service.<br/>

 Rust 1.86.0 or higher.

+> [!CAUTION]
+> The events server has a significant performance regression between Rust 1.77.2 and 1.78.0 onwards, see [issue #341](https://github.com/revoltchat/backend/issues/341). This is currently solved by build time options but we are looking for a proper fix.
+
 ## Development Guide

-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 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 getting started, you'll want to install:

- mise
+- Rust toolchain (rustup recommended)
 - Docker
 - Git
 - mold (optional, faster compilation)

 > A **default.nix** is available for Nix users!
-> Run `nix-shell` to activate mise.
+> Just run `nix-shell` and continue.

 As a heads-up, the development environment uses the following ports:

@@ -70,20 +73,11 @@ 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/stoatchat/stoatchat stoat-backend
-cd stoat-backend
-mise install
-mise build
+git clone https://github.com/revoltchat/backend revolt-backend
+cd revolt-backend
+cargo build
 ```

-> [!TIP]
-> You can override `BUILDER` in your `.env` file to run cargo with mold if you installed it:
->
-> ```bash
-> # .env
-> BUILDER = "mold --run cargo"
-> ```
-
 A default configuration `Revolt.toml` is present in this project that is suited for development.

 If you'd like to change anything, create a `Revolt.overrides.toml` file and specify relevant variables.
@@ -120,7 +114,7 @@ If you'd like to change anything, create a `Revolt.overrides.toml` file and spec
 >       - "14672:15672"
 > ```
 >
-> With the corresponding Revolt configuration:
+> And corresponding Revolt configuration:
 >
 > ```toml
 > #     Revolt.overrides.toml
@@ -132,41 +126,53 @@ If you'd like to change anything, create a `Revolt.overrides.toml` file and spec
 > [rabbit]
 > port = 14072
 > ```
->
-> And mise configuration
->
-> ```bash
-> #.env
-> DATABASE_PORT = "14017"
-> RABBIT_PORT = "14072"
-> REDIS_PORT = "14079"
-> ```

 Then continue:

 ```bash
-cp livekit.example.yml livekit.yml
+# start other necessary services
+docker compose up -d

-mise start
+# run everything together
+./scripts/start.sh
+# .. or individually
+# run the API server
+cargo run --bin revolt-delta
+# run the events server
+cargo run --bin revolt-bonfire
+# run the file server
+cargo run --bin revolt-autumn
+# run the proxy server
+cargo run --bin revolt-january
+# run the tenor proxy
+cargo run --bin revolt-gifbox
+# run the push daemon (not usually needed in regular development)
+cargo run --bin revolt-pushd
+
+# hint:
+# mold -run <cargo build, cargo run, etc...>
+# mold -run ./scripts/start.sh
 ```

-You can start a web client by doing the following in another terminal:
+You can start a web client by doing the following:

 ```bash
 # if you do not have yarn yet and have a modern Node.js:
 corepack enable

 # clone the web client and run it:
-git clone --recursive https://github.com/stoatchat/for-web stoat-web
-cd stoat-web
-# refer to stoat-web/README.md for startup, creating an account and loging in
+git clone --recursive https://github.com/revoltchat/revite
+cd revite
+yarn
+yarn build:deps
+echo "VITE_API_URL=http://local.revolt.chat:14702" > .env.local
+yarn dev --port 14701
 ```

+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.

-To stop all services, hit (CTRL + c) in the terminal you ran `mise start` and run `mise docker:stop`
-
-
 ## Deployment Guide

 ### Cutting new crate releases
@@ -195,14 +201,14 @@ Tag and push a new release by running:
 just release
 ```

-If you have bumped the crate versions, proceed to [GitHub releases](https://github.com/stoatchat/stoatchat/releases/new) to create a changelog.
+If you have bumped the crate versions, proceed to [GitHub releases](https://github.com/revoltchat/backend/releases/new) to create a changelog.

 ## Testing

 First, start the required services:

 ```sh
-docker compose up -d
+docker compose -f docker-compose.db.yml up -d
 ```

 Now run tests for whichever database:
@@ -214,6 +220,6 @@ TEST_DB=MONGODB cargo nextest run

 ## License

-The Stoat backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/stoatchat/stoatchat/blob/main/LICENSE).
+The Revolt backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/revoltchat/backend/blob/master/LICENSE).

 **Individual crates may supply their own licenses!**
--- a/Revolt.toml
+++ b/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/stoatchat/self-hosted/blob/main/Caddyfile
+# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
 #
 # Remember to change these to https/wss where appropriate in production!
 app = "http://local.revolt.chat:14701"
--- a/compose.yml
+++ b/compose.yml
@@ -8,33 +8,18 @@ services:
  # MongoDB
  database:
    image: mongo
-    command: mongod --replSet rs0
    ports:
      - "27017:27017"
    volumes:
      - ./.data/db:/data/db
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-    healthcheck:
-      test: echo "try { rs.status() } catch (err) { rs.initiate({_id:'rs0',members:[{_id:0,host:'127.0.0.1:27017'}]}) }" | mongosh --port 27017 --quiet
-      interval: 5s
-      timeout: 30s
-      start_period: 0s
-      start_interval: 1s
-      retries: 30
-    ulimits:
-      nofile:
-        soft: 65536
-        hard: 65536

  # MinIO
  minio:
-    image: firstfinger/minio:latest
-    #command: server /data
+    image: minio/minio
+    command: server /data
    environment:
      MINIO_ROOT_USER: minioautumn
      MINIO_ROOT_PASSWORD: minioautumn
-      MINIO_REGION: minio
    volumes:
      - ./.data/minio:/data
    ports:
@@ -70,7 +55,7 @@ services:

  # Mock SMTP server
  maildev:
-    image: maildev/maildev
+    image: soulteary/maildev
    ports:
      - "14025:25"
      - "14080:8080"
@@ -81,8 +66,8 @@ services:
      MAILDEV_INCOMING_PASS: smtp

  livekit:
-    image: ghcr.io/stoatchat/livekit-server:v1.9.13
+    image: ghcr.io/stoatchat/livekit-server:v1.9.9
    command: --config /etc/livekit.yml
    network_mode: "host"
    volumes:
-      - ./livekit.yml:/etc/livekit.yml
+      - ./livekit.yml:/etc/livekit.yml
--- a/crates/bonfire/Cargo.toml
+++ b/crates/bonfire/Cargo.toml
@@ -1,46 +1,49 @@
 [package]
 name = "revolt-bonfire"
-version = "0.13.7"
+version = "0.8.9"
 license = "AGPL-3.0-or-later"
 edition = "2021"
-publish = false

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
 # util
-log = { workspace = true }
-sentry = { workspace = true }
-lru = { workspace = true }
-ulid = { workspace = true }
-once_cell = { workspace = true }
-redis-kiss = { workspace = true }
-lru_time_cache = { workspace = true }
-async-channel = { workspace = true }
+log = "*"
+sentry = "0.31.5"
+lru = "0.7.6"
+ulid = "0.5.0"
+once_cell = "1.9.0"
+redis-kiss = "0.1.4"
+lru_time_cache = "0.11.11"
+async-channel = "2.3.1"

 # parsing
-querystring = { workspace = true }
-regex = { workspace = true }
+querystring = "1.1.0"
+regex = "1.11.1"

 # serde
-bincode = { workspace = true }
-serde_json = { workspace = true }
-rmp-serde = { workspace = true }
-serde = { workspace = true }
+bincode = "1.3.3"
+serde_json = "1.0.79"
+rmp-serde = "1.0.0"
+serde = "1.0.136"

 # async
-futures = { workspace = true }
-async-tungstenite = { workspace = true, features = ["async-std-runtime"] }
-async-std = { workspace = true }
+futures = "0.3.21"
+async-tungstenite = { version = "0.17.0", features = ["async-std-runtime"] }
+async-std = { version = "1.8.0", features = [
+    "tokio1",
+    "tokio02",
+    "attributes",
+] }

 # core
-authifier = { workspace = true }
-revolt-result = { workspace = true }
-revolt-models = { workspace = true }
-revolt-config = { workspace = true }
-revolt-database = { workspace = true, features = ["voice"] }
-revolt-permissions = { workspace = true }
-revolt-presence = { workspace = true, features = ["redis-is-patched"] }
+authifier = { version = "1.0.15" }
+revolt-result = { path = "../core/result" }
+revolt-models = { path = "../core/models" }
+revolt-config = { path = "../core/config" }
+revolt-database = { path = "../core/database", features = ["voice"] }
+revolt-permissions = { version = "0.8.9", path = "../core/permissions" }
+revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }

 # redis
-fred = { workspace = true, features = ["subscriber-client"] }
+fred = { version = "8.0.1", features = ["subscriber-client"] }
--- a/crates/bonfire/src/events/impl.rs
+++ b/crates/bonfire/src/events/impl.rs
@@ -1,11 +1,10 @@
 use std::collections::{HashMap, HashSet};

 use futures::future::join_all;
-use redis_kiss::AsyncCommands;
 use revolt_database::{
    events::client::{EventV1, ReadyPayloadFields},
    util::permissions::DatabasePermissionQuery,
-    voice::{get_channel_voice_state, UserVoiceChannel},
+    voice::get_channel_voice_state,
    Channel, Database, Member, MemberCompositeKey, Presence, RelationshipStatus,
 };
 use revolt_models::v0;
@@ -168,13 +167,9 @@ impl State {
                        | Channel::TextChannel { voice: Some(_), .. }
                )
            }) {
-                if let Ok(Some(voice_state)) =
-                    get_channel_voice_state(&UserVoiceChannel::from_channel(channel)).await
-                {
+                if let Ok(Some(voice_state)) = get_channel_voice_state(channel).await {
                    if let Some(server) = channel.server() {
-                        let set = voice_state_server_members
-                            .entry(server.to_string())
-                            .or_default();
+                        let set = voice_state_server_members.entry(server.to_string()).or_default();

                        for participant in &voice_state.participants {
                            user_ids.insert(participant.id.clone());
@@ -402,11 +397,6 @@ impl State {

    /// Push presence change to the user and all associated server topics
    pub async fn broadcast_presence_change(&self, target: bool) {
-        let config = revolt_config::config().await;
-        if config.disable_events_dont_use {
-            return;
-        }
-
        if if let Some(status) = &self.cache.users.get(&self.cache.user_id).unwrap().status {
            status.presence != Some(Presence::Invisible)
        } else {
--- a/crates/bonfire/src/events/state.rs
+++ b/crates/bonfire/src/events/state.rs
@@ -1,5 +1,7 @@
 use std::{
-    collections::{HashMap, HashSet}, num::NonZeroUsize, sync::Arc, time::Duration
+    collections::{HashMap, HashSet},
+    sync::Arc,
+    time::Duration,
 };

 use async_std::sync::{Mutex, RwLock};
@@ -55,7 +57,7 @@ impl Default for Cache {
            members: Default::default(),
            servers: Default::default(),

-            seen_events: LruCache::new(NonZeroUsize::new(20).unwrap()),
+            seen_events: LruCache::new(20),
        }
    }
 }
--- a/crates/bonfire/src/websocket.rs
+++ b/crates/bonfire/src/websocket.rs
@@ -5,7 +5,7 @@ use authifier::AuthifierEvent;
 use fred::{
    error::RedisErrorKind,
    interfaces::{ClientLike, EventInterface, PubsubInterface},
-    types::{ReconnectPolicy, RedisConfig},
+    types::RedisConfig,
 };
 use futures::{
    channel::oneshot,
@@ -13,7 +13,7 @@ use futures::{
    stream::{SplitSink, SplitStream},
    FutureExt, SinkExt, StreamExt, TryStreamExt,
 };
-use redis_kiss::{get_connection, AsyncCommands, PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
+use redis_kiss::{PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
 use revolt_config::report_internal_error;
 use revolt_database::{
    events::{client::EventV1, server::ClientMessage},
@@ -32,7 +32,6 @@ use sentry::Level;

 use crate::config::{ProtocolConfiguration, WebsocketHandshakeCallback};
 use crate::events::state::{State, SubscriptionStateChange};
-use revolt_models::v0;

 type WsReader = SplitStream<WebSocketStream<TcpStream>>;
 type WsWriter = SplitSink<WebSocketStream<TcpStream>, async_tungstenite::tungstenite::Message>;
@@ -129,14 +128,6 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
        return;
    }

-    let slowmodes = fetch_user_slowmodes(&user_id).await.unwrap_or_default();
-    if !slowmodes.is_empty() {
-        let event = EventV1::UserSlowmodes { slowmodes };
-        if report_internal_error!(write.send(config.encode(&event)).await).is_err() {
-            return;
-        }
-    }
-
    // Create presence session.
    let (first_session, session_id) = create_session(&user_id, 0).await;

@@ -227,16 +218,10 @@ async fn listener(
    kill_signal_r: async_channel::Receiver<()>,
    write: &Mutex<WsWriter>,
 ) {
-    let stoat_config = revolt_config::config().await;
-    let url = stoat_config
-        .database
-        .redis_pubsub
-        .unwrap_or(REDIS_URI.to_string());
-
-    let redis_config = RedisConfig::from_url(&url).unwrap();
-    let mut builder = fred::types::Builder::from_config(redis_config);
-    builder.set_policy(ReconnectPolicy::new_exponential(8, 100, 30_000, 2));
-    let subscriber = match report_internal_error!(builder.build_subscriber_client()) {
+    let redis_config = RedisConfig::from_url(&REDIS_URI).unwrap();
+    let subscriber = match report_internal_error!(
+        fred::types::Builder::from_config(redis_config).build_subscriber_client()
+    ) {
        Ok(subscriber) => subscriber,
        Err(_) => return,
    };
@@ -245,21 +230,16 @@ async fn listener(
        return;
    }

-    // Let Fred automatically re-subscribe to tracked channels on reconnect.
-    subscriber.manage_subscriptions();
-
    // Handle Redis connection dropping
    let (clean_up_s, clean_up_r) = async_channel::bounded(1);
    let clean_up_s = Arc::new(Mutex::new(clean_up_s));
    subscriber.on_error(move |err| {
-        warn!("Redis subscriber error: {:?}", err);
        if let RedisErrorKind::Canceled = err.kind() {
            let clean_up_s = clean_up_s.clone();
            spawn(async move {
                clean_up_s.lock().await.send(()).await.ok();
            });
        }
-        // Transient errors (IO, timeout) are handled by the reconnect policy.

        Ok(())
    });
@@ -442,8 +422,6 @@ 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();
@@ -480,10 +458,6 @@ async fn worker(

                match payload {
                    ClientMessage::BeginTyping { channel } => {
-                        if revolt_config.disable_events_dont_use {
-                            continue;
-                        }
-
                        if !subscribed.read().await.contains(&channel) {
                            continue;
                        }
@@ -496,10 +470,6 @@ async fn worker(
                        .await;
                    }
                    ClientMessage::EndTyping { channel } => {
-                        if revolt_config.disable_events_dont_use {
-                            continue;
-                        }
-
                        if !subscribed.read().await.contains(&channel) {
                            continue;
                        }
@@ -537,42 +507,3 @@ async fn worker(
        }
    }
 }
-
-async fn fetch_user_slowmodes(user_id: &str) -> Option<Vec<v0::ChannelSlowmode>> {
-    let mut conn = get_connection().await.ok()?.into_inner();
-    let idx_key = format!("slowmode_idx:{}", user_id);
-
-    let channel_ids: Vec<String> = conn.smembers(&idx_key).await.unwrap_or_default();
-    if channel_ids.is_empty() {
-        return Some(vec![]);
-    }
-
-    // Bulk fetch all TTLs in one round trip
-    let mut pipe = redis_kiss::redis::pipe();
-    for channel_id in &channel_ids {
-        pipe.ttl(format!("slowmode:{}:{}", user_id, channel_id));
-    }
-    let ttls: Vec<i64> = pipe.query_async(&mut conn).await.unwrap_or_default();
-
-    // Partition into alive/expired in one pass
-    let mut slowmodes = vec![];
-    let mut expired = vec![];
-    for (channel_id, ttl) in channel_ids.iter().zip(ttls.iter()) {
-        if *ttl > 0 {
-            slowmodes.push(v0::ChannelSlowmode {
-                channel_id: channel_id.clone(),
-                duration: *ttl as u64,
-                retry_after: *ttl as u64,
-            });
-        } else {
-            expired.push(channel_id.as_str());
-        }
-    }
-
-    // Bulk remove all expired members in one SREM call
-    if !expired.is_empty() {
-        conn.srem::<_, _, ()>(&idx_key, expired).await.ok();
-    }
-
-    Some(slowmodes)
-}
--- a/crates/core/coalesced/Cargo.toml
+++ b/crates/core/coalesced/Cargo.toml
@@ -1,11 +1,10 @@
 [package]
 name = "revolt-coalesced"
-version = "0.13.7"
+version = "0.8.9"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>", "Zomatree <me@zomatree.live>"]
 description = "Revolt Backend: Coalescion service"
-repository = "https://github.com/stoatchat/stoatchat"

 [features]
 tokio = ["dep:tokio"]
@@ -15,14 +14,9 @@ cache = ["dep:lru"]
 default = ["tokio"]

 [dependencies]
-tokio = { workspace = true, features = ["sync"], optional = true }
-indexmap = { workspace = true, optional = true }
-lru = { workspace = true, optional = true }
+tokio = { version = "1.47.0", features = ["sync"], optional = true }
+indexmap = { version = "*", optional = true }
+lru = { version = "*", optional = true }

 [dev-dependencies]
-tokio = { workspace = true, features = [
-    "rt",
-    "rt-multi-thread",
-    "macros",
-    "time",
-] }
+tokio = { version = "1.47.0", features = ["rt", "rt-multi-thread", "macros", "time"] }
--- a/crates/core/coalesced/src/service.rs
+++ b/crates/core/coalesced/src/service.rs
@@ -15,7 +15,7 @@ use crate::{CoalescionServiceConfig, Error};

 #[derive(Debug, Clone)]
 #[allow(clippy::type_complexity)]
-/// # Coalescion service
+/// Coalescion service
 ///
 /// See module description for example usage.
 pub struct CoalescionService<Id: Hash + Clone + Eq> {
--- a/crates/core/config/Cargo.toml
+++ b/crates/core/config/Cargo.toml
@@ -1,11 +1,10 @@
 [package]
 name = "revolt-config"
-version = "0.13.7"
+version = "0.8.9"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]
 description = "Revolt Backend: Configuration"
-repository = "https://github.com/stoatchat/stoatchat"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -18,24 +17,24 @@ default = ["test", "sentry"]

 [dependencies]
 # Utility
-config = { workspace = true }
-cached = { workspace = true }
-once_cell = { workspace = true }
+config = "0.13.3"
+cached = "0.44.0"
+once_cell = "1.18.0"

 # Serde
-serde = { workspace = true }
+serde = { version = "1", features = ["derive"] }

 # Async
-futures-locks = { workspace = true }
-async-std = { workspace = true, features = ["attributes"], optional = true }
+futures-locks = "0.7.1"
+async-std = { version = "1.8.0", features = ["attributes"], optional = true }

 # Logging
-log = { workspace = true }
-pretty_env_logger = { workspace = true }
+log = "0.4.14"
+pretty_env_logger = "0.4.0"

 # Sentry
-sentry = { workspace = true, optional = true }
-sentry-anyhow = { workspace = true, optional = true }
+sentry = { version = "0.31.5", optional = true }
+sentry-anyhow = { version = "0.38.1", optional = true }

 # Core
-revolt-result = { workspace = true, optional = true }
+revolt-result = { version = "0.8.9", path = "../result", optional = true }
--- a/crates/core/config/Revolt.toml
+++ b/crates/core/config/Revolt.toml
@@ -1,5 +1,4 @@
 production = false
-disable_events_dont_use = false

 [database]
 # MongoDB connection URL
@@ -12,7 +11,7 @@ redis = "redis://redis/"
 [hosts]
 # Web locations of various services
 # Defaults assume all services are reverse-proxied
-# See https://github.com/stoatchat/self-hosted/blob/main/Caddyfile
+# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
 #
 # Remember to change these to https/wss where appropriate in production!
 app = "http://local.revolt.chat"
@@ -30,16 +29,12 @@ host = "rabbit"
 port = 5672
 username = "rabbituser"
 password = "rabbitpass"
-default_exchange = "revolt.default"
-
-[rabbit.queues]
-acks = "internal.ack"

 [api]

 [api.registration]
 # Whether an invite should be required for registration
-# See https://github.com/stoatchat/self-hosted#making-your-instance-invite-only
+# See https://github.com/revoltchat/self-hosted#making-your-instance-invite-only
 invite_only = false

 [api.smtp]
@@ -82,8 +77,6 @@ call_ring_duration = 30
 [api.livekit.nodes]

 [api.users]
-# Minimum allowed length of usernames
-min_username_length = 2

 [pushd]
 # this changes the names of the queues to not overlap 
@@ -95,11 +88,6 @@ 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"
@@ -136,8 +124,6 @@ pkcs8 = ""
 key_id = ""
 team_id = ""

-[january]
-blocked_domains = []

 [files]
 # Encryption key for stored files
@@ -234,10 +220,6 @@ 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

@@ -262,7 +244,7 @@ voice_quality = 16000
 # Whether the user can use video streams in voice calls
 video = true

-# Maximum resolution (width, height) of video streams in voice calls
+# Mamimum resolution (width, height) of video streams in voice calls
 video_resolution = [1080, 720]

 # Minimum and maximum aspect ratio of video streams in voice calls
@@ -301,8 +283,8 @@ voice_quality = 16000
 # Whether the user can use video streams in voice calls
 video = true

-# Maximum resolution (width, height) of video streams in voice calls
-video_resolution = [1280, 720]
+# Mamimum resolution (width, height) of video streams in voice calls
+video_resolution = [1080, 720]

 # Minimum and maximum aspect ratio of video streams in voice calls
 video_aspect_ratio = [0.3, 2.5]
@@ -321,12 +303,6 @@ emojis = 500_000
 # default: 5
 process_message_delay_limit = 5

-[features.legal_links]
-# URLs for legal documents
-terms_of_service = ""
-privacy_policy = ""
-guidelines = ""
-
 [sentry]
 # Configuration for Sentry error reporting
 api = ""
@@ -336,4 +312,4 @@ files = ""
 proxy = ""
 pushd = ""
 crond = ""
-gifbox = ""
+gifbox = ""
--- a/crates/core/config/src/lib.rs
+++ b/crates/core/config/src/lib.rs
@@ -1,7 +1,7 @@
-use std::{collections::HashMap, path::Path};
+use std::collections::HashMap;

 use cached::proc_macro::cached;
-use config::{Config, Environment, File, FileFormat};
+use config::{Config, File, FileFormat};
 use futures_locks::RwLock;
 use once_cell::sync::Lazy;
 use serde::Deserialize;
@@ -94,23 +94,12 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
            }
        }

-        let cwd = std::env::current_dir().unwrap();
-        let mut cwd: Option<&Path> = Some(&cwd);
-
-        while let Some(path) = cwd {
-            for config_path in CONFIG_SEARCH_PATHS {
-                let config_path = path.join(config_path);
-                if config_path.exists() {
-                    builder = builder
-                        .add_source(File::new(config_path.to_str().unwrap(), FileFormat::Toml));
-                }
+        for path in CONFIG_SEARCH_PATHS {
+            if std::path::Path::new(path).exists() {
+                builder = builder.add_source(File::new(path, FileFormat::Toml));
            }
-
-            cwd = path.parent();
        }

-        builder = builder.add_source(Environment::with_prefix("REVOLT").separator("__"));
-
        builder.build().unwrap()
    })
 });
@@ -119,12 +108,6 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
 pub struct Database {
    pub mongodb: String,
    pub redis: String,
-    pub redis_pubsub: Option<String>,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct RabbitQueues {
-    pub acks: String,
 }

 #[derive(Deserialize, Debug, Clone)]
@@ -133,8 +116,6 @@ pub struct Rabbit {
    pub port: u16,
    pub username: String,
    pub password: String,
-    pub default_exchange: String,
-    pub queues: RabbitQueues,
 }

 #[derive(Deserialize, Debug, Clone)]
@@ -238,7 +219,6 @@ pub struct LiveKitNode {
 #[derive(Deserialize, Debug, Clone)]
 pub struct ApiUsers {
    pub early_adopter_cutoff: Option<u64>,
-    pub min_username_length: usize,
 }

 #[derive(Deserialize, Debug, Clone)]
@@ -256,7 +236,6 @@ 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,
@@ -309,11 +288,6 @@ impl Pushd {
    }
 }

-#[derive(Deserialize, Debug, Clone)]
-pub struct January {
-    pub blocked_domains: Vec<String>,
-}
-
 #[derive(Deserialize, Debug, Clone)]
 pub struct FilesLimit {
    pub min_file_size: usize,
@@ -358,8 +332,6 @@ pub struct GlobalLimits {
    pub new_user_hours: usize,

    pub body_limit_size: usize,
-
-    pub restrict_server_creation: Vec<String>,
 }

 #[derive(Deserialize, Debug, Clone)]
@@ -389,16 +361,6 @@ pub struct FeaturesLimitsCollection {
    pub roles: HashMap<String, FeaturesLimits>,
 }

-#[derive(Deserialize, Debug, Clone)]
-pub struct LegalLinks {
-    /// Terms of Service URL
-    pub terms_of_service: String,
-    /// Privacy Policy URL
-    pub privacy_policy: String,
-    /// Guidelines URL
-    pub guidelines: String,
-}
-
 #[derive(Deserialize, Debug, Clone)]
 pub struct FeaturesAdvanced {
    #[serde(default)]
@@ -416,7 +378,6 @@ impl Default for FeaturesAdvanced {
 #[derive(Deserialize, Debug, Clone)]
 pub struct Features {
    pub limits: FeaturesLimitsCollection,
-    pub legal_links: LegalLinks,
    pub webhooks_enabled: bool,
    pub mass_mentions_send_notifications: bool,
    pub mass_mentions_enabled: bool,
@@ -444,12 +405,10 @@ pub struct Settings {
    pub hosts: Hosts,
    pub api: Api,
    pub pushd: Pushd,
-    pub january: January,
    pub files: Files,
    pub features: Features,
    pub sentry: Sentry,
    pub production: bool,
-    pub disable_events_dont_use: bool,
 }

 impl Settings {
@@ -480,14 +439,12 @@ 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_URI").is_err() {
+    if std::env::var("REDIS_URL").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") || config.hosts.api.contains("stoat.chat"))
-    {
+    if config.hosts.api.contains("https") && config.hosts.api.contains("revolt.chat") {
        config.production = true;
    }

--- a/crates/core/database/Cargo.toml
+++ b/crates/core/database/Cargo.toml
@@ -1,11 +1,10 @@
 [package]
 name = "revolt-database"
-version = "0.13.7"
+version = "0.8.9"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
 description = "Revolt Backend: Database Implementation"
-repository = "https://github.com/stoatchat/stoatchat"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -16,14 +15,8 @@ mongodb = ["dep:mongodb", "bson", "authifier/database-mongodb"]
 # ... Other
 tasks = ["isahc", "linkify", "url-escape"]
 async-std-runtime = ["async-std", "authifier/async-std-runtime"]
-rocket-impl = [
-    "rocket",
-    "schemars",
-    "revolt_okapi",
-    "revolt_rocket_okapi",
-    "authifier/rocket_impl",
-]
-axum-impl = ["axum", "revolt-result/axum"]
+rocket-impl = ["rocket"]
+axum-impl = ["axum"]
 redis-is-patched = ["revolt-presence/redis-is-patched"]
 voice = ["livekit-api", "livekit-protocol", "livekit-runtime"]

@@ -32,72 +25,80 @@ default = ["mongodb", "async-std-runtime", "tasks"]

 [dependencies]
 # Core
-revolt-config = { workspace = true, features = ["report-macros"] }
-revolt-result = { workspace = true }
-revolt-models = { workspace = true, features = ["validator"] }
-revolt-presence = { workspace = true }
-revolt-permissions = { workspace = true, features = ["serde", "bson"] }
-revolt-parser = { workspace = true }
-revolt-coalesced = { workspace = true }
+revolt-config = { version = "0.8.9", path = "../config", features = [
+    "report-macros",
+] }
+revolt-result = { version = "0.8.9", path = "../result" }
+revolt-models = { version = "0.8.9", path = "../models", features = [
+    "validator",
+] }
+revolt-presence = { version = "0.8.9", path = "../presence" }
+revolt-permissions = { version = "0.8.9", path = "../permissions", features = [
+    "serde",
+    "bson",
+] }
+revolt-parser = { version = "0.8.9", path = "../parser" }

 # Utility
-log = { workspace = true }
-lru = { workspace = true }
-rand = { workspace = true }
-ulid = { workspace = true }
-nanoid = { workspace = true }
-base64 = { workspace = true }
-once_cell = { workspace = true }
-indexmap = { workspace = true }
-decancer = { workspace = true }
-deadqueue = { workspace = true }
-linkify = { workspace = true, optional = true }
-url-escape = { workspace = true, optional = true }
-validator = { workspace = true, features = ["derive"] }
-isahc = { workspace = true, features = ["json"], optional = true }
+log = "0.4"
+lru = "0.11.0"
+rand = "0.8.5"
+ulid = "1.0.0"
+nanoid = "0.4.0"
+base64 = "0.21.3"
+once_cell = "1.17"
+indexmap = "2.12.0"
+decancer = "1.6.2"
+deadqueue = "0.2.4"
+linkify = { optional = true, version = "0.8.1" }
+url-escape = { optional = true, version = "0.1.1" }
+validator = { version = "0.16", features = ["derive"] }
+isahc = { optional = true, version = "1.7", features = ["json"] }

 # Serialisation
-serde_json = { workspace = true }
-revolt_optional_struct = { workspace = true }
-serde = { workspace = true }
-iso8601-timestamp = { workspace = true, features = ["serde", "bson"] }
+serde_json = "1"
+revolt_optional_struct = "0.2.0"
+serde = { version = "1", features = ["derive"] }
+iso8601-timestamp = { version = "0.4.0", features = ["serde", "bson"] }

 # Events
-redis-kiss = { workspace = true }
+redis-kiss = { version = "0.1.4" }

 # Database
-bson = { workspace = true, optional = true }
-mongodb = { workspace = true, optional = true }
+bson = { optional = true, version = "2.1.0" }
+mongodb = { optional = true, version = "3.1.0" }

 # Database Migration
-unicode-segmentation = { workspace = true }
-regex = { workspace = true }
+unicode-segmentation = "1.10.1"
+regex = "1"

 # Async Language Features
-futures = { workspace = true }
-async-lock = { workspace = true }
-async-trait = { workspace = true }
-async-recursion = { workspace = true }
+futures = "0.3.19"
+async-lock = "2.8.0"
+async-trait = "0.1.51"
+async-recursion = "1.0.4"

 # Async
-async-std = { workspace = true, features = ["attributes"], optional = true }
+async-std = { version = "1.8.0", features = ["attributes"], optional = true }

 # Axum Impl
-axum = { workspace = true, optional = true }
+axum = { version = "0.8.6", optional = true }

 # Rocket Impl
-schemars = { workspace = true, optional = true }
-rocket = { workspace = true, features = ["json"], optional = true }
-revolt_okapi = { workspace = true, optional = true }
-revolt_rocket_okapi = { workspace = true, optional = true }
+rocket = { version = "0.5.1", default-features = false, features = [
+    "json",
+], optional = true }
+
+# Openapi Schema
+utoipa = { version = "5.4.0", optional = true }

 # Authifier
-authifier = { workspace = true }
+authifier = { version = "1.0.15" }

 # RabbitMQ
-lapin = { workspace = true, features = ["tokio"] }
+amqprs = { version = "1.7.0" }

 # Voice
-livekit-api = { workspace = true, features = ["rustls-tls-native-roots"], optional = true }
-livekit-protocol = { workspace = true, optional = true }
-livekit-runtime = { workspace = true, features = ["tokio"], optional = true }
+livekit-api = { version = "=0.4.4", optional = true}
+livekit-protocol = { version = "=0.4.0", optional = true }
+livekit-runtime = { version = "=0.3.1", features = ["tokio"], optional = true }
--- a/crates/core/database/fixtures/server_with_roles.json
+++ b/crates/core/database/fixtures/server_with_roles.json
@@ -47,7 +47,6 @@
    ],
    "roles": {
      "__ID:5__": {
-        "_id": "__ID:5__",
        "name": "Moderator",
        "permissions": {
          "a": 545270208,
@@ -56,7 +55,6 @@
        "rank": 1
      },
      "__ID:6__": {
-        "_id": "__ID:6__",
        "name": "Owner",
        "permissions": {
          "a": 0,
--- a/crates/core/database/src/amqp/amqp.rs
+++ b/crates/core/database/src/amqp/amqp.rs
@@ -1,77 +1,58 @@
 use std::collections::HashSet;
-use std::sync::Arc;

 use crate::events::rabbit::*;
 use crate::User;
-use lapin::{
-    options::BasicPublishOptions,
-    protocol::basic::AMQPProperties,
-    types::{AMQPValue, FieldTable},
-    Channel, Connection, ConnectionProperties, Error as AMQPError,
-};
+use amqprs::channel::{BasicPublishArguments, ExchangeDeclareArguments};
+use amqprs::connection::OpenConnectionArguments;
+use amqprs::{channel::Channel, connection::Connection, error::Error as AMQPError};
+use amqprs::{BasicProperties, FieldTable};
 use revolt_models::v0::PushNotification;
 use revolt_presence::filter_online;
-use revolt_result::Result;

 use serde_json::to_string;

 #[derive(Clone)]
 pub struct AMQP {
-    friend_request_accepted: Arc<Channel>,
-    friend_request_received: Arc<Channel>,
-    generic_message: Arc<Channel>,
-    message_sent: Arc<Channel>,
-    mass_mention_message_sent: Arc<Channel>,
-    ack_notification_message: Arc<Channel>,
-    dm_call_updated: Arc<Channel>,
-    process_ack: Arc<Channel>,
    #[allow(unused)]
-    connection: Arc<Connection>,
+    connection: Connection,
+    channel: Channel,
 }

 impl AMQP {
-    pub async fn new(connection: Arc<Connection>) -> Self {
-        Self {
-            friend_request_accepted: Self::create_channel(&connection).await,
-            friend_request_received: Self::create_channel(&connection).await,
-            generic_message: Self::create_channel(&connection).await,
-            message_sent: Self::create_channel(&connection).await,
-            mass_mention_message_sent: Self::create_channel(&connection).await,
-            ack_notification_message: Self::create_channel(&connection).await,
-            dm_call_updated: Self::create_channel(&connection).await,
-            process_ack: Self::create_channel(&connection).await,
+    pub fn new(connection: Connection, channel: Channel) -> AMQP {
+        AMQP {
            connection,
+            channel,
        }
    }

-    pub async fn new_auto() -> Self {
+    pub async fn new_auto() -> AMQP {
        let config = revolt_config::config().await;

-        let connection = Arc::new(
-            Connection::connect(
-                &format!(
-                    "amqp://{}:{}@{}:{}",
-                    &config.rabbit.username,
-                    &config.rabbit.password,
-                    &config.rabbit.host,
-                    &config.rabbit.port,
-                ),
-                ConnectionProperties::default(),
+        let connection = Connection::open(&OpenConnectionArguments::new(
+            &config.rabbit.host,
+            config.rabbit.port,
+            &config.rabbit.username,
+            &config.rabbit.password,
+        ))
+        .await
+        .expect("Failed to connect to RabbitMQ");
+
+        let channel = connection
+            .open_channel(None)
+            .await
+            .expect("Failed to open RabbitMQ channel");
+
+        channel
+            .exchange_declare(
+                ExchangeDeclareArguments::new(&config.pushd.exchange, "direct")
+                    .durable(true)
+                    .finish(),
            )
            .await
-            .expect("Failed to connect to RabbitMQ"),
-        );
+            .expect("Failed to declare exchange");

-        Self::new(connection).await
-    }
-
-    async fn create_channel(connection: &Connection) -> Arc<Channel> {
-        Arc::new(
-            connection
-                .create_channel()
-                .await
-                .expect("Failed to create channel"),
-        )
+        AMQP::new(connection, channel)
    }

    pub async fn friend_request_accepted(
@@ -91,20 +72,19 @@ impl AMQP {
            config.pushd.get_fr_accepted_routing_key(),
            payload
        );
-
-        self.friend_request_accepted
+        self.channel
            .basic_publish(
-                config.pushd.exchange.clone().into(),
-                config.pushd.get_fr_accepted_routing_key().into(),
-                BasicPublishOptions::default(),
-                payload.as_bytes(),
-                AMQPProperties::default()
-                    .with_content_type("application/json".into())
-                    .with_delivery_mode(2),
+                BasicProperties::default()
+                    .with_content_type("application/json")
+                    .with_persistence(true)
+                    .finish(),
+                payload.into(),
+                BasicPublishArguments::new(
+                    &config.pushd.exchange,
+                    &config.pushd.get_fr_accepted_routing_key(),
+                ),
            )
-            .await?;
-
-        Ok(())
+            .await
    }

    pub async fn friend_request_received(
@@ -125,19 +105,19 @@ impl AMQP {
            payload
        );

-        self.friend_request_received
+        self.channel
            .basic_publish(
-                config.pushd.exchange.clone().into(),
-                config.pushd.get_fr_received_routing_key().into(),
-                BasicPublishOptions::default(),
-                payload.as_bytes(),
-                AMQPProperties::default()
-                    .with_content_type("application/json".into())
-                    .with_delivery_mode(2),
+                BasicProperties::default()
+                    .with_content_type("application/json")
+                    .with_persistence(true)
+                    .finish(),
+                payload.into(),
+                BasicPublishArguments::new(
+                    &config.pushd.exchange,
+                    &config.pushd.get_fr_received_routing_key(),
+                ),
            )
-            .await?;
-
-        Ok(())
+            .await
    }

    pub async fn generic_message(
@@ -162,19 +142,19 @@ impl AMQP {
            payload
        );

-        self.generic_message
+        self.channel
            .basic_publish(
-                config.pushd.exchange.clone().into(),
-                config.pushd.get_generic_routing_key().into(),
-                BasicPublishOptions::default(),
-                payload.as_bytes(),
-                AMQPProperties::default()
-                    .with_content_type("application/json".into())
-                    .with_delivery_mode(2),
+                BasicProperties::default()
+                    .with_content_type("application/json")
+                    .with_persistence(true)
+                    .finish(),
+                payload.into(),
+                BasicPublishArguments::new(
+                    &config.pushd.exchange,
+                    &config.pushd.get_generic_routing_key(),
+                ),
            )
-            .await?;
-
-        Ok(())
+            .await
    }

    pub async fn message_sent(
@@ -205,19 +185,19 @@ impl AMQP {
            payload
        );

-        self.message_sent
+        self.channel
            .basic_publish(
-                config.pushd.exchange.clone().into(),
-                config.pushd.get_message_routing_key().into(),
-                BasicPublishOptions::default(),
-                payload.as_bytes(),
-                AMQPProperties::default()
-                    .with_content_type("application/json".into())
-                    .with_delivery_mode(2),
+                BasicProperties::default()
+                    .with_content_type("application/json")
+                    .with_persistence(true)
+                    .finish(),
+                payload.into(),
+                BasicPublishArguments::new(
+                    &config.pushd.exchange,
+                    &config.pushd.get_message_routing_key(),
+                ),
            )
-            .await?;
-
-        Ok(())
+            .await
    }

    pub async fn mass_mention_message_sent(
@@ -240,24 +220,19 @@ impl AMQP {
            routing_key, payload
        );

-        self.mass_mention_message_sent
+        self.channel
            .basic_publish(
-                config.pushd.exchange.clone().into(),
-                routing_key.into(),
-                BasicPublishOptions::default(),
-                payload.as_bytes(),
-                AMQPProperties::default()
-                    .with_content_type("application/json".into())
-                    .with_delivery_mode(2),
+                BasicProperties::default()
+                    .with_content_type("application/json")
+                    .with_persistence(true)
+                    .finish(),
+                payload.into(),
+                BasicPublishArguments::new(&config.pushd.exchange, routing_key.as_str()),
            )
-            .await?;
-
-        Ok(())
+            .await
    }

-    /// # Sends an ack to pushd to update badges on iPhones.
-    /// Not to be confused with the process_ack function, which handles sending all acks to crond for processing.
-    pub async fn ack_notification_message(
+    pub async fn ack_message(
        &self,
        user_id: String,
        channel_id: String,
@@ -277,25 +252,23 @@ impl AMQP {
            config.pushd.ack_queue, payload
        );

-        let mut headers = FieldTable::default();
+        let mut headers = FieldTable::new();
        headers.insert(
-            "x-deduplication-header".into(),
-            AMQPValue::LongString(format!("{}-{}", &user_id, &channel_id).into()),
+            "x-deduplication-header".try_into().unwrap(),
+            format!("{}-{}", &user_id, &channel_id).into(),
        );

-        self.ack_notification_message
+        self.channel
            .basic_publish(
-                config.pushd.exchange.clone().into(),
-                config.pushd.ack_queue.into(),
-                BasicPublishOptions::default(),
-                payload.as_bytes(),
-                AMQPProperties::default()
-                    .with_content_type("application/json".into())
-                    .with_delivery_mode(2),
+                BasicProperties::default()
+                    .with_content_type("application/json")
+                    .with_persistence(true)
+                    //.with_headers(headers)
+                    .finish(),
+                payload.into(),
+                BasicPublishArguments::new(&config.pushd.exchange, &config.pushd.ack_queue),
            )
-            .await?;
-
-        Ok(())
+            .await
    }

    /// # DM Call Update
@@ -329,54 +302,18 @@ impl AMQP {
            payload
        );

-        self.dm_call_updated
+        self.channel
            .basic_publish(
-                config.pushd.exchange.clone().into(),
-                config.pushd.get_dm_call_routing_key().into(),
-                BasicPublishOptions::default(),
-                payload.as_bytes(),
-                AMQPProperties::default()
-                    .with_content_type("application/json".into())
-                    .with_delivery_mode(2),
+                BasicProperties::default()
+                    .with_content_type("application/json")
+                    .with_persistence(true)
+                    .finish(),
+                payload.into(),
+                BasicPublishArguments::new(
+                    &config.pushd.exchange,
+                    &config.pushd.get_dm_call_routing_key(),
+                ),
            )
-            .await?;
-
-        Ok(())
-    }
-
-    /// # Send an ack to crond for processing
-    pub async fn process_ack(
-        &self,
-        user_id: &str,
-        channel_id: Option<&str>,
-        server_id: Option<&str>,
-    ) -> Result<(), AMQPError> {
-        let config = revolt_config::config().await;
-
-        let payload = AckEventPayload {
-            user_id: user_id.to_string(),
-            channel_id: channel_id.map(|value| value.to_string()),
-            server_id: server_id.map(|value| value.to_string()),
-        };
-        let payload = to_string(&payload).unwrap();
-
-        info!(
-            "Sending ack processor event on exchange {}, channel {}: {}",
-            config.rabbit.default_exchange, config.rabbit.queues.acks, payload
-        );
-
-        self.process_ack
-            .basic_publish(
-                config.rabbit.default_exchange.clone().into(),
-                config.rabbit.queues.acks.into(),
-                BasicPublishOptions::default(),
-                payload.as_bytes(),
-                AMQPProperties::default()
-                    .with_content_type("application/json".into())
-                    .with_delivery_mode(2),
-            )
-            .await?;
-
-        Ok(())
+            .await
    }
 }
--- a/crates/core/database/src/drivers/mod.rs
+++ b/crates/core/database/src/drivers/mod.rs
@@ -10,7 +10,6 @@ use authifier::config::SMTPSettings;
 use authifier::config::Shield;
 use authifier::config::Template;
 use authifier::config::Templates;
-use authifier::config::EmailExpiryConfig;
 use authifier::Authifier;
 use rand::Rng;
 use revolt_config::config;
@@ -70,7 +69,7 @@ impl DatabaseInfo {
                    .await;

                    #[cfg(not(feature = "mongodb"))]
-                    return Err("MongoDB not enabled.".to_string());
+                    return Err("MongoDB not enabled.".to_string())
                } else {
                    DatabaseInfo::Reference.connect().await
                }
@@ -91,7 +90,7 @@ impl DatabaseInfo {
                        .await;

                        #[cfg(not(feature = "mongodb"))]
-                        return Err("MongoDB not enabled.".to_string());
+                        return Err("MongoDB not enabled.".to_string())
                    }
                    _ => unreachable!("must specify REFERENCE or MONGODB"),
                }
@@ -138,33 +137,29 @@ impl Database {
                                .api
                                .smtp
                                .reply_to
-                                .unwrap_or("support@stoat.chat".into()),
+                                .unwrap_or("support@revolt.chat".into()),
                        ),
                        port: config.api.smtp.port,
                        use_tls: config.api.smtp.use_tls,
                        use_starttls: config.api.smtp.use_starttls,
                    },
-                    expiry: EmailExpiryConfig {
-                        expire_verification: 3600 * 24 * 7,
-                        expire_password_reset: 3600 * 24,
-                        expire_account_deletion: 3600 * 24,
-                    },
+                    expiry: Default::default(),
                    templates: if config.production {
                        Templates {
                            verify: Template {
-                                title: "Verify your Stoat account.".into(),
+                                title: "Verify your Revolt account.".into(),
                                text: include_str!("../../templates/verify.txt").into(),
                                url: format!("{}/login/verify/", config.hosts.app),
                                html: Some(include_str!("../../templates/verify.html").into()),
                            },
                            reset: Template {
-                                title: "Reset your Stoat password.".into(),
+                                title: "Reset your Revolt password.".into(),
                                text: include_str!("../../templates/reset.txt").into(),
                                url: format!("{}/login/reset/", config.hosts.app),
                                html: Some(include_str!("../../templates/reset.html").into()),
                            },
                            reset_existing: Template {
-                                title: "You already have a Stoat account, reset your password."
+                                title: "You already have a Revolt account, reset your password."
                                    .into(),
                                text: include_str!("../../templates/reset-existing.txt").into(),
                                url: format!("{}/login/reset/", config.hosts.app),
--- a/crates/core/database/src/events/client.rs
+++ b/crates/core/database/src/events/client.rs
@@ -3,12 +3,7 @@ use revolt_result::Error;
 use serde::{Deserialize, Serialize};

 use revolt_models::v0::{
-    AppendMessage, Channel, ChannelSlowmode, ChannelUnread, ChannelVoiceState, Emoji,
-    FieldsChannel, FieldsMember, FieldsMessage, FieldsRole, FieldsServer, FieldsUser,
-    FieldsWebhook, Member, MemberCompositeKey, Message, PartialChannel, PartialEmoji,
-    PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser, PartialUserVoiceState,
-    PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings,
-    UserVoiceState, Webhook,
+    AppendMessage, Channel, ChannelUnread, ChannelVoiceState, Emoji, FieldsChannel, FieldsMember, FieldsMessage, FieldsRole, FieldsServer, FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message, PartialChannel, PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser, PartialUserVoiceState, PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings, UserVoiceState, Webhook
 };

 use crate::Database;
@@ -56,13 +51,9 @@ impl Default for ReadyPayloadFields {
 #[serde(tag = "type")]
 pub enum EventV1 {
    /// Multiple events
-    Bulk {
-        v: Vec<EventV1>,
-    },
+    Bulk { v: Vec<EventV1> },
    /// Error event
-    Error {
-        data: Error,
-    },
+    Error { data: Error },

    /// Successfully authenticated
    Authenticated,
@@ -93,9 +84,7 @@ pub enum EventV1 {
    },

    /// Ping response
-    Pong {
-        data: Ping,
-    },
+    Pong { data: Ping },
    /// New message
    Message(Message),

@@ -116,10 +105,7 @@ pub enum EventV1 {
    },

    /// Delete message
-    MessageDelete {
-        id: String,
-        channel: String,
-    },
+    MessageDelete { id: String, channel: String },

    /// New reaction to a message
    MessageReact {
@@ -145,10 +131,7 @@ pub enum EventV1 {
    },

    /// Bulk delete messages
-    BulkMessageDelete {
-        channel: String,
-        ids: Vec<String>,
-    },
+    BulkMessageDelete { channel: String, ids: Vec<String> },

    /// New server
    ServerCreate {
@@ -156,7 +139,7 @@ pub enum EventV1 {
        server: Server,
        channels: Vec<Channel>,
        emojis: Vec<Emoji>,
-        voice_states: Vec<ChannelVoiceState>,
+        voice_states: Vec<ChannelVoiceState>
    },

    /// Update existing server
@@ -168,9 +151,7 @@ pub enum EventV1 {
    },

    /// Delete server
-    ServerDelete {
-        id: String,
-    },
+    ServerDelete { id: String },

    /// Update existing server member
    ServerMemberUpdate {
@@ -206,16 +187,10 @@ pub enum EventV1 {
    },

    /// Server role deleted
-    ServerRoleDelete {
-        id: String,
-        role_id: String,
-    },
+    ServerRoleDelete { id: String, role_id: String },

    /// Server roles ranks updated
-    ServerRoleRanksUpdate {
-        id: String,
-        ranks: Vec<String>,
-    },
+    ServerRoleRanksUpdate { id: String, ranks: Vec<String> },

    /// Update existing user
    UserUpdate {
@@ -227,15 +202,9 @@ pub enum EventV1 {
    },

    /// Relationship with another user changed
-    UserRelationship {
-        id: String,
-        user: User,
-    },
+    UserRelationship { id: String, user: User },
    /// Settings updated remotely
-    UserSettingsUpdate {
-        id: String,
-        update: UserSettings,
-    },
+    UserSettingsUpdate { id: String, update: UserSettings },

    /// User has been platform banned or deleted their account
    ///
@@ -246,23 +215,12 @@ pub enum EventV1 {
    /// - Server Memberships
    ///
    /// User flags are specified to explain why a wipe is occurring though not all reasons will necessarily ever appear.
-    UserPlatformWipe {
-        user_id: String,
-        flags: i32,
-    },
+    UserPlatformWipe { user_id: String, flags: i32 },
    /// New emoji
    EmojiCreate(Emoji),

-    /// Update existing emoji
-    EmojiUpdate {
-        id: String,
-        data: PartialEmoji,
-    },
-
    /// Delete emoji
-    EmojiDelete {
-        id: String,
-    },
+    EmojiDelete { id: String },

    /// New report
    ReportCreate(Report),
@@ -278,33 +236,19 @@ pub enum EventV1 {
    },

    /// Delete channel
-    ChannelDelete {
-        id: String,
-    },
+    ChannelDelete { id: String },

    /// User joins a group
-    ChannelGroupJoin {
-        id: String,
-        user: String,
-    },
+    ChannelGroupJoin { id: String, user: String },

    /// User leaves a group
-    ChannelGroupLeave {
-        id: String,
-        user: String,
-    },
+    ChannelGroupLeave { id: String, user: String },

    /// User started typing in a channel
-    ChannelStartTyping {
-        id: String,
-        user: String,
-    },
+    ChannelStartTyping { id: String, user: String },

    /// User stopped typing in a channel
-    ChannelStopTyping {
-        id: String,
-        user: String,
-    },
+    ChannelStopTyping { id: String, user: String },

    /// User acknowledged message in channel
    ChannelAck {
@@ -324,9 +268,7 @@ pub enum EventV1 {
    },

    /// Delete webhook
-    WebhookDelete {
-        id: String,
-    },
+    WebhookDelete { id: String },

    /// Auth events
    Auth(AuthifierEvent),
@@ -344,7 +286,7 @@ pub enum EventV1 {
        user: String,
        from: String,
        to: String,
-        state: UserVoiceState,
+        state: UserVoiceState
    },
    UserVoiceStateUpdate {
        id: String,
@@ -356,11 +298,7 @@ pub enum EventV1 {
        from: String,
        to: String,
        token: String,
-    },
-    /// User's active slowmodes
-    UserSlowmodes {
-        slowmodes: Vec<ChannelSlowmode>,
-    },
+    }
 }

 impl EventV1 {
--- a/crates/core/database/src/events/rabbit.rs
+++ b/crates/core/database/src/events/rabbit.rs
@@ -78,11 +78,3 @@ pub struct AckPayload {
    pub channel_id: String,
    pub message_id: String,
 }
-
-/// This is not the same as the AckPayload above, as the state for this event is stored in redis to allow for state updates while the event is queued.
-#[derive(Serialize, Deserialize, Debug)]
-pub struct AckEventPayload {
-    pub user_id: String,
-    pub channel_id: Option<String>,
-    pub server_id: Option<String>,
-}
--- a/crates/core/database/src/lib.rs
+++ b/crates/core/database/src/lib.rs
@@ -25,6 +25,10 @@ pub use mongodb;
 #[macro_use]
 extern crate bson;

+#[cfg(feature = "utoipa")]
+#[macro_use]
+extern crate utoipa;
+
 #[cfg(not(feature = "async-std-runtime"))]
 compile_error!("async-std-runtime feature must be enabled.");

@@ -60,7 +64,7 @@ macro_rules! database_derived {
 macro_rules! auto_derived {
    ( $( $item:item )+ ) => {
        $(
-            #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
+            #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
            $item
        )+
    };
@@ -68,8 +72,8 @@ macro_rules! auto_derived {

 macro_rules! auto_derived_partial {
    ( $item:item, $name:expr ) => {
-        #[derive(OptionalStruct, Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
-        #[optional_derive(Serialize, Deserialize, Debug, Clone, Default, Eq, PartialEq)]
+        #[derive(OptionalStruct, Serialize, Deserialize, Debug, Clone, PartialEq)]
+        #[optional_derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq)]
        #[optional_name = $name]
        #[opt_skip_serializing_none]
        #[opt_some_priority]
--- a/crates/core/database/src/models/admin_migrations/ops/mongodb/scripts.rs
+++ b/crates/core/database/src/models/admin_migrations/ops/mongodb/scripts.rs
@@ -25,7 +25,7 @@ struct MigrationInfo {
    revision: i32,
 }

-pub const LATEST_REVISION: i32 = 50; // MUST BE +1 to last migration
+pub const LATEST_REVISION: i32 = 49; // MUST BE +1 to last migration

 pub async fn migrate_database(db: &MongoDb) {
    let migrations = db.col::<Document>("migrations");
@@ -1246,7 +1246,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
            .expect("Failed to update voice channels");
    };

-    if revision <= 48 {
+        if revision <= 48 {
        info!("Running migration [revision 48 / 22-10-2025]: Add Video + Listen to default permissions");

        db.col::<Document>("servers")
@@ -1264,48 +1264,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
            .expect("Failed to update default_permissions");
    };

-    if revision <= 49 {
-        info!("Running migration [revision 49 / 12-12-2025]: Add _id key to roles");
-
-        #[derive(Serialize, Deserialize, Clone)]
-        struct Server {
-            #[serde(rename = "_id")]
-            pub id: String,
-            #[serde(default = "HashMap::<String, Document>::new")]
-            pub roles: HashMap<String, Document>,
-        }
-
-        let mut servers = db
-            .db()
-            .collection::<Server>("servers")
-            .find(doc! {
-                "roles": {
-                    "$exists": true,
-                    "$ne": {}
-                }
-            })
-            .await
-            .unwrap()
-            .map(|res| res.expect("Failed to decode Server { id, roles }"));
-
-        while let Some(server) = servers.next().await {
-            let mut doc = doc! {};
-
-            for id in server.roles.keys() {
-                doc.insert(
-                    format!("roles.{id}._id"),
-                    id,
-                );
-            }
-
-            db.db()
-                .collection::<Server>("servers")
-                .update_one(doc! { "_id": &server.id }, doc! { "$set": doc })
-                .await
-                .unwrap();
-        }
-    };
-
    // Reminder to update LATEST_REVISION when adding new migrations.
    LATEST_REVISION.max(revision)
 }
--- a/crates/core/database/src/models/channel_unreads/model.rs
+++ b/crates/core/database/src/models/channel_unreads/model.rs
@@ -14,7 +14,7 @@ auto_derived!(
    }

    /// Composite primary key consisting of channel and user id
-    #[derive(Hash)]
+    #[derive(Hash, Eq)]
    pub struct ChannelCompositeKey {
        /// Channel Id
        pub channel: String,
--- a/crates/core/database/src/models/channels/model.rs
+++ b/crates/core/database/src/models/channels/model.rs
@@ -1,7 +1,6 @@
 #![allow(deprecated)]
 use std::{borrow::Cow, collections::HashMap};

-use redis_kiss::get_connection;
 use revolt_config::config;
 use revolt_models::v0::{self, MessageAuthor};
 use revolt_permissions::OverrideField;
@@ -111,10 +110,6 @@ 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>,
        },
    }

@@ -151,8 +146,6 @@ 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
@@ -213,7 +206,6 @@ 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(),
@@ -226,7 +218,6 @@ impl Channel {
                role_permissions: HashMap::new(),
                nsfw: data.nsfw.unwrap_or(false),
                voice: Some(data.voice.unwrap_or_default().into()),
-                slowmode: None,
            },
        };

@@ -644,7 +635,7 @@ impl Channel {
    }

    /// Acknowledge a message
-    pub async fn ack(&self, user: &str, message: &str, amqp: &AMQP) -> Result<()> {
+    pub async fn ack(&self, user: &str, message: &str) -> Result<()> {
        EventV1::ChannelAck {
            id: self.id().to_string(),
            user: user.to_string(),
@@ -653,7 +644,17 @@ impl Channel {
        .private(user.to_string())
        .await;

-        crate::util::acker::ack_channel(user, self.id(), message, amqp).await
+        #[cfg(feature = "tasks")]
+        crate::tasks::ack::queue_ack(
+            self.id().to_string(),
+            user.to_string(),
+            crate::tasks::ack::AckEvent::AckMessage {
+                id: message.to_string(),
+            },
+        )
+        .await;
+
+        Ok(())
    }

    /// Remove user from a group
--- a/crates/core/database/src/models/emojis/model.rs
+++ b/crates/core/database/src/models/emojis/model.rs
@@ -2,7 +2,6 @@ use std::collections::HashSet;
 use std::str::FromStr;

 use once_cell::sync::Lazy;
-use revolt_models::v0;
 use revolt_result::Result;
 use ulid::Ulid;

@@ -12,7 +11,7 @@ use crate::Database;
 static PERMISSIBLE_EMOJIS: Lazy<HashSet<String>> = Lazy::new(|| {
    include_str!("unicode_emoji.txt")
        .split('\n')
-        .map(|x| x.replace('\u{FE0F}', ""))
+        .map(|x| x.into())
        .collect()
 });

@@ -42,12 +41,6 @@ auto_derived!(
        Server { id: String },
        Detached,
    }
-
-    /// Partial representation of an emoji
-    pub struct PartialEmoji {
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub name: Option<String>,
-    }
 );

 #[allow(clippy::disallowed_methods)]
@@ -82,34 +75,13 @@ impl Emoji {
        db.detach_emoji(&self).await
    }

-    /// Update an emoji
-    pub async fn update(&mut self, db: &Database, partial: PartialEmoji) -> Result<()> {
-        if let Some(name) = partial.name.clone() {
-            self.name = name;
-        }
-
-        db.update_emoji(&self.id, &partial).await?;
-
-        EventV1::EmojiUpdate {
-            id: self.id.clone(),
-            data: v0::PartialEmoji {
-                name: partial.name.clone(),
-            },
-        }
-        .p(self.parent().to_string())
-        .await;
-
-        Ok(())
-    }
-
    /// Check whether we can use a given emoji
    pub async fn can_use(db: &Database, emoji: &str) -> Result<bool> {
        if Ulid::from_str(emoji).is_ok() {
            db.fetch_emoji(emoji).await?;
            Ok(true)
        } else {
-            let sanitized_emoji = emoji.replace('\u{FE0F}', "");
-            Ok(PERMISSIBLE_EMOJIS.contains(&sanitized_emoji))
+            Ok(PERMISSIBLE_EMOJIS.contains(emoji))
        }
    }
 }
--- a/crates/core/database/src/models/emojis/ops.rs
+++ b/crates/core/database/src/models/emojis/ops.rs
@@ -1,6 +1,6 @@
 use revolt_result::Result;

-use crate::{Emoji, PartialEmoji};
+use crate::Emoji;

 #[cfg(feature = "mongodb")]
 mod mongodb;
@@ -20,9 +20,6 @@ pub trait AbstractEmojis: Sync + Send {
    /// Fetch emoji by their parent ids
    async fn fetch_emoji_by_parent_ids(&self, parent_ids: &[String]) -> Result<Vec<Emoji>>;

-    /// Update emoji with new information
-    async fn update_emoji(&self, emoji_id: &str, partial: &PartialEmoji) -> Result<()>;
-
    /// Detach an emoji by its id
    async fn detach_emoji(&self, emoji: &Emoji) -> Result<()>;
 }
--- a/crates/core/database/src/models/emojis/ops/mongodb.rs
+++ b/crates/core/database/src/models/emojis/ops/mongodb.rs
@@ -1,7 +1,7 @@
 use bson::Document;
 use revolt_result::Result;

-use crate::{Emoji, PartialEmoji};
+use crate::Emoji;
 use crate::MongoDb;

 use super::AbstractEmojis;
@@ -46,11 +46,6 @@ impl AbstractEmojis for MongoDb {
        )
    }

-    /// Update emoji with new information
-    async fn update_emoji(&self, emoji_id: &str, partial: &PartialEmoji) -> Result<()> {
-        query!(self, update_one_by_id, COL, emoji_id, partial, vec![], None).map(|_| ())
-    }
-
    /// Detach an emoji by its id
    async fn detach_emoji(&self, emoji: &Emoji) -> Result<()> {
        self.col::<Document>(COL)
--- a/crates/core/database/src/models/emojis/ops/reference.rs
+++ b/crates/core/database/src/models/emojis/ops/reference.rs
@@ -1,6 +1,6 @@
 use revolt_result::Result;

-use crate::{Emoji, PartialEmoji};
+use crate::Emoji;
 use crate::EmojiParent;
 use crate::ReferenceDb;

@@ -54,19 +54,6 @@ impl AbstractEmojis for ReferenceDb {
            .collect())
    }

-    /// Update emoji with new information
-    async fn update_emoji(&self, emoji_id: &str, partial: &PartialEmoji) -> Result<()> {
-        let mut emojis = self.emojis.lock().await;
-        if let Some(emoji) = emojis.get_mut(emoji_id) {
-            if let Some(name) = partial.name.clone() {
-                emoji.name = name;
-            }
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
    /// Detach an emoji by its id
    async fn detach_emoji(&self, emoji: &Emoji) -> Result<()> {
        let mut emojis = self.emojis.lock().await;
--- a/crates/core/database/src/models/emojis/unicode_emoji.txt
+++ b/crates/core/database/src/models/emojis/unicode_emoji.txt
--- a/crates/core/database/src/models/file_hashes/model.rs
+++ b/crates/core/database/src/models/file_hashes/model.rs
@@ -45,8 +45,7 @@ auto_derived!(
        Image {
            width: isize,
            height: isize,
-            thumbhash: Option<Vec<u8>>,
-            animated: Option<bool>,
+            // animated: bool // TODO: https://docs.rs/image/latest/image/trait.AnimationDecoder.html for APNG support
        },
        /// File is a video with specific dimensions
        Video { width: isize, height: isize },
--- a/crates/core/database/src/models/file_hashes/ops.rs
+++ b/crates/core/database/src/models/file_hashes/ops.rs
@@ -17,12 +17,6 @@ pub trait AbstractAttachmentHashes: Sync + Send {
    /// Update an attachment hash nonce value.
    async fn set_attachment_hash_nonce(&self, hash: &str, nonce: &str) -> Result<()>;

-    /// Updates the attachments animated metadata value.
-    ///
-    /// The primary use for this is to update the metadata for existing uploaded files, this
-    /// can only be used for images.
-    async fn set_attachment_hash_animated(&self, hash: &str, animated: bool) -> Result<()>;
-
    /// Delete attachment hash by id.
    async fn delete_attachment_hash(&self, id: &str) -> Result<()>;
 }
--- a/crates/core/database/src/models/file_hashes/ops/mongodb.rs
+++ b/crates/core/database/src/models/file_hashes/ops/mongodb.rs
@@ -48,29 +48,6 @@ impl AbstractAttachmentHashes for MongoDb {
            .map_err(|_| create_database_error!("update_one", COL))
    }

-    /// Updates the attachments animated metadata value.
-    ///
-    /// The primary use for this is to update the metadata for existing uploaded files, this
-    /// can only be used for images.
-    async fn set_attachment_hash_animated(&self, hash: &str, animated: bool) -> Result<()> {
-        self.col::<FileHash>(COL)
-            .update_one(
-                doc! {
-                    "_id": hash,
-                    "metadata.type": "Image",
-                    "metadata.animated": { "$exists": false },
-                },
-                doc! {
-                    "$set": {
-                        "metadata.animated": animated
-                    }
-                },
-            )
-            .await
-            .map(|_| ())
-            .map_err(|_| create_database_error!("update_one", COL))
-    }
-
    /// Delete attachment hash by id.
    async fn delete_attachment_hash(&self, id: &str) -> Result<()> {
        query!(self, delete_one_by_id, COL, id).map(|_| ())
--- a/crates/core/database/src/models/file_hashes/ops/reference.rs
+++ b/crates/core/database/src/models/file_hashes/ops/reference.rs
@@ -1,6 +1,7 @@
 use revolt_result::Result;

-use crate::{FileHash, Metadata, ReferenceDb};
+use crate::FileHash;
+use crate::ReferenceDb;

 use super::AbstractAttachmentHashes;

@@ -38,29 +39,6 @@ impl AbstractAttachmentHashes for ReferenceDb {
        }
    }

-    /// Updates the attachments animated metadata value.
-    ///
-    /// The primary use for this is to update the metadata for existing uploaded files, this
-    /// can only be used for images.
-    async fn set_attachment_hash_animated(&self, hash: &str, animated: bool) -> Result<()> {
-        let mut hashes = self.file_hashes.lock().await;
-        if let Some(FileHash {
-            metadata:
-                Metadata::Image {
-                    animated: Some(animated_metadata),
-                    ..
-                },
-            ..
-        }) = hashes.get_mut(hash)
-        {
-            *animated_metadata = animated;
-
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
    /// Delete attachment hash by id.
    async fn delete_attachment_hash(&self, id: &str) -> Result<()> {
        let mut file_hashes = self.file_hashes.lock().await;
--- a/crates/core/database/src/models/files/model.rs
+++ b/crates/core/database/src/models/files/model.rs
@@ -70,7 +70,6 @@ auto_derived!(
        LegacyGroupIcon,
        ChannelIcon,
        ServerIcon,
-        RoleIcon,
    }

    /// Information about what the file was used for
@@ -240,23 +239,4 @@ impl File {
        )
        .await
    }
-
-    /// Use a file for a role icon
-    pub async fn use_role_icon(
-        db: &Database,
-        id: &str,
-        parent: &str,
-        uploader_id: &str,
-    ) -> Result<File> {
-        db.find_and_use_attachment(
-            id,
-            "icons",
-            FileUsedFor {
-                id: parent.to_owned(),
-                object_type: FileUsedForType::RoleIcon,
-            },
-            uploader_id.to_owned(),
-        )
-        .await
-    }
 }
--- a/crates/core/database/src/models/messages/model.rs
+++ b/crates/core/database/src/models/messages/model.rs
@@ -1,3 +1,5 @@
+use std::{collections::HashSet, hash::RandomState};
+
 use indexmap::{IndexMap, IndexSet};
 use iso8601_timestamp::Timestamp;
 use revolt_config::{config, FeaturesLimits};
@@ -7,8 +9,6 @@ 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,7 +388,6 @@ 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() {
@@ -498,7 +497,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;
@@ -688,13 +687,8 @@ impl Message {
        )
        .await?;

-        let is_dm_or_group = matches!(
-            channel,
-            Channel::DirectMessage { .. } | Channel::Group { .. }
-        );
-
        if !self.has_suppressed_notifications()
-            && (is_dm_or_group || self.mentions.is_some() || self.contains_mass_push_mention())
+            && (self.mentions.is_some() || self.contains_mass_push_mention())
        {
            // send Push notifications
            #[cfg(feature = "tasks")]
@@ -705,7 +699,7 @@ impl Message {
                        Some(
                            PushNotification::from(
                                self.clone().into_model(user, member),
-                                Some(author.clone()),
+                                Some(author),
                                channel.to_owned().into(),
                            )
                            .await,
@@ -713,11 +707,7 @@ impl Message {
                        self.clone(),
                        match channel {
                            Channel::DirectMessage { recipients, .. }
-                            | Channel::Group { recipients, .. } => recipients
-                                .iter()
-                                .filter(|uid| *uid != author.id())
-                                .cloned()
-                                .collect(),
+                            | Channel::Group { recipients, .. } => recipients.clone(),
                            Channel::TextChannel { .. } => {
                                self.mentions.clone().unwrap_or_default()
                            }
@@ -1039,31 +1029,6 @@ 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
--- a/crates/core/database/src/models/messages/ops.rs
+++ b/crates/core/database/src/models/messages/ops.rs
@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-use std::time::SystemTime;
 use revolt_result::Result;

 use crate::{AppendMessage, FieldsMessage, Message, MessageQuery, PartialMessage};
@@ -42,12 +40,4 @@ 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>>>;
 }
--- a/crates/core/database/src/models/messages/ops/mongodb.rs
+++ b/crates/core/database/src/models/messages/ops/mongodb.rs
@@ -1,12 +1,8 @@
 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,
@@ -310,112 +306,6 @@ 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 {
--- a/crates/core/database/src/models/messages/ops/reference.rs
+++ b/crates/core/database/src/models/messages/ops/reference.rs
@@ -1,9 +1,7 @@
-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;
@@ -288,63 +286,4 @@ 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)
-    }
 }
--- a/crates/core/database/src/models/server_members/model.rs
+++ b/crates/core/database/src/models/server_members/model.rs
@@ -3,8 +3,8 @@ use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
 use revolt_result::{create_error, Result};

 use crate::{
-    events::client::EventV1, util::permissions::DatabasePermissionQuery, Channel, Database, File,
-    Server, SystemMessage, User,
+    events::client::EventV1, util::permissions::DatabasePermissionQuery, Channel,
+    Database, File, Server, SystemMessage, User,
 };

 fn default_true() -> bool {
@@ -45,6 +45,7 @@ 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>
@@ -54,7 +55,7 @@ auto_derived_partial!(

 auto_derived!(
    /// Composite primary key consisting of server and user id
-    #[derive(Hash, Default)]
+    #[derive(Hash, Default, Eq)]
    pub struct MemberCompositeKey {
        /// Server Id
        pub server: String,
@@ -71,7 +72,6 @@ auto_derived!(
        CanReceive,
        CanPublish,
        JoinedAt,
-        VoiceChannel,
    }

    /// Member removal intention
@@ -152,11 +152,7 @@ impl Member {

        #[cfg(feature = "voice")]
        for channel in &channels {
-            if let Ok(Some(voice_state)) = crate::voice::get_channel_voice_state(
-                &crate::voice::UserVoiceChannel::from_channel(channel),
-            )
-            .await
-            {
+            if let Ok(Some(voice_state)) = crate::voice::get_channel_voice_state(channel).await {
                voice_states.push(voice_state)
            }
        }
@@ -178,7 +174,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;
@@ -228,14 +224,13 @@ 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 => {}
        }
    }

--- a/crates/core/database/src/models/server_members/ops/mongodb.rs
+++ b/crates/core/database/src/models/server_members/ops/mongodb.rs
@@ -330,15 +330,14 @@ impl AbstractServerMembers for MongoDb {

 impl IntoDocumentPath for FieldsMember {
    fn as_path(&self) -> Option<&'static str> {
-        match self {
-            FieldsMember::JoinedAt => Some("joined_at"),
-            FieldsMember::Avatar => Some("avatar"),
-            FieldsMember::Nickname => Some("nickname"),
-            FieldsMember::Roles => Some("roles"),
-            FieldsMember::Timeout => Some("timeout"),
-            FieldsMember::CanPublish => Some("can_publish"),
-            FieldsMember::CanReceive => Some("can_receive"),
-            FieldsMember::VoiceChannel => None,
-        }
+        Some(match self {
+            FieldsMember::JoinedAt => "joined_at",
+            FieldsMember::Avatar => "avatar",
+            FieldsMember::Nickname => "nickname",
+            FieldsMember::Roles => "roles",
+            FieldsMember::Timeout => "timeout",
+            FieldsMember::CanPublish => "can_publish",
+            FieldsMember::CanReceive => "can_receive",
+        })
    }
 }
--- a/crates/core/database/src/models/servers/model.rs
+++ b/crates/core/database/src/models/servers/model.rs
@@ -68,9 +68,6 @@ auto_derived_partial!(
 auto_derived_partial!(
    /// Role
    pub struct Role {
-        /// Unique Id
-        #[serde(rename = "_id")]
-        pub id: String,
        /// Role name
        pub name: String,
        /// Permissions available to this role
@@ -86,9 +83,6 @@ auto_derived_partial!(
        /// Ranking of this role
        #[serde(default)]
        pub rank: i64,
-        /// Custom icon attachment
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub icon: Option<File>,
    },
    "PartialRole"
 );
@@ -132,7 +126,6 @@ auto_derived!(
    /// Optional fields on server object
    pub enum FieldsRole {
        Colour,
-        Icon,
    }
 );

@@ -253,6 +246,7 @@ impl Server {
            role.update(
                db,
                &self.id,
+                role_id,
                PartialRole {
                    permissions: Some(permissions),
                    ..Default::default()
@@ -303,41 +297,29 @@ impl Role {
    /// Into optional struct
    pub fn into_optional(self) -> PartialRole {
        PartialRole {
-            id: Some(self.id),
            name: Some(self.name),
            permissions: Some(self.permissions),
            colour: self.colour,
            hoist: Some(self.hoist),
            rank: Some(self.rank),
-            icon: self.icon,
        }
    }

    /// Create a role
-    pub async fn create(db: &Database, server: &Server, name: String) -> Result<Self> {
-        let role = Role {
-            id: Ulid::new().to_string(),
-            name,
-            // Rank of the new role should be below the lowest role
-            rank: server.roles.len() as i64,
-            colour: None,
-            hoist: false,
-            permissions: Default::default(),
-            icon: None,
-        };
-
-        db.insert_role(&server.id, &role).await?;
+    pub async fn create(&self, db: &Database, server_id: &str) -> Result<String> {
+        let role_id = Ulid::new().to_string();
+        db.insert_role(server_id, &role_id, self).await?;

        EventV1::ServerRoleUpdate {
-            id: server.id.clone(),
-            role_id: role.id.clone(),
-            data: role.clone().into_optional().into(),
+            id: server_id.to_string(),
+            role_id: role_id.to_string(),
+            data: self.clone().into_optional().into(),
            clear: vec![],
        }
-        .p(server.id.clone())
+        .p(server_id.to_string())
        .await;

-        Ok(role)
+        Ok(role_id)
    }

    /// Update server data
@@ -345,6 +327,7 @@ impl Role {
        &mut self,
        db: &Database,
        server_id: &str,
+        role_id: &str,
        partial: PartialRole,
        remove: Vec<FieldsRole>,
    ) -> Result<()> {
@@ -354,14 +337,14 @@ impl Role {

        self.apply_options(partial.clone());

-        db.update_role(server_id, &self.id, &partial, remove.clone())
+        db.update_role(server_id, role_id, &partial, remove.clone())
            .await?;

        EventV1::ServerRoleUpdate {
            id: server_id.to_string(),
-            role_id: self.id.clone(),
+            role_id: role_id.to_string(),
            data: partial.into(),
-            clear: remove.into_iter().map(Into::into).collect(),
+            clear: vec![],
        }
        .p(server_id.to_string())
        .await;
@@ -373,20 +356,19 @@ impl Role {
    pub fn remove_field(&mut self, field: &FieldsRole) {
        match field {
            FieldsRole::Colour => self.colour = None,
-            FieldsRole::Icon => self.icon = None,
        }
    }

    /// Delete a role
-    pub async fn delete(self, db: &Database, server_id: &str) -> Result<()> {
+    pub async fn delete(self, db: &Database, server_id: &str, role_id: &str) -> Result<()> {
        EventV1::ServerRoleDelete {
            id: server_id.to_string(),
-            role_id: self.id.clone(),
+            role_id: role_id.to_string(),
        }
        .p(server_id.to_string())
        .await;

-        db.delete_role(server_id, &self.id).await
+        db.delete_role(server_id, role_id).await
    }
 }

--- a/crates/core/database/src/models/servers/ops.rs
+++ b/crates/core/database/src/models/servers/ops.rs
@@ -29,7 +29,7 @@ pub trait AbstractServers: Sync + Send {
    async fn delete_server(&self, id: &str) -> Result<()>;

    /// Insert a new role into server object
-    async fn insert_role(&self, server_id: &str, role: &Role) -> Result<()>;
+    async fn insert_role(&self, server_id: &str, role_id: &str, role: &Role) -> Result<()>;

    /// Update an existing role on a server
    async fn update_role(
--- a/crates/core/database/src/models/servers/ops/mongodb.rs
+++ b/crates/core/database/src/models/servers/ops/mongodb.rs
@@ -69,7 +69,7 @@ impl AbstractServers for MongoDb {
    }

    /// Insert a new role into server object
-    async fn insert_role(&self, server_id: &str, role: &Role) -> Result<()> {
+    async fn insert_role(&self, server_id: &str, role_id: &str, role: &Role) -> Result<()> {
        self.col::<Document>(COL)
            .update_one(
                doc! {
@@ -77,7 +77,7 @@ impl AbstractServers for MongoDb {
                },
                doc! {
                    "$set": {
-                        "roles.".to_owned() + role.id.as_str(): to_document(role)
+                        "roles.".to_owned() + role_id: to_document(role)
                            .map_err(|_| create_database_error!("to_document", "role"))?
                    }
                },
@@ -172,7 +172,6 @@ impl IntoDocumentPath for FieldsRole {
    fn as_path(&self) -> Option<&'static str> {
        Some(match self {
            FieldsRole::Colour => "colour",
-            FieldsRole::Icon => "icon",
        })
    }
 }
--- a/crates/core/database/src/models/servers/ops/reference.rs
+++ b/crates/core/database/src/models/servers/ops/reference.rs
@@ -72,10 +72,10 @@ impl AbstractServers for ReferenceDb {
    }

    /// Insert a new role into server object
-    async fn insert_role(&self, server_id: &str, role: &Role) -> Result<()> {
+    async fn insert_role(&self, server_id: &str, role_id: &str, role: &Role) -> Result<()> {
        let mut servers = self.servers.lock().await;
        if let Some(server) = servers.get_mut(server_id) {
-            server.roles.insert(role.id.clone(), role.clone());
+            server.roles.insert(role_id.to_string(), role.clone());
            Ok(())
        } else {
            Err(create_error!(NotFound))
--- a/crates/core/database/src/models/users/axum.rs
+++ b/crates/core/database/src/models/users/axum.rs
@@ -4,7 +4,6 @@ use revolt_result::{create_error, Error, Result};

 use crate::{Database, User};

-#[async_trait::async_trait]
 impl<S> FromRequestParts<S> for User
 where
    Database: FromRef<S>,
--- a/crates/core/database/src/models/users/mod.rs
+++ b/crates/core/database/src/models/users/mod.rs
@@ -4,8 +4,6 @@ mod model;
 mod ops;
 #[cfg(feature = "rocket-impl")]
 mod rocket;
-#[cfg(feature = "rocket-impl")]
-mod schema;

 pub use model::*;
 pub use ops::*;
--- a/crates/core/database/src/models/users/model.rs
+++ b/crates/core/database/src/models/users/model.rs
@@ -7,7 +7,6 @@ use futures::future::join_all;
 use iso8601_timestamp::Timestamp;
 use once_cell::sync::Lazy;
 use rand::seq::SliceRandom;
-use regex::{Regex, RegexBuilder};
 use revolt_config::{config, FeaturesLimits};
 use revolt_models::v0::{self, UserBadges, UserFlags};
 use revolt_presence::filter_online;
@@ -16,7 +15,7 @@ use serde_json::json;
 use ulid::Ulid;

 auto_derived_partial!(
-    /// # User
+    /// User
    pub struct User {
        /// Unique Id
        #[serde(rename = "_id")]
@@ -164,13 +163,6 @@ pub static DISCRIMINATOR_SEARCH_SPACE: Lazy<HashSet<String>> = Lazy::new(|| {
    set.into_iter().collect()
 });

-static BLOCKED_USERNAME_PATTERNS: Lazy<Regex> = Lazy::new(|| {
-    RegexBuilder::new("`{3}|(discord|rvlt|guilded|stt)\\.gg|(revolt|stoat)\\.chat|https?:\\/\\/")
-        .case_insensitive(true)
-        .build()
-        .unwrap()
-});
-
 #[allow(clippy::derivable_impls)]
 impl Default for User {
    fn default() -> Self {
@@ -206,13 +198,11 @@ impl User {
        I: Into<Option<String>>,
        D: Into<Option<PartialUser>>,
    {
-        let new_username = User::sanitise_username(&username).await?;
-        User::validate_username(&new_username)?;
-
+        let username = User::validate_username(username)?;
        let mut user = User {
            id: account_id.into().unwrap_or_else(|| Ulid::new().to_string()),
-            discriminator: User::find_discriminator(db, &new_username, None).await?,
-            username: new_username.clone(),
+            discriminator: User::find_discriminator(db, &username, None).await?,
+            username,
            last_acknowledged_policy_change: Timestamp::now_utc(),
            ..Default::default()
        };
@@ -288,40 +278,39 @@ impl User {
        }
    }

-    /// Validate a username
-    ///
-    /// This will check if the username is a blocked name or contains a blocked pattern.
-    fn validate_username(username: &str) -> Result<()> {
+    /// Sanitise and validate a username can be used
+    pub fn validate_username(username: String) -> Result<String> {
+        // Copy the username for validation
        let username_lowercase = username.to_lowercase();

-        const BLOCKED_USERNAMES: &[&str] = &["admin", "revolt", "stoat"];
-
-        if BLOCKED_USERNAMES.contains(&username_lowercase.as_str())
-            || BLOCKED_USERNAME_PATTERNS.is_match(username)
-        {
+        // Block homoglyphs
+        if decancer::cure(&username_lowercase).into_str() != username_lowercase {
            return Err(create_error!(InvalidUsername));
        }

-        Ok(())
-    }
+        // Ensure the username itself isn't blocked
+        const BLOCKED_USERNAMES: &[&str] = &["admin", "revolt"];

-    /// Sanitise a username
-    ///
-    /// This will clean up Unicode homoglyphs and pad to the min username length with underscores.
-    async fn sanitise_username(username: &str) -> Result<String> {
-        let options = decancer::Options::default().retain_capitalization();
-        let mut username = decancer::cure(username, options)
-            .map_err(|_| create_error!(InvalidUsername))?
-            .to_string();
+        for username in BLOCKED_USERNAMES {
+            if username_lowercase == *username {
+                return Err(create_error!(InvalidUsername));
+            }
+        }

-        let config = revolt_config::config().await;
-        let username_length_diff = config
-            .api
-            .users
-            .min_username_length
-            .saturating_sub(username.len());
-        if username_length_diff > 0 {
-            username.push_str(&"_".repeat(username_length_diff))
+        // Ensure none of the following substrings show up in the username
+        const BLOCKED_SUBSTRINGS: &[&str] = &[
+            "```",
+            "discord.gg",
+            "rvlt.gg",
+            "guilded.gg",
+            "https://",
+            "http://",
+        ];
+
+        for substr in BLOCKED_SUBSTRINGS {
+            if username_lowercase.contains(substr) {
+                return Err(create_error!(InvalidUsername));
+            }
        }

        Ok(username)
@@ -427,14 +416,12 @@ impl User {

    /// Update a user's username
    pub async fn update_username(&mut self, db: &Database, username: String) -> Result<()> {
-        let new_username = User::sanitise_username(&username).await?;
-        User::validate_username(&new_username)?;
-
-        if self.username.to_lowercase() == new_username.to_lowercase() {
+        let username = User::validate_username(username)?;
+        if self.username.to_lowercase() == username.to_lowercase() {
            self.update(
                db,
                PartialUser {
-                    username: Some(new_username),
+                    username: Some(username),
                    ..Default::default()
                },
                vec![],
@@ -447,12 +434,12 @@ impl User {
                    discriminator: Some(
                        User::find_discriminator(
                            db,
-                            &new_username,
+                            &username,
                            Some((self.discriminator.to_string(), self.id.clone())),
                        )
                        .await?,
                    ),
-                    username: Some(new_username),
+                    username: Some(username),
                    ..Default::default()
                },
                vec![],
@@ -838,109 +825,3 @@ impl User {
        badges
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::User;
-
-    #[test]
-    fn username_validation_blocked_names() {
-        let username_admin = "Admin";
-        let username_revolt = "Revolt";
-        let username_stoat = "Stoat";
-        let username_allowed = "Allowed";
-
-        assert!(User::validate_username(username_admin).is_err());
-        assert!(User::validate_username(username_revolt).is_err());
-        assert!(User::validate_username(username_stoat).is_err());
-        assert!(User::validate_username(username_allowed).is_ok());
-    }
-
-    #[test]
-    fn username_validation_blocked_patterns() {
-        let username_grave = "```_test";
-        let username_discord = "discord.gg_test";
-        let username_rvlt = "rvlt.gg_test";
-        let username_guilded = "guilded.gg_test";
-        let username_stt = "stt.gg_test";
-        let username_revolt = "revolt.chat_test";
-        let username_stoat = "stoat.chat_test";
-        let username_http = "http://_test";
-        let username_https = "https://_test";
-
-        assert!(User::validate_username(username_grave).is_err());
-        assert!(User::validate_username(username_discord).is_err());
-        assert!(User::validate_username(username_rvlt).is_err());
-        assert!(User::validate_username(username_guilded).is_err());
-        assert!(User::validate_username(username_stt).is_err());
-        assert!(User::validate_username(username_revolt).is_err());
-        assert!(User::validate_username(username_stoat).is_err());
-        assert!(User::validate_username(username_http).is_err());
-        assert!(User::validate_username(username_https).is_err());
-    }
-
-    #[async_std::test]
-    async fn username_sanitisation_clean() {
-        let username_clean = "Test";
-
-        let username_clean_sanitised = User::sanitise_username(username_clean).await;
-
-        assert!(username_clean_sanitised.is_ok());
-        assert_eq!(username_clean, username_clean_sanitised.unwrap());
-    }
-
-    #[async_std::test]
-    async fn username_sanitisation_homoglyphs() {
-        let username_homoglyphs = "𝔽𝕌Ňℕｙ";
-
-        let username_homoglyphs_sanitised =
-            User::sanitise_username(username_homoglyphs).await.unwrap();
-
-        assert_ne!(username_homoglyphs, username_homoglyphs_sanitised);
-        assert_eq!("funny", username_homoglyphs_sanitised);
-    }
-
-    #[async_std::test]
-    async fn username_sanitisation_padding() {
-        let username_padding = "a";
-
-        let username = User::sanitise_username(username_padding).await.unwrap();
-
-        assert_eq!("a_", username);
-    }
-
-    #[async_std::test]
-    async fn create_user() {
-        use revolt_result::Result;
-
-        database_test!(|db| async move {
-            let mut created_clean = User::create(&db, "Test".to_string(), None, None)
-                .await
-                .unwrap();
-
-            assert_eq!("Test", created_clean.username);
-
-            created_clean
-                .update_username(&db, "Test2".to_string())
-                .await
-                .unwrap();
-
-            assert_eq!("Test2", created_clean.username);
-
-            let created_invalid_result: Result<_> =
-                User::create(&db, "stoat.chat".to_string(), None, None).await;
-
-            assert!(created_invalid_result.is_err());
-
-            let mut updated_invalid = User::create(&db, "Test".to_string(), None, None)
-                .await
-                .unwrap();
-
-            let updated_invalid_update_result = updated_invalid
-                .update_username(&db, "http://test".to_string())
-                .await;
-
-            assert!(updated_invalid_update_result.is_err());
-        });
-    }
-}
--- a/crates/core/database/src/models/users/schema.rs
+++ b/crates/core/database/src/models/users/schema.rs
@@ -1,31 +0,0 @@
-use revolt_okapi::openapi3::{SecurityScheme, SecuritySchemeData};
-use revolt_rocket_okapi::{
-    gen::OpenApiGenerator,
-    request::{OpenApiFromRequest, RequestHeaderInput},
-};
-
-use crate::User;
-
-impl OpenApiFromRequest<'_> for User {
-    fn from_request_input(
-        _gen: &mut OpenApiGenerator,
-        _name: String,
-        _required: bool,
-    ) -> revolt_rocket_okapi::Result<RequestHeaderInput> {
-        let mut requirements = schemars::Map::new();
-        requirements.insert("Session Token".to_owned(), vec![]);
-
-        Ok(RequestHeaderInput::Security(
-            "Session Token".to_owned(),
-            SecurityScheme {
-                data: SecuritySchemeData::ApiKey {
-                    name: "x-session-token".to_owned(),
-                    location: "header".to_owned(),
-                },
-                description: Some("Used to authenticate as a user.".to_owned()),
-                extensions: schemars::Map::new(),
-            },
-            requirements,
-        ))
-    }
-}
--- a/crates/core/database/src/tasks/ack.rs
+++ b/crates/core/database/src/tasks/ack.rs
@@ -17,7 +17,7 @@ use super::DelayedTask;
 use crate::Channel::TextChannel;

 /// Enumeration of possible events
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Debug, PartialEq)]
 pub enum AckEvent {
    /// Add mentions for a channel
    ProcessMessage {
@@ -105,11 +105,7 @@ pub async fn handle_ack_event(

                if mentions_acked > 0 {
                    if let Err(err) = amqp
-                        .ack_notification_message(
-                            user.to_string(),
-                            channel.to_string(),
-                            id.to_owned(),
-                        )
+                        .ack_message(user.to_string(), channel.to_string(), id.to_owned())
                        .await
                    {
                        revolt_config::capture_error(&err);
@@ -196,7 +192,9 @@ pub async fn handle_ack_event(
                    .expect("Failed to fetch channel from db");

                if let TextChannel { server, .. } = channel {
-                    if let Err(err) = amqp.mass_mention_message_sent(server, mass_mentions).await {
+                    if let Err(err) =
+                        amqp.mass_mention_message_sent(server, mass_mentions).await
+                    {
                        revolt_config::capture_error(&err);
                    }
                } else {
--- a/crates/core/database/src/util/acker.rs
+++ b/crates/core/database/src/util/acker.rs
@@ -1,77 +0,0 @@
-use redis_kiss::{get_connection, AsyncCommands};
-use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
-use revolt_result::{Result, ToRevoltError};
-
-use crate::{events::client::EventV1, Channel, Database, Server, User, AMQP};
-
-pub async fn ack_channel(user: &str, channel: &str, message: &str, amqp: &AMQP) -> Result<()> {
-    let mut redis = get_connection()
-        .await
-        .map_err(|_| create_error!(InternalError))?;
-
-    let old: Option<String> = redis
-        .getset(format!("acker:{user}+{channel}"), message)
-        .await
-        .to_internal_error()?;
-
-    if old.is_none() || old.unwrap() == message {
-        amqp.process_ack(user, Some(channel), None)
-            .await
-            .to_internal_error()?;
-    }
-
-    Ok(())
-}
-
-pub async fn ack_server(user: &User, server: &Server, db: &Database, amqp: &AMQP) -> Result<()> {
-    let mut redis = get_connection()
-        .await
-        .map_err(|_| create_error!(InternalError))?;
-
-    let channels = db.fetch_channels(&server.channels).await?;
-    let query = crate::util::permissions::DatabasePermissionQuery::new(db, user).server(server);
-
-    for channel in channels {
-        let channel_id = channel.id();
-        let mut q = query.clone().channel(&channel);
-
-        if calculate_channel_permissions(&mut q)
-            .await
-            .has_channel_permission(ChannelPermission::ViewChannel)
-        {
-            let channel_last_msg = match &channel {
-                Channel::TextChannel {
-                    last_message_id, ..
-                } => last_message_id,
-                _ => unreachable!(),
-            }
-            .clone();
-
-            if let Some(channel_last_msg) = channel_last_msg {
-                let old: Option<String> = redis
-                    .getset(
-                        format!("acker:{}+{}", user.id, channel_id),
-                        &channel_last_msg,
-                    )
-                    .await
-                    .to_internal_error()?;
-
-                if old.is_none() || old.unwrap() == channel_last_msg {
-                    amqp.process_ack(&user.id, Some(channel_id), Some(&server.id))
-                        .await
-                        .to_internal_error()?;
-
-                    EventV1::ChannelAck {
-                        id: channel_id.to_string(),
-                        user: user.id.clone(),
-                        message_id: channel_last_msg,
-                    }
-                    .private(user.id.clone())
-                    .await;
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
--- a/crates/core/database/src/util/bridge/v0.rs
+++ b/crates/core/database/src/util/bridge/v0.rs
@@ -190,7 +190,6 @@ impl From<crate::Channel> for Channel {
                role_permissions,
                nsfw,
                voice,
-                slowmode,
            } => Channel::TextChannel {
                id,
                server,
@@ -202,7 +201,6 @@ impl From<crate::Channel> for Channel {
                role_permissions,
                nsfw,
                voice: voice.map(|voice| voice.into()),
-                slowmode,
            },
        }
    }
@@ -256,7 +254,6 @@ impl From<Channel> for crate::Channel {
                role_permissions,
                nsfw,
                voice,
-                slowmode,
            } => crate::Channel::TextChannel {
                id,
                server,
@@ -268,7 +265,6 @@ impl From<Channel> for crate::Channel {
                role_permissions,
                nsfw,
                voice: voice.map(|voice| voice.into()),
-                slowmode,
            },
        }
    }
@@ -287,8 +283,7 @@ 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()),
-            slowmode: value.slowmode,
+            voice: value.voice.map(|voice| voice.into())
        }
    }
 }
@@ -306,8 +301,7 @@ 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()),
-            slowmode: value.slowmode,
+            voice: value.voice.map(|voice| voice.into())
        }
    }
 }
@@ -412,16 +406,9 @@ impl From<crate::Metadata> for Metadata {
        match value {
            crate::Metadata::File => Metadata::File,
            crate::Metadata::Text => Metadata::Text,
-            crate::Metadata::Image {
-                width,
-                height,
-                thumbhash,
-                animated,
-            } => Metadata::Image {
+            crate::Metadata::Image { width, height } => Metadata::Image {
                width: width as usize,
                height: height as usize,
-                thumbhash,
-                animated,
            },
            crate::Metadata::Video { width, height } => Metadata::Video {
                width: width as usize,
@@ -437,16 +424,9 @@ impl From<Metadata> for crate::Metadata {
        match value {
            Metadata::File => crate::Metadata::File,
            Metadata::Text => crate::Metadata::Text,
-            Metadata::Image {
-                width,
-                height,
-                thumbhash,
-                animated,
-            } => crate::Metadata::Image {
+            Metadata::Image { width, height } => crate::Metadata::Image {
                width: width as isize,
                height: height as isize,
-                thumbhash,
-                animated,
            },
            Metadata::Video { width, height } => crate::Metadata::Video {
                width: width as isize,
@@ -535,9 +515,7 @@ 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 }
        }
    }
 }
@@ -713,7 +691,6 @@ impl From<crate::FieldsMember> for FieldsMember {
            crate::FieldsMember::CanReceive => FieldsMember::CanReceive,
            crate::FieldsMember::CanPublish => FieldsMember::CanPublish,
            crate::FieldsMember::JoinedAt => FieldsMember::JoinedAt,
-            crate::FieldsMember::VoiceChannel => FieldsMember::VoiceChannel,
        }
    }
 }
@@ -728,7 +705,6 @@ impl From<FieldsMember> for crate::FieldsMember {
            FieldsMember::CanReceive => crate::FieldsMember::CanReceive,
            FieldsMember::CanPublish => crate::FieldsMember::CanPublish,
            FieldsMember::JoinedAt => crate::FieldsMember::JoinedAt,
-            FieldsMember::VoiceChannel => crate::FieldsMember::VoiceChannel,
        }
    }
 }
@@ -920,13 +896,11 @@ impl From<SystemMessageChannels> for crate::SystemMessageChannels {
 impl From<crate::Role> for Role {
    fn from(value: crate::Role) -> Self {
        Role {
-            id: value.id,
            name: value.name,
            permissions: value.permissions,
            colour: value.colour,
            hoist: value.hoist,
            rank: value.rank,
-            icon: value.icon.map(|f| f.into()),
        }
    }
 }
@@ -934,13 +908,11 @@ impl From<crate::Role> for Role {
 impl From<Role> for crate::Role {
    fn from(value: Role) -> crate::Role {
        crate::Role {
-            id: value.id,
            name: value.name,
            permissions: value.permissions,
            colour: value.colour,
            hoist: value.hoist,
            rank: value.rank,
-            icon: value.icon.map(|f| f.into()),
        }
    }
 }
@@ -948,13 +920,11 @@ impl From<Role> for crate::Role {
 impl From<crate::PartialRole> for PartialRole {
    fn from(value: crate::PartialRole) -> Self {
        PartialRole {
-            id: value.id,
            name: value.name,
            permissions: value.permissions,
            colour: value.colour,
            hoist: value.hoist,
            rank: value.rank,
-            icon: value.icon.map(|f| f.into()),
        }
    }
 }
@@ -962,13 +932,11 @@ impl From<crate::PartialRole> for PartialRole {
 impl From<PartialRole> for crate::PartialRole {
    fn from(value: PartialRole) -> crate::PartialRole {
        crate::PartialRole {
-            id: value.id,
            name: value.name,
            permissions: value.permissions,
            colour: value.colour,
            hoist: value.hoist,
            rank: value.rank,
-            icon: value.icon.map(|f| f.into()),
        }
    }
 }
@@ -977,7 +945,6 @@ impl From<crate::FieldsRole> for FieldsRole {
    fn from(value: crate::FieldsRole) -> Self {
        match value {
            crate::FieldsRole::Colour => FieldsRole::Colour,
-            crate::FieldsRole::Icon => FieldsRole::Icon,
        }
    }
 }
@@ -986,7 +953,6 @@ impl From<FieldsRole> for crate::FieldsRole {
    fn from(value: FieldsRole) -> Self {
        match value {
            FieldsRole::Colour => crate::FieldsRole::Colour,
-            FieldsRole::Icon => crate::FieldsRole::Icon,
        }
    }
 }
@@ -1410,7 +1376,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
        }
    }
 }
@@ -1418,7 +1384,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
        }
    }
-}
+}
--- a/crates/core/database/src/util/idempotency.rs
+++ b/crates/core/database/src/util/idempotency.rs
@@ -10,16 +10,16 @@ use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize};

 #[derive(Serialize, Deserialize)]
-pub struct IdempotencyKey {
-    key: String,
-}
+#[cfg_attr(feature = "utoipa", derive(IntoParams))]
+#[cfg_attr(feature = "utoipa", into_params(names("Idempotency-Key"), parameter_in=Header))]
+pub struct IdempotencyKey(String);

 static TOKEN_CACHE: Lazy<Mutex<lru::LruCache<String, ()>>> =
    Lazy::new(|| Mutex::new(lru::LruCache::new(NonZeroUsize::new(1000).unwrap())));

 impl IdempotencyKey {
    pub fn unchecked_from_string(key: String) -> Self {
-        Self { key }
+        Self(key)
    }

    // Backwards compatibility.
@@ -32,56 +32,56 @@ impl IdempotencyKey {
            }

            cache.put(v.clone(), ());
-            self.key = v;
+            self.0 = v;
        }

        Ok(())
    }

    pub fn into_key(self) -> String {
-        self.key
+        self.0
    }
 }

-#[cfg(feature = "rocket-impl")]
-use revolt_rocket_okapi::{
-    gen::OpenApiGenerator,
-    request::{OpenApiFromRequest, RequestHeaderInput},
-    revolt_okapi::openapi3::{Parameter, ParameterValue},
-};
+// #[cfg(feature = "rocket-impl")]
+// use revolt_rocket_okapi::{
+//     gen::OpenApiGenerator,
+//     request::{OpenApiFromRequest, RequestHeaderInput},
+//     revolt_okapi::openapi3::{Parameter, ParameterValue},
+// };

-#[cfg(feature = "rocket-impl")]
-use schemars::schema::{InstanceType, SchemaObject, SingleOrVec};
+// #[cfg(feature = "rocket-impl")]
+// use schemars::schema::{InstanceType, SchemaObject, SingleOrVec};

-#[cfg(feature = "rocket-impl")]
-impl OpenApiFromRequest<'_> for IdempotencyKey {
-    fn from_request_input(
-        _gen: &mut OpenApiGenerator,
-        _name: String,
-        _required: bool,
-    ) -> revolt_rocket_okapi::Result<RequestHeaderInput> {
-        Ok(RequestHeaderInput::Parameter(Parameter {
-            name: "Idempotency-Key".to_string(),
-            description: Some("Unique key to prevent duplicate requests".to_string()),
-            allow_empty_value: false,
-            required: false,
-            deprecated: false,
-            extensions: schemars::Map::new(),
-            location: "header".to_string(),
-            value: ParameterValue::Schema {
-                allow_reserved: false,
-                example: None,
-                examples: None,
-                explode: None,
-                style: None,
-                schema: SchemaObject {
-                    instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
-                    ..Default::default()
-                },
-            },
-        }))
-    }
-}
+// #[cfg(feature = "rocket-impl")]
+// impl OpenApiFromRequest<'_> for IdempotencyKey {
+//     fn from_request_input(
+//         _gen: &mut OpenApiGenerator,
+//         _name: String,
+//         _required: bool,
+//     ) -> revolt_rocket_okapi::Result<RequestHeaderInput> {
+//         Ok(RequestHeaderInput::Parameter(Parameter {
+//             name: "Idempotency-Key".to_string(),
+//             description: Some("Unique key to prevent duplicate requests".to_string()),
+//             allow_empty_value: false,
+//             required: false,
+//             deprecated: false,
+//             extensions: schemars::Map::new(),
+//             location: "header".to_string(),
+//             value: ParameterValue::Schema {
+//                 allow_reserved: false,
+//                 example: None,
+//                 examples: None,
+//                 explode: None,
+//                 style: None,
+//                 schema: SchemaObject {
+//                     instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
+//                     ..Default::default()
+//                 },
+//             },
+//         }))
+//     }
+// }

 #[cfg(feature = "rocket-impl")]
 use rocket::{
@@ -110,18 +110,16 @@ impl<'r> FromRequest<'r> for IdempotencyKey {
                ));
            }

-            let idempotency = IdempotencyKey { key };
+            let idempotency = IdempotencyKey(key);
            let mut cache = TOKEN_CACHE.lock().await;
-            if cache.get(&idempotency.key).is_some() {
+            if cache.get(&idempotency.0).is_some() {
                return Outcome::Error((Status::Conflict, create_error!(DuplicateNonce)));
            }

-            cache.put(idempotency.key.clone(), ());
+            cache.put(idempotency.0.clone(), ());
            return Outcome::Success(idempotency);
        }

-        Outcome::Success(IdempotencyKey {
-            key: ulid::Ulid::new().to_string(),
-        })
+        Outcome::Success(IdempotencyKey(ulid::Ulid::new().to_string()))
    }
 }
--- a/crates/core/database/src/util/mod.rs
+++ b/crates/core/database/src/util/mod.rs
@@ -1,4 +1,3 @@
-pub mod acker;
 pub mod bridge;
 pub mod bulk_permissions;
 mod funcs;
@@ -6,5 +5,7 @@ pub mod idempotency;
 pub mod permissions;
 pub mod reference;
 pub mod test_fixtures;
+#[cfg(feature = "utoipa")]
+pub mod utoipa;

 pub use funcs::*;
--- a/crates/core/database/src/util/reference.rs
+++ b/crates/core/database/src/util/reference.rs
@@ -3,11 +3,6 @@ use std::str::FromStr;
 use revolt_result::Result;
 #[cfg(feature = "rocket-impl")]
 use rocket::request::FromParam;
-#[cfg(feature = "rocket-impl")]
-use schemars::{
-    schema::{InstanceType, Schema, SchemaObject, SingleOrVec},
-    JsonSchema,
-};

 use crate::{
    Bot, Channel, Database, Emoji, Invite, Member, Message, Server, ServerBan, User, Webhook,
@@ -112,17 +107,3 @@ impl<'r> FromParam<'r> for Reference<'r> {
        Ok(Reference::from_unchecked(param))
    }
 }
-
-#[cfg(feature = "rocket-impl")]
-impl<'a> JsonSchema for Reference<'a> {
-    fn schema_name() -> String {
-        "Id".to_string()
-    }
-
-    fn json_schema(_gen: &mut schemars::gen::SchemaGenerator) -> Schema {
-        Schema::Object(SchemaObject {
-            instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
-            ..Default::default()
-        })
-    }
-}
--- a/crates/core/database/src/util/utoipa.rs
+++ b/crates/core/database/src/util/utoipa.rs
@@ -0,0 +1,49 @@
+use utoipa::{
+    openapi::{
+        schema::SchemaType,
+        security::{ApiKey, ApiKeyValue, SecurityScheme},
+        ObjectBuilder, OpenApi, RefOr, Schema, Type,
+    },
+    Modify, PartialSchema, ToSchema,
+};
+
+use crate::util::reference::Reference;
+
+pub struct TokenSecurity;
+
+impl Modify for TokenSecurity {
+    fn modify(&self, openapi: &mut OpenApi) {
+        let components = openapi.components.get_or_insert_default();
+
+        components.add_security_scheme(
+            "Session-Token",
+            SecurityScheme::ApiKey(ApiKey::Header(ApiKeyValue::new(
+                "X-Session-Token".to_string(),
+            ))),
+        );
+
+        components.add_security_scheme(
+            "Bot-Token",
+            SecurityScheme::ApiKey(ApiKey::Header(ApiKeyValue::new("X-Bot-Ticket".to_string()))),
+        );
+    }
+}
+
+impl ToSchema for Reference<'_> {
+    fn name() -> std::borrow::Cow<'static, str> {
+        std::borrow::Cow::Borrowed("Reference")
+    }
+}
+
+impl PartialSchema for Reference<'_> {
+    fn schema() -> RefOr<Schema> {
+        RefOr::T(
+            ObjectBuilder::new()
+                .description(Some("An id referencing a stoat model."))
+                .schema_type(SchemaType::Type(Type::String))
+                .examples(["01FD58YK5W7QRV5H3D64KTQYX3"])
+                .build()
+                .into(),
+        )
+    }
+}
--- a/crates/core/database/src/voice/mod.rs
+++ b/crates/core/database/src/voice/mod.rs
@@ -1,5 +1,3 @@
-use std::fmt::{Display, Write};
-
 use crate::{
    events::client::EventV1,
    models::{Channel, User},
@@ -8,11 +6,7 @@ use crate::{
 };
 use iso8601_timestamp::{Duration, Timestamp};
 use livekit_protocol::ParticipantPermission;
-use redis_kiss::{
-    get_connection as _get_connection,
-    redis::{FromRedisValue, Pipeline, RedisError, RedisWrite, ToRedisArgs, Value},
-    AsyncCommands, Conn,
-};
+use redis_kiss::{get_connection as _get_connection, redis::Pipeline, AsyncCommands, Conn};
 use revolt_config::FeaturesLimits;
 use revolt_models::v0::{self, PartialUserVoiceState, UserVoiceState};
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission, PermissionValue};
@@ -22,60 +16,48 @@ 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: &UserVoiceChannel) -> Result<()> {
+pub async fn raise_if_in_voice(user: &User, channel_id: &str) -> 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)
+    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
+        && conn.sismember(format!("vc:{}", &user.id), channel_id)
            .await
            .to_internal_error()?
-        {
-            return Err(create_error!(AlreadyConnected));
-        };
+    {
+        Err(create_error!(AlreadyConnected))
    } else if conn
        .scard::<_, u32>(format!("vc:{}", &user.id)) // check if the current vc set is empty
        .await
        .to_internal_error()?
        > 0
    {
-        return Err(create_error!(AlreadyConnected));
-    };
-
-    Ok(())
+        Err(create_error!(AlreadyConnected))
+    } else {
+        Ok(())
+    }
 }

-pub async fn set_channel_node(channel_id: &str, node: &str) -> Result<()> {
+pub async fn set_channel_node(channel: &str, node: &str) -> Result<()> {
    get_connection()
        .await?
-        .set(format!("node:{channel_id}"), node)
+        .set(format!("node:{channel}"), node)
        .await
        .to_internal_error()
 }

-pub async fn get_channel_node(channel_id: &str) -> Result<Option<String>> {
+pub async fn get_channel_node(channel: &str) -> Result<Option<String>> {
    get_connection()
        .await?
-        .get(format!("node:{channel_id}"))
+        .get(format!("node:{channel}"))
        .await
        .to_internal_error()
 }

-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>> {
+pub async fn get_user_voice_channels(user_id: &str) -> Result<Vec<String>> {
    get_connection()
        .await?
        .smembers(format!("vc:{user_id}"))
@@ -84,14 +66,14 @@ pub async fn get_user_voice_channels(user_id: &str) -> Result<Vec<UserVoiceChann
 }

 pub async fn set_user_moved_from_voice(
-    old_channel_id: &str,
-    new_channel: &UserVoiceChannel,
+    old_channel: &str,
+    new_channel: &str,
    user_id: &str,
 ) -> Result<()> {
    get_connection()
        .await?
        .set_ex(
-            format!("moved_from:{user_id}:{old_channel_id}"),
+            format!("moved_from:{user_id}:{old_channel}"),
            new_channel,
            10,
        )
@@ -108,25 +90,18 @@ 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_id: &str,
-    old_channel: &UserVoiceChannel,
+    new_channel: &str,
+    old_channel: &str,
    user_id: &str,
 ) -> Result<()> {
    get_connection()
        .await?
-        .set_ex(
-            format!("moved_to:{user_id}:{new_channel_id}"),
-            old_channel,
-            10,
-        )
+        .set_ex(format!("moved_to:{user_id}:{new_channel}"), old_channel, 10)
        .await
        .to_internal_error()
 }

-pub async fn get_user_moved_to_voice(
-    channel_id: &str,
-    user_id: &str,
-) -> Result<Option<UserVoiceChannel>> {
+pub async fn get_user_moved_to_voice(channel_id: &str, user_id: &str) -> Result<Option<String>> {
    get_connection()
        .await?
        .get_del(format!("moved_to:{user_id}:{channel_id}"))
@@ -134,10 +109,10 @@ pub async fn get_user_moved_to_voice(
        .to_internal_error()
 }

-pub async fn is_in_voice_channel(user_id: &str, channel: &UserVoiceChannel) -> Result<bool> {
+pub async fn is_in_voice_channel(user_id: &str, channel_id: &str) -> Result<bool> {
    get_connection()
        .await?
-        .sismember(format!("vc:{user_id}"), channel)
+        .sismember(format!("vc:{user_id}"), channel_id)
        .await
        .to_internal_error()
 }
@@ -171,15 +146,12 @@ pub fn get_allowed_sources(
 }

 pub async fn create_voice_state(
-    channel: &UserVoiceChannel,
+    channel_id: &str,
+    server_id: Option<&str>,
    user_id: &str,
    joined_at: Timestamp,
 ) -> Result<UserVoiceState> {
-    let unique_key = format!(
-        "{}:{}",
-        &user_id,
-        channel.server_id.as_ref().unwrap_or(&channel.id)
-    );
+    let unique_key = format!("{}:{}", &user_id, server_id.unwrap_or(channel_id));

    let voice_state = UserVoiceState {
        joined_at,
@@ -191,9 +163,9 @@ pub async fn create_voice_state(
    };

    Pipeline::new()
-        .sadd(format!("vc_members:{}", &channel.id), user_id)
-        .sadd(format!("vc:{user_id}"), channel)
-        .set(&unique_key, &channel.id)
+        .sadd(format!("vc_members:{channel_id}"), user_id)
+        .sadd(format!("vc:{user_id}"), channel_id)
+        .set(&unique_key, channel_id)
        .set(
            format!("joined_at:{unique_key}"),
            joined_at
@@ -220,16 +192,16 @@ pub async fn create_voice_state(
    Ok(voice_state)
 }

-pub async fn delete_voice_state(channel: &UserVoiceChannel, user_id: &str) -> Result<()> {
-    let unique_key = format!(
-        "{}:{}",
-        &user_id,
-        channel.server_id.as_ref().unwrap_or(&channel.id)
-    );
+pub async fn delete_voice_state(
+    channel_id: &str,
+    server_id: Option<&str>,
+    user_id: &str,
+) -> Result<()> {
+    let unique_key = format!("{}:{}", &user_id, server_id.unwrap_or(channel_id));

    Pipeline::new()
-        .srem(format!("vc_members:{}", &channel.id), user_id)
-        .srem(format!("vc:{user_id}"), channel)
+        .srem(format!("vc_members:{channel_id}"), user_id)
+        .srem(format!("vc:{user_id}"), channel_id)
        .del(&[
            format!("joined_at:{unique_key}"),
            format!("is_publishing:{unique_key}"),
@@ -244,19 +216,19 @@ pub async fn delete_voice_state(channel: &UserVoiceChannel, user_id: &str) -> Re
 }

 pub async fn delete_channel_voice_state(
-    channel: &UserVoiceChannel,
+    channel_id: &str,
+    server_id: Option<&str>,
    user_ids: &[String],
 ) -> Result<()> {
-    let parent_id = channel.server_id.as_ref().unwrap_or(&channel.id);
+    let parent_id = server_id.unwrap_or(channel_id);

    let mut pipeline = Pipeline::new();
-    pipeline.del(format!("vc_members:{}", &channel.id));
-    pipeline.del(format!("node:{}", &channel.id));
+    pipeline.del(format!("vc_members:{channel_id}"));

    for user_id in user_ids {
        let unique_key = format!("{user_id}:{parent_id}");

-        pipeline.srem(format!("vc:{user_id}"), channel).del(&[
+        pipeline.srem(format!("vc:{user_id}"), channel_id).del(&[
            format!("joined_at:{unique_key}"),
            format!("is_publishing:{unique_key}"),
            format!("is_receiving:{unique_key}"),
@@ -273,7 +245,8 @@ pub async fn delete_channel_voice_state(
 }

 pub async fn update_voice_state_tracks(
-    channel: &UserVoiceChannel,
+    channel_id: &str,
+    server_id: Option<&str>,
    user_id: &str,
    added: bool,
    track: i32,
@@ -298,21 +271,18 @@ pub async fn update_voice_state_tracks(
        _ => unreachable!(),
    };

-    update_voice_state(channel, user_id, &partial).await?;
+    update_voice_state(channel_id, server_id, user_id, &partial).await?;

    Ok(partial)
 }

 pub async fn update_voice_state(
-    channel: &UserVoiceChannel,
+    channel_id: &str,
+    server_id: Option<&str>,
    user_id: &str,
    partial: &PartialUserVoiceState,
 ) -> Result<()> {
-    let unique_key = format!(
-        "{}:{}",
-        &user_id,
-        channel.server_id.as_ref().unwrap_or(&channel.id)
-    );
+    let unique_key = format!("{}:{}", &user_id, server_id.unwrap_or(channel_id));

    let mut pipeline = Pipeline::new();

@@ -338,24 +308,21 @@ pub async fn update_voice_state(
        .to_internal_error()
 }

-pub async fn get_voice_channel_members(channel: &UserVoiceChannel) -> Result<Option<Vec<String>>> {
+pub async fn get_voice_channel_members(channel_id: &str) -> 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: &UserVoiceChannel,
+    channel_id: &str,
+    server_id: Option<&str>,
    user_id: &str,
 ) -> Result<Option<UserVoiceState>> {
-    let unique_key = format!(
-        "{}:{}",
-        &user_id,
-        channel.server_id.as_ref().unwrap_or(&channel.id)
-    );
+    let unique_key = format!("{}:{}", user_id, server_id.unwrap_or(channel_id));

    let (joined_at, is_publishing, is_receiving, screensharing, camera) = get_connection()
        .await?
@@ -396,21 +363,21 @@ pub async fn get_voice_state(
    }
 }

-pub async fn get_channel_voice_state(
-    channel: &UserVoiceChannel,
-) -> Result<Option<v0::ChannelVoiceState>> {
-    let members = get_voice_channel_members(channel).await?;
+pub async fn get_channel_voice_state(channel: &Channel) -> Result<Option<v0::ChannelVoiceState>> {
+    let members = get_voice_channel_members(channel.id()).await?;
+
+    let server = channel.server();

    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, &user_id).await? {
+            if let Some(voice_state) = get_voice_state(channel.id(), server, &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, &user_id).await?;
+                delete_voice_state(channel.id(), server, &user_id).await?;
            }
        }

@@ -418,7 +385,7 @@ pub async fn get_channel_voice_state(
        participants.shrink_to_fit();

        Ok(Some(v0::ChannelVoiceState {
-            id: channel.id.clone(),
+            id: channel.id().to_string(),
            participants,
        }))
    } else {
@@ -426,12 +393,12 @@ pub async fn get_channel_voice_state(
    }
 }

-pub async fn move_user(user: &str, from_channel_id: &str, to_channel_id: &str) -> Result<()> {
+pub async fn move_user(user: &str, from: &str, to: &str) -> Result<()> {
    get_connection()
        .await?
        .smove(
-            format!("vc_members:{from_channel_id}"),
-            format!("vc_members:{to_channel_id}"),
+            format!("vc-members-{from}"),
+            format!("vc-members-{to}"),
            user,
        )
        .await
@@ -445,13 +412,11 @@ 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(&user_voice_channel)
+    for user_id in get_voice_channel_members(channel.id())
        .await?
        .iter()
        .flatten()
@@ -491,9 +456,7 @@ pub async fn sync_user_voice_permissions(
            .as_ref()
            .is_none_or(|member| member.roles.iter().any(|r| r == role_id))
    }) {
-        let user_voice_channel = UserVoiceChannel::from_channel(channel);
-
-        let Some(voice_state) = get_voice_state(&user_voice_channel, &user.id).await? else {
+        let Some(voice_state) = get_voice_state(channel_id, server_id, &user.id).await? else {
            return Ok(());
        };

@@ -524,7 +487,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(&user_voice_channel, &user.id, &update_event).await?;
+        update_voice_state(channel_id, server_id, &user.id, &update_event).await?;

        voice_client
            .update_permissions(
@@ -602,95 +565,34 @@ pub async fn get_call_notification_recipients(
        .to_internal_error()
 }

-pub async fn remove_user_from_voice_channels(
-    voice_client: &VoiceClient,
-    user_id: &str,
-) -> Result<()> {
-    for channel in get_user_voice_channels(user_id).await? {
-        remove_user_from_voice_channel(voice_client, &channel, user_id).await?;
-    }
-
-    Ok(())
-}
-
-pub async fn remove_user_from_voice_channel(
-    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: &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?;
-
-        delete_channel_voice_state(channel, &users).await?;
+pub async fn remove_user_from_voice_channels(db: &Database, voice_client: &VoiceClient, user_id: &str) -> Result<()> {
+    for channel_id in get_user_voice_channels(user_id).await? {
+        remove_user_from_voice_channel(db, voice_client, &channel_id, user_id).await?;
    };

    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 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;
    }

-    pub fn from_channel(channel: &Channel) -> Self {
-        Self {
-            id: channel.id().to_string(),
-            server_id: channel.server().map(ToString::to_string),
-        }
-    }
+    let channel = Reference::from_unchecked(channel_id).as_channel(db).await?;
+
+    delete_voice_state(channel_id, channel.server(), user_id).await?;
+
+    Ok(())
 }

-impl Display for UserVoiceChannel {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&self.id)?;
+pub async fn delete_voice_channel(voice_client: &VoiceClient, channel_id: &str, server_id: Option<&str>) -> Result<()> {
+    if let Some(users) = get_voice_channel_members(channel_id).await? {
+        let node = get_channel_node(channel_id).await?.unwrap();

-        if let Some(server_id) = &self.server_id {
-            f.write_char('-')?;
-            f.write_str(server_id)?
-        };
+        voice_client.delete_room(&node, channel_id).await?;

-        Ok(())
-    }
-}
+        delete_channel_voice_state(channel_id, server_id, &users).await?;
+    };

-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)
-    }
-}
+    Ok(())
+}
--- a/crates/core/database/src/voice/voice_client.rs
+++ b/crates/core/database/src/voice/voice_client.rs
@@ -1,6 +1,5 @@
 use crate::{
    models::{Channel, User},
-    voice::RoomMetadata,
    Database,
 };
 use livekit_api::{
@@ -103,16 +102,11 @@ 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()
                },
            )
--- a/crates/core/database/templates/deletion.whitelabel.txt
+++ b/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/
+https://developers.stoat.chat/faq.html
--- a/crates/core/database/templates/reset.whitelabel.txt
+++ b/crates/core/database/templates/reset.whitelabel.txt
@@ -4,6 +4,6 @@ Please navigate to: {{url}}

 This email is intended for {{email}}

-This email has no association with Stoat or Revolt Platforms Ltd.
+This email has no association with Revolt or Revolt Platforms Ltd.
 Learn more about third party instances here:
-https://developers.stoat.chat/faq/
+https://developers.revolt.chat/faq.html
--- a/crates/core/database/templates/suspension.html
+++ b/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://stoat.chat/legal/community-guidelines" style="color: #0d6efd;">Community Guidelines</a>.
+                                      <a href="https://revolt.chat/aup" style="color: #0d6efd;">Acceptable Usage Policy</a>.
                                    </p>
                                    <table class="s-4 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">
                                      <tbody>
--- a/crates/core/database/templates/suspension.txt
+++ b/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 Community Guidelines (https://stoat.chat/legal/community-guidelines).
+Further violations may result in a permanent ban depending on severity, please abide by the Acceptable Usage Policy (https://revolt.chat/aup).

 Ban evasion is prohibited and will be dealt with accordingly.

--- a/crates/core/database/templates/suspension.whitelabel.txt
+++ b/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 Stoat or Revolt Platforms Ltd.
+This email has no association with Revolt or Revolt Platforms Ltd.
 Learn more about third party instances here:
-https://developers.stoat.chat/faq/
+https://developers.revolt.chat/faq.html
--- a/crates/core/database/templates/verify.whitelabel.txt
+++ b/crates/core/database/templates/verify.whitelabel.txt
@@ -5,6 +5,6 @@ Please navigate to: {{url}}

 This email is intended for {{email}}

-This email has no association with Stoat or Revolt Platforms Ltd.
+This email has no association with Revolt or Revolt Platforms Ltd.
 Learn more about third party instances here:
-https://developers.stoat.chat/faq/
+https://developers.revolt.chat/faq.html
--- a/crates/core/files/Cargo.toml
+++ b/crates/core/files/Cargo.toml
@@ -1,48 +1,38 @@
 [package]
 name = "revolt-files"
-version = "0.13.7"
+version = "0.8.9"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
 description = "Revolt Backend: S3 and encryption subroutines"
-repository = "https://github.com/stoatchat/stoatchat"

 [dependencies]
-anyhow = { workspace = true }
-thiserror = { workspace = true }
+tracing = "0.1"

-tracing = { workspace = true }
+ffprobe = "0.4.0"
+imagesize = "0.13.0"
+tempfile = "3.12.0"

-tokio = { workspace = true }
-async-trait = { workspace = true }
+base64 = "0.22.1"
+aes-gcm = "0.10.3"
+typenum = "1.17.0"

-ffprobe = { workspace = true }
-imagesize = { workspace = true }
-tempfile = { workspace = true }
+aws-config = "1.5.5"
+aws-sdk-s3 = { version = "1.46.0", features = ["behavior-version-latest"] }

-base64 = { workspace = true }
-aes-gcm = { workspace = true }
-typenum = { workspace = true }
-
-aws-config = { workspace = true }
-aws-sdk-s3 = { workspace = true, features = ["behavior-version-latest"] }
-
-revolt-config = { workspace = true, features = [
+revolt-config = { version = "0.8.9", path = "../config", features = [
    "report-macros",
 ] }
-revolt-result = { workspace = true }
+revolt-result = { version = "0.8.9", path = "../result" }

 # image processing
-jxl-oxide = { workspace = true, features = ["image"] }
-image = { workspace = true }
+jxl-oxide = "0.8.1"
+image = { version = "0.25.2" }

 # svg rendering
-usvg = { workspace = true }
-resvg = { workspace = true }
-tiny-skia = { workspace = true }
+usvg = "0.44.0"
+resvg = "0.44.0"
+tiny-skia = "0.11.4"

 # encoding
-webp = { workspace = true }
-
-[dev-dependencies]
-uuid = { workspace = true, features = ["v4"] }
+webp = "0.3.0"
--- a/crates/core/files/src/implementation/encryption_impl.rs
+++ b/crates/core/files/src/implementation/encryption_impl.rs
@@ -1,75 +0,0 @@
-use aes_gcm::{
-    aead::{Aead, AeadCore, AeadMutInPlace, OsRng},
-    Aes256Gcm, Key, KeyInit, Nonce,
-};
-use base64::{prelude::BASE64_STANDARD, Engine};
-
-use crate::EncryptionRepository;
-
-pub struct EncryptionKey {
-    key: String,
-}
-
-impl EncryptionKey {
-    pub async fn from_config() -> EncryptionKey {
-        EncryptionKey::new(revolt_config::config().await.files.encryption_key)
-    }
-
-    pub fn new(key: String) -> EncryptionKey {
-        EncryptionKey { key }
-    }
-
-    fn create_cipher(&self) -> Aes256Gcm {
-        let key = &BASE64_STANDARD
-            .decode(self.key.clone())
-            .expect("valid base64 string")[..];
-        let key: &Key<Aes256Gcm> = key.into();
-        Aes256Gcm::new(key)
-    }
-}
-
-impl EncryptionRepository for EncryptionKey {
-    fn decrypt_buffer(&self, mut buf: Vec<u8>, iv: &str) -> anyhow::Result<Vec<u8>> {
-        let iv = &BASE64_STANDARD.decode(iv).unwrap()[..];
-        let iv: &Nonce<typenum::consts::U12> = iv.into();
-
-        self.create_cipher()
-            .decrypt_in_place(iv, b"", &mut buf)
-            .map_err(|error| {
-                tracing::error!("{}", error);
-                anyhow::anyhow!("EncryptionRepository: decryption failed")
-            })?;
-
-        Ok(buf)
-    }
-
-    fn encrypt_buffer(&self, buf: &[u8]) -> anyhow::Result<(Vec<u8>, String)> {
-        let iv = Aes256Gcm::generate_nonce(&mut OsRng);
-
-        let buf = self.create_cipher().encrypt(&iv, buf).map_err(|error| {
-            tracing::error!("{}", error);
-            anyhow::anyhow!("EncryptionRepository: encryption failed")
-        })?;
-
-        Ok((buf, BASE64_STANDARD.encode(iv)))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_encrypt_and_decrypt() {
-        let encryption =
-            EncryptionKey::new("XkbJ8gBzrouQ+15Ri23xCC81+aZE26Z6+gXzglFxOD4=".to_string());
-
-        let buf: Vec<u8> = vec![67];
-        let (ciphertext, iv) = encryption.encrypt_buffer(&buf[..]).unwrap();
-        assert_eq!(ciphertext.len(), 17);
-
-        let plaintext = encryption.decrypt_buffer(ciphertext, &iv).unwrap();
-        assert_eq!(plaintext.len(), 1);
-        assert_eq!(plaintext[0], 67);
-    }
-}
--- a/crates/core/files/src/implementation/media_impl.rs
+++ b/crates/core/files/src/implementation/media_impl.rs
@@ -1,395 +0,0 @@
-use anyhow::Result;
-use image::{AnimationDecoder, DynamicImage, ImageBuffer, ImageReader};
-use jxl_oxide::integration::JxlDecoder;
-use revolt_config::report_internal_error;
-use std::io::{BufRead, Read, Seek};
-use tempfile::NamedTempFile;
-use tiny_skia::Pixmap;
-
-use crate::{MediaError, MediaRepository};
-
-pub struct MediaImpl {
-    config: revolt_config::Files,
-}
-
-impl MediaImpl {
-    pub async fn from_config() -> MediaImpl {
-        MediaImpl {
-            config: revolt_config::config().await.files,
-        }
-    }
-
-    pub fn new(config: revolt_config::Files) -> MediaImpl {
-        MediaImpl { config }
-    }
-}
-
-impl MediaRepository for MediaImpl {
-    fn image_size(&self, f: &NamedTempFile) -> Option<(usize, usize)> {
-        if let Ok(size) = imagesize::size(f.path())
-            .inspect_err(|err| tracing::error!("Failed to generate image size! {err:?}"))
-        {
-            Some((size.width, size.height))
-        } else {
-            None
-        }
-    }
-
-    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" => {
-                let tree =
-                    report_internal_error!(usvg::Tree::from_data(v, &Default::default())).ok()?;
-
-                let size = tree.size();
-                Some((size.width() as usize, size.height() as usize))
-            }
-            _ => {
-                if let Ok(size) = imagesize::blob_size(v)
-                    .inspect_err(|err| tracing::error!("Failed to generate image size! {err:?}"))
-                {
-                    Some((size.width, size.height))
-                } else {
-                    None
-                }
-            }
-        }
-    }
-
-    fn decode_image<R: Read + BufRead + Seek>(
-        &self,
-        reader: &mut R,
-        mime: &str,
-    ) -> Result<DynamicImage, MediaError> {
-        match mime {
-            "image/jxl" => {
-                let decoder =
-                    JxlDecoder::new(reader).map_err(|e| MediaError::from(anyhow::anyhow!(e)))?;
-
-                DynamicImage::from_decoder(decoder)
-                    .map_err(|e| MediaError::from(anyhow::anyhow!(e)))
-            }
-            "image/svg+xml" => {
-                let mut buf = Vec::new();
-                reader
-                    .read_to_end(&mut buf)
-                    .map_err(|e| MediaError::from(anyhow::anyhow!(e)))?;
-
-                let tree: usvg::Tree = usvg::Tree::from_data(&buf, &Default::default())
-                    .map_err(|e| MediaError::from(anyhow::anyhow!(e)))?;
-
-                let size = tree.size();
-                let mut pixmap = Pixmap::new(size.width() as u32, size.height() as u32)
-                    .ok_or_else(|| MediaError::ImageProcessingFailed {
-                        cause: "failed to create Pixmap, likely zero sized".to_string(),
-                    })?;
-
-                let mut pixmap_mut = pixmap.as_mut();
-                resvg::render(&tree, Default::default(), &mut pixmap_mut);
-
-                Ok(DynamicImage::ImageRgba8(
-                    ImageBuffer::from_vec(
-                        size.width() as u32,
-                        size.height() as u32,
-                        pixmap.data().to_vec(),
-                    )
-                    .ok_or_else(|| MediaError::ImageProcessingFailed {
-                        cause: "buffer is not big enough".to_string(),
-                    })?,
-                ))
-            }
-            _ => {
-                let image: ImageReader<&mut R> = image::ImageReader::new(reader)
-                    .with_guessed_format()
-                    .map_err(|e| MediaError::from(anyhow::anyhow!(e)))?;
-
-                let image: Result<DynamicImage, MediaError> = image
-                    .decode()
-                    .map_err(|e| MediaError::from(anyhow::anyhow!(e)));
-
-                image
-            }
-        }
-    }
-
-    fn is_valid_image<R: Read + BufRead + Seek>(&self, reader: &mut R, mime: &str) -> bool {
-        match mime {
-            "image/jxl" => jxl_oxide::JxlImage::builder()
-                .read(reader)
-                .inspect_err(|err| tracing::error!("Failed to read JXL! {err:?}"))
-                .is_ok(),
-            _ => !matches!(
-                image::ImageReader::new(reader)
-                    .with_guessed_format()
-                    .inspect_err(|err| tracing::error!("Failed to read image! {err:?}"))
-                    .map(|f| f.decode()),
-                Err(_) | Ok(Err(_))
-            ),
-        }
-    }
-
-    fn create_thumbnail(&self, image: DynamicImage, tag: &str) -> Vec<u8> {
-        let [w, h] = self.config.preview.get(tag).unwrap();
-
-        let image = image.thumbnail(image.width().min(*w as u32), image.height().min(*h as u32));
-        let image = match image {
-            DynamicImage::ImageRgb8(_) => image,
-            DynamicImage::ImageRgba8(_) => image,
-            _ => {
-                if image.has_alpha() {
-                    image.to_rgba8().into()
-                } else {
-                    image.to_rgb8().into()
-                }
-            }
-        };
-
-        let encoder = webp::Encoder::from_image(&image).expect("Could not create encoder.");
-        if self.config.webp_quality != 100.0 {
-            encoder.encode(self.config.webp_quality).to_vec()
-        } else {
-            encoder.encode_lossless().to_vec()
-        }
-    }
-
-    fn video_size(&self, f: &NamedTempFile) -> Option<(i64, i64)> {
-        if let Ok(data) = ffprobe::ffprobe(f.path())
-            .inspect_err(|err| tracing::error!("Failed to ffprobe file! {err:?}"))
-        {
-            for stream in data.streams {
-                if let (Some(w), Some(h)) = (stream.width, stream.height) {
-                    return Some((w, h));
-                }
-            }
-
-            None
-        } else {
-            None
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{MediaImpl, MediaRepository};
-    use std::io::{Cursor, Write};
-    use tempfile::NamedTempFile;
-
-    #[tokio::test]
-    async fn asset_test_jpeg() {
-        let media = MediaImpl::from_config().await;
-        let buf = include_bytes!("../../tests/assets/test.jpeg");
-        assert_eq!(media.image_size_vec(buf, "image/jpeg"), Some((655, 582)));
-
-        let mut reader = Cursor::new(buf);
-        let image = media.decode_image(&mut reader, "image/jpeg").unwrap();
-        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;
-        let buf = [
-            &include_bytes!("../../tests/assets/test.jpeg")[..],
-            &[0u8; 16],
-        ]
-        .concat();
-        assert_eq!(media.image_size_vec(&buf, "image/jpeg"), Some((655, 582)));
-
-        let mut reader = Cursor::new(buf);
-        let image = media.decode_image(&mut reader, "image/jpeg").unwrap();
-        media.create_thumbnail(image, "emojis");
-    }
-
-    #[tokio::test]
-    async fn asset_test_png() {
-        let media = MediaImpl::from_config().await;
-        let buf = include_bytes!("../../tests/assets/test.png");
-        assert_eq!(media.image_size_vec(buf, "image/png"), Some((900, 900)));
-
-        let mut reader = Cursor::new(buf);
-        let image = media.decode_image(&mut reader, "image/png").unwrap();
-        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;
-        let buf = [
-            &include_bytes!("../../tests/assets/test.png")[..],
-            &[0u8; 16],
-        ]
-        .concat();
-        assert_eq!(media.image_size_vec(&buf, "image/png"), Some((900, 900)));
-
-        let mut reader = Cursor::new(buf);
-        let image = media.decode_image(&mut reader, "image/png").unwrap();
-        media.create_thumbnail(image, "emojis");
-    }
-
-    #[tokio::test]
-    async fn asset_test_floating_point_png() {
-        let media = MediaImpl::from_config().await;
-        let buf = include_bytes!("../../tests/assets/test-float.png");
-        assert_eq!(media.image_size_vec(buf, "image/png"), Some((300, 300)));
-
-        let mut reader = Cursor::new(buf);
-        let image = media.decode_image(&mut reader, "image/png").unwrap();
-        media.create_thumbnail(image, "avatars");
-    }
-
-    #[tokio::test]
-    async fn asset_test_corrupted_png() {
-        let media = MediaImpl::from_config().await;
-        let buf = include_bytes!("../../tests/assets/corrupted.png");
-        assert_eq!(media.image_size_vec(buf, "image/png"), Some((900, 900)));
-
-        let mut reader = Cursor::new(buf);
-        media.decode_image(&mut reader, "image/png").unwrap_err();
-    }
-
-    #[tokio::test]
-    async fn asset_test_animated_png() {
-        let media = MediaImpl::from_config().await;
-        let buf = include_bytes!("../../tests/assets/anim-icos.apng");
-        assert_eq!(media.image_size_vec(buf, "image/png"), Some((128, 128)));
-
-        let mut reader = Cursor::new(buf);
-        let image = media.decode_image(&mut reader, "image/png").unwrap();
-        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;
-        let buf = include_bytes!("../../tests/assets/dice.jxl");
-        assert_eq!(media.image_size_vec(buf, "image/jxl"), Some((800, 600)));
-
-        let mut reader = Cursor::new(buf);
-        let image = media.decode_image(&mut reader, "image/jxl").unwrap();
-        media.create_thumbnail(image, "attachments");
-    }
-
-    #[tokio::test]
-    async fn asset_test_animated_jxl() {
-        let media = MediaImpl::from_config().await;
-        let buf = include_bytes!("../../tests/assets/anim-icos.jxl");
-        assert_eq!(media.image_size_vec(buf, "image/jxl"), Some((128, 128)));
-
-        let mut reader = Cursor::new(buf);
-        let image = media.decode_image(&mut reader, "image/jxl").unwrap();
-        media.create_thumbnail(image, "attachments");
-    }
-
-    #[tokio::test]
-    async fn asset_test_webp() {
-        let media = MediaImpl::from_config().await;
-        let buf = include_bytes!("../../tests/assets/dice.webp");
-        assert_eq!(media.image_size_vec(buf, "image/webp"), Some((800, 600)));
-
-        let mut reader = Cursor::new(buf);
-        let image = media.decode_image(&mut reader, "image/webp").unwrap();
-        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;
-        let buf = include_bytes!("../../tests/assets/anim-icos.webp");
-        assert_eq!(media.image_size_vec(buf, "image/webp"), Some((128, 128)));
-
-        let mut reader = Cursor::new(buf);
-        let image = media.decode_image(&mut reader, "image/webp").unwrap();
-        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;
-        let buf = include_bytes!("../../tests/assets/anim-icos.gif");
-        assert_eq!(media.image_size_vec(buf, "image/gif"), Some((128, 128)));
-
-        let mut reader = Cursor::new(buf);
-        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));
-    }
-}
--- a/crates/core/files/src/implementation/mod.rs
+++ b/crates/core/files/src/implementation/mod.rs
@@ -1,7 +0,0 @@
-mod encryption_impl;
-mod media_impl;
-mod s3_impl;
-
-pub use encryption_impl::EncryptionKey;
-pub use media_impl::MediaImpl;
-pub use s3_impl::S3Storage;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Zomatree	7780aa69c0	fix: manually specify params	2025-11-18 14:57:34 +00:00
Zomatree	d198796fde	Merge remote-tracking branch 'origin/main' into chore/utoipa	2025-11-17 23:11:21 +00:00
Zomatree	43c94b68b0	chore: update routes to use utoipa	2025-11-17 22:13:07 +00:00
Zomatree	ac60b2c795	chore: update everything to work with utoipa	2025-11-13 23:06:41 +00:00