feat: polish mobile responsive layout across all dashboard screens

.dockerignore

@@ -0,0 +1,27 @@
+.git
+.gitignore
+
+.venv
+__pycache__
+*.py[cod]
+*.egg-info
+.ruff_cache
+.ipynb_checkpoints
+.pytest_cache
+.mypy_cache
+
+frontend/node_modules
+frontend/dist
+frontend/.vite
+
+data/raw
+mlruns
+notebooks
+
+.vscode
+.idea
+.DS_Store
+
+Dockerfile*
+docker-compose*.yml
+.dockerignore

.gitattributes

@@ -0,0 +1,10 @@
+data/processed/*.npy filter=lfs diff=lfs merge=lfs -text
+data/processed/*.npz filter=lfs diff=lfs merge=lfs -text
+models/*.pt filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,11 @@
+.venv/
+__pycache__/
+*.py[cod]
+.ipynb_checkpoints/
+.ruff_cache/
+*.egg-info/
+/data/raw
+/mlruns/
+.DS_Store
+.vscode/
+.idea/

.python-version

@@ -0,0 +1 @@
+3.11

Dockerfile

@@ -0,0 +1,77 @@
+FROM node:20-alpine AS frontend
+
+RUN corepack enable && corepack prepare pnpm@9.12.0 --activate
+
+WORKDIR /web
+
+COPY frontend/package.json frontend/pnpm-lock.yaml ./
+RUN pnpm install --frozen-lockfile
+
+COPY frontend/ ./
+RUN pnpm build
+
+
+FROM python:3.11-slim AS backend-builder
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    UV_LINK_MODE=copy \
+    UV_PROJECT_ENVIRONMENT=/opt/venv
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        build-essential \
+        curl \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --from=ghcr.io/astral-sh/uv:0.5.11 /uv /usr/local/bin/uv
+
+WORKDIR /app
+
+COPY pyproject.toml uv.lock ./
+COPY src ./src
+
+RUN uv sync --frozen --no-dev
+
+
+FROM python:3.11-slim AS runtime
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PATH="/opt/venv/bin:$PATH" \
+    HOME=/home/user \
+    SADAR_PROCESSED_DIR=/app/data/processed \
+    SADAR_MODELS_DIR=/app/models \
+    SADAR_REPORTS_DIR=/app/reports \
+    SADAR_SERVE_CONFIG=/app/configs/serve.yaml \
+    SADAR_FRONTEND_DIR=/app/frontend/dist \
+    PORT=7860
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        libgomp1 \
+        curl \
+    && rm -rf /var/lib/apt/lists/* \
+    && useradd --create-home --uid 1000 --shell /bin/bash user
+
+WORKDIR /app
+
+COPY --from=backend-builder /opt/venv /opt/venv
+COPY --from=backend-builder /app/src /app/src
+COPY --from=frontend /web/dist /app/frontend/dist
+
+COPY configs ./configs
+COPY pyproject.toml ./
+COPY models ./models
+COPY reports ./reports
+COPY data/processed/scaler.npz data/processed/test.npy data/processed/val.npy ./data/processed/
+
+RUN chown -R user:user /app
+
+USER user
+
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=30s --retries=3 \
+    CMD curl -fsS http://localhost:${PORT}/api/health || exit 1
+
+CMD ["sh", "-c", "uvicorn sadar.serve.app:app --host 0.0.0.0 --port ${PORT}"]

Dockerfile.backend

@@ -0,0 +1,59 @@
+FROM python:3.11-slim AS builder
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    UV_LINK_MODE=copy \
+    UV_PROJECT_ENVIRONMENT=/opt/venv
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        build-essential \
+        curl \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --from=ghcr.io/astral-sh/uv:0.5.11 /uv /usr/local/bin/uv
+
+WORKDIR /app
+
+COPY pyproject.toml uv.lock ./
+COPY src ./src
+
+RUN uv sync --frozen --no-dev
+
+
+FROM python:3.11-slim AS runtime
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PATH="/opt/venv/bin:$PATH" \
+    SADAR_PROCESSED_DIR=/app/data/processed \
+    SADAR_MODELS_DIR=/app/models \
+    SADAR_REPORTS_DIR=/app/reports \
+    SADAR_SERVE_CONFIG=/app/configs/serve.yaml
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        libgomp1 \
+        curl \
+    && rm -rf /var/lib/apt/lists/* \
+    && groupadd --system --gid 1000 sadar \
+    && useradd  --system --uid 1000 --gid sadar --create-home sadar
+
+WORKDIR /app
+
+COPY --from=builder /opt/venv /opt/venv
+COPY --from=builder /app/src /app/src
+
+COPY configs ./configs
+COPY pyproject.toml ./
+
+RUN mkdir -p /app/data/processed /app/models /app/reports \
+    && chown -R sadar:sadar /app
+
+USER sadar
+
+EXPOSE 8000
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=20s --retries=3 \
+    CMD curl -fsS http://localhost:8000/api/health || exit 1
+
+CMD ["uvicorn", "sadar.serve.app:app", "--host", "0.0.0.0", "--port", "8000"]

Makefile

@@ -0,0 +1,85 @@
+.DEFAULT_GOAL := help
+.PHONY: help install notebook preprocess baseline train-lstm train-transformer train-vae tune-vae evaluate compare serve web dev artifacts mlflow-ui lint clean docker-build docker-up docker-down docker-logs
+
+PROCESSED_DIR ?= data/processed
+MODELS_DIR ?= models
+VAE_CHECKPOINT ?= $(MODELS_DIR)/vae_lstm.pt
+SCALER ?= $(PROCESSED_DIR)/scaler.npz
+
+help: ## Show this help
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | \
+		awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-14s\033[0m %s\n", $$1, $$2}'
+
+install: ## Create the Python environment with uv
+	uv sync
+
+notebook: ## Open Jupyter for the notebooks (EDA, etc.)
+	uv run jupyter lab
+
+preprocess: ## Run the preprocessing pipeline (raw -> tensors)
+	uv run sadar-preprocess
+
+baseline: ## Fit and evaluate the Isolation Forest baseline
+	uv run sadar-baseline
+
+train-lstm: ## Train the LSTM autoencoder on the normal flights
+	uv run sadar-train-lstm
+
+train-transformer: ## Train the Transformer autoencoder on the normal flights
+	uv run sadar-train-transformer
+
+train-vae: ## Train the VAE-LSTM on the normal flights
+	uv run sadar-train-vae
+
+tune-vae: ## Search VAE-LSTM hyperparameters with Optuna
+	uv run sadar-tune-vae
+
+evaluate: ## Evaluate a trained autoencoder against synthetic anomalies
+	uv run sadar-evaluate
+
+compare: ## Compare every detector and select the final model
+	uv run sadar-compare
+
+artifacts: ## Ensure the preprocessed tensors and the VAE checkpoint exist
+	@if [ ! -f "$(SCALER)" ]; then \
+		echo "[artifacts] $(SCALER) missing, running preprocess..."; \
+		$(MAKE) preprocess; \
+	fi
+	@if [ ! -f "$(VAE_CHECKPOINT)" ]; then \
+		echo "[artifacts] $(VAE_CHECKPOINT) missing, trying to restore from MLflow..."; \
+		uv run python -m sadar.models.restore || true; \
+	fi
+	@if [ ! -f "$(VAE_CHECKPOINT)" ]; then \
+		echo "[artifacts] still missing, training VAE-LSTM..."; \
+		$(MAKE) train-vae; \
+	fi
+
+serve: artifacts ## Run the inference API for the dashboard
+	uv run uvicorn sadar.serve.app:app --port 8000
+
+web: ## Run the frontend dev server (Vite)
+	pnpm -C frontend dev
+
+dev: artifacts ## Run the backend API and the frontend dev server together
+	@trap 'kill 0' EXIT; uv run uvicorn sadar.serve.app:app --port 8000 & pnpm -C frontend dev
+
+mlflow-ui: ## Open the MLflow experiment tracking UI
+	uv run mlflow ui --backend-store-uri file:mlruns
+
+lint: ## Python linter
+	uv run ruff check src
+
+clean: ## Clean caches and artifacts
+	rm -rf .ruff_cache **/__pycache__
+
+docker-build: ## Build the backend and frontend container images
+	docker compose build
+
+docker-up: ## Start the stack in the background (backend on :8000, frontend on :5180)
+	docker compose up -d
+
+docker-down: ## Stop the stack and remove the containers
+	docker compose down
+
+docker-logs: ## Tail the logs of the running stack
+	docker compose logs -f

README.es.md

