diff --git a/fluxer_admin/build.rs b/fluxer_admin/build.rs
index c2b2ebca9..2a72153b3 100644
--- a/fluxer_admin/build.rs
+++ b/fluxer_admin/build.rs
@@ -41,6 +41,11 @@ fn generate_admin_api(manifest_dir: &Path, out_dir: &Path) {
 
     let mut settings = progenitor::GenerationSettings::new();
     settings.with_interface(progenitor::InterfaceStyle::Positional);
+    settings.with_inner_type(
+        "reqwest::header::HeaderMap"
+            .parse()
+            .expect("valid generated client header type"),
+    );
 
     let mut generator = progenitor::Generator::new(&settings);
     let tokens = generator
diff --git a/fluxer_admin/src/api/audit.rs b/fluxer_admin/src/api/audit.rs
index 47013ac0b..b10983402 100644
--- a/fluxer_admin/src/api/audit.rs
+++ b/fluxer_admin/src/api/audit.rs
@@ -13,7 +13,7 @@ pub struct SearchAuditLogsParams {
     pub sort_by: Option<String>,
     pub sort_order: Option<String>,
     pub limit: u32,
-    pub offset: u32,
+    pub offset: u64,
 }
 
 impl AdminApiClient {
diff --git a/fluxer_admin/src/api/bans.rs b/fluxer_admin/src/api/bans.rs
index 80c411eeb..cdd43fa20 100644
--- a/fluxer_admin/src/api/bans.rs
+++ b/fluxer_admin/src/api/bans.rs
@@ -6,7 +6,7 @@ use super::client::{AdminApiClient, ApiError, ApiResult};
 use super::types::{BanAvatarResult, BanCheckResult, BulkBanResult};
 
 impl AdminApiClient {
-    pub async fn ban_email(&self, email: &str) -> ApiResult<()> {
+    pub async fn ban_email(&self, email: &str, audit_log_reason: Option<&str>) -> ApiResult<()> {
         self.create_blocklist_entry(
             "email",
             generated_types::AdminBlocklistEntryCreateRequest {
@@ -15,50 +15,63 @@ impl AdminApiClient {
                 }),
                 ..Default::default()
             },
+            audit_log_reason,
         )
         .await
     }
 
-    pub async fn unban_email(&self, email: &str) -> ApiResult<()> {
-        self.delete_blocklist_entry("email", email, None).await
+    pub async fn unban_email(&self, email: &str, audit_log_reason: Option<&str>) -> ApiResult<()> {
+        self.delete_blocklist_entry("email", email, None, audit_log_reason)
+            .await
     }
 
     pub async fn check_email_ban(&self, email: &str) -> ApiResult<BanCheckResult> {
         self.check_blocklist_entry("email", email, None).await
     }
 
-    pub async fn ban_ip(&self, ip: &str) -> ApiResult<()> {
+    pub async fn ban_ip(&self, ip: &str, audit_log_reason: Option<&str>) -> ApiResult<()> {
         self.create_blocklist_entry(
             "ip",
             generated_types::AdminBlocklistEntryCreateRequest {
                 subtype_0: Some(generated_types::BanIpRequest { ip: ip.to_owned() }),
                 ..Default::default()
             },
+            audit_log_reason,
         )
         .await
     }
 
-    pub async fn unban_ip(&self, ip: &str) -> ApiResult<()> {
-        self.delete_blocklist_entry("ip", ip, None).await
+    pub async fn unban_ip(&self, ip: &str, audit_log_reason: Option<&str>) -> ApiResult<()> {
+        self.delete_blocklist_entry("ip", ip, None, audit_log_reason)
+            .await
     }
 
     pub async fn check_ip_ban(&self, ip: &str) -> ApiResult<BanCheckResult> {
         self.check_blocklist_entry("ip", ip, None).await
     }
 
-    pub async fn add_suspicious_email_domain(&self, domain: &str) -> ApiResult<()> {
+    pub async fn add_suspicious_email_domain(
+        &self,
+        domain: &str,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<()> {
         self.create_blocklist_entry(
             SUSPICIOUS_EMAIL_DOMAIN_LIST,
             generated_types::AdminBlocklistEntryCreateRequest {
                 subtype_2: Some(suspicious_email_domain_request(domain)?),
                 ..Default::default()
             },
+            audit_log_reason,
         )
         .await
     }
 
-    pub async fn remove_suspicious_email_domain(&self, domain: &str) -> ApiResult<()> {
-        self.delete_blocklist_entry(SUSPICIOUS_EMAIL_DOMAIN_LIST, domain, None)
+    pub async fn remove_suspicious_email_domain(
+        &self,
+        domain: &str,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<()> {
+        self.delete_blocklist_entry(SUSPICIOUS_EMAIL_DOMAIN_LIST, domain, None, audit_log_reason)
             .await
     }
 
@@ -67,7 +80,7 @@ impl AdminApiClient {
             .await
     }
 
-    pub async fn ban_phrase(&self, phrase: &str) -> ApiResult<()> {
+    pub async fn ban_phrase(&self, phrase: &str, audit_log_reason: Option<&str>) -> ApiResult<()> {
         self.create_blocklist_entry(
             "phrase",
             generated_types::AdminBlocklistEntryCreateRequest {
@@ -76,19 +89,25 @@ impl AdminApiClient {
                 }),
                 ..Default::default()
             },
+            audit_log_reason,
         )
         .await
     }
 
-    pub async fn unban_phrase(&self, phrase: &str) -> ApiResult<()> {
-        self.delete_blocklist_entry("phrase", phrase, None).await
+    pub async fn unban_phrase(
+        &self,
+        phrase: &str,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<()> {
+        self.delete_blocklist_entry("phrase", phrase, None, audit_log_reason)
+            .await
     }
 
     pub async fn check_phrase_ban(&self, phrase: &str) -> ApiResult<BanCheckResult> {
         self.check_blocklist_entry("phrase", phrase, None).await
     }
 
-    pub async fn ban_url(&self, url: &str) -> ApiResult<()> {
+    pub async fn ban_url(&self, url: &str, audit_log_reason: Option<&str>) -> ApiResult<()> {
         self.create_blocklist_entry(
             "url",
             generated_types::AdminBlocklistEntryCreateRequest {
@@ -101,19 +120,26 @@ impl AdminApiClient {
                 }),
                 ..Default::default()
             },
+            audit_log_reason,
         )
         .await
     }
 
-    pub async fn unban_url(&self, url: &str) -> ApiResult<()> {
-        self.delete_blocklist_entry("url", url, None).await
+    pub async fn unban_url(&self, url: &str, audit_log_reason: Option<&str>) -> ApiResult<()> {
+        self.delete_blocklist_entry("url", url, None, audit_log_reason)
+            .await
     }
 
     pub async fn check_url_ban(&self, url: &str) -> ApiResult<BanCheckResult> {
         self.check_blocklist_entry("url", url, None).await
     }
 
-    pub async fn ban_url_domain(&self, domain: &str, match_subdomains: bool) -> ApiResult<()> {
+    pub async fn ban_url_domain(
+        &self,
+        domain: &str,
+        match_subdomains: bool,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<()> {
         self.create_blocklist_entry(
             "url-domain",
             generated_types::AdminBlocklistEntryCreateRequest {
@@ -127,12 +153,17 @@ impl AdminApiClient {
                 }),
                 ..Default::default()
             },
+            audit_log_reason,
         )
         .await
     }
 
-    pub async fn unban_url_domain(&self, domain: &str) -> ApiResult<()> {
-        self.delete_blocklist_entry("url-domain", domain, None)
+    pub async fn unban_url_domain(
+        &self,
+        domain: &str,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<()> {
+        self.delete_blocklist_entry("url-domain", domain, None, audit_log_reason)
             .await
     }
 
@@ -145,20 +176,19 @@ impl AdminApiClient {
         sha256_hex: &str,
         audit_log_reason: Option<&str>,
     ) -> ApiResult<()> {
-        let body = generated_types::AdminBlocklistEntryCreateRequest {
-            subtype_6: Some(generated_types::BanFileShaRequest {
-                category: None,
-                content_type: None,
-                notes: None,
-                severity: None,
-                sha256_hex: sha256_hex.to_owned(),
-                source_url: None,
-            }),
-            ..Default::default()
-        };
-        self.post_void_with_reason(
-            "/admin/blocklists/file-sha/entries",
-            Some(&serde_json::to_value(&body).map_err(|e| ApiError::Parse(e.to_string()))?),
+        self.create_blocklist_entry(
+            "file-sha",
+            generated_types::AdminBlocklistEntryCreateRequest {
+                subtype_6: Some(generated_types::BanFileShaRequest {
+                    category: None,
+                    content_type: None,
+                    notes: None,
+                    severity: None,
+                    sha256_hex: sha256_hex.to_owned(),
+                    source_url: None,
+                }),
+                ..Default::default()
+            },
             audit_log_reason,
         )
         .await
@@ -169,12 +199,8 @@ impl AdminApiClient {
         sha256_hex: &str,
         audit_log_reason: Option<&str>,
     ) -> ApiResult<()> {
-        self.delete_void_with_reason(
-            &blocklist_entry_path("file-sha", sha256_hex),
-            None,
-            audit_log_reason,
-        )
-        .await
+        self.delete_blocklist_entry("file-sha", sha256_hex, None, audit_log_reason)
+            .await
     }
 
     pub async fn check_file_sha_ban(&self, sha256_hex: &str) -> ApiResult<BanCheckResult> {
@@ -198,7 +224,11 @@ impl AdminApiClient {
         .await
     }
 
-    pub async fn ban_avatar_hash(&self, hash_short: &str) -> ApiResult<()> {
+    pub async fn ban_avatar_hash(
+        &self,
+        hash_short: &str,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<()> {
         self.create_blocklist_entry(
             "avatar-hash",
             generated_types::AdminBlocklistEntryCreateRequest {
@@ -212,12 +242,17 @@ impl AdminApiClient {
                 }),
                 ..Default::default()
             },
+            audit_log_reason,
         )
         .await
     }
 
-    pub async fn unban_avatar_hash(&self, hash_short: &str) -> ApiResult<()> {
-        self.delete_blocklist_entry("avatar-hash", hash_short, None)
+    pub async fn unban_avatar_hash(
+        &self,
+        hash_short: &str,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<()> {
+        self.delete_blocklist_entry("avatar-hash", hash_short, None, audit_log_reason)
             .await
     }
 
@@ -236,20 +271,36 @@ impl AdminApiClient {
         self.generated_value(response.into_inner())
     }
 
-    pub async fn ban_profile_substring(&self, scope: &str, substring: &str) -> ApiResult<()> {
+    pub async fn ban_profile_substring(
+        &self,
+        scope: &str,
+        substring: &str,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<()> {
         self.create_blocklist_entry(
             PROFILE_SUBSTRING_LIST,
             generated_types::AdminBlocklistEntryCreateRequest {
                 subtype_8: Some(profile_substring_request(scope, substring)?),
                 ..Default::default()
             },
+            audit_log_reason,
         )
         .await
     }
 
-    pub async fn unban_profile_substring(&self, scope: &str, substring: &str) -> ApiResult<()> {
-        self.delete_blocklist_entry(PROFILE_SUBSTRING_LIST, substring, Some(scope))
-            .await
+    pub async fn unban_profile_substring(
+        &self,
+        scope: &str,
+        substring: &str,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<()> {
+        self.delete_blocklist_entry(
+            PROFILE_SUBSTRING_LIST,
+            substring,
+            Some(scope),
+            audit_log_reason,
+        )
+        .await
     }
 
     pub async fn check_profile_substring_ban(
@@ -265,13 +316,14 @@ impl AdminApiClient {
         &self,
         list_type: &str,
         body: generated_types::AdminBlocklistEntryCreateRequest,
+        audit_log_reason: Option<&str>,
     ) -> ApiResult<()> {
         let list_type = blocklist_list_type(list_type)?;
-        self.generated()
+        self.generated_with_reason(audit_log_reason)?
             .create_admin_blocklist_entry(list_type, &body)
             .await
-            .map_err(|e| self.generated_error(e))?;
-        Ok(())
+            .map(drop)
+            .map_err(|error| self.generated_error(error))
     }
 
     async fn delete_blocklist_entry(
@@ -279,14 +331,15 @@ impl AdminApiClient {
         list_type: &str,
         entry_value: &str,
         scope: Option<&str>,
+        audit_log_reason: Option<&str>,
     ) -> ApiResult<()> {
         let list_type = blocklist_list_type(list_type)?;
         let scope = scope.map(blocklist_delete_scope).transpose()?;
-        self.generated()
+        self.generated_with_reason(audit_log_reason)?
             .delete_admin_blocklist_entry(list_type, entry_value, scope)
             .await
-            .map_err(|e| self.generated_error(e))?;
-        Ok(())
+            .map(drop)
+            .map_err(|error| self.generated_error(error))
     }
 
     async fn check_blocklist_entry(
@@ -315,14 +368,6 @@ fn blocklist_list_type(list_type: &str) -> ApiResult<generated_types::AdminBlock
         .map_err(|e| ApiError::Parse(e.to_string()))
 }
 
-fn blocklist_entry_path(list_type: &str, entry_value: &str) -> String {
-    format!(
-        "/admin/blocklists/{}/entries/{}",
-        urlencoding::encode(list_type),
-        urlencoding::encode(entry_value)
-    )
-}
-
 fn blocklist_get_scope(scope: &str) -> ApiResult<generated_types::GetAdminBlocklistEntryScope> {
     generated_types::GetAdminBlocklistEntryScope::try_from(scope)
         .map_err(|e| ApiError::Parse(e.to_string()))
diff --git a/fluxer_admin/src/api/client.rs b/fluxer_admin/src/api/client.rs
index 8b66b3ab6..c4357b36b 100644
--- a/fluxer_admin/src/api/client.rs
+++ b/fluxer_admin/src/api/client.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
+use crate::api::generated::GeneratedClient;
 use crate::{config::AdminConfig, session::Session};
+use progenitor_client::ClientInfo;
 use reqwest::header::{AUTHORIZATION, HeaderMap, HeaderName, HeaderValue};
 use reqwest::{Method, RequestBuilder};
 use serde::Serialize;
@@ -34,46 +36,39 @@ impl<T> ApiResultExt<T> for ApiResult<T> {
 }
 
 pub struct AdminApiClient {
-    http_client: reqwest::Client,
-    generated: crate::api::generated::GeneratedClient,
-    base_url: String,
-    access_token: String,
-    proxy_client_ip_headers: HeaderMap,
+    generated: GeneratedClient,
 }
 
 impl AdminApiClient {
     pub fn new(http_client: &reqwest::Client, config: &AdminConfig, session: &Session) -> Self {
-        let generated_http_client = build_generated_http_client(config, session);
-        let generated = crate::api::generated::GeneratedClient::new_with_client(
+        let generated = GeneratedClient::new_with_client(
             &config.api_endpoint,
-            generated_http_client,
+            http_client.clone(),
+            build_session_headers(config, session),
         );
-        Self {
-            http_client: http_client.clone(),
-            generated,
-            base_url: config.api_endpoint.clone(),
-            access_token: session.access_token.clone(),
-            proxy_client_ip_headers: build_proxy_client_ip_headers(config),
-        }
+        Self { generated }
     }
 
     fn build_url(&self, path: &str, query_params: Option<&[(&str, &str)]>) -> String {
-        let base = format!("{}{}", self.base_url, path);
-        match query_params {
-            None => base,
-            Some(params) => {
-                let filtered: Vec<_> = params.iter().filter(|(_, v)| !v.is_empty()).collect();
-                if filtered.is_empty() {
-                    return base;
-                }
-                let query = filtered
-                    .iter()
-                    .map(|(k, v)| format!("{}={}", urlencoding::encode(k), urlencoding::encode(v)))
-                    .collect::<Vec<_>>()
-                    .join("&");
-                format!("{base}?{query}")
-            }
+        let mut url = format!("{}{}", self.generated.baseurl(), path);
+        let query = query_params
+            .unwrap_or_default()
+            .iter()
+            .filter(|(_, value)| !value.is_empty())
+            .map(|(key, value)| {
+                format!(
+                    "{}={}",
+                    urlencoding::encode(key),
+                    urlencoding::encode(value)
+                )
+            })
+            .collect::<Vec<_>>()
+            .join("&");
+        if !query.is_empty() {
+            url.push('?');
+            url.push_str(&query);
         }
+        url
     }
 
     fn request(
@@ -81,30 +76,26 @@ impl AdminApiClient {
         method: Method,
         path: &str,
         query_params: Option<&[(&str, &str)]>,
-    ) -> RequestBuilder {
-        let url = self.build_url(path, query_params);
-        self.http_client
-            .request(method, &url)
-            .header("Authorization", format!("Bearer {}", self.access_token))
-            .header("Content-Type", "application/json")
-            .headers(self.proxy_client_ip_headers.clone())
-    }
-
-    fn with_audit_log_reason(
-        builder: RequestBuilder,
         audit_log_reason: Option<&str>,
-    ) -> RequestBuilder {
-        match audit_log_reason {
-            Some(reason) => builder.header("X-Audit-Log-Reason", reason),
-            None => builder,
-        }
+    ) -> ApiResult<RequestBuilder> {
+        let url = self.build_url(path, query_params);
+        Ok(self
+            .generated
+            .client()
+            .request(method, &url)
+            .header("Content-Type", "application/json")
+            .headers(self.headers_with_reason(audit_log_reason)?))
     }
 
-    fn with_json_body(builder: RequestBuilder, body: Option<&serde_json::Value>) -> RequestBuilder {
-        match body {
-            Some(body) => builder.json(body),
-            None => builder,
+    fn headers_with_reason(&self, audit_log_reason: Option<&str>) -> ApiResult<HeaderMap> {
+        let mut headers = self.generated.inner().clone();
+        if let Some(reason) = audit_log_reason {
+            let mut value = HeaderValue::from_str(reason)
+                .map_err(|_| ApiError::Parse("invalid audit log reason header".to_owned()))?;
+            value.set_sensitive(true);
+            headers.insert("x-audit-log-reason", value);
         }
+        Ok(headers)
     }
 
     async fn send_request(builder: RequestBuilder) -> ApiResult<reqwest::Response> {
@@ -114,12 +105,28 @@ impl AdminApiClient {
             .map_err(|e| ApiError::Network(e.to_string()))
     }
 
+    async fn send_json<B: Serialize + ?Sized>(
+        &self,
+        method: Method,
+        path: &str,
+        body: Option<&B>,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<reqwest::Response> {
+        let builder = self.request(method, path, None, audit_log_reason)?;
+        let builder = match body {
+            Some(body) => builder.json(body),
+            None => builder,
+        };
+        Self::send_request(builder).await
+    }
+
     pub async fn get<T: DeserializeOwned>(
         &self,
         path: &str,
         query_params: Option<&[(&str, &str)]>,
     ) -> ApiResult<T> {
-        let response = Self::send_request(self.request(Method::GET, path, query_params)).await?;
+        let response =
+            Self::send_request(self.request(Method::GET, path, query_params, None)?).await?;
         Self::parse_response(response).await
     }
 
@@ -149,9 +156,9 @@ impl AdminApiClient {
         T: DeserializeOwned,
         B: Serialize + ?Sized,
     {
-        let builder =
-            Self::with_audit_log_reason(self.request(Method::POST, path, None), audit_log_reason);
-        let response = Self::send_request(builder.json(body)).await?;
+        let response = self
+            .send_json(Method::POST, path, Some(body), audit_log_reason)
+            .await?;
         Self::parse_response(response).await
     }
 
@@ -161,9 +168,9 @@ impl AdminApiClient {
         body: Option<&serde_json::Value>,
         audit_log_reason: Option<&str>,
     ) -> ApiResult<T> {
-        let builder =
-            Self::with_audit_log_reason(self.request(Method::POST, path, None), audit_log_reason);
-        let response = Self::send_request(Self::with_json_body(builder, body)).await?;
+        let response = self
+            .send_json(Method::POST, path, body, audit_log_reason)
+            .await?;
         Self::parse_response(response).await
     }
 
@@ -177,9 +184,9 @@ impl AdminApiClient {
         body: Option<&serde_json::Value>,
         audit_log_reason: Option<&str>,
     ) -> ApiResult<()> {
-        let builder =
-            Self::with_audit_log_reason(self.request(Method::POST, path, None), audit_log_reason);
-        let response = Self::send_request(Self::with_json_body(builder, body)).await?;
+        let response = self
+            .send_json(Method::POST, path, body, audit_log_reason)
+            .await?;
         Self::parse_void_response(response).await
     }
 
@@ -197,9 +204,9 @@ impl AdminApiClient {
         body: Option<&serde_json::Value>,
         audit_log_reason: Option<&str>,
     ) -> ApiResult<T> {
-        let builder =
-            Self::with_audit_log_reason(self.request(Method::PATCH, path, None), audit_log_reason);
-        let response = Self::send_request(Self::with_json_body(builder, body)).await?;
+        let response = self
+            .send_json(Method::PATCH, path, body, audit_log_reason)
+            .await?;
         Self::parse_response(response).await
     }
 
@@ -213,9 +220,9 @@ impl AdminApiClient {
         T: DeserializeOwned,
         B: Serialize + ?Sized,
     {
-        let builder =
-            Self::with_audit_log_reason(self.request(Method::PATCH, path, None), audit_log_reason);
-        let response = Self::send_request(builder.json(body)).await?;
+        let response = self
+            .send_json(Method::PATCH, path, Some(body), audit_log_reason)
+            .await?;
         Self::parse_response(response).await
     }
 
@@ -225,9 +232,9 @@ impl AdminApiClient {
         body: Option<&serde_json::Value>,
         audit_log_reason: Option<&str>,
     ) -> ApiResult<T> {
-        let builder =
-            Self::with_audit_log_reason(self.request(Method::PUT, path, None), audit_log_reason);
-        let response = Self::send_request(Self::with_json_body(builder, body)).await?;
+        let response = self
+            .send_json(Method::PUT, path, body, audit_log_reason)
+            .await?;
         Self::parse_response(response).await
     }
 
@@ -241,9 +248,9 @@ impl AdminApiClient {
         T: DeserializeOwned,
         B: Serialize + ?Sized,
     {
-        let builder =
-            Self::with_audit_log_reason(self.request(Method::PUT, path, None), audit_log_reason);
-        let response = Self::send_request(builder.json(body)).await?;
+        let response = self
+            .send_json(Method::PUT, path, Some(body), audit_log_reason)
+            .await?;
         Self::parse_response(response).await
     }
 
@@ -253,9 +260,9 @@ impl AdminApiClient {
         body: Option<&serde_json::Value>,
         audit_log_reason: Option<&str>,
     ) -> ApiResult<()> {
-        let builder =
-            Self::with_audit_log_reason(self.request(Method::PUT, path, None), audit_log_reason);
-        let response = Self::send_request(Self::with_json_body(builder, body)).await?;
+        let response = self
+            .send_json(Method::PUT, path, body, audit_log_reason)
+            .await?;
         Self::parse_void_response(response).await
     }
 
@@ -269,9 +276,9 @@ impl AdminApiClient {
         body: Option<&serde_json::Value>,
         audit_log_reason: Option<&str>,
     ) -> ApiResult<()> {
-        let builder =
-            Self::with_audit_log_reason(self.request(Method::DELETE, path, None), audit_log_reason);
-        let response = Self::send_request(Self::with_json_body(builder, body)).await?;
+        let response = self
+            .send_json(Method::DELETE, path, body, audit_log_reason)
+            .await?;
         Self::parse_void_response(response).await
     }
 
@@ -281,9 +288,9 @@ impl AdminApiClient {
         body: Option<&serde_json::Value>,
         audit_log_reason: Option<&str>,
     ) -> ApiResult<T> {
-        let builder =
-            Self::with_audit_log_reason(self.request(Method::DELETE, path, None), audit_log_reason);
-        let response = Self::send_request(Self::with_json_body(builder, body)).await?;
+        let response = self
+            .send_json(Method::DELETE, path, body, audit_log_reason)
+            .await?;
         Self::parse_response(response).await
     }
 
@@ -302,10 +309,21 @@ impl AdminApiClient {
         Err(ApiError::Http { status, message })
     }
 
-    pub(crate) fn generated(&self) -> &crate::api::generated::GeneratedClient {
+    pub(crate) fn generated(&self) -> &GeneratedClient {
         &self.generated
     }
 
+    pub(crate) fn generated_with_reason(
+        &self,
+        audit_log_reason: Option<&str>,
+    ) -> ApiResult<GeneratedClient> {
+        Ok(GeneratedClient::new_with_client(
+            self.generated.baseurl(),
+            self.generated.client().clone(),
+            self.headers_with_reason(audit_log_reason)?,
+        ))
+    }
+
     pub(crate) fn generated_value<T, U>(&self, value: U) -> ApiResult<T>
     where
         T: DeserializeOwned,
@@ -346,17 +364,14 @@ impl AdminApiClient {
     }
 }
 
-fn build_generated_http_client(config: &AdminConfig, session: &Session) -> reqwest::Client {
+fn build_session_headers(config: &AdminConfig, session: &Session) -> HeaderMap {
     let mut headers = HeaderMap::new();
-    let auth_value = HeaderValue::from_str(&format!("Bearer {}", session.access_token))
+    let mut auth_value = HeaderValue::from_str(&format!("Bearer {}", session.access_token))
         .expect("failed to build generated API Authorization header");
+    auth_value.set_sensitive(true);
     headers.insert(AUTHORIZATION, auth_value);
     headers.extend(build_proxy_client_ip_headers(config));
-    reqwest::Client::builder()
-        .user_agent(format!("FluxerAdmin/{} (Rust)", config.build_version))
-        .default_headers(headers)
-        .build()
-        .expect("failed to create generated API HTTP client")
+    headers
 }
 
 pub(crate) fn with_proxy_client_ip_header(
diff --git a/fluxer_admin/src/api/codes.rs b/fluxer_admin/src/api/codes.rs
index 607560e91..80b211d4c 100644
--- a/fluxer_admin/src/api/codes.rs
+++ b/fluxer_admin/src/api/codes.rs
@@ -9,7 +9,7 @@ impl AdminApiClient {
     pub async fn generate_gift_codes(
         &self,
         count: u32,
-        duration_type: &str,
+        duration_type: generated_types::GiftCodeDurationTypeSchema,
         duration_quantity: u32,
     ) -> ApiResult<CodesResponse> {
         let body = generated_types::GenerateGiftCodesRequest {
@@ -22,8 +22,7 @@ impl AdminApiClient {
             )
             .map_err(ApiError::Parse)?
             .into(),
-            duration_type: generated_types::GiftCodeDurationTypeSchema::try_from(duration_type)
-                .map_err(|e| ApiError::Parse(e.to_string()))?,
+            duration_type,
         };
         let response = self
             .generated()
diff --git a/fluxer_admin/src/api/generated.rs b/fluxer_admin/src/api/generated.rs
index 58817c5c8..46e97962a 100644
--- a/fluxer_admin/src/api/generated.rs
+++ b/fluxer_admin/src/api/generated.rs
@@ -1,5 +1,8 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
+use progenitor_client::{ClientHooks, ClientInfo, Error, OperationInfo};
+use reqwest::header::HeaderMap;
+
 #[allow(
     clippy::all,
     unused_imports,
@@ -16,6 +19,20 @@ pub use inner::types;
 
 pub use inner::Client as GeneratedClient;
 
+impl ClientHooks<HeaderMap> for GeneratedClient {
+    async fn pre<E>(
+        &self,
+        request: &mut reqwest::Request,
+        _info: &OperationInfo,
+    ) -> Result<(), Error<E>> {
+        let headers = request.headers_mut();
+        for (name, value) in self.inner() {
+            headers.entry(name.clone()).or_insert_with(|| value.clone());
+        }
+        Ok(())
+    }
+}
+
 pub(crate) fn snowflake(value: &str) -> types::SnowflakeType {
     types::SnowflakeType::Variant0(value.to_owned())
 }
diff --git a/fluxer_admin/src/api/guilds.rs b/fluxer_admin/src/api/guilds.rs
index e3d659dd5..f1731b7c3 100644
--- a/fluxer_admin/src/api/guilds.rs
+++ b/fluxer_admin/src/api/guilds.rs
@@ -16,7 +16,7 @@ impl AdminApiClient {
         &self,
         query: &str,
         limit: u32,
-        offset: u32,
+        offset: u64,
     ) -> ApiResult<SearchGuildsResponse> {
         let limit = limit.to_string();
         let offset = offset.to_string();
@@ -97,7 +97,7 @@ impl AdminApiClient {
         &self,
         guild_id: &str,
         limit: u32,
-        offset: u32,
+        offset: u64,
     ) -> ApiResult<ListGuildMembersResponse> {
         let limit = limit.to_string();
         let offset = offset.to_string();
@@ -252,7 +252,7 @@ impl AdminApiClient {
         &self,
         guild_id: &str,
         limit: u32,
-        offset: u32,
+        offset: u64,
     ) -> ApiResult<SearchReportsResponse> {
         self.search_reports(&SearchReportsParams {
             reported_guild_id: Some(guild_id),
diff --git a/fluxer_admin/src/api/jobs.rs b/fluxer_admin/src/api/jobs.rs
index 47014790b..04a801239 100644
--- a/fluxer_admin/src/api/jobs.rs
+++ b/fluxer_admin/src/api/jobs.rs
@@ -24,9 +24,9 @@ impl AdminApiClient {
         let max_lookback_days = params.max_lookback_days.to_string();
         let query_params = [
             ("limit", limit.as_str()),
-            ("cursor_bucket_day", cursor_bucket_day.as_str()),
-            ("cursor_created_at", cursor_created_at.as_str()),
-            ("cursor_job_id", cursor_job_id.as_str()),
+            ("cursor_bucket_day", cursor_bucket_day),
+            ("cursor_created_at", cursor_created_at),
+            ("cursor_job_id", cursor_job_id),
             ("max_lookback_days", max_lookback_days.as_str()),
             ("status", params.status.as_deref().unwrap_or_default()),
             ("task_type", params.task_type.as_deref().unwrap_or_default()),
@@ -70,10 +70,9 @@ impl AdminApiClient {
     }
 }
 
-fn cursor_field(cursor: Option<&serde_json::Value>, field: &str) -> String {
+fn cursor_field<'a>(cursor: Option<&'a serde_json::Value>, field: &str) -> &'a str {
     cursor
         .and_then(|cursor| cursor.get(field))
         .and_then(serde_json::Value::as_str)
         .unwrap_or_default()
-        .to_owned()
 }
diff --git a/fluxer_admin/src/api/reports.rs b/fluxer_admin/src/api/reports.rs
index c98afe57d..83940c5b5 100644
--- a/fluxer_admin/src/api/reports.rs
+++ b/fluxer_admin/src/api/reports.rs
@@ -22,7 +22,7 @@ pub struct SearchReportsParams<'a> {
     pub sort_by: Option<&'a str>,
     pub sort_order: Option<&'a str>,
     pub limit: u32,
-    pub offset: u32,
+    pub offset: u64,
 }
 
 impl AdminApiClient {
@@ -129,7 +129,7 @@ impl AdminApiClient {
         &self,
         reporter_id: &str,
         limit: u32,
-        offset: u32,
+        offset: u64,
     ) -> ApiResult<SearchReportsResponse> {
         self.search_reports(&SearchReportsParams {
             reporter_id: Some(reporter_id),
@@ -144,7 +144,7 @@ impl AdminApiClient {
         &self,
         reported_user_id: &str,
         limit: u32,
-        offset: u32,
+        offset: u64,
     ) -> ApiResult<SearchReportsResponse> {
         self.search_reports(&SearchReportsParams {
             reported_user_id: Some(reported_user_id),
diff --git a/fluxer_admin/src/api/types/common.rs b/fluxer_admin/src/api/types/common.rs
index c25dd4421..e54d404ad 100644
--- a/fluxer_admin/src/api/types/common.rs
+++ b/fluxer_admin/src/api/types/common.rs
@@ -6,8 +6,14 @@ pub fn deserialize_discriminator<'de, D: Deserializer<'de>>(d: D) -> Result<Stri
     let v: serde_json::Value = Deserialize::deserialize(d)?;
     match v {
         serde_json::Value::String(s) => Ok(format!("{:0>4}", s)),
-        serde_json::Value::Number(n) => Ok(format!("{:04}", n.as_u64().unwrap_or(0))),
-        _ => Ok("0000".to_owned()),
+        serde_json::Value::Number(n) => n
+            .as_u64()
+            .map(|value| format!("{value:04}"))
+            .ok_or_else(|| serde::de::Error::custom("expected an unsigned integer discriminator")),
+        serde_json::Value::Null => Ok("0000".to_owned()),
+        _ => Err(serde::de::Error::custom(
+            "expected string or unsigned integer discriminator",
+        )),
     }
 }
 
@@ -15,7 +21,9 @@ pub fn deserialize_string_or_u64<'de, D: Deserializer<'de>>(d: D) -> Result<u64,
     let v: serde_json::Value = Deserialize::deserialize(d)?;
     match v {
         serde_json::Value::String(s) => s.parse::<u64>().map_err(serde::de::Error::custom),
-        serde_json::Value::Number(n) => Ok(n.as_u64().unwrap_or(0)),
+        serde_json::Value::Number(n) => n
+            .as_u64()
+            .ok_or_else(|| serde::de::Error::custom("expected an unsigned 64-bit integer")),
         serde_json::Value::Null => Ok(0),
         _ => Err(serde::de::Error::custom("expected string or number")),
     }
diff --git a/fluxer_admin/src/api/users.rs b/fluxer_admin/src/api/users.rs
index bf2e0f882..6e67665b6 100644
--- a/fluxer_admin/src/api/users.rs
+++ b/fluxer_admin/src/api/users.rs
@@ -15,7 +15,7 @@ impl AdminApiClient {
         email: Option<&str>,
         last_active_ip: Option<&str>,
         limit: u32,
-        offset: u32,
+        offset: u64,
     ) -> ApiResult<SearchUsersResponse> {
         let limit = limit.to_string();
         let offset = offset.to_string();
@@ -35,7 +35,8 @@ impl AdminApiClient {
         let response = response.into_inner();
         Ok(SearchUsersResponse {
             users: self.generated_value(response.users)?,
-            total: response.total as u64,
+            total: crate::api::generated::number_to_u64(response.total, "total")
+                .map_err(ApiError::Parse)?,
         })
     }
 
@@ -426,6 +427,7 @@ impl AdminApiClient {
         reason_code: i32,
         public_reason: Option<&str>,
         days_until_deletion: u32,
+        audit_log_reason: Option<&str>,
     ) -> ApiResult<AdminUser> {
         let body = generated_types::AdminUserDeletionScheduleRequest {
             days_until_deletion: crate::api::generated::nonzero_u32(
@@ -439,10 +441,10 @@ impl AdminApiClient {
                 .map_err(ApiError::Parse)?,
         };
         let response = self
-            .generated()
+            .generated_with_reason(audit_log_reason)?
             .schedule_admin_user_deletion(&snowflake(user_id), &body)
             .await
-            .map_err(|e| self.generated_error(e))?;
+            .map_err(|error| self.generated_error(error))?;
         let resp: UserMutationResponse = self.generated_value(response.into_inner())?;
         Ok(resp.user)
     }
diff --git a/fluxer_admin/src/routes/admin.rs b/fluxer_admin/src/routes/admin.rs
index 34dce3162..a7dd4371a 100644
--- a/fluxer_admin/src/routes/admin.rs
+++ b/fluxer_admin/src/routes/admin.rs
@@ -81,7 +81,7 @@ async fn admin_api_keys_post(
         "create" => {
             let name = form.clean("name").unwrap_or_default();
             let acls = form.list_values_any(&["acls[]", "acls"]);
-            return match client.create_api_key(&name, &acls).await {
+            match client.create_api_key(&name, &acls).await {
                 Ok(created) => {
                     let keys = client
                         .list_api_keys()
@@ -107,29 +107,38 @@ async fn admin_api_keys_post(
                         is_htmx,
                     )
                 }
-            };
-        }
-        "revoke" => {
-            if let Some(key_id) = form.clean("key_id") {
-                let result = client.revoke_api_key(&key_id).await;
-                let flash = match result.log_error("revoke API key") {
-                    Some(_) => FlashData::success("API key revoked."),
-                    None => FlashData::error("Failed to revoke API key"),
-                };
-                return flash::redirect_with_flash(
-                    &format!("{base}/admin-api-keys"),
-                    flash,
-                    config.secure_cookies(),
-                );
             }
         }
-        _ => {}
+        "revoke" => {
+            let Some(key_id) = form.clean("key_id") else {
+                return admin_api_key_flash_response(
+                    config,
+                    FlashData::error("API key ID is required"),
+                    is_htmx,
+                );
+            };
+            let result = client.revoke_api_key(&key_id).await;
+            let flash = match result.log_error("revoke API key") {
+                Some(_) => FlashData::success("API key revoked."),
+                None => FlashData::error("Failed to revoke API key"),
+            };
+            flash::redirect_with_flash(
+                &format!("{base}/admin-api-keys"),
+                flash,
+                config.secure_cookies(),
+            )
+        }
+        "" => admin_api_key_flash_response(
+            config,
+            FlashData::error("API key action is required"),
+            is_htmx,
+        ),
+        _ => admin_api_key_flash_response(
+            config,
+            FlashData::error("Unknown API key action"),
+            is_htmx,
+        ),
     }
-    flash::redirect_with_flash(
-        &format!("{base}/admin-api-keys"),
-        FlashData::success(format!("API key action '{action}' completed.")),
-        config.secure_cookies(),
-    )
 }
 
 fn admin_api_key_flash_response(
diff --git a/fluxer_admin/src/routes/bans.rs b/fluxer_admin/src/routes/bans.rs
index ec9a7c26c..f718d3f17 100644
--- a/fluxer_admin/src/routes/bans.rs
+++ b/fluxer_admin/src/routes/bans.rs
@@ -16,7 +16,7 @@ use axum::{
 
 use super::ActionQuery;
 use super::bans_actions::{
-    BanFormData, custom_flash, execute_ban, extract_value, flash_response, htmx_flash,
+    BanFormData, custom_flash, execute_ban, extract_value, flash_response, render_inline_flash,
 };
 
 pub fn router() -> Router<AppState> {
@@ -105,7 +105,7 @@ async fn generic_ban_post(
         form.audit_log_reason.as_deref(),
     )
     .await;
-    flash_response(config, auth, is_htmx, &level, &msg, ban_cfg, csrf_token)
+    flash_response(config, auth, is_htmx, level, &msg, ban_cfg, csrf_token)
 }
 
 macro_rules! ban_post {
@@ -171,19 +171,22 @@ async fn url_domain_bans_post(
         Query::try_from_uri(request.uri()).unwrap_or(Query(ActionQuery { action: None }));
     let form: BanFormData = match Form::from_request(request, &state).await {
         Ok(Form(f)) => f,
-        Err(_) => return htmx_flash("error", "Invalid form data", &headers),
+        Err(_) => return render_inline_flash("error", "Invalid form data"),
     };
     let is_htmx = htmx::is_htmx_request(&headers);
     let client = AdminApiClient::new(state.http_client(), config, &auth.0.session);
     let domain = form.domain.as_deref().unwrap_or("").trim().to_owned();
     if domain.is_empty() {
-        return htmx_flash("error", "Domain is required", &headers);
+        return render_inline_flash("error", "Domain is required");
     }
     let action = aq.action.as_deref().unwrap_or("");
     let (level, msg) = match action {
         "ban" => {
             let m_sub = form.match_subdomains.as_deref() == Some("true");
-            match client.ban_url_domain(&domain, m_sub).await {
+            match client
+                .ban_url_domain(&domain, m_sub, form.audit_log_reason.as_deref())
+                .await
+            {
                 Ok(()) => ("success", format!("Domain {domain} banned successfully")),
                 Err(error) => {
                     tracing::warn!(%error, domain, "admin API request failed: ban URL domain");
@@ -191,7 +194,10 @@ async fn url_domain_bans_post(
                 }
             }
         }
-        "unban" => match client.unban_url_domain(&domain).await {
+        "unban" => match client
+            .unban_url_domain(&domain, form.audit_log_reason.as_deref())
+            .await
+        {
             Ok(()) => ("success", format!("Domain {domain} unbanned")),
             Err(error) => {
                 tracing::warn!(%error, domain, "admin API request failed: unban URL domain");
@@ -247,25 +253,31 @@ async fn profile_substring_bans_post(
         Query::try_from_uri(request.uri()).unwrap_or(Query(ActionQuery { action: None }));
     let form: BanFormData = match Form::from_request(request, &state).await {
         Ok(Form(f)) => f,
-        Err(_) => return htmx_flash("error", "Invalid form data", &headers),
+        Err(_) => return render_inline_flash("error", "Invalid form data"),
     };
     let is_htmx = htmx::is_htmx_request(&headers);
     let client = AdminApiClient::new(state.http_client(), config, &auth.0.session);
     let scope = form.scope.as_deref().unwrap_or("").trim().to_owned();
     let substring = form.substring.as_deref().unwrap_or("").trim().to_owned();
     if scope.is_empty() || substring.is_empty() {
-        return htmx_flash("error", "Scope and substring required", &headers);
+        return render_inline_flash("error", "Scope and substring required");
     }
     let action = aq.action.as_deref().unwrap_or("");
     let (level, msg) = match action {
-        "ban" => match client.ban_profile_substring(&scope, &substring).await {
+        "ban" => match client
+            .ban_profile_substring(&scope, &substring, form.audit_log_reason.as_deref())
+            .await
+        {
             Ok(()) => ("success", format!("\"{substring}\" banned for {scope}")),
             Err(error) => {
                 tracing::warn!(%error, scope, substring, "admin API request failed: ban profile substring");
                 ("error", format!("Failed to ban substring for {scope}"))
             }
         },
-        "unban" => match client.unban_profile_substring(&scope, &substring).await {
+        "unban" => match client
+            .unban_profile_substring(&scope, &substring, form.audit_log_reason.as_deref())
+            .await
+        {
             Ok(()) => ("success", format!("\"{substring}\" unbanned for {scope}")),
             Err(error) => {
                 tracing::warn!(%error, scope, substring, "admin API request failed: unban profile substring");
diff --git a/fluxer_admin/src/routes/bans_actions.rs b/fluxer_admin/src/routes/bans_actions.rs
index e073e83b4..2524187e6 100644
--- a/fluxer_admin/src/routes/bans_actions.rs
+++ b/fluxer_admin/src/routes/bans_actions.rs
@@ -1,17 +1,13 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use crate::api::client::AdminApiClient;
+use crate::api::client::{AdminApiClient, ApiResult};
 use crate::api::types::{FlashLevel, FlashMessage};
 use crate::middleware::auth::AuthContext;
 use crate::templates;
-use axum::{
-    http::HeaderMap,
-    response::{Html, IntoResponse, Response},
-};
+use axum::response::{Html, IntoResponse, Response};
 use serde::Deserialize;
 
 #[derive(Deserialize)]
-#[allow(dead_code)]
 pub struct BanFormData {
     #[serde(default)]
     pub ip: Option<String>,
@@ -65,7 +61,7 @@ pub async fn execute_ban(
     bulk_hashes: Option<&str>,
     bulk_sha256_list: Option<&str>,
     audit_log_reason: Option<&str>,
-) -> (String, String) {
+) -> (&'static str, String) {
     if (action == "bulk-ban" || action == "bulk-ban-files") && ban_type == "file-sha-bans" {
         let raw_hashes = if action == "bulk-ban-files" {
             bulk_sha256_list
@@ -75,13 +71,13 @@ pub async fn execute_ban(
         return execute_bulk_ban(client, raw_hashes, audit_log_reason).await;
     }
     if value.is_empty() {
-        return ("error".into(), "Value is required".into());
+        return ("error", "Value is required".into());
     }
     match action {
         "ban" => execute_single_ban(client, ban_type, value, audit_log_reason).await,
         "unban" => execute_single_unban(client, ban_type, value, audit_log_reason).await,
         "check" => execute_check(client, ban_type, value).await,
-        _ => ("error".into(), "Unknown action".into()),
+        _ => ("error", "Unknown action".into()),
     }
 }
 
@@ -89,7 +85,7 @@ async fn execute_bulk_ban(
     client: &AdminApiClient,
     bulk_hashes: Option<&str>,
     audit_log_reason: Option<&str>,
-) -> (String, String) {
+) -> (&'static str, String) {
     let hashes: Vec<String> = bulk_hashes
         .unwrap_or("")
         .split(|c: char| c.is_whitespace() || c == ',' || c == ';')
@@ -98,18 +94,15 @@ async fn execute_bulk_ban(
         .collect();
     if hashes.is_empty() {
         return (
-            "error".into(),
+            "error",
             "No valid 64-character hex hashes found in input".into(),
         );
     }
     match client.bulk_ban_file_shas(&hashes, audit_log_reason).await {
-        Ok(r) => (
-            "success".into(),
-            format!("Bulk ban job created: {}", r.job_id),
-        ),
+        Ok(r) => ("success", format!("Bulk ban job created: {}", r.job_id)),
         Err(error) => {
             tracing::warn!(%error, "admin API request failed: bulk ban file SHAs");
-            ("error".into(), "Failed to enqueue bulk ban job".into())
+            ("error", "Failed to enqueue bulk ban job".into())
         }
     }
 }
@@ -119,29 +112,26 @@ async fn execute_single_ban(
     ban_type: &str,
     value: &str,
     audit_log_reason: Option<&str>,
-) -> (String, String) {
-    let success = format!("{value} banned successfully");
-    let failure = format!("Failed to ban {value}");
-    match ban_type {
-        "ip-bans" => ban_action_result(client.ban_ip(value).await, success, failure),
-        "email-bans" => ban_action_result(client.ban_email(value).await, success, failure),
-        "suspicious-email-domains" => ban_action_result(
-            client.add_suspicious_email_domain(value).await,
-            success,
-            failure,
-        ),
-        "phrase-bans" => ban_action_result(client.ban_phrase(value).await, success, failure),
-        "url-bans" => ban_action_result(client.ban_url(value).await, success, failure),
-        "file-sha-bans" => ban_action_result(
-            client.ban_file_sha(value, audit_log_reason).await,
-            success,
-            failure,
-        ),
-        "avatar-hash-bans" => {
-            ban_action_result(client.ban_avatar_hash(value).await, success, failure)
+) -> (&'static str, String) {
+    let result = match ban_type {
+        "ip-bans" => client.ban_ip(value, audit_log_reason).await,
+        "email-bans" => client.ban_email(value, audit_log_reason).await,
+        "suspicious-email-domains" => {
+            client
+                .add_suspicious_email_domain(value, audit_log_reason)
+                .await
         }
-        _ => ("error".into(), "Unknown ban type".into()),
-    }
+        "phrase-bans" => client.ban_phrase(value, audit_log_reason).await,
+        "url-bans" => client.ban_url(value, audit_log_reason).await,
+        "file-sha-bans" => client.ban_file_sha(value, audit_log_reason).await,
+        "avatar-hash-bans" => client.ban_avatar_hash(value, audit_log_reason).await,
+        _ => return ("error", "Unknown ban type".into()),
+    };
+    ban_action_result(
+        result,
+        format!("{value} banned successfully"),
+        format!("Failed to ban {value}"),
+    )
 }
 
 async fn execute_single_unban(
@@ -149,32 +139,33 @@ async fn execute_single_unban(
     ban_type: &str,
     value: &str,
     audit_log_reason: Option<&str>,
-) -> (String, String) {
-    let success = format!("{value} unbanned successfully");
-    let failure = format!("Failed to unban {value}");
-    match ban_type {
-        "ip-bans" => ban_action_result(client.unban_ip(value).await, success, failure),
-        "email-bans" => ban_action_result(client.unban_email(value).await, success, failure),
-        "suspicious-email-domains" => ban_action_result(
-            client.remove_suspicious_email_domain(value).await,
-            success,
-            failure,
-        ),
-        "phrase-bans" => ban_action_result(client.unban_phrase(value).await, success, failure),
-        "url-bans" => ban_action_result(client.unban_url(value).await, success, failure),
-        "file-sha-bans" => ban_action_result(
-            client.unban_file_sha(value, audit_log_reason).await,
-            success,
-            failure,
-        ),
-        "avatar-hash-bans" => {
-            ban_action_result(client.unban_avatar_hash(value).await, success, failure)
+) -> (&'static str, String) {
+    let result = match ban_type {
+        "ip-bans" => client.unban_ip(value, audit_log_reason).await,
+        "email-bans" => client.unban_email(value, audit_log_reason).await,
+        "suspicious-email-domains" => {
+            client
+                .remove_suspicious_email_domain(value, audit_log_reason)
+                .await
         }
-        _ => ("error".into(), "Unknown ban type".into()),
-    }
+        "phrase-bans" => client.unban_phrase(value, audit_log_reason).await,
+        "url-bans" => client.unban_url(value, audit_log_reason).await,
+        "file-sha-bans" => client.unban_file_sha(value, audit_log_reason).await,
+        "avatar-hash-bans" => client.unban_avatar_hash(value, audit_log_reason).await,
+        _ => return ("error", "Unknown ban type".into()),
+    };
+    ban_action_result(
+        result,
+        format!("{value} unbanned successfully"),
+        format!("Failed to unban {value}"),
+    )
 }
 
-async fn execute_check(client: &AdminApiClient, ban_type: &str, value: &str) -> (String, String) {
+async fn execute_check(
+    client: &AdminApiClient,
+    ban_type: &str,
+    value: &str,
+) -> (&'static str, String) {
     let result = match ban_type {
         "ip-bans" => client.check_ip_ban(value).await,
         "email-bans" => client.check_email_ban(value).await,
@@ -183,28 +174,28 @@ async fn execute_check(client: &AdminApiClient, ban_type: &str, value: &str) ->
         "url-bans" => client.check_url_ban(value).await,
         "file-sha-bans" => client.check_file_sha_ban(value).await,
         "avatar-hash-bans" => client.check_avatar_hash_ban(value).await,
-        _ => return ("error".into(), "Unknown ban type".into()),
+        _ => return ("error", "Unknown ban type".into()),
     };
     match result {
-        Ok(r) if r.banned => ("info".into(), format!("{value} is banned")),
-        Ok(_) => ("info".into(), format!("{value} is NOT banned")),
+        Ok(r) if r.banned => ("info", format!("{value} is banned")),
+        Ok(_) => ("info", format!("{value} is NOT banned")),
         Err(error) => {
             tracing::warn!(%error, ban_type, value, "admin API request failed: check ban status");
-            ("error".into(), "Error checking ban status".into())
+            ("error", "Error checking ban status".into())
         }
     }
 }
 
-fn ban_action_result<T, E: std::fmt::Display>(
-    result: Result<T, E>,
+fn ban_action_result(
+    result: ApiResult<()>,
     success_message: String,
     error_message: String,
-) -> (String, String) {
+) -> (&'static str, String) {
     match result {
-        Ok(_) => ("success".into(), success_message),
+        Ok(()) => ("success", success_message),
         Err(error) => {
             tracing::warn!(%error, "admin API request failed: ban action");
-            ("error".into(), error_message)
+            ("error", error_message)
         }
     }
 }
@@ -228,11 +219,6 @@ pub fn flash_response(
     }
 }
 
-pub fn htmx_flash(level: &str, message: &str, headers: &HeaderMap) -> Response {
-    let _ = headers;
-    render_inline_flash(level, message)
-}
-
 pub fn render_inline_flash(level: &str, message: &str) -> Response {
     let (border, bg, text) = match level {
         "success" => ("border-green-300", "bg-green-50", "text-green-800"),
diff --git a/fluxer_admin/src/routes/codes.rs b/fluxer_admin/src/routes/codes.rs
index 7a7dc2de6..b3e90ac40 100644
--- a/fluxer_admin/src/routes/codes.rs
+++ b/fluxer_admin/src/routes/codes.rs
@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use crate::{
-    api::client::AdminApiClient,
+    api::{client::AdminApiClient, generated::types::GiftCodeDurationTypeSchema},
     middleware::{
         auth::AuthContext,
         csrf::CsrfToken,
         flash::{self, FlashData},
     },
     state::AppState,
-    templates,
+    templates::{self, pages::gift_codes::MAX_GIFT_CODES},
 };
 use axum::{
     Form, Router,
@@ -28,11 +28,11 @@ struct GiftCodesForm {
     #[serde(default)]
     _csrf: Option<String>,
     #[serde(default)]
-    count: Option<String>,
+    count: Option<u32>,
     #[serde(default)]
-    duration_type: Option<String>,
+    duration_type: Option<GiftCodeDurationTypeSchema>,
     #[serde(default)]
-    duration_quantity: Option<String>,
+    duration_quantity: Option<u32>,
 }
 
 pub fn router() -> Router<AppState> {
@@ -86,21 +86,17 @@ async fn gift_codes_post(
             );
         }
     };
-    let count = form
-        .count
-        .as_deref()
-        .and_then(|s| s.parse::<u32>().ok())
-        .unwrap_or(1)
-        .clamp(1, 100);
-    let dur_type = form.duration_type.as_deref().unwrap_or("month");
-    let dur_qty = form
-        .duration_quantity
-        .as_deref()
-        .and_then(|s| s.parse::<u32>().ok())
-        .unwrap_or(1);
+    let count = form.count.unwrap_or(1).clamp(1, MAX_GIFT_CODES);
+    let duration_type = form
+        .duration_type
+        .unwrap_or(GiftCodeDurationTypeSchema::Months);
+    let duration_quantity = form.duration_quantity.unwrap_or(1);
     let client = AdminApiClient::new(state.http_client(), config, &auth.0.session);
     let secure_cookies = config.secure_cookies();
-    match client.generate_gift_codes(count, dur_type, dur_qty).await {
+    match client
+        .generate_gift_codes(count, duration_type, duration_quantity)
+        .await
+    {
         Ok(result) => {
             let codes = result.codes.join(",");
             flash::redirect_with_flash(
diff --git a/fluxer_admin/src/routes/guild_tabs.rs b/fluxer_admin/src/routes/guild_tabs.rs
index 86ecd5c77..619a4c4f0 100644
--- a/fluxer_admin/src/routes/guild_tabs.rs
+++ b/fluxer_admin/src/routes/guild_tabs.rs
@@ -43,7 +43,7 @@ pub async fn render(
             let page = query.members_page.unwrap_or(0);
             let limit: u32 = 50;
             let resp = client
-                .list_guild_members(guild_id, limit, page * limit)
+                .list_guild_members(guild_id, limit, u64::from(page) * u64::from(limit))
                 .await
                 .log_error("load guild members")?;
             Some(tabs::members::members_tab(
@@ -57,7 +57,7 @@ pub async fn render(
             let page = query.reports_page.unwrap_or(0);
             let limit: u32 = 25;
             let resp = client
-                .search_reports_by_guild(guild_id, limit, page * limit)
+                .search_reports_by_guild(guild_id, limit, u64::from(page) * u64::from(limit))
                 .await
                 .log_error("load guild reports")?;
             Some(tabs::reports::reports_tab(
diff --git a/fluxer_admin/src/routes/guilds.rs b/fluxer_admin/src/routes/guilds.rs
index b1575ca41..a3f41c46c 100644
--- a/fluxer_admin/src/routes/guilds.rs
+++ b/fluxer_admin/src/routes/guilds.rs
@@ -82,23 +82,19 @@ async fn guilds_list(
                 }
             }
         }
-        Some((guilds, Some(params.requested_ids.len() as u64), false))
+        Some((guilds, params.requested_ids.len() as u64))
     } else if params.has_search() {
-        let offset = params.page.saturating_mul(params.limit);
+        let offset = u64::from(params.page) * u64::from(params.limit);
         client
             .search_guilds(params.search_query(), params.limit, offset)
             .await
             .log_error("search guilds")
-            .map(|response| {
-                let has_more = u64::from(offset) + (response.guilds.len() as u64) < response.total;
-                (response.guilds, Some(response.total), has_more)
-            })
+            .map(|response| (response.guilds, response.total))
     } else {
         None
     };
     let result_guilds = results.as_ref().map(|result| result.0.as_slice());
-    let total = results.as_ref().and_then(|result| result.1);
-    let has_more = results.as_ref().is_some_and(|result| result.2);
+    let total = results.as_ref().map(|result| result.1);
 
     let markup = templates::pages::guilds_list::guilds_list_page(
         config,
@@ -106,7 +102,6 @@ async fn guilds_list(
         &params,
         result_guilds,
         total,
-        has_more,
         is_results_fragment,
     );
     Html(markup.into_string()).into_response()
@@ -324,8 +319,12 @@ async fn dispatch_guild_action(
                 "default_message_notifications",
                 "disabled_operations",
             ] {
-                if let Some(v) = form.parse_i64(key) {
-                    settings.insert(key.to_string(), serde_json::json!(v));
+                let value = match form.parse_value::<i64>(key) {
+                    Ok(value) => value,
+                    Err(_) => return FlashData::error(format!("Invalid {key} value")),
+                };
+                if let Some(value) = value {
+                    settings.insert(key.to_string(), serde_json::json!(value));
                 }
             }
             if form.contains_key("nsfw_submitted") {
@@ -356,11 +355,12 @@ async fn dispatch_guild_action(
             )
         }
         "update_disabled_operations" => {
-            let disabled_operations = form
-                .list_values_any(&["disabled_operations[]", "disabled_operations"])
-                .iter()
-                .filter_map(|value| value.parse::<i64>().ok())
-                .fold(0_i64, |acc, value| acc | value);
+            let Ok(operations) =
+                form.parse_list_values::<i64>(&["disabled_operations[]", "disabled_operations"])
+            else {
+                return FlashData::error("Invalid disabled operation value");
+            };
+            let disabled_operations = operations.into_iter().fold(0_i64, |acc, value| acc | value);
             let settings = serde_json::json!({
                 "disabled_operations": disabled_operations,
             });
diff --git a/fluxer_admin/src/routes/jobs.rs b/fluxer_admin/src/routes/jobs.rs
index d2f9a37fc..bb04af04c 100644
--- a/fluxer_admin/src/routes/jobs.rs
+++ b/fluxer_admin/src/routes/jobs.rs
@@ -21,7 +21,6 @@ use axum::{
 use serde::Deserialize;
 
 #[derive(Deserialize)]
-#[allow(dead_code)]
 struct JobsQuery {
     status: Option<String>,
     task_type: Option<String>,
@@ -219,49 +218,36 @@ async fn job_detail_post(
 }
 
 fn jobs_url(config: &crate::config::AdminConfig, query: &JobsQuery) -> String {
-    let mut params = Vec::new();
-    push_query(&mut params, "status", query.status.as_deref());
-    push_query(&mut params, "task_type", query.task_type.as_deref());
-    push_query(
-        &mut params,
-        "requested_by_user_id",
-        query.requested_by_user_id.as_deref(),
-    );
-    push_query(
-        &mut params,
-        "max_lookback_days",
-        query.max_lookback_days.as_deref(),
-    );
-    push_query(
-        &mut params,
-        "cursor_bucket_day",
-        query.cursor_bucket_day.as_deref(),
-    );
-    push_query(
-        &mut params,
-        "cursor_created_at",
-        query.cursor_created_at.as_deref(),
-    );
-    push_query(&mut params, "cursor_job_id", query.cursor_job_id.as_deref());
-    if params.is_empty() {
-        return format!("{}/jobs", config.base_path);
-    }
-    let query = params
-        .iter()
-        .map(|(key, value)| {
-            format!(
-                "{}={}",
-                urlencoding::encode(key),
-                urlencoding::encode(value)
-            )
-        })
-        .collect::<Vec<_>>()
-        .join("&");
-    format!("{}/jobs?{query}", config.base_path)
-}
-
-fn push_query(params: &mut Vec<(String, String)>, key: &str, value: Option<&str>) {
-    if let Some(value) = value.filter(|value| !value.is_empty()) {
-        params.push((key.to_owned(), value.to_owned()));
+    let query = [
+        ("status", query.status.as_deref()),
+        ("task_type", query.task_type.as_deref()),
+        (
+            "requested_by_user_id",
+            query.requested_by_user_id.as_deref(),
+        ),
+        ("max_lookback_days", query.max_lookback_days.as_deref()),
+        ("cursor_bucket_day", query.cursor_bucket_day.as_deref()),
+        ("cursor_created_at", query.cursor_created_at.as_deref()),
+        ("cursor_job_id", query.cursor_job_id.as_deref()),
+    ]
+    .into_iter()
+    .filter_map(|(key, value)| {
+        value
+            .filter(|value| !value.is_empty())
+            .map(|value| (key, value))
+    })
+    .map(|(key, value)| {
+        format!(
+            "{}={}",
+            urlencoding::encode(key),
+            urlencoding::encode(value)
+        )
+    })
+    .collect::<Vec<_>>()
+    .join("&");
+    if query.is_empty() {
+        format!("{}/jobs", config.base_path)
+    } else {
+        format!("{}/jobs?{query}", config.base_path)
     }
 }
diff --git a/fluxer_admin/src/routes/message_actions.rs b/fluxer_admin/src/routes/message_actions.rs
index e28b9b916..5d73e462a 100644
--- a/fluxer_admin/src/routes/message_actions.rs
+++ b/fluxer_admin/src/routes/message_actions.rs
@@ -59,53 +59,51 @@ pub(crate) async fn messages_post(
     match action {
         "lookup" => {
             let context_limit = parse_context_limit(form.first("context_limit"));
-            return Redirect::to(&format!(
+            Redirect::to(&format!(
                 "{base}/messages?channel_id={}&message_id={}&context_limit={context_limit}",
                 encode_opt(&channel_id),
                 encode_opt(&message_id)
             ))
-            .into_response();
+            .into_response()
         }
         "lookup-by-attachment" => {
             let attachment_id = form.clean("attachment_id");
             let filename = form.clean("filename");
             let context_limit = parse_context_limit(form.first("context_limit"));
-            return Redirect::to(&format!(
+            Redirect::to(&format!(
                 "{base}/messages?channel_id={}&attachment_id={}&filename={}&context_limit={context_limit}",
                 encode_opt(&channel_id),
                 encode_opt(&attachment_id),
                 encode_opt(&filename)
             ))
-            .into_response();
-        }
-        "browse" => {
-            return Redirect::to(&format!(
-                "{base}/messages?channel_id={}",
-                encode_opt(&channel_id)
-            ))
-            .into_response();
+            .into_response()
         }
+        "browse" => Redirect::to(&format!(
+            "{base}/messages?channel_id={}",
+            encode_opt(&channel_id)
+        ))
+        .into_response(),
         "search" => {
             let search = form.clean("search");
-            return Redirect::to(&format!(
+            Redirect::to(&format!(
                 "{base}/messages?channel_id={}&search={}",
                 encode_opt(&channel_id),
                 encode_opt(&search)
             ))
-            .into_response();
+            .into_response()
         }
         "delete" => {
             let (Some(cid), Some(mid)) = (&channel_id, &message_id) else {
                 return json_error(StatusCode::BAD_REQUEST, "Missing channel_id or message_id");
             };
             let audit_log_reason = form.clean("audit_log_reason");
-            return match client
+            match client
                 .delete_message(cid, mid, audit_log_reason.as_deref())
                 .await
             {
                 Ok(()) => Json(serde_json::json!({"success": true})).into_response(),
                 Err(e) => json_error(StatusCode::BAD_REQUEST, &format!("{e}")),
-            };
+            }
         }
         "report-to-ncmec" => {
             let attachment_id = form.clean("attachment_id");
@@ -131,7 +129,7 @@ pub(crate) async fn messages_post(
                     "Missing required NCMEC report fields",
                 );
             }
-            return match client
+            match client
                 .report_attachment_to_ncmec(
                     cid,
                     mid,
@@ -144,11 +142,10 @@ pub(crate) async fn messages_post(
             {
                 Ok(resp) => Json(resp.data).into_response(),
                 Err(e) => json_error(StatusCode::BAD_REQUEST, &format!("{e}")),
-            };
+            }
         }
-        _ => {}
+        _ => Redirect::to(&format!("{base}/messages")).into_response(),
     }
-    Redirect::to(&format!("{base}/messages")).into_response()
 }
 
 pub(crate) async fn system_dms_post(
@@ -253,14 +250,22 @@ pub(crate) async fn bulk_actions_post(
         }
         "bulk-schedule-user-deletion" | "bulk_delete_users" => {
             let user_ids = form.list_values_any(&["user_ids[]", "user_ids"]);
-            let reason_code = form.parse_u32("reason_code").unwrap_or(2);
-            let days = form.parse_u32("days_until_deletion").unwrap_or(14);
+            let (Ok(reason_code), Ok(days)) = (
+                form.parse_value::<u32>("reason_code"),
+                form.parse_value::<u32>("days_until_deletion"),
+            ) else {
+                return flash::redirect_with_flash(
+                    &format!("{base}/bulk-actions"),
+                    FlashData::error("Invalid deletion reason code or delay"),
+                    config.secure_cookies(),
+                );
+            };
             let public_reason = form.clean("public_reason");
             client
                 .bulk_schedule_user_deletion(
                     &user_ids,
-                    reason_code,
-                    days,
+                    reason_code.unwrap_or(2),
+                    days.unwrap_or(14),
                     public_reason.as_deref(),
                     audit_log_reason.as_deref(),
                 )
@@ -357,7 +362,7 @@ pub(crate) async fn messages_browse_fragment(
     }
 }
 
-fn parse_context_limit(value: Option<&str>) -> u32 {
+pub(super) fn parse_context_limit(value: Option<&str>) -> u32 {
     value
         .and_then(|s| s.parse::<u32>().ok())
         .filter(|n| *n > 0)
diff --git a/fluxer_admin/src/routes/messages.rs b/fluxer_admin/src/routes/messages.rs
index 9ef644209..a8207f0fd 100644
--- a/fluxer_admin/src/routes/messages.rs
+++ b/fluxer_admin/src/routes/messages.rs
@@ -16,7 +16,6 @@ use axum::{
 use serde::Deserialize;
 
 #[derive(Deserialize)]
-#[allow(dead_code)]
 struct MessagesQuery {
     channel_id: Option<String>,
     message_id: Option<String>,
@@ -82,13 +81,7 @@ async fn messages_page(
     let before = query.before.as_deref().filter(|s| !s.is_empty());
     let after = query.after.as_deref().filter(|s| !s.is_empty());
     let search = query.search.as_deref().filter(|s| !s.is_empty());
-    let context_limit = query
-        .context_limit
-        .as_deref()
-        .and_then(|s| s.parse::<u32>().ok())
-        .filter(|n| *n > 0)
-        .unwrap_or(50)
-        .min(100);
+    let context_limit = super::message_actions::parse_context_limit(query.context_limit.as_deref());
     let mut lookup_result = None;
     let mut browse_result = None;
     let mut search_result = None;
diff --git a/fluxer_admin/src/routes/reports.rs b/fluxer_admin/src/routes/reports.rs
index 6770cab2a..9ba227915 100644
--- a/fluxer_admin/src/routes/reports.rs
+++ b/fluxer_admin/src/routes/reports.rs
@@ -26,7 +26,7 @@ use axum::{
 };
 use serde::Deserialize;
 
-const MAX_REPORT_OFFSET: u32 = 10_000;
+const MAX_REPORT_OFFSET: u64 = 10_000;
 
 #[derive(Deserialize)]
 struct ReportsQuery {
@@ -75,7 +75,7 @@ async fn reports_list(
     let config = state.config();
     let page = query.page.unwrap_or(0);
     let limit = query.limit.unwrap_or(25).clamp(1, 200);
-    let offset = page.saturating_mul(limit);
+    let offset = u64::from(page) * u64::from(limit);
     if offset > MAX_REPORT_OFFSET {
         return reports_error_page(
             config,
diff --git a/fluxer_admin/src/routes/system.rs b/fluxer_admin/src/routes/system.rs
index 4e7c1d749..a2048bb04 100644
--- a/fluxer_admin/src/routes/system.rs
+++ b/fluxer_admin/src/routes/system.rs
@@ -17,14 +17,12 @@ use serde::Deserialize;
 use super::system_actions;
 
 #[derive(Deserialize)]
-#[allow(dead_code)]
 struct GatewayQuery {
     leaderboard_limit: Option<String>,
     node_stats: Option<String>,
 }
 
 #[derive(Deserialize)]
-#[allow(dead_code)]
 struct AuditLogsQuery {
     q: Option<String>,
     admin_user_id: Option<String>,
@@ -136,7 +134,7 @@ async fn audit_logs_page(
         sort_by: Some(params.sort_by.to_owned()),
         sort_order: Some(params.sort_order.to_owned()),
         limit,
-        offset: current_page * limit,
+        offset: u64::from(current_page) * u64::from(limit),
     };
     let result = client
         .search_audit_logs(&search_params)
diff --git a/fluxer_admin/src/routes/user_actions.rs b/fluxer_admin/src/routes/user_actions.rs
index f285e8126..0c529d8bd 100644
--- a/fluxer_admin/src/routes/user_actions.rs
+++ b/fluxer_admin/src/routes/user_actions.rs
@@ -60,7 +60,9 @@ pub async fn dispatch(
                     "Failed to update user flags",
                 );
             }
-            let submitted = parse_u64_list(form, &["flags[]", "flags"]);
+            let Ok(submitted) = form.parse_list_values::<u64>(&["flags[]", "flags"]) else {
+                return DispatchOutcome::error("Invalid user flag value");
+            };
             let selected = submitted.iter().copied().collect::<HashSet<_>>();
             let user = match client.get_user_by_id(user_id).await {
                 Ok(user) => user,
@@ -89,15 +91,22 @@ pub async fn dispatch(
         }
         "update_premium_flags" => {
             if has_legacy_flag_delta_fields(form) {
-                let add = parse_i32_list(form, &["add_flags[]", "add_flags"]);
-                let remove = parse_i32_list(form, &["remove_flags[]", "remove_flags"]);
+                let Ok(add) = form.parse_list_values::<i32>(&["add_flags[]", "add_flags"]) else {
+                    return DispatchOutcome::error("Invalid premium flag value to add");
+                };
+                let Ok(remove) = form.parse_list_values::<i32>(&["remove_flags[]", "remove_flags"])
+                else {
+                    return DispatchOutcome::error("Invalid premium flag value to remove");
+                };
                 return DispatchOutcome::from_result(
                     client.update_premium_flags(user_id, &add, &remove).await,
                     "Premium flags updated successfully",
                     "Failed to update premium flags",
                 );
             }
-            let submitted = parse_i32_list(form, &["flags[]", "flags"]);
+            let Ok(submitted) = form.parse_list_values::<i32>(&["flags[]", "flags"]) else {
+                return DispatchOutcome::error("Invalid premium flag value");
+            };
             let selected = submitted.iter().copied().collect::<HashSet<_>>();
             let user = match client.get_user_by_id(user_id).await {
                 Ok(user) => user,
@@ -124,9 +133,12 @@ pub async fn dispatch(
             )
         }
         "update_suspicious_flags" => {
-            let flags = parse_i32_list(form, &["suspicious_flags[]", "suspicious_flags"])
-                .into_iter()
-                .fold(0, |acc, flag| acc | flag);
+            let Ok(submitted) =
+                form.parse_list_values::<i32>(&["suspicious_flags[]", "suspicious_flags"])
+            else {
+                return DispatchOutcome::error("Invalid suspicious activity flag value");
+            };
+            let flags = submitted.into_iter().fold(0, |acc, flag| acc | flag);
             DispatchOutcome::from_result(
                 client.update_suspicious_flags(user_id, flags).await,
                 "Suspicious activity flags updated successfully",
@@ -225,15 +237,19 @@ pub async fn dispatch(
             )
         }
         "temp_ban" => {
-            let dur = form
-                .parse_u32("duration_hours")
-                .or_else(|| form.parse_u32("duration"))
-                .unwrap_or(24);
+            let Ok(duration) = form.parse_value_any::<u32>(&["duration_hours", "duration"]) else {
+                return DispatchOutcome::error("Invalid ban duration");
+            };
             let reason = get("reason");
             let private = get("private_reason");
             DispatchOutcome::from_result(
                 client
-                    .temp_ban_user(user_id, dur, reason.as_deref(), private.as_deref())
+                    .temp_ban_user(
+                        user_id,
+                        duration.unwrap_or(24),
+                        reason.as_deref(),
+                        private.as_deref(),
+                    )
                     .await,
                 "User temporarily banned successfully",
                 "Failed to temporarily ban user",
@@ -249,7 +265,7 @@ pub async fn dispatch(
                 return DispatchOutcome::error("IP address is required");
             };
             DispatchOutcome::from_result(
-                client.ban_ip(&ip).await,
+                client.ban_ip(&ip, None).await,
                 "IP banned successfully",
                 "Failed to ban IP",
             )
@@ -259,18 +275,29 @@ pub async fn dispatch(
                 return DispatchOutcome::error("Avatar hash is required");
             };
             DispatchOutcome::from_result(
-                client.ban_avatar_hash(&hash).await,
+                client.ban_avatar_hash(&hash, None).await,
                 "Avatar hash banned successfully",
                 "Failed to ban avatar hash",
             )
         }
         "schedule_deletion" => {
-            let reason_code = form.parse_i32("reason_code").unwrap_or(0);
+            let Ok(reason_code) = form.parse_value::<i32>("reason_code") else {
+                return DispatchOutcome::error("Invalid deletion reason code");
+            };
             let public_reason = get("public_reason");
-            let days = form.parse_u32("days_until_deletion").unwrap_or(60);
+            let private_reason = get("private_reason");
+            let Ok(days) = form.parse_value_any::<u32>(&["days_until_deletion", "days"]) else {
+                return DispatchOutcome::error("Invalid deletion delay");
+            };
             DispatchOutcome::from_result(
                 client
-                    .schedule_deletion(user_id, reason_code, public_reason.as_deref(), days)
+                    .schedule_deletion(
+                        user_id,
+                        reason_code.unwrap_or(0),
+                        public_reason.as_deref(),
+                        days.unwrap_or(60),
+                        private_reason.as_deref(),
+                    )
                     .await,
                 "User deletion scheduled successfully",
                 "Failed to schedule user deletion",
@@ -441,20 +468,6 @@ fn is_relationship_category(category: &str) -> bool {
     )
 }
 
-fn parse_u64_list(form: &MultiValueForm, keys: &[&str]) -> Vec<u64> {
-    form.list_values_any(keys)
-        .iter()
-        .filter_map(|value| value.parse().ok())
-        .collect()
-}
-
-fn parse_i32_list(form: &MultiValueForm, keys: &[&str]) -> Vec<i32> {
-    form.list_values_any(keys)
-        .iter()
-        .filter_map(|value| value.parse().ok())
-        .collect()
-}
-
 fn parse_dry_run(value: Option<&str>) -> bool {
     !matches!(value.map(|value| value.trim().to_ascii_lowercase()), Some(value) if value == "false" || value == "0")
 }
diff --git a/fluxer_admin/src/routes/user_tabs.rs b/fluxer_admin/src/routes/user_tabs.rs
index d7ebf23f9..30a8e4f76 100644
--- a/fluxer_admin/src/routes/user_tabs.rs
+++ b/fluxer_admin/src/routes/user_tabs.rs
@@ -164,25 +164,29 @@ pub async fn render(
             Some(tabs::guilds::guilds_tab(config, user_id, &g))
         }
         "reports" => {
-            let lim = query.reports_limit.unwrap_or(25);
-            let sp = query.reports_sent_page.unwrap_or(0);
-            let rp = query.reports_received_page.unwrap_or(0);
+            let limit = query.reports_limit.unwrap_or(25);
+            let sent_page = query.reports_sent_page.unwrap_or(0);
+            let received_page = query.reports_received_page.unwrap_or(0);
             let sent = client
-                .search_reports_by_reporter(user_id, lim, sp * lim)
+                .search_reports_by_reporter(user_id, limit, u64::from(sent_page) * u64::from(limit))
                 .await
                 .log_error("load reports sent by user");
-            let recv = client
-                .search_reports_by_reported_user(user_id, lim, rp * lim)
+            let received = client
+                .search_reports_by_reported_user(
+                    user_id,
+                    limit,
+                    u64::from(received_page) * u64::from(limit),
+                )
                 .await
                 .log_error("load reports against user");
             Some(tabs::reports::reports_tab(
                 config,
                 user_id,
                 sent.as_ref(),
-                recv.as_ref(),
-                sp,
-                rp,
-                lim,
+                received.as_ref(),
+                sent_page,
+                received_page,
+                limit,
             ))
         }
         "relationships" => {
@@ -244,7 +248,7 @@ pub async fn render(
                     sort_by: Some("created_at".to_owned()),
                     sort_order: Some("desc".to_owned()),
                     limit,
-                    offset: page * limit,
+                    offset: u64::from(page) * u64::from(limit),
                 })
                 .await
                 .log_error("load user admin audit logs")?;
diff --git a/fluxer_admin/src/routes/users.rs b/fluxer_admin/src/routes/users.rs
index 5f91705b0..2b66a1920 100644
--- a/fluxer_admin/src/routes/users.rs
+++ b/fluxer_admin/src/routes/users.rs
@@ -93,7 +93,7 @@ async fn users_list(
             .log_error("lookup users by ids")
             .map(|users| (users, false))
     } else if params.has_search() {
-        let offset = params.page.saturating_mul(params.limit);
+        let offset = u64::from(params.page) * u64::from(params.limit);
         client
             .search_users(
                 params.search_query(),
@@ -105,7 +105,7 @@ async fn users_list(
             .await
             .log_error("search users")
             .map(|r| {
-                let has_more = u64::from(offset) + (r.users.len() as u64) < r.total;
+                let has_more = (r.users.len() as u64) < r.total.saturating_sub(offset);
                 (r.users, has_more)
             })
     } else {
diff --git a/fluxer_admin/src/templates/components/archive.rs b/fluxer_admin/src/templates/components/archive.rs
index a1d8cc05c..55c0b3a55 100644
--- a/fluxer_admin/src/templates/components/archive.rs
+++ b/fluxer_admin/src/templates/components/archive.rs
@@ -41,17 +41,14 @@ pub fn archives_tab(
     }
 }
 
-fn status_text(archive: &Archive) -> String {
+fn status_text(archive: &Archive) -> &str {
     if archive.failed_at.is_some() {
-        return "Failed".to_owned();
+        return "Failed";
     }
     if archive.completed_at.is_some() {
-        return "Completed".to_owned();
+        return "Completed";
     }
-    archive
-        .progress_step
-        .clone()
-        .unwrap_or_else(|| "In Progress".to_owned())
+    archive.progress_step.as_deref().unwrap_or("In Progress")
 }
 
 fn archives_table(base: &str, archives: &[Archive]) -> Markup {
diff --git a/fluxer_admin/src/templates/components/audit_logs_for_target.rs b/fluxer_admin/src/templates/components/audit_logs_for_target.rs
index 653bfbef6..3d65b70e2 100644
--- a/fluxer_admin/src/templates/components/audit_logs_for_target.rs
+++ b/fluxer_admin/src/templates/components/audit_logs_for_target.rs
@@ -66,9 +66,15 @@ pub fn audit_logs_for_target(
 ) -> Markup {
     let has_previous = current_page > 0;
     let offset = (current_page as u64) * (PAGE_SIZE as u64);
-    let has_next = offset + (entries.len() as u64) < total;
-    let total_pages = ((total as f64) / (PAGE_SIZE as f64)).ceil().max(1.0) as u64;
-    let all_logs_href = format!("{base_path}/audit-logs?target_id={target_id}");
+    let next_page = current_page
+        .checked_add(1)
+        .filter(|_| offset + (entries.len() as u64) < total);
+    let total_pages = total.div_ceil(u64::from(PAGE_SIZE)).max(1);
+    let page_number = u64::from(current_page) + 1;
+    let all_logs_href = format!(
+        "{base_path}/audit-logs?target_id={}",
+        urlencoding::encode(target_id)
+    );
 
     html! {
         div class="rounded-lg bg-white transition-all border border-neutral-200 p-6" {
@@ -108,7 +114,7 @@ pub fn audit_logs_for_target(
                         }))
                     }))
                 }
-                @if has_previous || has_next {
+                @if has_previous || next_page.is_some() {
                     div class="flex items-center justify-center gap-2" {
                         @if has_previous {
                             a href={(tab_href_base) "&audit_logs_page=" (current_page - 1)}
@@ -119,10 +125,10 @@ pub fn audit_logs_for_target(
                             }
                         }
                         span class="text-sm text-neutral-500" {
-                            "Page " (current_page + 1) " of " (total_pages)
+                            "Page " (page_number) " of " (total_pages)
                         }
-                        @if has_next {
-                            a href={(tab_href_base) "&audit_logs_page=" (current_page + 1)}
+                        @if let Some(page) = next_page {
+                            a href={(tab_href_base) "&audit_logs_page=" (page)}
                                 class="inline-flex items-center justify-center gap-2 font-medium \
                                        rounded-lg bg-neutral-50 text-neutral-700 border \
                                        border-neutral-300 px-3 py-1.5 text-sm" {
diff --git a/fluxer_admin/src/templates/components/media.rs b/fluxer_admin/src/templates/components/media.rs
index 5b064f3a0..177c21eb6 100644
--- a/fluxer_admin/src/templates/components/media.rs
+++ b/fluxer_admin/src/templates/components/media.rs
@@ -81,20 +81,15 @@ pub fn guild_asset_url(
 }
 
 pub fn initials(name: &str) -> String {
-    let parts = name
-        .split_whitespace()
-        .filter(|part| !part.is_empty())
-        .collect::<Vec<_>>();
-    match parts.as_slice() {
-        [] => "?".to_owned(),
-        [part] => part.chars().next().unwrap_or('?').to_uppercase().collect(),
-        [first, .., last] => {
-            let mut value = String::new();
-            value.extend(first.chars().next().unwrap_or('?').to_uppercase());
-            value.extend(last.chars().next().unwrap_or('?').to_uppercase());
-            value
-        }
-    }
+    let mut parts = name.split_whitespace();
+    let Some(first) = parts.next() else {
+        return "?".to_owned();
+    };
+    std::iter::once(first)
+        .chain(parts.next_back())
+        .flat_map(|part| part.chars().take(1))
+        .flat_map(char::to_uppercase)
+        .collect()
 }
 
 fn media_asset_url(
diff --git a/fluxer_admin/src/templates/components/message_list.rs b/fluxer_admin/src/templates/components/message_list.rs
index 11d796d49..cbdb95f6f 100644
--- a/fluxer_admin/src/templates/components/message_list.rs
+++ b/fluxer_admin/src/templates/components/message_list.rs
@@ -45,8 +45,8 @@ fn ncmec_badge(att: &Attachment) -> Markup {
 }
 
 fn render_image_attachments(msg: &Message, include_delete: bool) -> Markup {
-    let images: Vec<&Attachment> = msg.attachments.iter().filter(|a| is_image(a)).collect();
-    if images.is_empty() {
+    let mut images = msg.attachments.iter().filter(|a| is_image(a)).peekable();
+    if images.peek().is_none() {
         return html! {};
     }
     let spacer = if !msg.content.is_empty() {
@@ -56,7 +56,7 @@ fn render_image_attachments(msg: &Message, include_delete: bool) -> Markup {
     };
     html! {
         div class=(spacer) {
-            @for att in &images {
+            @for att in images {
                 div class="max-w-xl overflow-hidden rounded-xl border border-neutral-200 bg-neutral-50" {
                     a href=(att.url) target="_blank" rel="noopener noreferrer"
                       class="block overflow-hidden bg-neutral-100" {
@@ -116,8 +116,8 @@ fn render_image_attachments(msg: &Message, include_delete: bool) -> Markup {
 }
 
 fn render_other_attachments(msg: &Message, has_content_or_images: bool) -> Markup {
-    let others: Vec<&Attachment> = msg.attachments.iter().filter(|a| !is_image(a)).collect();
-    if others.is_empty() {
+    let mut others = msg.attachments.iter().filter(|a| !is_image(a)).peekable();
+    if others.peek().is_none() {
         return html! {};
     }
     let spacer = if has_content_or_images {
@@ -127,7 +127,7 @@ fn render_other_attachments(msg: &Message, has_content_or_images: bool) -> Marku
     };
     html! {
         div class=(spacer) {
-            @for att in &others {
+            @for att in others {
                 div class="flex flex-wrap items-center gap-2 text-xs" {
                     (paperclip_icon("text-neutral-400"))
                     a href=(att.url) target="_blank" rel="noopener noreferrer"
diff --git a/fluxer_admin/src/templates/components/mod.rs b/fluxer_admin/src/templates/components/mod.rs
index 1e0099ecb..467b0a001 100644
--- a/fluxer_admin/src/templates/components/mod.rs
+++ b/fluxer_admin/src/templates/components/mod.rs
@@ -17,7 +17,6 @@ pub mod message_data;
 pub mod message_list;
 pub mod nsfw_indicators;
 pub mod page_container;
-pub mod pagination;
 pub mod resource_link;
 pub mod section_card;
 pub mod stack;
diff --git a/fluxer_admin/src/templates/components/nsfw_indicators.rs b/fluxer_admin/src/templates/components/nsfw_indicators.rs
index 11a4d9a24..4861d35a8 100644
--- a/fluxer_admin/src/templates/components/nsfw_indicators.rs
+++ b/fluxer_admin/src/templates/components/nsfw_indicators.rs
@@ -19,7 +19,7 @@ pub fn adult_content_badge(is_adult: bool, label: Option<&str>) -> Markup {
 }
 
 fn truncate(text: &str, max: usize) -> String {
-    if text.len() <= max {
+    if text.chars().nth(max).is_none() {
         text.to_owned()
     } else {
         let boundary = max.saturating_sub(1);
@@ -29,10 +29,7 @@ fn truncate(text: &str, max: usize) -> String {
 }
 
 pub fn content_warning_badge(level: Option<i32>, text: Option<&str>, inline_text: bool) -> Markup {
-    let Some(lvl) = level else {
-        return html! {};
-    };
-    if lvl != CONTENT_WARNING_LEVEL {
+    if level != Some(CONTENT_WARNING_LEVEL) {
         return html! {};
     }
     let default_text = "This contains sensitive content.";
@@ -82,13 +79,8 @@ fn resolve_nsfw_source(
 
 fn source_label(source: NsfwSource, explicit: Option<bool>) -> &'static str {
     match source {
-        NsfwSource::Channel => {
-            if explicit == Some(true) {
-                "(override on)"
-            } else {
-                "(override off)"
-            }
-        }
+        NsfwSource::Channel if explicit == Some(true) => "(override on)",
+        NsfwSource::Channel => "(override off)",
         NsfwSource::Category => "(from category)",
         NsfwSource::Community => "(from community)",
         NsfwSource::None => "",
@@ -110,11 +102,7 @@ pub fn channel_nsfw_state_badge(
     }
     let has_context =
         nsfw_override.is_some() || category_override.is_some() || guild_nsfw.is_some();
-    let (source, explicit) = if has_context {
-        resolve_nsfw_source(nsfw_override, category_override, guild_nsfw)
-    } else {
-        (NsfwSource::None, None)
-    };
+    let (source, explicit) = resolve_nsfw_source(nsfw_override, category_override, guild_nsfw);
     html! {
         span class="inline-flex flex-wrap items-center gap-1" {
             @if is_nsfw {
diff --git a/fluxer_admin/src/templates/components/pagination.rs b/fluxer_admin/src/templates/components/pagination.rs
deleted file mode 100644
index eaf1b5929..000000000
--- a/fluxer_admin/src/templates/components/pagination.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use maud::{Markup, PreEscaped, html};
-
-pub fn pagination(base_url: &str, current_page: u32, has_more: bool, extra_params: &str) -> Markup {
-    let sep = if base_url.contains('?') { "&" } else { "?" };
-    let has_previous = current_page > 1;
-    html! {
-        div class="mt-4 flex items-center justify-between" {
-            @if has_previous {
-                p class="text-sm font-normal text-neutral-500" {
-                    a href={
-                        (base_url) (sep) "page=" (current_page - 1) (extra_params)
-                    } class="text-neutral-900 underline decoration-neutral-300 hover:text-neutral-600 hover:decoration-neutral-500 hover:text-neutral-900" {
-                        (PreEscaped("&larr; Previous"))
-                    }
-                }
-            } @else {
-                span {}
-            }
-            @if has_more {
-                p class="text-sm font-normal text-neutral-500" {
-                    a href={
-                        (base_url) (sep) "page=" (current_page + 1) (extra_params)
-                    } class="text-neutral-900 underline decoration-neutral-300 hover:text-neutral-600 hover:decoration-neutral-500 hover:text-neutral-900" {
-                        (PreEscaped("Next &rarr;"))
-                    }
-                }
-            } @else {
-                span {}
-            }
-        }
-    }
-}
diff --git a/fluxer_admin/src/templates/components/resource_link.rs b/fluxer_admin/src/templates/components/resource_link.rs
index 714684ca2..6129a825b 100644
--- a/fluxer_admin/src/templates/components/resource_link.rs
+++ b/fluxer_admin/src/templates/components/resource_link.rs
@@ -12,8 +12,6 @@ const RESOURCE_LINK_CLASS: &str = "text-neutral-900 underline decoration-neutral
                       hover:text-neutral-600 hover:decoration-neutral-500 text-sm";
 const NAV_LINK_CLASS: &str = "label rounded-lg border border-neutral-300 bg-white \
                       px-3 py-2 text-neutral-700 transition-colors hover:bg-neutral-50";
-const TEXT_LINK_CLASS: &str = "text-neutral-900 underline decoration-neutral-300 \
-         hover:text-neutral-600 hover:decoration-neutral-500";
 
 impl ResourceType {
     fn path_segment(self) -> &'static str {
@@ -91,18 +89,3 @@ pub fn nav_link(href: &str, content: Markup) -> Markup {
         a href=(href) class=(NAV_LINK_CLASS) { (content) }
     }
 }
-
-pub fn text_link(href: &str, content: Markup, external: bool, _mono: bool) -> Markup {
-    if external {
-        html! {
-            a href=(href) class=(TEXT_LINK_CLASS)
-              target="_blank" rel="noopener noreferrer" {
-                (content)
-            }
-        }
-    } else {
-        html! {
-            a href=(href) class=(TEXT_LINK_CLASS) { (content) }
-        }
-    }
-}
diff --git a/fluxer_admin/src/templates/pages/audit_logs.rs b/fluxer_admin/src/templates/pages/audit_logs.rs
index 7eab358a6..d66f61442 100644
--- a/fluxer_admin/src/templates/pages/audit_logs.rs
+++ b/fluxer_admin/src/templates/pages/audit_logs.rs
@@ -72,27 +72,22 @@ fn filters_section(base: &str, params: &AuditLogsParams<'_>) -> Markup {
 }
 
 fn build_pagination_url(base: &str, page: u32, params: &AuditLogsParams<'_>) -> String {
-    let mut url = format!("{base}/audit-logs?page={page}");
-    if !params.query.is_empty() {
-        url.push_str(&format!("&q={}", params.query));
-    }
-    if !params.admin_user_id.is_empty() {
-        url.push_str(&format!("&admin_user_id={}", params.admin_user_id));
-    }
-    if !params.target_id.is_empty() {
-        url.push_str(&format!("&target_id={}", params.target_id));
-    }
-    if !params.target_type.is_empty() {
-        url.push_str(&format!("&target_type={}", params.target_type));
-    }
-    if !params.sort_by.is_empty() {
-        url.push_str(&format!("&sort_by={}", params.sort_by));
-    }
-    if !params.sort_order.is_empty() {
-        url.push_str(&format!("&sort_order={}", params.sort_order));
-    }
-    url.push_str(&format!("&limit={}", params.limit));
-    url
+    let mut query = url::form_urlencoded::Serializer::new(String::new());
+    query.append_pair("page", &page.to_string());
+    query.extend_pairs(
+        [
+            ("q", params.query),
+            ("admin_user_id", params.admin_user_id),
+            ("target_id", params.target_id),
+            ("target_type", params.target_type),
+            ("sort_by", params.sort_by),
+            ("sort_order", params.sort_order),
+        ]
+        .into_iter()
+        .filter(|(_, value)| !value.is_empty()),
+    );
+    query.append_pair("limit", &params.limit.to_string());
+    format!("{base}/audit-logs?{}", query.finish())
 }
 
 pub fn audit_logs_page(
@@ -107,10 +102,15 @@ pub fn audit_logs_page(
             let total = data.total;
             let entries = &data.logs;
             let total_pages = if params.limit > 0 {
-                ((total as f64) / (params.limit as f64)).ceil().max(1.0) as u64
+                total.div_ceil(u64::from(params.limit)).max(1)
             } else {
                 1
             };
+            let page_number = u64::from(params.current_page) + 1;
+            let next_page = params
+                .current_page
+                .checked_add(1)
+                .filter(|page| u64::from(*page) < total_pages);
             let showing = format!("Showing {} of {} entries", entries.len(), total);
             html! {
                 (page_header_with_actions("Audit Logs", None, html! {
@@ -134,10 +134,10 @@ pub fn audit_logs_page(
                             }
                         } @else { span {} }
                         span class="text-sm text-neutral-500" {
-                            "Page " (params.current_page + 1) " of " (total_pages)
+                            "Page " (page_number) " of " (total_pages)
                         }
-                        @if (params.current_page + 1) < total_pages as u32 {
-                            a href=(build_pagination_url(base, params.current_page + 1, params))
+                        @if let Some(page) = next_page {
+                            a href=(build_pagination_url(base, page, params))
                                 class="text-sm text-neutral-900 underline" {
                                 (PreEscaped("Next &rarr;"))
                             }
diff --git a/fluxer_admin/src/templates/pages/audit_logs_table.rs b/fluxer_admin/src/templates/pages/audit_logs_table.rs
index 498072972..e69df5e38 100644
--- a/fluxer_admin/src/templates/pages/audit_logs_table.rs
+++ b/fluxer_admin/src/templates/pages/audit_logs_table.rs
@@ -14,12 +14,7 @@ use crate::{
 use maud::{Markup, html};
 
 pub fn format_action(action: &str) -> String {
-    let replaced = action.replace('_', " ");
-    let mut chars = replaced.chars();
-    match chars.next() {
-        None => String::new(),
-        Some(c) => c.to_uppercase().to_string() + chars.as_str(),
-    }
+    capitalise(&action.replace('_', " "))
 }
 
 pub fn action_badge_variant(action: &str) -> BadgeVariant {
@@ -92,10 +87,8 @@ pub fn admin_user_cell(base: &str, entry: &AuditLogEntry) -> Markup {
     }
 }
 
-fn target_guild_label(guild: Option<&AuditLogGuildSummary>) -> String {
-    guild
-        .map(|guild| guild.name.clone())
-        .unwrap_or_else(|| "Guild".to_owned())
+fn target_guild_label(guild: Option<&AuditLogGuildSummary>) -> &str {
+    guild.map(|guild| guild.name.as_str()).unwrap_or("Guild")
 }
 
 pub fn target_cell(base: &str, entry: &AuditLogEntry) -> Markup {
diff --git a/fluxer_admin/src/templates/pages/gift_codes.rs b/fluxer_admin/src/templates/pages/gift_codes.rs
index 0546aac46..2ecb09189 100644
--- a/fluxer_admin/src/templates/pages/gift_codes.rs
+++ b/fluxer_admin/src/templates/pages/gift_codes.rs
@@ -16,7 +16,7 @@ use crate::{
 };
 use maud::{Markup, html};
 
-const MAX_GIFT_CODES: u32 = 100;
+pub const MAX_GIFT_CODES: u32 = 100;
 const DEFAULT_GIFT_COUNT: u32 = 10;
 
 pub fn gift_codes_page(
@@ -44,12 +44,12 @@ pub fn gift_codes_page(
                     (csrf_input(csrf_token))
                     div class="flex flex-col gap-4" {
                         (form_field_group(
-                            "Number of codes", "gift-count-slider", false, None,
+                            "Number of codes", "gift-count-slider", true, None,
                             Some(&format!("Range: 1-{MAX_GIFT_CODES}")),
                             html! {
                                 input type="number" id="gift-count-slider" name="count"
                                     value=(DEFAULT_GIFT_COUNT) min="1"
-                                    max=(MAX_GIFT_CODES)
+                                    max=(MAX_GIFT_CODES) required
                                     class=(FORM_INPUT_CLASS);
                             },
                         ))
diff --git a/fluxer_admin/src/templates/pages/guild_detail_tabs/members.rs b/fluxer_admin/src/templates/pages/guild_detail_tabs/members.rs
index 93c627884..fe4737fdb 100644
--- a/fluxer_admin/src/templates/pages/guild_detail_tabs/members.rs
+++ b/fluxer_admin/src/templates/pages/guild_detail_tabs/members.rs
@@ -25,7 +25,9 @@ pub fn members_tab(
     let total = response.total;
     let total_pages = if limit > 0 { total.div_ceil(limit) } else { 1 };
     let has_previous = page > 0;
-    let has_next = (page as u64) < total_pages.saturating_sub(1);
+    let next_page = page
+        .checked_add(1)
+        .filter(|page| u64::from(*page) < total_pages);
 
     html! {
         div class="space-y-4" {
@@ -34,12 +36,16 @@ pub fn members_tab(
                     "Guild Members (" (total) ")"
                 }
                 p class="text-sm text-neutral-500" {
-                    @let start = response.offset + 1;
-                    @let end = std::cmp::min(
-                        response.offset + response.members.len() as u64,
-                        total,
-                    );
-                    "Showing " (start) "-" (end) " of " (total)
+                    @if response.members.is_empty() {
+                        "Showing 0 of " (total)
+                    } @else {
+                        @let start = u128::from(response.offset) + 1;
+                        @let end = std::cmp::min(
+                            u128::from(response.offset) + response.members.len() as u128,
+                            u128::from(total),
+                        );
+                        "Showing " (start) "-" (end) " of " (total)
+                    }
                 }
             }
 
@@ -70,10 +76,10 @@ pub fn members_tab(
                         }
                     }
                     p class="text-sm text-neutral-500" {
-                        "Page " (page + 1) " of " (total_pages)
+                        "Page " (u64::from(page) + 1) " of " (total_pages)
                     }
-                    @if has_next {
-                        a href={(base) "/guilds/" (guild.id) "?tab=members&page=" (page + 1)}
+                    @if let Some(next_page) = next_page {
+                        a href={(base) "/guilds/" (guild.id) "?tab=members&page=" (next_page)}
                             class="inline-flex items-center rounded-md bg-brand-primary px-3 \
                                    py-2 text-sm font-medium text-white hover:bg-brand-primary-dark" {
                             "Next \u{2192}"
diff --git a/fluxer_admin/src/templates/pages/guild_detail_tabs/overview.rs b/fluxer_admin/src/templates/pages/guild_detail_tabs/overview.rs
index d5f5b764d..60e07abb6 100644
--- a/fluxer_admin/src/templates/pages/guild_detail_tabs/overview.rs
+++ b/fluxer_admin/src/templates/pages/guild_detail_tabs/overview.rs
@@ -40,13 +40,13 @@ fn channel_type_label(channel_type: i32) -> &'static str {
 pub fn overview_tab(config: &AdminConfig, guild: &GuildDetailInfo, csrf_token: &str) -> Markup {
     let base = &config.base_path;
 
-    let mut sorted_channels = guild.channels.clone();
+    let mut sorted_channels: Vec<_> = guild.channels.iter().collect();
     sorted_channels.sort_by_key(|c| c.position);
 
     let channels_by_id: std::collections::HashMap<&str, &crate::api::types::GuildChannelSummary> =
         guild.channels.iter().map(|c| (c.id.as_str(), c)).collect();
 
-    let mut sorted_roles = guild.roles.clone();
+    let mut sorted_roles: Vec<_> = guild.roles.iter().collect();
     sorted_roles.sort_by_key(|role| std::cmp::Reverse(role.position));
 
     let icon_url = guild_icon_url(config, &guild.id, guild.icon.as_deref(), 256, true);
@@ -102,16 +102,10 @@ pub fn overview_tab(config: &AdminConfig, guild: &GuildDetailInfo, csrf_token: &
                             p class="text-sm font-semibold text-neutral-500" {
                                 "Custom warning text"
                             }
-                            @if let Some(ref text) = guild.content_warning_text {
-                                @if !text.trim().is_empty() {
-                                    blockquote class="border-amber-300 border-l-2 bg-amber-50 \
-                                                      px-3 py-2 text-neutral-800 text-sm italic" {
-                                        (text)
-                                    }
-                                } @else {
-                                    p class="text-sm text-neutral-500" {
-                                        "\u{2014} (default fallback shown to users)"
-                                    }
+                            @if let Some(text) = guild.content_warning_text.as_deref().filter(|text| !text.trim().is_empty()) {
+                                blockquote class="border-amber-300 border-l-2 bg-amber-50 \
+                                                  px-3 py-2 text-neutral-800 text-sm italic" {
+                                    (text)
                                 }
                             } @else {
                                 p class="text-sm text-neutral-500" {
diff --git a/fluxer_admin/src/templates/pages/guild_detail_tabs/reports.rs b/fluxer_admin/src/templates/pages/guild_detail_tabs/reports.rs
index 73bbe0d3c..440c2669a 100644
--- a/fluxer_admin/src/templates/pages/guild_detail_tabs/reports.rs
+++ b/fluxer_admin/src/templates/pages/guild_detail_tabs/reports.rs
@@ -17,8 +17,9 @@ pub fn reports_tab(
     let base = &config.base_path;
     let page_size: u64 = 25;
     let has_previous = page > 0;
-    let has_next = (page as u64) * page_size + reports.len() as u64 > 0
-        && (page as u64 + 1) * page_size < total;
+    let next_page = page.checked_add(1).filter(|next_page| {
+        (page > 0 || !reports.is_empty()) && u64::from(*next_page) * page_size < total
+    });
     html! {
         div class="space-y-4" {
             div class="flex items-center justify-between" {
@@ -48,7 +49,7 @@ pub fn reports_tab(
                 ))
             }
 
-            @if has_previous || has_next {
+            @if has_previous || next_page.is_some() {
                 div class="flex justify-center gap-2" {
                     @if has_previous {
                         a href={(base) "/guilds/" (guild.id) "?tab=reports&reports_page=" (page - 1)}
@@ -58,8 +59,8 @@ pub fn reports_tab(
                             "\u{2190} Newer"
                         }
                     }
-                    @if has_next {
-                        a href={(base) "/guilds/" (guild.id) "?tab=reports&reports_page=" (page + 1)}
+                    @if let Some(next_page) = next_page {
+                        a href={(base) "/guilds/" (guild.id) "?tab=reports&reports_page=" (next_page)}
                             class="inline-flex items-center rounded-md border border-neutral-300 \
                                    bg-white px-3 py-2 text-sm font-medium text-neutral-700 \
                                    hover:bg-neutral-50" {
diff --git a/fluxer_admin/src/templates/pages/guilds_list.rs b/fluxer_admin/src/templates/pages/guilds_list.rs
index ec8dc3ca4..81d45faec 100644
--- a/fluxer_admin/src/templates/pages/guilds_list.rs
+++ b/fluxer_admin/src/templates/pages/guilds_list.rs
@@ -64,7 +64,6 @@ impl GuildsListParams {
 pub struct GuildsListResults<'a> {
     pub guilds: Option<&'a [GuildInfo]>,
     pub total: Option<u64>,
-    pub has_more: bool,
 }
 
 pub fn guilds_list_page(
@@ -73,14 +72,12 @@ pub fn guilds_list_page(
     params: &GuildsListParams,
     results: Option<&[GuildInfo]>,
     total: Option<u64>,
-    has_more: bool,
     is_htmx: bool,
 ) -> Markup {
     let base = &config.base_path;
     let result_state = GuildsListResults {
         guilds: results,
         total,
-        has_more,
     };
     let has_results = results.is_some_and(|guilds| !guilds.is_empty());
     let header = html! {
@@ -164,7 +161,10 @@ fn render_results(
 fn pagination(config: &AdminConfig, params: &GuildsListParams, total: u64) -> Markup {
     let total_pages = total.div_ceil(u64::from(params.limit)).max(1);
     let has_previous = params.page > 0;
-    let has_next = u64::from(params.page) < total_pages.saturating_sub(1);
+    let next_page = params
+        .page
+        .checked_add(1)
+        .filter(|page| u64::from(*page) < total_pages);
     html! {
         div class="mt-6 flex items-center justify-center gap-3" {
             @if has_previous {
@@ -181,10 +181,10 @@ fn pagination(config: &AdminConfig, params: &GuildsListParams, total: u64) -> Ma
                 }
             }
             span class="text-neutral-600 text-sm" {
-                "Page " (params.page + 1) " of " (total_pages)
+                "Page " (u64::from(params.page) + 1) " of " (total_pages)
             }
-            @if has_next {
-                a href=(pagination_url(&config.base_path, params, params.page + 1))
+            @if let Some(next_page) = next_page {
+                a href=(pagination_url(&config.base_path, params, next_page))
                     class="rounded-lg bg-neutral-900 px-6 py-2 font-medium text-sm \
                            text-white no-underline transition-colors hover:bg-neutral-800" {
                     "Next \u{2192}"
@@ -200,8 +200,7 @@ fn pagination(config: &AdminConfig, params: &GuildsListParams, total: u64) -> Ma
 }
 
 fn pagination_url(base: &str, params: &GuildsListParams, page: u32) -> String {
-    let mut parts = Vec::new();
-    parts.push(format!("page={page}"));
+    let mut parts = vec![format!("page={page}"), format!("limit={}", params.limit)];
     if !params.q.is_empty() {
         parts.push(format!("q={}", urlencoding::encode(&params.q)));
     }
diff --git a/fluxer_admin/src/templates/pages/job_detail.rs b/fluxer_admin/src/templates/pages/job_detail.rs
index 3dece0bae..604290c07 100644
--- a/fluxer_admin/src/templates/pages/job_detail.rs
+++ b/fluxer_admin/src/templates/pages/job_detail.rs
@@ -7,7 +7,6 @@ use crate::{
     templates::{
         components::{
             auto_refresh::auto_refresh,
-            badge::{BadgeVariant, badge},
             data_field::{data_field_mono, data_field_text, data_grid},
             form::{csrf_input, danger_button, form_field_group},
             page_container::{page_header_with_actions, page_header_with_back},
@@ -18,17 +17,7 @@ use crate::{
 };
 use maud::{Markup, html};
 
-fn status_badge(status: &str) -> Markup {
-    let variant = match status {
-        "queued" => BadgeVariant::Default,
-        "running" => BadgeVariant::Info,
-        "succeeded" => BadgeVariant::Success,
-        "failed" | "deadletter" => BadgeVariant::Danger,
-        "cancelled" => BadgeVariant::Warning,
-        _ => BadgeVariant::Default,
-    };
-    badge(status, variant)
-}
+use super::jobs_list_helpers::status_badge;
 
 fn val_str<'a>(job: &'a serde_json::Value, key: &str) -> &'a str {
     job.get(key).and_then(|v| v.as_str()).unwrap_or("")
@@ -71,7 +60,7 @@ fn progress_bar(job: &serde_json::Value) -> Markup {
         }
         (cur, Some(tot)) => {
             let c = cur.unwrap_or(0);
-            let pct = (c * 100 / tot).min(100);
+            let pct = (u128::from(c) * 100 / u128::from(tot)).min(100);
             html! {
                 div role="progressbar" aria-valuenow=(pct) aria-valuemin="0"
                     aria-valuemax="100"
diff --git a/fluxer_admin/src/templates/pages/jobs_list_helpers.rs b/fluxer_admin/src/templates/pages/jobs_list_helpers.rs
index 7c5fe6950..96f5521ec 100644
--- a/fluxer_admin/src/templates/pages/jobs_list_helpers.rs
+++ b/fluxer_admin/src/templates/pages/jobs_list_helpers.rs
@@ -33,25 +33,26 @@ pub(crate) fn format_progress(job: &serde_json::Value) -> String {
         (Some(cur), None | Some(0)) => format!("{cur}"),
         (cur, Some(tot)) => {
             let c = cur.unwrap_or(0);
-            let pct = c.saturating_mul(100).checked_div(tot).unwrap_or(0);
+            let pct = (u128::from(c) * 100)
+                .checked_div(u128::from(tot))
+                .unwrap_or(0);
             format!("{c} / {tot} ({pct}%)")
         }
     }
 }
 
-pub(crate) fn job_row(base: &str, job: &serde_json::Value) -> Markup {
-    let job_id = job
-        .get("job_id")
-        .and_then(|v| v.as_str().or_else(|| v.as_u64().map(|_| "")))
-        .unwrap_or("");
-    let job_id_display = job
+fn job_id_text(value: &serde_json::Value) -> String {
+    value
         .get("job_id")
         .map(|v| match v {
             serde_json::Value::String(s) => s.clone(),
-            serde_json::Value::Number(n) => n.to_string(),
             _ => v.to_string(),
         })
-        .unwrap_or_default();
+        .unwrap_or_default()
+}
+
+pub(crate) fn job_row(base: &str, job: &serde_json::Value) -> Markup {
+    let job_id = job_id_text(job);
     let task_type = job
         .get("task_type")
         .and_then(|v| v.as_str())
@@ -79,23 +80,17 @@ pub(crate) fn job_row(base: &str, job: &serde_json::Value) -> Markup {
         .unwrap_or_else(|| "cron".to_owned());
     let progress = format_progress(job);
 
-    let link_id = if job_id.is_empty() {
-        &job_id_display
-    } else {
-        job_id
-    };
-
     table_row(html! {
         (table_cell(true, html! {
             span class="whitespace-nowrap text-sm" { (created_at) }
         }))
         (table_cell(false, html! {
-            a href={(base) "/jobs/" (link_id)}
+            a href={(base) "/jobs/" (job_id)}
                 hx-target="#main-content"
                 hx-swap="innerHTML"
                 hx-push-url="true"
                 class="text-blue-600 text-sm hover:underline" {
-                (job_id_display)
+                (job_id)
             }
         }))
         (table_cell(false, html! {
@@ -103,7 +98,7 @@ pub(crate) fn job_row(base: &str, job: &serde_json::Value) -> Markup {
         }))
         (table_cell(false, html! { (status_badge(status)) }))
         (table_cell(false, html! {
-            span class="text-sm" data-job-progress=(link_id) { (progress) }
+            span class="text-sm" data-job-progress=(job_id) { (progress) }
         }))
         (table_cell(true, html! {
             span class="text-sm" { (attempts) "/" (max_attempts) }
@@ -112,7 +107,7 @@ pub(crate) fn job_row(base: &str, job: &serde_json::Value) -> Markup {
             span class="text-sm" { (requester) }
         }))
         (table_cell(false, html! {
-            a href={(base) "/jobs/" (link_id)}
+            a href={(base) "/jobs/" (job_id)}
                 hx-target="#main-content"
                 hx-swap="innerHTML"
                 hx-push-url="true"
@@ -159,14 +154,7 @@ pub(crate) fn next_page_link(
         .get("created_at")
         .and_then(|v| v.as_str())
         .unwrap_or("");
-    let job_id = cursor
-        .get("job_id")
-        .map(|v| match v {
-            serde_json::Value::String(s) => s.clone(),
-            serde_json::Value::Number(n) => n.to_string(),
-            _ => v.to_string(),
-        })
-        .unwrap_or_default();
+    let job_id = job_id_text(cursor);
 
     let mut params = vec![
         format!("cursor_bucket_day={bucket_day}"),
diff --git a/fluxer_admin/src/templates/pages/reports_list.rs b/fluxer_admin/src/templates/pages/reports_list.rs
index 3d2c56e47..58c25fa4d 100644
--- a/fluxer_admin/src/templates/pages/reports_list.rs
+++ b/fluxer_admin/src/templates/pages/reports_list.rs
@@ -466,7 +466,10 @@ fn reports_pagination(
     limit: u32,
     total: u64,
 ) -> Markup {
-    let total_pages = ((total + u64::from(limit).saturating_sub(1)) / u64::from(limit)).max(1);
+    let total_pages = total.div_ceil(u64::from(limit)).max(1);
+    let next_page = page
+        .checked_add(1)
+        .filter(|page| u64::from(*page) < total_pages);
     html! {
         div class="mt-4 flex items-center justify-between" {
             @if page > 0 {
@@ -478,10 +481,10 @@ fn reports_pagination(
                 span {}
             }
             span class="text-neutral-500 text-sm" {
-                "Page " (page + 1) " of " (total_pages)
+                "Page " (u64::from(page) + 1) " of " (total_pages)
             }
-            @if u64::from(page + 1) < total_pages {
-                a href=(reports_url(config, filters, page + 1, limit))
+            @if let Some(next_page) = next_page {
+                a href=(reports_url(config, filters, next_page, limit))
                     class="text-neutral-900 underline decoration-neutral-300 hover:text-neutral-600 hover:decoration-neutral-500" {
                     (PreEscaped("Next &rarr;"))
                 }
diff --git a/fluxer_admin/src/templates/pages/search_index.rs b/fluxer_admin/src/templates/pages/search_index.rs
index f91e922fe..9e8a69fcd 100644
--- a/fluxer_admin/src/templates/pages/search_index.rs
+++ b/fluxer_admin/src/templates/pages/search_index.rs
@@ -121,7 +121,7 @@ fn status_section(base: &str, rs: &RefreshStatus) -> Markup {
 
                 @if is_in_progress {
                     @if let (Some(idx), Some(tot)) = (rs.indexed, rs.total) {
-                        @let pct = idx.saturating_mul(100).checked_div(tot).unwrap_or(0);
+                        @let pct = (u128::from(idx) * 100).checked_div(u128::from(tot)).unwrap_or(0);
                         div class="space-y-2" {
                             div class="flex items-center justify-between" {
                                 p class="text-sm text-neutral-700" {
diff --git a/fluxer_admin/src/templates/pages/user_detail_tabs/moderation.rs b/fluxer_admin/src/templates/pages/user_detail_tabs/moderation.rs
index 9aa423e2c..9c3bf9133 100644
--- a/fluxer_admin/src/templates/pages/user_detail_tabs/moderation.rs
+++ b/fluxer_admin/src/templates/pages/user_detail_tabs/moderation.rs
@@ -146,7 +146,7 @@ fn deletion_card(base: &str, user: &AdminUser, csrf_token: &str) -> Markup {
                     (csrf_input(csrf_token))
                     div class="space-y-3" {
                         (form_label("Days until deletion"))
-                        input type="number" name="days" value="60"
+                        input type="number" name="days_until_deletion" value="60"
                             min="60" max="365"
                             class="block w-full rounded-md border border-neutral-300 \
                                    px-3 py-2 text-sm shadow-sm \
@@ -322,9 +322,8 @@ fn message_shred_status_content(status: &serde_json::Value) -> Markup {
     let total = value_u64(status, "total").unwrap_or(0);
     let processed = value_u64(status, "processed").unwrap_or(0);
     let skipped = value_u64(status, "skipped").unwrap_or(0);
-    let percentage = processed
-        .saturating_mul(100)
-        .checked_div(total)
+    let percentage = (u128::from(processed) * 100)
+        .checked_div(u128::from(total))
         .unwrap_or(0)
         .min(100);
     html! {
diff --git a/fluxer_admin/src/templates/pages/user_detail_tabs/reports.rs b/fluxer_admin/src/templates/pages/user_detail_tabs/reports.rs
index 1fd97bd5f..db9b4dd62 100644
--- a/fluxer_admin/src/templates/pages/user_detail_tabs/reports.rs
+++ b/fluxer_admin/src/templates/pages/user_detail_tabs/reports.rs
@@ -78,9 +78,11 @@ fn report_section(
         }
     };
 
-    let offset = current_page as u64 * limit as u64;
+    let offset = u64::from(current_page) * u64::from(limit);
     let has_previous = current_page > 0;
-    let has_next = offset + (reports.len() as u64) < total;
+    let next_page = current_page
+        .checked_add(1)
+        .filter(|_| (reports.len() as u64) < total.saturating_sub(offset));
 
     let (sent_page, received_page) = if kind == "sent" {
         (current_page, other_page)
@@ -115,7 +117,7 @@ fn report_section(
                     ))
                 }
 
-                @if has_previous || has_next {
+                @if has_previous || next_page.is_some() {
                     div class="flex justify-center gap-2" {
                         @if has_previous {
                             a href={(base) "/users/" (user_id) "?tab=reports&reports_limit=" (limit) "&reports_sent_page=" (if kind == "sent" { current_page - 1 } else { sent_page }) "&reports_received_page=" (if kind == "received" { current_page - 1 } else { received_page })}
@@ -125,8 +127,8 @@ fn report_section(
                                 "Previous"
                             }
                         }
-                        @if has_next {
-                            a href={(base) "/users/" (user_id) "?tab=reports&reports_limit=" (limit) "&reports_sent_page=" (if kind == "sent" { current_page + 1 } else { sent_page }) "&reports_received_page=" (if kind == "received" { current_page + 1 } else { received_page })}
+                        @if let Some(next_page) = next_page {
+                            a href={(base) "/users/" (user_id) "?tab=reports&reports_limit=" (limit) "&reports_sent_page=" (if kind == "sent" { next_page } else { sent_page }) "&reports_received_page=" (if kind == "received" { next_page } else { received_page })}
                                 class="inline-flex items-center rounded-md border \
                                        border-neutral-300 bg-white px-3 py-2 text-sm \
                                        font-medium text-neutral-700 hover:bg-neutral-50" {
diff --git a/fluxer_admin/src/templates/pages/users_list.rs b/fluxer_admin/src/templates/pages/users_list.rs
index f5ac4d8d3..2c988a999 100644
--- a/fluxer_admin/src/templates/pages/users_list.rs
+++ b/fluxer_admin/src/templates/pages/users_list.rs
@@ -393,6 +393,7 @@ fn render_users_table(config: &AdminConfig, users: &[AdminUser], can_view_email:
 }
 
 fn pagination_controls(base: &str, params: &UserListParams, has_more: bool) -> Markup {
+    let next_page = params.page.checked_add(1).filter(|_| has_more);
     html! {
         div class="mt-4 flex items-center justify-between" {
             @if params.page > 0 {
@@ -403,8 +404,8 @@ fn pagination_controls(base: &str, params: &UserListParams, has_more: bool) -> M
             } @else {
                 span {}
             }
-            @if has_more {
-                a href=(users_url(base, params, params.page + 1))
+            @if let Some(next_page) = next_page {
+                a href=(users_url(base, params, next_page))
                     class="text-neutral-900 underline decoration-neutral-300 hover:text-neutral-600 hover:decoration-neutral-500" {
                     "Next >"
                 }
diff --git a/fluxer_admin/src/utils/forms.rs b/fluxer_admin/src/utils/forms.rs
index 719faaa05..423376668 100644
--- a/fluxer_admin/src/utils/forms.rs
+++ b/fluxer_admin/src/utils/forms.rs
@@ -17,11 +17,14 @@ pub fn clean_string(value: &str) -> Option<String> {
 }
 
 pub fn parse_comma_separated(value: &str) -> Vec<String> {
+    comma_separated_values(value).map(str::to_owned).collect()
+}
+
+fn comma_separated_values(value: &str) -> impl Iterator<Item = &str> {
     value
         .split([',', '\n', '\r'])
-        .map(|s| s.trim().to_owned())
-        .filter(|s| !s.is_empty())
-        .collect()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
 }
 
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
@@ -63,12 +66,18 @@ impl MultiValueForm {
         self.first(key).and_then(clean_string)
     }
 
-    pub fn parse_i32(&self, key: &str) -> Option<i32> {
-        self.first(key).and_then(|value| value.parse().ok())
+    pub fn parse_value<T: std::str::FromStr>(&self, key: &str) -> Result<Option<T>, T::Err> {
+        self.parse_value_any(&[key])
     }
 
-    pub fn parse_i64(&self, key: &str) -> Option<i64> {
-        self.first(key).and_then(|value| value.parse().ok())
+    pub fn parse_value_any<T: std::str::FromStr>(
+        &self,
+        keys: &[&str],
+    ) -> Result<Option<T>, T::Err> {
+        keys.iter()
+            .find_map(|key| self.first(key))
+            .map(str::parse)
+            .transpose()
     }
 
     pub fn parse_u32(&self, key: &str) -> Option<u32> {
@@ -92,13 +101,21 @@ impl MultiValueForm {
             .get(key)
             .into_iter()
             .flat_map(|values| values.iter())
-            .flat_map(|value| parse_comma_separated(value))
+            .flat_map(|value| comma_separated_values(value))
+            .map(str::to_owned)
             .collect()
     }
 
     pub fn list_values_any(&self, keys: &[&str]) -> Vec<String> {
         keys.iter().flat_map(|key| self.list_values(key)).collect()
     }
+
+    pub fn parse_list_values<T: std::str::FromStr>(&self, keys: &[&str]) -> Result<Vec<T>, T::Err> {
+        self.list_values_any(keys)
+            .iter()
+            .map(|value| value.parse())
+            .collect()
+    }
 }
 
 pub fn parse_page(value: Option<&str>) -> u32 {