style: rustfmt after emoji runtime refactor

.env.template

···
 # Dev Mode Configuration
 DEV_MODE="false"       # Enable dev mode for testing with dummy data. Access via ?dev=true query parameter when enabled.
 
-
+# Custom Emojis
+# Directory to read/write custom emoji image files at runtime.
+# For local dev, keep under the repo:
+EMOJI_DIR="static/emojis"

README.md

···
 # navigate to http://127.0.0.1:8080
 ```
 
+### custom emojis (no redeploys)
+
+Emojis are now served from a runtime directory configured by `EMOJI_DIR` (defaults to `static/emojis` locally; set to `/data/emojis` on Fly.io). On startup, if the runtime emoji directory is empty, it will be seeded from the bundled `static/emojis`.
+
+- Local dev: add image files to `static/emojis/` (or set `EMOJI_DIR` in `.env`).
+- Production (Fly.io): upload files directly into the mounted volume at `/data/emojis` — no rebuild or redeploy needed.
+
+Examples with Fly CLI:
+
+```bash
+# Open an SSH console to the machine
+fly ssh console -a zzstoatzz-status
+
+# Inside the VM, copy or fetch files into /data/emojis
+mkdir -p /data/emojis
+curl -L -o /data/emojis/my_new_emoji.png https://example.com/my_new_emoji.png
+```
+
+Or from your machine using SFTP:
+
+```bash
+fly ssh sftp -a zzstoatzz-status
+sftp> put ./static/emojis/my_new_emoji.png /data/emojis/
+```
+
+The app serves them at `/emojis/<filename>` and lists them via `/api/custom-emojis`.
+
 ### available commands
 
 we use [just](https://github.com/casey/just) for common tasks:
···
 - [at protocol](https://atproto.com/) (via [atrium-rs](https://github.com/sugyan/atrium))
 - [sqlite](https://www.sqlite.org/) for local storage
 - [jetstream](https://github.com/bluesky-social/jetstream) for firehose consumption
-- [fly.io](https://fly.io/) for hosting
+- [fly.io](https://fly.io/) for hosting

fly.toml

···
   DATABASE_URL = "sqlite:///data/status.db"
   ENABLE_FIREHOSE = "true"
   OAUTH_REDIRECT_BASE = "https://status.zzstoatzz.io"
+  EMOJI_DIR = "/data/emojis"
 
 [http_service]
   internal_port = 8080
···
 [[vm]]
   cpu_kind = "shared"
   cpus = 1
-  memory_mb = 512
+  memory_mb = 512

src/api/status.rs

···
+use crate::config::Config;
 use crate::resolver::HickoryDnsTxtResolver;
 use crate::{
     api::auth::OAuthClientType,
···
 
 /// Get all custom emojis available on the site
 #[get("/api/custom-emojis")]
-pub async fn get_custom_emojis() -> Result<impl Responder> {
+pub async fn get_custom_emojis(app_config: web::Data<Config>) -> Result<impl Responder> {
     use std::fs;
 
     #[derive(Serialize)]
···
         filename: String,
     }
 
-    let emojis_dir = "static/emojis";
+    let emojis_dir = app_config.emoji_dir.clone();
     let mut emojis = Vec::new();
 
-    if let Ok(entries) = fs::read_dir(emojis_dir) {
+    if let Ok(entries) = fs::read_dir(&emojis_dir) {
         for entry in entries.flatten() {
             if let Some(filename) = entry.file_name().to_str() {
                 // Only include image files

src/config.rs

···
 
     /// Dev mode for testing with dummy data
     pub dev_mode: bool,
+
+    /// Directory to serve and manage custom emojis from
+    pub emoji_dir: String,
 }
 
 impl Config {
···
                 .unwrap_or_else(|_| "false".to_string())
                 .parse()
                 .unwrap_or(false),
+            // Default to static/emojis for local dev; override in prod to /data/emojis
+            emoji_dir: env::var("EMOJI_DIR").unwrap_or_else(|_| "static/emojis".to_string()),
         })
     }
 }

src/emoji.rs

···
+use std::{fs, path::Path};
+
+use crate::config::Config;
+
+/// Ensure the runtime emoji directory exists, and seed it from the bundled
+/// `static/emojis` on first run if the runtime directory is empty.
+pub fn init_runtime_dir(config: &Config) {
+    let runtime_emoji_dir = &config.emoji_dir;
+    let bundled_emoji_dir = "static/emojis";
+
+    if let Err(e) = fs::create_dir_all(runtime_emoji_dir) {
+        log::warn!(
+            "Failed to ensure emoji directory exists at {}: {}",
+            runtime_emoji_dir,
+            e
+        );
+        return;
+    }
+
+    let should_seed = runtime_emoji_dir != bundled_emoji_dir
+        && fs::read_dir(runtime_emoji_dir)
+            .map(|mut it| it.next().is_none())
+            .unwrap_or(false);
+
+    if !should_seed {
+        return;
+    }
+
+    if !Path::new(bundled_emoji_dir).exists() {
+        return;
+    }
+
+    match fs::read_dir(bundled_emoji_dir) {
+        Ok(entries) => {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if let Some(name) = path.file_name() {
+                    let dest = Path::new(runtime_emoji_dir).join(name);
+                    if path.is_file() {
+                        if let Err(err) = fs::copy(&path, &dest) {
+                            log::warn!("Failed to seed emoji {:?} -> {:?}: {}", path, dest, err);
+                        }
+                    }
+                }
+            }
+            log::info!(
+                "Seeded emoji directory {} from {}",
+                runtime_emoji_dir,
+                bundled_emoji_dir
+            );
+        }
+        Err(err) => log::warn!(
+            "Failed to read bundled emoji directory {}: {}",
+            bundled_emoji_dir,
+            err
+        ),
+    }
+}

src/main.rs

···
 mod config;
 mod db;
 mod dev_utils;
+mod emoji;
 mod error_handler;
 mod ingester;
 #[allow(dead_code)]
···
     // Create rate limiter - 30 requests per minute per IP
     let rate_limiter = web::Data::new(RateLimiter::new(30, Duration::from_secs(60)));
 
+    // Initialize runtime emoji directory (kept out of main for clarity)
+    emoji::init_runtime_dir(&config);
+
     log::debug!("starting HTTP server at http://{host}:{port}");
     HttpServer::new(move || {
         App::new()
···
                     .build(),
             )
             .service(Files::new("/static", "static").show_files_listing())
-            .service(Files::new("/emojis", "static/emojis").show_files_listing())
+            .service(
+                Files::new("/emojis", app_config.emoji_dir.clone())
+                    .use_last_modified(true)
+                    .use_etag(true)
+                    .show_files_listing(),
+            )
             .configure(api::configure_routes)
     })
     .bind((host.as_str(), port))?
···
     #[actix_web::test]
     async fn test_custom_emojis_endpoint() {
         // Test that the custom emojis endpoint returns JSON
-        let app = test::init_service(App::new().service(get_custom_emojis)).await;
+        let cfg = crate::config::Config::from_env().expect("load config");
+        let app = test::init_service(
+            App::new()
+                .app_data(web::Data::new(cfg))
+                .service(get_custom_emojis),
+        )
+        .await;
 
         let req = test::TestRequest::get()
             .uri("/api/custom-emojis")