@@ -0,0 +1,359 @@
+<div align="center">
+
+<img src="docs/assets/logo.png" alt="SADAR" width="220" />
+
+<h1>SADAR</h1>
+
+<p><b>Smart Anomaly Detection for Aviation Routes</b></p>
+
+<p>Detección temprana de comportamiento de vuelo no conforme sobre Madrid-Barajas (LEMD).</p>
+
+<p>
+  <img src="docs/assets/qr-placeholder.png" alt="QR" width="220" onerror="this.style.display='none'" />
+</p>
+
+<p>
+  <a href="README.md"><img src="https://img.shields.io/badge/English-0d1a1f?style=flat&logoColor=7fd1c6&labelColor=0a1014" alt="English" /></a>
+  ·
+  <a href="README.es.md"><img src="https://img.shields.io/badge/Espa%C3%B1ol-0d1a1f?style=flat&logoColor=7fd1c6&labelColor=0a1014" alt="Español" /></a>
+</p>
+
+<p>
+  <img src="https://img.shields.io/badge/Python-3.11-0a1014?logo=python&logoColor=7fd1c6&labelColor=0d1a1f" />
+  <img src="https://img.shields.io/badge/PyTorch-2.x-0a1014?logo=pytorch&logoColor=7fd1c6&labelColor=0d1a1f" />
+  <img src="https://img.shields.io/badge/FastAPI-0.136-0a1014?logo=fastapi&logoColor=7fd1c6&labelColor=0d1a1f" />
+  <img src="https://img.shields.io/badge/React-18-0a1014?logo=react&logoColor=7fd1c6&labelColor=0d1a1f" />
+  <img src="https://img.shields.io/badge/Vite-5-0a1014?logo=vite&logoColor=7fd1c6&labelColor=0d1a1f" />
+  <img src="https://img.shields.io/badge/MLflow-3.x-0a1014?logo=mlflow&logoColor=7fd1c6&labelColor=0d1a1f" />
+  <img src="https://img.shields.io/badge/Optuna-4.x-0a1014?logoColor=7fd1c6&labelColor=0d1a1f" />
+  <img src="https://img.shields.io/badge/uv-package%20mgr-0a1014?logoColor=7fd1c6&labelColor=0d1a1f" />
+  <img src="https://img.shields.io/badge/Hugging%20Face-Spaces-0a1014?logo=huggingface&logoColor=7fd1c6&labelColor=0d1a1f" />
+  <img src="https://img.shields.io/badge/Docker-compose-0a1014?logo=docker&logoColor=7fd1c6&labelColor=0d1a1f" />
+</p>
+
+<p>
+  <a href="https://medium.com/@devrup404/cuando-el-modelo-m%C3%A1s-complejo-no-es-el-que-detecta-mejor-db64f1195ae9"><img src="https://img.shields.io/badge/Medium-Leer%20el%20art%C3%ADculo-0a1014?logo=medium&logoColor=7fd1c6&labelColor=0d1a1f" alt="Leer en Medium" /></a>
+</p>
+
+</div>
+
+---
+
+### Descripción del proyecto
+
+**SADAR** (Smart Anomaly Detection for Aviation Routes) es un sistema de deep learning que aprende cómo es una aproximación o despegue **normal** en Madrid-Barajas (LEMD) y marca cualquier trayectoria que se desvíe del patrón aprendido: motores y al aire (go-arounds), rutas anómalas, pérdidas de transpondedor o maniobras compatibles con una emergencia.
+
+Está construido sobre tres autoencoders profundos entrenados con unos 20.000 vuelos reales de ADS-B de la red OpenSky: un **autoencoder LSTM**, un **autoencoder Transformer** y un **VAE-LSTM**. Los tres se entrenan en igualdad de condiciones y se comparan cabeza a cabeza; el **VAE-LSTM** es el que se sirve en producción porque combina la mejor PR-AUC con la menor latencia de detección.
+
+> **Alcance.** SADAR se entrena exclusivamente con operaciones normales de LEMD y funciona como monitor de conformidad de trayectorias: aprende el patrón normal y señala cualquier desviación para revisión humana. No es un predictor de eventos catastróficos.
+
+### Lo destacado
+
+- **Deep learning de una sola clase** sobre 7 variables dinámicas (posición, altitud, velocidad, seno/coseno del rumbo, régimen vertical).
+- **Selección comparativa**: baseline Isolation Forest vs LSTM vs Transformer vs VAE-LSTM con el mismo preprocesado y las mismas métricas.
+- **Banco de anomalías sintéticas** con cinco tipos de inyección (desviación de ruta, salto de altitud, anomalía de velocidad, holding, congelado de transpondedor) en varias intensidades, mide **PR-AUC** y **latencia de detección**.
+- **Dashboard estilo torre de control** con React + Vite: radar en vivo, ranking de anomalías, simulador con sliders y página de métricas.
+- **Totalmente reproducible**: `uv` para Python, `pnpm` para el front, configs YAML, semillas fijas.
+
+### Stack
+
+| Capa | Herramientas |
+|---|---|
+| Modelos | PyTorch · scikit-learn (baseline) · Optuna · MLflow |
+| Datos | pandas · pyarrow · pyproj · NumPy |
+| Backend | FastAPI · uvicorn · uv |
+| Frontend | React 18 · Vite 5 · TypeScript · framer-motion |
+| Despliegue | Docker · Hugging Face Spaces |
+
+### Capturas de la demo
+
+<details>
+<summary><b>1. Consola torre - radar en directo sobre LEMD</b></summary>
+
+![Radar en vivo sobre Madrid-Barajas](docs/assets/img1.png)
+
+Scope en tiempo real centrado en Barajas. Cada aeronave se colorea según su estado (en seguimiento / en alerta) y el panel lateral muestra todos los vuelos del espacio aéreo con su indicativo y su estado.
+
+</details>
+
+<details>
+<summary><b>2. Simulador - inyecta una anomalía y observa la alerta</b></summary>
+
+![Simulador de anomalías](docs/assets/img2.png)
+
+La estrella de la demo. Eliges un vuelo normal, seleccionas el tipo de anomalía (desviación de ruta, salto de altitud, velocidad, holding, corte de transpondedor), ajustas intensidad y momento, y la inyectas en vivo. El score de la derecha cruza el umbral y se reporta la latencia en segundos.
+
+</details>
+
+<details>
+<summary><b>3. Métricas - comparación de modelos y detector elegido</b></summary>
+
+![Página de comparación de modelos](docs/assets/img3.png)
+
+Reporta la PR-AUC y el desempeño por anomalía de baseline, LSTM, Transformer y VAE-LSTM, además del motivo por el que se selecciona el **VAE-LSTM** como modelo de producción.
+
+</details>
+
+<details>
+<summary><b>4. Métricas - desglose por tipo de anomalía</b></summary>
+
+![Desglose de métricas por anomalía](docs/assets/img4.png)
+
+PR-AUC detallada por tipo de anomalía e intensidad. Sirve para justificar qué detector funciona mejor en cada modo de fallo.
+
+</details>
+
+<details>
+<summary><b>5. Consola torre - instantánea completa del tráfico de LEMD</b></summary>
+
+![Tráfico completo en LEMD](docs/assets/img5.png)
+
+Vista más amplia del radar con toda la flota visible, bloque de datos del vuelo y, abajo a la derecha, el histograma en vivo del anomaly score.
+
+</details>
+
+<details>
+<summary><b>6. Consola torre - alerta levantada sobre un vuelo</b></summary>
+
+![Alerta sobre un vuelo](docs/assets/img6.png)
+
+Una aeronave marcada se pone en rojo y el controlador recibe el score, el umbral y la clasificación sugerida en el panel derecho.
+
+</details>
+
+### Arquitectura
+
+```
+        ┌──────────────────┐         ┌──────────────────┐
+        │  Parquet ADS-B   │         │  Banco anomalías │
+        │  (OpenSky / LEMD)│         │  sintéticas      │
+        └────────┬─────────┘         └────────┬─────────┘
+                 │                            │
+        ┌────────▼────────┐                   │
+        │ Preprocesado    │                   │
+        │ · limpieza      │                   │
+        │ · resample 10s  │                   │
+        │ · XY relativos  │                   │
+        │ · sin/cos rumbo │                   │
+        │ · estandarizado │                   │
+        └────────┬────────┘                   │
+                 │                            │
+        ┌────────▼────────────────────────────▼────────┐
+        │   Entrenamiento (solo vuelos normales)       │
+        │  ┌──────────┐ ┌─────────────┐ ┌────────────┐ │
+        │  │ Isolation│ │ LSTM-AE     │ │ Transformer│ │
+        │  │ Forest   │ │             │ │ AE         │ │
+        │  └──────────┘ └─────────────┘ └────────────┘ │
+        │            ┌─────────────────┐               │
+        │            │  VAE-LSTM ★     │  ← elegido    │
+        │            └─────────────────┘               │
+        └────────┬─────────────────────────────────────┘
+                 │  checkpoint + scaler + umbral
+        ┌────────▼─────────┐
+        │  Servicio FastAPI│  /api/health · /api/scene
+        │  (uvicorn)       │  /api/flights · /api/metrics
+        └────────┬─────────┘  /api/simulate
+                 │
+        ┌────────▼─────────┐
+        │  React + Vite    │  Radar · Simulador · Métricas
+        │  dashboard       │
+        └──────────────────┘
+```
+
+### Ejecutarlo en local
+
+Requisitos: **Python 3.11**, [`uv`](https://docs.astral.sh/uv/) para las deps de Python, **Node 20+** y [`pnpm`](https://pnpm.io/) para el frontend.
+
+Dashboard en `http://localhost:5180`, API en `http://localhost:8000`.
+
+<details>
+<summary><b>macOS / Linux - con Makefile (recomendado)</b></summary>
+
+```bash
+uv sync
+pnpm -C frontend install
+make dev
+```
+
+`make dev` arranca el backend FastAPI y el frontend Vite juntos con hot reload.
+
+</details>
+
+<details>
+<summary><b>macOS / Linux - sin Makefile</b></summary>
+
+Dos terminales:
+
+```bash
+# terminal 1: backend
+uv sync
+uv run uvicorn sadar.serve.app:app --port 8000
+
+# terminal 2: frontend
+pnpm -C frontend install
+pnpm -C frontend dev
+```
+
+</details>
+
+<details>
+<summary><b>Windows (PowerShell)</b></summary>
+
+PowerShell no trae `make`; arranca los dos servicios en dos terminales.
+
+```powershell
+# instalación una sola vez
+uv sync
+pnpm -C frontend install
+
+# terminal 1: backend
+uv run uvicorn sadar.serve.app:app --port 8000
+
+# terminal 2: frontend
+pnpm -C frontend dev
+```
+
+Si no tienes `pnpm`: `npm install -g pnpm`. Si no tienes `uv`: `winget install astral-sh.uv`.
+
+</details>
+
+<details>
+<summary><b>Windows con Make (Chocolatey / scoop / WSL)</b></summary>
+
+```powershell
+choco install make    # o: scoop install make
+make dev
+```
+
+O ejecuta todo dentro de WSL Ubuntu y sigue las instrucciones de macOS / Linux.
+
+</details>
+
+### Ejecutarlo con Docker
+
+Igual en cualquier sistema operativo, solo necesitas Docker Desktop / Docker Engine.
+
+<details>
+<summary><b>Un contenedor con Docker Compose</b></summary>
+
+```bash
+docker compose up --build
+```
+
+Abre `http://localhost:5180`. Modelos, tensores preprocesados e informes se montan en sólo lectura desde `./models`, `./data/processed` y `./reports`.
+
+</details>
+
+<details>
+<summary><b>Imagen única (la misma que en producción / Hugging Face Spaces)</b></summary>
+
+```bash
+docker build -t sadar .
+docker run --rm -p 7860:7860 sadar
+```
+
+Abre `http://localhost:7860`. Los modelos, tensores e informes van dentro de la imagen; no necesitas volúmenes.
+
+</details>
+
+### Desplegar en Hugging Face Spaces
+
+El repositorio trae un [Dockerfile](Dockerfile) listo para HF Spaces (una sola imagen, el frontend servido por FastAPI en el puerto 7860).
+
+```bash
+git lfs install
+git clone https://huggingface.co/spaces/<tu-usuario>/sadar
+cd sadar
+# copia los archivos del repositorio SADAR dentro
+git lfs track "*.npy" "*.npz" "*.pt"
+git add . && git commit -m "feat: initial deploy" && git push
+```
+
+### Estructura del repositorio
+
+```
+SADAR/
+├── src/sadar/                       Paquete Python (importable como `sadar`)
+│   ├── data/                          Pipeline de datos (parquet crudo → tensores)
+│   │   ├── pipeline.py                  Punto de entrada: `sadar-preprocess`
+│   │   ├── io.py                        Carga de parquet, dedupe, manifests
+│   │   ├── cleaning.py                  Nulos, huecos, eliminación de go-arounds
+│   │   ├── features.py                  XY relativo a pista, sin/cos del rumbo
+│   │   ├── scaling.py                   Estandarización por feature (fit solo en train)
+│   │   ├── splitting.py                 Split sin leak por flight_id y fecha
+│   │   └── windowing.py                 Ventanas de longitud fija
+│   ├── models/                        Modelos y entrenadores
+│   │   ├── baseline.py                  Baseline Isolation Forest
+│   │   ├── lstm_autoencoder.py          Arquitectura LSTM-AE
+│   │   ├── transformer_autoencoder.py   Arquitectura Transformer-AE
+│   │   ├── vae_lstm.py                  Arquitectura VAE-LSTM (elegida)
+│   │   ├── training.py                  Loop común, device, checkpoint I/O
+│   │   ├── train_lstm.py                Entrada: `sadar-train-lstm`
+│   │   ├── train_transformer.py         Entrada: `sadar-train-transformer`
+│   │   ├── train_vae.py                 Entrada: `sadar-train-vae`
+│   │   └── tune_vae.py                  Búsqueda Optuna: `sadar-tune-vae`
+│   ├── eval/                          Evaluación y banco sintético
+│   │   ├── synthetic.py                 Inyección de anomalías (5 tipos, varias intensidades)
+│   │   ├── evaluate.py                  Evaluación por modelo: `sadar-evaluate`
+│   │   └── compare.py                   Informe comparativo: `sadar-compare`
+│   └── serve/                         Inferencia en producción
+│       ├── app.py                       App FastAPI (también sirve la SPA en prod)
+│       └── inference.py                 ConformanceService (carga modelo + scaler)
+│
+├── frontend/                        Dashboard React + Vite (pnpm)
+│   ├── src/
+│   │   ├── pages/                       Dashboard, Simulador, Métricas, Presentación
+│   │   ├── components/                  RadarScope, paneles, gráficas
+│   │   ├── api.ts                       Cliente tipado para /api/*
+│   │   └── i18n.tsx                     Traducciones EN / ES
+│   ├── public/                          Logo y estáticos
+│   ├── vite.config.ts                   Proxy de dev /api → :8000
+│   └── package.json
+│
+├── configs/                         Configuración YAML
+│   ├── preprocessing.yaml
+│   ├── baseline.yaml
+│   ├── lstm.yaml · transformer.yaml · vae.yaml
+│   ├── tune.yaml · eval.yaml · compare.yaml
+│   └── serve.yaml                       Selecciona el checkpoint de producción
+│
+├── models/                          Checkpoints entrenados (Git LFS)
+│   ├── lstm_autoencoder.pt
+│   ├── transformer_autoencoder.pt
+│   └── vae_lstm.pt                      ★ servido en producción
+│
+├── data/
+│   ├── raw/                           Parquet ADS-B (fuera del repositorio, $SADAR_DATA_DIR)
+│   └── processed/                     Tensores estandarizados (Git LFS)
+│       ├── scaler.npz
+│       ├── train.npy · val.npy · test.npy
+│       └── anomalies.npy
+│
+├── reports/                         Métricas generadas
+│   ├── model_comparison.json
+│   └── vae_tuning.json
+│
+├── notebooks/                       EDA
+├── docs/assets/                     Capturas y logo del README
+│
+├── Dockerfile                       Imagen de producción (HF Spaces, un contenedor)
+├── docker-compose.yml               Stack local de dos contenedores
+├── pyproject.toml · uv.lock         Deps Python gestionadas con uv
+├── Makefile                         `make dev`, `make preprocess`, ...
+└── README.md · README.es.md         Este archivo (EN / ES)
+```
+
+### Limitaciones
+
+- El dataset no contiene incidentes reales catastróficos, SADAR valida una metodología, no eventos históricos.
+- No se dispone de planes de vuelo, la "ruta prevista" se aproxima como "patrón normal aprendido".
+- Los huecos de transpondedor son mayoritariamente cobertura del receptor, se usan como característica, no como etiqueta.
+- Solo hay cuatro vuelos reales con squawk de emergencia, se usan para validar, jamás para entrenar.
+
+---
+
+<div align="center">
+  <sub><b>SADAR</b> · Smart Anomaly Detection for Aviation Routes</sub>
+  <br />
+  <sub>Monitorización de conformidad de vuelos con deep learning sobre Madrid-Barajas (LEMD) · 2026</sub>
+</div>

README.md

@@ -0,0 +1,25 @@
+---
+title: SADAR Flight Conformance Monitor
+emoji: 🛬
+colorFrom: gray
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: false
+license: mit
+short_description: Anomaly detection on ADS-B trajectories at Madrid LEMD.
+---
+
+# SADAR — Hugging Face Space card
+
+This file is the README used **only** when the project is deployed to a Hugging Face
+Space. The YAML front-matter at the top is the Space card that Hugging Face needs to
+configure the container (SDK, port, title, colors, license).
+
+When deploying to Hugging Face Spaces, copy this file to the repository root as
+`README.md` (overwriting the GitHub one) before pushing to the Space remote. The GitHub
+`README.md` does not include this front-matter on purpose, so it renders cleanly on
+github.com.
+
+For the project description, screenshots, architecture and run instructions, see the
+main `README.md` at the repository root.

configs/baseline.yaml

@@ -0,0 +1,12 @@
+seed: 42
+
+data:
+  processed_dir: ${oc.env:SADAR_PROCESSED_DIR,data/processed}
+
+isolation_forest:
+  n_estimators: 200
+  max_samples: auto
+  contamination: auto
+
+threshold:
+  val_percentile: 99.0

configs/compare.yaml

@@ -0,0 +1,17 @@
+eval_config: configs/eval.yaml
+
+models:
+  - name: LSTM
+    checkpoint: ${oc.env:SADAR_MODELS_DIR,models}/lstm_autoencoder.pt
+  - name: Transformer
+    checkpoint: ${oc.env:SADAR_MODELS_DIR,models}/transformer_autoencoder.pt
+  - name: VAE-LSTM
+    checkpoint: ${oc.env:SADAR_MODELS_DIR,models}/vae_lstm.pt
+
+ensemble:
+  enabled: true
+  reducers: [mean, max]
+
+output:
+  path: ${oc.env:SADAR_REPORTS_DIR,reports}/model_comparison.json
+  curves_dir: ${oc.env:SADAR_REPORTS_DIR,reports}/figures

configs/eval.yaml

@@ -0,0 +1,31 @@
+seed: 42
+
+data:
+  processed_dir: ${oc.env:SADAR_PROCESSED_DIR,data/processed}
+
+preprocessing_config: configs/preprocessing.yaml
+baseline_config: configs/baseline.yaml
+
+model:
+  checkpoint: ${oc.env:SADAR_MODELS_DIR,models}/lstm_autoencoder.pt
+  device: auto
+
+synthetic:
+  sample_size: 2000
+  onset_fraction: 0.5
+  route_deviation:
+    magnitudes_m: [20000, 40000, 80000]
+  altitude:
+    magnitudes_m: [300, 800, 1500]
+  speed:
+    factors: [1.6, 2.2, 0.4]
+  holding:
+    turn_periods_s: [240, 120]
+  freeze:
+    enabled: true
+
+threshold:
+  val_percentile: 99.0
+
+latency:
+  normal_step_percentile: 99.0

configs/lstm.yaml

@@ -0,0 +1,24 @@
+seed: 42
+
+data:
+  processed_dir: ${oc.env:SADAR_PROCESSED_DIR,data/processed}
+
+model:
+  hidden_size: 64
+  latent_size: 16
+  num_layers: 1
+  dropout: 0.1
+
+training:
+  epochs: 50
+  batch_size: 256
+  learning_rate: 0.001
+  weight_decay: 0.0001
+  patience: 7
+  lr_factor: 0.5
+  lr_patience: 3
+  device: auto
+
+output:
+  dir: ${oc.env:SADAR_MODELS_DIR,models}
+  checkpoint: lstm_autoencoder.pt

configs/preprocessing.yaml

@@ -0,0 +1,48 @@
+seed: 42
+
+data:
+  raw_dir: ${oc.env:SADAR_DATA_DIR,data/raw}
+  file_glob: lemd_*.parquet
+  airport: LEMD
+
+runway:
+  ref_lat: 40.4936
+  ref_lon: -3.5668
+  projection_epsg: 32630
+
+resample:
+  seconds: 10
+
+cleaning:
+  min_points_per_flight: 40
+  max_gap_seconds: 120
+  max_missing_fraction: 0.5
+  remove_go_arounds: true
+  remove_emergency_squawks: true
+  emergency_squawks: [7500, 7600, 7700]
+  interpolate_columns: [lat, lon, baroaltitude, velocity, heading, vertrate]
+  go_around:
+    near_runway_m: 5000
+    descend_vertrate: -1.0
+    climb_vertrate: 2.0
+    min_climb_points: 3
+
+features:
+  columns: [x_rel, y_rel, baroaltitude, velocity, sin_hdg, cos_hdg, vertrate]
+  altitude_source: baroaltitude
+
+windowing:
+  length: 60
+  stride: 30
+
+split:
+  train_years: [2017, 2018, 2019]
+  eval_years: [2020]
+  val_fraction: 0.5
+
+scaling:
+  method: standard
+
+output:
+  dir: ${oc.env:SADAR_PROCESSED_DIR,data/processed}
+  format: npy

configs/serve.yaml

@@ -0,0 +1,5 @@
+eval_config: configs/eval.yaml
+
+checkpoint: ${oc.env:SADAR_MODELS_DIR,models}/vae_lstm.pt
+
+metrics: ${oc.env:SADAR_REPORTS_DIR,reports}/model_comparison.json

configs/transformer.yaml

@@ -0,0 +1,27 @@
+seed: 42
+
+data:
+  processed_dir: ${oc.env:SADAR_PROCESSED_DIR,data/processed}
+
+model:
+  d_model: 64
+  nhead: 4
+  num_layers: 2
+  dim_feedforward: 128
+  latent_size: 16
+  dropout: 0.1
+  max_len: 256
+
+training:
+  epochs: 50
+  batch_size: 256
+  learning_rate: 0.001
+  weight_decay: 0.0001
+  patience: 7
+  lr_factor: 0.5
+  lr_patience: 3
+  device: auto
+
+output:
+  dir: ${oc.env:SADAR_MODELS_DIR,models}
+  checkpoint: transformer_autoencoder.pt

configs/tune.yaml

@@ -0,0 +1,44 @@
+seed: 42
+
+data:
+  processed_dir: ${oc.env:SADAR_PROCESSED_DIR,data/processed}
+
+preprocessing_config: configs/preprocessing.yaml
+
+n_trials: 20
+
+search_space:
+  hidden_size: [32, 64, 128]
+  latent_size: [8, 16, 32]
+  num_layers: [1, 2]
+  dropout: [0.0, 0.3]
+  beta: [0.0001, 0.1]
+  learning_rate: [0.0003, 0.003]
+  weight_decay: [0.000001, 0.001]
+
+synthetic:
+  sample_size: 1500
+  onset_fraction: 0.5
+  route_deviation:
+    magnitudes_m: [20000, 40000, 80000]
+  altitude:
+    magnitudes_m: [300, 800, 1500]
+  speed:
+    factors: [1.6, 2.2, 0.4]
+  holding:
+    turn_periods_s: [240, 120]
+  freeze:
+    enabled: true
+
+training:
+  epochs: 30
+  batch_size: 256
+  learning_rate: 0.001
+  weight_decay: 0.0001
+  patience: 6
+  lr_factor: 0.5
+  lr_patience: 3
+  device: auto
+
+output:
+  path: ${oc.env:SADAR_REPORTS_DIR,reports}/vae_tuning.json

configs/vae.yaml

@@ -0,0 +1,25 @@
+seed: 42
+
+data:
+  processed_dir: ${oc.env:SADAR_PROCESSED_DIR,data/processed}
+
+model:
+  hidden_size: 64
+  latent_size: 8
+  num_layers: 1
+  dropout: 0.1488
+  beta: 0.0001193
+
+training:
+  epochs: 50
+  batch_size: 256
+  learning_rate: 0.001436
+  weight_decay: 0.0000054741
+  patience: 7
+  lr_factor: 0.5
+  lr_patience: 3
+  device: auto
+
+output:
+  dir: ${oc.env:SADAR_MODELS_DIR,models}
+  checkpoint: vae_lstm.pt

data/processed/anomalies.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc9b10f15b6b20da2d6c3ae51336d15f68e92d60802a0539d4ae2b27a5ea5171
+size 1807808

data/processed/scaler.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50bb65a11f9b41d2d6673b47fd83803cd847f19a5bde5860c05ba271e2891db4
+size 556

data/processed/test.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b66afdc544b8a34762131901244c30f7702983be692c321959638d6db9ffb66
+size 13083968

data/processed/train.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ac25b59731b49c1dc19180684a35198074f7e65fdc6cadd9149f42ab2902429
+size 102493568

data/processed/val.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8fc07743435ec2facb7c32649180b1d30d4d30892dbd933b75ce598b63f822a7
+size 12900848

docker-compose.yml

@@ -0,0 +1,33 @@
+name: sadar
+
+services:
+  backend:
+    build:
+      context: .
+      dockerfile: Dockerfile.backend
+    image: sadar-backend:latest
+    container_name: sadar-backend
+    environment:
+      SADAR_PROCESSED_DIR: /app/data/processed
+      SADAR_MODELS_DIR: /app/models
+      SADAR_REPORTS_DIR: /app/reports
+      SADAR_SERVE_CONFIG: /app/configs/serve.yaml
+    volumes:
+      - ./data/processed:/app/data/processed:ro
+      - ./models:/app/models:ro
+      - ./reports:/app/reports:ro
+    ports:
+      - "8000:8000"
+    restart: unless-stopped
+
+  frontend:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile
+    image: sadar-frontend:latest
+    container_name: sadar-frontend
+    depends_on:
+      - backend
+    ports:
+      - "5180:80"
+    restart: unless-stopped

docs/REPORT.es.md

@@ -0,0 +1,463 @@
+# SADAR
+
+**Smart Anomaly Detection for Aviation Routes**
+
+Memoria técnica
+
+---
+
+**Proyecto:** SADAR · Flight Conformance Monitor
+**Dominio:** Vigilancia de tráfico aéreo · datos ADS-B
+**Aeropuerto de estudio:** Madrid-Barajas (LEMD)
+**Enfoque:** Aprendizaje profundo de una sola clase para detección de anomalías en trayectorias
+**Fecha:** 2026
+
+---
+
+## Resumen ejecutivo
+
+SADAR es un sistema de aprendizaje profundo que aprende el patrón normal de las
+operaciones de aproximación y despegue en Madrid-Barajas (LEMD) a partir de datos de
+vigilancia ADS-B y señala en tiempo real cualquier trayectoria que se aparte de ese
+patrón. El sistema está concebido como **monitor de conformidad de vuelos**: no clasifica
+eventos concretos, asigna a cada vuelo del espacio aéreo una puntuación interpretable de
+anomalía para que un operador pueda revisar los casos que quedan fuera de la
+distribución aprendida.
+
+Se entrenan tres autoencoders secuenciales en igualdad de condiciones sobre unos 20.000
+vuelos reales obtenidos de la red OpenSky (un autoencoder LSTM, un autoencoder
+Transformer y un VAE-LSTM), junto con un baseline no secuencial basado en Isolation
+Forest. Los cuatro detectores se evalúan sobre el mismo conjunto de test y sobre un banco
+sintético con cinco tipos de inyección y varias intensidades. Se selecciona el
+**VAE-LSTM** como modelo de producción: obtiene la mejor PR-AUC sobre datos reales
+(0,299) y la mejor ROC-AUC media en el banco sintético (0,792). También se evalúan dos
+estrategias de ensemble (consenso y más sensible) y se descartan, porque ninguna mejora
+al mejor modelo individual.
+
+El modelo seleccionado se sirve a través de una aplicación FastAPI y de un dashboard
+React + Vite que combina un radar en vivo estilo torre de control, un ranking de
+anomalías, una página de métricas y un simulador interactivo. Todo el sistema es
+reproducible desde una única imagen Docker y está listo para desplegarse en Hugging Face
+Spaces.
+
+---
+
+## 1. Motivación y alcance
+
+La monitorización de trayectorias es una función central de la gestión del tráfico
+aéreo. Hoy se apoya en reglas deterministas y en supervisión humana: separación,
+perfiles de descenso, esperas o códigos de transpondedor de emergencia se vigilan
+contra umbrales fijos. Esas reglas funcionan bien para las situaciones para las que
+fueron diseñadas, pero no pueden anticipar comportamientos que sean inusuales sin ser
+una violación de manual.
+
+SADAR explora un enfoque complementario, basado en datos. En lugar de codificar reglas,
+el sistema **aprende** cómo es una operación normal en LEMD a partir de una muestra
+amplia de vuelos reales, y trata cada nueva trayectoria como más o menos compatible con
+esa distribución. La salida es una puntuación continua de conformidad que el operador
+puede ordenar, filtrar y umbralizar.
+
+El alcance del proyecto es deliberadamente acotado:
+
+- **Qué hace.** Detecta desviaciones respecto al patrón normal de tráfico de un único
+  aeropuerto (LEMD) a partir de un conjunto fijo de variables dinámicas extraídas de las
+  observaciones ADS-B.
+- **Qué no hace.** Predecir eventos operativos concretos, sustituir al controlador,
+  emitir recomendaciones de seguridad certificadas, ni generalizar sin reentrenamiento a
+  aeropuertos con procedimientos distintos.
+
+Esta formulación como **monitor de conformidad** es la que hace tratable el problema con
+los datos disponibles: solo requiere ejemplos de vuelo normal, que son abundantes, y
+deja clara la interpretación de la salida ("esta trayectoria no se parece a las que el
+modelo ha visto"), sin sobrevender.
+
+---
+
+## 2. Datos
+
+### 2.1 Fuente
+
+El dataset se construye a partir de observaciones ADS-B captadas por la red OpenSky en
+la zona terminal de Madrid-Barajas. Cubre aproximadamente 18 días de operaciones
+muestreados entre junio de 2017 y marzo de 2020. Cada aeronave se reporta una vez cada
+10 segundos, la cadencia natural de ADS-B.
+
+| Propiedad | Valor |
+|---|---|
+| Trayectorias totales | ≈ 20.000 (≈ 950 a 1.200 por día) |
+| Filas por día | 140.000 a 240.000 |
+| Columnas | 21 |
+| Puntos por vuelo (mín · mediana · máx) | 40 · 188 · 1.246 |
+
+### 2.2 Variables
+
+El esquema en bruto contiene información posicional (latitud, longitud, tiempo),
+dinámica (altitud barométrica y geométrica, velocidad respecto al suelo, rumbo, régimen
+vertical), campos derivados (distancia a pista, fase de vuelo), identidad (ICAO24,
+indicativo, identificador de vuelo) y estado del transpondedor (squawk, indicador de
+"en tierra", indicador de alerta, SPI y último contacto). Un campo, `operation`, está
+vacío en todo el dataset y se descarta.
+
+### 2.3 Calidad y limpieza
+
+Un análisis de perfilado sobre el dataset completo revela varios problemas que se
+gestionan en el pipeline de preprocesado:
+
+- **Valores ausentes.** `geoaltitude` falta en el 34,9 % de las filas, `baroaltitude` en
+  el 19,6 %, los campos cinemáticos (`velocity`, `heading`, `vertrate`) en torno al
+  19 %. El resto se queda por debajo del 4 %.
+- **Archivo duplicado.** Un día llega dos veces con nombres distintos y se deduplica por
+  hash de contenido.
+- **Días vacíos o erróneos.** Algunos días llegan sin filas o con errores en el
+  manifest y se descartan.
+- **Huecos de cobertura.** Cerca del 8 % de los vuelos en aire muestran un salto
+  superior a 120 s entre observaciones consecutivas. Casi siempre son artefactos de
+  cobertura del receptor, no eventos operativos, por lo que se utilizan como
+  característica, jamás como etiqueta.
+
+Tras la limpieza, el dataset contiene un conjunto estable de operaciones normales en
+LEMD que abarca varias estaciones e incluye el inicio de 2020, lo que sirve además como
+cambio de distribución natural para poner a prueba el split temporal.
+
+### 2.4 Observaciones destacadas
+
+El análisis exploratorio confirma un pequeño conjunto de casos raros que se reservan
+únicamente para validación:
+
+- Cuatro vuelos llevan un código de transpondedor de emergencia en algún punto.
+- Aproximadamente un centenar de vuelos muestran un patrón claro de motor y al aire
+  (aproximación seguida de ascenso sostenido).
+
+Ninguno de estos vuelos entra en el conjunto de entrenamiento. Se utilizan como prueba
+de cordura del modelo desplegado.
+
+---
+
+## 3. Formulación del problema
+
+El dataset contiene muchos vuelos normales y casi ninguna anomalía etiquetada. Eso
+descarta la clasificación supervisada y apunta al **aprendizaje de una sola clase**:
+entrenar un modelo que capture la distribución de trayectorias normales y puntuar los
+nuevos vuelos según su compatibilidad con esa distribución.
+
+En la práctica, los tres modelos profundos son **autoencoders** entrenados solo con
+vuelos normales. El objetivo de entrenamiento es reconstruir la ventana de entrada a
+partir de una representación latente comprimida; en inferencia se utiliza el **error de
+reconstrucción** como puntuación de conformidad. Una trayectoria parecida a los patrones
+normales se reconstruye con precisión y recibe un score bajo; una trayectoria que se
+aparta de esos patrones es más difícil de reconstruir y recibe un score alto.
+
+Esta formulación encaja con el contexto operativo por tres motivos. Sólo necesita datos
+normales, que son los únicos disponibles a escala. Produce una puntuación continua e
+interpretable en lugar de una etiqueta dura, lo que es la salida adecuada para una
+herramienta de apoyo a un operador humano. Y se comporta bien ante modos de fallo
+desconocidos: cualquier trayectoria que el modelo no haya aprendido a reconstruir
+emerge como anómala con independencia de qué es lo que la hace inusual.
+
+---
+
+## 4. Pipeline de preprocesado
+
+El pipeline transforma los parquet en bruto en tensores de longitud fija ya
+estandarizados y listos para entrenar. Cada paso está implementado como una función
+pequeña y testeable bajo `src/sadar/data/`.
+
+1. **Carga y fusión.** Se leen todos los parquet bajo `$SADAR_DATA_DIR` con pyarrow, se
+   concatenan y se deduplican. Los días vacíos o erróneos se descartan.
+2. **Transformación de coordenadas.** La latitud y la longitud se proyectan a un sistema
+   métrico relativo a pista con `pyproj`. Así el modelo es robusto a la curvatura de las
+   coordenadas y recibe metros como unidad.
+3. **Codificación del rumbo.** El rumbo se codifica como `(sin(rumbo), cos(rumbo))` para
+   evitar la discontinuidad entre 0 y 360 grados.
+4. **Tratamiento de ausentes.** Los huecos cortos dentro de una trayectoria por lo demás
+   completa se rellenan con interpolación lineal. Las trayectorias con demasiados
+   ausentes se descartan.
+5. **Resampleado.** Cada vuelo se resamplea a una rejilla uniforme de 10 s, que coincide
+   con la cadencia nominal de ADS-B.
+6. **Ventanado.** Cada trayectoria resampleada se trocea en ventanas de longitud fija.
+   La longitud de ventana es un hiperparámetro definido en
+   `configs/preprocessing.yaml`.
+7. **Estandarización.** Cada variable se normaliza a media cero y varianza unidad. El
+   escalador se ajusta **solo con el conjunto de entrenamiento** para evitar fugas, y se
+   guarda como `data/processed/scaler.npz`, de manera que la misma transformación se
+   aplica en inferencia.
+8. **Split sin fugas.** La división se hace conjuntamente por `flight_id` y por fecha:
+   ningún vuelo aparece en más de un conjunto, y el test es estrictamente posterior en
+   el tiempo al entrenamiento. Los años 2017 a 2019 se usan para entrenamiento y
+   validación; 2020 se reserva para test. Este split realista es lo que permite tomar
+   las cifras de latencia con confianza.
+9. **Limpieza del set de entrenamiento.** Los pocos vuelos con squawks de emergencia y
+   los go-around sospechosos se eliminan del entrenamiento. Sólo trayectorias
+   "normales" entran al modelo.
+
+La entrada de todos los modelos profundos es una ventana de siete variables:
+`[x_rel, y_rel, baroaltitude, velocity, sin_hdg, cos_hdg, vertrate]`.
+
+---
+
+## 5. Modelos
+
+### 5.1 Baseline Isolation Forest
+
+Detector de referencia, no secuencial. Cada ventana se resume por estadísticos por
+variable (media, desviación, mínimo, máximo) y se alimenta a un Isolation Forest. El
+baseline sirve para cuantificar cuánto añade realmente el modelado secuencial.
+
+### 5.2 Autoencoder LSTM
+
+Un encoder LSTM de dos capas comprime la ventana de entrada en un vector latente, y un
+decoder LSTM espejado la reconstruye. Se entrena de extremo a extremo con MSE y el loop
+de entrenamiento compartido descrito más abajo. Es la arquitectura caballo de batalla:
+estable, rápida en inferencia y alineada con la bibliografía sobre modelado de
+trayectorias ADS-B.
+
+### 5.3 Autoencoder Transformer
+
+El mismo esqueleto encoder-decoder, pero con atención multi-cabeza en lugar de
+recurrencia. El Transformer captura dependencias a largo plazo dentro de la ventana sin
+el cuello de botella secuencial de las LSTM, a cambio de más parámetros y una superficie
+de hiperparámetros mayor.
+
+### 5.4 VAE-LSTM (modelo de producción seleccionado)
+
+Un autoencoder variacional construido sobre encoder y decoder LSTM. En lugar de producir
+un único vector latente, el encoder produce una distribución posterior; el decoder
+reconstruye a partir de una muestra. La función de pérdida es la ELBO habitual: MSE de
+reconstrucción más un término KL que regulariza la posterior hacia una gaussiana
+estándar, escalado por un factor beta. Esto aporta una interpretación probabilística al
+score y se comporta mejor en el paso de selección de umbral.
+
+### 5.5 Ensembles (evaluados y descartados)
+
+Como parte de la comparación se evalúan dos estrategias de ensemble. Tras calibrar cada
+modelo con z-score sobre las normales de validación, los tres modelos profundos se
+combinan por la **media** de sus scores (consenso) o por el **máximo** (más sensible).
+Ninguna combinación supera al mejor modelo individual en el test real, así que el
+ensemble queda documentado y descartado. El detector final es el VAE-LSTM en solitario.
+
+### 5.6 Infraestructura de entrenamiento compartida
+
+Los tres modelos profundos comparten el mismo loop de entrenamiento, implementado una
+sola vez en `src/sadar/models/training.py`. El loop usa:
+
+- **Adam** con weight decay,
+- planificador **ReduceLROnPlateau**,
+- **early stopping** sobre la pérdida de validación,
+- **MLflow** para tracking (losses, hiperparámetros, mejor checkpoint),
+- **Optuna** para búsqueda de hiperparámetros, usado sobre todo en el VAE-LSTM.
+
+Cada arquitectura tiene su propio fichero YAML bajo `configs/`. La reproducibilidad se
+garantiza con semillas fijas y guardando junto al checkpoint la configuración exacta de
+preprocesado utilizada.
+
+---
+
+## 6. Banco de anomalías sintéticas
+
+Como las anomalías reales son escasas y carecen de etiqueta, se construye un banco
+controlado sobre los vuelos normales del test. Cada escenario parte de una ventana
+normal real e inyecta una perturbación conocida y etiquetada que se aplica de forma
+gradual a partir de la mitad de la ventana. Se implementan cinco tipos de inyección,
+cada uno en varias intensidades:
+
+| Tipo | Descripción |
+|---|---|
+| Desviación de ruta | Salida lateral del corredor, parametrizada en metros. |
+| Anomalía de altitud | Desplazamiento de altitud inconsistente con la fase. |
+| Anomalía de velocidad | Aceleración o deceleración multiplicativa. |
+| Holding | Giro de 360 ° repetido con periodo configurable. |
+| Congelado de transpondedor | La señal se mantiene fija desde un punto dado. |
+
+El banco produce etiquetas de verdad (cada inyección sabe exactamente cuándo empieza) y
+por tanto permite dos métricas que los datos reales no pueden dar: **PR-AUC por tipo de
+anomalía** y **latencia de detección** (mediana de segundos entre el inicio de la
+inyección y el primer instante en que el score por paso cruza el umbral de alerta).
+
+El banco sintético se utiliza únicamente para evaluación. Ninguna ventana sintética
+entra jamás en el entrenamiento.
+
+---
+
+## 7. Evaluación
+
+### 7.1 Conjunto de test real
+
+Los cuatro detectores se puntúan sobre el mismo split de test. La métrica principal es
+**PR-AUC**, más informativa que la ROC-AUC dado el fuerte desbalance de clases en datos
+reales.
+
+| Modelo | ROC-AUC | PR-AUC | ROC-AUC media sintética | Latencia mediana |
+|---|---|---|---|---|
+| Baseline Isolation Forest | 0,515 | 0,133 | 0,593 | n/d |
+| Autoencoder LSTM | 0,648 | 0,260 | 0,779 | 115 s |
+| Autoencoder Transformer | 0,614 | 0,227 | 0,743 | 115 s |
+| **VAE-LSTM (seleccionado)** | **0,659** | **0,299** | **0,792** | 120 s |
+| Ensemble (media) | 0,652 | 0,273 | 0,778 | n/d |
+| Ensemble (máximo) | 0,658 | 0,278 | 0,774 | n/d |
+
+Se desprenden tres conclusiones:
+
+- Los modelos profundos aportan valor sustancial sobre el baseline (la PR-AUC
+  aproximadamente se duplica).
+- El VAE-LSTM es el mejor en conjunto: mayor PR-AUC sobre datos reales, mayor ROC-AUC
+  media sintética y latencia competitiva.
+- Las dos estrategias de ensemble no superan al mejor modelo individual y no se
+  retienen.
+
+### 7.2 Banco sintético (ROC-AUC por anomalía)
+
+El VAE-LSTM es el mejor en todos los tipos de anomalía. El patrón es consistente: las
+perturbaciones grandes y sostenidas son más fáciles que las sutiles, y las maniobras
+estructuradas (holding, cambios fuertes de velocidad) son más fáciles que los
+desplazamientos pequeños.
+
+| Anomalía | Intensidad | Baseline | LSTM | Transformer | VAE-LSTM |
+|---|---|---|---|---|---|
+| Desviación de ruta | 20.000 m | 0,513 | 0,556 | 0,543 | 0,558 |
+| Desviación de ruta | 40.000 m | 0,537 | 0,684 | 0,657 | 0,700 |
+| Desviación de ruta | 80.000 m | 0,618 | 0,883 | 0,865 | 0,899 |
+| Desviación de altitud | 300 m | 0,502 | 0,512 | 0,505 | 0,514 |
+| Desviación de altitud | 800 m | 0,518 | 0,581 | 0,531 | 0,593 |
+| Desviación de altitud | 1.500 m | 0,561 | 0,726 | 0,606 | 0,752 |
+| Factor de velocidad | x1,6 | 0,620 | 0,901 | 0,835 | 0,927 |
+| Factor de velocidad | x2,2 | 0,743 | 0,985 | 0,965 | 0,989 |
+| Factor de velocidad | x0,4 | 0,673 | 0,901 | 0,884 | 0,925 |
+| Holding | 240 s/giro | 0,614 | 0,972 | 0,979 | 0,978 |
+| Holding | 120 s/giro | 0,634 | 0,975 | 0,985 | 0,984 |
+| Congelado transpondedor | fijo | 0,582 | 0,668 | 0,558 | 0,686 |
+
+### 7.3 Curvas y matrices de confusión
+
+Para cada detector se generan curvas precision-recall y ROC, junto con una matriz de
+confusión tomada al umbral del percentil 99 de validación. Las figuras se guardan como
+PNG en `reports/figures/` y los arrays subyacentes se almacenan dentro de
+`reports/model_comparison.json`, de modo que el dashboard puede renderizarlas sin
+recalcular.
+
+---
+
+## 8. Inferencia y servicio
+
+El VAE-LSTM seleccionado se sirve mediante una aplicación FastAPI compacta
+(`src/sadar/serve/app.py`). En el arranque el servicio carga:
+
+- el checkpoint del modelo de producción,
+- el escalador ajustado con los datos de entrenamiento,
+- el informe de métricas precomputado,
+- y una muestra curada de trayectorias para que el dashboard pueda funcionar sin los
+  datos brutos.
+
+La superficie HTTP es deliberadamente reducida. El dashboard se comunica con el backend
+a través de cinco endpoints:
+
+| Endpoint | Función |
+|---|---|
+| `GET /api/health` | Sonda de vida (también devuelve un identificador de build). |
+| `GET /api/scene` | Escena de radar actual: aeronaves, scores, umbral. |
+| `GET /api/flights` | Lista ordenada de vuelos monitorizados con metadatos. |
+| `GET /api/metrics` | Métricas comparativas y curvas precomputadas. |
+| `POST /api/simulate` | Inyecta una anomalía en un vuelo y devuelve la respuesta. |
+
+En producción, el mismo proceso FastAPI también sirve la SPA de React ya compilada (la
+SPA se monta en `/`, la API queda bajo `/api`). Todo el sistema corre en un único
+contenedor.
+
+---
+
+## 9. Frontend
+
+El dashboard es una aplicación React 18 + Vite + TypeScript diseñada para que parezca y
+se sienta como una consola de torre de control: fondo oscuro, bloques de datos en
+monoespaciada, criticidad codificada por color (verde y cian para normal, ámbar y rojo
+para alerta). Expone cuatro pantallas:
+
+1. **Consola torre.** Un radar en directo centrado en LEMD con un panel lateral que
+   lista todos los vuelos monitorizados y su estado actual. Las aeronaves en seguimiento
+   o en alerta se diferencian por color.
+2. **Simulador.** El corazón interactivo de la demo. El operador elige un vuelo, un tipo
+   de anomalía, una intensidad y un instante de inicio, e inyecta la perturbación en
+   tiempo real. El score de la derecha reacciona a la inyección y la latencia de
+   detección se reporta en segundos.
+3. **Métricas.** El informe comparativo completo: curvas ROC y PR, desglose de PR-AUC
+   por anomalía, justificación de la selección del modelo y resumen del detector final.
+4. **Presentación.** Un recorrido guiado utilizado para presentaciones en vivo del
+   proyecto.
+
+La aplicación está internacionalizada en inglés y español mediante un pequeño contexto
+de traducción.
+
+---
+
+## 10. Reproducibilidad y despliegue
+
+El proyecto está diseñado para que el pipeline completo (preprocesado, entrenamiento,
+evaluación, servicio) pueda reproducirse desde cero.
+
+- **Entorno Python.** Fijado con `uv` y `pyproject.toml`; un único comando
+  (`uv sync`) reconstruye el entorno.
+- **Entorno de frontend.** Gestionado con `pnpm` y `pnpm-lock.yaml`.
+- **Configuración.** Todos los parámetros (rutas, longitud de ventana, dimensiones del
+  modelo, plan de entrenamiento, umbrales de evaluación) viven en ficheros YAML bajo
+  `configs/`. El código no lee rutas literales.
+- **Semillas.** Una única semilla se fija al inicio de cada entry point y se propaga a
+  NumPy, scikit-learn y PyTorch.
+- **Tracking.** MLflow registra todas las ejecuciones en local; Optuna guarda su
+  historial de búsqueda junto a los hiperparámetros resultantes.
+- **Containerización.** Un único Dockerfile construye una imagen autocontenida que
+  incluye el modelo entrenado, el escalador, los informes precomputados y la SPA. La
+  misma imagen se utiliza en local (`docker compose up`) y en producción (Hugging Face
+  Spaces).
+
+Un `Makefile` expone el flujo como targets con nombre: `make install`,
+`make preprocess`, `make train-lstm`, `make train-transformer`, `make train-vae`,
+`make tune-vae`, `make compare`, `make serve`, `make dev`, `make docker-up`.
+
+---
+
+## 11. Limitaciones y trabajo futuro
+
+### 11.1 Limitaciones
+
+- **Alcance.** El dataset cubre un solo aeropuerto (LEMD) y un periodo acotado. No se
+  espera que el modelo transfiera a otras terminales sin reentrenamiento.
+- **Sin planes de vuelo.** La "ruta prevista" se aproxima como "patrón normal
+  aprendido". Un vuelo que se aparte de su plan de vuelo pero permanezca dentro del
+  patrón normal del tráfico podría no ser marcado.
+- **Huecos de cobertura.** Los huecos del transpondedor en ADS-B están dominados por la
+  cobertura del receptor. Se usan como característica de entrada, no como etiqueta.
+- **Desbalance de clases.** Los eventos anómalos reales son extremadamente raros. Las
+  cifras de PR-AUC sobre el test real se calculan con un conjunto positivo pequeño; el
+  banco sintético es el referente cuantitativo principal.
+
+### 11.2 Trabajo futuro
+
+- Ampliar el dataset a más aeropuertos y validar la generalización entre terminales.
+- Incorporar los planes de vuelo, cuando estén disponibles, como señal auxiliar.
+- Combinar el score de conformidad con un clasificador posterior entrenado sobre
+  eventos operativos etiquetados (motor y al aire, aproximaciones frustradas, holding)
+  para producir alertas más interpretables.
+- Explorar ensembles probabilísticos que ponderen cada modelo por su verosimilitud
+  calibrada en lugar de hacerlo con un reductor fijo.
+
+---
+
+## 12. Conclusiones
+
+SADAR muestra que un enfoque de aprendizaje profundo de una sola clase es una base
+viable para la monitorización de conformidad de trayectorias en un aeropuerto
+importante. Tres autoencoders secuenciales entrenados con los mismos datos y evaluados
+sobre el mismo banco arrojan una elección de modelo clara y defendible: el
+**VAE-LSTM** combina la mejor PR-AUC sobre datos reales, el mejor desempeño medio en el
+banco sintético y una latencia mediana de detección competitiva, mejorando con holgura
+a un baseline no secuencial. El sistema es completamente reproducible, se empaqueta en
+un único contenedor y se sirve a través de un dashboard construido en torno a un caso
+de uso real.
+
+El resultado no es un producto cerrado, pero sí un prototipo sólido de cómo la
+monitorización de conformidad basada en datos puede complementar las herramientas
+basadas en reglas que usan hoy los operadores del tráfico aéreo.
+
+---
+
+**Repositorio.** Smart Anomaly Detection for Aviation Routes (SADAR).
+Madrid-Barajas (LEMD) · 2026.

docs/REPORT.md

@@ -0,0 +1,440 @@
+# SADAR
+
+**Smart Anomaly Detection for Aviation Routes**
+
+Technical Report
+
+---
+
+**Project:** SADAR · Flight Conformance Monitor
+**Domain:** Air traffic surveillance · ADS-B data
+**Airport of study:** Madrid-Barajas (LEMD)
+**Approach:** One-class deep learning for trajectory anomaly detection
+**Date:** 2026
+
+---
+
+## Executive summary
+
+SADAR is a deep-learning system that learns the normal pattern of approach and departure
+operations at Madrid-Barajas (LEMD) from ADS-B surveillance data and surfaces, in real time,
+any trajectory that deviates from that pattern. The system is built as a **flight
+conformance monitor**: it does not classify specific events, it raises an interpretable
+anomaly score for every flight in the airspace so that an operator can review the cases
+that fall outside the learned distribution.
+
+Three sequence autoencoders are trained under identical conditions on roughly 20.000 real
+flights from the OpenSky Network (an LSTM autoencoder, a Transformer autoencoder and a
+VAE-LSTM), together with a non-sequential Isolation Forest baseline. The four detectors
+are evaluated on the same held-out test set and on a synthetic anomaly bench with five
+injection types and several intensities. The **VAE-LSTM** is selected as the production
+model: it achieves the highest PR-AUC on real held-out data (0.299) and the highest
+synthetic mean ROC-AUC (0.792). Two ensemble strategies (consensus and most-sensitive) are
+also evaluated and discarded because neither beats the best individual model.
+
+The selected model is wrapped in a FastAPI inference service and served through a
+React + Vite dashboard that combines a tower-style live radar, a ranked anomaly list, a
+metrics page and a fully interactive simulator. The whole system is reproducible from a
+single Docker image and ships ready for deployment on Hugging Face Spaces.
+
+---
+
+## 1. Motivation and scope
+
+Trajectory monitoring is a core function of air traffic management. Today it relies on
+deterministic rules and human supervision: separation, descent profiles, holding patterns
+and emergency squawk codes are all monitored against fixed thresholds. These rules work
+well for the situations they were designed for, but they cannot anticipate behavior that
+is unusual without being a textbook violation.
+
+SADAR explores a complementary, data-driven approach. Instead of encoding rules, the
+system **learns** what a normal operation at LEMD looks like from a large sample of real
+flights, and treats every new trajectory as more or less compatible with that learned
+distribution. The output is a continuous conformance score that an operator can rank,
+filter and threshold.
+
+The scope of the project is deliberately narrow and well defined:
+
+- **What it does.** Detects deviations from the normal traffic pattern at one airport
+  (LEMD) based on a fixed set of dynamic features extracted from ADS-B reports.
+- **What it does not do.** Predict specific operational events, replace controllers,
+  produce certified safety recommendations or generalize without retraining to airports
+  with different procedures.
+
+This framing as a **conformance monitor** is what makes the problem tractable with the
+data available: it requires only examples of normal flight, which are abundant, and it
+keeps the interpretation of the output clear ("this trajectory is unlike the ones the
+model has seen") without overclaiming.
+
+---
+
+## 2. Data
+
+### 2.1 Source
+
+The dataset is built from ADS-B reports collected by the OpenSky Network around the
+Madrid-Barajas terminal area. It covers approximately 18 days of operations sampled
+between June 2017 and March 2020. Each aircraft is reported once every 10 seconds, which
+is the natural cadence of ADS-B.
+
+| Property | Value |
+|---|---|
+| Total trajectories | ≈ 20.000 (≈ 950 to 1.200 per day) |
+| Rows per day | 140.000 to 240.000 |
+| Columns | 21 |
+| Points per flight (min · median · max) | 40 · 188 · 1.246 |
+
+### 2.2 Variables
+
+The raw schema includes positional information (latitude, longitude, time), dynamics
+(barometric and geometric altitude, ground velocity, heading, vertical rate), derived
+fields (distance to runway, flight phase), identity (ICAO24, callsign, flight id) and
+transponder state (squawk, on-ground flag, alert flag, special-purpose indicator, last
+contact). One field, `operation`, is entirely missing and is dropped.
+
+### 2.3 Quality and cleaning
+
+A profiling pass over the full dataset surfaces several issues that are handled in the
+preprocessing pipeline:
+
+- **Missing values.** `geoaltitude` is missing in 34.9 % of rows, `baroaltitude` in
+  19.6 %, kinematic fields (`velocity`, `heading`, `vertrate`) around 19 %. The rest are
+  below 4 %.
+- **Duplicate file.** One day is shipped twice with different filenames and is
+  deduplicated by content hash.
+- **Empty or errored days.** A handful of days arrive with zero rows or with manifest
+  errors and are dropped.
+- **Coverage gaps.** About 8 % of airborne flights show a gap greater than 120 s between
+  consecutive reports. These gaps are almost always receiver-coverage artifacts, not
+  operational events, and are used as a feature, never as a label.
+
+After cleaning, the dataset contains a stable set of normal LEMD operations spanning
+multiple seasons and including the start of 2020, which doubles as a natural distribution
+shift to stress-test the temporal split.
+
+### 2.4 Notable observations
+
+The exploratory analysis confirms a small set of rare cases that are kept aside for
+validation only:
+
+- Four flights carry an emergency squawk code at some point of their trajectory.
+- Roughly one hundred flights show a clear go-around pattern (an approach followed by a
+  sustained climb).
+
+None of these flights enter the training set. They serve as a sanity check for the
+deployed model.
+
+---
+
+## 3. Problem formulation
+
+The dataset contains many normal flights and almost no labeled anomalies. This rules out
+supervised classification and points to **one-class learning**: train a model that
+captures the distribution of normal trajectories and score new flights by how compatible
+they are with that distribution.
+
+Concretely, all three deep models are **autoencoders** trained on normal flights only.
+The training objective is to reconstruct the input window from a compressed latent
+representation; at inference time the **reconstruction error** is used as the conformance
+score. A trajectory that resembles the normal patterns is reconstructed accurately and
+gets a low score; a trajectory that departs from those patterns is harder to reconstruct
+and gets a high score.
+
+This formulation has three properties that match the operational context. It needs only
+normal data, which is the only data available at scale. It produces a continuous,
+interpretable score instead of a hard label, which is the right output for a tool that
+supports a human operator. And it gracefully handles unknown failure modes: any
+trajectory the model has not learned to reconstruct will surface as anomalous regardless
+of what makes it unusual.
+
+---
+
+## 4. Preprocessing pipeline
+
+The preprocessing pipeline turns raw parquet files into fixed-length, standardized
+tensors ready for training. Every step is implemented as a small, testable function under
+`src/sadar/data/`.
+
+1. **Load and merge.** All parquet files under `$SADAR_DATA_DIR` are read with pyarrow,
+   concatenated and deduplicated. Empty or errored days are dropped.
+2. **Coordinate transform.** Latitude and longitude are projected to a runway-relative
+   metric system using `pyproj`. This makes the model robust to the curvature of
+   coordinates and gives the network meters as input units.
+3. **Heading encoding.** Heading is encoded as `(sin(heading), cos(heading))` to avoid
+   the discontinuity at 0 / 360 degrees.
+4. **Missing-value handling.** Short gaps inside an otherwise complete trajectory are
+   filled with linear interpolation. Trajectories with too many missing samples are
+   discarded.
+5. **Resampling.** Every flight is resampled to a uniform 10 s grid, which matches the
+   nominal cadence of ADS-B.
+6. **Windowing.** Each resampled trajectory is sliced into fixed-length windows. The
+   window length is a hyperparameter, set in `configs/preprocessing.yaml`.
+7. **Standardization.** Each feature is normalized to zero mean and unit variance. The
+   scaler is fit **only on the training split** to avoid leakage and saved as
+   `data/processed/scaler.npz`, so the exact same transform is applied at inference time.
+8. **Leak-free split.** The split is done jointly by `flight_id` and by date: no flight
+   ever appears in more than one split, and the test split is strictly later in time than
+   the training split. Years 2017 to 2019 are used for training and validation; 2020 is
+   reserved for testing. This realistic split is what allows latency numbers to be taken
+   at face value.
+9. **Training set cleaning.** The few flights with emergency squawks and the suspected
+   go-arounds are removed from the training split. Only "normal" trajectories enter the
+   training set.
+
+The input to all deep models is a window of seven features:
+`[x_rel, y_rel, baroaltitude, velocity, sin_hdg, cos_hdg, vertrate]`.
+
+---
+
+## 5. Models
+
+### 5.1 Isolation Forest baseline
+
+A non-sequential reference detector. Each window is summarized by per-feature statistics
+(mean, standard deviation, min, max) and fed to an Isolation Forest. The baseline is
+useful to quantify how much sequential modeling actually adds.
+
+### 5.2 LSTM autoencoder
+
+A two-layer LSTM encoder compresses the input window into a latent vector, and a mirror
+LSTM decoder reconstructs it. Trained end-to-end with MSE loss and the shared training
+loop described below. This is the workhorse architecture: stable to train, fast to score
+and well aligned with the literature on ADS-B trajectory modeling.
+
+### 5.3 Transformer autoencoder
+
+The same encoder-decoder skeleton, but with multi-head self-attention instead of
+recurrence. The Transformer captures long-range dependencies inside the window without
+the sequential bottleneck of LSTMs, at the cost of more parameters and a larger
+hyperparameter surface.
+
+### 5.4 VAE-LSTM (selected production model)
+
+A variational autoencoder built on LSTM encoder and decoder. Instead of producing a single
+latent vector, the encoder produces a posterior distribution; the decoder reconstructs
+from a sample drawn from it. The training loss is the standard ELBO: reconstruction MSE
+plus a KL term that regularizes the posterior toward a unit Gaussian, scaled by a
+beta factor. This adds a principled, probabilistic interpretation to the score and
+behaves better at the threshold-selection step.
+
+### 5.5 Ensembling (evaluated and discarded)
+
+Two ensemble strategies are evaluated as part of the comparison. After per-model
+z-score calibration on validation normals, the three deep models are combined either by
+their **mean** score (consensus) or by their **max** score (most-sensitive). Neither
+combination beats the best individual model on the real test set, so the ensemble is
+documented and discarded. The final detector is the VAE-LSTM alone.
+
+### 5.6 Shared training infrastructure
+
+All three deep models share the same training loop, implemented once in
+`src/sadar/models/training.py`. The loop uses:
+
+- **Adam** with weight decay,
+- a **ReduceLROnPlateau** scheduler,
+- **early stopping** on the validation loss,
+- **MLflow** for tracking (losses, hyperparameters, best checkpoint),
+- **Optuna** for hyperparameter search, used here mainly for the VAE-LSTM.
+
+Each architecture has its own YAML configuration file under `configs/`. Reproducibility
+is enforced by fixed seeds and by storing the exact preprocessing config alongside the
+checkpoint.
+
+---
+
+## 6. Synthetic anomaly bench
+
+Because real anomalies are rare and unlabeled, a controlled benchmark is built on top of
+normal test flights. Each scenario starts from a real normal window and injects a known,
+labeled perturbation that ramps in halfway through the window. Five types of injection
+are implemented, each at multiple intensities:
+
+| Type | Description |
+|---|---|
+| Route deviation | Lateral departure from the corridor, parameterized in meters. |
+| Altitude anomaly | Altitude offset inconsistent with the flight phase. |
+| Speed anomaly | Multiplicative acceleration or deceleration. |
+| Holding | A repeated 360 ° turn at a configurable period. |
+| Transponder freeze | The signal is held constant from a chosen point. |
+
+The bench produces ground-truth labels (each injection knows exactly when it starts) and
+therefore enables two metrics that real data cannot give us: **PR-AUC per anomaly type**
+and **detection latency** (median seconds between the injection onset and the first
+moment the per-step score crosses the alert threshold).
+
+The synthetic bench is used only for evaluation. No synthetic window ever enters the
+training set.
+
+---
+
+## 7. Evaluation
+
+### 7.1 Real test set
+
+The four detectors are scored on the same held-out test split. The headline metric is
+**PR-AUC**, which is more informative than ROC-AUC under the strong class imbalance
+present in real data.
+
+| Model | ROC-AUC | PR-AUC | Synthetic mean ROC-AUC | Median latency |
+|---|---|---|---|---|
+| Isolation Forest baseline | 0.515 | 0.133 | 0.593 | n/a |
+| LSTM autoencoder | 0.648 | 0.260 | 0.779 | 115 s |
+| Transformer autoencoder | 0.614 | 0.227 | 0.743 | 115 s |
+| **VAE-LSTM (selected)** | **0.659** | **0.299** | **0.792** | 120 s |
+| Ensemble (mean) | 0.652 | 0.273 | 0.778 | n/a |
+| Ensemble (max) | 0.658 | 0.278 | 0.774 | n/a |
+
+Three conclusions stand out:
+
+- The deep models add substantial value over the baseline (PR-AUC roughly doubles).
+- The VAE-LSTM is the best overall: highest PR-AUC on real data, highest synthetic mean
+  ROC-AUC, competitive latency.
+- The two ensemble strategies do not beat the best individual model and are not retained.
+
+### 7.2 Synthetic bench (per-anomaly ROC-AUC)
+
+The VAE-LSTM performs best across all anomaly types. The pattern is consistent: large,
+sustained perturbations are easier than subtle ones, and structured maneuvers (holding,
+high-magnitude speed change) are easier than small drifts.
+
+| Anomaly | Intensity | Baseline | LSTM | Transformer | VAE-LSTM |
+|---|---|---|---|---|---|
+| Route deviation | 20.000 m | 0.513 | 0.556 | 0.543 | 0.558 |
+| Route deviation | 40.000 m | 0.537 | 0.684 | 0.657 | 0.700 |
+| Route deviation | 80.000 m | 0.618 | 0.883 | 0.865 | 0.899 |
+| Altitude offset | 300 m | 0.502 | 0.512 | 0.505 | 0.514 |
+| Altitude offset | 800 m | 0.518 | 0.581 | 0.531 | 0.593 |
+| Altitude offset | 1.500 m | 0.561 | 0.726 | 0.606 | 0.752 |
+| Speed factor | x1.6 | 0.620 | 0.901 | 0.835 | 0.927 |
+| Speed factor | x2.2 | 0.743 | 0.985 | 0.965 | 0.989 |
+| Speed factor | x0.4 | 0.673 | 0.901 | 0.884 | 0.925 |
+| Holding | 240 s/turn | 0.614 | 0.972 | 0.979 | 0.978 |
+| Holding | 120 s/turn | 0.634 | 0.975 | 0.985 | 0.984 |
+| Transponder freeze | stuck | 0.582 | 0.668 | 0.558 | 0.686 |
+
+### 7.3 Curves and confusion matrices
+
+Precision-recall and ROC curves are produced for every detector, together with a
+confusion matrix taken at the validation-99-percentile threshold. The figures are
+saved as PNGs under `reports/figures/` and the underlying arrays are stored inside
+`reports/model_comparison.json`, so the dashboard can render them without recomputing.
+
+---
+
+## 8. Serving
+
+The selected VAE-LSTM is served by a small FastAPI application
+(`src/sadar/serve/app.py`). At startup, the service loads:
+
+- the checkpoint of the production model,
+- the scaler fit on the training data,
+- the precomputed metrics report,
+- and a curated sample of trajectories so the dashboard can run without raw data.
+
+The HTTP surface is intentionally small. The dashboard talks to the backend through five
+endpoints:
+
+| Endpoint | Purpose |
+|---|---|
+| `GET /api/health` | Liveness probe (also serves a build identifier). |
+| `GET /api/scene` | Current radar scene: aircraft, scores, threshold. |
+| `GET /api/flights` | Ranked list of monitored flights with metadata. |
+| `GET /api/metrics` | Pre-computed comparative metrics and curves. |
+| `POST /api/simulate` | Inject an anomaly on a chosen flight and return the response. |
+
+In production, the same FastAPI process also serves the built React app (the SPA is
+mounted on `/`, the API stays under `/api`). The whole system runs in a single
+container.
+
+---
+
+## 9. Frontend
+
+The dashboard is a React 18 + Vite + TypeScript application designed to look and feel
+like a tower control console: dark background, monospace data blocks, criticality
+encoded by color (green/cyan for normal, amber/red for alert). It exposes four screens:
+
+1. **Tower console.** A live radar scope centered on LEMD with a side panel listing every
+   tracked flight and its current state. Tracked vs alerted aircraft are color-coded.
+2. **Simulator.** The interactive heart of the demo. The operator picks a flight, an
+   anomaly type, an intensity and an onset, and injects the perturbation in real time.
+   The score on the right reacts to the injection and the detection latency is reported
+   in seconds.
+3. **Metrics.** The full comparative report: ROC and PR curves, per-anomaly PR-AUC
+   breakdown, model selection rationale and final-detector summary.
+4. **Presentation.** A guided walkthrough used for live presentations of the project.
+
+The app is internationalized in English and Spanish through a small translation context.
+
+---
+
+## 10. Reproducibility and deployment
+
+The project is engineered so that the entire pipeline (preprocessing, training,
+evaluation, serving) can be reproduced from scratch.
+
+- **Python environment.** Locked with `uv` and `pyproject.toml`; one command (`uv sync`)
+  rebuilds the environment.
+- **Frontend environment.** Managed with `pnpm` and `pnpm-lock.yaml`.
+- **Configuration.** All knobs (paths, window length, model dimensions, training
+  schedule, evaluation thresholds) live in YAML files under `configs/`. The code reads no
+  literal paths.
+- **Seeds.** A single seed is set at the top of every entry point; it propagates to
+  NumPy, scikit-learn and PyTorch.
+- **Tracking.** MLflow logs all training runs locally; Optuna stores its search history
+  alongside the resulting hyperparameters.
+- **Containerization.** A single Dockerfile builds a self-contained image that bundles
+  the trained model, the scaler, the precomputed reports and the SPA. The same image is
+  used locally (`docker compose up`) and in production (Hugging Face Spaces).
+
+A `Makefile` exposes the workflow as named targets: `make install`, `make preprocess`,
+`make train-lstm`, `make train-transformer`, `make train-vae`, `make tune-vae`,
+`make compare`, `make serve`, `make dev`, `make docker-up`.
+
+---
+
+## 11. Limitations and future work
+
+### 11.1 Limitations
+
+- **Scope.** The dataset covers one airport (LEMD) and a limited time span. The model is
+  not expected to transfer to other terminals without retraining.
+- **No flight plans.** "Intended route" is approximated as "learned normal pattern". A
+  flight that deviates from its filed route but stays inside the normal traffic pattern
+  may not be flagged.
+- **Coverage gaps.** Transponder gaps in ADS-B are dominated by receiver coverage. They
+  are used as an input feature, not as a label.
+- **Class imbalance.** Real anomalous events are extremely rare. The PR-AUC numbers on
+  the real test set are computed on a small positive set; the synthetic bench is the
+  primary quantitative benchmark.
+
+### 11.2 Future work
+
+- Extend the dataset to additional airports and validate cross-airport generalization.
+- Incorporate filed flight plans, when available, as an auxiliary signal.
+- Combine the conformance score with a downstream classifier trained on labeled
+  operational events (go-arounds, missed approaches, holding) for more interpretable
+  alerts.
+- Explore probabilistic ensembles that weight each model by its calibrated likelihood
+  rather than by a fixed reducer.
+
+---
+
+## 12. Conclusions
+
+SADAR shows that a one-class deep-learning approach is a viable foundation for trajectory
+conformance monitoring at a major airport. Three sequence autoencoders trained on the
+same data and evaluated on the same bench produce a clear, defensible model choice: the
+**VAE-LSTM** combines the best PR-AUC on real data, the best mean performance on the
+synthetic bench and a competitive median detection latency, while improving substantially
+over a non-sequential baseline. The system is fully reproducible, packaged as a single
+container and served through a dashboard built around a real operational use case.
+
+The result is not a finished product, but it is a solid prototype of how data-driven
+conformance monitoring could complement the rule-based tools that air traffic operators
+use today.
+
+---
+
+**Repository.** Smart Anomaly Detection for Aviation Routes (SADAR).
+Madrid-Barajas (LEMD) · 2026.

docs/medium_post.en.md

@@ -0,0 +1,205 @@
+# When the most complex model is not the one that detects best
+
+*A comparison of LSTM, Transformer and VAE-LSTM autoencoders over 19,000 real flights at Madrid-Barajas. And why validation loss is a poor advisor.*
+
+![Control tower with air traffic over the runway at night.](../docs/assets/tower-night.png)
+
+> **Code:** [github.com/iRuperth/SADAR](https://github.com/iRuperth/SADAR)
+> **Live demo:** [huggingface.co/spaces/devrup404/sadar](https://huggingface.co/spaces/devrup404/sadar)
+>
+> The repository is public and open to collaborations, suggestions and forks. Any technical discussion, *issue* or *pull request* is welcome.
+
+---
+
+The most interesting data point in the dataset is not a hijacking. It is an aircraft that pretended to be one for thirty seconds, by mistake.
+
+On July 31, 2017, an Iberia Airbus flew over Madrid with the hijack code active on its transponder during three points of its trajectory. Then it went back to normal. The flight was IBE2845, the transmitted code was 7500, and in the secondary surveillance system that code means unlawful interference.
+
+It was not a hijacking. It was almost certainly a transponder fault: three points out of the 171 that make up the complete flight record, 800 meters from the runway, with no other operational anomaly. That flight, logged in a parquet file of 3.4 million rows, marks the beginning of this article. And it also marks the technical question I took into the project: can a model learn what a normal flight looks like and raise a flag when one stops looking like one?
+
+This article presents SADAR, an anomaly detection system for flight trajectories trained on eighteen days of real traffic from Adolfo Suárez Madrid-Barajas airport. It compares three deep autoencoders against a classical baseline, evaluates the system on a synthetic anomaly bench and discusses with candor where it works and where it does not.
+
+Let us start with the problem.
+
+## Problem statement
+
+Incident detection in civil aviation can rarely be framed as a supervised problem: the data is dominated by normal operation and the few labeled events are ambiguous. The standard alternative is **conformance monitoring**: learn the distribution of normal behavior and flag trajectories that deviate from it. This is the framing SADAR adopts.
+
+The distinction matters. Saying "this flight deviates from the learned pattern" is defensible with data. Saying "this flight is an incident" requires operational context that ADS-B does not provide. SADAR operates strictly under the first statement.
+
+## Data
+
+The data comes from OpenSky Network, a collaborative network of ADS-B receivers. The set covers 18 non-consecutive days between June 2017 and March 2020, centered on the airspace of Barajas. Each aircraft reports a position every 10 seconds, with 21 columns per point: position and dynamics (latitude, longitude, barometric and geometric altitude, velocity, heading, vertical rate), identity (callsign, icao24, flight_id) and transponder state (squawk, alert, onground).
+
+The raw figures after merging and deduplication:
+
+- 3,429,638 rows.
+- 19,057 distinct flights.
+- Median of 175 points per flight, maximum 1,606.
+- Median duration of 30.2 minutes.
+
+The first finding of the exploratory analysis was the gaps. GPS altitude (`geoaltitude`) shows 24.79 % missing values. Velocity and heading, around 13 %. These gaps are not errors: they correspond to areas of lower ground receiver coverage. I discarded GPS altitude and kept barometric altitude, more complete, treating the gaps as a property of the problem rather than a fault to correct.
+
+![Sampled trajectories over the airspace of LEMD. The approach and departure corridors are visually identifiable before any projection. In red, the points of the four flights with an emergency squawk.](../docs/assets/eda/trajectories_map.png)
+
+The second finding came from the heading histogram. Plotted on a polar chart, the two parallel runways of Barajas appear as two opposite lobes.
+
+![Polar histogram of heading over the full dataset. The two opposite lobes correspond to the parallel runways of Barajas. This circular property motivated the encoding of heading as the (sin, cos) pair.](../docs/assets/eda/heading_polar.png)
+
+The airport is identifiable in the data before projecting it onto a map.
+
+That circular property of heading motivated its encoding as a sine and cosine pair: for an autoencoder, 359° and 1° must remain adjacent, and a linear encoding prevents that.
+
+![Distribution of rows by flight phase in the dataset. The descent phase dominates, followed by climb and ground operations, which conditions which patterns the model learns best.](../docs/assets/eda/flight_phases.png)
+
+## Real events in the set
+
+The dataset contains only four flights with an emergency code on the transponder. They deserve detailed description because their scarcity determines the framing of the problem:
+
+- **IBE2845** (Iberia, July 31, 2017). Squawk 7500 for three points out of 171, transmitted 800 meters from the runway. Consistent with a transponder fault.
+- **ELY395** (El Al, October 2, 2017). Squawk 7700 for five points, declared 800 meters from the runway. The aircraft landed. The most plausible case of a real emergency.
+- **RYR61AD** (Ryanair, January 28, 2019). Squawk 7600 (communications failure). One point. Landed.
+- **SWR202Y** (Swiss, February 3, 2020). Squawk 7700. One point. Landed.
+
+Four labels in a universe of non-labels. This proportion rules out supervised learning: no classifier is trained on four positives. The four flights were set aside as a qualitative validation set, grouped in 1,076 labeled windows in `data/processed/anomalies.npy`, and do not appear at any point of training.
+
+## Methodology
+
+### One-class learning
+
+Without enough labels, the framing is **one-class learning** through autoencoders. The network learns to reconstruct normal trajectories. The reconstruction error operates as an anomaly score: an input similar to those in training produces a low error; an unusual input raises it.
+
+I trained four detectors under identical conditions (same preprocessing, same split, same threshold) to allow a rigorous comparison:
+
+| # | Model | Idea | Weights |
+|---|---|---|---|
+| 0 | Isolation Forest | Per-window summary statistics, not sequential | baseline |
+| 1 | LSTM autoencoder | Sequential reconstruction | 224 KB |
+| 2 | Transformer autoencoder | Attention over the full window | 635 KB |
+| 3 | VAE-LSTM | Probabilistic encoding of the latent space | 222 KB |
+
+### Preprocessing
+
+Four preprocessing decisions deserve specific mention because they determine the final quality of a trajectory detector.
+
+**Metric coordinates relative to the runway.** Latitude and longitude in degrees are inadequate for modeling movement over an airport: distances depend on latitude, and the model does not incorporate geodesy. The pipeline projects coordinates to UTM zone 30 (EPSG:32630), centered on the runway of Barajas, and operates in meters.
+
+**Heading as the (sin, cos) pair.** A circular variable that linear encoding does not represent faithfully. Trigonometric encoding ensures that values close on the circle are also close in feature space.
+
+**Split by date and by flight_id.** Training on 2017-2019, validation and test on 2020. Each flight appears in a single split. This blocks both temporal leakage and instance leakage simultaneously.
+
+**Cleaning of the training set.** I excluded from training the 100 flights with a go-around pattern and the four with an emergency squawk. The training set must represent the most conservative version of "normal flight". Leaving go-arounds in makes the model learn to reconstruct them without difficulty, nullifying their value as anomalies.
+
+The final windows have 60 steps of 10 seconds (10 minutes per window), with 50 % overlap. Seven features per step:
+
+```
+[x_rel, y_rel, baroaltitude, velocity, sin_hdg, cos_hdg, vertrate]
+```
+
+The resulting set: 61,008 training windows, 7,679 validation, 7,788 test and 1,076 labeled as anomalous. The scaler standardizes features by fitting only on the training set.
+
+### Architectures
+
+**Isolation Forest** over summary statistics (mean, standard deviation, minimum and maximum per feature). A non-sequential baseline whose function is to establish the reference line that deep learning must surpass.
+
+**LSTM autoencoder**: encoder with a single LSTM layer (hidden 64), linear bottleneck to a latent of dimension 16, symmetric decoder that unrolls from the repeated latent.
+
+**Transformer autoencoder**: two encoder layers with four attention heads (d_model 64), sinusoidal positional encoding, same bottleneck to latent 16.
+
+**VAE-LSTM**: LSTM encoder that produces the mean and log-variance, reparameterization so that gradients flow through the sampling, LSTM decoder from z. The loss combines reconstruction error (MSE) with the Kullback-Leibler divergence weighted by a beta coefficient of 0.0001193, selected by Optuna.
+
+```python
+std = torch.exp(0.5 * logvar)
+eps = torch.randn_like(std)
+z = mu + std * eps
+```
+
+All models share the same training loop: Adam optimizer with weight decay, ReduceLROnPlateau scheduler, early stopping with patience 7, fixed seed 42, complete tracking with MLflow.
+
+### Synthetic anomaly bench
+
+Four real events do not allow stable quantitative evaluation. To address this limitation, controlled anomalies are injected over normal flights from the test set. Five families, all with a linear ramp at onset to allow the measurement of **detection latency** (seconds from the start of the perturbation to the first threshold crossing):
+
+- **Route deviation**: lateral deformation, magnitudes of 20, 40 and 80 km.
+- **Altitude anomaly**: offset of 300, 800 or 1,500 m.
+- **Speed anomaly**: multiplicative factors of 0.4x, 1.6x and 2.2x.
+- **Holding**: continuous turns with a period of 120 or 240 seconds.
+- **Transponder freeze**: the ADS-B retains the last value for the rest of the window.
+
+Validation against an in-house simulator might seem circular. It is standard practice in *safety engineering*: the simulator was designed before the models and describes well-defined failure modes, not patterns learned from the model. The set produces 12 variants (combinations of type and intensity) and 24,000 synthetic windows per evaluated model.
+
+So much for the setup. Next, whether it works.
+
+## Results
+
+Results on the 2020 test set:
+
+| Model | Real ROC-AUC | Real PR-AUC | Synthetic ROC | Median latency |
+|---|---|---|---|---|
+| Isolation Forest | 0.515 | 0.133 | 0.593 | n/a |
+| LSTM-AE | 0.648 | 0.260 | 0.779 | 115 s |
+| Transformer-AE | 0.614 | 0.227 | 0.743 | 115 s |
+| **VAE-LSTM** | **0.659** | **0.299** | **0.792** | 120 s |
+
+The deep models nearly double the PR-AUC of the baseline. This difference justifies the investment in deep learning: if the LSTM had not beaten the Isolation Forest, the rest of the work would not have made sense.
+
+![Precision-recall curve of the VAE-LSTM on the real test set. The PR-AUC of 0.299 doubles the baseline under heavy imbalance.](../reports/figures/pr_vae-lstm.png)
+
+![ROC curve of the VAE-LSTM on the same set. ROC-AUC of 0.659.](../reports/figures/roc_vae-lstm.png)
+
+One observation deserves attention.
+
+The Transformer won the validation loss (0.038 against 0.053 for the VAE and 0.072 for the LSTM). And lost the PR-AUC. Something did not add up.
+
+The explanation is direct: an architecture with enough capacity also reconstructs anomalies with some fidelity, which reduces the separability between normal and anomalous as measured by reconstruction error. In reconstruction-based detection, validation loss is a poor proxy for performance. We know it and keep looking at it anyway.
+
+I also evaluated two ensembles, by mean and by maximum of the z-normalized scores. Neither beat the individual VAE (PR-AUC 0.273 and 0.278 against 0.299), and I discarded them. The ensemble was an attempt to close with a push. It did not deliver. It is honest to report it.
+
+The numbers tell one part. The other lies in what does not show up in the table.
+
+## Discussion
+
+The results show a detection profile that is **heterogeneous by anomaly type**. The final model easily detects loud perturbations: ROC-AUC 0.984 in holding with a 120 s period, 0.989 in acceleration with factor 2.2, 0.899 in route deviation of 80 km. Subtle perturbations (300 m of altitude, small drifts) require close to two minutes and fall into the 0.51-0.55 range.
+
+The most relevant case of the discussion is the **transponder freeze**.
+
+The VAE detects it in 1.2 % of cases. One out of every eighty attempts.
+
+The explanation is structural: an aircraft in stable cruise whose values freeze produces a pattern very close to that of an aircraft in stable cruise that keeps transmitting. The reconstruction error remains low and the score does not cross the threshold. It is a limitation of the reconstruction approach, not of training.
+
+![Confusion matrix of the VAE-LSTM with the threshold set at the 99th percentile of validation. The balance favors precision over recall, consistent with a target false alarm rate of 1 %.](../reports/figures/cm_vae-lstm.png)
+
+This heterogeneity defines the scope of the system. SADAR is a detector of **anomalous maneuvers**, not a universal incident detector. Its operational value lies in those deviations that the traditional rule-based network (systems such as STCA or MSAW) does not cover, not in replacing those systems.
+
+Before closing, it is worth being explicit about what the system does not do.
+
+## Limitations
+
+The system assumes certain limitations documented explicitly in the technical report.
+
+- **Absence of flight plans**. SADAR does not have the planned route for each flight. The "deviation from the expected route" is approximated by "deviation from the mean pattern". A flight that departs from its assigned plan but stays within the mean pattern will not be flagged.
+- **Temporal coverage**. The set consists of 18 non-consecutive days between 2017 and 2020. Modeling demand, seasonality or continuous temporal prediction falls outside the scope.
+- **Transponder freeze**. Within-window detection rate of 1.2 %. Any serious extension of the system must address this case specifically (derivative signals, change-point detection, dedicated model).
+- **Coverage gaps**. 24.2 % of in-air flights present gaps longer than 120 seconds in reception. These gaps are receiver artifacts, not operational incidents. Treating them as positive labels would generate systematic noise.
+
+## Deployed system
+
+The final model is served through an API built on FastAPI that mounts a React + Vite + TypeScript frontend on the same port, allowing a *single-image* deployment on Hugging Face Spaces. The dashboard consists of three screens:
+
+1. **Tower console**: live radar over Barajas with the day's flights and their scores, visual alert when one crosses the threshold.
+2. **Simulator**: controlled injection of anomalies over a reference flight, with visualization of the deformed trajectory, the score and the latency.
+3. **Metrics**: model comparison table, precision-recall and ROC curves, confusion matrices, breakdown by anomaly type.
+
+## Stack and reproducibility
+
+Python 3.11, PyTorch, FastAPI, MLflow and Optuna on the backend. Vite, React 18 and TypeScript on the frontend. Packaged in a *single-image* Docker container. Reproducibility guaranteed by fixed seeds, YAML configurations that resolve environment variables, and checkpoints stored also as MLflow artifacts.
+
+## Conclusions and future work
+
+SADAR shows that conformance monitoring of flight trajectories is tractable with deep autoencoders trained exclusively on normal operation, with defensible metrics and a reproducible evaluation protocol. The comparison between three model families under identical conditions allows the choice of VAE-LSTM to be justified not only by its final PR-AUC, but by its overall detection and latency profile.
+
+The Transformer was not the right choice for this problem. I leave it documented because discarded options also count.
+
+Immediate future work points to three directions. First, replace the Transformer with a TCN or a convolutional autoencoder to bound capacity without losing temporal modeling. Second, incorporate derivatives and change-point detection to address the transponder freeze. Third, evaluate the incorporation of flight plans when available, which would reframe the problem as plan-conditioned prediction rather than approximation to the mean pattern.
+
+IBE2845 landed without incident on July 31, 2017 and its three red points received no further attention. Glitch, anomaly or incident, reality rarely arrives labeled, and building systems that operate in that terrain begins by accepting it.

docs/medium_post.md

@@ -0,0 +1,205 @@
+# Cuando el modelo más complejo no es el que detecta mejor
+
+*Comparativa entre LSTM, Transformer y VAE-LSTM sobre 19.000 vuelos reales de Barajas. Y por qué la pérdida de validación no es buena consejera.*
+
+![Torre de control con tráfico aéreo sobre la pista al atardecer.](../docs/assets/tower-day.png)
+
+> **Código:** [github.com/iRuperth/SADAR](https://github.com/iRuperth/SADAR)
+> **Demo en vivo:** [huggingface.co/spaces/devrup404/sadar](https://huggingface.co/spaces/devrup404/sadar)
+>
+> El repositorio es público y está abierto a colaboraciones, sugerencias y forks. Cualquier discusión técnica, *issue* o *pull request* es bienvenida.
+
+---
+
+El dato más interesante del dataset no es un secuestro. Es un avión que fingió serlo durante treinta segundos por error.
+
+El 31 de julio de 2017, un Airbus de Iberia voló sobre Madrid con el código de secuestro activado en el transpondedor durante tres puntos de su trayectoria. Después volvió a la normalidad. El vuelo era el IBE2845, el código transmitido era el 7500, y en el sistema secundario de vigilancia ese código significa interferencia ilícita.
+
+No era un secuestro. Era casi con total seguridad un fallo del transpondedor: tres puntos sobre los 171 que componen el registro completo del vuelo, a 800 metros de la pista, sin más anomalía operativa. Aquel vuelo, anotado en un fichero parquet de 3,4 millones de filas, marca el inicio de este artículo. Y marca también la pregunta técnica que me llevé al proyecto: ¿puede un modelo aprender qué aspecto tiene un vuelo normal y avisar cuando uno deja de parecerlo?
+
+Este artículo presenta SADAR, un sistema de detección de anomalías en trayectorias aéreas entrenado sobre dieciocho días de tráfico real procedente del aeropuerto Adolfo Suárez Madrid-Barajas. Compara tres autoencoders profundos contra un baseline clásico, evalúa el sistema sobre un banco de anomalías sintéticas y discute con franqueza dónde funciona y dónde no.
+
+Empecemos por el problema.
+
+## Planteamiento
+
+La detección de incidentes en aviación civil rara vez puede formularse como un problema supervisado: los datos están dominados por operación normal y los pocos eventos etiquetados son ambiguos. La alternativa estándar es la **monitorización de conformidad**: aprender la distribución del comportamiento normal y señalar las trayectorias que se apartan de ella. Esta es la formulación que adopta SADAR.
+
+La distinción importa. Decir "este vuelo se aparta del patrón aprendido" es defendible con datos. Decir "este vuelo es un incidente" requiere contexto operacional que el ADS-B no proporciona. SADAR opera estrictamente en el primer enunciado.
+
+## Datos
+
+Los datos provienen de OpenSky Network, una red colaborativa de receptores ADS-B. El conjunto cubre 18 días no consecutivos entre junio de 2017 y marzo de 2020, centrados en el espacio aéreo de Barajas. Cada aeronave reporta una posición cada 10 segundos, con 21 columnas por punto: posición y dinámica (latitud, longitud, altitud barométrica y geométrica, velocidad, rumbo, régimen vertical), identidad (callsign, icao24, flight_id) y estado del transpondedor (squawk, alert, onground).
+
+Las cifras crudas, tras la unión y deduplicación:
+
+- 3.429.638 filas.
+- 19.057 vuelos distintos.
+- Mediana de 175 puntos por vuelo, máximo 1.606.
+- Mediana de duración de 30,2 minutos.
+
+El primer hallazgo del análisis exploratorio fueron los huecos. La altitud GPS (`geoaltitude`) presenta un 24,79 % de valores ausentes. La velocidad y el rumbo, alrededor del 13 %. Estos huecos no son errores: corresponden a zonas de menor cobertura del receptor terrestre. Descarté la altitud GPS y me quedé con la barométrica, más completa, tratando los huecos como una propiedad del problema y no como un fallo a corregir.
+
+![Trayectorias muestreadas sobre el espacio aéreo de LEMD. Los corredores de aproximación y salida se identifican visualmente antes de cualquier proyección. En rojo, los puntos de los cuatro vuelos con squawk de emergencia.](../docs/assets/eda/trajectories_map.png)
+
+El segundo hallazgo provino del histograma del rumbo. Representado en un gráfico polar, las dos pistas paralelas de Barajas aparecen como dos lóbulos opuestos.
+
+![Histograma polar del rumbo sobre el dataset completo. Los dos lóbulos opuestos corresponden a las pistas paralelas de Barajas. Esta propiedad circular motivó la codificación del rumbo como par (sin, cos).](../docs/assets/eda/heading_polar.png)
+
+El aeropuerto es identificable en los datos antes de proyectarlos sobre un mapa.
+
+Esa propiedad circular del rumbo motivó su codificación como par seno y coseno: para un autoencoder, 359° y 1° deben quedar adyacentes, y una codificación lineal lo impide.
+
+![Distribución de filas por fase de vuelo en el dataset. La fase de descenso domina, seguida de ascenso y operaciones en superficie, lo que condiciona qué patrones aprende mejor el modelo.](../docs/assets/eda/flight_phases.png)
+
+## Eventos reales en el conjunto
+
+El dataset contiene únicamente cuatro vuelos con código de emergencia en el transpondedor. Conviene describirlos con detalle, porque su escasez determina el planteamiento del problema:
+
+- **IBE2845** (Iberia, 31 de julio de 2017). Squawk 7500 durante tres puntos sobre 171, transmitido a 800 metros de pista. Compatible con un fallo del transpondedor.
+- **ELY395** (El Al, 2 de octubre de 2017). Squawk 7700 durante cinco puntos, declarado a 800 metros de pista. El avión aterrizó. Es el caso más plausible de emergencia real.
+- **RYR61AD** (Ryanair, 28 de enero de 2019). Squawk 7600 (fallo de comunicaciones). Un punto. Aterrizó.
+- **SWR202Y** (Swiss, 3 de febrero de 2020). Squawk 7700. Un punto. Aterrizó.
+
+Cuatro etiquetas en un universo de no etiquetas. Esta proporción descarta el aprendizaje supervisado: ningún clasificador se entrena con cuatro positivos. Los cuatro vuelos se reservaron como conjunto de validación cualitativa, agrupados en 1.076 ventanas etiquetadas en `data/processed/anomalies.npy`, y no aparecen en ningún momento del entrenamiento.
+
+## Metodología
+
+### Aprendizaje de una sola clase
+
+Sin etiquetas suficientes, el planteamiento es **aprendizaje de una sola clase** mediante autoencoders. La red aprende a reconstruir trayectorias normales. El error de reconstrucción opera como score de anomalía: una entrada parecida a las del entrenamiento produce un error bajo; una entrada inusual lo eleva.
+
+Entrené cuatro detectores bajo idénticas condiciones (mismo preprocesado, mismo split, mismo umbral) para permitir una comparación rigurosa:
+
+| # | Modelo | Idea | Pesos |
+|---|---|---|---|
+| 0 | Isolation Forest | Estadísticas resumen por ventana, no secuencial | baseline |
+| 1 | LSTM autoencoder | Reconstrucción secuencial | 224 KB |
+| 2 | Transformer autoencoder | Atención sobre la ventana completa | 635 KB |
+| 3 | VAE-LSTM | Codificación probabilística del espacio latente | 222 KB |
+
+### Preprocesado
+
+Cuatro decisiones de preprocesado merecen mención específica porque determinan la calidad final de un detector de trayectorias.
+
+**Coordenadas métricas relativas a la pista.** Latitud y longitud en grados resultan inadecuadas para modelar movimiento sobre un aeropuerto: las distancias dependen de la latitud, y el modelo no incorpora geodesia. El pipeline proyecta las coordenadas a UTM zona 30 (EPSG:32630), centradas en la pista de Barajas, y opera en metros.
+
+**Rumbo como par (sin, cos).** Variable circular que la codificación lineal no representa con fidelidad. La codificación trigonométrica asegura que valores próximos en el círculo lo sean también en el espacio de features.
+
+**Split por fecha y por flight_id.** Entrenamiento sobre 2017-2019, validación y test sobre 2020. Cada vuelo aparece en un único split. Esto bloquea simultáneamente la fuga temporal y la de instancia.
+
+**Limpieza del conjunto de entrenamiento.** Excluí del entrenamiento los 100 vuelos con patrón de go-around y los cuatro con squawk de emergencia. El conjunto de entrenamiento debe representar la versión más conservadora de "vuelo normal". Mantener go-arounds dentro hace que el modelo aprenda a reconstruirlos sin dificultad, anulando su valor como anomalías.
+
+Las ventanas finales tienen 60 pasos de 10 segundos (10 minutos por ventana), con solapamiento del 50 %. Siete features por paso:
+
+```
+[x_rel, y_rel, baroaltitude, velocity, sin_hdg, cos_hdg, vertrate]
+```
+
+El conjunto resultante: 61.008 ventanas de entrenamiento, 7.679 de validación, 7.788 de test y 1.076 etiquetadas como anómalas. El escalador estandariza las features ajustándose únicamente sobre el conjunto de entrenamiento.
+
+### Arquitecturas
+
+**Isolation Forest** sobre estadísticas resumen (media, desviación, mínimo y máximo por feature). Baseline no secuencial cuya función es establecer la línea de referencia que el deep learning debe superar.
+
+**LSTM autoencoder**: encoder con una capa LSTM (hidden 64), cuello de botella lineal a un latente de dimensión 16, decoder simétrico que desenrolla desde el latente repetido.
+
+**Transformer autoencoder**: dos capas de encoder con cuatro cabezas de atención (d_model 64), codificación posicional sinusoidal, mismo cuello de botella a latente 16.
+
+**VAE-LSTM**: encoder LSTM que produce la media y el logaritmo de la varianza, reparametrización para que los gradientes fluyan a través del muestreo, decoder LSTM desde z. La pérdida combina el error de reconstrucción (MSE) con la divergencia de Kullback-Leibler ponderada por un coeficiente beta de 0,0001193, seleccionado por Optuna.
+
+```python
+std = torch.exp(0.5 * logvar)
+eps = torch.randn_like(std)
+z = mu + std * eps
+```
+
+Todos los modelos comparten el mismo loop de entrenamiento: optimizador Adam con weight decay, scheduler ReduceLROnPlateau, early stopping con paciencia 7, semilla fija a 42, tracking completo con MLflow.
+
+### Banco de anomalías sintéticas
+
+Cuatro eventos reales no permiten una evaluación cuantitativa estable. Para suplir esta limitación, se inyectan anomalías controladas sobre vuelos normales del conjunto de test. Cinco familias, todas con rampa lineal de inicio para permitir la medición de la **latencia de detección** (segundos desde el inicio de la perturbación hasta el primer cruce del umbral):
+
+- **Desviación de ruta**: deformación lateral, magnitudes de 20, 40 y 80 km.
+- **Anomalía de altitud**: offset de 300, 800 o 1.500 m.
+- **Anomalía de velocidad**: factores multiplicativos de 0,4x, 1,6x y 2,2x.
+- **Holding**: giros continuos con período de 120 o 240 segundos.
+- **Congelación del transpondedor**: el ADS-B retiene el último valor durante el resto de la ventana.
+
+La validación contra un simulador propio podría parecer circular. Es una práctica estándar en *safety engineering*: el simulador se diseñó antes que los modelos y describe modos de fallo bien definidos, no patrones aprendidos del modelo. El conjunto produce 12 variantes (combinaciones de tipo e intensidad) y 24.000 ventanas sintéticas por modelo evaluado.
+
+Hasta aquí, el planteamiento. Lo siguiente es ver si funciona.
+
+## Resultados
+
+Resultados sobre el conjunto de test de 2020:
+
+| Modelo | ROC-AUC real | PR-AUC real | ROC sintético | Latencia mediana |
+|---|---|---|---|---|
+| Isolation Forest | 0,515 | 0,133 | 0,593 | n/d |
+| LSTM-AE | 0,648 | 0,260 | 0,779 | 115 s |
+| Transformer-AE | 0,614 | 0,227 | 0,743 | 115 s |
+| **VAE-LSTM** | **0,659** | **0,299** | **0,792** | 120 s |
+
+Los modelos profundos prácticamente duplican la PR-AUC del baseline. Esta diferencia justifica la inversión en deep learning: si el LSTM no hubiera batido al Isolation Forest, el resto del trabajo no habría tenido sentido.
+
+![Curva precision-recall del VAE-LSTM sobre el conjunto de test real. La PR-AUC de 0,299 duplica al baseline en condiciones de fuerte desbalance.](../reports/figures/pr_vae-lstm.png)
+
+![Curva ROC del VAE-LSTM sobre el mismo conjunto. ROC-AUC de 0,659.](../reports/figures/roc_vae-lstm.png)
+
+Una observación merece atención.
+
+El Transformer ganó la pérdida de validación (0,038 frente a 0,053 del VAE y 0,072 del LSTM). Y perdió la PR-AUC. Algo no cuadraba.
+
+La explicación es directa: una arquitectura con suficiente capacidad reconstruye también con cierta fidelidad las anomalías, lo que reduce la separabilidad entre normal y anómalo medida por el error de reconstrucción. En detección por reconstrucción, la pérdida de validación es un mal proxy del rendimiento. Lo sabemos y aun así la seguimos mirando.
+
+Evalué además dos ensembles, por promedio y por máximo de los scores z-normalizados. Ninguno superó al VAE individual (PR-AUC 0,273 y 0,278 frente a 0,299), y los descarté. El ensemble fue un intento de cerrar con un empujón. No lo dio. Es honesto reportarlo.
+
+Los números cuentan una parte. La otra está en lo que no sale en la tabla.
+
+## Discusión
+
+Los resultados muestran un perfil de detección **heterogéneo por tipo de anomalía**. El modelo final detecta con facilidad las perturbaciones ruidosas: ROC-AUC 0,984 en holding con periodo de 120 s, 0,989 en aceleración con factor 2,2, 0,899 en desviación de ruta de 80 km. Las perturbaciones sutiles (300 m de altitud, derivas pequeñas) requieren tiempos cercanos a los dos minutos y bajan al rango 0,51-0,55.
+
+El caso más relevante de la discusión es la **congelación del transpondedor**.
+
+El VAE lo detecta en el 1,2 % de los casos. Uno de cada ochenta intentos.
+
+La explicación es estructural: un avión en crucero estable cuyos valores se congelan produce un patrón muy próximo al de un avión en crucero estable que continúa transmitiendo. El error de reconstrucción permanece bajo y el score no llega a cruzar el umbral. Es una limitación del enfoque de reconstrucción, no del entrenamiento.
+
+![Matriz de confusión del VAE-LSTM con umbral en el percentil 99 de la validación. El balance favorece la precisión sobre la sensibilidad, consistente con una tasa de falsa alarma objetivo del 1 %.](../reports/figures/cm_vae-lstm.png)
+
+Esta heterogeneidad delimita el alcance del sistema. SADAR es un detector de **maniobras anómalas**, no un detector universal de incidentes. Su valor operativo está en aquellas desviaciones que la red de reglas tradicional (sistemas tipo STCA o MSAW) no cubre, no en sustituir esos sistemas.
+
+Antes de cerrar, conviene ser explícito en lo que el sistema no hace.
+
+## Limitaciones
+
+El sistema asume ciertas limitaciones documentadas explícitamente en el informe técnico.
+
+- **Ausencia de planes de vuelo**. SADAR no dispone de la ruta prevista de cada vuelo. La "desviación respecto a la ruta esperada" se aproxima por "desviación respecto al patrón medio". Un vuelo que se aparte de su plan asignado pero permanezca dentro del patrón medio no será marcado.
+- **Cobertura temporal**. El conjunto consta de 18 días no consecutivos entre 2017 y 2020. Modelar demanda, estacionalidad o predicción temporal continua queda fuera del alcance.
+- **Congelación del transpondedor**. Tasa de detección dentro de ventana del 1,2 %. Cualquier extensión seria del sistema debe atacar este caso de forma específica (señales derivadas, detección de cambio de régimen, modelo dedicado).
+- **Huecos de cobertura**. El 24,2 % de los vuelos en aire presentan gaps superiores a 120 segundos en la recepción. Estos huecos son artefactos del receptor, no incidentes operativos. Tratarlos como etiquetas positivas generaría ruido sistemático.
+
+## Sistema desplegado
+
+El modelo final se sirve a través de una API construida sobre FastAPI que monta un frontend React + Vite + TypeScript en el mismo puerto, lo que permite un despliegue *single-image* en Hugging Face Spaces. El dashboard consta de tres pantallas:
+
+1. **Tower console**: radar en vivo sobre Barajas con los vuelos del día y sus scores, alerta visual al cruzar el umbral.
+2. **Simulator**: inyección controlada de anomalías sobre un vuelo de referencia, con visualización de la trayectoria deformada, el score y la latencia.
+3. **Metrics**: tabla comparativa de modelos, curvas precision-recall y ROC, matrices de confusión, desglose por tipo de anomalía.
+
+## Stack y reproducibilidad
+
+Python 3.11, PyTorch, FastAPI, MLflow y Optuna en el backend. Vite, React 18 y TypeScript en el frontend. Empaquetado en Docker *single-image*. Reproducibilidad garantizada por semillas fijas, configuraciones YAML que resuelven variables de entorno, y los checkpoints almacenados también como artifacts de MLflow.
+
+## Conclusiones y trabajo futuro
+
+SADAR demuestra que la monitorización de conformidad de trayectorias aéreas es abordable mediante autoencoders profundos entrenados exclusivamente sobre operación normal, con métricas defendibles y un protocolo de evaluación reproducible. La comparación entre tres familias de modelos bajo idénticas condiciones permite justificar la elección del VAE-LSTM no solo por su PR-AUC final, sino por su perfil global de detección y latencia.
+
+El Transformer no fue la elección correcta para este problema. Lo dejo documentado porque los descartes también cuentan.
+
+El trabajo futuro inmediato apunta a tres líneas. Primero, sustituir el Transformer por un TCN o un autoencoder convolucional para acotar la capacidad sin perder modelado temporal. Segundo, incorporar derivadas y detección de cambio de régimen para atacar la congelación del transpondedor. Tercero, evaluar la incorporación de planes de vuelo cuando estén disponibles, lo que replantearía el problema como predicción condicionada por el plan en lugar de aproximación al patrón medio.
+
+El IBE2845 aterrizó sin incidentes el 31 de julio de 2017 y sus tres puntos en rojo no recibieron mayor atención. Glitch, anomalía o incidente, la realidad rara vez llega etiquetada, y construir sistemas que operen en ese terreno empieza por aceptarlo.

frontend/.dockerignore

@@ -0,0 +1,8 @@
+node_modules
+dist
+.vite
+.DS_Store
+.env
+.env.*
+Dockerfile
+.dockerignore

frontend/.gitignore

@@ -0,0 +1,5 @@
+node_modules
+dist
+dist-ssr
+*.local
+.vite

frontend/Dockerfile

@@ -0,0 +1,27 @@
+FROM node:20-alpine AS builder
+
+RUN corepack enable && corepack prepare pnpm@9.12.0 --activate
+
+WORKDIR /app
+
+COPY package.json pnpm-lock.yaml ./
+
+RUN pnpm install --frozen-lockfile
+
+COPY . .
+
+ARG VITE_API_BASE=/api
+ENV VITE_API_BASE=$VITE_API_BASE
+
+RUN pnpm build
+
+
+FROM nginx:1.27-alpine AS runtime
+
+COPY --from=builder /app/dist /usr/share/nginx/html
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+
+EXPOSE 80
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+    CMD wget -q -O - http://localhost/ >/dev/null || exit 1

frontend/index.html

@@ -0,0 +1,20 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" type="image/png" href="/sadar-mark.png" />
+    <link rel="apple-touch-icon" href="/sadar-mark.png" />
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=B612+Mono:wght@400;700&display=swap"
+      rel="stylesheet"
+    />
+    <title>SADAR Flight Conformance Monitor</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

frontend/nginx.conf

@@ -0,0 +1,31 @@
+server {
+    listen 80;
+    server_name _;
+
+    root /usr/share/nginx/html;
+    index index.html;
+
+    gzip on;
+    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript image/svg+xml;
+    gzip_min_length 1024;
+
+    location /api/ {
+        proxy_pass http://backend:8000;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_read_timeout 120s;
+    }
+
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    location ~* \.(?:js|css|woff2?|ttf|otf|eot|svg|png|jpg|jpeg|gif|webp|ico|map)$ {
+        expires 7d;
+        access_log off;
+        add_header Cache-Control "public, max-age=604800, immutable";
+    }
+}

frontend/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "sadar-frontend",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "framer-motion": "^11.5.4",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^6.26.2"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.10",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.3.2",
+    "typescript": "^5.6.2",
+    "vite": "^5.4.8"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": ["esbuild"]
+  }
+}

frontend/pnpm-lock.yaml

@@ -0,0 +1,1160 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      framer-motion:
+        specifier: ^11.5.4
+        version: 11.18.2(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      react:
+        specifier: ^18.3.1
+        version: 18.3.1
+      react-dom:
+        specifier: ^18.3.1
+        version: 18.3.1(react@18.3.1)
+      react-router-dom:
+        specifier: ^6.26.2
+        version: 6.30.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+    devDependencies:
+      '@types/react':
+        specifier: ^18.3.10
+        version: 18.3.29
+      '@types/react-dom':
+        specifier: ^18.3.0
+        version: 18.3.7(@types/react@18.3.29)
+      '@vitejs/plugin-react':
+        specifier: ^4.3.2
+        version: 4.7.0(vite@5.4.21)
+      typescript:
+        specifier: ^5.6.2
+        version: 5.9.3
+      vite:
+        specifier: ^5.4.8
+        version: 5.4.21
+
+packages:
+
+  '@babel/code-frame@7.29.7':
+    resolution: {integrity: sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/compat-data@7.29.7':
+    resolution: {integrity: sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/core@7.29.7':
+    resolution: {integrity: sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/generator@7.29.7':
+    resolution: {integrity: sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-compilation-targets@7.29.7':
+    resolution: {integrity: sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-globals@7.29.7':
+    resolution: {integrity: sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-module-imports@7.29.7':
+    resolution: {integrity: sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-module-transforms@7.29.7':
+    resolution: {integrity: sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/helper-plugin-utils@7.29.7':
+    resolution: {integrity: sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-string-parser@7.29.7':
+    resolution: {integrity: sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-identifier@7.29.7':
+    resolution: {integrity: sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-option@7.29.7':
+    resolution: {integrity: sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helpers@7.29.7':
+    resolution: {integrity: sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/parser@7.29.7':
+    resolution: {integrity: sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  '@babel/plugin-transform-react-jsx-self@7.29.7':
+    resolution: {integrity: sha512-TL0hMc9xzy86VD31nUiwzd5otRAcyEPcsegCxolO0PvcXuH1v0kECe/UIznYFihpkvU5wg/jk4v0TTEFfm53fw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-react-jsx-source@7.29.7':
+    resolution: {integrity: sha512-06IyK09H3wi4cGbhDBwp5gUGo0IKtnYa8tyTiephirPCK6fbobVGiXMMI5zLQ4aKEYP3wZ3ArU44o+8KMrSG/Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/template@7.29.7':
+    resolution: {integrity: sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/traverse@7.29.7':
+    resolution: {integrity: sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/types@7.29.7':
+    resolution: {integrity: sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==}
+    engines: {node: '>=6.9.0'}
+
+  '@esbuild/aix-ppc64@0.21.5':
+    resolution: {integrity: sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==}
+    engines: {node: '>=12'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.21.5':
+    resolution: {integrity: sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.21.5':
+    resolution: {integrity: sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.21.5':
+    resolution: {integrity: sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.21.5':
+    resolution: {integrity: sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.21.5':
+    resolution: {integrity: sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.21.5':
+    resolution: {integrity: sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.21.5':
+    resolution: {integrity: sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.21.5':
+    resolution: {integrity: sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.21.5':
+    resolution: {integrity: sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.21.5':
+    resolution: {integrity: sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.21.5':
+    resolution: {integrity: sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==}
+    engines: {node: '>=12'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.21.5':
+    resolution: {integrity: sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==}
+    engines: {node: '>=12'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.21.5':
+    resolution: {integrity: sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==}
+    engines: {node: '>=12'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.21.5':
+    resolution: {integrity: sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==}
+    engines: {node: '>=12'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.21.5':
+    resolution: {integrity: sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==}
+    engines: {node: '>=12'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.21.5':
+    resolution: {integrity: sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-x64@0.21.5':
+    resolution: {integrity: sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-x64@0.21.5':
+    resolution: {integrity: sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/sunos-x64@0.21.5':
+    resolution: {integrity: sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.21.5':
+    resolution: {integrity: sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.21.5':
+    resolution: {integrity: sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.21.5':
+    resolution: {integrity: sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [win32]
+
+  '@jridgewell/gen-mapping@0.3.13':
+    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
+
+  '@jridgewell/remapping@2.3.5':
+    resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==}
+
+  '@jridgewell/resolve-uri@3.1.2':
+    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/sourcemap-codec@1.5.5':
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
+
+  '@remix-run/router@1.23.3':
+    resolution: {integrity: sha512-4An71tdz9X8+3sI4Qqqd2LWd9vS39J7sqd9EU4Scw7TJE/qB10Flv/UuqbPVgfQV9XoK8Np6jNquZitnZq5i+Q==}
+    engines: {node: '>=14.0.0'}
+
+  '@rolldown/pluginutils@1.0.0-beta.27':
+    resolution: {integrity: sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==}
+
+  '@rollup/rollup-android-arm-eabi@4.60.4':
+    resolution: {integrity: sha512-F5QXMSiFebS9hKZj02XhWLLnRpJ3B3AROP0tWbFBSj+6kCbg5m9j5JoHKd4mmSVy5mS/IMQloYgYxCuJC0fxEQ==}
+    cpu: [arm]
+    os: [android]
+
+  '@rollup/rollup-android-arm64@4.60.4':
+    resolution: {integrity: sha512-GxxTKApUpzRhof7poWvCJHRF51C67u1R7D6DiluBE8wKU1u5GWE8t+v81JvJYtbawoBFX1hLv5Ei4eVjkWokaw==}
+    cpu: [arm64]
+    os: [android]
+
+  '@rollup/rollup-darwin-arm64@4.60.4':
+    resolution: {integrity: sha512-tua0TaJxMOB1R0V0RS1jFZ/RpURFDJIOR2A6jWwQeawuFyS4gBW+rntLRaQd0EQ4bd6Vp44Z2rXW+YYDBsj6IA==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rollup/rollup-darwin-x64@4.60.4':
+    resolution: {integrity: sha512-CSKq7MsP+5PFIcydhAiR1K0UhEI1A2jWXVKHPCBZ151yOutENwvnPocgVHkivu2kviURtCEB6zUQw0vs8RrhMg==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rollup/rollup-freebsd-arm64@4.60.4':
+    resolution: {integrity: sha512-+O8OkVdyvXMtJEciu2wS/pzm1IxntEEQx3z5TAVy4l32G0etZn+RsA48ARRrFm6Ri8fvqPQfgrvNxSjKAbnd3g==}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@rollup/rollup-freebsd-x64@4.60.4':
+    resolution: {integrity: sha512-Iw3oMskH3AfNuhU0MSN7vNbdi4me/NiYo2azqPz/Le16zHSa+3RRmliCMWWQmh4lcndccU40xcJuTYJZxNo/lw==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.60.4':
+    resolution: {integrity: sha512-EIPRXTVQpHyF8WOo219AD2yEltPehLTcTMz2fn6JsatLYSzQf00hj3rulF+yauOlF9/FtM2WpkT/hJh/KJFGhA==}
+    cpu: [arm]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-arm-musleabihf@4.60.4':
+    resolution: {integrity: sha512-J3Yh9PzzF1Ovah2At+lHiGQdsYgArxBbXv/zHfSyaiFQEqvNv7DcW98pCrmdjCZBrqBiKrKKe2V+aaSGWuBe/w==}
+    cpu: [arm]
+    os: [linux]
+    libc: [musl]
+
+  '@rollup/rollup-linux-arm64-gnu@4.60.4':
+    resolution: {integrity: sha512-BFDEZMYfUvLn37ONE1yMBojPxnMlTFsdyNoqncT0qFq1mAfllL+ATMMJd8TeuVMiX84s1KbcxcZbXInmcO2mRg==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-arm64-musl@4.60.4':
+    resolution: {integrity: sha512-pc9EYOSlOgdQ2uPl1o9PF6/kLSgaUosia7gOuS8mB69IxJvlclko1MECXysjs5ryez1/5zjYqx3+xYU0TU6R1A==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@rollup/rollup-linux-loong64-gnu@4.60.4':
+    resolution: {integrity: sha512-NxnomyxYerDh5n4iLrNa+sH+Z+U4BMEE46V2PgQ/hoB909i8gV1M5wPojWg9fk1jWpO3IQnOs20K4wyZuFLEFQ==}
+    cpu: [loong64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-loong64-musl@4.60.4':
+    resolution: {integrity: sha512-nbJnQ8a3z1mtmrwImCYhc6BGpThAyYVRQxw9uKSKG4wR6aAYno9sVjJ0zaZcW9BPJX1GbrDPf+SvdWjgTuDmnw==}
+    cpu: [loong64]
+    os: [linux]
+    libc: [musl]
+
+  '@rollup/rollup-linux-ppc64-gnu@4.60.4':
+    resolution: {integrity: sha512-2EU6acNrQLd8tYvo/LXW535wupT3m6fo7HKo6lr7ktQoItxTyOL1ZCR/GfGCuXl2vR+zmfI6eRXkSemafv+iVg==}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-ppc64-musl@4.60.4':
+    resolution: {integrity: sha512-WeBtoMuaMxiiIrO2IYP3xs6GMWkJP2C0EoT8beTLkUPmzV1i/UcOSVw1d5r9KBODtHKilG5yFxsGRnBbK3wJ4A==}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [musl]
+
+  '@rollup/rollup-linux-riscv64-gnu@4.60.4':
+    resolution: {integrity: sha512-FJHFfqpKUI3A10WrWKiFbBZ7yVbGT4q4B5o1qKFFojqpaYoh9LrQgqWCmmcxQzVSXYtyB5bzkXrYzlHTs21MYA==}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-riscv64-musl@4.60.4':
+    resolution: {integrity: sha512-mcEl6CUT5IAUmQf1m9FYSmVqCJlpQ8r8eyftFUHG8i9OhY7BkBXSUdnLH5DOf0wCOjcP9v/QO93zpmF1SptCCw==}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [musl]
+
+  '@rollup/rollup-linux-s390x-gnu@4.60.4':
+    resolution: {integrity: sha512-ynt3JxVd2w2buzoKDWIyiV1pJW93xlQic1THVLXilz429oijRpSHivZAgp65KBu+cMcgf1eVVjdnTLvPxgCuoQ==}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-x64-gnu@4.60.4':
+    resolution: {integrity: sha512-Boiz5+MsaROEWDf+GGEwF8VMHGhlUoQMtIPjOgA5fv4osupqTVnJteQNKJwUcnUog2G55jYXH7KZFFiJe0TEzQ==}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-x64-musl@4.60.4':
+    resolution: {integrity: sha512-+qfSY27qIrFfI/Hom04KYFw3GKZSGU4lXus51wsb5EuySfFlWRwjkKWoE9emgRw/ukoT4Udsj4W/+xxG8VbPKg==}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@rollup/rollup-openbsd-x64@4.60.4':
+    resolution: {integrity: sha512-VpTfOPHgVXEBeeR8hZ2O0F3aSso+JDWqTWmTmzcQKted54IAdUVbxE+j/MVxUsKa8L20HJhv3vUezVPoquqWjA==}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@rollup/rollup-openharmony-arm64@4.60.4':
+    resolution: {integrity: sha512-IPOsh5aRYuLv/nkU51X10Bf75Bsf6+gZdx1X+QP5QM6lIJFHHqbHLG0uJn/hWthzo13UAc2umiUorqZy3axoZg==}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@rollup/rollup-win32-arm64-msvc@4.60.4':
+    resolution: {integrity: sha512-4QzE9E81OohJ/HKzHhsqU+zcYYojVOXlFMs1DdyMT6qXl/niOH7AVElmmEdUNHHS/oRkc++d5k6Vy85zFs0DEw==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rollup/rollup-win32-ia32-msvc@4.60.4':
+    resolution: {integrity: sha512-zTPgT1YuHHcd+Tmx7h8aml0FWFVelV5N54oHow9SLj+GfoDy/huQ+UV396N/C7KpMDMiPspRktzM1/0r1usYEA==}
+    cpu: [ia32]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-gnu@4.60.4':
+    resolution: {integrity: sha512-DRS4G7mi9lJxqEDezIkKCaUIKCrLUUDCUaCsTPCi/rtqaC6D/jjwslMQyiDU50Ka0JKpeXeRBFBAXwArY52vBw==}
+    cpu: [x64]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-msvc@4.60.4':
+    resolution: {integrity: sha512-QVTUovf40zgTqlFVrKA1uXMVvU2QWEFWfAH8Wdc48IxLvrJMQVMBRjuQyUpzZCDkakImib9eVazbWlC6ksWtJw==}
+    cpu: [x64]
+    os: [win32]
+
+  '@types/babel__core@7.20.5':
+    resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
+
+  '@types/babel__generator@7.27.0':
+    resolution: {integrity: sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==}
+
+  '@types/babel__template@7.4.4':
+    resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==}
+
+  '@types/babel__traverse@7.28.0':
+    resolution: {integrity: sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==}
+
+  '@types/estree@1.0.8':
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+
+  '@types/prop-types@15.7.15':
+    resolution: {integrity: sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==}
+
+  '@types/react-dom@18.3.7':
+    resolution: {integrity: sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==}
+    peerDependencies:
+      '@types/react': ^18.0.0
+
+  '@types/react@18.3.29':
+    resolution: {integrity: sha512-ch0qJdr2JY0r04NXSprbK6TXOgnaJ1Tz23fm5W+z0/CBah6BSBc3n96h7K9GOtwh0HrilNWHIBzE1Ko4Dcw/Wg==}
+
+  '@vitejs/plugin-react@4.7.0':
+    resolution: {integrity: sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    peerDependencies:
+      vite: ^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0
+
+  baseline-browser-mapping@2.10.32:
+    resolution: {integrity: sha512-wbPvpyjJPC0zdfdKXxqEL3Ea+bOMD/87X4lftiJkkaBiuG6ALQy1SLmEd7BSmVCuwCQsBrCamgBoLyfFDD1EPg==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  browserslist@4.28.2:
+    resolution: {integrity: sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
+    hasBin: true
+
+  caniuse-lite@1.0.30001793:
+    resolution: {integrity: sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA==}
+
+  convert-source-map@2.0.0:
+    resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
+
+  csstype@3.2.3:
+    resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
+
+  debug@4.4.3:
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  electron-to-chromium@1.5.364:
+    resolution: {integrity: sha512-G/dYE3+AYhyHwzTwg8UbnXf7zqMERYh7l2jJ3QujhFsH8agSYwtnGAR2aZ7f0AakIKJXd5En/Hre4igIUrdlYw==}
+
+  esbuild@0.21.5:
+    resolution: {integrity: sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==}
+    engines: {node: '>=12'}
+    hasBin: true
+
+  escalade@3.2.0:
+    resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
+    engines: {node: '>=6'}
+
+  framer-motion@11.18.2:
+    resolution: {integrity: sha512-5F5Och7wrvtLVElIpclDT0CBzMVg3dL22B64aZwHtsIY8RB4mXICLrkajK4G9R+ieSAGcgrLeae2SeUTg2pr6w==}
+    peerDependencies:
+      '@emotion/is-prop-valid': '*'
+      react: ^18.0.0 || ^19.0.0
+      react-dom: ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@emotion/is-prop-valid':
+        optional: true
+      react:
+        optional: true
+      react-dom:
+        optional: true
+
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  gensync@1.0.0-beta.2:
+    resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
+    engines: {node: '>=6.9.0'}
+
+  js-tokens@4.0.0:
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+
+  jsesc@3.1.0:
+    resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
+    engines: {node: '>=6'}
+    hasBin: true
+
+  json5@2.2.3:
+    resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==}
+    engines: {node: '>=6'}
+    hasBin: true
+
+  loose-envify@1.4.0:
+    resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==}
+    hasBin: true
+
+  lru-cache@5.1.1:
+    resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
+
+  motion-dom@11.18.1:
+    resolution: {integrity: sha512-g76KvA001z+atjfxczdRtw/RXOM3OMSdd1f4DL77qCTF/+avrRJiawSG4yDibEQ215sr9kpinSlX2pCTJ9zbhw==}
+
+  motion-utils@11.18.1:
+    resolution: {integrity: sha512-49Kt+HKjtbJKLtgO/LKj9Ld+6vw9BjH5d9sc40R/kVyH8GLAXgT42M2NnuPcJNuA3s9ZfZBUcwIgpmZWGEE+hA==}
+
+  ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  nanoid@3.3.12:
+    resolution: {integrity: sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  node-releases@2.0.46:
+    resolution: {integrity: sha512-GYVXHE2KnrzAfsAjl4uP++evGFCrAU1jta4ubEjIG7YWt/64Gqv66a30yKwWczVjA6j3bM4nBwH7Pk1JmDHaxQ==}
+    engines: {node: '>=18'}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  postcss@8.5.15:
+    resolution: {integrity: sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  react-dom@18.3.1:
+    resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==}
+    peerDependencies:
+      react: ^18.3.1
+
+  react-refresh@0.17.0:
+    resolution: {integrity: sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==}
+    engines: {node: '>=0.10.0'}
+
+  react-router-dom@6.30.4:
+    resolution: {integrity: sha512-q4HvNl+mmDdkS0g+MqiBZNteQJCuimWoOyHMy4T/RQLAn9Z29+E91QXRaxOujeMl2HTzRSS0KFPd7lxX3PjV0Q==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      react: '>=16.8'
+      react-dom: '>=16.8'
+
+  react-router@6.30.4:
+    resolution: {integrity: sha512-SVUsDe+DybHM/WmYKIVYhZh1o5Dcuf16yM6WjG02Q9XVFMZIJyHYhwrr6bFBXZkVP6z69kNkMyBCujt8FaFLJA==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      react: '>=16.8'
+
+  react@18.3.1:
+    resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==}
+    engines: {node: '>=0.10.0'}
+
+  rollup@4.60.4:
+    resolution: {integrity: sha512-WHeFSbZYsPu3+bLoNRUuAO+wavNlocOPf3wSHTP7hcFKVnJeWsYlCDbr3mTS14FCizf9ccIxXA8sGL8zKeQN3g==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+
+  scheduler@0.23.2:
+    resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==}
+
+  semver@6.3.1:
+    resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
+    hasBin: true
+
+  source-map-js@1.2.1:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
+
+  tslib@2.8.1:
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
+
+  typescript@5.9.3:
+    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  update-browserslist-db@1.2.3:
+    resolution: {integrity: sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==}
+    hasBin: true
+    peerDependencies:
+      browserslist: '>= 4.21.0'
+
+  vite@5.4.21:
+    resolution: {integrity: sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^18.0.0 || >=20.0.0
+      less: '*'
+      lightningcss: ^1.21.0
+      sass: '*'
+      sass-embedded: '*'
+      stylus: '*'
+      sugarss: '*'
+      terser: ^5.4.0
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+
+  yallist@3.1.1:
+    resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}
+
+snapshots:
+
+  '@babel/code-frame@7.29.7':
+    dependencies:
+      '@babel/helper-validator-identifier': 7.29.7
+      js-tokens: 4.0.0
+      picocolors: 1.1.1
+
+  '@babel/compat-data@7.29.7': {}
+
+  '@babel/core@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-compilation-targets': 7.29.7
+      '@babel/helper-module-transforms': 7.29.7(@babel/core@7.29.7)
+      '@babel/helpers': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+      '@jridgewell/remapping': 2.3.5
+      convert-source-map: 2.0.0
+      debug: 4.4.3
+      gensync: 1.0.0-beta.2
+      json5: 2.2.3
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/generator@7.29.7':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+      jsesc: 3.1.0
+
+  '@babel/helper-compilation-targets@7.29.7':
+    dependencies:
+      '@babel/compat-data': 7.29.7
+      '@babel/helper-validator-option': 7.29.7
+      browserslist: 4.28.2
+      lru-cache: 5.1.1
+      semver: 6.3.1
+
+  '@babel/helper-globals@7.29.7': {}
+
+  '@babel/helper-module-imports@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-module-transforms@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-module-imports': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
+      '@babel/traverse': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-plugin-utils@7.29.7': {}
+
+  '@babel/helper-string-parser@7.29.7': {}
+
+  '@babel/helper-validator-identifier@7.29.7': {}
+
+  '@babel/helper-validator-option@7.29.7': {}
+
+  '@babel/helpers@7.29.7':
+    dependencies:
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
+
+  '@babel/parser@7.29.7':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@babel/plugin-transform-react-jsx-self@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
+
+  '@babel/plugin-transform-react-jsx-source@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
+
+  '@babel/template@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+
+  '@babel/traverse@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-globals': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/types@7.29.7':
+    dependencies:
+      '@babel/helper-string-parser': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
+
+  '@esbuild/aix-ppc64@0.21.5':
+    optional: true
+
+  '@esbuild/android-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/android-arm@0.21.5':
+    optional: true
+
+  '@esbuild/android-x64@0.21.5':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/darwin-x64@0.21.5':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-arm@0.21.5':
+    optional: true
+
+  '@esbuild/linux-ia32@0.21.5':
+    optional: true
+
+  '@esbuild/linux-loong64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.21.5':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-s390x@0.21.5':
+    optional: true
+
+  '@esbuild/linux-x64@0.21.5':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.21.5':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.21.5':
+    optional: true
+
+  '@esbuild/sunos-x64@0.21.5':
+    optional: true
+
+  '@esbuild/win32-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/win32-ia32@0.21.5':
+    optional: true
+
+  '@esbuild/win32-x64@0.21.5':
+    optional: true
+
+  '@jridgewell/gen-mapping@0.3.13':
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/remapping@2.3.5':
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/resolve-uri@3.1.2': {}
+
+  '@jridgewell/sourcemap-codec@1.5.5': {}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  '@remix-run/router@1.23.3': {}
+
+  '@rolldown/pluginutils@1.0.0-beta.27': {}
+
+  '@rollup/rollup-android-arm-eabi@4.60.4':
+    optional: true
+
+  '@rollup/rollup-android-arm64@4.60.4':
+    optional: true
+
+  '@rollup/rollup-darwin-arm64@4.60.4':
+    optional: true
+
+  '@rollup/rollup-darwin-x64@4.60.4':
+    optional: true
+
+  '@rollup/rollup-freebsd-arm64@4.60.4':
+    optional: true
+
+  '@rollup/rollup-freebsd-x64@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-arm-musleabihf@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-gnu@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-musl@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-loong64-gnu@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-loong64-musl@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-ppc64-gnu@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-ppc64-musl@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-gnu@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-musl@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-s390x-gnu@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-x64-gnu@4.60.4':
+    optional: true
+
+  '@rollup/rollup-linux-x64-musl@4.60.4':
+    optional: true
+
+  '@rollup/rollup-openbsd-x64@4.60.4':
+    optional: true
+
+  '@rollup/rollup-openharmony-arm64@4.60.4':
+    optional: true
+
+  '@rollup/rollup-win32-arm64-msvc@4.60.4':
+    optional: true
+
+  '@rollup/rollup-win32-ia32-msvc@4.60.4':
+    optional: true
+
+  '@rollup/rollup-win32-x64-gnu@4.60.4':
+    optional: true
+
+  '@rollup/rollup-win32-x64-msvc@4.60.4':
+    optional: true
+
+  '@types/babel__core@7.20.5':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+      '@types/babel__generator': 7.27.0
+      '@types/babel__template': 7.4.4
+      '@types/babel__traverse': 7.28.0
+
+  '@types/babel__generator@7.27.0':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@types/babel__template@7.4.4':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+
+  '@types/babel__traverse@7.28.0':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@types/estree@1.0.8': {}
+
+  '@types/prop-types@15.7.15': {}
+
+  '@types/react-dom@18.3.7(@types/react@18.3.29)':
+    dependencies:
+      '@types/react': 18.3.29
+
+  '@types/react@18.3.29':
+    dependencies:
+      '@types/prop-types': 15.7.15
+      csstype: 3.2.3
+
+  '@vitejs/plugin-react@4.7.0(vite@5.4.21)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/plugin-transform-react-jsx-self': 7.29.7(@babel/core@7.29.7)
+      '@babel/plugin-transform-react-jsx-source': 7.29.7(@babel/core@7.29.7)
+      '@rolldown/pluginutils': 1.0.0-beta.27
+      '@types/babel__core': 7.20.5
+      react-refresh: 0.17.0
+      vite: 5.4.21
+    transitivePeerDependencies:
+      - supports-color
+
+  baseline-browser-mapping@2.10.32: {}
+
+  browserslist@4.28.2:
+    dependencies:
+      baseline-browser-mapping: 2.10.32
+      caniuse-lite: 1.0.30001793
+      electron-to-chromium: 1.5.364
+      node-releases: 2.0.46
+      update-browserslist-db: 1.2.3(browserslist@4.28.2)
+
+  caniuse-lite@1.0.30001793: {}
+
+  convert-source-map@2.0.0: {}
+
+  csstype@3.2.3: {}
+
+  debug@4.4.3:
+    dependencies:
+      ms: 2.1.3
+
+  electron-to-chromium@1.5.364: {}
+
+  esbuild@0.21.5:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.21.5
+      '@esbuild/android-arm': 0.21.5
+      '@esbuild/android-arm64': 0.21.5
+      '@esbuild/android-x64': 0.21.5
+      '@esbuild/darwin-arm64': 0.21.5
+      '@esbuild/darwin-x64': 0.21.5
+      '@esbuild/freebsd-arm64': 0.21.5
+      '@esbuild/freebsd-x64': 0.21.5
+      '@esbuild/linux-arm': 0.21.5
+      '@esbuild/linux-arm64': 0.21.5
+      '@esbuild/linux-ia32': 0.21.5
+      '@esbuild/linux-loong64': 0.21.5
+      '@esbuild/linux-mips64el': 0.21.5
+      '@esbuild/linux-ppc64': 0.21.5
+      '@esbuild/linux-riscv64': 0.21.5
+      '@esbuild/linux-s390x': 0.21.5
+      '@esbuild/linux-x64': 0.21.5
+      '@esbuild/netbsd-x64': 0.21.5
+      '@esbuild/openbsd-x64': 0.21.5
+      '@esbuild/sunos-x64': 0.21.5
+      '@esbuild/win32-arm64': 0.21.5
+      '@esbuild/win32-ia32': 0.21.5
+      '@esbuild/win32-x64': 0.21.5
+
+  escalade@3.2.0: {}
+
+  framer-motion@11.18.2(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
+    dependencies:
+      motion-dom: 11.18.1
+      motion-utils: 11.18.1
+      tslib: 2.8.1
+    optionalDependencies:
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+
+  fsevents@2.3.3:
+    optional: true
+
+  gensync@1.0.0-beta.2: {}
+
+  js-tokens@4.0.0: {}
+
+  jsesc@3.1.0: {}
+
+  json5@2.2.3: {}
+
+  loose-envify@1.4.0:
+    dependencies:
+      js-tokens: 4.0.0
+
+  lru-cache@5.1.1:
+    dependencies:
+      yallist: 3.1.1
+
+  motion-dom@11.18.1:
+    dependencies:
+      motion-utils: 11.18.1
+
+  motion-utils@11.18.1: {}
+
+  ms@2.1.3: {}
+
+  nanoid@3.3.12: {}
+
+  node-releases@2.0.46: {}
+
+  picocolors@1.1.1: {}
+
+  postcss@8.5.15:
+    dependencies:
+      nanoid: 3.3.12
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  react-dom@18.3.1(react@18.3.1):
+    dependencies:
+      loose-envify: 1.4.0
+      react: 18.3.1
+      scheduler: 0.23.2
+
+  react-refresh@0.17.0: {}
+
+  react-router-dom@6.30.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
+    dependencies:
+      '@remix-run/router': 1.23.3
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+      react-router: 6.30.4(react@18.3.1)
+
+  react-router@6.30.4(react@18.3.1):
+    dependencies:
+      '@remix-run/router': 1.23.3
+      react: 18.3.1
+
+  react@18.3.1:
+    dependencies:
+      loose-envify: 1.4.0
+
+  rollup@4.60.4:
+    dependencies:
+      '@types/estree': 1.0.8
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.60.4
+      '@rollup/rollup-android-arm64': 4.60.4
+      '@rollup/rollup-darwin-arm64': 4.60.4
+      '@rollup/rollup-darwin-x64': 4.60.4
+      '@rollup/rollup-freebsd-arm64': 4.60.4
+      '@rollup/rollup-freebsd-x64': 4.60.4
+      '@rollup/rollup-linux-arm-gnueabihf': 4.60.4
+      '@rollup/rollup-linux-arm-musleabihf': 4.60.4
+      '@rollup/rollup-linux-arm64-gnu': 4.60.4
+      '@rollup/rollup-linux-arm64-musl': 4.60.4
+      '@rollup/rollup-linux-loong64-gnu': 4.60.4
+      '@rollup/rollup-linux-loong64-musl': 4.60.4
+      '@rollup/rollup-linux-ppc64-gnu': 4.60.4
+      '@rollup/rollup-linux-ppc64-musl': 4.60.4
+      '@rollup/rollup-linux-riscv64-gnu': 4.60.4
+      '@rollup/rollup-linux-riscv64-musl': 4.60.4
+      '@rollup/rollup-linux-s390x-gnu': 4.60.4
+      '@rollup/rollup-linux-x64-gnu': 4.60.4
+      '@rollup/rollup-linux-x64-musl': 4.60.4
+      '@rollup/rollup-openbsd-x64': 4.60.4
+      '@rollup/rollup-openharmony-arm64': 4.60.4
+      '@rollup/rollup-win32-arm64-msvc': 4.60.4
+      '@rollup/rollup-win32-ia32-msvc': 4.60.4
+      '@rollup/rollup-win32-x64-gnu': 4.60.4
+      '@rollup/rollup-win32-x64-msvc': 4.60.4
+      fsevents: 2.3.3
+
+  scheduler@0.23.2:
+    dependencies:
+      loose-envify: 1.4.0
+
+  semver@6.3.1: {}
+
+  source-map-js@1.2.1: {}
+
+  tslib@2.8.1: {}
+
+  typescript@5.9.3: {}
+
+  update-browserslist-db@1.2.3(browserslist@4.28.2):
+    dependencies:
+      browserslist: 4.28.2
+      escalade: 3.2.0
+      picocolors: 1.1.1
+
+  vite@5.4.21:
+    dependencies:
+      esbuild: 0.21.5
+      postcss: 8.5.15
+      rollup: 4.60.4
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  yallist@3.1.1: {}