v1.0.0 — Hexagonal architecture rewrite

Restructure the monolithic 252-line main.rs into a 10-crate workspace
with clean hexagonal architecture, swappable adapters, and a production-
ready deployment pipeline.

Backend architecture:
- domain: Canvas, Color/Position/PixelUpdate value objects, port traits
  (CanvasStore, CanvasPersistence, EventBroadcaster), BroadcastEvent
- application: use cases (place_pixel, get_state, save/restore snapshot,
  connect/disconnect), AppState with Arc snapshot cache
- config: AppConfig structs + ConfigSource trait
- api-types: shared DTOs, event name constants
- adapters: config-env, canvas-file, http-axum (rust-embed), socketio,
  websocket — all behind port traits, swappable via feature flags
- server: composition root with graceful shutdown (SIGTERM/SIGINT)

Frontend:
- Transport abstraction: Socket.IO and native WebSocket via VITE_TRANSPORT
- Canvas zoom/pan with mouse wheel, pinch-to-zoom, and +/- buttons
- ImageData rendering (~50x faster than fillRect loop)
- Touch support, responsive CSS scaling, mobile-friendly layout
- OG/Twitter Card meta tags for rich link previews

Production:
- Docker: musl static build on scratch — 2.73MB image
- CI workflows for Gitea and GitHub Actions (fmt, clippy, test, Docker push)
- deploy.sh for private registry
- 39 unit tests across domain and application
- Zero unwraps, zero unsafe, graceful error handling with tracing
- Periodic canvas snapshots with rotation, restored on startup
- All config via environment variables with typed defaults

crates/adapters/socketio/src/handlers.rs

@@ -0,0 +1,109 @@
+use std::sync::Arc;
+
+use api_types::{self, PixelUpdatePayload};
+use application::AppState;
+use application::canvas::place_pixel;
+use domain::{BroadcastEvent, BroadcastSubscription, Color, Position};
+use socketioxide::extract::{Data, SocketRef};
+use tracing::info;
+
+pub async fn on_connect(socket: SocketRef, state: Arc<AppState>) {
+    info!("Socket connected: {:?} {:?}", socket.ns(), socket.id);
+
+    let subscription = state.broadcaster().subscribe();
+
+    send_canvas_state(&socket, &state);
+    register_soldier(&state, &socket);
+    spawn_broadcast_forwarder(socket.clone(), subscription);
+    register_place_pixel_handler(&socket, state.clone());
+    register_disconnect_handler(&socket, state);
+}
+
+fn send_canvas_state(socket: &SocketRef, state: &AppState) {
+    let canvas_pixels = application::canvas::get_state::execute(state);
+    let pixel_values = Color::collect_as_u32(&canvas_pixels);
+    socket
+        .emit(api_types::events::CANVAS_STATE, &pixel_values)
+        .ok();
+}
+
+fn register_soldier(state: &AppState, socket: &SocketRef) {
+    let socket_id = socket.id.to_string();
+    application::soldiers::connect::execute(state, socket_id);
+}
+
+fn spawn_broadcast_forwarder(socket: SocketRef, mut subscription: BroadcastSubscription) {
+    tokio::spawn(async move {
+        while let Some(event) = subscription.recv().await {
+            if forward_broadcast_event(&socket, &event).is_err() {
+                break;
+            }
+        }
+    });
+}
+
+fn forward_broadcast_event(socket: &SocketRef, event: &BroadcastEvent) -> Result<(), ()> {
+    match event {
+        BroadcastEvent::PixelUpdated(update) => {
+            let payload = PixelUpdatePayload::from(*update);
+            socket
+                .emit(api_types::events::PIXEL_UPDATED, &payload)
+                .map_err(|_| ())
+        }
+        BroadcastEvent::SoldierCountChanged(count) => socket
+            .emit(api_types::events::CURRENT_SOLDIERS, count)
+            .map_err(|_| ()),
+    }
+}
+
+fn register_place_pixel_handler(socket: &SocketRef, state: Arc<AppState>) {
+    socket.on(
+        api_types::events::PLACE_PIXEL,
+        move |socket: SocketRef, Data::<PixelUpdatePayload>(payload)| async move {
+            handle_place_pixel(&socket, &state, payload);
+        },
+    );
+}
+
+fn handle_place_pixel(socket: &SocketRef, state: &AppState, payload: PixelUpdatePayload) {
+    let position = Position::new(payload.x, payload.y);
+    let color = Color::new(payload.color);
+
+    info!("Received pixel update: {position} color={}", color.as_u32());
+
+    let socket_id = socket.id.to_string();
+    let command = place_pixel::Command {
+        user_id: &socket_id,
+        position,
+        color,
+    };
+
+    match place_pixel::execute(state, command) {
+        Ok(place_pixel::Outcome::Placed(_)) => {}
+        Ok(place_pixel::Outcome::CooldownActive) => {
+            emit_error(socket, domain::COOLDOWN_MESSAGE);
+        }
+        Err(err) => {
+            emit_error(socket, &err.to_string());
+        }
+    }
+}
+
+fn register_disconnect_handler(socket: &SocketRef, state: Arc<AppState>) {
+    socket.on_disconnect(move |socket: SocketRef| async move {
+        handle_disconnect(&socket, &state);
+    });
+}
+
+fn handle_disconnect(socket: &SocketRef, state: &AppState) {
+    info!("Socket disconnected: {:?}", socket.id);
+    let socket_id = socket.id.to_string();
+    application::soldiers::disconnect::execute(state, &socket_id);
+}
+
+fn emit_error(socket: &SocketRef, message: &str) {
+    let _ = socket.emit(
+        api_types::events::ERROR,
+        &serde_json::Value::String(message.to_string()),
+    );
+}

crates/adapters/socketio/src/lib.rs

@@ -0,0 +1,12 @@
+mod handlers;
+
+use std::sync::Arc;
+
+use application::AppState;
+use socketioxide::{SocketIo, extract::SocketRef};
+
+pub fn setup_namespaces(io: &SocketIo, state: Arc<AppState>) {
+    io.ns("/", move |socket: SocketRef| async move {
+        handlers::on_connect(socket, state).await;
+    });
+}