refactor: Rename PduBuilder to PartialPdu

Co-authored-by: Jade Ellis <jade@ellis.link>

.envrc

@@ -2,7 +2,7 @@
 
 dotenv_if_exists
 
-if command -v nix >/dev/null 2>&1; then
+if [ -f /etc/os-release ] && grep -q '^ID=nixos' /etc/os-release; then
     use flake ".#${DIRENV_DEVSHELL:-default}"
 fi
 

.forgejo/actions/sccache/action.yml

@@ -9,7 +9,7 @@ runs:
   - name: Install sccache
     uses: https://git.tomfos.tr/tom/sccache-action@v1
   - name: Configure sccache
-    uses: https://github.com/actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9
+    uses: https://github.com/actions/github-script@v8
     with:
       script: |
         core.exportVariable('ACTIONS_RESULTS_URL', process.env.ACTIONS_RESULTS_URL || '');

.forgejo/actions/setup-rust/action.yml

@@ -149,6 +149,37 @@ runs:
     - name: Setup sccache
       uses: https://git.tomfos.tr/tom/sccache-action@v1
 
+    - name: Cache dependencies
+      id: deps-cache
+      uses: actions/cache@v4
+      with:
+        path: |
+          target/**/.fingerprint
+          target/**/deps
+          target/**/*.d
+          target/**/.cargo-lock
+          target/**/CACHEDIR.TAG
+          target/**/.rustc_info.json
+          /timelord/
+        # Dependencies cache - based on Cargo.lock, survives source code changes
+        key: >-
+          continuwuity-deps-${{ steps.runner-os.outputs.slug }}-${{ steps.runner-os.outputs.arch }}-${{ steps.rust-setup.outputs.version }}${{ inputs.cache-key-suffix && format('-{0}', inputs.cache-key-suffix) || '' }}-${{ hashFiles('rust-toolchain.toml', '**/Cargo.lock') }}
+        restore-keys: |
+          continuwuity-deps-${{ steps.runner-os.outputs.slug }}-${{ steps.runner-os.outputs.arch }}-${{ steps.rust-setup.outputs.version }}${{ inputs.cache-key-suffix && format('-{0}', inputs.cache-key-suffix) || '' }}-
+
+    - name: Cache incremental compilation
+      id: incremental-cache
+      uses: actions/cache@v4
+      with:
+        path: |
+          target/**/incremental
+        # Incremental cache - based on source code changes
+        key: >-
+          continuwuity-incremental-${{ steps.runner-os.outputs.slug }}-${{ steps.runner-os.outputs.arch }}-${{ steps.rust-setup.outputs.version }}${{ inputs.cache-key-suffix && format('-{0}', inputs.cache-key-suffix) || '' }}-${{ hashFiles('rust-toolchain.toml', '**/Cargo.lock') }}-${{ hashFiles('**/*.rs', '**/Cargo.toml') }}
+        restore-keys: |
+          continuwuity-incremental-${{ steps.runner-os.outputs.slug }}-${{ steps.runner-os.outputs.arch }}-${{ steps.rust-setup.outputs.version }}${{ inputs.cache-key-suffix && format('-{0}', inputs.cache-key-suffix) || '' }}-${{ hashFiles('rust-toolchain.toml', '**/Cargo.lock') }}-
+          continuwuity-incremental-${{ steps.runner-os.outputs.slug }}-${{ steps.runner-os.outputs.arch }}-${{ steps.rust-setup.outputs.version }}${{ inputs.cache-key-suffix && format('-{0}', inputs.cache-key-suffix) || '' }}-
+
     - name: End build cache restore group
       shell: bash
       run: echo "::endgroup::"

.forgejo/workflows/check-changelog.yml

@@ -55,7 +55,7 @@ jobs:
           fi
 
       - name: Manage PR Comment
-        uses: https://github.com/actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9
+        uses: https://github.com/actions/github-script@v8
         env:
           HAS_CHANGELOG: ${{ steps.check_files.outputs.has_changelog }}
           SRC_CHANGED: ${{ steps.check_files.outputs.src_changed }}

.forgejo/workflows/mirror-images.yml

@@ -51,8 +51,10 @@ jobs:
       #     owner: continuwuity
       #     repositories: continuwuity
 
-      - name: Install regsync
-        uses: https://github.com/regclient/actions/regsync-installer@main
+      - name: Install regctl
+        uses: https://forgejo.ellis.link/continuwuation/regclient-actions/regctl-installer@main
+        with:
+          binary: regsync
 
       - name: Check what images need mirroring
         run: |

.forgejo/workflows/update-flake-hashes.yml

@@ -16,19 +16,48 @@ jobs:
     steps:
       - uses: actions/checkout@v6
         with:
+          fetch-depth: 0
+          fetch-tags: false
+          fetch-single-branch: true
+          submodules: false
           persist-credentials: true
           token: ${{ secrets.FORGEJO_TOKEN }}
 
-      - name: Install Lix
-        uses: https://github.com/samueldr/lix-gha-installer-action@f5e94192f565f53d84f41a056956dc0d3183b343
+      - uses: https://github.com/cachix/install-nix-action@19effe9fe722874e6d46dd7182e4b8b7a43c4a99 # v31.10.0
         with:
-          extra_nix_config: experimental-features = nix-command flakes flake-self-attrs
+          nix_path: nixpkgs=channel:nixos-unstable
+
+        # We can skip getting a toolchain hash if this was ran as a dispatch with the intent
+        # to update just the rocksdb hash. If this was ran as a dispatch and the toolchain
+        # files are changed, we still update them, as well as the rocksdb import.
+      - name: Detect changed files
+        id: changes
+        run: |
+          git fetch origin ${{ github.base_ref }} --depth=1 || true
+          if [ -n "${{ github.event.pull_request.base.sha }}" ]; then
+            base=${{ github.event.pull_request.base.sha }}
+          else
+            base=$(git rev-parse HEAD~1)
+          fi
+          echo "Base: $base"
+          echo "HEAD: $(git rev-parse HEAD)"
+          git diff --name-only $base HEAD > changed_files.txt
+          echo "detected changes in $(cat changed_files.txt)"
+          # Join files with commas
+          files=$(paste -sd, changed_files.txt)
+          echo "files=$files" >> $FORGEJO_OUTPUT
+
+      - name: Debug output
+        run: |
+          echo "State of output"
+          echo "Changed files: ${{ steps.changes.outputs.files }}"
 
       - name: Get new toolchain hash
+        if: contains(steps.changes.outputs.files, 'Cargo.toml') || contains(steps.changes.outputs.files, 'Cargo.lock') || contains(steps.changes.outputs.files, 'rust-toolchain.toml')
         run: |
           # Set the current sha256 to an empty hash to make `nix build` calculate a new one
-          awk '/fromToolchainFile *\{/{found=1; print; next} found && /sha256 =/{sub(/sha256 = .*/, "sha256 = lib.fakeSha256;"); found=0} 1' nix/rust.nix > temp.nix
-          mv temp.nix nix/rust.nix
+          awk '/fromToolchainFile *\{/{found=1; print; next} found && /sha256 =/{sub(/sha256 = .*/, "sha256 = lib.fakeSha256;"); found=0} 1' nix/packages/rust.nix > temp.nix
+          mv temp.nix nix/packages/rust.nix
 
           # Build continuwuity and filter for the new hash
           # We do `|| true` because we want this to fail without stopping the workflow
@@ -36,17 +65,36 @@ jobs:
 
           # Place the new hash in place of the empty hash
           new_hash=$(cat new_toolchain_hash.txt)
-          sed -i "s|lib.fakeSha256|\"$new_hash\"|" nix/rust.nix
+          sed -i "s|lib.fakeSha256|\"$new_hash\"|" nix/packages/rust.nix
 
           echo "New hash:"
-          awk -F'"' '/fromToolchainFile/{found=1; next} found && /sha256 =/{print $2; found=0}' nix/rust.nix
+          awk -F'"' '/fromToolchainFile/{found=1; next} found && /sha256 =/{print $2; found=0}' nix/packages/rust.nix
           echo "Expected new hash:"
           cat new_toolchain_hash.txt
 
           rm new_toolchain_hash.txt
 
-      - name: Update rocksdb
-        run: nix run .#update-rocksdb
+      - name: Get new rocksdb hash
+        if: contains(steps.changes.outputs.files, '.nix') || contains(steps.changes.outputs.files, 'flake.lock')
+        run: |
+          # Set the current sha256 to an empty hash to make `nix build` calculate a new one
+          awk '/repo = "rocksdb";/{found=1; print; next} found && /sha256 =/{sub(/sha256 = .*/, "sha256 = lib.fakeSha256;"); found=0} 1' nix/packages/rocksdb/package.nix > temp.nix
+          mv temp.nix nix/packages/rocksdb/package.nix
+
+          # Build continuwuity and filter for the new hash
+          # We do `|| true` because we want this to fail without stopping the workflow
+          nix build .#default 2>&1 | tee >(grep 'got:' | awk '{print $2}' > new_rocksdb_hash.txt) || true
+
+          # Place the new hash in place of the empty hash
+          new_hash=$(cat new_rocksdb_hash.txt)
+          sed -i "s|lib.fakeSha256|\"$new_hash\"|" nix/packages/rocksdb/package.nix
+
+          echo "New hash:"
+          awk -F'"' '/repo = "rocksdb";/{found=1; next} found && /sha256 =/{print $2; found=0}' nix/packages/rocksdb/package.nix
+          echo "Expected new hash:"
+          cat new_rocksdb_hash.txt
+
+          rm new_rocksdb_hash.txt
 
       - name: Show diff
         run: git diff flake.nix nix

Cargo.toml

@@ -39,7 +39,7 @@ features = ["ffi", "std", "union"]
 version = "0.7.0"
 
 [workspace.dependencies.ctor]
-version = "0.9.0"
+version = "0.6.0"
 
 [workspace.dependencies.cargo_toml]
 version = "0.22"
@@ -68,7 +68,7 @@ default-features = false
 version = "0.1.3"
 
 [workspace.dependencies.rand]
-version = "0.10.1"
+version = "0.10.0"
 
 # Used for the http request / response body type for Ruma endpoints used with reqwest
 [workspace.dependencies.bytes]
@@ -159,7 +159,7 @@ features = ["raw_value"]
 
 # Used for appservice registration files
 [workspace.dependencies.serde-saphyr]
-version = "0.0.23"
+version = "0.0.21"
 
 # Used to load forbidden room/user regex from config
 [workspace.dependencies.serde_regex]
@@ -167,7 +167,7 @@ version = "1.1.0"
 
 # Used for ruma wrapper
 [workspace.dependencies.serde_html_form]
-version = "0.4.0"
+version = "0.2.6"
 
 # Used for password hashing
 [workspace.dependencies.argon2]
@@ -346,8 +346,8 @@ version = "1.1.1"
 # Used for matrix spec type definitions and helpers
 [workspace.dependencies.ruma]
 # version = "0.14.1"
