Rename crates.

Signed-off-by: Jason Volk <jason@zemos.net>

src/service/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "conduwuit_service"
+name = "tuwunel_service"
 categories.workspace = true
 description.workspace = true
 edition.workspace = true
@@ -22,7 +22,7 @@ blurhashing = [
 	"dep:blurhash",
 ]
 brotli_compression = [
-	"conduwuit-core/brotli_compression",
+	"tuwunel-core/brotli_compression",
 	"reqwest/brotli",
 ]
 console = [
@@ -31,34 +31,34 @@ console = [
 ]
 element_hacks = []
 gzip_compression = [
-	"conduwuit-core/gzip_compression",
+	"tuwunel-core/gzip_compression",
 	"reqwest/gzip",
 ]
 io_uring = [
-	"conduwuit-database/io_uring",
+	"tuwunel-database/io_uring",
 ]
 jemalloc = [
-	"conduwuit-core/jemalloc",
-	"conduwuit-database/jemalloc",
+	"tuwunel-core/jemalloc",
+	"tuwunel-database/jemalloc",
 ]
 jemalloc_conf = [
-	"conduwuit-core/jemalloc_conf",
-	"conduwuit-database/jemalloc_conf",
+	"tuwunel-core/jemalloc_conf",
+	"tuwunel-database/jemalloc_conf",
 ]
 jemalloc_prof = [
-	"conduwuit-core/jemalloc_prof",
-	"conduwuit-database/jemalloc_prof",
+	"tuwunel-core/jemalloc_prof",
+	"tuwunel-database/jemalloc_prof",
 ]
 jemalloc_stats = [
-	"conduwuit-core/jemalloc_stats",
-	"conduwuit-database/jemalloc_stats",
+	"tuwunel-core/jemalloc_stats",
+	"tuwunel-database/jemalloc_stats",
 ]
 media_thumbnail = [
 	"dep:image",
 ]
 release_max_log_level = [
-	"conduwuit-core/release_max_log_level",
-	"conduwuit-database/release_max_log_level",
+	"tuwunel-core/release_max_log_level",
+	"tuwunel-database/release_max_log_level",
 	"log/max_level_trace",
 	"log/release_max_level_info",
 	"tracing/max_level_trace",
@@ -69,8 +69,8 @@ url_preview = [
 	"dep:webpage",
 ]
 zstd_compression = [
-	"conduwuit-core/zstd_compression",
-	"conduwuit-database/zstd_compression",
+	"tuwunel-core/zstd_compression",
+	"tuwunel-database/zstd_compression",
     "reqwest/zstd",
 ]
 
@@ -78,8 +78,6 @@ zstd_compression = [
 async-trait.workspace = true
 base64.workspace = true
 bytes.workspace = true
-conduwuit-core.workspace = true
-conduwuit-database.workspace = true
 const-str.workspace = true
 either.workspace = true
 futures.workspace = true
@@ -111,6 +109,8 @@ webpage.workspace = true
 webpage.optional = true
 blurhash.workspace = true
 blurhash.optional = true
+tuwunel-core.workspace = true
+tuwunel-database.workspace = true
 
 [lints]
 workspace = true

src/service/account_data/mod.rs

@@ -1,10 +1,5 @@
 use std::sync::Arc;
 
-use conduwuit::{
-	Err, Result, err, implement,
-	utils::{ReadyExt, result::LogErr, stream::TryIgnore},
-};
-use database::{Deserialized, Handle, Ignore, Json, Map};
 use futures::{Stream, StreamExt, TryFutureExt};
 use ruma::{
 	RoomId, UserId,
@@ -15,6 +10,11 @@ use ruma::{
 	serde::Raw,
 };
 use serde::Deserialize;
+use tuwunel_core::{
+	Err, Result, err, implement,
+	utils::{ReadyExt, result::LogErr, stream::TryIgnore},
+};
+use tuwunel_database::{Deserialized, Handle, Ignore, Json, Map};
 
 use crate::{Dep, globals};
 

src/service/admin/console.rs

@@ -5,12 +5,12 @@ use std::{
 	sync::{Arc, Mutex},
 };
 
-use conduwuit::{Server, debug, defer, error, log, log::is_systemd_mode};
 use futures::future::{AbortHandle, Abortable};
 use ruma::events::room::message::RoomMessageEventContent;
 use rustyline_async::{Readline, ReadlineError, ReadlineEvent};
 use termimad::MadSkin;
 use tokio::task::JoinHandle;
+use tuwunel_core::{Server, debug, defer, error, log, log::is_systemd_mode};
 
 use crate::{Dep, admin};
 
@@ -96,7 +96,7 @@ impl Console {
 		debug!("session starting");
 
 		self.output
-			.print_inline(&format!("**conduwuit {}** admin console\n", conduwuit::version()));
+			.print_inline(&format!("**conduwuit {}** admin console\n", tuwunel_core::version()));
 		self.output
 			.print_text("\"help\" for help, ^D to exit the console, ^\\ to stop the server\n");
 

src/service/admin/create.rs

@@ -1,6 +1,5 @@
 use std::collections::BTreeMap;
 
-use conduwuit::{Result, pdu::PduBuilder};
 use futures::FutureExt;
 use ruma::{
 	RoomId, RoomVersionId,
@@ -17,6 +16,7 @@ use ruma::{
 		topic::RoomTopicEventContent,
 	},
 };
+use tuwunel_core::{Result, pdu::PduBuilder};
 
 use crate::Services;
 

src/service/admin/execute.rs

@@ -1,6 +1,6 @@
-use conduwuit::{Err, Result, debug, debug_info, error, implement, info};
 use ruma::events::room::message::RoomMessageEventContent;
 use tokio::time::{Duration, sleep};
+use tuwunel_core::{Err, Result, debug, debug_info, error, implement, info};
 
 pub(super) const SIGNAL: &str = "SIGUSR2";
 

src/service/admin/grant.rs

@@ -1,6 +1,5 @@
 use std::collections::BTreeMap;
 
-use conduwuit::{Err, Result, debug_info, debug_warn, error, implement, matrix::pdu::PduBuilder};
 use ruma::{
 	RoomId, UserId,
 	events::{
@@ -13,6 +12,9 @@ use ruma::{
 		tag::{TagEvent, TagEventContent, TagInfo},
 	},
 };
+use tuwunel_core::{
+	Err, Result, debug_info, debug_warn, error, implement, matrix::pdu::PduBuilder,
+};
 
 /// Invite the user to the conduwuit admin room.
 ///

src/service/admin/mod.rs

@@ -10,9 +10,6 @@ use std::{
 };
 
 use async_trait::async_trait;
-use conduwuit::{
-	Error, PduEvent, Result, Server, debug, err, error, error::default_log, pdu::PduBuilder,
-};
 pub use create::create_admin_room;
 use futures::{FutureExt, TryFutureExt};
 use loole::{Receiver, Sender};
@@ -21,6 +18,9 @@ use ruma::{
 	events::room::message::{Relation, RoomMessageEventContent},
 };
 use tokio::sync::RwLock;
+use tuwunel_core::{
+	Error, PduEvent, Result, Server, debug, err, error, error::default_log, pdu::PduBuilder,
+};
 
 use crate::{Dep, account_data, globals, rooms, rooms::state::RoomMutexGuard};
 

src/service/appservice/mod.rs

@@ -4,11 +4,11 @@ mod registration_info;
 use std::{collections::BTreeMap, iter::IntoIterator, sync::Arc};
 
 use async_trait::async_trait;
-use conduwuit::{Result, err, utils::stream::IterStream};
-use database::Map;
 use futures::{Future, FutureExt, Stream, TryStreamExt};
 use ruma::{RoomAliasId, RoomId, UserId, api::appservice::Registration};
 use tokio::sync::{RwLock, RwLockReadGuard};
+use tuwunel_core::{Result, err, utils::stream::IterStream};
+use tuwunel_database::Map;
 
 pub use self::{namespace_regex::NamespaceRegex, registration_info::RegistrationInfo};
 use crate::{Dep, sending};

src/service/appservice/namespace_regex.rs

@@ -1,6 +1,6 @@
-use conduwuit::Result;
 use regex::RegexSet;
 use ruma::api::appservice::Namespace;
+use tuwunel_core::Result;
 
 /// Compiled regular expressions for a namespace
 #[derive(Clone, Debug)]

src/service/appservice/registration_info.rs

@@ -1,5 +1,5 @@
-use conduwuit::Result;
 use ruma::{UserId, api::appservice::Registration};
+use tuwunel_core::Result;
 
 use super::NamespaceRegex;
 

src/service/client/mod.rs

@@ -1,9 +1,9 @@
 use std::{sync::Arc, time::Duration};
 
-use conduwuit::{Config, Result, err, implement, trace};
 use either::Either;
 use ipaddress::IPAddress;
 use reqwest::redirect;
+use tuwunel_core::{Config, Result, err, implement, trace};
 
 use crate::{resolver, service};
 
@@ -126,9 +126,9 @@ fn base(config: &Config) -> Result<reqwest::ClientBuilder> {
 		.timeout(Duration::from_secs(config.request_total_timeout))
 		.pool_idle_timeout(Duration::from_secs(config.request_idle_timeout))
 		.pool_max_idle_per_host(config.request_idle_per_host.into())
-		.user_agent(conduwuit::version::user_agent())
+		.user_agent(tuwunel_core::version::user_agent())
 		.redirect(redirect::Policy::limited(6))
-        .danger_accept_invalid_certs(config.allow_invalid_tls_certificates_yes_i_know_what_the_fuck_i_am_doing_with_this_and_i_know_this_is_insecure)
+		.danger_accept_invalid_certs(config.allow_invalid_tls_certificates)
 		.connection_verbose(cfg!(debug_assertions));
 
 	#[cfg(feature = "gzip_compression")]
@@ -196,7 +196,7 @@ fn builder_interface(
 	builder: reqwest::ClientBuilder,
 	config: Option<&str>,
 ) -> Result<reqwest::ClientBuilder> {
-	use conduwuit::Err;
+	use tuwunel_core::Err;
 
 	if let Some(iface) = config {
 		Err!("Binding to network-interface {iface:?} by name is not supported on this platform.")

src/service/config/mod.rs

@@ -1,7 +1,7 @@
 use std::{iter, ops::Deref, path::Path, sync::Arc};
 
 use async_trait::async_trait;
-use conduwuit::{
+use tuwunel_core::{
 	Result, Server,
 	config::{Config, check},
 	error, implement,

src/service/emergency/mod.rs

@@ -1,13 +1,13 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use conduwuit::{Result, error, warn};
 use ruma::{
 	events::{
 		GlobalAccountDataEvent, GlobalAccountDataEventType, push_rules::PushRulesEventContent,
 	},
 	push::Ruleset,
 };
+use tuwunel_core::{Result, error, warn};
 
 use crate::{Dep, account_data, config, globals, users};
 

src/service/federation/execute.rs

@@ -1,10 +1,6 @@
 use std::{fmt::Debug, mem};
 
 use bytes::Bytes;
-use conduwuit::{
-	Err, Error, Result, debug, debug::INFO_SPAN_LEVEL, debug_error, debug_warn, err,
-	error::inspect_debug_log, implement, trace, utils::string::EMPTY,
-};
 use http::{HeaderValue, header::AUTHORIZATION};
 use ipaddress::IPAddress;
 use reqwest::{Client, Method, Request, Response, Url};
@@ -16,6 +12,10 @@ use ruma::{
 	},
 	serde::Base64,
 };
+use tuwunel_core::{
+	Err, Error, Result, debug, debug::INFO_SPAN_LEVEL, debug_error, debug_warn, err,
+	error::inspect_debug_log, implement, trace, utils::string::EMPTY,
+};
 
 use crate::resolver::actual::ActualDest;
 

src/service/federation/mod.rs

@@ -2,7 +2,7 @@ mod execute;
 
 use std::sync::Arc;
 
-use conduwuit::{Result, Server};
+use tuwunel_core::{Result, Server};
 
 use crate::{Dep, client, resolver, server_keys};
 

src/service/globals/data.rs

@@ -1,7 +1,7 @@
 use std::sync::{Arc, RwLock};
 
-use conduwuit::{Result, utils};
-use database::{Database, Deserialized, Map};
+use tuwunel_core::{Result, utils};
+use tuwunel_database::{Database, Deserialized, Map};
 
 pub struct Data {
 	global: Arc<Map>,

src/service/globals/mod.rs

@@ -8,10 +8,10 @@ use std::{
 };
 
 use async_trait::async_trait;
-use conduwuit::{Result, Server, error, utils::bytes::pretty};
 use data::Data;
 use regex::RegexSet;
 use ruma::{OwnedEventId, OwnedRoomAliasId, OwnedServerName, OwnedUserId, ServerName, UserId};
+use tuwunel_core::{Result, Server, error, utils::bytes::pretty};
 
 use crate::service;
 

src/service/key_backups/mod.rs

@@ -1,16 +1,16 @@
 use std::{collections::BTreeMap, sync::Arc};
 
-use conduwuit::{
-	Err, Result, err, implement,
-	utils::stream::{ReadyExt, TryIgnore},
-};
-use database::{Deserialized, Ignore, Interfix, Json, Map};
 use futures::StreamExt;
 use ruma::{
 	OwnedRoomId, RoomId, UserId,
 	api::client::backup::{BackupAlgorithm, KeyBackupData, RoomKeyBackup},
 	serde::Raw,
 };
+use tuwunel_core::{
+	Err, Result, err, implement,
+	utils::stream::{ReadyExt, TryIgnore},
+};
+use tuwunel_database::{Deserialized, Ignore, Interfix, Json, Map};
 
 use crate::{Dep, globals};
 

src/service/manager.rs

@@ -1,12 +1,14 @@
 use std::{panic::AssertUnwindSafe, sync::Arc, time::Duration};
 
-use conduwuit::{Err, Error, Result, Server, debug, debug_warn, error, trace, utils::time, warn};
 use futures::{FutureExt, TryFutureExt};
 use tokio::{
 	sync::{Mutex, MutexGuard},
 	task::{JoinHandle, JoinSet},
 	time::sleep,
 };
+use tuwunel_core::{
+	Err, Error, Result, Server, debug, debug_warn, error, trace, utils::time, warn,
+};
 
 use crate::{Services, service, service::Service};
 

src/service/media/blurhash.rs

@@ -1,6 +1,6 @@
 #[cfg(feature = "blurhashing")]
-use conduwuit::config::BlurhashConfig as CoreBlurhashConfig;
-use conduwuit::{Result, implement};
+use tuwunel_core::config::BlurhashConfig as CoreBlurhashConfig;
+use tuwunel_core::{Result, implement};
 
 use super::Service;
 
@@ -12,7 +12,7 @@ pub fn create_blurhash(
 	_content_type: Option<&str>,
 	_file_name: Option<&str>,
 ) -> Result<Option<String>> {
-	conduwuit::debug_warn!("blurhashing on upload support was not compiled");
+	tuwunel_core::debug_warn!("blurhashing on upload support was not compiled");
 
 	Ok(None)
 }
@@ -33,7 +33,7 @@ pub fn create_blurhash(
 	}
 
 	get_blurhash_from_request(file, content_type, file_name, config)
-		.map_err(|e| conduwuit::err!(debug_error!("blurhashing error: {e}")))
+		.map_err(|e| tuwunel_core::err!(debug_error!("blurhashing error: {e}")))
 		.map(Some)
 }
 

src/service/media/data.rs

@@ -1,12 +1,12 @@
 use std::{sync::Arc, time::Duration};
 
-use conduwuit::{
+use futures::StreamExt;
+use ruma::{Mxc, OwnedMxcUri, UserId, http_headers::ContentDisposition};
+use tuwunel_core::{
 	Err, Result, debug, debug_info, err,
 	utils::{ReadyExt, str_from_bytes, stream::TryIgnore, string_from_bytes},
 };
-use database::{Database, Interfix, Map};
-use futures::StreamExt;
-use ruma::{Mxc, OwnedMxcUri, UserId, http_headers::ContentDisposition};
+use tuwunel_database::{Database, Interfix, Map, serialize_key};
 
 use super::{preview::UrlPreviewData, thumbnail::Dim};
 
@@ -42,7 +42,7 @@ impl Data {
 	) -> Result<Vec<u8>> {
 		let dim: &[u32] = &[dim.width, dim.height];
 		let key = (mxc, dim, content_disposition, content_type);
-		let key = database::serialize_key(key)?;
+		let key = serialize_key(key)?;
 		self.mediaid_file.insert(&key, []);
 		if let Some(user) = user {
 			let key = (mxc, user);

src/service/media/migrations.rs

@@ -7,7 +7,7 @@ use std::{
 	time::Instant,
 };
 
-use conduwuit::{
+use tuwunel_core::{
 	Config, Result, debug, debug_info, debug_warn, error, info,
 	utils::{ReadyExt, stream::TryIgnore},
 	warn,
@@ -95,7 +95,7 @@ pub(crate) async fn checkup_sha256_media(services: &Services) -> Result<()> {
 }
 
 async fn handle_media_check(
-	dbs: &(&Arc<database::Map>, &Arc<database::Map>),
+	dbs: &(&Arc<tuwunel_database::Map>, &Arc<tuwunel_database::Map>),
 	config: &Config,
 	files: &HashSet<OsString>,
 	key: &[u8],

src/service/media/mod.rs

@@ -9,16 +9,16 @@ use std::{path::PathBuf, sync::Arc, time::SystemTime};
 
 use async_trait::async_trait;
 use base64::{Engine as _, engine::general_purpose};
-use conduwuit::{
-	Err, Result, Server, debug, debug_error, debug_info, debug_warn, err, error, trace,
-	utils::{self, MutexMap},
-	warn,
-};
 use ruma::{Mxc, OwnedMxcUri, UserId, http_headers::ContentDisposition};
 use tokio::{
 	fs,
 	io::{AsyncReadExt, AsyncWriteExt, BufReader},
 };
+use tuwunel_core::{
+	Err, Result, Server, debug, debug_error, debug_info, debug_warn, err, error, trace,
+	utils::{self, MutexMap},
+	warn,
+};
 
 use self::data::{Data, Metadata};
 pub use self::thumbnail::Dim;

src/service/media/preview.rs

@@ -7,10 +7,9 @@
 
 use std::time::SystemTime;
 
-use conduwuit::{Err, Result, debug, err};
-use conduwuit_core::implement;
 use ipaddress::IPAddress;
 use serde::Serialize;
+use tuwunel_core::{Err, Result, debug, err, implement};
 use url::Url;
 
 use super::Service;
@@ -105,9 +104,9 @@ async fn request_url_preview(&self, url: &Url) -> Result<UrlPreviewData> {
 #[cfg(feature = "url_preview")]
 #[implement(Service)]
 pub async fn download_image(&self, url: &str) -> Result<UrlPreviewData> {
-	use conduwuit::utils::random_string;
 	use image::ImageReader;
 	use ruma::Mxc;
+	use tuwunel_core::utils::random_string;
 
 	let image = self.services.client.url_preview.get(url).send().await?;
 	let image = image.bytes().await?;

src/service/media/remote.rs

@@ -1,9 +1,5 @@
 use std::{fmt::Debug, time::Duration};
 
-use conduwuit::{
-	Err, Error, Result, debug_warn, err, implement,
-	utils::content_disposition::make_content_disposition,
-};
 use http::header::{CONTENT_DISPOSITION, CONTENT_TYPE, HeaderValue};
 use ruma::{
 	Mxc, ServerName, UserId,
@@ -17,6 +13,10 @@ use ruma::{
 		federation::authenticated_media::{Content, FileOrLocation},
 	},
 };
+use tuwunel_core::{
+	Err, Error, Result, debug_warn, err, implement,
+	utils::content_disposition::make_content_disposition,
+};
 
 use super::{Dim, FileMeta};
 

src/service/media/thumbnail.rs

@@ -7,12 +7,12 @@
 
 use std::{cmp, num::Saturating as Sat};
 
-use conduwuit::{Result, checked, err, implement};
 use ruma::{Mxc, UInt, UserId, http_headers::ContentDisposition, media::Method};
 use tokio::{
 	fs,
 	io::{AsyncReadExt, AsyncWriteExt},
 };
+use tuwunel_core::{Result, checked, err, implement};
 
 use super::{FileMeta, data::Metadata};
 

src/service/migrations.rs

@@ -1,14 +1,5 @@
 use std::cmp;
 
-use conduwuit::{
-	Err, Result, debug, debug_info, debug_warn, error, info,
-	result::NotFound,
-	utils::{
-		IterStream, ReadyExt,
-		stream::{TryExpect, TryIgnore},
-	},
-	warn,
-};
 use futures::{FutureExt, StreamExt};
 use itertools::Itertools;
 use ruma::{
@@ -18,6 +9,15 @@ use ruma::{
 	},
 	push::Ruleset,
 };
+use tuwunel_core::{
+	Err, Result, debug, debug_info, debug_warn, error, info,
+	result::NotFound,
+	utils::{
+		IterStream, ReadyExt,
+		stream::{TryExpect, TryIgnore},
+	},
+	warn,
+};
 
 use crate::{Services, media};
 
@@ -480,7 +480,7 @@ async fn fix_referencedevents_missing_sep(services: &Services) -> Result {
 		.ready_fold(totals, |mut a, (i, (key, val))| {
 			debug_assert!(val.is_empty(), "expected no value");
 
-			let has_sep = key.contains(&database::SEP);
+			let has_sep = key.contains(&tuwunel_database::SEP);
 
 			if !has_sep {
 				let key_str = std::str::from_utf8(key).expect("key not utf-8");
@@ -507,8 +507,8 @@ async fn fix_referencedevents_missing_sep(services: &Services) -> Result {
 }
 
 async fn fix_readreceiptid_readreceipt_duplicates(services: &Services) -> Result {
-	use conduwuit::arrayvec::ArrayString;
 	use ruma::identifiers_validation::MAX_BYTES;
+	use tuwunel_core::arrayvec::ArrayString;
 
 	type ArrayId = ArrayString<MAX_BYTES>;
 	type Key<'a> = (&'a RoomId, u64, &'a UserId);

src/service/mod.rs

@@ -27,13 +27,10 @@ pub mod transaction_ids;
 pub mod uiaa;
 pub mod users;
 
-extern crate conduwuit_core as conduwuit;
-extern crate conduwuit_database as database;
-
 pub(crate) use service::{Args, Dep, Service};
 
 pub use crate::services::Services;
 
-conduwuit::mod_ctor! {}
-conduwuit::mod_dtor! {}
-conduwuit::rustc_flags_capture! {}
+tuwunel_core::mod_ctor! {}
+tuwunel_core::mod_dtor! {}
+tuwunel_core::rustc_flags_capture! {}

src/service/presence/data.rs

@@ -1,12 +1,12 @@
 use std::sync::Arc;
 
-use conduwuit::{
+use futures::Stream;
+use ruma::{UInt, UserId, events::presence::PresenceEvent, presence::PresenceState};
+use tuwunel_core::{
 	Result, debug_warn, utils,
 	utils::{ReadyExt, stream::TryIgnore},
 };
-use database::{Deserialized, Json, Map};
-use futures::Stream;
-use ruma::{UInt, UserId, events::presence::PresenceEvent, presence::PresenceState};
+use tuwunel_database::{Deserialized, Json, Map};
 
 use super::Presence;
 use crate::{Dep, globals, users};

src/service/presence/mod.rs

@@ -4,14 +4,14 @@ mod presence;
 use std::{sync::Arc, time::Duration};
 
 use async_trait::async_trait;
-use conduwuit::{
-	Error, Result, Server, checked, debug, debug_warn, error, result::LogErr, trace,
-};
-use database::Database;
 use futures::{Stream, StreamExt, TryFutureExt, stream::FuturesUnordered};
 use loole::{Receiver, Sender};
 use ruma::{OwnedUserId, UInt, UserId, events::presence::PresenceEvent, presence::PresenceState};
 use tokio::time::sleep;
+use tuwunel_core::{
+	Error, Result, Server, checked, debug, debug_warn, error, result::LogErr, trace,
+};
+use tuwunel_database::Database;
 
 use self::{data::Data, presence::Presence};
 use crate::{Dep, globals, users};

src/service/presence/presence.rs

@@ -1,10 +1,10 @@
-use conduwuit::{Error, Result, utils};
 use ruma::{
 	UInt, UserId,
 	events::presence::{PresenceEvent, PresenceEventContent},
 	presence::PresenceState,
 };
 use serde::{Deserialize, Serialize};
+use tuwunel_core::{Error, Result, utils};
 
 use crate::users;
 

src/service/pusher/mod.rs

@@ -1,12 +1,6 @@
 use std::{fmt::Debug, mem, sync::Arc};
 
 use bytes::BytesMut;
-use conduwuit::{
-	Err, PduEvent, Result, debug_warn, err, trace,
-	utils::{stream::TryIgnore, string_from_bytes},
-	warn,
-};
-use database::{Deserialized, Ignore, Interfix, Json, Map};
 use futures::{Stream, StreamExt};
 use ipaddress::IPAddress;
 use ruma::{
@@ -29,6 +23,12 @@ use ruma::{
 	serde::Raw,
 	uint,
 };
+use tuwunel_core::{
+	Err, PduEvent, Result, debug_warn, err, trace,
+	utils::{stream::TryIgnore, string_from_bytes},
+	warn,
+};
+use tuwunel_database::{Deserialized, Ignore, Interfix, Json, Map};
 
 use crate::{Dep, client, globals, rooms, sending, users};
 

src/service/resolver/actual.rs

@@ -3,11 +3,11 @@ use std::{
 	net::{IpAddr, SocketAddr},
 };
 
-use conduwuit::{Err, Result, debug, debug_info, err, error, trace};
 use futures::{FutureExt, TryFutureExt};
 use hickory_resolver::ResolveError;
 use ipaddress::IPAddress;
 use ruma::ServerName;
+use tuwunel_core::{Err, Result, debug, debug_info, err, error, trace};
 
 use super::{
 	cache::{CachedDest, CachedOverride, MAX_IPS},

src/service/resolver/cache.rs

@@ -1,15 +1,15 @@
 use std::{net::IpAddr, sync::Arc, time::SystemTime};
 
-use conduwuit::{
+use futures::{Stream, StreamExt, future::join};
+use ruma::ServerName;
+use serde::{Deserialize, Serialize};
+use tuwunel_core::{
 	Result,
 	arrayvec::ArrayVec,
 	at, err, implement,
 	utils::{math::Expected, rand, stream::TryIgnore},
 };
-use database::{Cbor, Deserialized, Map};
-use futures::{Stream, StreamExt, future::join};
-use ruma::ServerName;
-use serde::{Deserialize, Serialize};
+use tuwunel_database::{Cbor, Deserialized, Map};
 
 use super::fed::FedDest;
 

src/service/resolver/dns.rs

@@ -1,9 +1,9 @@
 use std::{net::SocketAddr, sync::Arc, time::Duration};
 
-use conduwuit::{Result, Server, err};
 use futures::FutureExt;
 use hickory_resolver::{TokioResolver, lookup_ip::LookupIp};
 use reqwest::dns::{Addrs, Name, Resolve, Resolving};
+use tuwunel_core::{Result, Server, err};
 
 use super::cache::{Cache, CachedOverride};
 

src/service/resolver/fed.rs

@@ -4,8 +4,8 @@ use std::{
 	net::{IpAddr, SocketAddr},
 };
 
-use conduwuit::{arrayvec::ArrayString, utils::math::Expected};
 use serde::{Deserialize, Serialize};
+use tuwunel_core::{arrayvec::ArrayString, utils::math::Expected};
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
 pub enum FedDest {

src/service/resolver/mod.rs

@@ -9,7 +9,7 @@ mod well_known;
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use conduwuit::{Result, Server, arrayvec::ArrayString, utils::MutexMap};
+use tuwunel_core::{Result, Server, arrayvec::ArrayString, utils::MutexMap};
 
 use self::{cache::Cache, dns::Resolver};
 use crate::{Dep, client};

src/service/resolver/well_known.rs

@@ -1,4 +1,4 @@
-use conduwuit::{Result, debug, debug_error, debug_info, debug_warn, implement, trace};
+use tuwunel_core::{Result, debug, debug_error, debug_info, debug_warn, implement, trace};
 
 #[implement(super::Service)]
 #[tracing::instrument(name = "well-known", level = "debug", skip(self, dest))]

src/service/rooms/alias/mod.rs

@@ -2,11 +2,6 @@ mod remote;
 
 use std::sync::Arc;
 
-use conduwuit::{
-	Err, Result, Server, err,
-	utils::{ReadyExt, stream::TryIgnore},
-};
-use database::{Deserialized, Ignore, Interfix, Map};
 use futures::{Stream, StreamExt, TryFutureExt};
 use ruma::{
 	OwnedRoomId, OwnedServerName, OwnedUserId, RoomAliasId, RoomId, RoomOrAliasId, UserId,
@@ -15,6 +10,11 @@ use ruma::{
 		room::power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent},
 	},
 };
+use tuwunel_core::{
+	Err, Result, Server, err,
+	utils::{ReadyExt, stream::TryIgnore},
+};
+use tuwunel_database::{Deserialized, Ignore, Interfix, Map};
 
 use crate::{Dep, admin, appservice, appservice::RegistrationInfo, globals, rooms, sending};
 

src/service/rooms/alias/remote.rs

@@ -1,8 +1,8 @@
 use std::iter::once;
 
-use conduwuit::{Result, debug, debug_error, err, implement};
 use federation::query::get_room_information::v1::Response;
 use ruma::{OwnedRoomId, OwnedServerName, RoomAliasId, ServerName, api::federation};
+use tuwunel_core::{Result, debug, debug_error, err, implement};
 
 #[implement(super::Service)]
 pub(super) async fn remote_resolve(

src/service/rooms/auth_chain/data.rs

@@ -3,9 +3,9 @@ use std::{
 	sync::{Arc, Mutex},
 };
 
-use conduwuit::{Err, Result, err, utils, utils::math::usize_from_f64};
-use database::Map;
 use lru_cache::LruCache;
+use tuwunel_core::{Err, Result, err, utils, utils::math::usize_from_f64};
+use tuwunel_database::Map;
 
 use crate::rooms::short::ShortEventId;
 

src/service/rooms/auth_chain/mod.rs

@@ -7,7 +7,9 @@ use std::{
 	time::Instant,
 };
 
-use conduwuit::{
+use futures::{FutureExt, Stream, StreamExt, TryFutureExt, TryStreamExt};
+use ruma::{EventId, OwnedEventId, RoomId};
+use tuwunel_core::{
 	Err, Result, at, debug, debug_error, implement, trace,
 	utils::{
 		IterStream,
@@ -15,8 +17,6 @@ use conduwuit::{
 	},
 	validated, warn,
 };
-use futures::{FutureExt, Stream, StreamExt, TryFutureExt, TryStreamExt};
-use ruma::{EventId, OwnedEventId, RoomId};
 
 use self::data::Data;
 use crate::{Dep, rooms, rooms::short::ShortEventId};

src/service/rooms/directory/mod.rs

@@ -1,9 +1,9 @@
 use std::sync::Arc;
 
-use conduwuit::{Result, implement, utils::stream::TryIgnore};
-use database::Map;
 use futures::Stream;
 use ruma::{RoomId, api::client::room::Visibility};
+use tuwunel_core::{Result, implement, utils::stream::TryIgnore};
+use tuwunel_database::Map;
 
 pub struct Service {
 	db: Data,

src/service/rooms/event_handler/acl_check.rs

@@ -1,8 +1,8 @@
-use conduwuit::{Err, Result, debug, implement, trace, warn};
 use ruma::{
 	RoomId, ServerName,
 	events::{StateEventType, room::server_acl::RoomServerAclEventContent},
 };
+use tuwunel_core::{Err, Result, debug, implement, trace, warn};
 
 /// Returns Ok if the acl allows the server
 #[implement(super::Service)]

src/service/rooms/event_handler/fetch_and_handle_outliers.rs

@@ -3,13 +3,13 @@ use std::{
 	time::Instant,
 };
 
-use conduwuit::{
-	PduEvent, debug, debug_error, debug_warn, implement, pdu, trace,
-	utils::continue_exponential_backoff_secs, warn,
-};
 use ruma::{
 	CanonicalJsonValue, OwnedEventId, RoomId, ServerName, api::federation::event::get_event,
 };
+use tuwunel_core::{
+	PduEvent, debug, debug_error, debug_warn, implement, pdu, trace,
+	utils::continue_exponential_backoff_secs, warn,
+};
 
 use super::get_room_version_id;
 

src/service/rooms/event_handler/fetch_prev.rs

@@ -1,14 +1,14 @@
 use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
 
-use conduwuit::{
-	PduEvent, Result, debug_warn, err, implement,
-	state_res::{self},
-};
 use futures::{FutureExt, future};
 use ruma::{
 	CanonicalJsonValue, MilliSecondsSinceUnixEpoch, OwnedEventId, RoomId, ServerName, UInt, int,
 	uint,
 };
+use tuwunel_core::{
+	PduEvent, Result, debug_warn, err, implement,
+	state_res::{self},
+};
 
 use super::check_room_id;
 

src/service/rooms/event_handler/fetch_state.rs

@@ -1,11 +1,11 @@
 use std::collections::{HashMap, hash_map};
 
-use conduwuit::{Err, Error, PduEvent, Result, debug, debug_warn, implement};
 use futures::FutureExt;
 use ruma::{
 	EventId, OwnedEventId, RoomId, ServerName, api::federation::event::get_room_state_ids,
 	events::StateEventType,
 };
+use tuwunel_core::{Err, Error, PduEvent, Result, debug, debug_warn, implement};
 
 use crate::rooms::short::ShortStateKey;
 

src/service/rooms/event_handler/handle_incoming_pdu.rs

@@ -3,15 +3,15 @@ use std::{
 	time::Instant,
 };
 
-use conduwuit::{
-	Err, Result, debug, debug::INFO_SPAN_LEVEL, defer, err, implement, utils::stream::IterStream,
-	warn,
-};
 use futures::{
 	FutureExt, TryFutureExt, TryStreamExt,
 	future::{OptionFuture, try_join5},
 };
 use ruma::{CanonicalJsonValue, EventId, RoomId, ServerName, UserId, events::StateEventType};
+use tuwunel_core::{
+	Err, Result, debug, debug::INFO_SPAN_LEVEL, defer, err, implement, utils::stream::IterStream,
+	warn,
+};
 
 use crate::rooms::timeline::RawPduId;
 

src/service/rooms/event_handler/handle_outlier_pdu.rs

@@ -1,13 +1,13 @@
 use std::collections::{BTreeMap, HashMap, hash_map};
 
-use conduwuit::{
-	Err, Error, PduEvent, Result, debug, debug_info, err, implement, state_res, trace, warn,
-};
 use futures::future::ready;
 use ruma::{
 	CanonicalJsonObject, CanonicalJsonValue, EventId, RoomId, ServerName,
 	api::client::error::ErrorKind, events::StateEventType,
 };
+use tuwunel_core::{
+	Err, Error, PduEvent, Result, debug, debug_info, err, implement, state_res, trace, warn,
+};
 
 use super::{check_room_id, get_room_version_id, to_room_version};
 

src/service/rooms/event_handler/handle_prev_pdu.rs

@@ -1,10 +1,10 @@
 use std::{collections::BTreeMap, time::Instant};
 
-use conduwuit::{
+use ruma::{CanonicalJsonValue, EventId, RoomId, ServerName, UInt};
+use tuwunel_core::{
 	Err, PduEvent, Result, debug, debug::INFO_SPAN_LEVEL, defer, implement,
 	utils::continue_exponential_backoff_secs,
 };
-use ruma::{CanonicalJsonValue, EventId, RoomId, ServerName, UInt};
 
 #[implement(super::Service)]
 #[allow(clippy::type_complexity)]

src/service/rooms/event_handler/mod.rs

@@ -18,11 +18,11 @@ use std::{
 };
 
 use async_trait::async_trait;
-use conduwuit::{Err, PduEvent, Result, RoomVersion, Server, utils::MutexMap};
 use ruma::{
 	OwnedEventId, OwnedRoomId, RoomId, RoomVersionId,
 	events::room::create::RoomCreateEventContent,
 };
+use tuwunel_core::{Err, PduEvent, Result, RoomVersion, Server, utils::MutexMap};
 
 use crate::{Dep, globals, rooms, sending, server_keys};
 

src/service/rooms/event_handler/parse_incoming_pdu.rs

@@ -1,6 +1,6 @@
-use conduwuit::{Result, err, implement, pdu::gen_event_id_canonical_json, result::FlatOk};
 use ruma::{CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, OwnedRoomId};
 use serde_json::value::RawValue as RawJsonValue;
+use tuwunel_core::{Result, err, implement, pdu::gen_event_id_canonical_json, result::FlatOk};
 
 type Parsed = (OwnedRoomId, OwnedEventId, CanonicalJsonObject);
 

src/service/rooms/event_handler/resolve_state.rs

@@ -4,14 +4,14 @@ use std::{
 	sync::Arc,
 };
 
-use conduwuit::{
+use futures::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, future::try_join};
+use ruma::{OwnedEventId, RoomId, RoomVersionId};
+use tuwunel_core::{
 	Error, Result, err, implement,
 	state_res::{self, StateMap},
 	trace,
 	utils::stream::{IterStream, ReadyExt, TryWidebandExt, WidebandExt, automatic_width},
 };
-use futures::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, future::try_join};
-use ruma::{OwnedEventId, RoomId, RoomVersionId};
 
 use crate::rooms::state_compressor::CompressedState;
 

src/service/rooms/event_handler/state_at_incoming.rs

@@ -4,14 +4,14 @@ use std::{
 	iter::Iterator,
 };
 
-use conduwuit::{
+use futures::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, future::try_join};
+use ruma::{OwnedEventId, RoomId, RoomVersionId};
+use tuwunel_core::{
 	Result, debug, err, implement,
 	matrix::{PduEvent, StateMap},
 	trace,
 	utils::stream::{BroadbandExt, IterStream, ReadyExt, TryBroadbandExt, TryWidebandExt},
 };
-use futures::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, future::try_join};
-use ruma::{OwnedEventId, RoomId, RoomVersionId};
 
 use crate::rooms::short::ShortStateHash;
 

src/service/rooms/event_handler/upgrade_outlier_pdu.rs

@@ -1,14 +1,14 @@
 use std::{borrow::Borrow, collections::BTreeMap, iter::once, sync::Arc, time::Instant};
 
-use conduwuit::{
+use futures::{FutureExt, StreamExt, future::ready};
+use ruma::{CanonicalJsonValue, RoomId, ServerName, events::StateEventType};
+use tuwunel_core::{
 	Err, Result, debug, debug_info, err, implement,
 	matrix::{EventTypeExt, PduEvent, StateKey, state_res},
 	trace,
 	utils::stream::{BroadbandExt, ReadyExt},
 	warn,
 };
-use futures::{FutureExt, StreamExt, future::ready};
-use ruma::{CanonicalJsonValue, RoomId, ServerName, events::StateEventType};
 
 use super::{get_room_version_id, to_room_version};
 use crate::rooms::{

src/service/rooms/lazy_loading/mod.rs

@@ -2,13 +2,13 @@
 
 use std::{collections::HashSet, sync::Arc};
 
-use conduwuit::{
+use futures::{Stream, StreamExt, pin_mut};
+use ruma::{DeviceId, OwnedUserId, RoomId, UserId, api::client::filter::LazyLoadOptions};
+use tuwunel_core::{
 	Result, implement,
 	utils::{IterStream, ReadyExt, stream::TryIgnore},
 };
-use database::{Database, Deserialized, Handle, Interfix, Map, Qry};
-use futures::{Stream, StreamExt, pin_mut};
-use ruma::{DeviceId, OwnedUserId, RoomId, UserId, api::client::filter::LazyLoadOptions};
+use tuwunel_database::{Database, Deserialized, Handle, Interfix, Map, Qry};
 
 pub struct Service {
 	db: Data,

src/service/rooms/metadata/mod.rs

@@ -1,9 +1,9 @@
 use std::sync::Arc;
 
-use conduwuit::{Result, implement, utils::stream::TryIgnore};
-use database::Map;
 use futures::{Stream, StreamExt};
 use ruma::RoomId;
+use tuwunel_core::{Result, implement, utils::stream::TryIgnore};
+use tuwunel_database::Map;
 
 use crate::{Dep, rooms};
 

src/service/rooms/outlier/mod.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
-use conduwuit::{Result, implement, matrix::pdu::PduEvent};
-use conduwuit_database::{Deserialized, Json, Map};
 use ruma::{CanonicalJsonObject, EventId};
+use tuwunel_core::{Result, implement, matrix::pdu::PduEvent};
+use tuwunel_database::{Deserialized, Json, Map};
 
 pub struct Service {
 	db: Data,

src/service/rooms/pdu_metadata/data.rs

@@ -1,6 +1,8 @@
 use std::{mem::size_of, sync::Arc};
 
-use conduwuit::{
+use futures::{Stream, StreamExt};
+use ruma::{EventId, RoomId, UserId, api::Direction};
+use tuwunel_core::{
 	PduCount, PduEvent,
 	arrayvec::ArrayVec,
 	result::LogErr,
@@ -10,9 +12,7 @@ use conduwuit::{
 		u64_from_u8,
 	},
 };
-use database::Map;
-use futures::{Stream, StreamExt};
-use ruma::{EventId, RoomId, UserId, api::Direction};
+use tuwunel_database::Map;
 
 use crate::{
 	Dep, rooms,

src/service/rooms/pdu_metadata/mod.rs

@@ -1,9 +1,9 @@
 mod data;
 use std::sync::Arc;
 
-use conduwuit::{PduCount, Result};
 use futures::{StreamExt, future::try_join};
 use ruma::{EventId, RoomId, UserId, api::Direction};
+use tuwunel_core::{PduCount, Result};
 
 use self::data::{Data, PdusIterItem};
 use crate::{Dep, rooms};

src/service/rooms/read_receipt/data.rs

@@ -1,16 +1,16 @@
 use std::sync::Arc;
 
-use conduwuit::{
-	Result,
-	utils::{ReadyExt, stream::TryIgnore},
-};
-use database::{Deserialized, Json, Map};
 use futures::{Stream, StreamExt};
 use ruma::{
 	CanonicalJsonObject, RoomId, UserId,
 	events::{AnySyncEphemeralRoomEvent, receipt::ReceiptEvent},
 	serde::Raw,
 };
+use tuwunel_core::{
+	Result,
+	utils::{ReadyExt, stream::TryIgnore},
+};
+use tuwunel_database::{Deserialized, Json, Map};
 
 use crate::{Dep, globals};
 

src/service/rooms/read_receipt/mod.rs

@@ -2,11 +2,6 @@ mod data;
 
 use std::{collections::BTreeMap, sync::Arc};
 
-use conduwuit::{
-	Result, debug, err,
-	matrix::pdu::{PduCount, PduId, RawPduId},
-	warn,
-};
 use futures::{Stream, TryFutureExt, try_join};
 use ruma::{
 	OwnedEventId, OwnedUserId, RoomId, UserId,
@@ -16,6 +11,11 @@ use ruma::{
 	},
 	serde::Raw,
 };
+use tuwunel_core::{
+	Result, debug, err,
+	matrix::pdu::{PduCount, PduId, RawPduId},
+	warn,
+};
 
 use self::data::{Data, ReceiptItem};
 use crate::{Dep, rooms, sending};
@@ -161,7 +161,7 @@ where
 	}
 	let content = ReceiptEventContent::from_iter(json);
 
-	conduwuit::trace!(?content);
+	tuwunel_core::trace!(?content);
 	Raw::from_json(
 		serde_json::value::to_raw_value(&SyncEphemeralRoomEvent { content })
 			.expect("received valid json"),

src/service/rooms/search/mod.rs

@@ -1,6 +1,8 @@
 use std::sync::Arc;
 
-use conduwuit::{
+use futures::{Stream, StreamExt};
+use ruma::{RoomId, UserId, api::client::search::search_events::v3::Criteria};
+use tuwunel_core::{
 	PduCount, PduEvent, Result,
 	arrayvec::ArrayVec,
 	implement,
@@ -9,9 +11,7 @@ use conduwuit::{
 		stream::{TryIgnore, WidebandExt},
 	},
 };
-use database::{Map, keyval::Val};
-use futures::{Stream, StreamExt};
-use ruma::{RoomId, UserId, api::client::search::search_events::v3::Criteria};
+use tuwunel_database::{Map, keyval::Val};
 
 use crate::{
 	Dep, rooms,
@@ -224,7 +224,7 @@ fn make_prefix(shortroomid: ShortRoomId, word: &str) -> TokenId {
 	let mut key = TokenId::new();
 	key.extend_from_slice(&shortroomid.to_be_bytes());
 	key.extend_from_slice(word.as_bytes());
-	key.push(database::SEP);
+	key.push(tuwunel_database::SEP);
 	key
 }
 

src/service/rooms/short/mod.rs

@@ -1,11 +1,11 @@
 use std::{borrow::Borrow, fmt::Debug, mem::size_of_val, sync::Arc};
 
-pub use conduwuit::matrix::pdu::{ShortEventId, ShortId, ShortRoomId, ShortStateKey};
-use conduwuit::{Result, err, implement, matrix::StateKey, utils, utils::IterStream};
-use database::{Deserialized, Get, Map, Qry};
 use futures::{Stream, StreamExt};
 use ruma::{EventId, RoomId, events::StateEventType};
 use serde::Deserialize;
+pub use tuwunel_core::matrix::pdu::{ShortEventId, ShortId, ShortRoomId, ShortStateKey};
+use tuwunel_core::{Result, err, implement, matrix::StateKey, utils, utils::IterStream};
+use tuwunel_database::{Deserialized, Get, Map, Qry};
 
 use crate::{Dep, globals};
 

src/service/rooms/spaces/mod.rs

@@ -5,15 +5,6 @@ mod tests;
 use std::{fmt::Write, sync::Arc};
 
 use async_trait::async_trait;
-use conduwuit::{
-	Err, Error, PduEvent, Result, implement,
-	utils::{
-		IterStream,
-		future::{BoolExt, TryExtExt},
-		math::usize_from_f64,
-		stream::{BroadbandExt, ReadyExt},
-	},
-};
 use futures::{FutureExt, Stream, StreamExt, TryFutureExt, pin_mut, stream::FuturesUnordered};
 use lru_cache::LruCache;
 use ruma::{
@@ -33,6 +24,15 @@ use ruma::{
 	space::SpaceRoomJoinRule,
 };
 use tokio::sync::{Mutex, MutexGuard};
+use tuwunel_core::{
+	Err, Error, PduEvent, Result, implement,
+	utils::{
+		IterStream,
+		future::{BoolExt, TryExtExt},
+		math::usize_from_f64,
+		stream::{BroadbandExt, ReadyExt},
+	},
+};
 
 pub use self::pagination_token::PaginationToken;
 use crate::{Dep, rooms, sending};

src/service/rooms/spaces/pagination_token.rs

@@ -3,8 +3,8 @@ use std::{
 	str::FromStr,
 };
 
-use conduwuit::{Error, Result};
 use ruma::{UInt, api::client::error::ErrorKind};
+use tuwunel_core::{Error, Result};
 
 use crate::rooms::short::ShortRoomId;
 

src/service/rooms/state/mod.rs

@@ -1,17 +1,6 @@
 use std::{collections::HashMap, fmt::Write, iter::once, sync::Arc};
 
 use async_trait::async_trait;
-use conduwuit::{
-	PduEvent, Result, err,
-	result::FlatOk,
-	state_res::{self, StateMap},
-	utils::{
-		IterStream, MutexMap, MutexMapGuard, ReadyExt, calculate_hash,
-		stream::{BroadbandExt, TryIgnore},
-	},
-	warn,
-};
-use database::{Deserialized, Ignore, Interfix, Map};
 use futures::{
 	FutureExt, Stream, StreamExt, TryFutureExt, TryStreamExt, future::join_all, pin_mut,
 };
@@ -23,6 +12,17 @@ use ruma::{
 	},
 	serde::Raw,
 };
+use tuwunel_core::{
+	PduEvent, Result, err,
+	result::FlatOk,
+	state_res::{self, StateMap},
+	utils::{
+		IterStream, MutexMap, MutexMapGuard, ReadyExt, calculate_hash,
+		stream::{BroadbandExt, TryIgnore},
+	},
+	warn,
+};
+use tuwunel_database::{Deserialized, Ignore, Interfix, Map};
 
 use crate::{
 	Dep, globals, rooms,

src/service/rooms/state_accessor/mod.rs

@@ -6,8 +6,6 @@ mod user_can;
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use conduwuit::{Result, err};
-use database::Map;
 use ruma::{
 	EventEncryptionAlgorithm, JsOption, OwnedRoomAliasId, RoomId, UserId,
 	events::{
@@ -27,6 +25,8 @@ use ruma::{
 	},
 	room::RoomType,
 };
+use tuwunel_core::{Result, err};
+use tuwunel_database::Map;
 
 use crate::{Dep, rooms};
 

src/service/rooms/state_accessor/room_state.rs

@@ -1,12 +1,12 @@
 use std::borrow::Borrow;
 
-use conduwuit::{
-	Result, err, implement,
-	matrix::{PduEvent, StateKey},
-};
 use futures::{Stream, StreamExt, TryFutureExt};
 use ruma::{EventId, RoomId, events::StateEventType};
 use serde::Deserialize;
+use tuwunel_core::{
+	Result, err, implement,
+	matrix::{PduEvent, StateKey},
+};
 
 /// Returns a single PDU from `room_id` with key (`event_type`,`state_key`).
 #[implement(super::Service)]

src/service/rooms/state_accessor/server_can.rs

@@ -1,4 +1,3 @@
-use conduwuit::{implement, utils::stream::ReadyExt};
 use futures::StreamExt;
 use ruma::{
 	EventId, RoomId, ServerName,
@@ -7,6 +6,7 @@ use ruma::{
 		room::history_visibility::{HistoryVisibility, RoomHistoryVisibilityEventContent},
 	},
 };
+use tuwunel_core::{implement, utils::stream::ReadyExt};
 
 /// Whether a server is allowed to see an event through federation, based on
 /// the room's history_visibility at that event's state.

src/service/rooms/state_accessor/state.rs

@@ -1,15 +1,5 @@
 use std::{borrow::Borrow, ops::Deref, sync::Arc};
 
-use conduwuit::{
-	Result, at, err, implement,
-	matrix::{PduEvent, StateKey},
-	pair_of,
-	utils::{
-		result::FlatOk,
-		stream::{BroadbandExt, IterStream, ReadyExt, TryIgnore},
-	},
-};
-use conduwuit_database::Deserialized;
 use futures::{FutureExt, Stream, StreamExt, TryFutureExt, future::try_join, pin_mut};
 use ruma::{
 	EventId, OwnedEventId, UserId,
@@ -19,6 +9,16 @@ use ruma::{
 	},
 };
 use serde::Deserialize;
+use tuwunel_core::{
+	Result, at, err, implement,
+	matrix::{PduEvent, StateKey},
+	pair_of,
+	utils::{
+		result::FlatOk,
+		stream::{BroadbandExt, IterStream, ReadyExt, TryIgnore},
+	},
+};
+use tuwunel_database::Deserialized;
 
 use crate::rooms::{
 	short::{ShortEventId, ShortStateHash, ShortStateKey},

src/service/rooms/state_accessor/user_can.rs

@@ -1,4 +1,3 @@
-use conduwuit::{Err, Result, implement, pdu::PduBuilder};
 use ruma::{
 	EventId, RoomId, UserId,
 	events::{
@@ -10,6 +9,7 @@ use ruma::{
 		},
 	},
 };
+use tuwunel_core::{Err, Result, implement, pdu::PduBuilder};
 
 use crate::rooms::state::RoomMutexGuard;
 

src/service/rooms/state_cache/mod.rs

@@ -3,13 +3,6 @@ use std::{
 	sync::{Arc, RwLock},
 };
 
-use conduwuit::{
-	Result, is_not_empty,
-	result::LogErr,
-	utils::{ReadyExt, StreamTools, stream::TryIgnore},
-	warn,
-};
-use database::{Deserialized, Ignore, Interfix, Json, Map, serialize_key};
 use futures::{Stream, StreamExt, future::join5, pin_mut, stream::iter};
 use itertools::Itertools;
 use ruma::{
@@ -27,6 +20,13 @@ use ruma::{
 	int,
 	serde::Raw,
 };
+use tuwunel_core::{
+	Result, is_not_empty,
+	result::LogErr,
+	utils::{ReadyExt, StreamTools, stream::TryIgnore},
+	warn,
+};
+use tuwunel_database::{Deserialized, Ignore, Interfix, Json, Map, serialize_key};
 
 use crate::{Dep, account_data, appservice::RegistrationInfo, config, globals, rooms, users};
 
@@ -499,7 +499,7 @@ impl Service {
 		user_a: &'a UserId,
 		user_b: &'a UserId,
 	) -> impl Stream<Item = &RoomId> + Send + 'a {
-		use conduwuit::utils::set;
+		use tuwunel_core::utils::set;
 
 		let a = self.rooms_joined(user_a);
 		let b = self.rooms_joined(user_b);

src/service/rooms/state_compressor/mod.rs

@@ -6,16 +6,16 @@ use std::{
 };
 
 use async_trait::async_trait;
-use conduwuit::{
+use futures::{Stream, StreamExt};
+use lru_cache::LruCache;
+use ruma::{EventId, RoomId};
+use tuwunel_core::{
 	Result,
 	arrayvec::ArrayVec,
 	at, checked, err, expected, utils,
 	utils::{bytes, math::usize_from_f64, stream::IterStream},
 };
-use database::Map;
-use futures::{Stream, StreamExt};
-use lru_cache::LruCache;
-use ruma::{EventId, RoomId};
+use tuwunel_database::Map;
 
 use crate::{
 	Dep, rooms,

src/service/rooms/threads/mod.rs

@@ -1,6 +1,12 @@
 use std::{collections::BTreeMap, sync::Arc};
 
-use conduwuit::{
+use futures::{Stream, StreamExt};
+use ruma::{
+	CanonicalJsonValue, EventId, OwnedUserId, RoomId, UserId,
+	api::client::threads::get_threads::v1::IncludeThreads, events::relation::BundledThread, uint,
+};
+use serde_json::json;
+use tuwunel_core::{
 	Result, err,
 	matrix::pdu::{PduCount, PduEvent, PduId, RawPduId},
 	utils::{
@@ -8,13 +14,7 @@ use conduwuit::{
 		stream::{TryIgnore, WidebandExt},
 	},
 };
-use conduwuit_database::{Deserialized, Map};
-use futures::{Stream, StreamExt};
-use ruma::{
-	CanonicalJsonValue, EventId, OwnedUserId, RoomId, UserId,
-	api::client::threads::get_threads::v1::IncludeThreads, events::relation::BundledThread, uint,
-};
-use serde_json::json;
+use tuwunel_database::{Deserialized, Map};
 
 use crate::{Dep, rooms, rooms::short::ShortRoomId};
 

src/service/rooms/timeline/data.rs

@@ -1,14 +1,14 @@
 use std::{borrow::Borrow, sync::Arc};
 
-use conduwuit::{
+use futures::{FutureExt, Stream, TryFutureExt, TryStreamExt, future::select_ok, pin_mut};
+use ruma::{CanonicalJsonObject, EventId, OwnedUserId, RoomId, UserId, api::Direction};
+use tuwunel_core::{
 	Err, PduCount, PduEvent, Result, at, err,
 	result::{LogErr, NotFound},
 	utils,
 	utils::stream::TryReadyExt,
 };
-use database::{Database, Deserialized, Json, KeyVal, Map};
-use futures::{FutureExt, Stream, TryFutureExt, TryStreamExt, future::select_ok, pin_mut};
-use ruma::{CanonicalJsonObject, EventId, OwnedUserId, RoomId, UserId, api::Direction};
+use tuwunel_database::{Database, Deserialized, Json, KeyVal, Map};
 
 use super::{PduId, RawPduId};
 use crate::{Dep, rooms, rooms::short::ShortRoomId};

src/service/rooms/timeline/mod.rs

@@ -10,19 +10,6 @@ use std::{
 };
 
 use async_trait::async_trait;
-pub use conduwuit::matrix::pdu::{PduId, RawPduId};
-use conduwuit::{
-	Err, Error, Result, Server, at, debug, debug_warn, err, error, implement, info,
-	matrix::{
-		Event,
-		pdu::{EventHash, PduBuilder, PduCount, PduEvent, gen_event_id},
-		state_res::{self, RoomVersion},
-	},
-	utils::{
-		self, IterStream, MutexMap, MutexMapGuard, ReadyExt, future::TryExtExt, stream::TryIgnore,
-	},
-	validated, warn,
-};
 use futures::{
 	Future, FutureExt, Stream, StreamExt, TryStreamExt, future, future::ready, pin_mut,
 };
@@ -47,6 +34,19 @@ use ruma::{
 };
 use serde::Deserialize;
 use serde_json::value::{RawValue as RawJsonValue, to_raw_value};
+pub use tuwunel_core::matrix::pdu::{PduId, RawPduId};
+use tuwunel_core::{
+	Err, Error, Result, Server, at, debug, debug_warn, err, error, implement, info,
+	matrix::{
+		Event,
+		pdu::{EventHash, PduBuilder, PduCount, PduEvent, gen_event_id},
+		state_res::{self, RoomVersion},
+	},
+	utils::{
+		self, IterStream, MutexMap, MutexMapGuard, ReadyExt, future::TryExtExt, stream::TryIgnore,
+	},
+	validated, warn,
+};
 
 use self::data::Data;
 pub use self::data::PdusIterItem;

src/service/rooms/typing/mod.rs

@@ -1,9 +1,5 @@
 use std::{collections::BTreeMap, sync::Arc};
 
-use conduwuit::{
-	Result, Server, debug_info, trace,
-	utils::{self, IterStream},
-};
 use futures::StreamExt;
 use ruma::{
 	OwnedRoomId, OwnedUserId, RoomId, UserId,
@@ -11,6 +7,10 @@ use ruma::{
 	events::SyncEphemeralRoomEvent,
 };
 use tokio::sync::{RwLock, broadcast};
+use tuwunel_core::{
+	Result, Server, debug_info, trace,
+	utils::{self, IterStream},
+};
 
 use crate::{Dep, globals, sending, sending::EduBuf, users};
 

src/service/rooms/user/mod.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
-use conduwuit::{Result, implement};
-use database::{Database, Deserialized, Map};
 use ruma::{RoomId, UserId};
+use tuwunel_core::{Result, implement};
+use tuwunel_database::{Database, Deserialized, Map};
 
 use crate::{Dep, globals, rooms, rooms::short::ShortStateHash};
 

src/service/sending/appservice.rs

@@ -1,11 +1,11 @@
 use std::{fmt::Debug, mem};
 
 use bytes::BytesMut;
-use conduwuit::{Err, Result, debug_error, err, trace, utils, warn};
 use reqwest::Client;
 use ruma::api::{
 	IncomingResponse, MatrixVersion, OutgoingRequest, SendAccessToken, appservice::Registration,
 };
+use tuwunel_core::{Err, Result, debug_error, err, trace, utils, warn};
 
 /// Sends a request to an appservice
 ///

src/service/sending/data.rs

@@ -1,12 +1,12 @@
 use std::{fmt::Debug, sync::Arc};
 
-use conduwuit::{
+use futures::{Stream, StreamExt};
+use ruma::{OwnedServerName, ServerName, UserId};
+use tuwunel_core::{
 	Error, Result, at, utils,
 	utils::{ReadyExt, stream::TryIgnore},
 };
-use database::{Database, Deserialized, Map};
-use futures::{Stream, StreamExt};
-use ruma::{OwnedServerName, ServerName, UserId};
+use tuwunel_database::{Database, Deserialized, Map};
 
 use super::{Destination, SendingEvent};
 use crate::{Dep, globals};

src/service/sending/dest.rs

@@ -1,7 +1,7 @@
 use std::fmt::Debug;
 
-use conduwuit::implement;
 use ruma::{OwnedServerName, OwnedUserId};
+use tuwunel_core::implement;
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Destination {

src/service/sending/mod.rs

@@ -11,18 +11,18 @@ use std::{
 };
 
 use async_trait::async_trait;
-use conduwuit::{
-	Result, Server, debug, debug_warn, err, error,
-	smallvec::SmallVec,
-	utils::{ReadyExt, TryReadyExt, available_parallelism, math::usize_from_u64_truncated},
-	warn,
-};
 use futures::{FutureExt, Stream, StreamExt};
 use ruma::{
 	RoomId, ServerName, UserId,
 	api::{OutgoingRequest, appservice::Registration},
 };
 use tokio::{task, task::JoinSet};
+use tuwunel_core::{
+	Result, Server, debug, debug_warn, err, error,
+	smallvec::SmallVec,
+	utils::{ReadyExt, TryReadyExt, available_parallelism, math::usize_from_u64_truncated},
+	warn,
+};
 
 use self::data::Data;
 pub use self::{

src/service/sending/sender.rs

@@ -9,17 +9,6 @@ use std::{
 };
 
 use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
-use conduwuit::{
-	Error, Result, debug, err, error,
-	result::LogErr,
-	trace,
-	utils::{
-		ReadyExt, calculate_hash, continue_exponential_backoff_secs,
-		future::TryExtExt,
-		stream::{BroadbandExt, IterStream, WidebandExt},
-	},
-	warn,
-};
 use futures::{
 	FutureExt, StreamExt,
 	future::{BoxFuture, OptionFuture},
@@ -49,6 +38,17 @@ use ruma::{
 	uint,
 };
 use serde_json::value::{RawValue as RawJsonValue, to_raw_value};
+use tuwunel_core::{
+	Error, Result, debug, err, error,
+	result::LogErr,
+	trace,
+	utils::{
+		ReadyExt, calculate_hash, continue_exponential_backoff_secs,
+		future::TryExtExt,
+		stream::{BroadbandExt, IterStream, WidebandExt},
+	},
+	warn,
+};
 
 use super::{
 	Destination, EduBuf, EduVec, Msg, SendingEvent, Service, appservice, data::QueueItem,

src/service/server_keys/acquire.rs

@@ -4,9 +4,6 @@ use std::{
 	time::Duration,
 };
 
-use conduwuit::{
-	debug, debug_error, debug_warn, error, implement, info, result::FlatOk, trace, warn,
-};
 use futures::{StreamExt, stream::FuturesUnordered};
 use ruma::{
 	CanonicalJsonObject, OwnedServerName, OwnedServerSigningKeyId, ServerName,
@@ -14,6 +11,9 @@ use ruma::{
 };
 use serde_json::value::RawValue as RawJsonValue;
 use tokio::time::{Instant, timeout_at};
+use tuwunel_core::{
+	debug, debug_error, debug_warn, error, implement, info, result::FlatOk, trace, warn,
+};
 
 use super::key_exists;
 

src/service/server_keys/get.rs

@@ -1,10 +1,10 @@
 use std::borrow::Borrow;
 
-use conduwuit::{Err, Result, implement};
 use ruma::{
 	CanonicalJsonObject, RoomVersionId, ServerName, ServerSigningKeyId,
 	api::federation::discovery::VerifyKey,
 };
+use tuwunel_core::{Err, Result, implement};
 
 use super::{PubKeyMap, PubKeys, extract_key};
 

src/service/server_keys/keypair.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
-use conduwuit::{Result, debug, debug_info, err, error, utils, utils::string_from_bytes};
-use database::Database;
 use ruma::{api::federation::discovery::VerifyKey, serde::Base64, signatures::Ed25519KeyPair};
+use tuwunel_core::{Result, debug, debug_info, err, error, utils, utils::string_from_bytes};
+use tuwunel_database::Database;
 
 use super::VerifyKeys;
 

src/service/server_keys/mod.rs

@@ -7,11 +7,6 @@ mod verify;
 
 use std::{collections::BTreeMap, sync::Arc, time::Duration};
 
-use conduwuit::{
-	Result, Server, implement,
-	utils::{IterStream, timepoint_from_now},
-};
-use database::{Deserialized, Json, Map};
 use futures::StreamExt;
 use ruma::{
 	CanonicalJsonObject, MilliSecondsSinceUnixEpoch, OwnedServerSigningKeyId, RoomVersionId,
@@ -21,6 +16,11 @@ use ruma::{
 	signatures::{Ed25519KeyPair, PublicKeyMap, PublicKeySet},
 };
 use serde_json::value::RawValue as RawJsonValue;
+use tuwunel_core::{
+	Result, Server, implement,
+	utils::{IterStream, timepoint_from_now},
+};
+use tuwunel_database::{Deserialized, Json, Map};
 
 use crate::{Dep, globals, sending};
 

src/service/server_keys/request.rs

@@ -1,6 +1,5 @@
 use std::{collections::BTreeMap, fmt::Debug};
 
-use conduwuit::{Err, Result, debug, implement};
 use ruma::{
 	OwnedServerName, OwnedServerSigningKeyId, ServerName, ServerSigningKeyId,
 	api::federation::discovery::{
@@ -9,6 +8,7 @@ use ruma::{
 		get_server_keys,
 	},
 };
+use tuwunel_core::{Err, Result, debug, implement};
 
 #[implement(super::Service)]
 pub(super) async fn batch_notary_request<'a, S, K>(

src/service/server_keys/sign.rs

@@ -1,5 +1,5 @@
-use conduwuit::{Result, implement};
 use ruma::{CanonicalJsonObject, RoomVersionId};
+use tuwunel_core::{Result, implement};
 
 #[implement(super::Service)]
 pub fn sign_json(&self, object: &mut CanonicalJsonObject) -> Result {

src/service/server_keys/verify.rs

@@ -1,8 +1,8 @@
-use conduwuit::{Err, Result, implement, pdu::gen_event_id_canonical_json};
 use ruma::{
 	CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, RoomVersionId, signatures::Verified,
 };
 use serde_json::value::RawValue as RawJsonValue;
+use tuwunel_core::{Err, Result, implement, pdu::gen_event_id_canonical_json};
 
 #[implement(super::Service)]
 pub async fn validate_and_add_event_id(

src/service/service.rs

@@ -7,8 +7,10 @@ use std::{
 };
 
 use async_trait::async_trait;
-use conduwuit::{Err, Result, Server, err, error::inspect_log, utils::string::SplitInfallible};
-use database::Database;
+use tuwunel_core::{
+	Err, Result, Server, err, error::inspect_log, utils::string::SplitInfallible,
+};
+use tuwunel_database::Database;
 
 /// Abstract interface for a Service
 #[async_trait]

src/service/services.rs

@@ -4,10 +4,10 @@ use std::{
 	sync::{Arc, RwLock},
 };
 
-use conduwuit::{Result, Server, debug, debug_info, info, trace, utils::stream::IterStream};
-use database::Database;
 use futures::{Stream, StreamExt, TryStreamExt};
 use tokio::sync::Mutex;
+use tuwunel_core::{Result, Server, debug, debug_info, info, trace, utils::stream::IterStream};
+use tuwunel_database::Database;
 
 use crate::{
 	account_data, admin, appservice, client, config, emergency, federation, globals, key_backups,

src/service/sync/mod.rs

@@ -5,8 +5,6 @@ use std::{
 	sync::{Arc, Mutex, Mutex as StdMutex},
 };
 
-use conduwuit::{Result, Server};
-use database::Map;
 use ruma::{
 	OwnedDeviceId, OwnedRoomId, OwnedUserId,
 	api::client::sync::sync_events::{
@@ -15,6 +13,8 @@ use ruma::{
 		v5,
 	},
 };
+use tuwunel_core::{Result, Server};
+use tuwunel_database::Map;
 
 use crate::{Dep, rooms};
 

src/service/sync/watch.rs

@@ -1,6 +1,6 @@
-use conduwuit::{Result, implement, trace};
 use futures::{FutureExt, StreamExt, pin_mut, stream::FuturesUnordered};
 use ruma::{DeviceId, UserId};
+use tuwunel_core::{Result, implement, trace};
 
 #[implement(super::Service)]
 #[tracing::instrument(skip(self), level = "debug")]

src/service/transaction_ids/mod.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
-use conduwuit::{Result, implement};
-use database::{Handle, Map};
 use ruma::{DeviceId, TransactionId, UserId};
+use tuwunel_core::{Result, implement};
+use tuwunel_database::{Handle, Map};
 
 pub struct Service {
 	db: Data,

src/service/uiaa/mod.rs

@@ -3,11 +3,6 @@ use std::{
 	sync::{Arc, RwLock},
 };
 
-use conduwuit::{
-	Err, Error, Result, err, error, implement, utils,
-	utils::{hash, string::EMPTY},
-};
-use database::{Deserialized, Json, Map};
 use ruma::{
 	CanonicalJsonValue, DeviceId, OwnedDeviceId, OwnedUserId, UserId,
 	api::client::{
@@ -15,6 +10,11 @@ use ruma::{
 		uiaa::{AuthData, AuthType, Password, UiaaInfo, UserIdentifier},
 	},
 };
+use tuwunel_core::{
+	Err, Error, Result, err, error, implement, utils,
+	utils::{hash, string::EMPTY},
+};
+use tuwunel_database::{Deserialized, Json, Map};
 
 use crate::{Dep, config, globals, users};
 

src/service/users/mod.rs

@@ -1,10 +1,5 @@
 use std::{collections::BTreeMap, mem, sync::Arc};
 
-use conduwuit::{
-	Err, Error, Result, Server, at, debug_warn, err, trace,
-	utils::{self, ReadyExt, stream::TryIgnore, string::Unquoted},
-};
-use database::{Deserialized, Ignore, Interfix, Json, Map};
 use futures::{Stream, StreamExt, TryFutureExt};
 use ruma::{
 	DeviceId, KeyId, MilliSecondsSinceUnixEpoch, OneTimeKeyAlgorithm, OneTimeKeyId,
@@ -17,6 +12,11 @@ use ruma::{
 	serde::Raw,
 };
 use serde_json::json;
+use tuwunel_core::{
+	Err, Error, Result, Server, at, debug_warn, err, trace,
+	utils::{self, ReadyExt, stream::TryIgnore, string::Unquoted},
+};
+use tuwunel_database::{Deserialized, Ignore, Interfix, Json, Map};
 
 use crate::{Dep, account_data, admin, globals, rooms};