chore(history): squash 67 commit(s) from 2026-09-25

- feat(accounts): persist device links with opaque hashed tokens, list and revoke endpoints
- feat(frontend): app shell, routing and landing page with the chat-command hero
- feat(frontend): Cyrillic-first fonts (Unbounded, Onest, JetBrains Mono); add i18next and motion
- docs: free mod, bilingual site, one-click download, theme editor, public profiles, rich landing in plans
- feat(accounts): internal gRPC AuthenticateDevice guarded by internal key
- feat(frontend): ru/en i18n with typed per-feature dictionaries and language switch
- feat(accounts): GET /me profile endpoint
- feat(gateway): scaffold crate with config validation and health check
- feat(gateway): reverse proxy to accounts and configs services
- feat(gateway): resolve identity once from access JWT or device token via gRPC
- feat(gateway): per-route and global rate limits with Retry-After
- feat(gateway): CORS for the site origin; docs for gateway and internal contract
- feat(configs): scaffold service with schema, config validation and health check
- feat(configs): four config slots per account with list, get and save
- feat(configs): permanent share codes with regenerate and public load-by-code
- feat(accounts): GetPublicProfiles gRPC for showcase author info
- style(accounts,common): apply rustfmt to existing sources
- feat(configs): public showcase with publish, browse, detail and copy-to-slot
- feat(backend): public profile endpoint and showcase author filter
- fix(gateway): silence clippy collapsible-if and needless-ref warnings
- docs(backend): configs-service implemented; Подсистема 1 backend complete
- feat(mod): add Optimize module skeleton with OptimizeState holder
- feat(mod): gate glass blur behind Optimize no_glass knob
- feat(mod): cut MotionBlur and DoF sample counts behind lite_post knob
- feat(mod): trim procedural sky noise behind lite_sky knob
- feat(mod): drop fade gradients and digit rolls behind lean_hud knob
- docs(todo): mark Optimize module phase 9.2 complete
- refactor(mod): drop dead Renderer2D compatibility shims
- refactor(mod): prune unreachable Renderer2D overload towers
- refactor(mod): remove unused Renderer2D overloads and imports
- docs(todo): mark Renderer2D giant-splitting done (2179 to 1597)
- refactor(mod): extract shader id constants from LoVisualRenderPipelines
- docs(todo): record registry wave 2026-09-25 (Renderer2D, pipelines)
- refactor(mod): move Renderer2D instance state into base class
- refactor(mod): extract Renderer2DRounded drawing family
- refactor(mod): extract Renderer2DPath connector and chamfer family
- refactor(mod): extract Renderer2DShapes circle line and texture primitives
- refactor(mod): extract Renderer2DGlass and Renderer2DItem families
- refactor(mod): prune Renderer2D imports after facade split
- docs(todo): record Renderer2D facade inheritance split (1597 to 475)
- docs: easter eggs — .env honeypot, konami troll mode, devtools banner, IDDQD config, breakable 404 block, 418 teapot
- feat(mod): introduce surface style system core (SurfaceStyle, StyleSpec, StyleConfig, SurfaceRenderer)
- refactor(mod): delegate HudRenderUtil liquid glass draws to SurfaceRenderer (dedupe glass constants)
- refactor(mod): route bespoke glass call sites through SurfaceRenderer.plateSpec
- feat(mod): add Auto option to HUD bg effects via shared HudBgStyles resolution
- feat(mod): flat fallback for no-glass optimize mode and persist global HUD config
- feat(mod): default HUD bg effects to Auto so the global surface style drives widgets
- feat(mod): add global cycle-style hotkey with surface style notification
- feat(mod): add surface style swatch strip under the global style picker
- feat(gateway): reject ambiguous paths and answer .env probes with a honeypot
- fix(gateway): charge failed credentials against the rate limit, allow stale ones on /auth
- feat(frontend): ClickGui theme pipeline generated from the mod, live site theming
- feat(frontend): landing v2 hero — voxel/particle backdrop, live ClickGui, theme strip
- docs(todo): drop the FPS A/B measurement from phase 9.3, close phase 9
- feat(gateway): answer /coffee with a 418 teapot
- feat(frontend): land the rest of landing v2 — HUD, module wall, showcase, FAQ, footer
- feat(frontend): one-click download from GitHub releases, changelog page, release CI
- feat(frontend): theme editor with live ClickGui preview, mod-compatible export and share links
- fix(frontend): landing HUD playground now shows real mod widgets (fps, coordinates, module list, keybinds, ping)
- style(frontend): apply ClickGui glass effect to landing HUD playground widgets
- fix(frontend): prevent color field row overflow in theme editor grid
- fix(frontend): never attach stale bearer token to /auth/* requests
- fix(configs): unpublish/publish can no longer bypass moderation
- refactor(accounts): shrink auth/handlers.rs under the 250-line cap
- fix(accounts): tolerate concurrent refresh without killing every session
- fix(gateway): minor hardening from the backend review
- feat(configs): IDDQD easter egg config

backend/accounts-service/src/accounts/handlers.rs

@@ -0,0 +1,88 @@
+use super::repo;
+use crate::error::AppError;
+use axum::{
+    Json,
+    extract::{Path, State},
+};
+use chrono::{DateTime, Utc};
+use common::internal::GatewayIdentity;
+use serde::Serialize;
+use uuid::Uuid;
+
+#[derive(Clone)]
+pub struct AccountsState {
+    pub pool: sqlx::PgPool,
+    pub avatar_base_url: String,
+}
+
+#[derive(Serialize)]
+pub struct MeResponse {
+    pub id: Uuid,
+    pub email: String,
+    pub display_nick: String,
+    pub role: String,
+    pub avatar_url: Option<String>,
+    pub created_at: DateTime<Utc>,
+}
+
+pub async fn me(
+    State(state): State<AccountsState>,
+    identity: GatewayIdentity,
+) -> Result<Json<MeResponse>, AppError> {
+    let account = repo::find_by_id(&state.pool, identity.account_id)
+        .await?
+        .ok_or(AppError::Unauthorized)?;
+    let avatar_url = repo::avatar_key(&state.pool, account.id)
+        .await?
+        .map(|key| format!("{}/{key}", state.avatar_base_url));
+    Ok(Json(MeResponse {
+        id: account.id,
+        email: account.email,
+        display_nick: account.display_nick,
+        role: account.role,
+        avatar_url,
+        created_at: account.created_at,
+    }))
+}
+
+/// Public profile for the site's `/u/:id` page: no identity required, and no
+/// private fields (email, role) — only what showcase viewers may see.
+#[derive(Serialize)]
+pub struct PublicProfileResponse {
+    pub id: Uuid,
+    pub display_nick: String,
+    pub avatar_url: Option<String>,
+    pub created_at: DateTime<Utc>,
+    pub badges: Vec<String>,
+}
+
+/// Accounts are handed out in `created_at` order, so the first 1000 to sign
+/// up get the `early` badge.
+const EARLY_ADOPTER_LIMIT: i64 = 1000;
+
+pub async fn public_profile(
+    State(state): State<AccountsState>,
+    Path(raw): Path<String>,
+) -> Result<Json<PublicProfileResponse>, AppError> {
+    let not_found = || AppError::NotFound("no such account".into());
+    let id = Uuid::parse_str(&raw).map_err(|_| not_found())?;
+    let account = repo::find_by_id(&state.pool, id)
+        .await?
+        .ok_or_else(not_found)?;
+    let avatar_url = repo::avatar_key(&state.pool, account.id)
+        .await?
+        .map(|key| format!("{}/{key}", state.avatar_base_url));
+    let rank = repo::account_rank(&state.pool, account.created_at).await?;
+    let badges = if rank < EARLY_ADOPTER_LIMIT {
+        vec!["early".to_owned()]
+    } else {
+        Vec::new()
+    };
+    Ok(Json(PublicProfileResponse {
+        id: account.id,
+        display_nick: account.display_nick,
+        avatar_url,
+        created_at: account.created_at,
+        badges,
+    }))
+}

backend/accounts-service/src/accounts/mod.rs

@@ -1,2 +1,3 @@
+pub mod handlers;
 pub mod model;
 pub mod repo;

backend/accounts-service/src/accounts/model.rs

@@ -1,3 +1,5 @@
+use crate::auth::password::MAX_PASSWORD_BYTES;
+use crate::error::AppError;
 use chrono::{DateTime, Utc};
 use serde::Serialize;
 use uuid::Uuid;
@@ -13,3 +15,106 @@ pub struct Account {
     pub can_publish_addons: bool,
     pub created_at: DateTime<Utc>,
 }
+
+/// Validates and normalizes a registration request. Returns the trimmed
+/// `(email, nick)` on success. Lives here (rather than `auth::handlers`) so
+/// that handler file stays small and this stays testable independent of axum.
+pub fn validate_register(
+    email: &str,
+    password: &str,
+    nick: &str,
+) -> Result<(String, String), AppError> {
+    let email = email.trim();
+    if email.is_empty() {
+        return Err(AppError::Validation("email must not be empty".into()));
+    }
+    if email.len() > 254 {
+        return Err(AppError::Validation(
+            "email must be at most 254 characters".into(),
+        ));
+    }
+    let mut parts = email.split('@');
+    let (Some(local), Some(domain)) = (parts.next(), parts.next()) else {
+        return Err(AppError::Validation("email must contain '@'".into()));
+    };
+    if parts.next().is_some() || local.is_empty() || domain.is_empty() {
+        return Err(AppError::Validation(
+            "email must have exactly one '@' with non-empty parts".into(),
+        ));
+    }
+
+    let nick = nick.trim();
+    let nick_len = nick.chars().count();
+    if nick_len == 0 || nick_len > 32 {
+        return Err(AppError::Validation(
+            "nick must be 1 to 32 characters".into(),
+        ));
+    }
+    if nick.chars().any(|c| c.is_control()) {
+        return Err(AppError::Validation(
+            "nick must not contain control characters".into(),
+        ));
+    }
+
+    if password.chars().count() < 8 {
+        return Err(AppError::Validation(
+            "password must be at least 8 characters".into(),
+        ));
+    }
+    if password.len() > MAX_PASSWORD_BYTES {
+        return Err(AppError::Validation(format!(
+            "password must be at most {MAX_PASSWORD_BYTES} bytes"
+        )));
+    }
+
+    Ok((email.to_string(), nick.to_string()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn valid() -> (String, String, String) {
+        (
+            "user@example.com".into(),
+            "password123".into(),
+            "Rider".into(),
+        )
+    }
+
+    #[test]
+    fn valid_request_passes() {
+        let (email, password, nick) = valid();
+        assert!(validate_register(&email, &password, &nick).is_ok());
+    }
+
+    #[test]
+    fn short_password_is_rejected() {
+        let (email, _, nick) = valid();
+        assert!(validate_register(&email, "short12", &nick).is_err());
+    }
+
+    #[test]
+    fn empty_email_is_rejected() {
+        let (_, password, nick) = valid();
+        assert!(validate_register("   ", &password, &nick).is_err());
+    }
+
+    #[test]
+    fn email_without_at_is_rejected() {
+        let (_, password, nick) = valid();
+        assert!(validate_register("not-an-email", &password, &nick).is_err());
+    }
+
+    #[test]
+    fn empty_nick_is_rejected() {
+        let (email, password, _) = valid();
+        assert!(validate_register(&email, &password, "   ").is_err());
+    }
+
+    #[test]
+    fn thirty_three_char_nick_is_rejected() {
+        let (email, password, _) = valid();
+        assert!(validate_register(&email, &password, &"a".repeat(33)).is_err());
+    }
+}

backend/accounts-service/src/accounts/repo.rs

@@ -58,6 +58,40 @@ pub async fn set_avatar(pool: &PgPool, account_id: Uuid, s3_key: &str) -> Result
     Ok(())
 }
 
+pub async fn avatar_key(pool: &PgPool, account_id: Uuid) -> Result<Option<String>, sqlx::Error> {
+    sqlx::query_scalar("SELECT s3_key FROM avatars WHERE account_id = $1")
+        .bind(account_id)
+        .fetch_optional(pool)
+        .await
+}
+
+/// Nick + avatar key for the given accounts (showcase authors etc.).
+/// Missing ids are simply absent from the result.
+pub async fn public_profiles(
+    pool: &PgPool,
+    ids: &[Uuid],
+) -> Result<Vec<(Uuid, String, Option<String>)>, sqlx::Error> {
+    sqlx::query_as(
+        "SELECT a.id, a.display_nick, av.s3_key FROM accounts a
+         LEFT JOIN avatars av ON av.account_id = a.id
+         WHERE a.id = ANY($1)",
+    )
+    .bind(ids)
+    .fetch_all(pool)
+    .await
+}
+
+/// How many accounts existed before `created_at`; 0 means the very first one.
+pub async fn account_rank(
+    pool: &PgPool,
+    created_at: chrono::DateTime<chrono::Utc>,
+) -> Result<i64, sqlx::Error> {
+    sqlx::query_scalar("SELECT count(*) FROM accounts WHERE created_at < $1")
+        .bind(created_at)
+        .fetch_one(pool)
+        .await
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -66,7 +100,10 @@ mod tests {
         let url = std::env::var("DATABASE_URL")
             .unwrap_or_else(|_| "postgres://lovisual:lovisual@localhost:5432/accounts_db".into());
         let pool = PgPool::connect(&url).await.expect("connect");
-        sqlx::migrate!("./migrations").run(&pool).await.expect("migrate");
+        sqlx::migrate!("./migrations")
+            .run(&pool)
+            .await
+            .expect("migrate");
         pool
     }
 
@@ -80,7 +117,10 @@ mod tests {
         assert_eq!(created.role, "user");
         assert!(created.can_publish_addons);
 
-        let found = find_by_email(&pool, &email).await.unwrap().expect("must exist");
+        let found = find_by_email(&pool, &email)
+            .await
+            .unwrap()
+            .expect("must exist");
         assert_eq!(found.id, created.id);
 
         sqlx::query("DELETE FROM accounts WHERE id = $1")
@@ -93,7 +133,9 @@ mod tests {
     #[tokio::test]
     async fn find_by_email_returns_none_for_missing() {
         let pool = test_pool().await;
-        let result = find_by_email(&pool, "does-not-exist@example.com").await.unwrap();
+        let result = find_by_email(&pool, "does-not-exist@example.com")
+            .await
+            .unwrap();
         assert!(result.is_none());
     }
 
@@ -123,7 +165,9 @@ mod tests {
     async fn duplicate_email_differing_only_by_case_is_rejected() {
         let pool = test_pool().await;
         let tag = Uuid::new_v4();
-        let first = create(&pool, &format!("dup-{tag}@example.com"), "h", "A").await.unwrap();
+        let first = create(&pool, &format!("dup-{tag}@example.com"), "h", "A")
+            .await
+            .unwrap();
 
         let second = create(&pool, &format!("DUP-{tag}@EXAMPLE.com"), "h", "B").await;
         let err = second.expect_err("case-variant duplicate must violate the unique index");
@@ -144,12 +188,21 @@ mod tests {
     #[tokio::test]
     async fn set_avatar_inserts_then_updates_in_place() {
         let pool = test_pool().await;
-        let created = create(&pool, &format!("av-{}@example.com", Uuid::new_v4()), "h", "N")
+        let created = create(
+            &pool,
+            &format!("av-{}@example.com", Uuid::new_v4()),
+            "h",
+            "N",
+        )
+        .await
+        .unwrap();
+
+        set_avatar(&pool, created.id, "avatars/one.png")
+            .await
+            .unwrap();
+        set_avatar(&pool, created.id, "avatars/two.png")
             .await
             .unwrap();
-
-        set_avatar(&pool, created.id, "avatars/one.png").await.unwrap();
-        set_avatar(&pool, created.id, "avatars/two.png").await.unwrap();
 
         let rows: Vec<(String,)> =
             sqlx::query_as("SELECT s3_key FROM avatars WHERE account_id = $1")