-git = "https://github.com/gingershaped/ruwuma.git"
-rev = "ce7ea072a3d47f1e674bb4badcb2af15b30e4088"
+git = "https://github.com/ruma/ruma.git"
+rev = "e2e5fece57800a2559ab028fd775a7978f3725e9"
 features = [
     "appservice-api-c",
     "client-api",
@@ -365,22 +365,19 @@ features = [
     "unstable-msc3061",
     "unstable-msc3814",
     "unstable-msc3245",
-    "unstable-msc3381",
-    "unstable-msc3489",
-    "unstable-msc3930",
+    "unstable-msc3381", # polls
+    "unstable-msc3489", # beacon / live location
+    "unstable-msc3930", # polls push rules
     "unstable-msc4075",
     "unstable-msc4095",
     "unstable-msc4121",
     "unstable-msc4125",
     "unstable-msc4186",
-    "unstable-msc4195",
-    "unstable-msc4203",
+    "unstable-msc4203", # sending to-device events to appservices
     "unstable-msc4310",
-    "unstable-msc4373",
     "unstable-msc4380",
-    "unstable-msc4143",
-    "unstable-msc4406",
-    "unstable-msc4439",
+    "unstable-msc4143", # livekit well_known response
+    "unstable-msc4439", # pgp_key in .well_known/matrix/support
     "unstable-extensible-events",
 ]
 

changelog.d/+7409b1db.feature.md

@@ -1 +0,0 @@
-Added support for requiring users to accept terms and conditions when registering.

changelog.d/+75749b75.misc.md

@@ -1 +0,0 @@
-Switched from Continuwuity's fork of Ruma back to upstream Ruma, unblocking exciting new features such as OAuth login. Contributed by @ginger.

changelog.d/1596.bugfix

@@ -1 +0,0 @@
-Refactored nix package. Breaking, since `all-features` package no longer exists. Continuwuity is now built with jemalloc and liburing by default. Contributed by @Henry-Hiles (QuadRadical).

changelog.d/1620.misc

@@ -1 +0,0 @@
-Fixed compiler warning in cf_opts.rs when building in release. Contributed by @ezera.

changelog.d/1623.bugfix

@@ -1 +0,0 @@
-Fixed "Sender must be a local user" error for make_join, make_knock, and make_leave federation routes. Contributed by @nex.

changelog.d/1629.feature.md

@@ -1 +0,0 @@
-Added admin commands to get build information and features. Contributed by @Jade

changelog.d/1630.bugfix

@@ -1 +0,0 @@
-Fixed restricted joins not being signed when we are being used as an authorising server. Contributed by @nex, reported by [vel](matrix:u/vel:nhjkl.com?action=chat).

conduwuit-example.toml

@@ -523,18 +523,6 @@
 #
 #recaptcha_private_site_key =
 
-# Policy documents, such as terms and conditions or a privacy policy,
-# which users must agree to when registering an account.
-#
-# Example:
-# ```ignore
-# [global.registration_terms.privacy_policy]
-# en = { name = "Privacy Policy", url = "https://homeserver.example/en/privacy_policy.html" }
-# es = { name = "Política de Privacidad", url = "https://homeserver.example/es/privacy_policy.html" }
-# ```
-#
-#registration_terms = {}
-
 # Controls whether encrypted rooms and events are allowed.
 #
 #allow_encryption = true
@@ -573,6 +561,18 @@
 #
 #allow_public_room_directory_over_federation = false
 
+# Allow guests/unauthenticated users to access TURN credentials.
+#
+# This is the equivalent of Synapse's `turn_allow_guests` config option.
+# This allows any unauthenticated user to call the endpoint
+# `/_matrix/client/v3/voip/turnServer`.
+#
+# It is unlikely you need to enable this as all major clients support
+# authentication for this endpoint and prevents misuse of your TURN server
+# from potential bots.
+#
+#turn_allow_guests = false
+
 # Set this to true to lock down your server's public room directory and
 # only allow admins to publish rooms to the room directory. Unpublishing
 # is still allowed by all users with this enabled.

docker/Dockerfile

@@ -48,7 +48,7 @@ EOF
 
 # Developer tool versions
 # renovate: datasource=github-releases depName=cargo-bins/cargo-binstall
-ENV BINSTALL_VERSION=1.17.9
+ENV BINSTALL_VERSION=1.17.8
 # renovate: datasource=github-releases depName=psastras/sbom-rs
 ENV CARGO_SBOM_VERSION=0.9.1
 # renovate: datasource=crate depName=lddtree

docker/musl.Dockerfile

@@ -18,7 +18,7 @@ RUN --mount=type=cache,target=/etc/apk/cache apk add \
 
 # Developer tool versions
 # renovate: datasource=github-releases depName=cargo-bins/cargo-binstall
-ENV BINSTALL_VERSION=1.17.9
+ENV BINSTALL_VERSION=1.17.8
 # renovate: datasource=github-releases depName=psastras/sbom-rs
 ENV CARGO_SBOM_VERSION=0.9.1
 # renovate: datasource=crate depName=lddtree

docs/deploying/generic.mdx

@@ -14,7 +14,6 @@ ### Prebuilt binary
 run the `uname -m` to check which you need.
 
 Prebuilt binaries are available from:
-
 - **Tagged releases**: [Latest release page](https://forgejo.ellis.link/continuwuation/continuwuity/releases/latest)
 - **Development builds**: CI artifacts from the `main` branch
   (includes Debian/Ubuntu packages)
@@ -43,36 +42,32 @@ #### Performance-optimised builds
 [link-time optimisation (LTO)](https://doc.rust-lang.org/cargo/reference/profiles.html#lto)
 and, for amd64, target the haswell CPU architecture.
 
-### Nix
-
-Theres a Nix package defined in our flake, available for Linux and MacOS. Add continuwuity as an input to your flake, and use `inputs.continuwuity.packages.${system}.default` to get a working Continuwuity package.
-
-If you simply wish to generate a binary using Nix, you can run `nix build git+https://forgejo.ellis.link/continuwuation/continuwuity` to generate a binary in `result/bin/conduwuit`.
-
 ### Compiling
 
 Alternatively, you may compile the binary yourself.
 
-#### Using Docker
+### Building with the Rust toolchain
 
-If you would like to build using docker, you can run the command `docker build -f ./docker/Dockerfile -t forgejo.ellis.link/continuwuation/continuwuity:main .` to compile continuwuity.
+If wanting to build using standard Rust toolchains, make sure you install:
 
-#### Manual
-
-##### Dependencies
-
-- Run `nix develop` to get a devshell with everything you need
-- Or, install the following:
-    - (On linux) `liburing-dev` on the compiling machine, and `liburing` on the target host
-    - (On linux) `pkg-config` on the compiling machine to allow finding `liburing`
-    - A C++ compiler and (on linux) `libclang` for RocksDB
-
-##### Build
+- (On linux) `liburing-dev` on the compiling machine, and `liburing` on the target host
+- (On linux) `pkg-config` on the compiling machine to allow finding `liburing`
+- A C++ compiler and (on linux) `libclang` for RocksDB
 
 You can build Continuwuity using `cargo build --release`.
 
 Continuwuity supports various optional features that can be enabled during compilation. Please see the Cargo.toml file for a comprehensive list, or ask in our rooms.
 
+### Building with Nix
+
+If you prefer, you can use Nix (or [Lix](https://lix.systems)) to build Continuwuity. This provides improved reproducibility and makes it easy to set up a build environment and generate output. This approach also allows for easy cross-compilation.
+
+You can run the `nix build -L .#static-x86_64-linux-musl-all-features` or
+`nix build -L .#static-aarch64-linux-musl-all-features` commands based
+on architecture to cross-compile the necessary static binary located at
+`result/bin/conduwuit`. This is reproducible with the static binaries produced
+in our CI.
+
 ## Adding a Continuwuity user
 
 While Continuwuity can run as any user, it is better to use dedicated users for
@@ -133,11 +128,13 @@ ## Setting up a systemd service
 ReadWritePaths=/path/to/custom/database/path
 ```
 
+
 ### Example systemd Unit File
 
 <details>
 <summary>Click to expand systemd unit file (conduwuit.service)</summary>
 
+
 ```ini file="../../pkg/conduwuit.service"
 
 ```
@@ -205,27 +202,23 @@ ### Other Reverse Proxies
 As we prefer our users to use Caddy, we do not provide configuration files for other proxies.
 
 You will need to reverse proxy everything under the following routes:
-
 - `/_matrix/` - core Matrix C-S and S-S APIs
 - `/_conduwuit/` and/or `/_continuwuity/` - ad-hoc Continuwuity routes such as `/local_user_count` and
-  `/server_version`
+`/server_version`
 
 You can optionally reverse proxy the following individual routes:
-
 - `/.well-known/matrix/client` and `/.well-known/matrix/server` if using
-  Continuwuity to perform delegation (see the `[global.well_known]` config section)
+Continuwuity to perform delegation (see the `[global.well_known]` config section)
 - `/.well-known/matrix/support` if using Continuwuity to send the homeserver admin
-  contact and support page (formerly known as MSC1929)
+contact and support page (formerly known as MSC1929)
 - `/` if you would like to see `hewwo from conduwuit woof!` at the root
 
 See the following spec pages for more details on these files:
-
 - [`/.well-known/matrix/server`](https://spec.matrix.org/latest/client-server-api/#getwell-knownmatrixserver)
 - [`/.well-known/matrix/client`](https://spec.matrix.org/latest/client-server-api/#getwell-knownmatrixclient)
 - [`/.well-known/matrix/support`](https://spec.matrix.org/latest/client-server-api/#getwell-knownmatrixsupport)
 
 Examples of delegation:
-
 - https://continuwuity.org/.well-known/matrix/server
 - https://continuwuity.org/.well-known/matrix/client
 - https://ellis.link/.well-known/matrix/server
@@ -239,7 +232,6 @@ ### Other Reverse Proxies
 If using Apache, you need to use `nocanon` in your `ProxyPass` directive to prevent httpd from interfering with the `X-Matrix` header (note that Apache is not ideal as a general reverse proxy, so we discourage using it if alternatives are available).
 
 If using Nginx, you need to pass the request URI to Continuwuity using `$request_uri`, like this:
-
 - `proxy_pass http://127.0.0.1:6167$request_uri;`
 - `proxy_pass http://127.0.0.1:6167;`
 
@@ -279,17 +271,17 @@ # If federation is enabled
 ```
 
 - To check if your server can communicate with other homeservers, use the
-  [Matrix Federation Tester](https://federationtester.mtrnord.blog/). If you can
-  register but cannot join federated rooms, check your configuration and verify
-  that port 8448 is open and forwarded correctly.
+[Matrix Federation Tester](https://federationtester.mtrnord.blog/). If you can
+register but cannot join federated rooms, check your configuration and verify
+that port 8448 is open and forwarded correctly.
 
-## What's next?
+# What's next?
 
-### Audio/Video calls
+## Audio/Video calls
 
 For Audio/Video call functionality see the [Calls](../calls.md) page.
 
-### Appservices
+## Appservices
 
 If you want to set up an appservice, take a look at the [Appservice
 Guide](../appservices.md).

docs/deploying/nixos.mdx

@@ -1,40 +1,40 @@
 # Continuwuity for NixOS
 
-## Nix package
+NixOS packages Continuwuity as `matrix-continuwuity`. This package includes both the Continuwuity software and a dedicated NixOS module for configuration and deployment.
 
-You can get a Nix package for Continuwuity from the following sources:
+## Installation methods
 
-- Directly from Nixpkgs: `pkgs.matrix-continuwuity`
-- Or, using `continuwuity.packages.${system}.default` from:
-    - The `flake.nix` at the root of the Continuwuity repo, by adding Continuwuity to your flake inputs:
+You can acquire Continuwuity with Nix (or [Lix][lix]) from these sources:
 
-    ```nix
-    inputs.continuwuity.url = "git+https://forgejo.ellis.link/continuwuation/continuwuity";
-    ```
-
-    - The `default.nix` at the root of the Continuwuity repo
+* Directly from Nixpkgs using the official package (`pkgs.matrix-continuwuity`)
+* The `flake.nix` at the root of the Continuwuity repo
+* The `default.nix` at the root of the Continuwuity repo
 
 ## NixOS module
 
-Continuwuity has an official NixOS module that simplifies configuration and deployment. The module is available in Nixpkgs as `services.matrix-continuwuity`.
+Continuwuity now has an official NixOS module that simplifies configuration and deployment. The module is available in Nixpkgs as `services.matrix-continuwuity` from NixOS 25.05.
 
 Here's a basic example of how to use the module:
 
 ```nix
-services.matrix-continuwuity = {
-  enable = true;
-  settings = {
-    global = {
-      server_name = "example.com";
+{ config, pkgs, ... }:
 
-      # Continuwuity listens on localhost by default,
-      # address and port are handled automatically
-
-      # You can add any further configuration here, e.g.
-	  # trusted_servers = [ "matrix.org" ];
+{
+  services.matrix-continuwuity = {
+    enable = true;
+    settings = {
+      global = {
+        server_name = "example.com";
+        # Listening on localhost by default
+        # address and port are handled automatically
+        allow_registration = false;
+        allow_encryption = true;
+        allow_federation = true;
+        trusted_servers = [ "matrix.org" ];
+      };
     };
   };
-};
+}
 ```
 
 ### Available options
@@ -45,30 +45,86 @@ ### Available options
 - `user`: The user to run Continuwuity as (defaults to "continuwuity")
 - `group`: The group to run Continuwuity as (defaults to "continuwuity")
 - `extraEnvironment`: Extra environment variables to pass to the Continuwuity server
-- `package`: The Continuwuity package to use, defaults to `pkgs.matrix-continuwuity`
-    - You may want to override this to be from our flake, for faster updates and unstable versions:
-    ```nix
-    package = inputs.continuwuity.packages.${pkgs.stdenv.hostPlatform.system}.default;
-    ```
-- `admin.enable`: Whether to add the `conduwuit` binary to `PATH` for administration (enabled by default)
-- `settings`: The Continuwuity configuration
+- `package`: The Continuwuity package to use
+- `settings`: The Continuwuity configuration (in TOML format)
 
 Use the `settings` option to configure Continuwuity itself. See the [example configuration file](../reference/config.mdx) for all available options.
 
-Settings are automatically translated from Nix to TOML. For example, the following line of Nix:
+### UNIX sockets
+
+The NixOS module natively supports UNIX sockets through the `global.unix_socket_path` option. When using UNIX sockets, set `global.address` to `null`:
 
 ```nix
-settings.global.well_known.client = "https://matrix.example.com";
+services.matrix-continuwuity = {
+  enable = true;
+  settings = {
+    global = {
+      server_name = "example.com";
+      address = null; # Must be null when using unix_socket_path
+      unix_socket_path = "/run/continuwuity/continuwuity.sock";
+      unix_socket_perms = 660; # Default permissions for the socket
+      # ...
+    };
+  };
+};
 ```
 
-Would become this equivalent TOML configuration:
+The module automatically sets the correct `RestrictAddressFamilies` in the systemd service configuration to allow access to UNIX sockets.
 
-```toml
-[global.well_known]
-client = "https://matrix.example.com"
+### RocksDB database
+
+Continuwuity exclusively uses RocksDB as its database backend. The system configures the database path automatically to `/var/lib/continuwuity/` and you cannot change it due to the service's reliance on systemd's StateDir.
+
+If you're migrating from Conduit with SQLite, use this [tool to migrate a Conduit SQLite database to RocksDB](https://github.com/ShadowJonathan/conduit_toolbox/).
+
+### jemalloc and hardened profile
+
+Continuwuity uses jemalloc by default. This may interfere with the [`hardened.nix` profile][hardened.nix] because it uses `scudo` by default. Either disable/hide `scudo` from Continuwuity or disable jemalloc like this:
+
+```nix
+services.matrix-continuwuity = {
+  enable = true;
+  package = pkgs.matrix-continuwuity.override {
+    enableJemalloc = false;
+  };
+  # ...
+};
 ```
 
+## Upgrading from Conduit
+
+If you previously used Conduit with the `services.matrix-conduit` module:
+
+1. Ensure your Conduit uses the RocksDB backend, or migrate from SQLite using the [migration tool](https://github.com/ShadowJonathan/conduit_toolbox/)
+2. Switch to the new module by changing `services.matrix-conduit` to `services.matrix-continuwuity` in your configuration
+3. Update any custom configuration to match the new module's structure
+
 ## Reverse proxy configuration
 
-You'll need to set up a reverse proxy (like NGINX or Caddy) to expose Continuwuity to the internet. You can configure your reverse proxy using NixOS options (e.g. `services.caddy`).
-See the [reverse proxy setup guide](./generic.mdx#setting-up-the-reverse-proxy) for information on correct reverse proxy configuration.
+You'll need to set up a reverse proxy (like nginx or caddy) to expose Continuwuity to the internet. Configure your reverse proxy to forward requests to `/_matrix` on port 443 and 8448 to your Continuwuity instance.
+
+Here's an example nginx configuration:
+
+```nginx
+server {
+    listen 443 ssl;
+    listen [::]:443 ssl;
+    listen 8448 ssl;
+    listen [::]:8448 ssl;
+
+    server_name example.com;
+
+    # SSL configuration here...
+
+    location /_matrix/ {
+        proxy_pass http://127.0.0.1:6167$request_uri;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}
+```
+
+[lix]: https://lix.systems/
+[hardened.nix]: https://github.com/NixOS/nixpkgs/blob/master/nixos/modules/profiles/hardened.nix

docs/reference/admin/query.md

@@ -133,18 +133,6 @@ ### `!admin query pusher get-pushers`
 
 Returns all the pushers for the user
 
-### `!admin query pusher delete-pusher`
-
-Deletes a specific pusher by ID
-
-### `!admin query pusher delete-all-user`
-
-Deletes all pushers for a user
-
-### `!admin query pusher delete-all-device`
-
-Deletes all pushers associated with a device ID
-
 ## `!admin query short`
 
 short service

docs/reference/admin/server.md

@@ -47,11 +47,3 @@ ## `!admin server restart`
 ## `!admin server shutdown`
 
 Shutdown the server
-
-## `!admin server list-features`
-
-List features built into the server
-
-## `!admin server build-info`
-
-Build information

docs/reference/admin/users.md

@@ -157,7 +157,3 @@ ## `!admin users force-join-all-local-users`
 At least 1 server admin must be in the room to reduce abuse.
 
 Requires the `--yes-i-want-to-do-this` flag.
-
-## `!admin users reset-push-rules`
-
-Resets the push-rules (notification settings) of the target user to the server defaults

flake.lock

@@ -3,11 +3,11 @@
     "advisory-db": {
       "flake": false,
       "locked": {
-        "lastModified": 1775907537,
-        "narHash": "sha256-vbeLNgmsx1Z6TwnlDV0dKyeBCcon3UpkV9yLr/yc6HM=",
+        "lastModified": 1773786698,
+        "narHash": "sha256-o/J7ZculgwSs1L4H4UFlFZENOXTJzq1X0n71x6oNNvY=",
         "owner": "rustsec",
         "repo": "advisory-db",
-        "rev": "d99f7b9eb81731bddebf80a355f8be7b2f8b1b28",
+        "rev": "99e9de91bb8b61f06ef234ff84e11f758ecd5384",
         "type": "github"
       },
       "original": {
@@ -18,11 +18,11 @@
     },
     "crane": {
       "locked": {
-        "lastModified": 1775839657,
-        "narHash": "sha256-SPm9ck7jh3Un9nwPuMGbRU04UroFmOHjLP56T10MOeM=",
+        "lastModified": 1773189535,
+        "narHash": "sha256-E1G/Or6MWeP+L6mpQ0iTFLpzSzlpGrITfU2220Gq47g=",
         "owner": "ipetkov",
         "repo": "crane",
-        "rev": "7cf72d978629469c4bd4206b95c402514c1f6000",
+        "rev": "6fa2fb4cf4a89ba49fc9dd5a3eb6cde99d388269",
         "type": "github"
       },
       "original": {
@@ -39,11 +39,11 @@
         "rust-analyzer-src": "rust-analyzer-src"
       },
       "locked": {
-        "lastModified": 1775891769,
-        "narHash": "sha256-EOfVlTKw2n8w1uhfh46GS4hEGnQ7oWrIWQfIY6utIkI=",
+        "lastModified": 1773732206,
+        "narHash": "sha256-HKibxaUXyWd4Hs+ZUnwo6XslvaFqFqJh66uL9tphU4Q=",
         "owner": "nix-community",
         "repo": "fenix",
-        "rev": "6fbc54dde15aee725bdc7aae5e478849685d5f56",
+        "rev": "0aa13c1b54063a8d8679b28a5cd357ba98f4a56b",
         "type": "github"
       },
       "original": {
@@ -74,11 +74,11 @@
         "nixpkgs-lib": "nixpkgs-lib"
       },
       "locked": {
-        "lastModified": 1775087534,
-        "narHash": "sha256-91qqW8lhL7TLwgQWijoGBbiD4t7/q75KTi8NxjVmSmA=",
+        "lastModified": 1772408722,
+        "narHash": "sha256-rHuJtdcOjK7rAHpHphUb1iCvgkU3GpfvicLMwwnfMT0=",
         "owner": "hercules-ci",
         "repo": "flake-parts",
-        "rev": "3107b77cd68437b9a76194f0f7f9c55f2329ca5b",
+        "rev": "f20dc5d9b8027381c474144ecabc9034d6a839a3",
         "type": "github"
       },
       "original": {
@@ -89,11 +89,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1775710090,
-        "narHash": "sha256-ar3rofg+awPB8QXDaFJhJ2jJhu+KqN/PRCXeyuXR76E=",
+        "lastModified": 1773734432,
+        "narHash": "sha256-IF5ppUWh6gHGHYDbtVUyhwy/i7D261P7fWD1bPefOsw=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "4c1018dae018162ec878d42fec712642d214fdfa",
+        "rev": "cda48547b432e8d3b18b4180ba07473762ec8558",
         "type": "github"
       },
       "original": {
@@ -105,11 +105,11 @@
     },
     "nixpkgs-lib": {
       "locked": {
-        "lastModified": 1774748309,
-        "narHash": "sha256-+U7gF3qxzwD5TZuANzZPeJTZRHS29OFQgkQ2kiTJBIQ=",
+        "lastModified": 1772328832,
+        "narHash": "sha256-e+/T/pmEkLP6BHhYjx6GmwP5ivonQQn0bJdH9YrRB+Q=",
         "owner": "nix-community",
         "repo": "nixpkgs.lib",
-        "rev": "333c4e0545a6da976206c74db8773a1645b5870a",
+        "rev": "c185c7a5e5dd8f9add5b2f8ebeff00888b070742",
         "type": "github"
       },
       "original": {
@@ -132,11 +132,11 @@
     "rust-analyzer-src": {
       "flake": false,
       "locked": {
-        "lastModified": 1775843361,
-        "narHash": "sha256-j53ZgyDvmYf3Sjh1IPvvTjqa614qUfVQSzj59+MpzkY=",
+        "lastModified": 1773697963,
+        "narHash": "sha256-xdKI77It9PM6eNrCcDZsnP4SKulZwk8VkDgBRVMnCb8=",
         "owner": "rust-lang",
         "repo": "rust-analyzer",
-        "rev": "9eb97ea96d8400e8957ddd56702e962614296583",
+        "rev": "2993637174252ff60a582fd1f55b9ab52c39db6d",
         "type": "github"
       },
       "original": {
@@ -153,11 +153,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1775636079,
-        "narHash": "sha256-pc20NRoMdiar8oPQceQT47UUZMBTiMdUuWrYu2obUP0=",
+        "lastModified": 1773297127,
+        "narHash": "sha256-6E/yhXP7Oy/NbXtf1ktzmU8SdVqJQ09HC/48ebEGBpk=",
         "owner": "numtide",
         "repo": "treefmt-nix",
-        "rev": "790751ff7fd3801feeaf96d7dc416a8d581265ba",
+        "rev": "71b125cd05fbfd78cab3e070b73544abe24c5016",
         "type": "github"
       },
       "original": {

flake.nix

@@ -29,6 +29,7 @@
       url = "github:edolstra/flake-compat?ref=master";
       flake = false;
     };
+
   };
 
   outputs =
@@ -36,10 +37,10 @@
     flake-parts.lib.mkFlake { inherit inputs; } {
       imports = [ ./nix ];
       systems = [
+        # good support
         "x86_64-linux"
-        "aarch64-linux"
         # support untested but theoretically there
-        "aarch64-darwin"
+        "aarch64-linux"
       ];
     };
 }

nix/checks/default.nix

@@ -0,0 +1,107 @@
+{ inputs, ... }:
+{
+  perSystem =
+    {
+      self',
+      lib,
+      pkgs,
+      ...
+    }:
+    let
+      uwulib = inputs.self.uwulib.init pkgs;
+
+      rocksdbAllFeatures = self'.packages.rocksdb.override {
+        enableJemalloc = true;
+      };
+
+      commonAttrs = (uwulib.build.commonAttrs { }) // {
+        buildInputs = [
+          pkgs.liburing
+          pkgs.rust-jemalloc-sys-unprefixed
+          rocksdbAllFeatures
+        ];
+        nativeBuildInputs = [
+          pkgs.pkg-config
+          # bindgen needs the build platform's libclang. Apparently due to "splicing
+          # weirdness", pkgs.rustPlatform.bindgenHook on its own doesn't quite do the
+          # right thing here.
+          pkgs.rustPlatform.bindgenHook
+        ];
+        env = {
+          LIBCLANG_PATH = lib.makeLibraryPath [ pkgs.llvmPackages.libclang.lib ];
+          LD_LIBRARY_PATH = lib.makeLibraryPath [
+            pkgs.liburing
+            pkgs.rust-jemalloc-sys-unprefixed
+            rocksdbAllFeatures
+          ];
+        }
+        // uwulib.environment.buildPackageEnv
+        // {
+          ROCKSDB_INCLUDE_DIR = "${rocksdbAllFeatures}/include";
+          ROCKSDB_LIB_DIR = "${rocksdbAllFeatures}/lib";
+        };
+      };
+      cargoArtifacts = self'.packages.continuwuity-all-features-deps;
+    in
+    {
+      # taken from
+      #
+      # https://crane.dev/examples/quick-start.html
+      checks = {
+        continuwuity-all-features-build = self'.packages.continuwuity-all-features-bin;
+
+        continuwuity-all-features-clippy = uwulib.build.craneLibForChecks.cargoClippy (
+          commonAttrs
+          // {
+            inherit cargoArtifacts;
+            cargoClippyExtraArgs = "-- --deny warnings";
+          }
+        );
+
+        continuwuity-all-features-docs = uwulib.build.craneLibForChecks.cargoDoc (
+          commonAttrs
+          // {
+            inherit cargoArtifacts;
+            # This can be commented out or tweaked as necessary, e.g. set to
+            # `--deny rustdoc::broken-intra-doc-links` to only enforce that lint
+            env.RUSTDOCFLAGS = "--deny warnings";
+          }
+        );
+
+        # Check formatting
+        continuwuity-all-features-fmt = uwulib.build.craneLibForChecks.cargoFmt {
+          src = uwulib.build.src;
+        };
+
+        continuwuity-all-features-toml-fmt = uwulib.build.craneLibForChecks.taploFmt {
+          src = pkgs.lib.sources.sourceFilesBySuffices uwulib.build.src [ ".toml" ];
+          # taplo arguments can be further customized below as needed
+          taploExtraArgs = "--config ${inputs.self}/taplo.toml";
+        };
+
+        # Audit dependencies
+        continuwuity-all-features-audit = uwulib.build.craneLibForChecks.cargoAudit {
+          inherit (inputs) advisory-db;
+          src = uwulib.build.src;
+        };
+
+        # Audit licenses
+        continuwuity-all-features-deny = uwulib.build.craneLibForChecks.cargoDeny {
+          src = uwulib.build.src;
+        };
+
+        # Run tests with cargo-nextest
+        # Consider setting `doCheck = false` on `continuwuity-all-features` if you do not want
+        # the tests to run twice
+        continuwuity-all-features-nextest = uwulib.build.craneLibForChecks.cargoNextest (
+          commonAttrs
+          // {
+            inherit cargoArtifacts;
+            partitions = 1;
+            partitionType = "count";
+            cargoNextestPartitionsExtraArgs = "--no-tests=pass";
+          }
+        );
+      };
+    };
+}

nix/crane.nix

@@ -1,14 +0,0 @@
-{ inputs, ... }:
-{
-  perSystem =
-    {
-      pkgs,
-      self',
-      ...
-    }:
-    {
-      _module.args.craneLib = (inputs.crane.mkLib pkgs).overrideToolchain (
-        pkgs: self'.packages.stable-toolchain
-      );
-    };
-}

nix/default.nix

@@ -1,10 +1,11 @@
 {
   imports = [
-    ./rust.nix
-    ./crane.nix
+    ./checks
     ./packages
-    ./devshell.nix
+    ./shells
+    ./tests
+
+    ./hydra.nix
     ./fmt.nix
-    ./rocksdb-updater.nix
   ];
 }

nix/devshell.nix

@@ -1,42 +0,0 @@
-{
-  perSystem =
-    {
-      craneLib,
-      self',
-      lib,
-      pkgs,
-      ...
-    }:
-    {
-      # basic nix shell containing all things necessary to build continuwuity in all flavors manually (on x86_64-linux)
-      devShells.default = craneLib.devShell {
-        packages = [
-          self'.packages.rocksdb
-          pkgs.nodejs
-          pkgs.pkg-config
-        ]
-        ++ lib.optionals pkgs.stdenv.isLinux [
-          pkgs.liburing
-          pkgs.rust-jemalloc-sys-unprefixed
-        ];
-
-        env = {
-          LIBCLANG_PATH = lib.makeLibraryPath [ pkgs.llvmPackages.libclang.lib ];
-          LD_LIBRARY_PATH = lib.makeLibraryPath (
-            [
-              pkgs.stdenv.cc.cc.lib
-            ]
-            ++ lib.optionals pkgs.stdenv.isLinux [
-              pkgs.liburing
-              pkgs.jemalloc
-            ]
-          );
-        }
-        // lib.optionalAttrs pkgs.stdenv.isLinux {
-          PKG_CONFIG_PATH = lib.makeSearchPath "lib/pkgconfig" [
-            pkgs.liburing.dev
-          ];
-        };
-      };
-    };
-}

nix/hydra.nix

@@ -0,0 +1,9 @@
+{ inputs, ... }:
+let
+  lib = inputs.nixpkgs.lib;
+in
+{
+  flake.hydraJobs.packages = builtins.mapAttrs (
+    _name: lib.hydraJob
+  ) inputs.self.packages.x86_64-linux;
+}

nix/packages/continuwuity.nix

@@ -1,65 +0,0 @@
-{
-  lib,
-  self,
-  stdenv,
-  liburing,
-  craneLib,
-  pkg-config,
-  callPackage,
-  rustPlatform,
-  cargoExtraArgs ? "",
-  rocksdb ? callPackage ./rocksdb.nix { },
-}:
-let
-  # see https://crane.dev/API.html#cranelibfiltercargosources
-  # we need to keep the `web` directory which would be filtered out by the regular source filtering function
-  # https://crane.dev/API.html#cranelibcleancargosource
-  isWebTemplate = path: _type: builtins.match ".*(src/(web|service)|docs).*" path != null;
-  isRust = craneLib.filterCargoSources;
-  isNix = path: _type: builtins.match ".+/nix.*" path != null;
-  webOrRustNotNix = p: t: !(isNix p t) && (isWebTemplate p t || isRust p t);
-
-  src = lib.cleanSourceWith {
-    src = self;
-    filter = webOrRustNotNix;
-    name = "source";
-  };
-
-  attrs = {
-    inherit src;
-    nativeBuildInputs = [
-      pkg-config
-      rustPlatform.bindgenHook
-    ];
-    buildInputs = lib.optionals stdenv.hostPlatform.isLinux [ liburing ];
-    env = {
-      ROCKSDB_INCLUDE_DIR = "${rocksdb}/include";
-      ROCKSDB_LIB_DIR = "${rocksdb}/lib";
-    };
-  };
-in
-craneLib.buildPackage (
-  lib.recursiveUpdate attrs {
-    inherit cargoExtraArgs;
-    cargoArtifacts = craneLib.buildDepsOnly attrs;
-
-    # Needed to make continuwuity link to rocksdb
-    postFixup = lib.optionalString stdenv.hostPlatform.isLinux ''
-      old_rpath="$(patchelf --print-rpath $out/bin/conduwuit)"
-      extra_rpath="${
-        lib.makeLibraryPath [
-          rocksdb
-        ]
-      }"
-
-      patchelf  --set-rpath "$old_rpath:$extra_rpath" $out/bin/conduwuit
-    '';
-
-    meta = {
-      description = "A community-driven Matrix homeserver in Rust";
-      mainProgram = "conduwuit";
-      platforms = lib.platforms.all;
-      maintainers = with lib.maintainers; [ quadradical ];
-    };
-  }
-)

nix/packages/continuwuity/default.nix

@@ -0,0 +1,59 @@
+{ inputs, ... }:
+{
+  perSystem =
+    {
+      self',
+      lib,
+      pkgs,
+      ...
+    }:
+    let
+      uwulib = inputs.self.uwulib.init pkgs;
+    in
+    {
+      packages =
+        lib.pipe
+          [
+            # this is the default variant
+            {
+              variantName = "default";
+              commonAttrsArgs.profile = "release";
+              rocksdb = self'.packages.rocksdb;
+              features = { };
+            }
+            # this is the variant with all features enabled (liburing + jemalloc)
+            {
+              variantName = "all-features";
+              commonAttrsArgs.profile = "release";
+              rocksdb = self'.packages.rocksdb.override {
+                enableJemalloc = true;
+              };
+              features = {
+                enabledFeatures = "all";
+                disabledFeatures = uwulib.features.defaultDisabledFeatures ++ [ "bindgen-static" ];
+              };
+            }
+          ]
+          [
+            (builtins.map (cfg: rec {
+              deps = {
+                name = "continuwuity-${cfg.variantName}-deps";
+                value = uwulib.build.buildDeps {
+                  features = uwulib.features.calcFeatures cfg.features;
+                  inherit (cfg) commonAttrsArgs rocksdb;
+                };
+              };
+              bin = {
+                name = "continuwuity-${cfg.variantName}-bin";
+                value = uwulib.build.buildPackage {
+                  deps = self'.packages.${deps.name};
+                  features = uwulib.features.calcFeatures cfg.features;
+                  inherit (cfg) commonAttrsArgs rocksdb;
+                };
+              };
+            }))
+            (builtins.concatMap builtins.attrValues)
+            builtins.listToAttrs
+          ];
+    };
+}

nix/packages/default.nix

@@ -1,18 +1,14 @@
 {
-  self,
-  ...
-}:
-{
+  imports = [
+    ./continuwuity
+    ./rocksdb
+    ./rust.nix
+    ./uwulib
+  ];
+
   perSystem =
+    { self', ... }:
     {
-      pkgs,
-      craneLib,
-      ...
-    }:
-    {
-      packages = {
-        rocksdb = pkgs.callPackage ./rocksdb.nix { };
-        default = pkgs.callPackage ./continuwuity.nix { inherit self craneLib; };
-      };
+      packages.default = self'.packages.continuwuity-default-bin;
     };
 }

nix/packages/rocksdb.nix

@@ -1,34 +0,0 @@
-{
-  stdenv,
-  rocksdb,
-  fetchFromGitea,
-  rust-jemalloc-sys-unprefixed,
-  ...
-}:
-(rocksdb.override {
-  # rocksdb fails to build with prefixed jemalloc, which is required on
-  # darwin due to [1]. In this case, fall back to building rocksdb with
-  # libc malloc. This should not cause conflicts, because all of the
-  # jemalloc symbols are prefixed.
-  #
-  # [1]: https://github.com/tikv/jemallocator/blob/ab0676d77e81268cd09b059260c75b38dbef2d51/jemalloc-sys/src/env.rs#L17
-  jemalloc = rust-jemalloc-sys-unprefixed;
-  enableJemalloc = stdenv.hostPlatform.isLinux;
-}).overrideAttrs
-  ({
-    version = "continuwuity-v0.5.0-unstable-2026-03-27";
-    src = fetchFromGitea {
-      domain = "forgejo.ellis.link";
-      owner = "continuwuation";
-      repo = "rocksdb";
-      rev = "463f47afceebfe088f6922420265546bd237f249";
-      hash = "sha256-1ef75IDMs5Hba4VWEyXPJb02JyShy5k4gJfzGDhopRk=";
-    };
-
-    # We have this already at https://forgejo.ellis.link/continuwuation/rocksdb/commit/a935c0273e1ba44eacf88ce3685a9b9831486155
-    # Unsetting `patches` so we don't have to revert it and make this nix exclusive
-    patches = [ ];
-
-    # Unset postPatch, as our version override breaks version-specific sed calls in the original package
-    postPatch = "";
-  })

nix/packages/rocksdb/default.nix

@@ -0,0 +1,12 @@
+{
+  perSystem =
+    {
+      pkgs,
+      ...
+    }:
+    {
+      packages = {
+        rocksdb = pkgs.callPackage ./package.nix { };
+      };
+    };
+}

nix/packages/rocksdb/package.nix

@@ -0,0 +1,87 @@
+{
+  lib,
+  stdenv,
+
+  rocksdb,
+  liburing,
+  rust-jemalloc-sys-unprefixed,
+
+  enableJemalloc ? false,
+
+  fetchFromGitea,
+
+  ...
+}:
+let
+  notDarwin = !stdenv.hostPlatform.isDarwin;
+in
+(rocksdb.override {
+  # Override the liburing input for the build with our own so
+  # we have it built with the library flag
+  inherit liburing;
+  jemalloc = rust-jemalloc-sys-unprefixed;
+
+  # rocksdb fails to build with prefixed jemalloc, which is required on
+  # darwin due to [1]. In this case, fall back to building rocksdb with
+  # libc malloc. This should not cause conflicts, because all of the
+  # jemalloc symbols are prefixed.
+  #
+  # [1]: https://github.com/tikv/jemallocator/blob/ab0676d77e81268cd09b059260c75b38dbef2d51/jemalloc-sys/src/env.rs#L17
+  enableJemalloc = enableJemalloc && notDarwin;
+
+  # for some reason enableLiburing in nixpkgs rocksdb is default true
+  # which breaks Darwin entirely
+  enableLiburing = notDarwin;
+}).overrideAttrs
+  (old: {
+    src = fetchFromGitea {
+      domain = "forgejo.ellis.link";
+      owner = "continuwuation";
+      repo = "rocksdb";
+      rev = "10.5.fb";
+      sha256 = "sha256-X4ApGLkHF9ceBtBg77dimEpu720I79ffLoyPa8JMHaU=";
+    };
+    version = "10.5.fb";
+    cmakeFlags =
+      lib.subtractLists (builtins.map (flag: lib.cmakeBool flag true) [
+        # No real reason to have snappy or zlib, no one uses this
+        "WITH_SNAPPY"
+        "ZLIB"
+        "WITH_ZLIB"
+        # We don't need to use ldb or sst_dump (core_tools)
+        "WITH_CORE_TOOLS"
+        # We don't need to build rocksdb tests
+        "WITH_TESTS"
+        # We use rust-rocksdb via C interface and don't need C++ RTTI
+        "USE_RTTI"
+        # This doesn't exist in RocksDB, and USE_SSE is deprecated for
+        # PORTABLE=$(march)
+        "FORCE_SSE42"
+      ]) old.cmakeFlags
+      ++ (builtins.map (flag: lib.cmakeBool flag false) [
+        # No real reason to have snappy, no one uses this
+        "WITH_SNAPPY"
+        "ZLIB"
+        "WITH_ZLIB"
+        # We don't need to use ldb or sst_dump (core_tools)
+        "WITH_CORE_TOOLS"
+        # We don't need trace tools
+        "WITH_TRACE_TOOLS"
+        # We don't need to build rocksdb tests
+        "WITH_TESTS"
+        # We use rust-rocksdb via C interface and don't need C++ RTTI
+        "USE_RTTI"
+      ]);
+
+    enableLiburing = notDarwin;
+
+    # outputs has "tools" which we don't need or use
+    outputs = [ "out" ];
+
+    # preInstall hooks has stuff for messing with ldb/sst_dump which we don't need or use
+    preInstall = "";
+
+    # We have this already at https://forgejo.ellis.link/continuwuation/rocksdb/commit/a935c0273e1ba44eacf88ce3685a9b9831486155
+    # Unsetting `patches` so we don't have to revert it and make this nix exclusive
+    patches = [ ];
+  })

nix/packages/rust.nix

@@ -4,7 +4,6 @@
     {
       system,
       lib,
-      pkgs,
       ...
     }:
     {
@@ -12,7 +11,7 @@
         let
           fnx = inputs.fenix.packages.${system};
 
-          stable-toolchain = fnx.fromToolchainFile {
+          stable = fnx.fromToolchainFile {
             file = inputs.self + "/rust-toolchain.toml";
 
             # See also `rust-toolchain.toml`
@@ -20,10 +19,11 @@
           };
         in
         {
-          inherit stable-toolchain;
-
+          # used for building nix stuff (doesn't include rustfmt overhead)
+          build-toolchain = stable;
+          # used for dev shells
           dev-toolchain = fnx.combine [
-            stable-toolchain
+            stable
             # use the nightly rustfmt because we use nightly features
             fnx.complete.rustfmt
           ];

nix/packages/uwulib/build.nix

@@ -0,0 +1,122 @@
+args@{ pkgs, inputs, ... }:
+let
+  inherit (pkgs) lib;
+  uwuenv = import ./environment.nix args;
+  selfpkgs = inputs.self.packages.${pkgs.stdenv.system};
+in
+rec {
+  # basic, very minimal instance of the crane library with a minimal rust toolchain
+  craneLib = (inputs.crane.mkLib pkgs).overrideToolchain (_: selfpkgs.build-toolchain);
+  # the checks require more rust toolchain components, hence we have this separate instance of the crane library
+  craneLibForChecks = (inputs.crane.mkLib pkgs).overrideToolchain (_: selfpkgs.dev-toolchain);
+
+  # meta information (name, version, etc) of the rust crate based on the Cargo.toml
+  crateInfo = craneLib.crateNameFromCargoToml { cargoToml = "${inputs.self}/Cargo.toml"; };
+
+  src =
+    let
+      # see https://crane.dev/API.html#cranelibfiltercargosources
+      #
+      # we need to keep the `web` directory which would be filtered out by the regular source filtering function
+      #
+      # https://crane.dev/API.html#cranelibcleancargosource
+      isWebTemplate = path: _type: builtins.match ".*(src/(web|service)|docs).*" path != null;
+      isRust = craneLib.filterCargoSources;
+      isNix = path: _type: builtins.match ".+/nix.*" path != null;
+      webOrRustNotNix = p: t: !(isNix p t) && (isWebTemplate p t || isRust p t);
+    in
+    lib.cleanSourceWith {
+      src = inputs.self;
+      filter = webOrRustNotNix;
+      name = "source";
+    };
+
+  # common attrs that are shared between building continuwuity's deps and the package itself
+  commonAttrs =
+    {
+      profile ? "dev",
+      ...
+    }:
+    {
+      inherit (crateInfo)
+        pname
+        version
+        ;
+      inherit src;
+
+      # this prevents unnecessary rebuilds
+      strictDeps = true;
+
+      dontStrip = profile == "dev" || profile == "test";
+      dontPatchELF = profile == "dev" || profile == "test";
+
+      doCheck = true;
+
+      nativeBuildInputs = [
+        # bindgen needs the build platform's libclang. Apparently due to "splicing
+        # weirdness", pkgs.rustPlatform.bindgenHook on its own doesn't quite do the
+        # right thing here.
+        pkgs.rustPlatform.bindgenHook
+      ];
+    };
+
+  makeRocksDBEnv =
+    { rocksdb }:
+    {
+      ROCKSDB_INCLUDE_DIR = "${rocksdb}/include";
+      ROCKSDB_LIB_DIR = "${rocksdb}/lib";
+    };
+
+  # function that builds the continuwuity dependencies derivation
+  buildDeps =
+    {
+      rocksdb,
+      features,
+      commonAttrsArgs,
+    }:
+    craneLib.buildDepsOnly (
+      (commonAttrs commonAttrsArgs)
+      // {
+        env = uwuenv.buildDepsOnlyEnv
+              // (makeRocksDBEnv { inherit rocksdb; })
+              // {
+                # required since we started using unstable reqwest apparently ... otherwise the all-features build will fail
+                RUSTFLAGS = "--cfg reqwest_unstable";
+              };
+        inherit (features) cargoExtraArgs;
+      }
+
+    );
+
+  # function that builds the continuwuity package
+  buildPackage =
+    {
+      deps,
+      rocksdb,
+      features,
+      commonAttrsArgs,
+    }:
+    let
+      rocksdbEnv = makeRocksDBEnv { inherit rocksdb; };
+    in
+    craneLib.buildPackage (
+      (commonAttrs commonAttrsArgs)
+      // {
+        postFixup = ''
+          patchelf --set-rpath "$(${pkgs.patchelf}/bin/patchelf --print-rpath $out/bin/${crateInfo.pname}):${rocksdb}/lib" $out/bin/${crateInfo.pname}
+        '';
+        cargoArtifacts = deps;
+        doCheck = true;
+        env =
+          uwuenv.buildPackageEnv
+          // rocksdbEnv
+          // {
+            # required since we started using unstable reqwest apparently ... otherwise the all-features build will fail
+            RUSTFLAGS = "--cfg reqwest_unstable";
+          };
+        passthru.env = uwuenv.buildPackageEnv // rocksdbEnv;
+        meta.mainProgram = crateInfo.pname;
+        inherit (features) cargoExtraArgs;
+      }
+    );
+}

nix/packages/uwulib/default.nix

@@ -0,0 +1,10 @@
+{ inputs, ... }:
+{
+  flake.uwulib = {
+    init = pkgs: {
+      features = import ./features.nix { inherit pkgs inputs; };
+      environment = import ./environment.nix { inherit pkgs inputs; };
+      build = import ./build.nix { inherit pkgs inputs; };
+    };
+  };
+}

nix/packages/uwulib/environment.nix

@@ -0,0 +1,18 @@
+args@{ pkgs, inputs, ... }:
+let
+  uwubuild = import ./build.nix args;
+in
+rec {
+  buildDepsOnlyEnv = {
+    # https://crane.dev/faq/rebuilds-bindgen.html
+    NIX_OUTPATH_USED_AS_RANDOM_SEED = "aaaaaaaaaa";
+    CARGO_PROFILE = "release";
+  }
+  // uwubuild.craneLib.mkCrossToolchainEnv (p: pkgs.clangStdenv);
+
+  buildPackageEnv = {
+    GIT_COMMIT_HASH = inputs.self.rev or inputs.self.dirtyRev or "";
+    GIT_COMMIT_HASH_SHORT = inputs.self.shortRev or inputs.self.dirtyShortRev or "";
+  }
+  // buildDepsOnlyEnv;
+}

nix/packages/uwulib/features.nix

@@ -0,0 +1,77 @@
+{ pkgs, inputs, ... }:
+let
+  inherit (pkgs) lib;
+in
+rec {
+  defaultDisabledFeatures = [
+    # dont include experimental features
+    "experimental"
+    # jemalloc profiling/stats features are expensive and shouldn't
+    # be expected on non-debug builds.
+    "jemalloc_prof"
+    "jemalloc_stats"
+    # this is non-functional on nix for some reason
+    "hardened_malloc"
+    # conduwuit_mods is a development-only hot reload feature
+    "conduwuit_mods"
+    # we don't want to enable this feature set by default but be more specific about it
+    "full"
+  ];
+  # We perform default-feature unification in nix, because some of the dependencies
+  # on the nix side depend on feature values.
+  calcFeatures =
+    {
+      tomlPath ? "${inputs.self}/src/main",
+      # either a list of feature names or a string "all" which enables all non-default features
+      enabledFeatures ? [ ],
+      disabledFeatures ? defaultDisabledFeatures,
+      default_features ? true,
+      disable_release_max_log_level ? false,
+    }:
+    let
+      # simple helper to get the contents of a Cargo.toml file in a nix format
+      getToml = path: lib.importTOML "${path}/Cargo.toml";
+
+      # get all the features except for the default features
+      allFeatures = lib.pipe tomlPath [
+        getToml
+        (manifest: manifest.features)
+        lib.attrNames
+        (lib.remove "default")
+      ];
+
+      # get just the default enabled features
+      allDefaultFeatures = lib.pipe tomlPath [
+        getToml
+        (manifest: manifest.features.default)
+      ];
+
+      # depending on the value of enabledFeatures choose just a set or all non-default features
+      #
+      # - [ list of features ] -> choose exactly the features listed
+      # - "all" -> choose all non-default features
+      additionalFeatures = if enabledFeatures == "all" then allFeatures else enabledFeatures;
+
+      # unification with default features (if enabled)
+      features = lib.unique (additionalFeatures ++ lib.optionals default_features allDefaultFeatures);
+
+      # prepare the features that are subtracted from the set
+      disabledFeatures' =
+        disabledFeatures ++ lib.optionals disable_release_max_log_level [ "release_max_log_level" ];
+
+      # construct the final feature set
+      finalFeatures = lib.subtractLists disabledFeatures' features;
+    in
+    {
+      # final feature set, useful for querying it
+      features = finalFeatures;
+
+      # crane flag with the relevant features
+      cargoExtraArgs = builtins.concatStringsSep " " [
+        "--no-default-features"
+        "--locked"
+        (lib.optionalString (finalFeatures != [ ]) "--features")
+        (builtins.concatStringsSep "," finalFeatures)
+      ];
+    };
+}

nix/rocksdb-updater.nix

@@ -1,14 +0,0 @@
-{
-  perSystem =
-    { pkgs, ... }:
-    {
-      apps.update-rocksdb = {
-        type = "app";
-        program = pkgs.writeShellApplication {
-          name = "update-rocksdb";
-          runtimeInputs = [ pkgs.nix-update ];
-          text = "nix-update rocksdb -F --version branch";
-        };
-      };
-    };
-}

nix/shells/default.nix

@@ -0,0 +1,29 @@
+{ inputs, ... }:
+{
+  perSystem =
+    {
+      self',
+      lib,
+      pkgs,
+      ...
+    }:
+    let
+      uwulib = inputs.self.uwulib.init pkgs;
+      rocksdbAllFeatures = self'.packages.rocksdb.override {
+        enableJemalloc = true;
+      };
+    in
+    {
+      # basic nix shell containing all things necessary to build continuwuity in all flavors manually (on x86_64-linux)
+      devShells.default = uwulib.build.craneLib.devShell {
+        packages = [
+          pkgs.nodejs
+          pkgs.pkg-config
+          pkgs.liburing
+          pkgs.rust-jemalloc-sys-unprefixed
+          rocksdbAllFeatures
+        ];
+        env.LIBCLANG_PATH = lib.makeLibraryPath [ pkgs.llvmPackages.libclang.lib ];
+      };
+    };
+}

nix/tests/default.nix

@@ -0,0 +1,150 @@
+{
+  perSystem =
+    {
+      self',
+      lib,
+      pkgs,
+      ...
+    }:
+    let
+      baseTestScript =
+        pkgs.writers.writePython3Bin "do_test" { libraries = [ pkgs.python3Packages.matrix-nio ]; }
+          ''
+            import asyncio
+            import nio
+
+
+            async def main() -> None:
+                # Connect to continuwuity
+                client = nio.AsyncClient("http://continuwuity:6167", "alice")
+
+                # Register as user alice
+                response = await client.register("alice", "my-secret-password")
+
+                # Log in as user alice
+                response = await client.login("my-secret-password")
+
+                # Create a new room
+                response = await client.room_create(federate=False)
+                print("Matrix room create response:", response)
+                assert isinstance(response, nio.RoomCreateResponse)
+                room_id = response.room_id
+
+                # Join the room
+                response = await client.join(room_id)
+                print("Matrix join response:", response)
+                assert isinstance(response, nio.JoinResponse)
+
+                # Send a message to the room
+                response = await client.room_send(
+                    room_id=room_id,
+                    message_type="m.room.message",
+                    content={
+                        "msgtype": "m.text",
+                        "body": "Hello continuwuity!"
+                    }
+                )
+                print("Matrix room send response:", response)
+                assert isinstance(response, nio.RoomSendResponse)
+
+                # Sync responses
+                response = await client.sync(timeout=30000)
+                print("Matrix sync response:", response)
+                assert isinstance(response, nio.SyncResponse)
+
+                # Check the message was received by continuwuity
+                last_message = response.rooms.join[room_id].timeline.events[-1].body
+                assert last_message == "Hello continuwuity!"
+
+                # Leave the room
+                response = await client.room_leave(room_id)
+                print("Matrix room leave response:", response)
+                assert isinstance(response, nio.RoomLeaveResponse)
+
+                # Close the client
+                await client.close()
+
+
+            if __name__ == "__main__":
+                asyncio.run(main())
+          '';
+    in
+    {
+      # run some nixos tests as checks
+      checks = lib.pipe self'.packages [
+        # we take all packages (names)
+        builtins.attrNames
+        # we filter out all packages that end with `-bin` (which we are interested in for testing)
+        (builtins.filter (lib.hasSuffix "-bin"))
+        # for each of these binaries we built the basic nixos test
+        #
+        # this test was initially yoinked from
+        #
+        # https://github.com/NixOS/nixpkgs/blob/960ce26339661b1b69c6f12b9063ca51b688615f/nixos/tests/matrix/continuwuity.nix
+        (builtins.concatMap (
+          name:
+          builtins.map
+            (
+              { config, suffix }:
+              {
+                name = "test-${name}-${suffix}";
+                value = pkgs.testers.runNixOSTest {
+                  inherit name;
+
+                  nodes = {
+                    continuwuity = {
+                      services.matrix-continuwuity = {
+                        enable = true;
+                        package = self'.packages.${name};
+                        settings = config;
+                        extraEnvironment.RUST_BACKTRACE = "yes";
+                      };
+                      networking.firewall.allowedTCPPorts = [ 6167 ];
+                    };
+                    client.environment.systemPackages = [ baseTestScript ];
+                  };
+
+                  testScript = ''
+                    start_all()
+
+                    with subtest("start continuwuity"):
+                          continuwuity.wait_for_unit("continuwuity.service")
+                          continuwuity.wait_for_open_port(6167)
+
+                    with subtest("ensure messages can be exchanged"):
+                          client.succeed("${lib.getExe baseTestScript} >&2")
+                  '';
+
+                };
+              }
+            )
+            [
+              {
+                suffix = "base";
+                config = {
+                  global = {
+                    server_name = name;
+                    address = [ "0.0.0.0" ];
+                    allow_registration = true;
+                    yes_i_am_very_very_sure_i_want_an_open_registration_server_prone_to_abuse = true;
+                  };
+                };
+              }
+              {
+                suffix = "with-room-version";
+                config = {
+                  global = {
+                    server_name = name;
+                    address = [ "0.0.0.0" ];
+                    allow_registration = true;
+                    yes_i_am_very_very_sure_i_want_an_open_registration_server_prone_to_abuse = true;
+                    default_room_version = "12";
+                  };
+                };
+              }
+            ]
+        ))
+        builtins.listToAttrs
+      ];
+    };
+}

src/admin/Cargo.toml

@@ -2,7 +2,6 @@
 name = "conduwuit_admin"
 description.workspace = true
 edition.workspace = true
-homepage.workspace = true
 license.workspace = true
 readme.workspace = true
 repository.workspace = true
@@ -80,7 +79,6 @@ conduwuit-database.workspace = true
 conduwuit-macros.workspace = true
 conduwuit-service.workspace = true
 const-str.workspace = true
-ctor.workspace = true
 futures.workspace = true
 lettre.workspace = true
 log.workspace = true

src/admin/check/commands.rs

@@ -7,7 +7,7 @@
 #[implement(Context, params = "<'_>")]
 pub(super) async fn check_all_users(&self) -> Result {
 	let timer = tokio::time::Instant::now();
-	let users = self.services.users.stream().collect::<Vec<_>>().await;
+	let users = self.services.users.iter().collect::<Vec<_>>().await;
 	let query_time = timer.elapsed();
 
 	let total = users.len();

src/admin/debug/commands.rs

@@ -79,14 +79,12 @@ pub(super) async fn parse_pdu(&self) -> Result {
 	}
 
 	let string = self.body[1..self.body.len().saturating_sub(1)].join("\n");
-	let room_version_rules = RoomVersionId::V12.rules().unwrap();
-
 	match serde_json::from_str(&string) {
 		| Err(e) => return Err!("Invalid json in command body: {e}"),
-		| Ok(value) => match ruma::signatures::reference_hash(&value, &room_version_rules) {
+		| Ok(value) => match ruma::signatures::reference_hash(&value, &RoomVersionId::V6) {
 			| Err(e) => return Err!("Could not parse PDU JSON: {e:?}"),
 			| Ok(hash) => {
-				let event_id = EventId::parse(format!("${hash}"));
+				let event_id = OwnedEventId::parse(format!("${hash}"));
 				match serde_json::from_value::<PduEvent>(serde_json::to_value(value)?) {
 					| Err(e) => return Err!("EventId: {event_id:?}\nCould not parse event: {e}"),
 					| Ok(pdu) => write!(self, "EventId: {event_id:?}\n{pdu:#?}"),
@@ -121,7 +119,7 @@ pub(super) async fn get_pdu(&self, event_id: OwnedEventId) -> Result {
 			} else {
 				"PDU found in our database"
 			};
-			write!(self, "{msg}\n```json\n{text}\n```")
+			write!(self, "{msg}\n```json\n{text}\n```",)
 		},
 	}
 	.await
@@ -189,7 +187,10 @@ pub(super) async fn get_remote_pdu_list(&self, server: OwnedServerName, force: b
 
 	for event_id in list {
 		if force {
-			match self.get_remote_pdu(event_id.clone(), server.clone()).await {
+			match self
+				.get_remote_pdu(event_id.to_owned(), server.clone())
+				.await
+			{
 				| Err(e) => {
 					failed_count = failed_count.saturating_add(1);
 					self.services
@@ -204,7 +205,7 @@ pub(super) async fn get_remote_pdu_list(&self, server: OwnedServerName, force: b
 				},
 			}
 		} else {
-			self.get_remote_pdu(event_id.clone(), server.clone())
+			self.get_remote_pdu(event_id.to_owned(), server.clone())
 				.await?;
 			success_count = success_count.saturating_add(1);
 		}
@@ -236,10 +237,10 @@ pub(super) async fn get_remote_pdu(
 	match self
 		.services
 		.sending
-		.send_federation_request(
-			&server,
-			ruma::api::federation::event::get_event::v1::Request::new(event_id.clone()),
-		)
+		.send_federation_request(&server, ruma::api::federation::event::get_event::v1::Request {
+			event_id: event_id.clone(),
+			include_unredacted_content: None,
+		})
 		.await
 	{
 		| Err(e) => {
@@ -329,9 +330,9 @@ pub(super) async fn ping(&self, server: OwnedServerName) -> Result {
 	match self
 		.services
 		.sending
-		.send_unauthenticated_request(
+		.send_federation_request(
 			&server,
-			ruma::api::federation::discovery::get_server_version::v1::Request::new(),
+			ruma::api::federation::discovery::get_server_version::v1::Request {},
 		)
 		.await
 	{
@@ -360,7 +361,7 @@ pub(super) async fn force_device_list_updates(&self) -> Result {
 	self.services
 		.users
 		.stream()
-		.for_each(async |user_id| self.services.users.mark_device_key_update(&user_id).await)
+		.for_each(|user_id| self.services.users.mark_device_key_update(user_id))
 		.await;
 
 	write!(self, "Marked all devices for all users as having new keys to update").await
@@ -429,16 +430,9 @@ pub(super) async fn verify_json(&self) -> Result {
 	}
 
 	let string = self.body[1..self.body.len().checked_sub(1).unwrap()].join("\n");
-	let room_version_rules = RoomVersionId::V12.rules().unwrap();
-
 	match serde_json::from_str::<CanonicalJsonObject>(&string) {
 		| Err(e) => return Err!("Invalid json: {e}"),
-		| Ok(value) => match self
-			.services
-			.server_keys
-			.verify_json(&value, &room_version_rules)
-			.await
-		{
+		| Ok(value) => match self.services.server_keys.verify_json(&value, None).await {
 			| Err(e) => return Err!("Signature verification failed: {e}"),
 			| Ok(()) => write!(self, "Signature correct"),
 		},
@@ -451,15 +445,9 @@ pub(super) async fn verify_pdu(&self, event_id: OwnedEventId) -> Result {
 	use ruma::signatures::Verified;
 
 	let mut event = self.services.rooms.timeline.get_pdu_json(&event_id).await?;
-	let room_version_rules = RoomVersionId::V12.rules().unwrap();
 
 	event.remove("event_id");
-	let msg = match self
-		.services
-		.server_keys
-		.verify_event(&event, &room_version_rules)
-		.await
-	{
+	let msg = match self.services.server_keys.verify_event(&event, None).await {
 		| Err(e) => return Err(e),
 		| Ok(Verified::Signatures) => "signatures OK, but content hash failed (redaction).",
 		| Ok(Verified::All) => "signatures and hashes OK.",
@@ -556,17 +544,16 @@ pub(super) async fn force_set_room_state_from_server(
 	};
 
 	let room_version = self.services.rooms.state.get_room_version(&room_id).await?;
-	let room_version_rules = room_version.rules().unwrap();
 
 	let mut state: HashMap<u64, OwnedEventId> = HashMap::new();
 
 	let remote_state_response = self
 		.services
 		.sending
-		.send_federation_request(
-			&server_name,
-			get_room_state::v1::Request::new(at_event_id, room_id.clone()),
-		)
+		.send_federation_request(&server_name, get_room_state::v1::Request {
+			room_id: room_id.clone(),
+			event_id: at_event_id,
+		})
 		.await?;
 
 	for pdu in remote_state_response.pdus.clone() {
@@ -589,7 +576,7 @@ pub(super) async fn force_set_room_state_from_server(
 	for result in remote_state_response.pdus.iter().map(|pdu| {
 		self.services
 			.server_keys
-			.validate_and_add_event_id(pdu, &room_version_rules)
+			.validate_and_add_event_id(pdu, &room_version)
 	}) {
 		let Ok((event_id, value)) = result.await else {
 			continue;
@@ -621,7 +608,7 @@ pub(super) async fn force_set_room_state_from_server(
 	for result in remote_state_response.auth_chain.iter().map(|pdu| {
 		self.services
 			.server_keys
-			.validate_and_add_event_id(pdu, &room_version_rules)
+			.validate_and_add_event_id(pdu, &room_version)
 	}) {
 		let Ok((event_id, value)) = result.await else {
 			continue;
@@ -638,7 +625,7 @@ pub(super) async fn force_set_room_state_from_server(
 		.services
 		.rooms
 		.event_handler
-		.resolve_state(&room_id, &room_version_rules, state)
+		.resolve_state(&room_id, &room_version, state)
 		.await?;
 
 	info!("Compressing new room state");

src/admin/federation/commands.rs

@@ -111,7 +111,7 @@ pub(super) async fn remote_user_in_rooms(&self, user_id: OwnedUserId) -> Result
 		.rooms
 		.state_cache
 		.rooms_joined(&user_id)
-		.then(async |room_id| get_room_info(self.services, &room_id).await)
+		.then(|room_id| get_room_info(self.services, room_id))
 		.collect()
 		.await;
 
@@ -129,6 +129,6 @@ pub(super) async fn remote_user_in_rooms(&self, user_id: OwnedUserId) -> Result
 		.collect::<Vec<_>>()
 		.join("\n");
 
-	self.write_str(&format!("Rooms {user_id} shares with us ({num}):\n```\n{body}\n```"))
+	self.write_str(&format!("Rooms {user_id} shares with us ({num}):\n```\n{body}\n```",))
 		.await
 }

src/admin/media/commands.rs

@@ -6,8 +6,7 @@
 	warn,
 };
 use conduwuit_service::media::Dim;
-use ruma::{OwnedEventId, OwnedMxcUri, OwnedServerName};
-use service::media::mxc::Mxc;
+use ruma::{Mxc, OwnedEventId, OwnedMxcUri, OwnedServerName};
 
 use crate::{admin_command, utils::parse_local_user_id};
 
@@ -262,7 +261,7 @@ pub(super) async fn delete_past_remote_media(
 		)
 		.await?;
 
-	self.write_str(&format!("Deleted {deleted_count} total files."))
+	self.write_str(&format!("Deleted {deleted_count} total files.",))
 		.await
 }
 
@@ -272,7 +271,7 @@ pub(super) async fn delete_all_from_user(&self, username: String) -> Result {
 
 	let deleted_count = self.services.media.delete_from_user(&user_id).await?;
 
-	self.write_str(&format!("Deleted {deleted_count} total files."))
+	self.write_str(&format!("Deleted {deleted_count} total files.",))
 		.await
 }
 
@@ -331,7 +330,7 @@ pub(super) async fn delete_all_from_server(
 		}
 	}
 
-	self.write_str(&format!("Deleted {deleted_count} total files."))
+	self.write_str(&format!("Deleted {deleted_count} total files.",))
 		.await
 }
 

src/admin/mod.rs

@@ -3,8 +3,6 @@
 #![allow(clippy::enum_glob_use)]
 #![allow(clippy::too_many_arguments)]
 
-conduwuit_macros::introspect_crate! {}
-
 pub(crate) mod admin;
 pub(crate) mod context;
 pub(crate) mod processor;

src/admin/processor.rs

@@ -16,8 +16,8 @@
 use ruma::{
 	EventId,
 	events::{
-		relation::{InReplyTo, Reply},
-		room::message::{Relation, RoomMessageEventContent},
+		relation::InReplyTo,
+		room::message::{Relation::Reply, RoomMessageEventContent},
 	},
 };
 use service::{
@@ -38,7 +38,6 @@ pub(super) fn dispatch(services: Arc<Services>, command: CommandInput) -> Proces
 }
 
 #[tracing::instrument(skip_all, name = "admin", level = "info")]
-#[allow(clippy::result_large_err)]
 async fn handle_command(services: Arc<Services>, command: CommandInput) -> ProcessorResult {
 	AssertUnwindSafe(Box::pin(process_command(services, &command)))
 		.catch_unwind()
@@ -278,8 +277,9 @@ fn reply(
 	mut content: RoomMessageEventContent,
 	reply_id: Option<&EventId>,
 ) -> RoomMessageEventContent {
-	content.relates_to =
-		reply_id.map(|event_id| Relation::Reply(Reply::new(InReplyTo::new(event_id.to_owned()))));
+	content.relates_to = reply_id.map(|event_id| Reply {
+		in_reply_to: InReplyTo { event_id: event_id.to_owned() },
+	});
 
 	content
 }

src/admin/query/resolver.rs

@@ -50,7 +50,7 @@ async fn destinations_cache(&self, server_name: Option<OwnedServerName>) -> Resu
 
 	while let Some((name, CachedDest { dest, host, expire })) = destinations.next().await {
 		if let Some(server_name) = server_name.as_ref() {
-			if name != *server_name {
+			if name != server_name {
 				continue;
 			}
 		}
@@ -76,7 +76,7 @@ async fn overrides_cache(&self, server_name: Option<String>) -> Result {
 		overrides.next().await
 	{
 		if let Some(server_name) = server_name.as_ref() {
-			if name != *server_name {
+			if name != server_name {
 				continue;
 			}
 		}

src/admin/query/room_alias.rs

@@ -41,6 +41,7 @@ pub(super) async fn process(subcommand: RoomAliasCommand, context: &Context<'_>)
 				.rooms
 				.alias
 				.local_aliases_for_room(&room_id)
+				.map(ToOwned::to_owned)
 				.collect()
 				.await;
 			let query_time = timer.elapsed();
@@ -53,7 +54,7 @@ pub(super) async fn process(subcommand: RoomAliasCommand, context: &Context<'_>)
 				.rooms
 				.alias
 				.all_local_aliases()
-				.map(|(room_id, alias)| (room_id, alias.to_owned()))
+				.map(|(room_id, alias)| (room_id.to_owned(), alias.to_owned()))
 				.collect::<Vec<_>>()
 				.await;
 			let query_time = timer.elapsed();

src/admin/query/room_state_cache.rs

@@ -101,6 +101,7 @@ pub(super) async fn process(subcommand: RoomStateCacheCommand, context: &Context
 				.rooms
 				.state_cache
 				.room_servers(&room_id)
+				.map(ToOwned::to_owned)
 				.collect()
 				.await;
 			let query_time = timer.elapsed();
@@ -117,6 +118,7 @@ pub(super) async fn process(subcommand: RoomStateCacheCommand, context: &Context
 				.rooms
 				.state_cache
 				.server_rooms(&server)
+				.map(ToOwned::to_owned)
 				.collect()
 				.await;
 			let query_time = timer.elapsed();
@@ -133,6 +135,7 @@ pub(super) async fn process(subcommand: RoomStateCacheCommand, context: &Context
 				.rooms
 				.state_cache
 				.room_members(&room_id)
+				.map(ToOwned::to_owned)
 				.collect()
 				.await;
 			let query_time = timer.elapsed();
@@ -149,6 +152,7 @@ pub(super) async fn process(subcommand: RoomStateCacheCommand, context: &Context
 				.rooms
 				.state_cache
 				.local_users_in_room(&room_id)
+				.map(ToOwned::to_owned)
 				.collect()
 				.await;
 			let query_time = timer.elapsed();
@@ -165,6 +169,7 @@ pub(super) async fn process(subcommand: RoomStateCacheCommand, context: &Context
 				.rooms
 				.state_cache
 				.active_local_users_in_room(&room_id)
+				.map(ToOwned::to_owned)
 				.collect()
 				.await;
 			let query_time = timer.elapsed();
@@ -207,6 +212,7 @@ pub(super) async fn process(subcommand: RoomStateCacheCommand, context: &Context
 				.rooms
 				.state_cache
 				.room_useroncejoined(&room_id)
+				.map(ToOwned::to_owned)
 				.collect()
 				.await;
 			let query_time = timer.elapsed();
@@ -223,6 +229,7 @@ pub(super) async fn process(subcommand: RoomStateCacheCommand, context: &Context
 				.rooms
 				.state_cache
 				.room_members_invited(&room_id)
+				.map(ToOwned::to_owned)
 				.collect()
 				.await;
 			let query_time = timer.elapsed();
@@ -269,6 +276,7 @@ pub(super) async fn process(subcommand: RoomStateCacheCommand, context: &Context
 				.rooms
 				.state_cache
 				.rooms_joined(&user_id)
+				.map(ToOwned::to_owned)
 				.collect()
 				.await;
 			let query_time = timer.elapsed();

src/admin/query/users.rs

@@ -104,6 +104,7 @@ async fn get_shared_rooms(&self, user_a: OwnedUserId, user_b: OwnedUserId) -> Re
 		.rooms
 		.state_cache
 		.get_shared_rooms(&user_a, &user_b)
+		.map(ToOwned::to_owned)
 		.collect()
 		.await;
 	let query_time = timer.elapsed();
@@ -216,7 +217,8 @@ async fn iter_users2(&self) -> Result {
 	let result: Vec<_> = self.services.users.stream().collect().await;
 	let result: Vec<_> = result
 		.into_iter()
-		.map(|user_id| String::from_utf8_lossy(user_id.as_bytes()).into_owned())
+		.map(ruma::UserId::as_bytes)
+		.map(String::from_utf8_lossy)
 		.collect();
 
 	let query_time = timer.elapsed();
@@ -252,6 +254,7 @@ async fn list_devices(&self, user_id: OwnedUserId) -> Result {
 		.services
 		.users
 		.all_device_ids(&user_id)
+		.map(ToOwned::to_owned)
 		.collect::<Vec<_>>()
 		.await;
 

src/admin/room/alias.rs

@@ -3,7 +3,7 @@
 use clap::Subcommand;
 use conduwuit::{Err, Result};
 use futures::StreamExt;
-use ruma::{OwnedRoomAliasId, OwnedRoomId, RoomAliasId};
+use ruma::{OwnedRoomAliasId, OwnedRoomId};
 
 use crate::Context;
 
@@ -52,7 +52,7 @@ pub(super) async fn process(command: RoomAliasCommand, context: &Context<'_>) ->
 		| RoomAliasCommand::Which { ref room_alias_localpart } => {
 			let room_alias_str =
 				format!("#{}:{}", room_alias_localpart, services.globals.server_name());
-			let room_alias = match RoomAliasId::parse(room_alias_str) {
+			let room_alias = match OwnedRoomAliasId::parse(room_alias_str) {
 				| Ok(alias) => alias,
 				| Err(err) => {
 					return Err!("Failed to parse alias: {err}");
@@ -139,7 +139,7 @@ pub(super) async fn process(command: RoomAliasCommand, context: &Context<'_>) ->
 					.rooms
 					.alias
 					.all_local_aliases()
-					.map(|(room_id, localpart)| (room_id, localpart.into()))
+					.map(|(room_id, localpart)| (room_id.into(), localpart.into()))
 					.collect::<Vec<(OwnedRoomId, String)>>()
 					.await;
 

src/admin/room/commands.rs

@@ -22,14 +22,14 @@ pub(super) async fn list_rooms(
 		.metadata
 		.iter_ids()
 		.filter_map(|room_id| async move {
-			(!exclude_disabled || !self.services.rooms.metadata.is_disabled(&room_id).await)
+			(!exclude_disabled || !self.services.rooms.metadata.is_disabled(room_id).await)
 				.then_some(room_id)
 		})
 		.filter_map(|room_id| async move {
-			(!exclude_banned || !self.services.rooms.metadata.is_banned(&room_id).await)
+			(!exclude_banned || !self.services.rooms.metadata.is_banned(room_id).await)
 				.then_some(room_id)
 		})
-		.then(async |room_id| get_room_info(self.services, &room_id).await)
+		.then(|room_id| get_room_info(self.services, room_id))
 		.then(|(room_id, total_members, name)| async move {
 			let local_members: Vec<_> = self
 				.services
@@ -72,7 +72,7 @@ pub(super) async fn list_rooms(
 		.collect::<Vec<_>>()
 		.join("\n");
 
-	self.write_str(&format!("Rooms ({}):\n```\n{body}\n```", rooms.len()))
+	self.write_str(&format!("Rooms ({}):\n```\n{body}\n```", rooms.len(),))
 		.await
 }
 

src/admin/room/directory.rs

@@ -43,7 +43,7 @@ pub(super) async fn process(command: RoomDirectoryCommand, context: &Context<'_>
 				.rooms
 				.directory
 				.public_rooms()
-				.then(async |room_id| get_room_info(services, &room_id).await)
+				.then(|room_id| get_room_info(services, room_id))
 				.collect()
 				.await;
 
@@ -67,7 +67,7 @@ pub(super) async fn process(command: RoomDirectoryCommand, context: &Context<'_>
 				.join("\n");
 
 			context
-				.write_str(&format!("Rooms (page {page}):\n```\n{body}\n```"))
+				.write_str(&format!("Rooms (page {page}):\n```\n{body}\n```",))
 				.await
 		},
 	}

src/admin/room/info.rs

@@ -46,6 +46,7 @@ async fn list_joined_members(&self, room_id: OwnedRoomId, local_only: bool) -> R
 				.then(|| self.services.globals.user_is_local(user_id))
 				.unwrap_or(true)
 		})
+		.map(ToOwned::to_owned)
 		.filter_map(|user_id| async move {
 			Some((
 				self.services
@@ -66,7 +67,7 @@ async fn list_joined_members(&self, room_id: OwnedRoomId, local_only: bool) -> R
 		.collect::<Vec<_>>()
 		.join("\n");
 
-	self.write_str(&format!("{num} Members in Room \"{room_name}\":\n```\n{body}\n```"))
+	self.write_str(&format!("{num} Members in Room \"{room_name}\":\n```\n{body}\n```",))
 		.await
 }
 

src/admin/room/moderation.rs

@@ -71,7 +71,7 @@ async fn ban_room(&self, room: OwnedRoomOrAliasId) -> Result {
 
 		debug!("Room specified is a room ID, banning room ID");
 
-		room_id.clone()
+		room_id.to_owned()
 	} else if room.is_room_alias_id() {
 		let room_alias = match RoomAliasId::parse(&room) {
 			| Ok(room_alias) => room_alias,
@@ -89,7 +89,7 @@ async fn ban_room(&self, room: OwnedRoomOrAliasId) -> Result {
 			 locally, if not using get_alias_helper to fetch room ID remotely"
 		);
 
-		match self.services.rooms.alias.resolve_alias(&room_alias).await {
+		match self.services.rooms.alias.resolve_alias(room_alias).await {
 			| Ok((room_id, servers)) => {
 				debug!(
 					%room_id,
@@ -116,6 +116,7 @@ async fn ban_room(&self, room: OwnedRoomOrAliasId) -> Result {
 		.rooms
 		.state_cache
 		.room_members(&room_id)
+		.map(ToOwned::to_owned)
 		.ready_filter(|user| self.services.globals.user_is_local(user))
 		.boxed();
 
@@ -139,6 +140,7 @@ async fn ban_room(&self, room: OwnedRoomOrAliasId) -> Result {
 		.rooms
 		.alias
 		.local_aliases_for_room(&room_id)
+		.map(ToOwned::to_owned)
 		.for_each(|local_alias| async move {
 			self.services
 				.rooms
@@ -203,7 +205,7 @@ async fn ban_list_of_rooms(&self) -> Result {
 						},
 					};
 
-					room_ids.push(room_id.clone());
+					room_ids.push(room_id.to_owned());
 				}
 
 				if room_alias_or_id.is_room_alias_id() {
@@ -213,7 +215,7 @@ async fn ban_list_of_rooms(&self) -> Result {
 								.services
 								.rooms
 								.alias
-								.resolve_local_alias(&room_alias)
+								.resolve_local_alias(room_alias)
 								.await
 							{
 								| Ok(room_id) => room_id,
@@ -227,7 +229,7 @@ async fn ban_list_of_rooms(&self) -> Result {
 										.services
 										.rooms
 										.alias
-										.resolve_alias(&room_alias)
+										.resolve_alias(room_alias)
 										.await
 									{
 										| Ok((room_id, servers)) => {
@@ -282,6 +284,7 @@ async fn ban_list_of_rooms(&self) -> Result {
 			.rooms
 			.state_cache
 			.room_members(&room_id)
+			.map(ToOwned::to_owned)
 			.ready_filter(|user| self.services.globals.user_is_local(user))
 			.boxed();
 
@@ -306,6 +309,7 @@ async fn ban_list_of_rooms(&self) -> Result {
 			.rooms
 			.alias
 			.local_aliases_for_room(&room_id)
+			.map(ToOwned::to_owned)
 			.for_each(|local_alias| async move {
 				self.services
 					.rooms
@@ -344,9 +348,9 @@ async fn unban_room(&self, room: OwnedRoomOrAliasId) -> Result {
 		};
 
 		debug!("Room specified is a room ID, unbanning room ID");
-		self.services.rooms.metadata.ban_room(&room_id, false);
+		self.services.rooms.metadata.ban_room(room_id, false);
 
-		room_id.clone()
+		room_id.to_owned()
 	} else if room.is_room_alias_id() {
 		let room_alias = match RoomAliasId::parse(&room) {
 			| Ok(room_alias) => room_alias,
@@ -368,7 +372,7 @@ async fn unban_room(&self, room: OwnedRoomOrAliasId) -> Result {
 			.services
 			.rooms
 			.alias
-			.resolve_local_alias(&room_alias)
+			.resolve_local_alias(room_alias)
 			.await
 		{
 			| Ok(room_id) => room_id,
@@ -378,7 +382,7 @@ async fn unban_room(&self, room: OwnedRoomOrAliasId) -> Result {
 					 room ID over federation"
 				);
 
-				match self.services.rooms.alias.resolve_alias(&room_alias).await {
+				match self.services.rooms.alias.resolve_alias(room_alias).await {
 					| Ok((room_id, servers)) => {
 						debug!(
 							%room_id,
@@ -449,6 +453,6 @@ async fn list_banned_rooms(&self, no_details: bool) -> Result {
 		.collect::<Vec<_>>()
 		.join("\n");
 
-	self.write_str(&format!("Rooms Banned ({num}):\n```\n{body}\n```"))
+	self.write_str(&format!("Rooms Banned ({num}):\n```\n{body}\n```",))
 		.await
 }

src/admin/server/commands.rs

@@ -1,4 +1,4 @@
-use std::{fmt::Write, path::PathBuf, sync::Arc};
+use std::{path::PathBuf, sync::Arc};
 
 use conduwuit::{
 	Err, Result,
@@ -153,97 +153,3 @@ pub(super) async fn shutdown(&self) -> Result {
 
 	self.write_str("Shutting down server...").await
 }
-
-#[admin_command]
-pub(super) async fn list_features(&self) -> Result {
-	let mut enabled_features = conduwuit::info::introspection::ENABLED_FEATURES
-		.lock()
-		.expect("locked")
-		.values()
-		.flat_map(|f| f.iter())
-		.collect::<Vec<_>>();
-
-	enabled_features.sort_unstable();
-	enabled_features.dedup();
-
-	let mut available_features = conduwuit::build_metadata::WORKSPACE_FEATURES
-		.iter()
-		.flat_map(|(_, f)| f.iter())
-		.collect::<Vec<_>>();
-
-	available_features.sort_unstable();
-	available_features.dedup();
-
-	let mut features = String::new();
-
-	for feature in available_features {
-		let active = enabled_features.contains(&feature);
-		let emoji = if active { "✅" } else { "❌" };
-		let remark = if active { "[enabled]" } else { "" };
-		writeln!(features, "{emoji} {feature} {remark}")?;
-	}
-
-	self.write_str(&features).await
-}
-
-#[admin_command]
-pub(super) async fn build_info(&self) -> Result {
-	use conduwuit::build_metadata::built;
-
-	let mut info = String::new();
-
-	// Version information
-	writeln!(info, "# Build Information\n")?;
-	writeln!(info, "**Version:** {}", built::PKG_VERSION)?;
-	writeln!(info, "**Package:** {}", built::PKG_NAME)?;
-	writeln!(info, "**Description:** {}", built::PKG_DESCRIPTION)?;
-
-	// Git information
-	writeln!(info, "\n## Git Information\n")?;
-	if let Some(hash) = conduwuit::build_metadata::GIT_COMMIT_HASH {
-		writeln!(info, "**Commit Hash:** {hash}")?;
-	}
-	if let Some(hash) = conduwuit::build_metadata::GIT_COMMIT_HASH_SHORT {
-		writeln!(info, "**Commit Hash (short):** {hash}")?;
-	}
-	if let Some(url) = conduwuit::build_metadata::GIT_REMOTE_WEB_URL {
-		writeln!(info, "**Repository:** {url}")?;
-	}
-	if let Some(url) = conduwuit::build_metadata::GIT_REMOTE_COMMIT_URL {
-		writeln!(info, "**Commit URL:** {url}")?;
-	}
-
-	// Build environment
-	writeln!(info, "\n## Build Environment\n")?;
-	writeln!(info, "**Profile:** {}", built::PROFILE)?;
-	writeln!(info, "**Optimization Level:** {}", built::OPT_LEVEL)?;
-	writeln!(info, "**Debug:** {}", built::DEBUG)?;
-	writeln!(info, "**Target:** {}", built::TARGET)?;
-	writeln!(info, "**Host:** {}", built::HOST)?;
-
-	// Rust compiler information
-	writeln!(info, "\n## Compiler Information\n")?;
-	writeln!(info, "**Rustc Version:** {}", built::RUSTC_VERSION)?;
-	if !built::RUSTDOC_VERSION.is_empty() {
-		writeln!(info, "**Rustdoc Version:** {}", built::RUSTDOC_VERSION)?;
-	}
-
-	// Target configuration
-	writeln!(info, "\n## Target Configuration\n")?;
-	writeln!(info, "**Architecture:** {}", built::CFG_TARGET_ARCH)?;
-	writeln!(info, "**OS:** {}", built::CFG_OS)?;
-	writeln!(info, "**Family:** {}", built::CFG_FAMILY)?;
-	writeln!(info, "**Endianness:** {}", built::CFG_ENDIAN)?;
-	writeln!(info, "**Pointer Width:** {} bits", built::CFG_POINTER_WIDTH)?;
-	if !built::CFG_ENV.is_empty() {
-		writeln!(info, "**Environment:** {}", built::CFG_ENV)?;
-	}
-
-	// CI information
-	if let Some(ci) = built::CI_PLATFORM {
-		writeln!(info, "\n## CI Platform\n")?;
-		writeln!(info, "**Platform:** {ci}")?;
-	}
-
-	self.write_str(&info).await
-}

src/admin/server/mod.rs

@@ -52,10 +52,4 @@ pub enum ServerCommand {
 
 	/// Shutdown the server
 	Shutdown,
-
-	/// List features built into the server
-	ListFeatures,
-
-	/// Build information
-	BuildInfo,
 }

src/admin/user/commands.rs

@@ -16,11 +16,13 @@
 use futures::{FutureExt, StreamExt};
 use lettre::Address;
 use ruma::{
-	OwnedEventId, OwnedRoomId, OwnedRoomOrAliasId, OwnedServerName, OwnedUserId, ServerName,
-	UserId, assign,
+	OwnedEventId, OwnedRoomId, OwnedRoomOrAliasId, OwnedServerName, OwnedUserId, UserId,
 	events::{
-		RoomAccountDataEventType,
-		room::{power_levels::RoomPowerLevelsEventContent, redaction::RoomRedactionEventContent},
+		RoomAccountDataEventType, StateEventType,
+		room::{
+			power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent},
+			redaction::RoomRedactionEventContent,
+		},
 		tag::{TagEvent, TagEventContent, TagInfo},
 	},
 };
@@ -39,7 +41,7 @@ pub(super) async fn list_users(&self) -> Result {
 		.services
 		.users
 		.list_local_users()
-		.map(|id| id.as_str().to_owned())
+		.map(ToString::to_string)
 		.collect()
 		.await;
 
@@ -101,12 +103,11 @@ pub(super) async fn create_user(&self, username: String, password: Option<String
 			ruma::events::GlobalAccountDataEventType::PushRules
 				.to_string()
 				.into(),
-			&serde_json::to_value(ruma::events::push_rules::PushRulesEvent::new(
-				ruma::events::push_rules::PushRulesEventContent::new(
-					ruma::push::Ruleset::server_default(&user_id),
-				),
-			))
-			.unwrap(),
+			&serde_json::to_value(ruma::events::push_rules::PushRulesEvent {
+				content: ruma::events::push_rules::PushRulesEventContent {
+					global: ruma::push::Ruleset::server_default(&user_id),
+				},
+			})?,
 		)
 		.await?;
 
@@ -291,12 +292,7 @@ pub(super) async fn reset_password(
 		self.services
 			.users
 			.all_device_ids(&user_id)
-			.for_each(async |device_id| {
-				self.services
-					.users
-					.remove_device(&user_id, &device_id)
-					.await;
-			})
+			.for_each(|device_id| self.services.users.remove_device(&user_id, device_id))
 			.await;
 		write!(self, "\nAll existing sessions have been logged out.").await?;
 	}
@@ -441,7 +437,7 @@ pub(super) async fn list_joined_rooms(&self, user_id: String) -> Result {
 		.rooms
 		.state_cache
 		.rooms_joined(&user_id)
-		.then(async |room_id| get_room_info(self.services, &room_id).await)
+		.then(|room_id| get_room_info(self.services, room_id))
 		.collect()
 		.await;
 
@@ -458,7 +454,7 @@ pub(super) async fn list_joined_rooms(&self, user_id: String) -> Result {
 		.collect::<Vec<_>>()
 		.join("\n");
 
-	self.write_str(&format!("Rooms {user_id} Joined ({}):\n```\n{body}\n```", rooms.len()))
+	self.write_str(&format!("Rooms {user_id} Joined ({}):\n```\n{body}\n```", rooms.len(),))
 		.await
 }
 
@@ -510,7 +506,7 @@ pub(super) async fn force_join_list_of_local_users(
 		.rooms
 		.state_cache
 		.room_members(&room_id)
-		.ready_any(|user_id| server_admins.contains(&user_id))
+		.ready_any(|user_id| server_admins.contains(&user_id.to_owned()))
 		.await
 	{
 		return Err!("There is not a single server admin in the room.",);
@@ -624,7 +620,7 @@ pub(super) async fn force_join_all_local_users(
 		.rooms
 		.state_cache
 		.room_members(&room_id)
-		.ready_any(|user_id| server_admins.contains(&user_id))
+		.ready_any(|user_id| server_admins.contains(&user_id.to_owned()))
 		.await
 	{
 		return Err!("There is not a single server admin in the room.",);
@@ -637,6 +633,7 @@ pub(super) async fn force_join_all_local_users(
 		.services
 		.users
 		.list_local_users()
+		.map(UserId::to_owned)
 		.collect::<Vec<_>>()
 		.await
 	{
@@ -687,7 +684,7 @@ pub(super) async fn force_join_room(
 	);
 	join_room_by_id_helper(self.services, &user_id, &room_id, None, &servers, &None).await?;
 
-	self.write_str(&format!("{user_id} has been joined to {room_id}."))
+	self.write_str(&format!("{user_id} has been joined to {room_id}.",))
 		.await
 }
 
@@ -719,7 +716,7 @@ pub(super) async fn force_leave_room(
 		.boxed()
 		.await?;
 
-	self.write_str(&format!("{user_id} has left {room_id}."))
+	self.write_str(&format!("{user_id} has left {room_id}.",))
 		.await
 }
 
@@ -733,7 +730,7 @@ pub(super) async fn force_demote(&self, user_id: String, room_id: OwnedRoomOrAli
 		"Parsed user_id must be a local user"
 	);
 
-	let state_lock = self.services.rooms.state.mutex.lock(room_id.as_str()).await;
+	let state_lock = self.services.rooms.state.mutex.lock(&room_id).await;
 
 	let mut room_power_levels = self
 		.services
@@ -758,7 +755,8 @@ pub(super) async fn force_demote(&self, user_id: String, room_id: OwnedRoomOrAli
 		.build_and_append_pdu(
 			PartialPdu::state(
 				String::new(),
-				&RoomPowerLevelsEventContent::try_from(room_power_levels)
+				room_power_levels
+					.try_into()
 					.expect("PLs should be valid for room version"),
 			),
 			&user_id,
@@ -788,7 +786,7 @@ pub(super) async fn make_user_admin(&self, user_id: String) -> Result {
 		.boxed()
 		.await?;
 
-	self.write_str(&format!("{user_id} has been granted admin privileges."))
+	self.write_str(&format!("{user_id} has been granted admin privileges.",))
 		.await
 }
 
@@ -806,7 +804,9 @@ pub(super) async fn put_room_tag(
 		.account_data
 		.get_room(&room_id, &user_id, RoomAccountDataEventType::Tag)
 		.await
-		.unwrap_or_else(|_| TagEvent::new(TagEventContent::new(BTreeMap::new())));
+		.unwrap_or(TagEvent {
+			content: TagEventContent { tags: BTreeMap::new() },
+		});
 
 	tags_event
 		.content
@@ -843,7 +843,9 @@ pub(super) async fn delete_room_tag(
 		.account_data
 		.get_room(&room_id, &user_id, RoomAccountDataEventType::Tag)
 		.await
-		.unwrap_or_else(|_| TagEvent::new(TagEventContent::new(BTreeMap::new())));
+		.unwrap_or(TagEvent {
+			content: TagEventContent { tags: BTreeMap::new() },
+		});
 
 	tags_event.content.tags.remove(&tag.clone().into());
 
@@ -873,7 +875,9 @@ pub(super) async fn get_room_tags(&self, user_id: String, room_id: OwnedRoomId)
 		.account_data
 		.get_room(&room_id, &user_id, RoomAccountDataEventType::Tag)
 		.await
-		.unwrap_or_else(|_| TagEvent::new(TagEventContent::new(BTreeMap::new())));
+		.unwrap_or(TagEvent {
+			content: TagEventContent { tags: BTreeMap::new() },
+		});
 
 	self.write_str(&format!("```\n{:#?}\n```", tags_event.content.tags))
 		.await
@@ -910,7 +914,7 @@ pub(super) async fn redact_event(&self, event_id: OwnedEventId) -> Result {
 			.rooms
 			.state
 			.mutex
-			.lock(event.room_id_or_hash().as_str())
+			.lock(&event.room_id_or_hash())
 			.await;
 
 		self.services
@@ -919,10 +923,10 @@ pub(super) async fn redact_event(&self, event_id: OwnedEventId) -> Result {
 			.build_and_append_pdu(
 				PartialPdu {
 					redacts: Some(event.event_id().to_owned()),
-					..PartialPdu::timeline(&assign!(RoomRedactionEventContent::new_v1(), {
+					..PartialPdu::timeline(&RoomRedactionEventContent {
 						redacts: Some(event.event_id().to_owned()),
 						reason: Some(reason),
-					}))
+					})
 				},
 				event.sender(),
 				Some(&event.room_id_or_hash()),
@@ -952,7 +956,7 @@ pub(super) async fn force_leave_remote_room(
 		.resolve_with_servers(
 			&room_id,
 			if let Some(v) = via.clone() {
-				Some(vec![ServerName::parse(v)?])
+				Some(vec![OwnedServerName::parse(v)?])
 			} else {
 				None
 			},
@@ -965,7 +969,7 @@ pub(super) async fn force_leave_remote_room(
 	);
 	let mut vias: HashSet<OwnedServerName> = HashSet::new();
 	if let Some(via) = via {
-		vias.insert(ServerName::parse(via)?);
+		vias.insert(OwnedServerName::parse(via)?);
 	}
 	for server in vias_raw {
 		vias.insert(server);
@@ -1040,12 +1044,7 @@ pub(super) async fn logout(&self, user_id: String) -> Result {
 	self.services
 		.users
 		.all_device_ids(&user_id)
-		.for_each(async |device_id| {
-			self.services
-				.users
-				.remove_device(&user_id, &device_id)
-				.await;
-		})
+		.for_each(|device_id| self.services.users.remove_device(&user_id, device_id))
 		.await;
 	self.write_str(&format!("User {user_id} has been logged out from all devices."))
 		.await
@@ -1123,9 +1122,11 @@ pub(super) async fn get_user_by_email(&self, email: String) -> Result {
 
 	match self.services.threepid.get_localpart_for_email(&email).await {
 		| Some(localpart) => {
-			let user_id =
-				UserId::parse(format!("@{localpart}:{}", self.services.globals.server_name()))
-					.unwrap();
+			let user_id = OwnedUserId::parse(format!(
+				"@{localpart}:{}",
+				self.services.globals.server_name()
+			))
+			.unwrap();
 
 			self.write_str(&format!("{email} belongs to {user_id}."))
 				.await

src/api/Cargo.toml

@@ -2,7 +2,6 @@
 name = "conduwuit_api"
 description.workspace = true
 edition.workspace = true
-homepage.workspace = true
 license.workspace = true
 readme.workspace = true
 repository.workspace = true
@@ -77,10 +76,8 @@ axum.workspace = true
 base64.workspace = true
 bytes.workspace = true
 conduwuit-core.workspace = true
-conduwuit-macros.workspace = true
 conduwuit-service.workspace = true
 const-str.workspace = true
-ctor.workspace = true
 futures.workspace = true
 hmac.workspace = true
 http.workspace = true

src/api/admin/rooms/ban.rs

@@ -60,9 +60,9 @@ pub(crate) async fn ban_room(
 			.rooms
 			.alias
 			.local_aliases_for_room(&body.room_id)
-			.collect()
+			.map(ToOwned::to_owned)
+			.collect::<Vec<_>>()
 			.await;
-
 		for alias in &aliases {
 			info!("Removing alias {} for banned room {}", alias, body.room_id);
 			services

src/api/admin/rooms/list.rs

@@ -24,7 +24,7 @@ pub(crate) async fn list_rooms(
 		.iter_ids()
 		.filter_map(|room_id| async move {
 			if !services.rooms.metadata.is_banned(&room_id).await {
-				Some(room_id.clone())
+				Some(room_id.to_owned())
 			} else {
 				None
 			}

src/api/client/account/mod.rs

@@ -173,8 +173,8 @@ pub(crate) async fn change_password_route(
 					.get_pusher_device(&pushkey)
 					.await
 					.ok()
-					.as_ref()
-					.is_some_and(|pusher_device| pusher_device != body.sender_device())
+					.filter(|pusher_device| pusher_device != body.sender_device())
+					.is_some()
 					.then_some(pushkey)
 			})
 			.for_each(async |pushkey| {
@@ -349,7 +349,13 @@ pub async fn full_user_deactivate(
 			.await;
 	}
 
-	services.users.clear_profile(user_id).await;
+	services
+		.users
+		.all_profile_keys(user_id)
+		.ready_for_each(|(profile_key, _)| {
+			services.users.set_profile_key(user_id, &profile_key, None);
+		})
+		.await;
 
 	services
 		.pusher
@@ -367,7 +373,7 @@ pub async fn full_user_deactivate(
 		let room_power_levels = services
 			.rooms
 			.state_accessor
-			.get_room_power_levels(room_id)
+			.get_room_power_levels(&room_id)
 			.await;
 
 		let user_can_demote_self =
@@ -394,16 +400,7 @@ pub async fn full_user_deactivate(
 		// TODO: Redact all messages sent by the user in the room
 	}
 
-	for (pdu, room_id) in pdu_queue {
-		let state_lock = services.rooms.state.mutex.lock(room_id.as_str()).await;
-
-		let _ = services
-			.rooms
-			.timeline
-			.build_and_append_pdu(pdu, user_id, Some(room_id.as_ref()), &state_lock)
-			.await;
-	}
-
+	super::update_all_rooms(services, pdu_queue, user_id).await;
 	for room_id in all_joined_rooms {
 		services.rooms.state_cache.forget(room_id, user_id);
 	}

src/api/client/account/register.rs

@@ -459,31 +459,6 @@ async fn create_registration_uiaa_session(
 			flows.push(untrusted_flow);
 		}
 
-		// Require all users to agree to the terms and conditions, if configured
-		let terms = &services.config.registration_terms;
-		if !terms.is_empty() {
-			let mut terms =
-				serde_json::to_value(terms.clone()).expect("failed to serialize terms");
-
-			// Insert a dummy `version` field
-			for (_, documents) in terms.as_object_mut().unwrap() {
-				let documents = documents.as_object_mut().unwrap();
-
-				documents.insert("version".to_owned(), "latest".into());
-			}
-
-			params.insert(
-				AuthType::Terms.as_str().to_owned(),
-				serde_json::json!({
-					"policies": terms,
-				}),
-			);
-
-			for flow in &mut flows {
-				flow.stages.insert(0, AuthType::Terms);
-			}
-		}
-
 		if flows.is_empty() {
 			// No flows are configured. Bail out by default
 			// unless open registration was explicitly enabled.

src/api/client/account/threepid.rs

@@ -133,7 +133,9 @@ pub(crate) async fn delete_3pid_route(
 	let sender_user = body.sender_user();
 
 	if body.medium != Medium::Email {
-		return Ok(delete_3pid::v3::Response::new(ThirdPartyIdRemovalStatus::NoSupport));
+		return Ok(delete_3pid::v3::Response {
+			id_server_unbind_result: ThirdPartyIdRemovalStatus::NoSupport,
+		});
 	}
 
 	if services
@@ -145,5 +147,7 @@ pub(crate) async fn delete_3pid_route(
 		return Err!(Request(ThreepidNotFound("Your account has no associated email.")));
 	}
 
-	Ok(delete_3pid::v3::Response::new(ThirdPartyIdRemovalStatus::Success))
+	Ok(delete_3pid::v3::Response {
+		id_server_unbind_result: ThirdPartyIdRemovalStatus::Success,
+	})
 }

src/api/client/account_data.rs

@@ -7,7 +7,10 @@
 		get_global_account_data, get_room_account_data, set_global_account_data,
 		set_room_account_data,
 	},
-	events::{AnyGlobalAccountDataEventContent, AnyRoomAccountDataEventContent},
+	events::{
+		AnyGlobalAccountDataEventContent, AnyRoomAccountDataEventContent,
+		RoomAccountDataEventType,
+	},
 	serde::Raw,
 };
 use serde::Deserialize;
@@ -84,7 +87,7 @@ pub(crate) async fn get_global_account_data_route(
 		.await
 		.map_err(|_| err!(Request(NotFound("Data not found."))))?;
 
-	Ok(get_global_account_data::v3::Response::new(account_data.content))
+	Ok(get_global_account_data::v3::Response { account_data: account_data.content })
 }
 
 /// # `GET /_matrix/client/r0/user/{userId}/rooms/{roomId}/account_data/{type}`
@@ -106,7 +109,7 @@ pub(crate) async fn get_room_account_data_route(
 		.await
 		.map_err(|_| err!(Request(NotFound("Data not found."))))?;
 
-	Ok(get_room_account_data::v3::Response::new(account_data.content))
+	Ok(get_room_account_data::v3::Response { account_data: account_data.content })
 }
 
 async fn set_account_data(

src/api/client/appservice.rs

@@ -1,9 +1,6 @@
 use axum::extract::State;
 use conduwuit::{Err, Result, err};
-use ruma::{
-	api::{appservice::ping, client::appservice::request_ping},
-	assign,
-};
+use ruma::api::{appservice::ping, client::appservice::request_ping};
 
 use crate::Ruma;
 
@@ -43,9 +40,9 @@ pub(crate) async fn appservice_ping(
 		.sending
 		.send_appservice_request(
 			appservice_info.registration.clone(),
-			assign!(ping::send_ping::v1::Request::new(), {
+			ping::send_ping::v1::Request {
 				transaction_id: body.transaction_id.clone(),
-			}),
+			},
 		)
 		.await?
 		.expect("We already validated if an appservice URL exists above");

src/api/client/backup.rs

@@ -3,6 +3,7 @@
 use axum::extract::State;
 use conduwuit::{Err, Result, err};
 use conduwuit_service::Services;
+use futures::{FutureExt, future::try_join};
 use ruma::{
 	UInt, UserId,
 	api::client::backup::{
@@ -59,9 +60,9 @@ pub(crate) async fn get_latest_backup_info_route(
 		.await
 		.map_err(|_| err!(Request(NotFound("Key backup does not exist."))))?;
 
-	let (count, etag) = get_count_etag(&services, body.sender_user(), &version).await;
+	let (count, etag) = get_count_etag(&services, body.sender_user(), &version).await?;
 
-	Ok(get_latest_backup_info::v3::Response::new(algorithm, count, etag, version))
+	Ok(get_latest_backup_info::v3::Response { algorithm, count, etag, version })
 }
 
 /// # `GET /_matrix/client/v3/room_keys/version/{version}`
@@ -79,9 +80,14 @@ pub(crate) async fn get_backup_info_route(
 			err!(Request(NotFound("Key backup does not exist at version {:?}", body.version)))
 		})?;
 
-	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await;
+	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await?;
 
-	Ok(get_backup_info::v3::Response::new(algorithm, count, etag, body.version.clone()))
+	Ok(get_backup_info::v3::Response {
+		algorithm,
+		count,
+		etag,
+		version: body.version.clone(),
+	})
 }
 
 /// # `DELETE /_matrix/client/r0/room_keys/version/{version}`
@@ -134,9 +140,9 @@ pub(crate) async fn add_backup_keys_route(
 		}
 	}
 
-	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await;
+	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await?;
 
-	Ok(add_backup_keys::v3::Response::new(etag, count))
+	Ok(add_backup_keys::v3::Response { count, etag })
 }
 
 /// # `PUT /_matrix/client/r0/room_keys/keys/{roomId}`
@@ -169,9 +175,9 @@ pub(crate) async fn add_backup_keys_for_room_route(
 			.await?;
 	}
 
-	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await;
+	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await?;
 
-	Ok(add_backup_keys_for_room::v3::Response::new(etag, count))
+	Ok(add_backup_keys_for_room::v3::Response { count, etag })
 }
 
 /// # `PUT /_matrix/client/r0/room_keys/keys/{roomId}/{sessionId}`
@@ -269,9 +275,9 @@ pub(crate) async fn add_backup_keys_for_session_route(
 			.await?;
 	}
 
-	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await;
+	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await?;
 
-	Ok(add_backup_keys_for_session::v3::Response::new(etag, count))
+	Ok(add_backup_keys_for_session::v3::Response { count, etag })
 }
 
 /// # `GET /_matrix/client/r0/room_keys/keys`
@@ -334,7 +340,7 @@ pub(crate) async fn delete_backup_keys_route(
 		.delete_all_keys(body.sender_user(), &body.version)
 		.await;
 
-	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await;
+	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await?;
 
 	Ok(delete_backup_keys::v3::Response::new(etag, count))
 }
@@ -351,7 +357,7 @@ pub(crate) async fn delete_backup_keys_for_room_route(
 		.delete_room_keys(body.sender_user(), &body.version, &body.room_id)
 		.await;
 
-	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await;
+	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await?;
 
 	Ok(delete_backup_keys_for_room::v3::Response::new(etag, count))
 }
@@ -368,7 +374,7 @@ pub(crate) async fn delete_backup_keys_for_session_route(
 		.delete_room_key(body.sender_user(), &body.version, &body.room_id, &body.session_id)
 		.await;
 
-	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await;
+	let (count, etag) = get_count_etag(&services, body.sender_user(), &body.version).await?;
 
 	Ok(delete_backup_keys_for_session::v3::Response::new(etag, count))
 }
@@ -377,15 +383,13 @@ async fn get_count_etag(
 	services: &Services,
 	sender_user: &UserId,
 	version: &str,
-) -> (UInt, String) {
-	let count: UInt = services
+) -> Result<(UInt, String)> {
+	let count = services
 		.key_backups
 		.count_keys(sender_user, version)
-		.await
-		.try_into()
-		.expect("number of keys should fit into a UInt");
+		.map(TryInto::try_into);
 
-	let etag = services.key_backups.get_etag(sender_user, version).await;
+	let etag = services.key_backups.get_etag(sender_user, version).map(Ok);
 
-	(count, etag)
+	Ok(try_join(count, etag).await?)
 }

src/api/client/capabilities.rs

@@ -5,11 +5,8 @@
 use ruma::{
 	RoomVersionId,
 	api::client::discovery::get_capabilities::{
-		self,
-		v3::{
-			Capabilities, GetLoginTokenCapability, RoomVersionStability, RoomVersionsCapability,
-			ThirdPartyIdChangesCapability,
-		},
+		self, Capabilities, GetLoginTokenCapability, RoomVersionStability,
+		RoomVersionsCapability, ThirdPartyIdChangesCapability,
 	},
 };
 use serde_json::json;
@@ -28,17 +25,19 @@ pub(crate) async fn get_capabilities_route(
 		Server::available_room_versions().collect();
 
 	let mut capabilities = Capabilities::default();
-	capabilities.room_versions = RoomVersionsCapability::new(
-		services.server.config.default_room_version.clone(),
+	capabilities.room_versions = RoomVersionsCapability {
 		available,
-	);
+		default: services.server.config.default_room_version.clone(),
+	};
 
 	// Only allow 3pid changes if SMTP is configured
-	capabilities.thirdparty_id_changes =
-		ThirdPartyIdChangesCapability::new(services.mailer.mailer().is_some());
+	capabilities.thirdparty_id_changes = ThirdPartyIdChangesCapability {
+		enabled: services.mailer.mailer().is_some(),
+	};
 
-	capabilities.get_login_token =
-		GetLoginTokenCapability::new(services.server.config.login_via_existing_session);
+	capabilities.get_login_token = GetLoginTokenCapability {
+		enabled: services.server.config.login_via_existing_session,
+	};
 
 	// MSC4133 capability
 	capabilities.set("uk.tcpip.msc4133.profile_fields", json!({"enabled": true}))?;

src/api/client/context.rs

@@ -12,9 +12,7 @@
 	FutureExt, StreamExt, TryFutureExt, TryStreamExt,
 	future::{OptionFuture, join, join3, try_join3},
 };
-use ruma::{
-	OwnedEventId, UserId, api::client::context::get_context, assign, events::StateEventType,
-};
+use ruma::{OwnedEventId, UserId, api::client::context::get_context, events::StateEventType};
 
 use crate::{
 	Ruma,
@@ -215,7 +213,7 @@ pub(crate) async fn get_context_route(
 		.collect()
 		.await;
 
-	Ok(assign!(get_context::v3::Response::new(), {
+	Ok(get_context::v3::Response {
 		event: base_event.map(at!(1)).map(Event::into_format),
 
 		start: events_before
@@ -245,5 +243,5 @@ pub(crate) async fn get_context_route(
 			.collect(),
 
 		state,
-	}))
+	})
 }

src/api/client/dehydrated_device.rs

@@ -2,14 +2,10 @@
 use axum_client_ip::InsecureClientIp;
 use conduwuit::{Err, Result, at};
 use futures::StreamExt;
-use ruma::{
-	api::client::dehydrated_device::{
-		delete_dehydrated_device::unstable as delete_dehydrated_device,
-		get_dehydrated_device::unstable as get_dehydrated_device,
-		get_events::unstable as get_events,
-		put_dehydrated_device::unstable as put_dehydrated_device,
-	},
-	assign,
+use ruma::api::client::dehydrated_device::{
+	delete_dehydrated_device::unstable as delete_dehydrated_device,
+	get_dehydrated_device::unstable as get_dehydrated_device, get_events::unstable as get_events,
+	put_dehydrated_device::unstable as put_dehydrated_device,
 };
 
 use crate::Ruma;
@@ -115,7 +111,8 @@ pub(crate) async fn get_dehydrated_events_route(
 		.collect()
 		.await;
 
-	Ok(assign!(get_events::Response::new(events), {
+	Ok(get_events::Response {
+		events,
 		next_batch: next_batch.as_ref().map(ToString::to_string),
-	}))
+	})
 }

src/api/client/device.rs

@@ -121,28 +121,36 @@ pub(crate) async fn delete_device_route(
 	let sender_user = body.sender_user();
 	let appservice = body.appservice_info.as_ref();
 
-	// Appservices get to skip UIAA for this endpoint
-	if appservice.is_none() {
-		// Prompt the user to confirm with their password using UIAA
-		let _ = services
-			.uiaa
-			.authenticate_password(&body.auth, Some(Identity::from_user_id(sender_user)))
-			.await?;
+	if appservice.is_some() {
+		debug!("Skipping UIAA for {sender_user} as this is from an appservice");
+		services
+			.users
+			.remove_device(sender_user, &body.device_id)
+			.await;
+
+		return Ok(delete_device::v3::Response::new());
 	}
 
+	// Prompt the user to confirm with their password using UIAA
+	let _ = services
+		.uiaa
+		.authenticate_password(&body.auth, Some(Identity::from_user_id(sender_user)))
+		.await?;
+
 	services
 		.users
 		.remove_device(sender_user, &body.device_id)
 		.await;
 
-	Ok(delete_device::v3::Response::new())
+	Ok(delete_device::v3::Response {})
 }
 
 /// # `POST /_matrix/client/v3/delete_devices`
 ///
 /// Deletes the given list of devices.
 ///
-/// - Requires UIAA to verify user password.
+/// - Requires UIAA to verify user password unless from an appservice with
+///   MSC4190 enabled.
 ///
 /// For each device:
 /// - Invalidates access token
@@ -157,18 +165,27 @@ pub(crate) async fn delete_devices_route(
 	let sender_user = body.sender_user();
 	let appservice = body.appservice_info.as_ref();
 
-	// Appservices get to skip UIAA for this endpoint
-	if appservice.is_none() {
-		// Prompt the user to confirm with their password using UIAA
-		let _ = services
-			.uiaa
-			.authenticate_password(&body.auth, Some(Identity::from_user_id(sender_user)))
-			.await?;
+	if appservice.is_some_and(|appservice| appservice.registration.device_management) {
+		debug!(
+			"Skipping UIAA for {sender_user} as this is from an appservice and MSC4190 is \
+			 enabled"
+		);
+		for device_id in &body.devices {
+			services.users.remove_device(sender_user, device_id).await;
+		}
+
+		return Ok(delete_devices::v3::Response {});
 	}
 
+	// Prompt the user to confirm with their password using UIAA
+	let _ = services
+		.uiaa
+		.authenticate_password(&body.auth, Some(Identity::from_user_id(sender_user)))
+		.await?;
+
 	for device_id in &body.devices {
 		services.users.remove_device(sender_user, device_id).await;
 	}
 
-	Ok(delete_devices::v3::Response::new())
+	Ok(delete_devices::v3::Response {})
 }

src/api/client/directory.rs

@@ -1,16 +1,21 @@
 use axum::extract::State;
 use axum_client_ip::InsecureClientIp;
 use conduwuit::{
-	Err, Result, err, info,
+	Err, Event, Result, err, info,
 	utils::{
+		TryFutureExtExt,
 		math::Expected,
+		result::FlatOk,
 		stream::{ReadyExt, WidebandExt},
 	},
 };
 use conduwuit_service::Services;
-use futures::StreamExt;
+use futures::{
+	FutureExt, StreamExt, TryFutureExt,
+	future::{join, join4, join5},
+};
 use ruma::{
-	RoomId, ServerName, UInt, UserId,
+	OwnedRoomId, RoomId, ServerName, UInt, UserId,
 	api::{
 		client::{
 			directory::{
@@ -21,12 +26,17 @@
 		},
 		federation,
 	},
-	assign,
 	directory::{Filter, PublicRoomsChunk, RoomNetwork, RoomTypeFilter},
-	events::StateEventType,
+	events::{
+		StateEventType,
+		room::{
+			join_rules::{JoinRule, RoomJoinRulesEventContent},
+			power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent},
+		},
+	},
+	room::JoinRuleKind,
 	uint,
 };
-use tokio::join;
 
 use crate::Ruma;
 
@@ -96,11 +106,12 @@ pub(crate) async fn get_public_rooms_route(
 		err!(Request(Unknown(warn!(?body.server, "Failed to return /publicRooms: {e}"))))
 	})?;
 
-	Ok(assign!(get_public_rooms::v3::Response::new(response.chunk), {
+	Ok(get_public_rooms::v3::Response {
+		chunk: response.chunk,
 		prev_batch: response.prev_batch,
 		next_batch: response.next_batch,
 		total_room_count_estimate: response.total_room_count_estimate,
-	}))
+	})
 }
 
 /// # `PUT /_matrix/client/r0/directory/list/room/{roomId}`
@@ -132,7 +143,13 @@ pub(crate) async fn set_room_visibility_route(
 		return Err!(Request(Forbidden("Guests cannot publish to room directories")));
 	}
 
-	if !user_can_publish_room(&services, sender_user, &body.room_id).await? {
+	let room_power_levels = services
+		.rooms
+		.state_accessor
+		.get_room_power_levels(&body.room_id)
+		.await;
+
+	if !room_power_levels.user_can_send_state(user_id, StateEventType::RoomHistoryVisibility) {
 		return Err!(Request(Forbidden("User is not allowed to publish this room")));
 	}
 
@@ -183,7 +200,7 @@ pub(crate) async fn set_room_visibility_route(
 		},
 	}
 
-	Ok(set_room_visibility::v3::Response::new())
+	Ok(set_room_visibility::v3::Response {})
 }
 
 /// # `GET /_matrix/client/r0/directory/list/room/{roomId}`
@@ -198,13 +215,13 @@ pub(crate) async fn get_room_visibility_route(
 		return Err!(Request(NotFound("Room not found")));
 	}
 
-	let visibility = if services.rooms.directory.is_public_room(&body.room_id).await {
-		room::Visibility::Public
-	} else {
-		room::Visibility::Private
-	};
-
-	Ok(get_room_visibility::v3::Response::new(visibility))
+	Ok(get_room_visibility::v3::Response {
+		visibility: if services.rooms.directory.is_public_room(&body.room_id).await {
+			room::Visibility::Public
+		} else {
+			room::Visibility::Private
+		},
+	})
 }
 
 pub(crate) async fn get_public_rooms_filtered_helper(
@@ -222,24 +239,24 @@ pub(crate) async fn get_public_rooms_filtered_helper(
 			.sending
 			.send_federation_request(
 				other_server,
-				assign!(federation::directory::get_public_rooms_filtered::v1::Request::new(), {
+				federation::directory::get_public_rooms_filtered::v1::Request {
 					limit,
 					since: since.map(ToOwned::to_owned),
-					filter: assign!(Filter::new(), {
+					filter: Filter {
 						generic_search_term: filter.generic_search_term.clone(),
 						room_types: filter.room_types.clone(),
-					}),
+					},
 					room_network: RoomNetwork::Matrix,
-				}),
+				},
 			)
 			.await?;
 
-		return Ok(assign!(get_public_rooms_filtered::v3::Response::new(), {
+		return Ok(get_public_rooms_filtered::v3::Response {
 			chunk: response.chunk,
 			prev_batch: response.prev_batch,
 			next_batch: response.next_batch,
 			total_room_count_estimate: response.total_room_count_estimate,
-		}));
+		});
 	}
 
 	// Use limit or else 10, with maximum 100
@@ -270,24 +287,16 @@ pub(crate) async fn get_public_rooms_filtered_helper(
 		.rooms
 		.directory
 		.public_rooms()
-		.wide_then(async |room_id| {
-			let summary = services
-				.rooms
-				.summary
-				.build_local_room_summary(&room_id)
-				.await
-				.expect("room in public room directory should exist");
-
-			summary.into()
-		})
-		.ready_filter_map(|chunk: PublicRoomsChunk| {
+		.map(ToOwned::to_owned)
+		.wide_then(|room_id| public_rooms_chunk(services, room_id))
+		.ready_filter_map(|chunk| {
 			if !filter.room_types.is_empty() && !filter.room_types.contains(&RoomTypeFilter::from(chunk.room_type.clone())) {
 				return None;
 			}
 
 			if let Some(query) = filter.generic_search_term.as_ref().map(|q| q.to_lowercase()) {
 				if let Some(name) = &chunk.name {
-					if name.to_lowercase().contains(&query) {
+					if name.as_str().to_lowercase().contains(&query) {
 						return Some(chunk);
 					}
 				}
@@ -314,7 +323,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
 		.collect()
 		.await;
 
-	all_rooms.sort_by_key(|r| std::cmp::Reverse(r.num_joined_members));
+	all_rooms.sort_by(|l, r| r.num_joined_members.cmp(&l.num_joined_members));
 
 	let total_room_count_estimate = UInt::try_from(all_rooms.len())
 		.unwrap_or_else(|_| uint!(0))
@@ -329,46 +338,70 @@ pub(crate) async fn get_public_rooms_filtered_helper(
 		.ge(&limit)
 		.then_some(format!("n{}", num_since.expected_add(limit)));
 
-	Ok(assign!(get_public_rooms_filtered::v3::Response::new(), {
+	Ok(get_public_rooms_filtered::v3::Response {
 		chunk,
 		prev_batch,
 		next_batch,
 		total_room_count_estimate,
-	}))
+	})
 }
 
-/// Checks whether the given user ID is allowed to publish the target room to
-/// the server's public room directory. Users are allowed to publish rooms if
-/// they are server admins, room creators (in v12), or have the power level to
-/// send `m.room.canonical_alias`.
-async fn user_can_publish_room(
-	services: &Services,
-	user_id: &UserId,
-	room_id: &RoomId,
-) -> Result<bool> {
-	if services.users.is_admin(user_id).await {
-		// Server admins can always publish to their own room directory.
-		return Ok(true);
+async fn public_rooms_chunk(services: &Services, room_id: OwnedRoomId) -> PublicRoomsChunk {
+	let name = services.rooms.state_accessor.get_name(&room_id).ok();
+
+	let room_type = services.rooms.state_accessor.get_room_type(&room_id).ok();
+
+	let canonical_alias = services
+		.rooms
+		.state_accessor
+		.get_canonical_alias(&room_id)
+		.ok();
+
+	let avatar_url = services.rooms.state_accessor.get_avatar(&room_id);
+
+	let topic = services.rooms.state_accessor.get_room_topic(&room_id).ok();
+
+	let world_readable = services.rooms.state_accessor.is_world_readable(&room_id);
+
+	let join_rule = services
+		.rooms
+		.state_accessor
+		.room_state_get_content(&room_id, &StateEventType::RoomJoinRules, "")
+		.map_ok(|c: RoomJoinRulesEventContent| match c.join_rule {
+			| JoinRule::Public => JoinRuleKind::Public,
+			| JoinRule::Knock => "knock".into(),
+			| JoinRule::KnockRestricted(_) => "knock_restricted".into(),
+			| _ => "invite".into(),
+		});
+
+	let guest_can_join = services.rooms.state_accessor.guest_can_join(&room_id);
+
+	let num_joined_members = services.rooms.state_cache.room_joined_count(&room_id);
+
+	let (
+		(avatar_url, canonical_alias, guest_can_join, join_rule, name),
+		(num_joined_members, room_type, topic, world_readable),
+	) = join(
+		join5(avatar_url, canonical_alias, guest_can_join, join_rule, name),
+		join4(num_joined_members, room_type, topic, world_readable),
+	)
+	.boxed()
+	.await;
+
+	PublicRoomsChunk {
+		avatar_url: avatar_url.into_option().unwrap_or_default().url,
+		canonical_alias,
+		guest_can_join,
+		join_rule: join_rule.unwrap_or_default(),
+		name,
+		num_joined_members: num_joined_members
+			.map(TryInto::try_into)
+			.map(Result::ok)
+			.flat_ok()
+			.unwrap_or_else(|| uint!(0)),
+		room_id,
+		room_type,
+		topic,
+		world_readable,
 	}
-
-	let (room_version, room_creators, power_levels) = join!(
-		services.rooms.state.get_room_version(room_id),
-		services.rooms.state_accessor.get_room_creators(room_id),
-		services.rooms.state_accessor.get_room_power_levels(room_id),
-	);
-
-	let room_version = room_version
-		.as_ref()
-		.map_err(|_| err!(Request(NotFound("Unknown room"))))?;
-	let room_version_rules = room_version.rules().unwrap();
-
-	if room_version_rules
-		.authorization
-		.explicitly_privilege_room_creators
-		&& room_creators.contains(user_id)
-	{
-		return Ok(true);
-	}
-
-	Ok(power_levels.user_can_send_state(user_id, StateEventType::RoomCanonicalAlias))
 }

src/api/client/keys.rs

@@ -5,7 +5,7 @@
 
 use axum::extract::State;
 use conduwuit::{
-	Err, Result, debug, debug_warn, err,
+	Err, Error, Result, debug, debug_warn, err,
 	result::NotFound,
 	utils::{IterStream, stream::WidebandExt},
 };
@@ -14,14 +14,16 @@
 use ruma::{
 	OneTimeKeyAlgorithm, OwnedDeviceId, OwnedUserId, UserId,
 	api::{
-		client::keys::{
-			claim_keys, get_key_changes, get_keys, upload_keys,
-			upload_signatures::{self},
-			upload_signing_keys,
+		client::{
+			error::ErrorKind,
+			keys::{
+				claim_keys, get_key_changes, get_keys, upload_keys,
+				upload_signatures::{self},
+				upload_signing_keys,
+			},
 		},
 		federation,
 	},
-	assign,
 	encryption::CrossSigningKey,
 	serde::Raw,
 };
@@ -113,12 +115,12 @@ pub(crate) async fn upload_keys_route(
 		}
 	}
 
-	let one_time_key_counts = services
-		.users
-		.count_one_time_keys(sender_user, sender_device)
-		.await;
-
-	Ok(upload_keys::v3::Response::new(one_time_key_counts))
+	Ok(upload_keys::v3::Response {
+		one_time_key_counts: services
+			.users
+			.count_one_time_keys(sender_user, sender_device)
+			.await,
+	})
 }
 
 /// # `POST /_matrix/client/r0/keys/query`
@@ -212,7 +214,7 @@ pub(crate) async fn upload_signing_keys_route(
 		)
 		.await?;
 
-	Ok(upload_signing_keys::v3::Response::new())
+	Ok(upload_signing_keys::v3::Response {})
 }
 
 async fn check_for_new_keys(
@@ -224,7 +226,8 @@ async fn check_for_new_keys(
 ) -> Result<Option<upload_signing_keys::v3::Response>> {
 	debug!("checking for existing keys");
 	let mut empty = false;
-	if master_signing_key.is_some() {
+	if let Some(master_signing_key) = master_signing_key {
+		let (key, value) = parse_master_key(user_id, master_signing_key)?;
 		let result = services
 			.users
 			.get_master_key(None, user_id, &|_| true)
@@ -232,12 +235,16 @@ async fn check_for_new_keys(
 		if result.is_not_found() {
 			empty = true;
 		} else {
-			return Err!(Request(Forbidden(
-				"Tried to change an existing master key, UIA required"
-			)));
+			let existing_master_key = result?;
+			let (existing_key, existing_value) = parse_master_key(user_id, &existing_master_key)?;
+			if existing_key != key || existing_value != value {
+				return Err!(Request(Forbidden(
+					"Tried to change an existing master key, UIA required"
+				)));
+			}
 		}
 	}
-	if user_signing_key.is_some() {
+	if let Some(user_signing_key) = user_signing_key {
 		let key = services.users.get_user_signing_key(user_id).await;
 		if key.is_not_found() && !empty {
 			return Err!(Request(Forbidden(
@@ -245,12 +252,15 @@ async fn check_for_new_keys(
 			)));
 		}
 		if !key.is_not_found() {
-			return Err!(Request(Forbidden(
-				"Tried to change an existing user signing key, UIA required"
-			)));
+			let existing_signing_key = key?.deserialize()?;
+			if existing_signing_key != user_signing_key.deserialize()? {
+				return Err!(Request(Forbidden(
+					"Tried to change an existing user signing key, UIA required"
+				)));
+			}
 		}
 	}
-	if self_signing_key.is_some() {
+	if let Some(self_signing_key) = self_signing_key {
 		let key = services
 			.users
 			.get_self_signing_key(None, user_id, &|_| true)
@@ -262,16 +272,19 @@ async fn check_for_new_keys(
 			)));
 		}
 		if !key.is_not_found() {
-			return Err!(Request(Forbidden(
-				"Tried to update an existing self signing key, UIA required"
-			)));
+			let existing_signing_key = key?.deserialize()?;
+			if existing_signing_key != self_signing_key.deserialize()? {
+				return Err!(Request(Forbidden(
+					"Tried to update an existing self signing key, UIA required"
+				)));
+			}
 		}
 	}
 	if empty {
 		return Ok(None);
 	}
 
-	Ok(Some(upload_signing_keys::v3::Response::new()))
+	Ok(Some(upload_signing_keys::v3::Response {}))
 }
 
 /// # `POST /_matrix/client/r0/keys/signatures/upload`
@@ -330,7 +343,7 @@ pub(crate) async fn upload_signatures_route(
 		}
 	}
 
-	Ok(upload_signatures::v3::Response::new())
+	Ok(upload_signatures::v3::Response { failures: BTreeMap::new() })
 }
 
 /// # `POST /_matrix/client/r0/keys/changes`
@@ -350,17 +363,18 @@ pub(crate) async fn get_key_changes_route(
 	let from = body
 		.from
 		.parse()
-		.map_err(|_| err!(Request(InvalidParam("Invalid `from`."))))?;
+		.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid `from`."))?;
 
 	let to = body
 		.to
 		.parse()
-		.map_err(|_| err!(Request(InvalidParam("Invalid `to`."))))?;
+		.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid `to`."))?;
 
 	device_list_updates.extend(
 		services
 			.users
 			.keys_changed(sender_user, Some(from), Some(to))
+			.map(ToOwned::to_owned)
 			.collect::<Vec<_>>()
 			.await,
 	);
@@ -371,18 +385,18 @@ pub(crate) async fn get_key_changes_route(
 		device_list_updates.extend(
 			services
 				.users
-				.room_keys_changed(&room_id, Some(from), Some(to))
+				.room_keys_changed(room_id, Some(from), Some(to))
 				.map(|(user_id, _)| user_id)
+				.map(ToOwned::to_owned)
 				.collect::<Vec<_>>()
 				.await,
 		);
 	}
 
-	Ok(get_key_changes::v3::Response::new(
-		device_list_updates.into_iter().collect(),
-		// TODO
-		vec![],
-	))
+	Ok(get_key_changes::v3::Response {
+		changed: device_list_updates.into_iter().collect(),
+		left: Vec::new(), // TODO
+	})
 }
 
 pub(crate) async fn get_keys_helper<F>(
@@ -419,10 +433,10 @@ pub(crate) async fn get_keys_helper<F>(
 			let mut devices = services.users.all_device_ids(user_id).boxed();
 
 			while let Some(device_id) = devices.next().await {
-				if let Ok(mut keys) = services.users.get_device_keys(user_id, &device_id).await {
+				if let Ok(mut keys) = services.users.get_device_keys(user_id, device_id).await {
 					let metadata = services
 						.users
-						.get_device_metadata(user_id, &device_id)
+						.get_device_metadata(user_id, device_id)
 						.await
 						.map_err(|_| {
 							err!(Database("all_device_keys contained nonexistent device."))
@@ -431,7 +445,7 @@ pub(crate) async fn get_keys_helper<F>(
 					add_unsigned_device_display_name(&mut keys, metadata, include_display_names)
 						.map_err(|_| err!(Database("invalid device keys in database")))?;
 
-					container.insert(device_id.clone(), keys);
+					container.insert(device_id.to_owned(), keys);
 				}
 			}
 
@@ -492,7 +506,8 @@ pub(crate) async fn get_keys_helper<F>(
 				device_keys_input_fed.insert(user_id.to_owned(), keys.clone());
 			}
 
-			let request = federation::keys::get_keys::v1::Request::new(device_keys_input_fed);
+			let request =
+				federation::keys::get_keys::v1::Request { device_keys: device_keys_input_fed };
 			let response = tokio::time::timeout(
 				timeout,
 				services.sending.send_federation_request(server, request),
@@ -546,13 +561,13 @@ pub(crate) async fn get_keys_helper<F>(
 		}
 	}
 
-	Ok(assign!(get_keys::v3::Response::new(), {
+	Ok(get_keys::v3::Response {
 		failures,
 		device_keys,
 		master_keys,
 		self_signing_keys,
 		user_signing_keys,
-	}))
+	})
 }
 
 fn add_unsigned_device_display_name(
@@ -561,8 +576,7 @@ fn add_unsigned_device_display_name(
 	include_display_names: bool,
 ) -> serde_json::Result<()> {
 	if let Some(display_name) = metadata.display_name {
-		let mut object =
-			keys.deserialize_as_unchecked::<serde_json::Map<String, serde_json::Value>>()?;
+		let mut object = keys.deserialize_as::<serde_json::Map<String, serde_json::Value>>()?;
 
 		let unsigned = object.entry("unsigned").or_insert_with(|| json!({}));
 		if let serde_json::Value::Object(unsigned_object) = unsigned {
@@ -628,7 +642,9 @@ pub(crate) async fn claim_keys_helper(
 				timeout,
 				services.sending.send_federation_request(
 					server,
-					federation::keys::claim_keys::v1::Request::new(one_time_keys_input_fed),
+					federation::keys::claim_keys::v1::Request {
+						one_time_keys: one_time_keys_input_fed,
+					},
 				),
 			)
 			.await
@@ -651,5 +667,5 @@ pub(crate) async fn claim_keys_helper(
 		}
 	}
 
-	Ok(assign!(claim_keys::v3::Response::new(one_time_keys), { failures: failures }))
+	Ok(claim_keys::v3::Response { failures, one_time_keys })
 }

src/api/client/media.rs

@@ -9,7 +9,7 @@
 use conduwuit_core::error;
 use conduwuit_service::{
 	Services,
-	media::{Dim, FileMeta, MXC_LENGTH},
+	media::{CACHE_CONTROL_IMMUTABLE, CORP_CROSS_ORIGIN, Dim, FileMeta, MXC_LENGTH},
 };
 use reqwest::Url;
 use ruma::{
@@ -21,9 +21,7 @@
 		},
 		media::create_content,
 	},
-	assign,
 };
-use service::media::mxc::Mxc;
 
 use crate::Ruma;
 
@@ -32,9 +30,9 @@ pub(crate) async fn get_media_config_route(
 	State(services): State<crate::State>,
 	_body: Ruma<get_media_config::v1::Request>,
 ) -> Result<get_media_config::v1::Response> {
-	Ok(get_media_config::v1::Response::new(ruma_from_usize(
-		services.server.config.max_request_size,
-	)))
+	Ok(get_media_config::v1::Response {
+		upload_size: ruma_from_usize(services.server.config.max_request_size),
+	})
 }
 
 /// # `POST /_matrix/media/v3/upload`
@@ -84,9 +82,10 @@ pub(crate) async fn create_content_route(
 			.flatten()
 	});
 
-	Ok(assign!(create_content::v3::Response::new(mxc.to_string().into()), {
+	Ok(create_content::v3::Response {
+		content_uri: mxc.to_string().into(),
 		blurhash: blurhash.flatten(),
-	}))
+	})
 }
 
 /// # `GET /_matrix/client/v1/media/thumbnail/{serverName}/{mediaId}`
@@ -115,7 +114,7 @@ pub(crate) async fn get_content_thumbnail_route(
 		content,
 		content_type,
 		content_disposition,
-	} = match fetch_thumbnail_meta(&services, &mxc, user, body.timeout_ms, &dim).await {
+	} = match fetch_thumbnail(&services, &mxc, user, body.timeout_ms, &dim).await {
 		| Ok(meta) => meta,
 		| Err(conduwuit::Error::Io(e)) => match e.kind() {
 			| std::io::ErrorKind::NotFound =>
@@ -129,14 +128,13 @@ pub(crate) async fn get_content_thumbnail_route(
 		| Err(_) => return Err!(Request(Unknown("Unknown error when fetching thumbnail."))),
 	};
 
-	let content_disposition =
-		make_content_disposition(content_disposition.as_ref(), content_type.as_deref(), None);
-
-	Ok(get_content_thumbnail::v1::Response::new(
-		content.expect("entire file contents"),
-		content_type.unwrap_or_default(),
+	Ok(get_content_thumbnail::v1::Response {
+		file: content.expect("entire file contents"),
+		content_type: content_type.map(Into::into),
+		cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
+		cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
 		content_disposition,
-	))
+	})
 }
 
 /// # `GET /_matrix/client/v1/media/download/{serverName}/{mediaId}`
@@ -163,7 +161,7 @@ pub(crate) async fn get_content_route(
 		content,
 		content_type,
 		content_disposition,
-	} = match fetch_file_meta(&services, &mxc, user, body.timeout_ms).await {
+	} = match fetch_file(&services, &mxc, user, body.timeout_ms, None).await {
 		| Ok(meta) => meta,
 		| Err(conduwuit::Error::Io(e)) => match e.kind() {
 			| std::io::ErrorKind::NotFound => return Err!(Request(NotFound("Media not found."))),
@@ -176,14 +174,13 @@ pub(crate) async fn get_content_route(
 		| Err(_) => return Err!(Request(Unknown("Unknown error when fetching file."))),
 	};
 
-	let content_disposition =
-		make_content_disposition(content_disposition.as_ref(), content_type.as_deref(), None);
-
-	Ok(get_content::v1::Response::new(
-		content.expect("entire file contents"),
-		content_type.unwrap_or_default(),
+	Ok(get_content::v1::Response {
+		file: content.expect("entire file contents"),
+		content_type: content_type.map(Into::into),
+		cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
+		cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
 		content_disposition,
-	))
+	})
 }
 
 /// # `GET /_matrix/client/v1/media/download/{serverName}/{mediaId}/{fileName}`
@@ -211,7 +208,7 @@ pub(crate) async fn get_content_as_filename_route(
 		content,
 		content_type,
 		content_disposition,
-	} = match fetch_file_meta(&services, &mxc, user, body.timeout_ms).await {
+	} = match fetch_file(&services, &mxc, user, body.timeout_ms, None).await {
 		| Ok(meta) => meta,
 		| Err(conduwuit::Error::Io(e)) => match e.kind() {
 			| std::io::ErrorKind::NotFound => return Err!(Request(NotFound("Media not found."))),
@@ -224,17 +221,13 @@ pub(crate) async fn get_content_as_filename_route(
 		| Err(_) => return Err!(Request(Unknown("Unknown error when fetching file."))),
 	};
 
-	let content_disposition = make_content_disposition(
-		content_disposition.as_ref(),
-		content_type.as_deref(),
-		Some(&body.filename),
-	);
-
-	Ok(get_content_as_filename::v1::Response::new(
-		content.expect("entire file contents"),
-		content_type.unwrap_or_default(),
+	Ok(get_content_as_filename::v1::Response {
+		file: content.expect("entire file contents"),
+		content_type: content_type.map(Into::into),
+		cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
+		cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
 		content_disposition,
-	))
+	})
 }
 
 /// # `GET /_matrix/client/v1/media/preview_url`
@@ -285,6 +278,58 @@ pub(crate) async fn get_media_preview_route(
 		})
 }
 
+async fn fetch_thumbnail(
+	services: &Services,
+	mxc: &Mxc<'_>,
+	user: &UserId,
+	timeout_ms: Duration,
+	dim: &Dim,
+) -> Result<FileMeta> {
+	let FileMeta {
+		content,
+		content_type,
+		content_disposition,
+	} = fetch_thumbnail_meta(services, mxc, user, timeout_ms, dim).await?;
+
+	let content_disposition = Some(make_content_disposition(
+		content_disposition.as_ref(),
+		content_type.as_deref(),
+		None,
+	));
+
+	Ok(FileMeta {
+		content,
+		content_type,
+		content_disposition,
+	})
+}
+
+async fn fetch_file(
+	services: &Services,
+	mxc: &Mxc<'_>,
+	user: &UserId,
+	timeout_ms: Duration,
+	filename: Option<&str>,
+) -> Result<FileMeta> {
+	let FileMeta {
+		content,
+		content_type,
+		content_disposition,
+	} = fetch_file_meta(services, mxc, user, timeout_ms).await?;
+
+	let content_disposition = Some(make_content_disposition(
+		content_disposition.as_ref(),
+		content_type.as_deref(),
+		filename,
+	));
+
+	Ok(FileMeta {
+		content,
+		content_type,
+		content_disposition,
+	})
+}
+
 async fn fetch_thumbnail_meta(
 	services: &Services,
 	mxc: &Mxc<'_>,

src/api/client/media_legacy.rs

@@ -6,16 +6,15 @@
 	Err, Result, err,
 	utils::{content_disposition::make_content_disposition, math::ruma_from_usize},
 };
-use conduwuit_service::media::{CORP_CROSS_ORIGIN, Dim, FileMeta};
+use conduwuit_service::media::{CACHE_CONTROL_IMMUTABLE, CORP_CROSS_ORIGIN, Dim, FileMeta};
 use reqwest::Url;
 use ruma::{
+	Mxc,
 	api::client::media::{
 		create_content, get_content, get_content_as_filename, get_content_thumbnail,
 		get_media_config, get_media_preview,
 	},
-	assign,
 };
-use service::media::mxc::Mxc;
 
 use crate::{Ruma, RumaResponse, client::create_content_route};
 
@@ -26,9 +25,9 @@ pub(crate) async fn get_media_config_legacy_route(
 	State(services): State<crate::State>,
 	_body: Ruma<get_media_config::v3::Request>,
 ) -> Result<get_media_config::v3::Response> {
-	Ok(get_media_config::v3::Response::new(ruma_from_usize(
-		services.server.config.max_request_size,
-	)))
+	Ok(get_media_config::v3::Response {
+		upload_size: ruma_from_usize(services.server.config.max_request_size),
+	})
 }
 
 /// # `GET /_matrix/media/v1/config`
@@ -154,16 +153,13 @@ pub(crate) async fn get_content_legacy_route(
 				None,
 			);
 
-			Ok(assign!(
-				get_content::v3::Response::new(
-					content.expect("entire file contents"),
-					content_type.unwrap_or_default(),
-					content_disposition,
-				),
-				{
-					cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
-				}
-			))
+			Ok(get_content::v3::Response {
+				file: content.expect("entire file contents"),
+				content_type: content_type.map(Into::into),
+				content_disposition: Some(content_disposition),
+				cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
+				cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
+			})
 		},
 		| _ =>
 			if !services.globals.server_is_ours(&body.server_name) && body.allow_remote {
@@ -181,16 +177,13 @@ pub(crate) async fn get_content_legacy_route(
 					None,
 				);
 
-				Ok(assign!(
-					get_content::v3::Response::new(
-						response.file,
-						response.content_type.unwrap_or_default(),
-						content_disposition,
-					),
-					{
-						cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
-					}
-				))
+				Ok(get_content::v3::Response {
+					file: response.file,
+					content_type: response.content_type,
+					content_disposition: Some(content_disposition),
+					cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
+					cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
+				})
 			} else {
 				Err!(Request(NotFound("Media not found.")))
 			},
@@ -251,15 +244,13 @@ pub(crate) async fn get_content_as_filename_legacy_route(
 				Some(&body.filename),
 			);
 
-			Ok(assign!(get_content_as_filename::v3::Response::new(
-					content.expect("entire file contents"),
-					content_type.unwrap_or_default(),
-					content_disposition,
-				),
-				{
-					cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
-				}
-			))
+			Ok(get_content_as_filename::v3::Response {
+				file: content.expect("entire file contents"),
+				content_type: content_type.map(Into::into),
+				content_disposition: Some(content_disposition),
+				cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
+				cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
+			})
 		},
 		| _ =>
 			if !services.globals.server_is_ours(&body.server_name) && body.allow_remote {
@@ -277,16 +268,13 @@ pub(crate) async fn get_content_as_filename_legacy_route(
 					None,
 				);
 
-				Ok(assign!(
-					get_content_as_filename::v3::Response::new(
-						response.file,
-						response.content_type.unwrap_or_default(),
-						content_disposition,
-					),
-					{
-						cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
-					}
-				))
+				Ok(get_content_as_filename::v3::Response {
+					content_disposition: Some(content_disposition),
+					content_type: response.content_type,
+					file: response.file,
+					cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
+					cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
+				})
 			} else {
 				Err!(Request(NotFound("Media not found.")))
 			},
@@ -347,16 +335,13 @@ pub(crate) async fn get_content_thumbnail_legacy_route(
 				None,
 			);
 
-			Ok(assign!(
-				get_content_thumbnail::v3::Response::new(
-					content.expect("entire file contents"),
-					content_type.unwrap_or_default(),
-					content_disposition,
-				),
-				{
-					cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.to_owned()),
-				}
-			))
+			Ok(get_content_thumbnail::v3::Response {
+				file: content.expect("entire file contents"),
+				content_type: content_type.map(Into::into),
+				cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
+				cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
+				content_disposition: Some(content_disposition),
+			})
 		},
 		| _ =>
 			if !services.globals.server_is_ours(&body.server_name) && body.allow_remote {
@@ -374,16 +359,13 @@ pub(crate) async fn get_content_thumbnail_legacy_route(
 					None,
 				);
 
-				Ok(assign!(
-					get_content_thumbnail::v3::Response::new(
-						response.file,
-						response.content_type.unwrap_or_default(),
-						content_disposition,
-					),
-					{
-						cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.to_owned()),
-					}
-				))
+				Ok(get_content_thumbnail::v3::Response {
+					file: response.file,
+					content_type: response.content_type,
+					cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
+					cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
+					content_disposition: Some(content_disposition),
+				})
 			} else {
 				Err!(Request(NotFound("Media not found.")))
 			},

src/api/client/membership/ban.rs

@@ -34,7 +34,7 @@ pub(crate) async fn ban_user_route(
 		.unwrap_or_else(|_| RoomMemberEventContent::new(MembershipState::Ban));
 
 	content.membership = MembershipState::Ban;
-	content.reason.clone_from(&body.reason);
+	content.reason = body.reason.clone();
 	content.displayname = None;
 	content.avatar_url = None;
 	content.is_direct = None;

src/api/client/membership/invite.rs

@@ -10,7 +10,7 @@
 	RoomId, UserId,
 	api::{
 		client::membership::invite_user::{self, v3::InviteUserId},
-		federation::membership::create_invite,
+		federation::membership::{RawStrippedState, create_invite},
 	},
 	events::room::member::{MembershipState, RoomMemberEventContent},
 };
@@ -163,7 +163,15 @@ pub(crate) async fn invite_helper(
 				)
 				.await?;
 
-			let invite_room_state = services.rooms.state.summary_stripped(&pdu, room_id).await;
+			#[allow(deprecated)]
+			let invite_room_state = services
+				.rooms
+				.state
+				.summary_stripped(&pdu, room_id)
+				.await
+				.into_iter()
+				.map(|event| RawStrippedState::Stripped(event))
+				.collect();
 
 			drop(state_lock);
 
@@ -250,8 +258,8 @@ pub(crate) async fn invite_helper(
 	services
 		.rooms
 		.timeline
-		.build_and_append_pdu(
-			PartialPdu::state(recipient_user.to_string(), &content),
+		.PartialPduappend_pdu(
+			PduBuilder::state(recipient_user.to_string(), &content),
 			sender_user,
 			Some(room_id),
 			&state_lock,

src/api/client/membership/join.rs

@@ -424,9 +424,7 @@ async fn join_room_by_id_helper_remote(
 	join_content.avatar_url = services.users.avatar_url(sender_user).await.ok();
 	join_content.blurhash = services.users.blurhash(sender_user).await.ok();
 	join_content.reason = reason;
-	join_content
-		.join_authorized_via_users_server
-		.clone_from(&join_authorized_via_users_server);
+	join_content.join_authorized_via_users_server = join_authorized_via_users_server.clone();
 
 	join_event_stub.insert(
 		"content".to_owned(),
@@ -735,7 +733,8 @@ async fn join_room_by_id_helper_local(
 			// This is a restricted room, check if we can complete the join requirements
 			// locally.
 			let needs_auth_user =
-				user_can_perform_restricted_join(services, sender_user, room_id).await;
+				user_can_perform_restricted_join(services, sender_user, room_id, &room_version)
+					.await;
 			if needs_auth_user.is_ok_and(is_true!()) {
 				// If there was an error or the value is false, we'll try joining over
 				// federation. Since it's Ok(true), we can authorise this locally.
@@ -752,7 +751,7 @@ async fn join_room_by_id_helper_local(
 	content.displayname = services.users.displayname(sender_user).await.ok();
 	content.avatar_url = services.users.avatar_url(sender_user).await.ok();
 	content.blurhash = services.users.blurhash(sender_user).await.ok();
-	content.reason.clone_from(&reason);
+	content.reason = reason.clone();
 	content.join_authorized_via_users_server = auth_user;
 
 	// Try normal join first
@@ -861,7 +860,7 @@ async fn make_join_request(
 					);
 					return Err(e);
 				},
-				| ErrorKind::Forbidden => {
+				| ErrorKind::Forbidden { .. } => {
 					warn!("{remote_server} refuses to let us join: {e}.");
 					return Err(e);
 				},

src/api/client/membership/kick.rs

@@ -39,7 +39,7 @@ pub(crate) async fn kick_user_route(
 	}
 
 	event.membership = MembershipState::Leave;
-	event.reason.clone_from(&body.reason);
+	event.reason = body.reason.clone();
 	event.is_direct = None;
 	event.join_authorized_via_users_server = None;
 	event.third_party_invite = None;

src/api/client/membership/knock.rs

@@ -347,7 +347,7 @@ async fn knock_room_helper_local(
 	content.displayname = services.users.displayname(sender_user).await.ok();
 	content.avatar_url = services.users.avatar_url(sender_user).await.ok();
 	content.blurhash = services.users.blurhash(sender_user).await.ok();
-	content.reason.clone_from(&reason.clone());
+	content.reason = reason.clone();
 
 	// Try normal knock first
 	let Err(error) = services

src/api/client/membership/members.rs

@@ -119,5 +119,5 @@ fn membership_filter<Pdu: Event>(
 		return None;
 	}
 
-	Some(pdu)
+	return Some(pdu);
 }

src/api/client/membership/unban.rs

@@ -35,7 +35,7 @@ pub(crate) async fn unban_user_route(
 	}
 
 	current_member_content.membership = MembershipState::Leave;
-	current_member_content.reason.clone_from(&body.reason);
+	current_member_content.reason = body.reason.clone();
 	current_member_content.join_authorized_via_users_server = None;
 	current_member_content.third_party_invite = None;
 	current_member_content.is_direct = None;

src/api/client/message.rs

@@ -26,17 +26,15 @@
 	DeviceId, RoomId, UserId,
 	api::{
 		Direction,
-		client::{filter::RoomEventFilter, message::get_message_events},
-		error::{ErrorKind, SenderIgnoredErrorData},
+		client::{error::ErrorKind, filter::RoomEventFilter, message::get_message_events},
 	},
-	assign,
 	events::{
 		AnyStateEvent, StateEventType,
 		TimelineEventType::{self, *},
+		invite_permission_config::FilterLevel,
 	},
 	serde::Raw,
 };
-use ruminuwuity::invite_permission_config::FilterLevel;
 use tracing::warn;
 
 use crate::Ruma;
@@ -76,6 +74,7 @@ pub(crate) async fn get_message_events_route(
 	InsecureClientIp(client_ip): InsecureClientIp,
 	body: Ruma<get_message_events::v3::Request>,
 ) -> Result<get_message_events::v3::Response> {
+	debug_assert!(IGNORED_MESSAGE_TYPES.is_sorted(), "IGNORED_MESSAGE_TYPES is not sorted");
 	let sender_user = body.sender_user();
 	let sender_device = body.sender_device.as_deref();
 	let room_id = &body.room_id;
@@ -200,12 +199,12 @@ pub(crate) async fn get_message_events_route(
 		.map(Event::into_format)
 		.collect();
 
-	Ok(assign!(get_message_events::v3::Response::new(), {
+	Ok(get_message_events::v3::Response {
 		start: from.to_string(),
 		end: next_token.as_ref().map(PduCount::to_string),
-		chunk: chunk,
-		state: state,
-	}))
+		chunk,
+		state,
+	})
 }
 
 pub(crate) async fn lazy_loading_witness<'a, I>(
@@ -302,7 +301,7 @@ pub(crate) async fn is_ignored_pdu<Pdu>(
 {
 	// exclude Synapse's dummy events from bloating up response bodies. clients
 	// don't need to see this.
-	if event.kind().to_string() == "org.matrix.dummy_event" {
+	if event.kind().to_cow_str() == "org.matrix.dummy_event" {
 		return Ok(true);
 	}
 
@@ -324,7 +323,7 @@ pub(crate) async fn is_ignored_pdu<Pdu>(
 	if server_ignored {
 		// the sender's server is ignored, so ignore this event
 		return Err(Error::BadRequest(
-			ErrorKind::SenderIgnored(SenderIgnoredErrorData::new()),
+			ErrorKind::SenderIgnored { sender: None },
 			"The sender's server is ignored by this server.",
 		));
 	}
@@ -333,9 +332,7 @@ pub(crate) async fn is_ignored_pdu<Pdu>(
 		// the recipient of this PDU has the sender ignored, and we're not
 		// configured to send ignored messages to clients
 		return Err(Error::BadRequest(
-			ErrorKind::SenderIgnored(SenderIgnoredErrorData::with_sender(
-				event.sender().to_owned(),
-			)),
+			ErrorKind::SenderIgnored { sender: Some(event.sender().to_owned()) },
 			"You have ignored this sender.",
 		));
 	}

src/api/client/mod.rs

@@ -15,7 +15,6 @@
 pub(super) mod media_legacy;
 pub(super) mod membership;
 pub(super) mod message;
-pub(super) mod mutual_rooms;
 pub(super) mod openid;
 pub(super) mod presence;
 pub(super) mod profile;
@@ -36,6 +35,7 @@
 pub(super) mod threads;
 pub(super) mod to_device;
 pub(super) mod typing;
+pub(super) mod unstable;
 pub(super) mod unversioned;
 pub(super) mod user_directory;
 pub(super) mod voip;
@@ -60,10 +60,10 @@
 pub(super) use membership::*;
 pub use membership::{join_room_by_id_helper, leave_all_rooms, leave_room, remote_leave_room};
 pub(super) use message::*;
-pub(super) use mutual_rooms::*;
 pub(super) use openid::*;
 pub(super) use presence::*;
 pub(super) use profile::*;
+pub use profile::{update_all_rooms, update_avatar_url, update_displayname};
 pub use push::recreate_push_rules_and_return;
 pub(super) use push::*;
 pub(super) use read_marker::*;
@@ -82,6 +82,7 @@
 pub(super) use threads::*;
 pub(super) use to_device::*;
 pub(super) use typing::*;
+pub(super) use unstable::*;
 pub(super) use unversioned::*;
 pub(super) use user_directory::*;
 pub(super) use voip::*;

src/api/client/mutual_rooms.rs

@@ -1,36 +0,0 @@
-use axum::extract::State;
-use conduwuit::{Err, Result};
-use futures::StreamExt;
-use ruma::api::client::membership::mutual_rooms;
-
-use crate::Ruma;
-
-/// # `GET /_matrix/client/unstable/uk.half-shot.msc2666/user/mutual_rooms`
-///
-/// Gets all the rooms the sender shares with the specified user.
-///
-/// An implementation of [MSC2666](https://github.com/matrix-org/matrix-spec-proposals/pull/2666)
-#[tracing::instrument(skip_all, name = "mutual_rooms", level = "info")]
-pub(crate) async fn get_mutual_rooms_route(
-	State(services): State<crate::State>,
-	body: Ruma<mutual_rooms::unstable::Request>,
-) -> Result<mutual_rooms::unstable::Response> {
-	let sender_user = body.sender_user();
-
-	if sender_user == body.user_id {
-		return Err!(Request(Unknown("You cannot request rooms in common with yourself.")));
-	}
-
-	if !services.users.exists(&body.user_id).await {
-		return Ok(mutual_rooms::unstable::Response::new(vec![]));
-	}
-
-	let mutual_rooms = services
-		.rooms
-		.state_cache
-		.get_shared_rooms(sender_user, &body.user_id)
-		.collect()
-		.await;
-
-	Ok(mutual_rooms::unstable::Response::new(mutual_rooms))
-}

src/api/client/openid.rs

@@ -29,10 +29,10 @@ pub(crate) async fn create_openid_token_route(
 		.users
 		.create_openid_token(&body.user_id, &access_token)?;
 
-	Ok(account::request_openid_token::v3::Response::new(
+	Ok(account::request_openid_token::v3::Response {
 		access_token,
-		TokenType::Bearer,
-		services.server.name.clone(),
-		Duration::from_secs(expires_in),
-	))
+		token_type: TokenType::Bearer,
+		matrix_server_name: services.server.name.clone(),
+		expires_in: Duration::from_secs(expires_in),
+	})
 }

src/api/client/presence.rs

@@ -2,10 +2,7 @@
 
 use axum::extract::State;
 use conduwuit::{Err, Result};
-use ruma::{
-	api::client::presence::{get_presence, set_presence},
-	assign,
-};
+use ruma::api::client::presence::{get_presence, set_presence};
 
 use crate::Ruma;
 
@@ -29,7 +26,7 @@ pub(crate) async fn set_presence_route(
 		.set_presence(body.sender_user(), &body.presence, None, None, body.status_msg.clone())
 		.await?;
 
-	Ok(set_presence::v3::Response::new())
+	Ok(set_presence::v3::Response {})
 }
 
 /// # `GET /_matrix/client/r0/presence/{userId}/status`
@@ -79,11 +76,13 @@ pub(crate) async fn get_presence_route(
 					.map(|millis| Duration::from_millis(millis.into())),
 			};
 
-			Ok(assign!(get_presence::v3::Response::new(presence.content.presence), {
+			Ok(get_presence::v3::Response {
+				// TODO: Should ruma just use the presenceeventcontent type here?
 				status_msg,
 				currently_active: presence.content.currently_active,
 				last_active_ago,
-			}))
+				presence: presence.content.presence,
+			})
 		},
 		| _ => Err!(Request(NotFound("Presence state for this user was not found"))),
 	}

src/api/client/profile.rs

@@ -1,26 +1,227 @@
-use std::collections::BTreeMap;
-
 use axum::extract::State;
-use conduwuit::{Err, Result, matrix::pdu::PartialPdu};
+use conduwuit::{
+	Err, Result,
+	matrix::pdu::PartialPdu,
+	utils::{IterStream, future::TryExtExt, stream::TryIgnore},
+	warn,
+};
 use conduwuit_service::Services;
-use futures::StreamExt;
+use futures::{
+	StreamExt, TryStreamExt,
+	future::{join, join3, join4},
+};
 use ruma::{
-	UserId,
+	OwnedMxcUri, OwnedRoomId, UserId,
 	api::{
 		client::profile::{
-			delete_profile_field, get_profile, get_profile_field, set_profile_field,
+			get_avatar_url, get_display_name, get_profile, set_avatar_url, set_display_name,
 		},
 		federation,
 	},
-	assign,
 	events::room::member::{MembershipState, RoomMemberEventContent},
 	presence::PresenceState,
-	profile::{ProfileFieldName, ProfileFieldValue},
 };
-use serde_json::{Value, to_value};
 
 use crate::Ruma;
 
+/// # `PUT /_matrix/client/r0/profile/{userId}/displayname`
+///
+/// Updates the displayname.
+///
+/// - Also makes sure other users receive the update using presence EDUs
+pub(crate) async fn set_displayname_route(
+	State(services): State<crate::State>,
+	body: Ruma<set_display_name::v3::Request>,
+) -> Result<set_display_name::v3::Response> {
+	let sender_user = body.sender_user();
+	if services.users.is_suspended(sender_user).await? {
+		return Err!(Request(UserSuspended("You cannot perform this action while suspended.")));
+	}
+
+	if *sender_user != body.user_id && body.appservice_info.is_none() {
+		return Err!(Request(Forbidden("You cannot update the profile of another user")));
+	}
+
+	let all_joined_rooms: Vec<OwnedRoomId> = services
+		.rooms
+		.state_cache
+		.rooms_joined(&body.user_id)
+		.map(ToOwned::to_owned)
+		.collect()
+		.await;
+
+	update_displayname(&services, &body.user_id, body.displayname.clone(), &all_joined_rooms)
+		.await;
+
+	if services.config.allow_local_presence {
+		// Presence update
+		services
+			.presence
+			.ping_presence(&body.user_id, &PresenceState::Online)
+			.await?;
+	}
+
+	Ok(set_display_name::v3::Response {})
+}
+
+/// # `GET /_matrix/client/v3/profile/{userId}/displayname`
+///
+/// Returns the displayname of the user.
+///
+/// - If user is on another server and we do not have a local copy already fetch
+///   displayname over federation
+pub(crate) async fn get_displayname_route(
+	State(services): State<crate::State>,
+	body: Ruma<get_display_name::v3::Request>,
+) -> Result<get_display_name::v3::Response> {
+	if !services.globals.user_is_local(&body.user_id) {
+		// Create and update our local copy of the user
+		if let Ok(response) = services
+			.sending
+			.send_federation_request(
+				body.user_id.server_name(),
+				federation::query::get_profile_information::v1::Request {
+					user_id: body.user_id.clone(),
+					field: None, // we want the full user's profile to update locally too
+				},
+			)
+			.await
+		{
+			if !services.users.exists(&body.user_id).await {
+				services.users.create(&body.user_id, None, None).await?;
+			}
+
+			services
+				.users
+				.set_displayname(&body.user_id, response.displayname.clone());
+			services
+				.users
+				.set_avatar_url(&body.user_id, response.avatar_url.clone());
+			services
+				.users
+				.set_blurhash(&body.user_id, response.blurhash.clone());
+
+			return Ok(get_display_name::v3::Response { displayname: response.displayname });
+		}
+	}
+
+	if !services.users.exists(&body.user_id).await {
+		// Return 404 if this user doesn't exist and we couldn't fetch it over
+		// federation
+		return Err!(Request(NotFound("Profile was not found.")));
+	}
+
+	Ok(get_display_name::v3::Response {
+		displayname: services.users.displayname(&body.user_id).await.ok(),
+	})
+}
+
+/// # `PUT /_matrix/client/v3/profile/{userId}/avatar_url`
+///
+/// Updates the `avatar_url` and `blurhash`.
+///
+/// - Also makes sure other users receive the update using presence EDUs
+pub(crate) async fn set_avatar_url_route(
+	State(services): State<crate::State>,
+	body: Ruma<set_avatar_url::v3::Request>,
+) -> Result<set_avatar_url::v3::Response> {
+	let sender_user = body.sender_user();
+	if services.users.is_suspended(sender_user).await? {
+		return Err!(Request(UserSuspended("You cannot perform this action while suspended.")));
+	}
+
+	if *sender_user != body.user_id && body.appservice_info.is_none() {
+		return Err!(Request(Forbidden("You cannot update the profile of another user")));
+	}
+
+	let all_joined_rooms: Vec<OwnedRoomId> = services
+		.rooms
+		.state_cache
+		.rooms_joined(&body.user_id)
+		.map(ToOwned::to_owned)
+		.collect()
+		.await;
+
+	update_avatar_url(
+		&services,
+		&body.user_id,
+		body.avatar_url.clone(),
+		body.blurhash.clone(),
+		&all_joined_rooms,
+	)
+	.await;
+
+	if services.config.allow_local_presence {
+		// Presence update
+		services
+			.presence
+			.ping_presence(&body.user_id, &PresenceState::Online)
+			.await
+			.ok();
+	}
+
+	Ok(set_avatar_url::v3::Response {})
+}
+
+/// # `GET /_matrix/client/v3/profile/{userId}/avatar_url`
+///
+/// Returns the `avatar_url` and `blurhash` of the user.
+///
+/// - If user is on another server and we do not have a local copy already fetch
+///   `avatar_url` and blurhash over federation
+pub(crate) async fn get_avatar_url_route(
+	State(services): State<crate::State>,
+	body: Ruma<get_avatar_url::v3::Request>,
+) -> Result<get_avatar_url::v3::Response> {
+	if !services.globals.user_is_local(&body.user_id) {
+		// Create and update our local copy of the user
+		if let Ok(response) = services
+			.sending
+			.send_federation_request(
+				body.user_id.server_name(),
+				federation::query::get_profile_information::v1::Request {
+					user_id: body.user_id.clone(),
+					field: None, // we want the full user's profile to update locally as well
+				},
+			)
+			.await
+		{
+			if !services.users.exists(&body.user_id).await {
+				services.users.create(&body.user_id, None, None).await?;
+			}
+
+			services
+				.users
+				.set_displayname(&body.user_id, response.displayname.clone());
+			services
+				.users
+				.set_avatar_url(&body.user_id, response.avatar_url.clone());
+			services
+				.users
+				.set_blurhash(&body.user_id, response.blurhash.clone());
+
+			return Ok(get_avatar_url::v3::Response {
+				avatar_url: response.avatar_url,
+				blurhash: response.blurhash,
+			});
+		}
+	}
+
+	if !services.users.exists(&body.user_id).await {
+		// Return 404 if this user doesn't exist and we couldn't fetch it over
+		// federation
+		return Err!(Request(NotFound("Profile was not found.")));
+	}
+
+	let (avatar_url, blurhash) = join(
+		services.users.avatar_url(&body.user_id).ok(),
+		services.users.blurhash(&body.user_id).ok(),
+	)
+	.await;
+
+	Ok(get_avatar_url::v3::Response { avatar_url, blurhash })
+}
+
 /// # `GET /_matrix/client/v3/profile/{userId}`
 ///
 /// Returns the displayname, avatar_url, blurhash, and custom profile fields of
@@ -32,296 +233,184 @@ pub(crate) async fn get_profile_route(
 	State(services): State<crate::State>,
 	body: Ruma<get_profile::v3::Request>,
 ) -> Result<get_profile::v3::Response> {
-	let Some(profile) = fetch_full_profile(&services, &body.user_id).await else {
-		return Err!(Request(NotFound("This user's profile could not be fetched.")));
-	};
-
-	Ok(get_profile::v3::Response::from_iter(profile))
-}
-
-pub(crate) async fn get_profile_field_route(
-	State(services): State<crate::State>,
-	body: Ruma<get_profile_field::v3::Request>,
-) -> Result<get_profile_field::v3::Response> {
-	let value = fetch_profile_field(&services, &body.user_id, body.field.clone()).await?;
-
-	Ok(assign!(get_profile_field::v3::Response::default(), { value }))
-}
-
-pub(crate) async fn set_profile_field_route(
-	State(services): State<crate::State>,
-	body: Ruma<set_profile_field::v3::Request>,
-) -> Result<set_profile_field::v3::Response> {
-	if body.user_id != body.sender_user()
-		&& !(body.appservice_info.is_some()
-			|| services.admin.user_is_admin(body.sender_user()).await)
-	{
-		return Err!(Request(Forbidden("You may not change other users' profile data.")));
-	}
-
 	if !services.globals.user_is_local(&body.user_id) {
-		return Err!(Request(InvalidParam("You may not change a remote user's profile data.")));
-	}
-
-	set_profile_field(&services, &body.user_id, ProfileFieldChange::Set(body.value.clone()))
-		.await;
-
-	Ok(set_profile_field::v3::Response::new())
-}
-
-pub(crate) async fn delete_profile_field_route(
-	State(services): State<crate::State>,
-	body: Ruma<delete_profile_field::v3::Request>,
-) -> Result<delete_profile_field::v3::Response> {
-	if body.user_id != body.sender_user()
-		&& !(body.appservice_info.is_some()
-			|| services.admin.user_is_admin(body.sender_user()).await)
-	{
-		return Err!(Request(Forbidden("You may not change other users' profile data.")));
-	}
-
-	if !services.globals.user_is_local(&body.user_id) {
-		return Err!(Request(InvalidParam("You may not change a remote user's profile data.")));
-	}
-
-	set_profile_field(&services, &body.user_id, ProfileFieldChange::Delete(body.field.clone()))
-		.await;
-
-	Ok(delete_profile_field::v3::Response::new())
-}
-
-async fn fetch_full_profile(
-	services: &Services,
-	user_id: &UserId,
-) -> Option<BTreeMap<String, Value>> {
-	// If the user exists locally, fetch their local profile
-	if services.users.exists(user_id).await {
-		return Some(get_local_profile(services, user_id).await);
-	}
-
-	// Otherwise ask their homeserver
-	let Ok(response) = services
-		.sending
-		.send_federation_request(
-			user_id.server_name(),
-			federation::query::get_profile_information::v1::Request::new(user_id.to_owned()),
-		)
-		.await
-	else {
-		return None;
-	};
-
-	// Update our local copies of their profile fields
-	services.users.clear_profile(user_id).await;
-
-	for (field, value) in response.iter() {
-		let Ok(value) = ProfileFieldValue::new(field, value.to_owned()) else {
-			// Skip malformed fields
-			continue;
-		};
-
-		set_profile_field(services, user_id, ProfileFieldChange::Set(value)).await;
-	}
-
-	Some(BTreeMap::from_iter(response))
-}
-
-async fn fetch_profile_field(
-	services: &Services,
-	user_id: &UserId,
-	field: ProfileFieldName,
-) -> Result<Option<ProfileFieldValue>> {
-	// If the user exists locally, fetch their local profile field
-	if services.globals.user_is_local(user_id) {
-		return Ok(get_local_profile_field(services, user_id, field).await);
-	}
-
-	// Otherwise ask their homeserver
-	let Ok(response) = services
-		.sending
-		.send_federation_request(
-			user_id.server_name(),
-			assign!(federation::query::get_profile_information::v1::Request::new(user_id.to_owned()), {
-				field: Some(field.clone())
-			}),
-		)
-		.await
-	else {
-		return Err!(Request(NotFound(
-			"User's homeserver could not provide this profile field."
-		)));
-	};
-
-	if let Some(value) = response.get(field.as_str()).map(ToOwned::to_owned) {
-		if let Ok(value) = ProfileFieldValue::new(field.as_str(), value) {
-			set_profile_field(services, user_id, ProfileFieldChange::Set(value.clone())).await;
-
-			Ok(Some(value))
-		} else {
-			Err!(Request(Unknown(
-				"User's homeserver returned malformed data for this profile field."
-			)))
-		}
-	} else {
-		set_profile_field(services, user_id, ProfileFieldChange::Delete(field)).await;
-
-		Ok(None)
-	}
-}
-
-pub(crate) async fn get_local_profile(
-	services: &Services,
-	user_id: &UserId,
-) -> BTreeMap<String, Value> {
-	let mut profile = BTreeMap::new();
-
-	// Get displayname and avatar_url independently because `all_profile_keys`
-	// doesn't include them
-	for field in [ProfileFieldName::AvatarUrl, ProfileFieldName::DisplayName] {
-		let key = field.as_str().to_owned();
-
-		if let Some(value) = get_local_profile_field(services, user_id, field).await {
-			profile.insert(key, value.value().into_owned());
-		}
-	}
-
-	// Insert all other profile fields
-	let mut all_fields = services.users.all_profile_keys(user_id);
-
-	while let Some((key, value)) = all_fields.next().await {
-		profile.insert(key, value);
-	}
-
-	profile
-}
-
-pub(crate) async fn get_local_profile_field(
-	services: &Services,
-	user_id: &UserId,
-	field: ProfileFieldName,
-) -> Option<ProfileFieldValue> {
-	let value = match field.clone() {
-		| ProfileFieldName::AvatarUrl => services
-			.users
-			.avatar_url(user_id)
+		// Create and update our local copy of the user
+		if let Ok(response) = services
+			.sending
+			.send_federation_request(
+				body.user_id.server_name(),
+				federation::query::get_profile_information::v1::Request {
+					user_id: body.user_id.clone(),
+					field: None,
+				},
+			)
 			.await
-			.ok()
-			.map(to_value)
-			.transpose()
-			.expect("converting avatar url to value should succeed"),
-		| ProfileFieldName::DisplayName => services
-			.users
-			.displayname(user_id)
-			.await
-			.ok()
-			.map(to_value)
-			.transpose()
-			.expect("converting displayname to value should succeed"),
-		| other => services
-			.users
-			.profile_key(user_id, other.as_str())
-			.await
-			.ok(),
-	}?;
+		{
+			if !services.users.exists(&body.user_id).await {
+				services.users.create(&body.user_id, None, None).await?;
+			}
 
-	Some(
-		ProfileFieldValue::new(field.as_str(), value)
-			.expect("local profile field should be valid"),
-	)
-}
-
-enum ProfileFieldChange {
-	Set(ProfileFieldValue),
-	Delete(ProfileFieldName),
-}
-
-impl ProfileFieldChange {
-	fn field_name(&self) -> ProfileFieldName {
-		match self {
-			| &Self::Delete(ref name) => name.clone(),
-			| &Self::Set(ref value) => value.field_name(),
-		}
-	}
-
-	fn value(&self) -> Option<Value> {
-		if let Self::Set(value) = self {
-			Some(value.value().into_owned())
-		} else {
-			None
-		}
-	}
-}
-
-async fn set_profile_field(services: &Services, user_id: &UserId, change: ProfileFieldChange) {
-	let field_name = change.field_name();
-
-	match change {
-		| ProfileFieldChange::Set(ProfileFieldValue::DisplayName(displayname)) => {
 			services
 				.users
-				.set_displayname(user_id, Some(displayname).filter(|dn| !dn.is_empty()));
-		},
-		| ProfileFieldChange::Set(ProfileFieldValue::AvatarUrl(avatar_url)) => {
+				.set_displayname(&body.user_id, response.displayname.clone());
 			services
 				.users
-				.set_avatar_url(user_id, Some(avatar_url).filter(|av| av.is_valid()));
-		},
-		| ProfileFieldChange::Delete(ProfileFieldName::DisplayName) => {
-			services.users.set_displayname(user_id, None);
-		},
-		| ProfileFieldChange::Delete(ProfileFieldName::AvatarUrl) => {
-			services.users.set_avatar_url(user_id, None);
-		},
-		| other =>
-			if other.field_name().as_str() == "blurhash" {
-				if let Some(Value::String(blurhash)) = other.value() {
-					services.users.set_blurhash(user_id, Some(blurhash));
-				} else {
-					services.users.set_blurhash(user_id, None);
-				}
-			} else {
+				.set_avatar_url(&body.user_id, response.avatar_url.clone());
+			services
+				.users
+				.set_blurhash(&body.user_id, response.blurhash.clone());
+
+			for (profile_key, profile_key_value) in &response.custom_profile_fields {
 				services.users.set_profile_key(
-					user_id,
-					other.field_name().as_str(),
-					other.value(),
+					&body.user_id,
+					profile_key,
+					Some(profile_key_value.clone()),
 				);
-			},
+			}
+
+			return Ok(get_profile::v3::Response {
+				displayname: response.displayname,
+				avatar_url: response.avatar_url,
+				blurhash: response.blurhash,
+				custom_profile_fields: response.custom_profile_fields,
+			});
+		}
 	}
 
-	// If the user is local and changed their displayname or avatar_url, update it
-	// in all their joined rooms
-	if matches!(field_name, ProfileFieldName::AvatarUrl | ProfileFieldName::DisplayName)
-		&& services.users.is_active_local(user_id).await
-	{
-		let displayname = services.users.displayname(user_id).await.ok();
-		let avatar_url = services.users.avatar_url(user_id).await.ok();
-		let membership_content = assign!(
-			RoomMemberEventContent::new(MembershipState::Join), { displayname, avatar_url }
-		);
+	if !services.users.exists(&body.user_id).await {
+		// Return 404 if this user doesn't exist and we couldn't fetch it over
+		// federation
+		return Err!(Request(NotFound("Profile was not found.")));
+	}
 
-		let mut all_joined_rooms = services.rooms.state_cache.rooms_joined(user_id);
+	let (avatar_url, blurhash, displayname, custom_profile_fields) = join4(
+		services.users.avatar_url(&body.user_id).ok(),
+		services.users.blurhash(&body.user_id).ok(),
+		services.users.displayname(&body.user_id).ok(),
+		services.users.all_profile_keys(&body.user_id).collect(),
+	)
+	.await;
 
-		while let Some(room_id) = all_joined_rooms.next().await {
-			let state_lock = services.rooms.state.mutex.lock(room_id.as_str()).await;
+	Ok(get_profile::v3::Response {
+		avatar_url,
+		blurhash,
+		displayname,
+		custom_profile_fields,
+	})
+}
 
-			let _ = services
-				.rooms
-				.timeline
-				.build_and_append_pdu(
-					PartialPdu::state(user_id.to_string(), &membership_content),
-					user_id,
-					Some(&room_id),
-					&state_lock,
-				)
-				.await;
-		}
+pub async fn update_displayname(
+	services: &Services,
+	user_id: &UserId,
+	displayname: Option<String>,
+	all_joined_rooms: &[OwnedRoomId],
+) {
+	let (current_avatar_url, current_blurhash, current_displayname) = join3(
+		services.users.avatar_url(user_id).ok(),
+		services.users.blurhash(user_id).ok(),
+		services.users.displayname(user_id).ok(),
+	)
+	.await;
 
-		if services.config.allow_local_presence {
-			// Send a presence EDU to indicate the profile changed
-			let _ = services
-				.presence
-				.ping_presence(user_id, &PresenceState::Online)
-				.await;
+	if displayname == current_displayname {
+		return;
+	}
+
+	services.users.set_displayname(user_id, displayname.clone());
+
+	// Send a new join membership event into all joined rooms
+	let avatar_url = &current_avatar_url;
+	let blurhash = &current_blurhash;
+	let displayname = &displayname;
+	let all_joined_rooms: Vec<_> = all_joined_rooms
+		.iter()
+		.try_stream()
+		.and_then(|room_id: &OwnedRoomId| async move {
+			let pdu = PartialPdu::state(user_id.to_string(), &RoomMemberEventContent {
+				displayname: displayname.clone(),
+				membership: MembershipState::Join,
+				avatar_url: avatar_url.clone(),
+				blurhash: blurhash.clone(),
+				join_authorized_via_users_server: None,
+				reason: None,
+				is_direct: None,
+				third_party_invite: None,
+				redact_events: None,
+			});
+
+			Ok((pdu, room_id))
+		})
+		.ignore_err()
+		.collect()
+		.await;
+
+	update_all_rooms(services, all_joined_rooms, user_id).await;
+}
+
+pub async fn update_avatar_url(
+	services: &Services,
+	user_id: &UserId,
+	avatar_url: Option<OwnedMxcUri>,
+	blurhash: Option<String>,
+	all_joined_rooms: &[OwnedRoomId],
+) {
+	let (current_avatar_url, current_blurhash, current_displayname) = join3(
+		services.users.avatar_url(user_id).ok(),
+		services.users.blurhash(user_id).ok(),
+		services.users.displayname(user_id).ok(),
+	)
+	.await;
+
+	if current_avatar_url == avatar_url && current_blurhash == blurhash {
+		return;
+	}
+
+	services.users.set_avatar_url(user_id, avatar_url.clone());
+	services.users.set_blurhash(user_id, blurhash.clone());
+
+	// Send a new join membership event into all joined rooms
+	let avatar_url = &avatar_url;
+	let blurhash = &blurhash;
+	let displayname = &current_displayname;
+	let all_joined_rooms: Vec<_> = all_joined_rooms
+		.iter()
+		.try_stream()
+		.and_then(|room_id: &OwnedRoomId| async move {
+			let pdu = PartialPdu::state(user_id.to_string(), &RoomMemberEventContent {
+				avatar_url: avatar_url.clone(),
+				blurhash: blurhash.clone(),
+				membership: MembershipState::Join,
+				displayname: displayname.clone(),
+				join_authorized_via_users_server: None,
+				reason: None,
+				is_direct: None,
+				third_party_invite: None,
+				redact_events: None,
+			});
+
+			Ok((pdu, room_id))
+		})
+		.ignore_err()
+		.collect()
+		.await;
+
+	update_all_rooms(services, all_joined_rooms, user_id).await;
+}
+
+pub async fn update_all_rooms(
+	services: &Services,
+	all_joined_rooms: Vec<(PartialPdu, &OwnedRoomId)>,
+	user_id: &UserId,
+) {
+	for (partial_pdu, room_id) in all_joined_rooms {
+		let state_lock = services.rooms.state.mutex.lock(room_id).await;
+		if let Err(e) = services
+			.rooms
+			.timeline
+			.build_and_append_pdu(partial_pdu, user_id, Some(room_id), &state_lock)
+			.await
+		{
+			warn!(%user_id, %room_id, "Failed to update/send new profile join membership update in room: {e}");
 		}
 	}
 }

src/api/client/push.rs

@@ -3,13 +3,13 @@
 use conduwuit_service::Services;
 use ruma::{
 	CanonicalJsonObject, CanonicalJsonValue,
-	api::{
-		client::push::{
+	api::client::{
+		error::ErrorKind,
+		push::{
 			delete_pushrule, get_pushers, get_pushrule, get_pushrule_actions,
 			get_pushrule_enabled, get_pushrules_all, get_pushrules_global_scope, set_pusher,
 			set_pushrule, set_pushrule_actions, set_pushrule_enabled,
 		},
-		error::ErrorKind,
 	},
 	events::{
 		GlobalAccountDataEventType,
@@ -80,7 +80,9 @@ pub(crate) async fn get_pushrules_all_route(
 			global_ruleset.update_with_server_default(Ruleset::server_default(sender_user));
 
 			let ty = GlobalAccountDataEventType::PushRules;
-			let event = PushRulesEvent::new(PushRulesEventContent::new(global_ruleset.clone()));
+			let event = PushRulesEvent {
+				content: PushRulesEventContent { global: global_ruleset.clone() },
+			};
 
 			services
 				.account_data
@@ -89,7 +91,7 @@ pub(crate) async fn get_pushrules_all_route(
 		}
 	};
 
-	Ok(get_pushrules_all::v3::Response::new(global_ruleset))
+	Ok(get_pushrules_all::v3::Response { global: global_ruleset })
 }
 
 /// # `GET /_matrix/client/r0/pushrules/global/`
@@ -114,20 +116,21 @@ pub(crate) async fn get_pushrules_global_route(
 		// user somehow has non-existent push rule event. recreate it and return server
 		// default silently
 
-		let global_ruleset = Ruleset::server_default(sender_user);
-		let event = PushRulesEvent::new(PushRulesEventContent::new(global_ruleset.clone()));
+		let ty = GlobalAccountDataEventType::PushRules;
+		let event = PushRulesEvent {
+			content: PushRulesEventContent {
+				global: Ruleset::server_default(sender_user),
+			},
+		};
 
 		services
 			.account_data
-			.update(
-				None,
-				sender_user,
-				GlobalAccountDataEventType::PushRules.to_string().into(),
-				&serde_json::to_value(event)?,
-			)
+			.update(None, sender_user, ty.to_string().into(), &serde_json::to_value(event)?)
 			.await?;
 
-		return Ok(get_pushrules_global_scope::v3::Response::new(global_ruleset));
+		return Ok(get_pushrules_global_scope::v3::Response {
+			global: Ruleset::server_default(sender_user),
+		});
 	};
 
 	let account_data_content =
@@ -170,16 +173,16 @@ pub(crate) async fn get_pushrules_global_route(
 					None,
 					sender_user,
 					GlobalAccountDataEventType::PushRules.to_string().into(),
-					&serde_json::to_value(PushRulesEvent::new(PushRulesEventContent::new(
-						global_ruleset.clone(),
-					)))
+					&serde_json::to_value(PushRulesEvent {
+						content: PushRulesEventContent { global: global_ruleset.clone() },
+					})
 					.expect("to json always works"),
 				)
 				.await?;
 		}
 	};
 
-	Ok(get_pushrules_global_scope::v3::Response::new(global_ruleset))
+	Ok(get_pushrules_global_scope::v3::Response { global: global_ruleset })
 }
 
 /// # `GET /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}`
@@ -213,7 +216,7 @@ pub(crate) async fn get_pushrule_route(
 		.map(Into::into);
 
 	if let Some(rule) = rule {
-		Ok(get_pushrule::v3::Response::new(rule))
+		Ok(get_pushrule::v3::Response { rule })
 	} else {
 		Err!(Request(NotFound("Push rule not found.")))
 	}
@@ -272,7 +275,7 @@ pub(crate) async fn set_pushrule_route(
 		.update(None, sender_user, ty.to_string().into(), &serde_json::to_value(account_data)?)
 		.await?;
 
-	Ok(set_pushrule::v3::Response::new())
+	Ok(set_pushrule::v3::Response {})
 }
 
 /// # `GET /_matrix/client/r0/pushrules/global/{kind}/{ruleId}/actions`
@@ -306,7 +309,7 @@ pub(crate) async fn get_pushrule_actions_route(
 		.map(|rule| rule.actions().to_owned())
 		.ok_or_else(|| err!(Request(NotFound("Push rule not found."))))?;
 
-	Ok(get_pushrule_actions::v3::Response::new(actions))
+	Ok(get_pushrule_actions::v3::Response { actions })
 }
 
 /// # `PUT /_matrix/client/r0/pushrules/global/{kind}/{ruleId}/actions`
@@ -339,7 +342,7 @@ pub(crate) async fn set_pushrule_actions_route(
 		.update(None, sender_user, ty.to_string().into(), &serde_json::to_value(account_data)?)
 		.await?;
 
-	Ok(set_pushrule_actions::v3::Response::new())
+	Ok(set_pushrule_actions::v3::Response {})
 }
 
 /// # `GET /_matrix/client/r0/pushrules/global/{kind}/{ruleId}/enabled`
@@ -357,7 +360,7 @@ pub(crate) async fn get_pushrule_enabled_route(
 		|| body.rule_id.as_str() == PredefinedOverrideRuleId::ContainsDisplayName.as_str()
 		|| body.rule_id.as_str() == PredefinedOverrideRuleId::RoomNotif.as_str()
 	{
-		return Ok(get_pushrule_enabled::v3::Response::new(false));
+		return Ok(get_pushrule_enabled::v3::Response { enabled: false });
 	}
 
 	let event: PushRulesEvent = services
@@ -373,7 +376,7 @@ pub(crate) async fn get_pushrule_enabled_route(
 		.map(ruma::push::AnyPushRuleRef::enabled)
 		.ok_or_else(|| err!(Request(NotFound("Push rule not found."))))?;
 
-	Ok(get_pushrule_enabled::v3::Response::new(enabled))
+	Ok(get_pushrule_enabled::v3::Response { enabled })
 }
 
 /// # `PUT /_matrix/client/r0/pushrules/global/{kind}/{ruleId}/enabled`
@@ -406,7 +409,7 @@ pub(crate) async fn set_pushrule_enabled_route(
 		.update(None, sender_user, ty.to_string().into(), &serde_json::to_value(account_data)?)
 		.await?;
 
-	Ok(set_pushrule_enabled::v3::Response::new())
+	Ok(set_pushrule_enabled::v3::Response {})
 }
 
 /// # `DELETE /_matrix/client/r0/pushrules/global/{kind}/{ruleId}`
@@ -448,7 +451,7 @@ pub(crate) async fn delete_pushrule_route(
 		.update(None, sender_user, ty.to_string().into(), &serde_json::to_value(account_data)?)
 		.await?;
 
-	Ok(delete_pushrule::v3::Response::new())
+	Ok(delete_pushrule::v3::Response {})
 }
 
 /// # `GET /_matrix/client/r0/pushers`
@@ -460,7 +463,9 @@ pub(crate) async fn get_pushers_route(
 ) -> Result<get_pushers::v3::Response> {
 	let sender_user = body.sender_user();
 
-	Ok(get_pushers::v3::Response::new(services.pusher.get_pushers(sender_user).await))
+	Ok(get_pushers::v3::Response {
+		pushers: services.pusher.get_pushers(sender_user).await,
+	})
 }
 
 /// # `POST /_matrix/client/r0/pushers/set`
@@ -488,18 +493,19 @@ pub async fn recreate_push_rules_and_return(
 	services: &Services,
 	sender_user: &ruma::UserId,
 ) -> Result<get_pushrules_all::v3::Response> {
-	let global_ruleset = Ruleset::server_default(sender_user);
-	let event = PushRulesEvent::new(PushRulesEventContent::new(global_ruleset.clone()));
+	let ty = GlobalAccountDataEventType::PushRules;
+	let event = PushRulesEvent {
+		content: PushRulesEventContent {
+			global: Ruleset::server_default(sender_user),
+		},
+	};
 
 	services
 		.account_data
-		.update(
-			None,
-			sender_user,
-			GlobalAccountDataEventType::PushRules.to_string().into(),
-			&serde_json::to_value(event)?,
-		)
+		.update(None, sender_user, ty.to_string().into(), &serde_json::to_value(event)?)
 		.await?;
 
-	Ok(get_pushrules_all::v3::Response::new(global_ruleset))
+	Ok(get_pushrules_all::v3::Response {
+		global: Ruleset::server_default(sender_user),
+	})
 }

src/api/client/read_marker.rs

@@ -8,8 +8,7 @@
 	api::client::{read_marker::set_read_marker, receipt::create_receipt},
 	events::{
 		RoomAccountDataEventType,
-		fully_read::{FullyReadEvent, FullyReadEventContent},
-		receipt::{Receipt, ReceiptEvent, ReceiptEventContent, ReceiptType},
+		receipt::{ReceiptThread, ReceiptType},
 	},
 };
 
@@ -29,7 +28,9 @@ pub(crate) async fn set_read_marker_route(
 	let sender_user = body.sender_user();
 
 	if let Some(event) = &body.fully_read {
-		let fully_read_event = FullyReadEvent::new(FullyReadEventContent::new(event.to_owned()));
+		let fully_read_event = ruma::events::fully_read::FullyReadEvent {
+			content: ruma::events::fully_read::FullyReadEventContent { event_id: event.clone() },
+		};
 
 		services
 			.account_data
@@ -61,16 +62,19 @@ pub(crate) async fn set_read_marker_route(
 		if services.config.allow_local_read_receipts
 			&& !services.users.is_suspended(sender_user).await?
 		{
-			let receipt_content = [(
+			let receipt_content = BTreeMap::from_iter([(
 				event.to_owned(),
 				BTreeMap::from_iter([(
 					ReceiptType::Read,
 					BTreeMap::from_iter([(
 						sender_user.to_owned(),
-						Receipt::new(MilliSecondsSinceUnixEpoch::now()),
+						ruma::events::receipt::Receipt {
+							ts: Some(MilliSecondsSinceUnixEpoch::now()),
+							thread: ReceiptThread::Unthreaded,
+						},
 					)]),
 				)]),
-			)];
+			)]);
 
 			services
 				.rooms
@@ -78,10 +82,10 @@ pub(crate) async fn set_read_marker_route(
 				.readreceipt_update(
 					sender_user,
 					&body.room_id,
-					&ReceiptEvent::new(
-						body.room_id.clone(),
-						ReceiptEventContent::from_iter(receipt_content),
-					),
+					&ruma::events::receipt::ReceiptEvent {
+						content: ruma::events::receipt::ReceiptEventContent(receipt_content),
+						room_id: body.room_id.clone(),
+					},
 				)
 				.await;
 		}
@@ -107,7 +111,7 @@ pub(crate) async fn set_read_marker_route(
 			.private_read_set(&body.room_id, sender_user, count);
 	}
 
-	Ok(set_read_marker::v3::Response::new())
+	Ok(set_read_marker::v3::Response {})
 }
 
 /// # `POST /_matrix/client/r0/rooms/{roomId}/receipt/{receiptType}/{eventId}`
@@ -144,8 +148,11 @@ pub(crate) async fn create_receipt_route(
 
 	match body.receipt_type {
 		| create_receipt::v3::ReceiptType::FullyRead => {
-			let fully_read_event =
-				FullyReadEvent::new(FullyReadEventContent::new(body.event_id.clone()));
+			let fully_read_event = ruma::events::fully_read::FullyReadEvent {
+				content: ruma::events::fully_read::FullyReadEventContent {
+					event_id: body.event_id.clone(),
+				},
+			};
 			services
 				.account_data
 				.update(
@@ -157,16 +164,19 @@ pub(crate) async fn create_receipt_route(
 				.await?;
 		},
 		| create_receipt::v3::ReceiptType::Read => {
-			let receipt_content = [(
+			let receipt_content = BTreeMap::from_iter([(
 				body.event_id.clone(),
 				BTreeMap::from_iter([(
 					ReceiptType::Read,
 					BTreeMap::from_iter([(
 						sender_user.to_owned(),
-						Receipt::new(MilliSecondsSinceUnixEpoch::now()),
+						ruma::events::receipt::Receipt {
+							ts: Some(MilliSecondsSinceUnixEpoch::now()),
+							thread: ReceiptThread::Unthreaded,
+						},
 					)]),
 				)]),
-			)];
+			)]);
 
 			services
 				.rooms
@@ -174,10 +184,10 @@ pub(crate) async fn create_receipt_route(
 				.readreceipt_update(
 					sender_user,
 					&body.room_id,
-					&ReceiptEvent::new(
-						body.room_id.clone(),
-						ReceiptEventContent::from_iter(receipt_content),
-					),
+					&ruma::events::receipt::ReceiptEvent {
+						content: ruma::events::receipt::ReceiptEventContent(receipt_content),
+						room_id: body.room_id.clone(),
+					},
 				)
 				.await;
 		},
@@ -208,5 +218,5 @@ pub(crate) async fn create_receipt_route(
 		},
 	}
 
-	Ok(create_receipt::v3::Response::new())
+	Ok(create_receipt::v3::Response {})
 }

src/api/client/redact.rs

@@ -2,7 +2,7 @@
 use axum_client_ip::InsecureClientIp;
 use conduwuit::{Err, Result, matrix::pdu::PartialPdu};
 use ruma::{
-	api::client::redact::redact_event, assign, events::room::redaction::RoomRedactionEventContent,
+	api::client::redact::redact_event, events::room::redaction::RoomRedactionEventContent,
 };
 
 use crate::Ruma;
@@ -28,7 +28,7 @@ pub(crate) async fn redact_event_route(
 		return Err!(Request(UserSuspended("You cannot perform this action while suspended.")));
 	}
 
-	let state_lock = services.rooms.state.mutex.lock(body.room_id.as_str()).await;
+	let state_lock = services.rooms.state.mutex.lock(&body.room_id).await;
 
 	let event_id = services
 		.rooms
@@ -36,11 +36,10 @@ pub(crate) async fn redact_event_route(
 		.build_and_append_pdu(
 			PartialPdu {
 				redacts: Some(body.event_id.clone()),
-				..PartialPdu::timeline(
-					&assign!(RoomRedactionEventContent::new_v11(body.event_id.clone()), {
-						reason: body.reason.clone()
-					}),
-				)
+				..PartialPdu::timeline(&RoomRedactionEventContent {
+					redacts: Some(body.event_id.clone()),
+					reason: body.reason.clone(),
+				})
 			},
 			sender_user,
 			Some(&body.room_id),
@@ -50,5 +49,5 @@ pub(crate) async fn redact_event_route(
 
 	drop(state_lock);
 
-	Ok(redact_event::v3::Response::new(event_id))
+	Ok(redact_event::v3::Response { event_id })
 }

src/api/client/relations.rs

@@ -15,7 +15,6 @@
 			get_relating_events_with_rel_type_and_event_type,
 		},
 	},
-	assign,
 	events::{TimelineEventType, relation::RelationType},
 };
 
@@ -40,12 +39,11 @@ pub(crate) async fn get_relating_events_with_rel_type_and_event_type_route(
 		body.dir,
 	)
 	.await
-	.map(|res| {
-		assign!(get_relating_events_with_rel_type_and_event_type::v1::Response::new(res.chunk), {
-			next_batch: res.next_batch,
-			prev_batch: res.prev_batch,
-			recursion_depth: res.recursion_depth,
-		})
+	.map(|res| get_relating_events_with_rel_type_and_event_type::v1::Response {
+		chunk: res.chunk,
+		next_batch: res.next_batch,
+		prev_batch: res.prev_batch,
+		recursion_depth: res.recursion_depth,
 	})
 }
 
@@ -68,12 +66,11 @@ pub(crate) async fn get_relating_events_with_rel_type_route(
 		body.dir,
 	)
 	.await
-	.map(|res| {
-		assign!(get_relating_events_with_rel_type::v1::Response::new(res.chunk), {
-			next_batch: res.next_batch,
-			prev_batch: res.prev_batch,
-			recursion_depth: res.recursion_depth,
-		})
+	.map(|res| get_relating_events_with_rel_type::v1::Response {
+		chunk: res.chunk,
+		next_batch: res.next_batch,
+		prev_batch: res.prev_batch,
+		recursion_depth: res.recursion_depth,
 	})
 }
 
@@ -204,11 +201,12 @@ async fn paginate_relations_with_filter(
 		.map(Event::into_format)
 		.collect();
 
-	Ok(assign!(get_relating_events::v1::Response::new(chunk), {
+	Ok(get_relating_events::v1::Response {
 		next_batch,
 		prev_batch: from.map(Into::into),
 		recursion_depth: recurse.then_some(depth.into()),
-	}))
+		chunk,
+	})
 }
 
 async fn visibility_filter<Pdu: Event + Send + Sync>(

src/api/client/report.rs

@@ -22,7 +22,7 @@ struct Report {
 	event_id: Option<OwnedEventId>,
 	user_id: Option<OwnedUserId>,
 	report_type: String,
-	reason: String,
+	reason: Option<String>,
 }
 
 /// # `POST /_matrix/client/v3/rooms/{roomId}/report`
@@ -39,7 +39,7 @@ pub(crate) async fn report_room_route(
 		return Err!(Request(UserSuspended("You cannot perform this action while suspended.")));
 	}
 
-	if body.reason.len() > 750 {
+	if body.reason.as_ref().is_some_and(|s| s.len() > 750) {
 		return Err!(Request(
 			InvalidParam("Reason too long, should be 750 characters or fewer",)
 		));
@@ -52,7 +52,8 @@ pub(crate) async fn report_room_route(
 	// their discretion.
 	info!(
 		"Received room report by user {sender_user} for room {} with reason: \"{}\"",
-		body.room_id, body.reason
+		body.room_id,
+		body.reason.as_deref().unwrap_or("")
 	);
 
 	if !services
@@ -77,7 +78,7 @@ pub(crate) async fn report_room_route(
 
 	services.admin.send_message(build_report(report)).await.ok();
 
-	Ok(report_room::v3::Response::new())
+	Ok(report_room::v3::Response {})
 }
 
 /// # `POST /_matrix/client/v3/rooms/{roomId}/report/{eventId}`
@@ -97,22 +98,26 @@ pub(crate) async fn report_event_route(
 
 	delay_response().await;
 
-	let reason = body
-		.reason
-		.clone()
-		.unwrap_or_else(|| "<no reason provided>".to_owned());
-
 	// check if we know about the reported event ID or if it's invalid
 	let Ok(pdu) = services.rooms.timeline.get_pdu(&body.event_id).await else {
 		return Err!(Request(NotFound("Event ID is not known to us or Event ID is invalid")));
 	};
 
-	is_event_report_valid(&services, &pdu.event_id, &body.room_id, sender_user, &reason, &pdu)
-		.await?;
+	is_event_report_valid(
+		&services,
+		&pdu.event_id,
+		&body.room_id,
+		sender_user,
+		body.reason.as_ref(),
+		&pdu,
+	)
+	.await?;
 	info!(
 		"Received event report by user {sender_user} for room {} and event ID {}, with reason: \
 		 \"{}\"",
-		body.room_id, body.event_id, reason
+		body.room_id,
+		body.event_id,
+		body.reason.as_deref().unwrap_or("")
 	);
 	let report = Report {
 		sender: sender_user.to_owned(),
@@ -120,11 +125,11 @@ pub(crate) async fn report_event_route(
 		event_id: Some(body.event_id.clone()),
 		user_id: None,
 		report_type: "event".to_owned(),
-		reason,
+		reason: body.reason.clone(),
 	};
 	services.admin.send_message(build_report(report)).await.ok();
 
-	Ok(report_content::v3::Response::new())
+	Ok(report_content::v3::Response {})
 }
 
 #[tracing::instrument(skip_all, fields(%client), name = "report_user", level = "info")]
@@ -139,7 +144,7 @@ pub(crate) async fn report_user_route(
 		return Err!(Request(UserSuspended("You cannot perform this action while suspended.")));
 	}
 
-	if body.reason.len() > 750 {
+	if body.reason.as_ref().is_some_and(|s| s.len() > 750) {
 		return Err!(Request(
 			InvalidParam("Reason too long, should be 750 characters or fewer",)
 		));
@@ -149,7 +154,7 @@ pub(crate) async fn report_user_route(
 
 	if !services.users.is_active_local(&body.user_id).await {
 		// return 200 as to not reveal if the user exists. Recommended by spec.
-		return Ok(report_user::v3::Response::new());
+		return Ok(report_user::v3::Response {});
 	}
 
 	let report = Report {
@@ -163,12 +168,13 @@ pub(crate) async fn report_user_route(
 
 	info!(
 		"Received room report from {sender_user} for user {} with reason: \"{}\"",
-		body.user_id, body.reason
+		body.user_id,
+		body.reason.as_deref().unwrap_or("")
 	);
 
 	services.admin.send_message(build_report(report)).await.ok();
 
-	Ok(report_user::v3::Response::new())
+	Ok(report_user::v3::Response {})
 }
 
 /// in the following order:
@@ -182,7 +188,7 @@ async fn is_event_report_valid(
 	event_id: &EventId,
 	room_id: &RoomId,
 	sender_user: &UserId,
-	reason: &str,
+	reason: Option<&String>,
 	pdu: &PduEvent,
 ) -> Result<()> {
 	debug_info!(
@@ -194,7 +200,7 @@ async fn is_event_report_valid(
 		return Err!(Request(NotFound("Event ID does not belong to the reported room",)));
 	}
 
-	if reason.len() > 750 {
+	if reason.as_ref().is_some_and(|s| s.len() > 750) {
 		return Err!(Request(
 			InvalidParam("Reason too long, should be 750 characters or fewer",)
 		));
@@ -226,7 +232,9 @@ fn build_report(report: Report) -> RoomMessageEventContent {
 	if report.event_id.is_some() {
 		let _ = writeln!(text, "- Reported Event ID: `{}`", report.event_id.unwrap());
 	}
-	let _ = writeln!(text, "- Report Reason: {}", report.reason);
+	if let Some(reason) = report.reason {
+		let _ = writeln!(text, "- Report Reason: {reason}");
+	}
 
 	RoomMessageEventContent::text_markdown(text).add_mentions(Mentions::with_room_mention())
 }

src/api/client/room/create.rs

@@ -9,10 +9,8 @@
 use conduwuit_service::{Services, appservice::RegistrationInfo};
 use futures::FutureExt;
 use ruma::{
-	CanonicalJsonObject, Int, MilliSecondsSinceUnixEpoch, OwnedRoomAliasId, OwnedRoomId,
-	OwnedUserId, RoomAliasId, RoomId, RoomVersionId, UserId,
+	CanonicalJsonObject, Int, OwnedRoomAliasId, OwnedRoomId, OwnedUserId, RoomId, RoomVersionId,
 	api::client::room::{self, create_room},
-	assign,
 	events::{
 		TimelineEventType,
 		room::{
@@ -28,7 +26,7 @@
 		},
 	},
 	int,
-	room_version_rules::{AuthorizationRules, RoomIdFormatVersion},
+	room_version_rules::RoomIdFormatVersion,
 	serde::{JsonObject, Raw},
 };
 use ruminuwuity::invite_permission_config::FilterLevel;
@@ -216,33 +214,18 @@ pub(crate) async fn create_room_route(
 				.short
 				.get_or_create_shortroomid(&room_id)
 				.await;
-			services.rooms.state.mutex.lock(room_id.as_str()).await
+			services.rooms.state.mutex.lock(&room_id).await
 		},
 		| None => {
-			let temp_room_id = RoomId::new_v1(services.globals.server_name());
+			let temp_room_id = RoomId::new(services.globals.server_name());
 			trace!("Locking temporary room state mutex for {temp_room_id}");
-			services.rooms.state.mutex.lock(temp_room_id.as_str()).await
+			services.rooms.state.mutex.lock(&temp_room_id).await
 		},
 	};
 
 	// 1. The room create event
 	debug!("Creating room create event for {sender_user} in room {room_id:?}");
 	let tmp_id = room_id.as_deref();
-
-	// Allow requesters to override the `origin_server_ts` to customize room ids
-	// from v12 onwards
-	let custom_origin_server_ts = body
-		.json_body
-		.as_ref()
-		.unwrap()
-		.as_object()
-		.unwrap()
-		.get("origin_server_ts")
-		.and_then(ruma::CanonicalJsonValue::as_integer)
-		.map(Into::into)
-		.and_then(|value: i64| value.try_into().ok())
-		.map(MilliSecondsSinceUnixEpoch);
-
 	let create_event_id = services
 		.rooms
 		.timeline
@@ -251,7 +234,7 @@ pub(crate) async fn create_room_route(
 				event_type: TimelineEventType::RoomCreate,
 				content: to_raw_value(&create_content)?,
 				state_key: Some(StateKey::new()),
-				timestamp: custom_origin_server_ts,
+				timestamp: body.origin_server_ts,
 				..Default::default()
 			},
 			sender_user,
@@ -266,7 +249,7 @@ pub(crate) async fn create_room_route(
 		| None => {
 			let as_room_id = create_event_id.as_str().replace('$', "!");
 			trace!("Creating room with v12 room ID {as_room_id}");
-			RoomId::parse(&as_room_id)?.clone()
+			RoomId::parse(&as_room_id)?.to_owned()
 		},
 	};
 	drop(state_lock);
@@ -312,10 +295,7 @@ pub(crate) async fn create_room_route(
 
 	let mut creators: Vec<OwnedUserId> = vec![sender_user.to_owned()];
 	// Do we care about additional_creators?
-	if room_version_rules
-		.authorization
-		.explicitly_privilege_room_creators
-	{
+	if room_version_rules.explicitly_privilege_room_creators {
 		// Have they been specified?
 		if let Some(additional_creators) = create_content.get("additional_creators") {
 			// Are they a real array?
@@ -325,9 +305,9 @@ pub(crate) async fn create_room_route(
 					// Are they a string?
 					if let Some(creator) = creator.as_str() {
 						// Do they parse into a real user ID?
-						if let Ok(creator) = UserId::parse(creator) {
+						if let Ok(creator) = OwnedUserId::parse(creator) {
 							// Add them to the power levels and creators
-							creators.push(creator);
+							creators.push(creator.clone());
 						}
 					}
 				}
@@ -340,13 +320,10 @@ pub(crate) async fn create_room_route(
 	}
 
 	let power_levels_content = default_power_levels_content(
-		body.power_level_content_override
-			.as_ref()
-			.map(Raw::cast_ref),
+		body.power_level_content_override.as_ref(),
 		&body.visibility,
 		power_levels_to_grant,
 		creators,
-		&room_version_rules.authorization,
 	)?;
 
 	services
@@ -372,13 +349,10 @@ pub(crate) async fn create_room_route(
 			.rooms
 			.timeline
 			.build_and_append_pdu(
-				PartialPdu::state(
-					String::new(),
-					&assign!(RoomCanonicalAliasEventContent::new(), {
-						alias: Some(room_alias_id.to_owned()),
-						alt_aliases: vec![],
-					}),
-				),
+				PartialPdu::state(String::new(), &RoomCanonicalAliasEventContent {
+					alias: Some(room_alias_id.to_owned()),
+					alt_aliases: vec![],
+				}),
 				sender_user,
 				Some(&room_id),
 				&state_lock,
@@ -446,11 +420,9 @@ pub(crate) async fn create_room_route(
 
 	// 6. Events listed in initial_state
 	for event in &body.initial_state {
-		let mut partial_pdu = event
-			.deserialize_as_unchecked::<PartialPdu>()
-			.map_err(|e| {
-				err!(Request(InvalidParam(warn!("Invalid initial state event: {e:?}"))))
-			})?;
+		let mut partial_pdu = event.deserialize_as::<PartialPdu>().map_err(|e| {
+			err!(Request(InvalidParam(warn!("Invalid initial state event: {e:?}"))))
+		})?;
 
 		debug_info!("Room creation initial state event: {event:?}");
 
@@ -501,7 +473,7 @@ pub(crate) async fn create_room_route(
 			.rooms
 			.timeline
 			.build_and_append_pdu(
-				PartialPdu::state(String::new(), &RoomTopicEventContent::new(topic.clone())),
+				PartialPdu::state(String::new(), &RoomTopicEventContent { topic: topic.clone() }),
 				sender_user,
 				Some(&room_id),
 				&state_lock,
@@ -556,13 +528,10 @@ fn default_power_levels_content(
 	visibility: &room::Visibility,
 	users: BTreeMap<OwnedUserId, Int>,
 	creators: Vec<OwnedUserId>,
-	authorization_rules: &AuthorizationRules,
 ) -> Result<serde_json::Value> {
 	let mut power_levels_content =
-		serde_json::to_value(assign!(RoomPowerLevelsEventContent::new(authorization_rules), {
-			users
-		}))
-		.unwrap();
+		serde_json::to_value(RoomPowerLevelsEventContent { users, ..Default::default() })
+			.expect("event is valid, we just created it");
 
 	// secure proper defaults of sensitive/dangerous permissions that moderators
 	// (power level 50) should not have easy access to
@@ -652,7 +621,7 @@ async fn room_alias_check(
 	}
 
 	let server_name = services.globals.server_name();
-	let full_room_alias = RoomAliasId::parse(format!("#{room_alias_name}:{server_name}"))
+	let full_room_alias = OwnedRoomAliasId::parse(format!("#{room_alias_name}:{server_name}"))
 		.map_err(|e| {
 			err!(Request(InvalidParam(debug_error!(
 				?e,