Deploy AUGUR

.dockerignore

@@ -0,0 +1,31 @@
+# Data & datasets (huge, never needed in image)
+data/
+*.tif
+*.mp4
+
+# Training artifacts
+wandb/
+checkpoints/*.pt
+!checkpoints/model.onnx
+!checkpoints/model.onnx.data
+
+# Python
+venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+
+# Node (frontend build context if shared)
+node_modules/
+frontend/dist/
+
+# Git & IDE
+.git/
+.gitignore
+*.md
+.vscode/
+.idea/
+
+# Env
+.env
+*.db

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.onnx.data filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+node_modules/
+__pycache__/
+*.pyc
+venv/
+.env

Dockerfile

@@ -0,0 +1,45 @@
+# Combined single-image build for deployment (e.g. Hugging Face Spaces).
+# Backend serves BOTH the API and the built frontend (same origin, no CORS,
+# no nginx). One container, runnable with: docker run -p 7860:7860
+#
+# Build from repo root:
+#   docker build -f docker/Dockerfile.deploy -t augur-deploy .
+
+# ---- Stage 1: build the frontend ----
+FROM node:20-slim AS frontend
+
+WORKDIR /app
+COPY frontend/package.json frontend/package-lock.json* ./
+RUN npm install
+COPY frontend/ .
+# Same-origin: the frontend calls /predict directly (no /api proxy here).
+ENV VITE_API_URL=/predict
+RUN npm run build
+# Output: /app/dist
+
+# ---- Stage 2: backend + bundled frontend ----
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Python deps (CPU torch wheel, lean serving set)
+COPY requirements-inference.txt .
+RUN pip install --no-cache-dir \
+        --extra-index-url https://download.pytorch.org/whl/cpu \
+        -r requirements-inference.txt
+
+# Backend code + model (onnx + external data)
+COPY src/ ./src/
+COPY backend/ ./backend/
+COPY checkpoints/model.onnx* ./checkpoints/
+
+# Built frontend from stage 1 -> served by FastAPI StaticFiles at /
+COPY --from=frontend /app/dist ./static
+
+# HF Spaces expects the app on port 7860 by default
+EXPOSE 7860
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,12 @@
+---
+title: AUGUR Anomaly Detection
+emoji: 📈
+colorFrom: blue
+colorTo: red
+sdk: docker
+app_port: 7860
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

backend/main.py

@@ -0,0 +1,240 @@
+"""
+FastAPI backend for video anomaly detection (M4).
+
+Serves the M3 U-Net future-frame predictor (via ONNX) over HTTP.
+Minimal first slice: a single POST /predict endpoint that accepts a video
+upload and returns per-frame anomaly scores as JSON.
+
+Run:
+    uvicorn backend.main:app --reload --port 8000
+
+Then POST a video file to http://localhost:8000/predict (multipart form-data,
+field name "file").
+"""
+
+import os
+import tempfile
+from contextlib import asynccontextmanager
+import io
+import base64
+import numpy as np
+import matplotlib
+matplotlib.use("Agg")   # GUI yok, sadece render — server'da şart
+import matplotlib.cm as cm
+
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+from prometheus_fastapi_instrumentator import Instrumentator
+from prometheus_client import Histogram, Gauge
+
+from src.inference.stream import process_frames  # reused; see note on video below
+from src.inference.stream import process_video
+
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+ONNX_PATH = "checkpoints/model.onnx"
+
+# Anomaly threshold on the raw per-frame MSE score.
+#
+# DECISION POINT (yours): this should be calibrated from the NORMAL training
+# distribution, not guessed. The principled way:
+#   1. Run the stream over the normal training clips.
+#   2. Collect all per-frame scores (these are all "normal" by construction).
+#   3. Set THRESHOLD = mean + k * std  (k ~ 2-3), i.e. "how far above normal
+#      counts as anomalous".
+# The value below is a placeholder based on the M3 histogram (normal frames
+# clustered ~0.0002-0.0003, anomalies tailing to ~0.0011). Replace it with a
+# calibrated value and document the choice in milestones.md.
+THRESHOLD = 0.000291
+
+
+def make_overlay_png(frame_img: np.ndarray, heatmap: np.ndarray, alpha: float = 0.5) -> str:
+    """
+    Overlay the anomaly heatmap on the grayscale frame, return base64 PNG.
+
+    frame_img: (128,128) preprocessed frame in [-1,1]
+    heatmap:   (128,128) prediction error (>=0), arbitrary scale
+    Returns: base64-encoded PNG string (no data: prefix)
+    """
+    from PIL import Image
+
+    # 1. Frame [-1,1] -> [0,1] grayscale, then to RGB
+    frame01 = (frame_img + 1.0) / 2.0
+    frame01 = np.clip(frame01, 0, 1)
+    base_rgb = np.stack([frame01] * 3, axis=-1)   # (128,128,3)
+
+    # 2. Heatmap -> [0,1] normalized, apply colormap (inferno: dark->bright)
+    hm = heatmap - heatmap.min()
+    hm = hm / (hm.max() + 1e-12)                  # [0,1]
+    heat_rgb = cm.inferno(hm)[..., :3]            # (128,128,3), drop alpha
+
+    # 3. Blend: base frame + heatmap overlay
+    blended = (1 - alpha) * base_rgb + alpha * heat_rgb
+    blended = (np.clip(blended, 0, 1) * 255).astype(np.uint8)
+
+    # 4. To PNG -> base64
+    img = Image.fromarray(blended)
+    buf = io.BytesIO()
+    img.save(buf, format="PNG")
+    return base64.b64encode(buf.getvalue()).decode("utf-8")
+
+
+# ---------------------------------------------------------------------------
+# App lifespan: load the model once at startup, not per request
+# ---------------------------------------------------------------------------
+
+# We store shared state on app.state so every request reuses it.
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup: verify the model file exists. (The ONNX session itself is created
+    # inside the stream pipeline per call; see the note in /predict below.)
+    if not os.path.exists(ONNX_PATH):
+        raise RuntimeError(f"ONNX model not found at {ONNX_PATH}. Run the export first.")
+    app.state.onnx_path = ONNX_PATH
+    app.state.threshold = THRESHOLD
+    yield
+    # Shutdown: nothing to clean up.
+
+
+app = FastAPI(title="Video Anomaly Detection", lifespan=lifespan)
+
+# Cors middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173"],
+    allow_methods=["*"], allow_headers=["*"],
+)
+
+# Anomaly ratio per processed video (flagged frames / scored frames)
+ANOMALY_RATIO = Gauge(
+    "augur_anomaly_ratio",
+    "Fraction of scored frames flagged as anomalous in the last request",
+)
+
+# Mean anomaly score per processed video — watch for drift vs the calibrated
+# normal mean (~0.000153). A rising mean suggests the input distribution shifted.
+MEAN_SCORE = Gauge(
+    "augur_mean_score",
+    "Mean per-frame anomaly score (raw MSE) of the last processed video",
+)
+
+# Distribution of per-frame scores — a histogram to see the spread, not just mean
+SCORE_HIST = Histogram(
+    "augur_frame_score",
+    "Per-frame anomaly score (raw MSE) distribution",
+    buckets=[1e-4, 1.5e-4, 2e-4, 2.5e-4, 3e-4, 4e-4, 5e-4, 7e-4, 1e-3],
+)
+
+Instrumentator().instrument(app).expose(app)
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
+
+@app.get("/health")
+def health():
+    """Simple liveness check."""
+    return {"status": "ok", "model": app.state.onnx_path, "threshold": app.state.threshold}
+
+
+@app.post("/predict")
+async def predict(file: UploadFile = File(...)):
+    """
+    Accept a video upload, run the streaming anomaly detector over it, and
+    return per-frame anomaly scores.
+
+    Response JSON:
+        {
+          "total_frames": int,
+          "scored_frames": int,
+          "warmup_frames": int,        # first 15 frames have no score (cold start)
+          "threshold": float,
+          "frames": [
+             {"frame_idx": int, "score": float|null, "is_anomaly": bool|null}
+          ],
+          "top_anomalies": [{"frame_idx": int, "score": float, "overlay": "<base64 png>"}]
+        }
+    A null score / null is_anomaly marks a warm-up frame (model needs 15 past
+    frames before it can predict; those frames cannot be scored).
+    """
+    # Basic content-type guard (not bulletproof, just a friendly check).
+    if file.content_type is None or not file.content_type.startswith("video"):
+        raise HTTPException(status_code=400, detail="Please upload a video file.")
+
+    # cv2.VideoCapture needs a file path, so we write the upload to a temp file.
+    # Preserve the original suffix so the decoder picks the right backend.
+    suffix = os.path.splitext(file.filename or "")[1] or ".mp4"
+    tmp_path = None
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+            tmp.write(await file.read())
+            tmp_path = tmp.name
+
+        # Run the streaming pipeline (this is the code you wrote in stream.py).
+        # NOTE: process_video currently builds its own AnomalyStream (and thus
+        # its own ONNX session) per call. That is fine for a demo. To optimize
+        # later, refactor AnomalyStream to accept a pre-loaded session and share
+        # it across requests.
+        raw_scores, top_anomalies, fps = process_video(tmp_path, app.state.onnx_path)
+        fps = fps if fps and fps > 0 else 10.0   # fallback to 10 (UCSD default)
+
+        # Convert top anomalies to an overlay PNG
+        top = [
+            {
+                "frame_idx": a["frame_idx"],
+                "score": a["score"],
+                "overlay": make_overlay_png(a["frame"], a["heatmap"]),
+            }
+            for a in top_anomalies
+        ]
+
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Inference failed: {exc}")
+    finally:
+        # Always clean up the temp file.
+        if tmp_path and os.path.exists(tmp_path):
+            os.remove(tmp_path)
+
+    # Build the per-frame response. raw_scores contains None for warm-up frames.
+    threshold = app.state.threshold
+    frames = []
+    scored = 0
+    for idx, score in enumerate(raw_scores):
+        if score is None:
+            frames.append({"frame_idx": idx, "score": None, "is_anomaly": None})
+        else:
+            scored += 1
+            frames.append({
+                "frame_idx": idx,
+                "score": float(score),
+                "is_anomaly": bool(score > threshold),
+            })
+
+    # Filter out the valid scores
+    valid_scores = [f["score"] for f in frames if f["score"] is not None]
+    if valid_scores:
+        flagged = sum(1 for f in frames if f["is_anomaly"])
+        ANOMALY_RATIO.set(flagged / len(valid_scores))
+        MEAN_SCORE.set(sum(valid_scores) / len(valid_scores))
+        for s in valid_scores:
+            SCORE_HIST.observe(s)
+
+    return {
+        "total_frames": len(raw_scores),
+        "scored_frames": scored,
+        "warmup_frames": len(raw_scores) - scored,
+        "threshold": threshold,
+        "fps": fps,
+        "frames": frames,
+        "top_anomalies": top
+    }
+
+# Serve the built frontend. MUST come AFTER all API routes, otherwise the
+# catch-all static mount would swallow /predict, /health, /metrics.
+app.mount("/", StaticFiles(directory="static", html=True), name="static")

checkpoints/model.onnx

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

checkpoints/model.onnx.data

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

frontend/index.html

@@ -0,0 +1,18 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>AUGUR — Predictive Anomaly Detection</title>
+    <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=Space+Grotesk:wght@400;500;700&family=JetBrains+Mono:wght@400;500;700&display=swap"
+      rel="stylesheet"
+    />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package-lock.json

@@ -0,0 +1,2059 @@
+{
+  "name": "augur-frontend",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "augur-frontend",
+      "version": "0.1.0",
+      "dependencies": {
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1",
+        "recharts": "^2.12.7"
+      },
+      "devDependencies": {
+        "@vitejs/plugin-react": "^4.3.1",
+        "vite": "^5.4.0"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
+      "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz",
+      "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz",
+      "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==",
+      "dev": true,
+      "license": "MIT",
+      "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/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.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.7.tgz",
+      "integrity": "sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz",
+      "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",
+      "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",
+      "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz",
+      "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz",
+      "integrity": "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz",
+      "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz",
+      "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz",
+      "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.29.7.tgz",
+      "integrity": "sha512-TL0hMc9xzy86VD31nUiwzd5otRAcyEPcsegCxolO0PvcXuH1v0kECe/UIznYFihpkvU5wg/jk4v0TTEFfm53fw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.29.7.tgz",
+      "integrity": "sha512-06IyK09H3wi4cGbhDBwp5gUGo0IKtnYa8tyTiephirPCK6fbobVGiXMMI5zLQ4aKEYP3wZ3ArU44o+8KMrSG/Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/runtime": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
+      "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
+      "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.7.tgz",
+      "integrity": "sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==",
+      "dev": true,
+      "license": "MIT",
+      "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.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz",
+      "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.27",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",
+      "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.0.tgz",
+      "integrity": "sha512-IPIQ55ythEHkfEd9jMEi32OQ7SxURsGA43JI22lj01OLZNt2NUbJX8YUHxkVWyQ6daHPNn0truF5nSj3DQp6YQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.62.0.tgz",
+      "integrity": "sha512-M6s9cr10MibETyo8JsOkq+Lo1+lU6hcvb1MApnUql5qte/5hMEgzlN8/ReIKNfRV8rrqX50W1BX9zoUhC192RA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.62.0.tgz",
+      "integrity": "sha512-BqCoMoIbn0keKys+dEAdBa70EtOwV1bEsQCUgU9FdiZmmMge/Zk7LlkYGqbrdHR+Frnt0E1FOanly+rlwvvQzw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.62.0.tgz",
+      "integrity": "sha512-SIMzST3VFNXDAbeIWDWiFCNM5qncUBDWaEV7NfE7oZbDt2mgfW4MvbKdbYiGOLoM32gbTv608UMd0XktEYSD7w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.62.0.tgz",
+      "integrity": "sha512-ezjfSQMP7ArdUsbBwbQIfwAlhE84I2iVnzQNCFSveqV42q+BmKlzVpf7mxv5EchLcoWU4y6/heFzVg1F+hodUQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.62.0.tgz",
+      "integrity": "sha512-9+qTWGW9AZRhnUgwtTwzNwcPlL87ngkeN0LA+q1bADvmY9aNvWaF2TFW8BZgnQPYxpDI7+rMVLivcd4V737TAQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.62.0.tgz",
+      "integrity": "sha512-T1dMEQhXA/jkJ/jyMIw9IovK8bSUq7A8kLIlvZTb/6YIVsp2zLavr4F3oyllHWo7eIVJRyE5n3tUjQJEbE1IuQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.62.0.tgz",
+      "integrity": "sha512-2as0LgT7qQpyceQq6VUJYnumUMUrgGQCWIiDIN9DE0/tglsk6o66uCB4f3djRawAltvfCNLyZZrsqbPA6inCsA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.62.0.tgz",
+      "integrity": "sha512-bVURMg+6eNN9C/yc0aVjooZcwTTtYF4YW3xta5pP0//r3o1V8gXEHXWCndj47w/HhwsFroZrFhR+6uQP5T0n0g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.62.0.tgz",
+      "integrity": "sha512-Ful8pM/2yYI83PViWdFdpZhdI8HJ5qsXANe5atypbHDf+KIBBDsZsbyy8hbXnULVvW9NsTh5DHwbcBftyLTfiw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.62.0.tgz",
+      "integrity": "sha512-9Gp/DgrkzfUBmNPVTyPTvay+4xEP7M/clXpj3efXBcm6uTIVIgDg4rqUpqKXvLEuFRVuEpSAOkhgNeecvaZ4Cg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.62.0.tgz",
+      "integrity": "sha512-m9tsJz54LUXkSYM8+8PG81B9IKK5r+2T0clMq4QrS16xFosufU7firBDAZEsDheDs7wTlP7h3++S7lMsU955HA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.62.0.tgz",
+      "integrity": "sha512-3UvJ5PNVU16aJf6M3tFI24pWzAl2/ynfbyRN3ICyQajK1lSkrnVYNnLz3v04J32qKa0FczJc22zeToc0lr2A3w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.62.0.tgz",
+      "integrity": "sha512-vRWUAbYLGHBZS6Q8Msb2sfnf1fvJf+47t8l/TwOerM2qArzy+IeNMTHrYLHXh95h8MoatPHI5hhSZNs+mGXKPg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.62.0.tgz",
+      "integrity": "sha512-c00T5SYENHAt86cfW47URaP3Us5vLC/4QO7GYud1G5VNRffCwwCuBspwqYrriuJB+5m0WFzClCn9wed0FBjKvg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.62.0.tgz",
+      "integrity": "sha512-krrCDilhXOwFkSkO3Wm9I/f9H0L92XHHwy2fwxjukxIbh0dem8gZqOW5Y8BsHrpJv5qwlRBV+Wl4ZFyRWhUpwg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.62.0.tgz",
+      "integrity": "sha512-7pfYFSTc4/rUC/FtAI0Qp6QthDBCIi6/AuP1xYqFk5vanI6KnL5dWKP60OM/05LOsbwTmIcvr6eXC4CJuJ75IA==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.0.tgz",
+      "integrity": "sha512-7SDIalKeIpG0Ifogbbdn58HmSotYMlf23K3dCJEmiVd9Fg36Vmni82iPQec27N3wY4Bvbxftkxz6vSx9OcouTg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.0.tgz",
+      "integrity": "sha512-eRZevouTH2i1HeAVLqJuLnt256krQkGY0TN6WsTmsIhuzbh457HuWDMakKwmi0Cjadux983CoSr8Lim2QhUIFw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.62.0.tgz",
+      "integrity": "sha512-3oVS7FLGa4U1qcvao9ylGxrjXZyUQqR8UwxEcnUEyPX53O/C/mKDZegNXTdHCP+h3e6ta/f1EN38Yif1mmZHYg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.62.0.tgz",
+      "integrity": "sha512-yTB9TgfWj5wHe5QgktAgXTLLot1gvEjl1NiPPAUiCs4oPrIWFl5V4nC3GrkNdj9LaAU4s94nVrGbGOCqUpyWsg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.62.0.tgz",
+      "integrity": "sha512-5LOhoaesY3doG1c+ac/2JtgREpKoJr5bUHH8tKY0V8di7+uSV6BwLs2PlR0/yzefGOkR+wE7ZolZphHCsyG5Rw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.62.0.tgz",
+      "integrity": "sha512-yYkWHhmbhRTWTnWos5HC4GcPQfjlzzCNbM9e/+GXrLuaBXYA3qSDR9f0Vgufd5S8yX81U8jPKp7ZnAjZFMtRnw==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.62.0.tgz",
+      "integrity": "sha512-SoTb6lPg25xZlA2ibwQ++ahCCnH+FP0qmEuafMJ4gznZKOlXioKEAeJLgCrqjM98ACziXM9V1amFjICVL4IFoA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.62.0.tgz",
+      "integrity": "sha512-5L+T1fMX4RIEBoZzT0+sQ0PhTS36NULFmMXtl1TZo44TMAROIMHbZufSOjVWt/Y622BtxgxtaNOokbTDvfsrZA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/d3-array": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz",
+      "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-color": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz",
+      "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-ease": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-3.0.2.tgz",
+      "integrity": "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-interpolate": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz",
+      "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-color": "*"
+      }
+    },
+    "node_modules/@types/d3-path": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-3.1.1.tgz",
+      "integrity": "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-scale": {
+      "version": "4.0.9",
+      "resolved": "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-4.0.9.tgz",
+      "integrity": "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-time": "*"
+      }
+    },
+    "node_modules/@types/d3-shape": {
+      "version": "3.1.8",
+      "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.8.tgz",
+      "integrity": "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-path": "*"
+      }
+    },
+    "node_modules/@types/d3-time": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/d3-time/-/d3-time-3.0.4.tgz",
+      "integrity": "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-timer": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-3.0.2.tgz",
+      "integrity": "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==",
+      "license": "MIT"
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
+      "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.28.0",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.27",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.17.0"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.37",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.37.tgz",
+      "integrity": "sha512-girxaJ7WZssDOFhzCGZTDKoTa1gk6A1TbflaYTpykLJ4UU9Fz9kx1aREM8JCuoVHbL8X8T/mJg7w2oYSq72Oig==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001799",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001799.tgz",
+      "integrity": "sha512-hG1bReV+OUU+MOqK4t/ZWI0tZOyz3rqS9XuhOUz1cIcbwBKjOyJEJuw9ER5JuNyqxNk8u/JUVbGibBOL1yrjFw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/clsx": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "license": "MIT"
+    },
+    "node_modules/d3-array": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz",
+      "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==",
+      "license": "ISC",
+      "dependencies": {
+        "internmap": "1 - 2"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-color": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz",
+      "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-ease": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz",
+      "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-format": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz",
+      "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-interpolate": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz",
+      "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-color": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-path": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz",
+      "integrity": "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-scale": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz",
+      "integrity": "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-array": "2.10.0 - 3",
+        "d3-format": "1 - 3",
+        "d3-interpolate": "1.2.0 - 3",
+        "d3-time": "2.1.1 - 3",
+        "d3-time-format": "2 - 4"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-shape": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz",
+      "integrity": "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-path": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-time": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz",
+      "integrity": "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-array": "2 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-time-format": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz",
+      "integrity": "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-time": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-timer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz",
+      "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decimal.js-light": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/decimal.js-light/-/decimal.js-light-2.5.1.tgz",
+      "integrity": "sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==",
+      "license": "MIT"
+    },
+    "node_modules/dom-helpers": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/dom-helpers/-/dom-helpers-5.2.1.tgz",
+      "integrity": "sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.8.7",
+        "csstype": "^3.0.2"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.372",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.372.tgz",
+      "integrity": "sha512-M3yhbAlilnwqC8D21t28UCDGHyitShTmmLRU/H+b74P6Ski16Nb9HONYEaVpMj/pwC7BEo5B95FpjODLCWbtfA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "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"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/eventemitter3": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz",
+      "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==",
+      "license": "MIT"
+    },
+    "node_modules/fast-equals": {
+      "version": "5.4.0",
+      "resolved": "https://registry.npmjs.org/fast-equals/-/fast-equals-5.4.0.tgz",
+      "integrity": "sha512-jt2DW/aNFNwke7AUd+Z+e6pz39KO5rzdbbFCg2sGafS4mk13MI7Z8O5z9cADNn5lhGODIgLwug6TZO2ctf7kcw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/internmap": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz",
+      "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/lodash": {
+      "version": "4.18.1",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+      "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
+      "license": "MIT"
+    },
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.12",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
+      "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.47",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.47.tgz",
+      "integrity": "sha512-Uzmd6LXpouKo8EUK68IjH4+E01w/hXyV3R3g/geCJo+rXLNfh1xucB+LOzYEOQPSiUK3h/xZf0cQGcSsmyL2Og==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/postcss": {
+      "version": "8.5.15",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz",
+      "integrity": "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.12",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/prop-types": {
+      "version": "15.8.1",
+      "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
+      "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.4.0",
+        "object-assign": "^4.1.1",
+        "react-is": "^16.13.1"
+      }
+    },
+    "node_modules/prop-types/node_modules/react-is": {
+      "version": "16.13.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
+      "license": "MIT"
+    },
+    "node_modules/react": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0",
+        "scheduler": "^0.23.2"
+      },
+      "peerDependencies": {
+        "react": "^18.3.1"
+      }
+    },
+    "node_modules/react-is": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
+      "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
+      "license": "MIT"
+    },
+    "node_modules/react-refresh": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-smooth": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/react-smooth/-/react-smooth-4.0.4.tgz",
+      "integrity": "sha512-gnGKTpYwqL0Iii09gHobNolvX4Kiq4PKx6eWBCYYix+8cdw+cGo3do906l1NBPKkSWx1DghC1dlWG9L2uGd61Q==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-equals": "^5.0.1",
+        "prop-types": "^15.8.1",
+        "react-transition-group": "^4.4.5"
+      },
+      "peerDependencies": {
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/react-transition-group": {
+      "version": "4.4.5",
+      "resolved": "https://registry.npmjs.org/react-transition-group/-/react-transition-group-4.4.5.tgz",
+      "integrity": "sha512-pZcd1MCJoiKiBR2NRxeCRg13uCXbydPnmB4EOeRrY7480qNWO8IIgQG6zlDkm6uRMsURXPuKq0GWtiM59a5Q6g==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@babel/runtime": "^7.5.5",
+        "dom-helpers": "^5.0.1",
+        "loose-envify": "^1.4.0",
+        "prop-types": "^15.6.2"
+      },
+      "peerDependencies": {
+        "react": ">=16.6.0",
+        "react-dom": ">=16.6.0"
+      }
+    },
+    "node_modules/recharts": {
+      "version": "2.15.4",
+      "resolved": "https://registry.npmjs.org/recharts/-/recharts-2.15.4.tgz",
+      "integrity": "sha512-UT/q6fwS3c1dHbXv2uFgYJ9BMFHu3fwnd7AYZaEQhXuYQ4hgsxLvsUXzGdKeZrW5xopzDCvuA2N41WJ88I7zIw==",
+      "deprecated": "1.x and 2.x branches are no longer active. Bump to Recharts v3 to receive latest features and bugfixes. See https://github.com/recharts/recharts/wiki/3.0-migration-guide",
+      "license": "MIT",
+      "dependencies": {
+        "clsx": "^2.0.0",
+        "eventemitter3": "^4.0.1",
+        "lodash": "^4.17.21",
+        "react-is": "^18.3.1",
+        "react-smooth": "^4.0.4",
+        "recharts-scale": "^0.4.4",
+        "tiny-invariant": "^1.3.1",
+        "victory-vendor": "^36.6.8"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "peerDependencies": {
+        "react": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/recharts-scale": {
+      "version": "0.4.5",
+      "resolved": "https://registry.npmjs.org/recharts-scale/-/recharts-scale-0.4.5.tgz",
+      "integrity": "sha512-kivNFO+0OcUNu7jQquLXAxz1FIwZj8nrj+YkOKc5694NbjCvcT6aSZiIzNzd2Kul4o4rTto8QVR9lMNtxD4G1w==",
+      "license": "MIT",
+      "dependencies": {
+        "decimal.js-light": "^2.4.1"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.0.tgz",
+      "integrity": "sha512-nc72Wgq62I7rtDV4izT5/aaS0zxy3kttkinf9586ApknY3jZO9NYsmtc24fUckA0X7Q2v+ML4a15pdUlV5V/jA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.9"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.62.0",
+        "@rollup/rollup-android-arm64": "4.62.0",
+        "@rollup/rollup-darwin-arm64": "4.62.0",
+        "@rollup/rollup-darwin-x64": "4.62.0",
+        "@rollup/rollup-freebsd-arm64": "4.62.0",
+        "@rollup/rollup-freebsd-x64": "4.62.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.62.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.62.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.62.0",
+        "@rollup/rollup-linux-arm64-musl": "4.62.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.62.0",
+        "@rollup/rollup-linux-loong64-musl": "4.62.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.62.0",
+        "@rollup/rollup-linux-ppc64-musl": "4.62.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.62.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.62.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.62.0",
+        "@rollup/rollup-linux-x64-gnu": "4.62.0",
+        "@rollup/rollup-linux-x64-musl": "4.62.0",
+        "@rollup/rollup-openbsd-x64": "4.62.0",
+        "@rollup/rollup-openharmony-arm64": "4.62.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.62.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.62.0",
+        "@rollup/rollup-win32-x64-gnu": "4.62.0",
+        "@rollup/rollup-win32-x64-msvc": "4.62.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      }
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/tiny-invariant": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz",
+      "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==",
+      "license": "MIT"
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/victory-vendor": {
+      "version": "36.9.2",
+      "resolved": "https://registry.npmjs.org/victory-vendor/-/victory-vendor-36.9.2.tgz",
+      "integrity": "sha512-PnpQQMuxlwYdocC8fIJqVXvkeViHYzotI+NJrCuav0ZYFoq912ZHBk3mCeuj+5/VpodOjPe1z0Fk2ihgzlXqjQ==",
+      "license": "MIT AND ISC",
+      "dependencies": {
+        "@types/d3-array": "^3.0.3",
+        "@types/d3-ease": "^3.0.0",
+        "@types/d3-interpolate": "^3.0.1",
+        "@types/d3-scale": "^4.0.2",
+        "@types/d3-shape": "^3.1.0",
+        "@types/d3-time": "^3.0.0",
+        "@types/d3-timer": "^3.0.0",
+        "d3-array": "^3.1.6",
+        "d3-ease": "^3.0.1",
+        "d3-interpolate": "^3.0.1",
+        "d3-scale": "^4.0.2",
+        "d3-shape": "^3.1.0",
+        "d3-time": "^3.0.0",
+        "d3-timer": "^3.0.1"
+      }
+    },
+    "node_modules/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "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
+        }
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    }
+  }
+}

frontend/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "augur-frontend",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "recharts": "^2.12.7"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.3.1",
+    "vite": "^5.4.0"
+  }
+}

frontend/src/App.jsx

@@ -0,0 +1,328 @@
+import { useState, useRef, useMemo, useEffect } from "react";
+import {
+  ResponsiveContainer,
+  AreaChart,
+  Area,
+  XAxis,
+  YAxis,
+  CartesianGrid,
+  ReferenceLine,
+  ReferenceArea,
+  Tooltip,
+} from "recharts";
+
+const API_URL = import.meta.env.VITE_API_URL || "/api/predict";
+
+/* Extract contiguous anomaly regions [start, end] from the frame list.
+   These become the glowing alarm bands behind the trace. */
+function anomalyBands(frames) {
+  const bands = [];
+  let start = null;
+  for (const f of frames) {
+    if (f.is_anomaly) {
+      if (start === null) start = f.frame_idx;
+    } else if (start !== null) {
+      bands.push([start, f.frame_idx - 1]);
+      start = null;
+    }
+  }
+  if (start !== null) bands.push([start, frames[frames.length - 1].frame_idx]);
+  return bands;
+}
+
+/* Tooltip shows the threshold-relative value (intuitive) AND the raw MSE
+   score (technical transparency). */
+function makeTip(threshold) {
+  return function TipBox({ active, payload }) {
+    if (!active || !payload || !payload.length) return null;
+    const p = payload[0].payload;
+    if (p.rawScore === null || p.rawScore === undefined) return null;
+    const rel = p.rawScore / threshold;
+    return (
+      <div className="tip">
+        <div className="row"><span className="lab">FRAME</span><span className="val">{p.frame}</span></div>
+        <div className="row">
+          <span className="lab">SURPRISE</span>
+          <span className={"val" + (p.is_anomaly ? " alarm" : "")}>{rel.toFixed(2)}×</span>
+        </div>
+        <div className="row">
+          <span className="lab">RAW</span>
+          <span className="val">{p.rawScore.toExponential(2)}</span>
+        </div>
+      </div>
+    );
+  };
+}
+
+export default function App() {
+  const [file, setFile] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [result, setResult] = useState(null);
+  const [error, setError] = useState(null);
+  const [drag, setDrag] = useState(false);
+  const [currentFrame, setCurrentFrame] = useState(0);
+  const inputRef = useRef(null);
+  const videoRef = useRef(null);
+
+  // Playable URL for the uploaded file (revoke on change to avoid leaks)
+  const videoUrl = useMemo(() => (file ? URL.createObjectURL(file) : null), [file]);
+  useEffect(() => {
+    return () => { if (videoUrl) URL.revokeObjectURL(videoUrl); };
+  }, [videoUrl]);
+
+  const status = loading ? "reading" : result ? "flagged" : "standby";
+  const statusLabel = loading ? "READING FEED" : result ? "ANALYSIS COMPLETE" : "FEED STANDBY";
+
+  function pick(f) {
+    if (!f) return;
+    setFile(f);
+    setResult(null);
+    setError(null);
+    setCurrentFrame(0);
+  }
+
+  async function analyze() {
+    if (!file) return;
+    setLoading(true);
+    setError(null);
+    setResult(null);
+    setCurrentFrame(0);
+    try {
+      const body = new FormData();
+      body.append("file", file);
+      const res = await fetch(API_URL, { method: "POST", body });
+      if (!res.ok) {
+        const detail = await res.json().catch(() => ({}));
+        throw new Error(detail.detail || `Server returned ${res.status}`);
+      }
+      setResult(await res.json());
+    } catch (e) {
+      setError(
+        e.message?.includes("fetch")
+          ? "Cannot reach the detector. Start the backend, then run again."
+          : e.message
+      );
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  const fps = result?.fps || 10;
+  const threshold = result?.threshold || 1;
+
+  // Trace data: store BOTH the threshold-relative value (for the axis) and the
+  // raw score (for the tooltip). Tripwire sits at 1.0x.
+  const chartData = useMemo(
+    () =>
+      result?.frames.map((f) => ({
+        frame: f.frame_idx,
+        rel: f.score === null ? null : f.score / threshold,
+        rawScore: f.score,
+        is_anomaly: f.is_anomaly,
+      })) ?? [],
+    [result, threshold]
+  );
+
+  // Progressive reveal: hide values beyond the playhead so the trace draws in sync
+  const revealedData = useMemo(
+    () => chartData.map((d) => ({ ...d, rel: d.frame <= currentFrame ? d.rel : null })),
+    [chartData, currentFrame]
+  );
+
+  const bands = useMemo(() => (result ? anomalyBands(result.frames) : []), [result]);
+  const peakRel = useMemo(() => {
+    const s = result?.frames.map((f) => f.score).filter((v) => v !== null) ?? [];
+    return s.length ? Math.max(...s) / threshold : 0;
+  }, [result, threshold]);
+
+  const liveFrame = result?.frames[currentFrame];
+  const liveRel = liveFrame && liveFrame.score !== null ? liveFrame.score / threshold : null;
+
+  const TipBox = useMemo(() => makeTip(threshold), [threshold]);
+
+  return (
+    <div className="shell">
+      <header className="masthead">
+        <div>
+          <div className="wordmark">AUGUR</div>
+          <div className="tagline">Every frame, predicted. Every surprise, flagged.</div>
+        </div>
+        <div className="status" data-state={status}>
+          <span className="dot" />
+          {statusLabel}
+        </div>
+      </header>
+
+      <section className="intake">
+        <div
+          className="dropzone"
+          data-drag={drag}
+          onClick={() => inputRef.current?.click()}
+          onDragOver={(e) => { e.preventDefault(); setDrag(true); }}
+          onDragLeave={() => setDrag(false)}
+          onDrop={(e) => { e.preventDefault(); setDrag(false); pick(e.dataTransfer.files?.[0]); }}
+        >
+          <div className="eyebrow">VIDEO FEED INPUT</div>
+          <div className="prompt">Drop a video, or click to select</div>
+          <div className="sub">The detector learns normal motion, then flags what it cannot predict.</div>
+          {file && <div className="filename">{file.name}</div>}
+          <input
+            ref={inputRef}
+            type="file"
+            accept="video/*"
+            className="hidden-input"
+            onChange={(e) => pick(e.target.files?.[0])}
+          />
+        </div>
+
+        <button className="run" onClick={analyze} disabled={!file || loading}>
+          {loading ? "ANALYZING…" : "RUN DETECTION"}
+        </button>
+
+        {error && <div className="error">{error}</div>}
+      </section>
+
+      {result && (
+        <section className="stats">
+          <div className="stat">
+            <div className="k">FRAMES</div>
+            <div className="v">{result.total_frames}</div>
+          </div>
+          <div className="stat">
+            <div className="k">FLAGGED</div>
+            <div className="v alarm">{result.frames.filter((f) => f.is_anomaly).length}</div>
+          </div>
+          <div className="stat">
+            <div className="k">PEAK SURPRISE</div>
+            <div className="v">{peakRel.toFixed(2)}×</div>
+          </div>
+          <div className="stat">
+            <div className="k">ALARM LINE</div>
+            <div className="v amber">1.00×</div>
+          </div>
+        </section>
+      )}
+
+      {/* Synced playback: video + live readout */}
+      {result && videoUrl && (
+        <section className="playback">
+          <video
+            ref={videoRef}
+            src={videoUrl}
+            controls
+            className="feed-video"
+            onTimeUpdate={(e) => setCurrentFrame(Math.floor(e.target.currentTime * fps))}
+          />
+          <div className="live-readout">
+            <span className="lr-frame">FRAME {currentFrame}</span>
+            {!liveFrame || liveFrame.score === null ? (
+              <span className="lr-warm">WARMING UP</span>
+            ) : (
+              <span className={"lr-score" + (liveFrame.is_anomaly ? " alarm" : "")}>
+                {liveRel.toFixed(2)}× {liveFrame.is_anomaly ? "· ANOMALY" : "· normal"}
+              </span>
+            )}
+          </div>
+        </section>
+      )}
+
+      <section className="trace">
+        <div className="trace-head">
+          <div className="trace-title">THE SURPRISE TRACE</div>
+          <div className="trace-legend">
+            <span className="item"><span className="swatch calm" />signal</span>
+            <span className="item"><span className="swatch amber" />tripwire</span>
+            <span className="item"><span className="swatch alarm" />anomaly</span>
+          </div>
+        </div>
+        <div className="trace-note">
+          Surprise shown relative to the detection threshold — 1.0× is the alarm line.
+        </div>
+
+        {result ? (
+          <ResponsiveContainer width="100%" height={300}>
+            <AreaChart data={revealedData} margin={{ top: 8, right: 12, bottom: 4, left: 0 }}>
+              <defs>
+                <linearGradient id="calmFill" x1="0" y1="0" x2="0" y2="1">
+                  <stop offset="0%" stopColor="#56C7BE" stopOpacity={0.28} />
+                  <stop offset="100%" stopColor="#56C7BE" stopOpacity={0} />
+                </linearGradient>
+              </defs>
+
+              <CartesianGrid strokeDasharray="2 4" vertical={false} />
+
+              {/* glowing alarm bands behind the trace (full range, not revealed) */}
+              {bands.map(([a, b], i) => (
+                <ReferenceArea key={i} x1={a} x2={b} fill="#FF6A5A" fillOpacity={0.10} stroke="none" />
+              ))}
+
+              <XAxis dataKey="frame" type="number" domain={[0, result.total_frames]}
+                     tickLine={false} interval="preserveStartEnd" minTickGap={40} allowDataOverflow />
+              <YAxis tickFormatter={(v) => `${v.toFixed(1)}×`} width={48} tickLine={false} />
+
+              {/* the amber tripwire — now fixed at 1.0x */}
+              <ReferenceLine
+                y={1.0}
+                stroke="#E6A93C"
+                strokeDasharray="5 4"
+                strokeWidth={1.2}
+                label={{ value: "TRIPWIRE", position: "insideTopRight", fill: "#E6A93C", fontSize: 10, fontFamily: "JetBrains Mono" }}
+              />
+
+              {/* the playhead — follows the video */}
+              <ReferenceLine x={currentFrame} stroke="#56C7BE" strokeWidth={1.5} strokeOpacity={0.9} />
+
+              <Tooltip content={<TipBox />} cursor={{ stroke: "#66768A", strokeDasharray: "3 3" }} />
+
+              {/* connectNulls=false leaves a gap over warm-up AND beyond the playhead */}
+              <Area
+                type="monotone"
+                dataKey="rel"
+                stroke="#56C7BE"
+                strokeWidth={1.6}
+                fill="url(#calmFill)"
+                connectNulls={false}
+                isAnimationActive={false}
+                dot={false}
+                activeDot={{ r: 3, fill: "#56C7BE", stroke: "none" }}
+              />
+            </AreaChart>
+          </ResponsiveContainer>
+        ) : (
+          <div className="idle">
+            <div className="label">{loading ? "READING FEED…" : "AWAITING FEED"}</div>
+            <div className="scan" />
+            <div className="label" style={{ color: "var(--dim-2)", fontSize: 11 }}>
+              SURPRISE / FRAME
+            </div>
+          </div>
+        )}
+      </section>
+
+      {/* Most anomalous moments — heatmap overlays */}
+      {result && result.top_anomalies?.length > 0 && (
+        <section className="moments">
+          <div className="moments-head">
+            <div className="moments-title">MOST ANOMALOUS MOMENTS</div>
+            <div className="moments-sub">Where the model was most surprised — heatmap over frame</div>
+          </div>
+          <div className="moments-grid">
+            {result.top_anomalies.map((a) => (
+              <figure className="moment" key={a.frame_idx}>
+                <img
+                  className="moment-img"
+                  src={`data:image/png;base64,${a.overlay}`}
+                  alt={`Frame ${a.frame_idx}`}
+                />
+                <figcaption className="moment-cap">
+                  <span className="moment-frame">FRAME {a.frame_idx}</span>
+                  <span className="moment-score">{(a.score / threshold).toFixed(2)}×</span>
+                </figcaption>
+              </figure>
+            ))}
+          </div>
+        </section>
+      )}
+    </div>
+  );
+}

frontend/src/index.css

@@ -0,0 +1,410 @@
+/* ============================================================
+   AUGUR — design system
+   A surveillance-instrument console for predictive anomaly
+   detection. The signal trace is the hero; everything else
+   stays quiet. Color encodes meaning: teal = calm/normal,
+   coral = alarm/anomaly, amber = the threshold tripwire.
+   ============================================================ */
+
+:root {
+  --void: #0A0E13;       /* cold monitor black */
+  --panel: #121922;      /* raised surface */
+  --panel-2: #0E141B;    /* recessed surface */
+  --line: #1F2A35;       /* hairline grid / dividers */
+  --line-soft: #18222C;
+
+  --calm: #56C7BE;       /* normal signal — all clear */
+  --calm-dim: #2E6B66;
+  --alarm: #FF6A5A;      /* anomaly — surprise crosses the line */
+  --amber: #E6A93C;      /* sodium-lamp threshold tripwire */
+
+  --text: #C8D4DF;
+  --dim: #66768A;
+  --dim-2: #44515F;
+
+  --font-display: "Space Grotesk", system-ui, sans-serif;
+  --font-mono: "JetBrains Mono", ui-monospace, monospace;
+}
+
+* { box-sizing: border-box; margin: 0; padding: 0; }
+
+html, body, #root { height: 100%; }
+
+body {
+  background: var(--void);
+  color: var(--text);
+  font-family: var(--font-display);
+  -webkit-font-smoothing: antialiased;
+  /* faint cold vignette so the console feels lit from the center */
+  background-image: radial-gradient(120% 90% at 50% -10%, #0F1722 0%, var(--void) 60%);
+}
+
+/* ---- shell ---------------------------------------------------- */
+
+.shell {
+  max-width: 1080px;
+  margin: 0 auto;
+  padding: 40px 28px 80px;
+}
+
+/* ---- masthead ------------------------------------------------- */
+
+.masthead {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 24px;
+  padding-bottom: 28px;
+  border-bottom: 1px solid var(--line);
+}
+
+.wordmark {
+  font-family: var(--font-display);
+  font-weight: 700;
+  font-size: 28px;
+  letter-spacing: 0.42em;
+  text-indent: 0.42em;     /* compensate so it stays optically centered */
+  color: var(--text);
+}
+
+.tagline {
+  margin-top: 10px;
+  font-family: var(--font-mono);
+  font-size: 13px;
+  letter-spacing: 0.02em;
+  color: var(--dim);
+}
+
+/* status chip — live instrument indicator */
+.status {
+  display: inline-flex;
+  align-items: center;
+  gap: 9px;
+  font-family: var(--font-mono);
+  font-size: 11px;
+  letter-spacing: 0.18em;
+  color: var(--dim);
+  padding: 8px 13px;
+  border: 1px solid var(--line);
+  border-radius: 2px;
+  background: var(--panel-2);
+  white-space: nowrap;
+}
+.status .dot {
+  width: 7px; height: 7px; border-radius: 50%;
+  background: var(--dim-2);
+}
+.status[data-state="standby"] .dot { background: var(--amber); animation: blink 2.4s ease-in-out infinite; }
+.status[data-state="reading"]  .dot { background: var(--calm);  animation: blink 0.7s ease-in-out infinite; }
+.status[data-state="flagged"]  .dot { background: var(--alarm); box-shadow: 0 0 10px var(--alarm); }
+
+@keyframes blink { 0%,100%{opacity:1} 50%{opacity:0.25} }
+
+/* ---- drop zone ------------------------------------------------ */
+
+.intake {
+  margin-top: 36px;
+}
+
+.dropzone {
+  position: relative;
+  border: 1px dashed var(--line);
+  border-radius: 3px;
+  background:
+    repeating-linear-gradient(45deg, transparent 0 11px, rgba(86,199,190,0.015) 11px 12px),
+    var(--panel-2);
+  padding: 54px 32px;
+  text-align: center;
+  cursor: pointer;
+  transition: border-color 0.18s ease, background-color 0.18s ease;
+}
+.dropzone:hover { border-color: var(--calm-dim); }
+.dropzone[data-drag="true"] {
+  border-color: var(--calm);
+  background-color: rgba(86,199,190,0.04);
+}
+
+.dropzone .eyebrow {
+  font-family: var(--font-mono);
+  font-size: 11px;
+  letter-spacing: 0.24em;
+  color: var(--dim);
+  margin-bottom: 14px;
+}
+.dropzone .prompt {
+  font-family: var(--font-display);
+  font-weight: 500;
+  font-size: 20px;
+  color: var(--text);
+  margin-bottom: 8px;
+}
+.dropzone .sub {
+  font-family: var(--font-mono);
+  font-size: 12px;
+  color: var(--dim-2);
+}
+.dropzone .filename {
+  margin-top: 16px;
+  font-family: var(--font-mono);
+  font-size: 13px;
+  color: var(--calm);
+}
+.hidden-input { display: none; }
+
+.run {
+  margin-top: 18px;
+  display: inline-flex;
+  align-items: center;
+  gap: 10px;
+  font-family: var(--font-mono);
+  font-size: 13px;
+  letter-spacing: 0.12em;
+  color: var(--void);
+  background: var(--calm);
+  border: none;
+  border-radius: 2px;
+  padding: 13px 26px;
+  cursor: pointer;
+  transition: filter 0.15s ease, opacity 0.15s ease;
+}
+.run:hover { filter: brightness(1.08); }
+.run:disabled { opacity: 0.4; cursor: not-allowed; }
+
+.error {
+  margin-top: 16px;
+  font-family: var(--font-mono);
+  font-size: 13px;
+  color: var(--alarm);
+  border-left: 2px solid var(--alarm);
+  padding-left: 12px;
+}
+
+/* ---- stat strip ---------------------------------------------- */
+
+.stats {
+  margin-top: 44px;
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  border: 1px solid var(--line);
+  border-radius: 3px;
+  overflow: hidden;
+  background: var(--panel);
+}
+.stat {
+  padding: 20px 22px;
+  border-right: 1px solid var(--line);
+}
+.stat:last-child { border-right: none; }
+.stat .k {
+  font-family: var(--font-mono);
+  font-size: 10px;
+  letter-spacing: 0.22em;
+  color: var(--dim);
+  margin-bottom: 10px;
+}
+.stat .v {
+  font-family: var(--font-mono);
+  font-weight: 700;
+  font-size: 26px;
+  color: var(--text);
+  line-height: 1;
+}
+.stat .v.alarm { color: var(--alarm); }
+.stat .v.amber { color: var(--amber); }
+
+/* ---- trace panel (the signature) ------------------------------ */
+
+.trace {
+  margin-top: 18px;
+  border: 1px solid var(--line);
+  border-radius: 3px;
+  background:
+    linear-gradient(180deg, rgba(86,199,190,0.02), transparent 30%),
+    var(--panel);
+  padding: 22px 20px 14px;
+}
+.trace-head {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  margin-bottom: 18px;
+  padding: 0 6px;
+}
+.trace-title {
+  font-family: var(--font-display);
+  font-weight: 700;
+  font-size: 15px;
+  letter-spacing: 0.16em;
+  color: var(--text);
+}
+.trace-legend {
+  display: flex;
+  gap: 18px;
+  font-family: var(--font-mono);
+  font-size: 11px;
+  color: var(--dim);
+}
+.trace-legend .item { display: inline-flex; align-items: center; gap: 7px; }
+.trace-legend .swatch { width: 14px; height: 2px; display: inline-block; }
+.swatch.calm  { background: var(--calm); }
+.swatch.amber { background: var(--amber); }
+.swatch.alarm { background: var(--alarm); height: 8px; opacity: 0.55; }
+
+/* idle ambient trace (empty state) */
+.idle {
+  height: 280px;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 18px;
+}
+.idle .scan {
+  width: 100%;
+  height: 1px;
+  background: linear-gradient(90deg, transparent, var(--calm-dim), transparent);
+  opacity: 0.5;
+  animation: sweep 3.4s ease-in-out infinite;
+}
+@keyframes sweep { 0%,100%{transform:scaleX(0.2);opacity:0.2} 50%{transform:scaleX(1);opacity:0.55} }
+.idle .label {
+  font-family: var(--font-mono);
+  font-size: 12px;
+  letter-spacing: 0.2em;
+  color: var(--dim-2);
+}
+
+/* recharts overrides — keep the instrument quiet */
+.recharts-cartesian-grid line { stroke: var(--line-soft); }
+.recharts-text { fill: var(--dim); font-family: var(--font-mono); font-size: 11px; }
+.recharts-cartesian-axis-line { stroke: var(--line); }
+
+/* custom tooltip */
+.tip {
+  background: var(--void);
+  border: 1px solid var(--line);
+  border-radius: 2px;
+  padding: 10px 12px;
+  font-family: var(--font-mono);
+  font-size: 12px;
+}
+.tip .row { display: flex; gap: 14px; justify-content: space-between; }
+.tip .lab { color: var(--dim); }
+.tip .val { color: var(--text); }
+.tip .val.alarm { color: var(--alarm); }
+
+/* ---- responsive ----------------------------------------------- */
+
+@media (max-width: 680px) {
+  .masthead { flex-direction: column; }
+  .stats { grid-template-columns: repeat(2, 1fr); }
+  .stat:nth-child(2) { border-right: none; }
+  .stat:nth-child(1), .stat:nth-child(2) { border-bottom: 1px solid var(--line); }
+  .wordmark { font-size: 22px; letter-spacing: 0.32em; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .status .dot, .idle .scan { animation: none; }
+}
+
+/* ---- anomalous moments strip ---------------------------------- */
+
+.moments { margin-top: 18px; }
+
+.moments-head {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  margin-bottom: 14px;
+  padding: 0 2px;
+}
+.moments-title {
+  font-family: var(--font-display);
+  font-weight: 700;
+  font-size: 14px;
+  letter-spacing: 0.16em;
+  color: var(--text);
+}
+.moments-sub {
+  font-family: var(--font-mono);
+  font-size: 11px;
+  color: var(--dim);
+}
+
+.moments-grid {
+  display: grid;
+  grid-template-columns: repeat(5, 1fr);
+  gap: 12px;
+}
+
+.moment {
+  border: 1px solid var(--line);
+  border-radius: 3px;
+  overflow: hidden;
+  background: var(--panel);
+  transition: border-color 0.15s ease, transform 0.15s ease;
+}
+.moment:hover {
+  border-color: var(--alarm);
+  transform: translateY(-2px);
+}
+.moment-img {
+  display: block;
+  width: 100%;
+  aspect-ratio: 1;
+  object-fit: cover;
+  image-rendering: pixelated;   /* 128x128 büyürken keskin kalsın */
+}
+.moment-cap {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 9px 11px;
+  font-family: var(--font-mono);
+  font-size: 11px;
+  border-top: 1px solid var(--line);
+}
+.moment-frame { color: var(--dim); letter-spacing: 0.08em; }
+.moment-score { color: var(--alarm); font-weight: 500; }
+
+@media (max-width: 680px) {
+  .moments-grid { grid-template-columns: repeat(2, 1fr); }
+  .moments-head { flex-direction: column; gap: 4px; }
+}
+
+/* ---- synced playback -------------------- */
+ 
+.playback { margin-top: 18px; }
+ 
+.feed-video {
+  width: 100%;
+  max-height: 360px;
+  border: 1px solid var(--line);
+  border-radius: 3px;
+  background: #000;
+  display: block;
+}
+ 
+.live-readout {
+  display: flex;
+  gap: 18px;
+  align-items: baseline;
+  margin-top: 10px;
+  padding: 0 2px;
+  font-family: var(--font-mono);
+  font-size: 13px;
+}
+.lr-frame { color: var(--dim); letter-spacing: 0.08em; }
+.lr-score { color: var(--calm); }
+.lr-score.alarm { color: var(--alarm); font-weight: 700; }
+.lr-warm { color: var(--dim-2); letter-spacing: 0.12em; }
+
+/* ---- trace explanation note (append to index.css) ------------- */
+
+.trace-note {
+  font-family: var(--font-mono);
+  font-size: 11px;
+  color: var(--dim);
+  padding: 0 6px 14px;
+  margin-top: -6px;
+}

frontend/src/main.jsx

@@ -0,0 +1,10 @@
+import React from "react";
+import ReactDOM from "react-dom/client";
+import App from "./App.jsx";
+import "./index.css";
+
+ReactDOM.createRoot(document.getElementById("root")).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);

frontend/vite.config.js

@@ -0,0 +1,16 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 5173,
+    proxy: {
+      "/api": {
+        target: "http://localhost:8000",
+        changeOrigin: true,
+        rewrite: (path) => path.replace(/^\/api/, ""),
+      },
+    },
+  },
+});

requirements-inference.txt

@@ -0,0 +1,12 @@
+# Inference-only dependencies (CPU serving image)
+numpy
+opencv-python-headless
+pillow
+onnxruntime
+fastapi
+uvicorn[standard]
+python-multipart
+matplotlib
+torch
+torchvision
+prometheus-fastapi-instrumentator

src/data/ucsd_loader.py

@@ -0,0 +1,186 @@
+"""
+Module for dataset and dataloaders of UCSD dataset.
+"""
+
+import re
+from pathlib import Path
+from typing import List, Tuple, Optional
+import numpy as np
+from PIL import Image
+import torch
+from torch.utils.data import Dataset
+
+from src.data.video_transforms import transform
+
+
+class UCSDDataset(Dataset):
+    """
+    UCSD Anomaly Detection Dataset.
+    
+    Train: only normal clips.
+    Test: clips with frame-level ground truth annotations.
+    
+    Args:
+        root: Dataset root path (containing UCSDped1/, UCSDped2/)
+        subset: 'Ped1' or 'Ped2'
+        split: 'train' or 'test'
+        window_size: Number of frames per sample (sliding window)
+        stride: Stride between windows
+        transform: Optional transform applied to each frame
+    """
+    
+    def __init__(
+        self,
+        root: str,
+        subset: str = "Ped2",
+        split: str = "train",
+        window_size: int = 16,
+        stride: int = 8,
+        mode: str = "reconstruction",
+        transform: Optional[callable] = None,
+        clip_indices: Optional[List[int]] = None
+    ):
+        super().__init__()
+        self.root = Path(root)
+        self.subset = subset.lower()
+        self.split = split
+        self.window_size = window_size
+        self.stride = stride
+        self.mode = mode
+        self.transform = transform
+        self.clip_indices = clip_indices
+
+        # Subset check
+        assert subset in ("ped1", "ped2"), f"subset must be ped1 or ped2, got {subset}"
+
+        # Read the subset and store the clip directories
+        self.subset_split = self.root / f"UCSD{self.subset}" / f"{split.title()}"
+
+        # Sanity check to ensure the files and clip directories exist
+        if not self.subset_split.exists():
+            raise FileNotFoundError(f"Dataset path not found: {self.subset_split}")
+        
+        self.clip_dirs = sorted([
+            d for d in self.subset_split.iterdir() 
+            if d.is_dir() and not d.name.endswith("_gt")
+        ])
+
+        # Filter out the clips
+        if self.clip_indices is not None:
+            self.clip_dirs = [self.clip_dirs[i] for i in self.clip_indices]
+        
+        if len(self.clip_dirs) == 0:
+            raise RuntimeError(f"No clip directories found in {self.subset_split}")
+
+        # Collect the clip paths
+        self.clips = []
+        for clip_dir in self.clip_dirs:  # clip_dir = Path("Train001")
+            frame_paths = sorted(clip_dir.glob("*.tif"))  # liste of frame paths
+            frames = np.stack([np.array(Image.open(p)) for p in frame_paths])
+            self.clips.append(frames)
+
+        # Create labels based on split
+        if self.split == "test":
+            m_file = self.subset_split / f"UCSD{subset}.m"  # path case dikkat
+            content = m_file.read_text()
+            matches = re.findall(r"\[(\d+):(\d+)\]", content)
+            
+            self.labels = []
+            for clip_idx, (start_str, end_str) in enumerate(matches):
+                start, end = int(start_str), int(end_str)
+                n_frames = len(self.clips[clip_idx])  # clip's frame length
+                label = np.zeros(n_frames, dtype=np.int64)
+                label[start-1:end] = 1  # 1-indexed -> 0-indexed slice
+                self.labels.append(label)
+        else:
+            self.labels = None  # train, no label
+
+        # Collect the window indexes
+        self.windows = []  # list of (clip_idx, start_frame)
+        for clip_idx, frames in enumerate(self.clips):
+            n_frames = len(frames)
+            for start in range(0, n_frames - window_size + 1, stride):
+                self.windows.append((clip_idx, start))
+
+    def __len__(self) -> int:
+        return len(self.windows)
+    
+    def __getitem__(self, idx: int) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Returns:
+           frames: (T, C, H, W) tensor
+           label: (T,) tensor of 0/1 (train: all zeros, test: from gt)
+        """
+        # Read frames and label
+        clip_idx, start_frame = self.windows[idx]
+        
+        # Take the frames within frame range
+        window_frames = self.clips[clip_idx][start_frame : start_frame + self.window_size] # shape: (T, H, W) uint8
+
+        # Check labels based on split
+        if self.split == "test":
+            labels_np = self.labels[clip_idx][start_frame : start_frame + self.window_size]
+            labels = torch.from_numpy(labels_np)  # int64 tensor
+        else:
+            labels = torch.zeros(self.window_size, dtype=torch.long)
+
+        # Convert window array to tensor and reshape it
+        window_tensor = torch.from_numpy(window_frames).float() / 255.0
+        window_tensor = window_tensor.unsqueeze(1)  # (T, H, W) -> (T, 1, H, W)
+        
+        # Check for transforms
+        if self.transform is not None:
+            window_tensor = self.transform(window_tensor)
+
+        if self.mode == "prediction":
+            input_frames = window_tensor[:-1]   # (15, 1, H, W) — first 15 window
+            target_frame = window_tensor[-1]    # (1, H, W) — last frame, target
+            return input_frames, target_frame
+        else:
+            return window_tensor, labels
+
+if __name__ == "__main__":
+    # Run sanity check
+    train_clips = [0,1,2,3,4,5,6,7,8,9,10,11,12]   # 13 clip
+    val_clips   = [13,14,15]                       # 3 clip
+
+    # Train
+    ds_train = UCSDDataset(root="data/ucsd/raw", subset="ped2", clip_indices=train_clips, transform=transform, split="train")
+    print(f"Train: {len(ds_train.clips)} clips, {len(ds_train)} windows")
+    print(f"First clip shape: {ds_train.clips[0].shape}")
+
+    # Validation
+    ds_val = UCSDDataset(root="data/ucsd/raw", subset="ped2", clip_indices=val_clips, transform=transform, split="train")
+    print(f"Val: {len(ds_val.clips)} clips, {len(ds_val)} windows")
+    print(f"Val labels: {ds_val.labels}") # Should be None
+
+    # Test
+    ds_test = UCSDDataset(root="data/ucsd/raw", subset="ped2", split="test", transform=transform)
+    print(f"Test: {len(ds_test.clips)} clips, {len(ds_test)} windows")
+    print(f"First label sum: {ds_test.labels[0].sum()}/{len(ds_test.labels[0])}")
+
+    # Test getitem
+    sample, label = ds_train[0]
+    print(f"\nSample 0 (train):")
+    print(f"  Sample shape: {sample.shape}, dtype: {sample.dtype}")
+    print(f"  Sample range: [{sample.min():.3f}, {sample.max():.3f}]")
+    print(f"  Label shape: {label.shape}, sum: {label.sum()}")
+
+    sample, label = ds_val[0]
+    print(f"\nSample 0 (test):")
+    print(f"  Sample shape: {sample.shape}")
+    print(f"  Label shape: {label.shape}, sum: {label.sum()}")
+
+    # Random middle sample
+    sample, label = ds_train[len(ds_train) // 2]
+    print(f"\nMiddle train sample shape: {sample.shape}")
+
+    # Transform check
+    print(sample.shape)  # torch.Size([16, 1, 128, 128])
+
+    # Prediction
+    ds = UCSDDataset(root="data/ucsd/raw", subset="ped2", split="train",
+                    clip_indices=list(range(13)), transform=transform, mode="prediction")
+    inp, tgt = ds[0]
+    print(f"input: {inp.shape}")    # expected (15, 1, 128, 128)
+    print(f"target: {tgt.shape}")   # expected (1, 128, 128)

src/data/video_transforms.py

@@ -0,0 +1,27 @@
+"""
+Video transforms for UCSD anomaly detection.
+M1 minimal: Resize + Normalize. No random augmentation.
+"""
+
+import torch
+from torchvision.transforms import v2
+
+
+# Input: float32 tensor, shape (T, 1, H, W), range [0, 1]
+# Output: float32 tensor, shape (T, 1, 128, 128), range ~[-1, 1]
+transform = v2.Compose([
+    v2.Resize(size=(128, 128), antialias=True),
+    v2.Normalize(mean=[0.5], std=[0.5]),
+])
+
+
+if __name__ == "__main__":
+    # Dummy window
+    x = torch.rand(16, 1, 240, 360)  # (T, C, H, W)
+    print(f"Before: shape={x.shape}, range=[{x.min():.3f}, {x.max():.3f}]")
+    
+    y = transform(x)
+    print(f"After:  shape={y.shape}, range=[{y.min():.3f}, {y.max():.3f}]")
+    
+    # Mean/std after normalize, beklenen ~0 mean ~0.577 std (uniform [-1,1] için)
+    print(f"After mean={y.mean():.3f}, std={y.std():.3f}")

src/eval/metrics.py

@@ -0,0 +1,22 @@
+"""
+Module for measuring metrics.
+"""
+
+from sklearn.metrics import roc_auc_score, roc_curve
+import numpy as np
+
+
+def compute_auc(all_scores, all_labels):
+    """Frame-level ROC-AUC."""
+    return roc_auc_score(all_labels, all_scores)
+
+
+def compute_eer(all_scores, all_labels):
+    """Equal Error Rate: The error at point FPR == FNR"""
+    fpr, tpr, _ = roc_curve(all_labels, all_scores)
+    fnr = 1 - tpr
+    
+    # FPR and FNR's nearest index
+    idx = np.nanargmin(np.abs(fpr - fnr))
+    eer = (fpr[idx] + fnr[idx]) / 2
+    return eer

src/eval/visualization.py

@@ -0,0 +1,27 @@
+"""
+Module for visualizations.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def plot_error_distribution(all_scores, all_labels, save_path="docs/error_dist.png"):
+    """
+    Function that plots the error distribution between normal and anomaly scores using label masking.
+    """
+    
+    # Mask the labels
+    normal_scores  = all_scores[all_labels == 0]
+    anomaly_scores = all_scores[all_labels == 1]
+
+    # Plot the graph
+    plt.figure(figsize=(10, 5))
+    plt.hist(normal_scores,  bins=50, alpha=0.6, label="Normal",  density=True)
+    plt.hist(anomaly_scores, bins=50, alpha=0.6, label="Anomaly", density=True)
+    plt.xlabel("Reconstruction error")
+    plt.ylabel("Density")
+    plt.title("Per-frame reconstruction error: normal vs anomaly")
+    plt.legend()
+    plt.savefig(save_path, dpi=120, bbox_inches="tight")
+    print(f"saved: {save_path}")

src/export/onnx_export.py

@@ -0,0 +1,48 @@
+"""
+Export the M3 U-Net predictor to ONNX, with a PyTorch-vs-ONNX parity check.
+"""
+
+import torch
+import numpy as np
+import onnxruntime as ort
+from src.models.predictor import UNetPredictor
+
+
+if __name__ == "__main__":
+    device = "cpu"   # generally conducts on cpu
+
+    # Load trained model
+    model = UNetPredictor().to(device)
+    ckpt = torch.load("checkpoints/pred_best.pt", map_location=device)
+    model.load_state_dict(ckpt["model_state"])
+    model.eval()
+
+    # Example input — same shape as a real window
+    dummy = torch.randn(1, 15, 1, 128, 128)   # (B, 15, 1, H, W)
+
+    # Export to ONNX
+    torch.onnx.export(
+        model,                          # model
+        dummy,                          # sample input (for trace)
+        "checkpoints/model.onnx",       # output filename
+        input_names=["input"],          # input node name
+        output_names=["output"],        # output node name
+        dynamic_axes={                  # dynamic batch axis
+            "input":  {0: "batch"},
+            "output": {0: "batch"},
+        },
+        opset_version=18,
+    )
+
+    # Parity test — PyTorch vs ONNX Runtime
+    with torch.no_grad():
+        torch_out = model(dummy).cpu().numpy()
+
+    sess = ort.InferenceSession("checkpoints/model.onnx")
+    input_name = sess.get_inputs()[0].name
+    onnx_out = sess.run(None, {input_name: dummy.numpy()})[0]
+
+    # Compare model outputs
+    max_diff = np.abs(torch_out - onnx_out).max()
+    print(max_diff)  # expected ~1e-5
+    assert max_diff < 1e-4

src/inference/scoring.py

@@ -0,0 +1,189 @@
+"""
+Module for per-frame anomaly scoring on UCSD test split.
+
+Pipeline: model reconstruction -> per-frame error -> overlapping-window
+averaging -> per-clip frame-aligned anomaly scores.
+"""
+
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+from scipy.ndimage import gaussian_filter1d
+from src.data.ucsd_loader import UCSDDataset
+from src.models.autoencoder import AutoEncoder
+from src.data.video_transforms import transform
+
+
+def smooth_scores(scores: np.ndarray, sigma: float = 2.0) -> np.ndarray:
+    """Temporal Gaussian smoothing on a single clip's per-frame scores."""
+    return gaussian_filter1d(scores, sigma=sigma)
+
+
+def compute_frame_errors(model: nn.Module, dataset: UCSDDataset, device: str) -> dict:
+    """
+    Compute per-frame reconstruction error for every clip in the test set,
+    averaging across overlapping windows.
+
+    Returns:
+        dict mapping clip_idx -> (scores, labels)
+        - scores: np.ndarray shape (n_frames,), avg reconstruction error per frame
+        - labels: np.ndarray shape (n_frames,), 0/1 ground truth per frame
+    """
+    model.eval()
+
+    # Prepare an accumulator for every clip
+    error_sum = {}
+    count = {}
+    for clip_idx in range(len(dataset.clips)):
+        n_frames = len(dataset.clips[clip_idx])
+        error_sum[clip_idx] = np.zeros(n_frames, dtype=np.float64)
+        count[clip_idx] = np.zeros(n_frames, dtype=np.float64)
+
+    # Give out the windows towards the model
+    loader = DataLoader(dataset, batch_size=1, shuffle=False)
+
+    with torch.no_grad():
+        for idx, (window, _labels) in enumerate(loader):
+            # Window shape: (1, T, C, H, W)  -- batch size 1
+            window = window.to(device)
+
+            # Reconstruction
+            out = model(window)
+            recon = out[0] if isinstance(out, tuple) else out
+
+            # Calculate per-frame error with taking the mean based on (C,H,W) channels
+            per_frame_err = torch.mean(((window - recon)**2), dim=(0, 2, 3, 4)).cpu().numpy()   # shape: (T,)
+
+            # Take a particular window from a particular clip
+            clip_idx, start_frame = dataset.windows[idx]
+
+            # For every t, global frame = start_frame + t
+            error_sum[clip_idx][start_frame : start_frame + dataset.window_size] += per_frame_err
+            count[clip_idx][start_frame : start_frame + dataset.window_size] += 1
+
+    # Ortalama al + ground truth'u hizala
+    results = {}
+    for clip_idx in error_sum:
+        # Counts and errors
+        counts = count[clip_idx]
+        errs = error_sum[clip_idx]
+
+        # Log the number of frames that aren't valid
+        print(f"clip {clip_idx}: {(counts==0).sum()} frames with no window coverage")
+
+        # Valid frame filter
+        valid = counts > 0
+        
+        # Take out the average which gives the result of average error
+        scores = errs[valid] / counts[valid]          # Only valid frames
+        scores = smooth_scores(scores, sigma=1.0)     # Clip based smoothing
+        labels = dataset.labels[clip_idx][valid]      # Apply same mask
+
+        results[clip_idx] = (scores, labels)
+
+    return results
+
+
+def aggregate_all(results: dict) -> tuple:
+    """
+    Flatten per-clip results into two 1D arrays for global AUC.
+
+    Returns:
+        all_scores: np.ndarray (total_frames,)
+        all_labels: np.ndarray (total_frames,)
+    """
+    scores_list = []
+    labels_list = []
+
+    # Append corresponding clip's (scores, labels) by order
+    for clip_idx in results:
+        scores, labels = results[clip_idx]
+        scores_list.append(scores)
+        labels_list.append(labels)
+
+    # Concatenate the results on 1D numpy array
+    all_scores = np.concatenate(scores_list)
+    all_labels = np.concatenate(labels_list)
+
+    return all_scores, all_labels
+
+
+def compute_prediction_errors(model: nn.Module, dataset: UCSDDataset, device: str) -> dict:
+    """
+    Per-frame prediction error for M3.
+    Each window (15 input -> 1 target) scores ONE frame: the target frame
+    at index (start_frame + 15) in its clip.
+    """
+    model.eval()
+
+    # Per-clip accumulator. Many frames are never a target:
+    # the first 15 frames of each clip are always inputs, never predicted.
+    error_sum = {}
+    count = {}
+    for clip_idx in range(len(dataset.clips)):
+        n_frames = len(dataset.clips[clip_idx])
+        error_sum[clip_idx] = np.zeros(n_frames, dtype=np.float64)
+        count[clip_idx] = np.zeros(n_frames, dtype=np.float64)
+
+    loader = DataLoader(dataset, batch_size=1, shuffle=False)
+
+    with torch.no_grad():
+        for idx, (inputs, target) in enumerate(loader):
+            # inputs: (1,15,1,H,W), target: (1,1,H,W)
+            inputs, target = inputs.to(device), target.to(device)
+            pred = model(inputs)                      # (1,1,H,W)
+
+            # Single target frame -> one scalar error (mean over C,H,W)
+            err = ((pred - target) ** 2).mean().item()
+
+            # Which clip / which target frame does this window predict?
+            clip_idx, start_frame = dataset.windows[idx]
+            target_idx = start_frame + 15   # first 15 are inputs, 16th is target
+            error_sum[clip_idx][target_idx] += err
+            count[clip_idx][target_idx] += 1
+
+    # Average + align ground truth (count>0 mask, like M1/M2).
+    # NOTE: first 15 frames + uncovered frames have count==0, masked out.
+    results = {}
+    for clip_idx in error_sum:
+        counts = count[clip_idx]
+        errs = error_sum[clip_idx]
+
+        # Log frames with no coverage (expected: at least the first 15)
+        print(f"clip {clip_idx}: {(counts==0).sum()} frames with no prediction coverage")
+
+        # Keep only frames that were predicted at least once
+        valid = counts > 0
+
+        scores = errs[valid] / counts[valid]          # average error per frame
+        scores = smooth_scores(scores, sigma=1.0)     # clip-level temporal smoothing
+        labels = dataset.labels[clip_idx][valid]      # same mask -> alignment
+
+        results[clip_idx] = (scores, labels)
+
+    return results
+
+
+if __name__ == "__main__":
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    # Modeli yükle (eğittiğin best checkpoint)
+    model = AutoEncoder().to(device)
+    ckpt = torch.load("checkpoints/ae_best.pt", map_location=device)
+    model.load_state_dict(ckpt["model_state"])
+
+    # Test dataset — clip_indices YOK (tüm 12 clip), split="test"
+    test_ds = UCSDDataset(root="data/ucsd/raw", subset="ped2", split="test", transform=transform)
+
+    results = compute_frame_errors(model, test_ds, device)
+    all_scores, all_labels = aggregate_all(results)
+
+    # Sanity check
+    print(f"shape: {all_scores.shape}, {all_labels.shape}")          # same, 1D
+    print(f"anomaly frames: {all_labels.sum()}/{len(all_labels)}")
+
+    normal_mean  = all_scores[all_labels == 0].mean()
+    anomaly_mean = all_scores[all_labels == 1].mean()
+    print(f"normal mean error:  {normal_mean:.6f}")
+    print(f"anomaly mean error: {anomaly_mean:.6f}")

src/inference/stream.py

@@ -0,0 +1,142 @@
+"""
+Streaming anomaly detection for the M3 predictor.
+Rolling 15-frame buffer -> predict next frame -> per-frame anomaly score (+ heatmap).
+"""
+
+import os
+import glob
+import numpy as np
+import cv2
+import onnxruntime as ort
+from collections import deque
+from src.data.video_transforms import transform   # same transform as training
+import torch
+
+
+class AnomalyStream:
+    def __init__(self, onnx_path: str, buffer_size: int = 15):
+        self.sess = ort.InferenceSession(onnx_path)
+        self.input_name = self.sess.get_inputs()[0].name
+        self.buffer_size = buffer_size
+        self.buffer = deque(maxlen=buffer_size)   # last 15 preprocessed frame
+
+    def preprocess(self, frame_bgr: np.ndarray) -> torch.Tensor:
+        """
+        Raw video frame (H,W,3 BGR) -> training format (1, H, W) [-1,1] grayscale 128x128.
+        """
+        # BGR -> grayscale (numpy, uint8, (H,W))
+        gray = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2GRAY)
+
+        # numpy -> torch, float, [0,1]
+        gray_t = torch.from_numpy(gray).float() / 255.0   # (H, W)
+
+        # transform expects (T, C, H, W) — make it (1, 1, H, W): T=1, C=1
+        gray_t = gray_t.unsqueeze(0).unsqueeze(0)          # (1, 1, H, W)
+
+        # apply training transform (resize 128, normalize [-1,1])
+        gray_t = transform(gray_t)                          # (1, 1, 128, 128)
+
+        # drop the T axis -> (1, 128, 128) = (C, H, W) for buffering
+        return gray_t.squeeze(0)                            # (1, 128, 128)
+
+    def push(self, frame_bgr: np.ndarray):
+        """
+        Add one frame. Returns (score, heatmap) or None if still warming up.
+        """
+        frame_t = self.preprocess(frame_bgr)                    # (1,128,128)
+
+        # Cold start: wait for buffer to warm up (first 15 frames)
+        if len(self.buffer) < self.buffer_size:
+            self.buffer.append(frame_t)
+            return None   # warming up
+
+        # buffer: 15 frame, every frame shaped (1,128,128) = (C,H,W)
+        # stack -> (15, 1, 128, 128), then batch axis -> (1, 15, 1, 128, 128)
+        stacked = torch.stack(list(self.buffer))                # (15, 1, 128, 128)
+        inp = stacked.unsqueeze(0).numpy()                      # (1, 15, 1, 128, 128) numpy
+        pred = self.sess.run(None, {self.input_name: inp})[0]   # (1,1,128,128)
+
+        # Real frame (target) = this new frame
+        actual = frame_t.numpy()[None, ...]                     # (1,1,128,128) -- shape matching
+
+        # Per-pixel error -> heatmap, mean -> score
+        error_map = (pred - actual) ** 2                        # (1, 1, 128, 128)
+        heatmap = error_map[0, 0]                               # (128, 128) — spatial harita, frontend için
+        score = float(error_map.mean())                         # scaler anomaly score
+
+        # Update the buffer
+        self.buffer.append(frame_t)
+
+        return score, heatmap, frame_t.numpy()[0]   # (128,128) preprocessed target image
+
+
+def process_video(video_path, onnx_path, top_n=5):
+    """Run the stream over a video file, collect per-frame scores."""
+    stream = AnomalyStream(onnx_path)
+    cap = cv2.VideoCapture(video_path)
+
+    scores = []
+    scored_records = []   # (score, frame_idx, heatmap, frame_image)
+
+    # Measure the FPS
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    
+    frame_idx = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        result = stream.push(frame)
+        if result is None:
+            scores.append(None)
+        else:
+            score, heatmap, frame_img = result
+            scores.append(score)
+            scored_records.append((score, frame_idx, heatmap, frame_img))
+        frame_idx += 1
+    cap.release()
+
+    # Top-N highest scored frame
+    top = sorted(scored_records, key=lambda r: r[0], reverse=True)[:top_n]
+    top_anomalies = [
+        {"frame_idx": idx, "score": float(s), "heatmap": hmap, "frame": img}
+        for (s, idx, hmap, img) in top
+    ]
+
+    return scores, top_anomalies, fps
+
+
+def process_frames(frame_dir: str, onnx_path: str):
+    """
+    Run the stream over a directory of .tif frames (UCSD format).
+    Mirrors process_video but reads ordered image files instead of decoding video.
+    Used to verify the streaming pipeline matches eval scoring.
+    """
+    stream = AnomalyStream(onnx_path)
+
+    # UCSD frames: sorted .tif files in the clip dir
+    frame_paths = sorted(glob.glob(os.path.join(frame_dir, "*.tif")))
+
+    scores = []
+    for path in frame_paths:
+        # cv2.imread reads as BGR (H,W,3) even for grayscale .tif -> preprocess handles BGR->gray
+        frame = cv2.imread(path)
+        result = stream.push(frame)
+        if result is None:
+            scores.append(None)              # warming up (first 15)
+        else:
+            score, heatmap = result
+            scores.append(score)
+
+    return scores
+
+
+if __name__ == "__main__":
+    # Smoke test for streaming
+    onnx_path = "checkpoints/model.onnx"
+    clip_dir = "data/ucsd/raw/UCSDped2/Test/Test001"   # a test clip
+
+    scores, top = process_video("/tmp/test001.mp4", "checkpoints/model.onnx", top_n=5)
+    print(f"scored: {len([s for s in scores if s is not None])}, top anomalies: {len(top)}")
+    for t in top:
+        print(f"  frame {t['frame_idx']}: score {t['score']:.6e}, heatmap {t['heatmap'].shape}, frame {t['frame'].shape}")

src/models/autoencoder.py

@@ -0,0 +1,72 @@
+"""
+Module for autoencoder model.
+"""
+
+import torch
+import torch.nn as nn
+
+
+class AutoEncoder(nn.Module):
+    """
+    Auto encoder model class.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.network = nn.Sequential(
+            # Encoder layers
+            nn.Conv3d(in_channels=1, out_channels=16, kernel_size=(3, 3, 3), stride=(1, 2, 2), padding=1),
+            nn.GroupNorm(num_groups=8, num_channels=16),
+            nn.LeakyReLU(),
+
+            nn.Conv3d(in_channels=16, out_channels=32, kernel_size=(3, 3, 3), stride=(2, 2, 2), padding=1),
+            nn.GroupNorm(num_groups=8, num_channels=32),
+            nn.LeakyReLU(),
+
+            nn.Conv3d(in_channels=32, out_channels=64, kernel_size=(3, 3, 3), stride=(2, 2, 2), padding=1),
+            nn.GroupNorm(num_groups=8, num_channels=64),
+            nn.LeakyReLU(),
+
+            # Bottleneck
+            nn.Conv3d(in_channels=64, out_channels=16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=1),
+            nn.GroupNorm(num_groups=8, num_channels=16),
+            nn.LeakyReLU(),
+
+            # Decoder layers
+            nn.ConvTranspose3d(in_channels=16, out_channels=32, kernel_size=(3, 3, 3), stride=(2, 2, 2), padding=1, output_padding=(1, 1, 1)),
+            nn.GroupNorm(num_groups=8, num_channels=32),
+            nn.LeakyReLU(),
+
+            nn.ConvTranspose3d(in_channels=32, out_channels=16, kernel_size=(3, 3, 3), stride=(2, 2, 2), padding=1, output_padding=(1, 1, 1)),
+            nn.GroupNorm(num_groups=8, num_channels=16),
+            nn.LeakyReLU(),
+
+            # Output layer
+            nn.ConvTranspose3d(in_channels=16, out_channels=1, kernel_size=(3, 3, 3), stride=(1, 2, 2), padding=1, output_padding=(0, 1, 1)),
+            nn.Tanh(),
+        )
+
+    def forward(self, x):
+        # Permute to match the shape that dataloader gives
+        x = x.permute(0, 2, 1, 3, 4)   # (B,T,C,H,W) -> (B,C,T,H,W)
+        x = self.network(x)
+        x = x.permute(0, 2, 1, 3, 4)   # backwards: (B,C,T,H,W) -> (B,T,C,H,W)
+        return x
+    
+
+if __name__ == "__main__":
+    # Smoke test to assert that shapes are correctly matches
+    model = AutoEncoder()
+    x = torch.randn(2, 16, 1, 128, 128)
+
+    # debug: seperate variable to permute manually
+    xd = x.permute(0,2,1,3,4)
+    for layer in model.network:
+        xd = layer(xd)
+        if isinstance(xd, torch.Tensor):
+            print(type(layer).__name__, tuple(xd.shape))
+
+    # real forward prop
+    out = model(x)
+    print("out:", tuple(out.shape))
+    assert out.shape == x.shape

src/models/memory_ae.py

@@ -0,0 +1,175 @@
+"""
+Memory-Augmented Autoencoder (MemAE) for video anomaly detection.
+
+Encoder/decoder backbone = M1 AutoEncoder, unchanged. A memory module is
+inserted between them: the decoder can only reconstruct from stored normal
+prototypes, so anomalies (absent from memory) reconstruct poorly.
+
+Ref: Gong et al. 2019, "Memorizing Normality to Detect Anomaly" (ICCV).
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class MemoryModule(nn.Module):
+    """
+    Memory bank with sparse attention-based addressing.
+
+    Forward: bottleneck feature -> queries -> address memory -> reconstructed
+    feature (+ attention weights for entropy loss / sparsity inspection).
+
+    Args:
+        n_slots: N, number of memory items (paper value)
+        feat_dim: C, dimension of each memory item = bottleneck channel dim (16)
+        shrink_thres: lambda, sparse addressing threshold (paper value)
+    """
+
+    def __init__(self, n_slots: int, feat_dim: int = 16, shrink_thres: float = None):
+        super().__init__()
+        self.n_slots = n_slots
+        self.feat_dim = feat_dim
+
+        # Edge case check
+        if shrink_thres is None:
+            shrink_thres = 1.0 / n_slots   # lambda, dependant on N
+        self.shrink_thres = shrink_thres
+
+        # Memory bank: learnable (N, C) matrix, trained end-to-end via backprop
+        self.memory = nn.Parameter(torch.randn(size=(self.n_slots, self.feat_dim)))
+
+    def forward(self, z: torch.Tensor):
+        """
+        Args:
+            z: bottleneck feature, shape (B, C, T, H, W) = (B, 16, 4, 16, 16)
+        Returns:
+            z_hat: reconstructed feature, same shape as z
+            attn:  attention weights, shape (B, n_queries, N) -- for loss/viz
+        """
+        B, C, T, H, W = z.shape
+        n_queries = T * H * W   # 4*16*16 = 1024
+
+        # (B,C,T,H,W) -> queries (B, n_queries, C)
+        z = z.permute(dims=(0, 2, 3, 4, 1))
+        query = z.reshape(shape=(B, n_queries, C))   # shape (B, n_queries, C)
+
+        # Cosine similarity: query vs her memory slot.
+        query_n  = F.normalize(query, dim=-1)        # (B, n_queries, C)
+        memory_n = F.normalize(self.memory, dim=-1)  # (N, C)
+        sim = query_n @ memory_n.t()                 # (B, n_queries, N)
+
+        # Softmax over N
+        attn = F.softmax(sim, dim=-1)   # -1 dim to autocalculate dimensions, shape (B, n_queries, N)
+
+        # Sparse addressing: hard shrinkage + renormalize
+        eps = 1e-12
+        # hard shrinkage
+        attn = F.relu(attn - self.shrink_thres) * attn / (torch.abs(attn - self.shrink_thres) + eps)
+        # renormalize
+        attn = attn / (attn.sum(dim=-1, keepdim=True) + eps)
+
+        # Weighted sum: with plain (unnormalized) memory
+        z_hat_flat = attn @ self.memory   # (B,n_queries,N) @ (N,C) = (B,n_queries,C)
+
+        # queries -> (B,C,T,H,W) backwards
+        # Backwards of the first step: reshape -> (B,T,H,W,C), after permute -> (B,C,T,H,W)
+        z_hat = z_hat_flat.reshape(B, T, H, W, C).permute(0, 4, 1, 2, 3)      # (B,C,T,H,W)
+
+        return z_hat, attn
+
+
+class MemoryAE(nn.Module):
+    """
+    M1 encoder + MemoryModule + M1 decoder.
+    Encoder/decoder backbone unchanged from M1 (clean ablation).
+    """
+
+    def __init__(self, n_slots: int, shrink_thres: float = None):
+        super().__init__()
+
+        # Edge case check
+        if shrink_thres is None:
+            shrink_thres = 1.0 / n_slots   # lambda, dependant on N
+
+        # Encoder layers
+        self.encoder = nn.Sequential(
+            # enc1
+            nn.Conv3d(1, 16, (3,3,3), stride=(1,2,2), padding=1),
+            nn.GroupNorm(8, 16),
+            nn.LeakyReLU(),
+            # enc2
+            nn.Conv3d(16, 32, (3,3,3), stride=(2,2,2), padding=1),
+            nn.GroupNorm(8, 32),
+            nn.LeakyReLU(),
+            # enc3
+            nn.Conv3d(32, 64, (3,3,3), stride=(2,2,2), padding=1),
+            nn.GroupNorm(8, 64),
+            nn.LeakyReLU(),
+            # bottleneck — encoder's last piece
+            nn.Conv3d(64, 16, (3,3,3), stride=(1,1,1), padding=1),
+            nn.GroupNorm(8, 16),
+            nn.LeakyReLU(),
+        )
+        # Memory layer
+        self.memory = MemoryModule(n_slots=n_slots, feat_dim=16, shrink_thres=shrink_thres)
+        # Decoder layers
+        self.decoder = nn.Sequential(
+            # dec1
+            nn.ConvTranspose3d(16, 32, (3,3,3), stride=(2,2,2), padding=1, output_padding=(1,1,1)),
+            nn.GroupNorm(8, 32),
+            nn.LeakyReLU(),
+            # dec2
+            nn.ConvTranspose3d(32, 16, (3,3,3), stride=(2,2,2), padding=1, output_padding=(1,1,1)),
+            nn.GroupNorm(8, 16),
+            nn.LeakyReLU(),
+            # dec3
+            nn.ConvTranspose3d(16, 1, (3,3,3), stride=(1,2,2), padding=1, output_padding=(0,1,1)),
+            nn.Tanh(),
+        )
+
+    def forward(self, x: torch.Tensor):
+        """
+        Args:
+            x: (B, T, C, H, W) -- loader format (same with M1)
+        Returns:
+            recon: (B, T, C, H, W)
+            attn:  (B, n_queries, N)
+        """
+        # M1 permute logic: loader (B,T,C,H,W) -> conv (B,C,T,H,W)
+        x = x.permute(0, 2, 1, 3, 4)   # (B,C,T,H,W)
+
+        # encoder -> bottleneck
+        z = self.encoder(x)                    # (B, 16, 4, 16, 16)
+
+        # memory addressing
+        z_hat, attn = self.memory(z)           # (B, 16, 4, 16, 16), (B, 1024, N)
+
+        # decoder
+        recon = self.decoder(z_hat)            # (B, C, T, H, W)
+
+        # permute backwards to loader format
+        recon = recon.permute(0, 2, 1, 3, 4)   # (B,T,C,H,W)
+
+        return recon, attn
+    
+
+if __name__ == "__main__":
+    # Smoke test
+    model = MemoryAE(n_slots=2000)   # paper N
+    x = torch.randn(2, 16, 1, 128, 128)
+
+    # Control piece by piece
+    xp = x.permute(0,2,1,3,4)                           # (2,16,1,128,128) -> (2,1,16,128,128)
+    z = model.encoder(xp)
+    print("bottleneck:", z.shape)                       # should be (2, 16, 4, 16, 16)
+
+    z_hat, attn = model.memory(z)
+    print("z_hat:", z_hat.shape, "attn:", attn.shape)   # (2,16,4,16,16), (2,1024,2000)
+
+    recon, attn = model(x)
+    active_frac = (attn > 0).float().mean()
+    active_per_query = (attn > 0).float().sum(dim=-1).mean()
+    print(f"shrink_thres (lambda): {model.memory.shrink_thres}")
+    print(f"active slot fraction: {active_frac:.4f}")
+    print(f"avg active slots/query: {active_per_query:.1f} / {model.memory.n_slots}")

src/models/predictor.py

@@ -0,0 +1,88 @@
+"""
+Module for UNet based predictor.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class UNetPredictor(nn.Module):
+    """
+    U net based predictor model class.
+    """
+    
+    def __init__(self):
+        super().__init__()
+        
+        # Encoder blocks
+        self.enc1 = nn.Sequential(
+            nn.Conv2d(in_channels=15, out_channels=32, kernel_size=(3, 3), padding=1),
+            nn.GroupNorm(num_groups=8, num_channels=32),
+            nn.LeakyReLU()
+        )
+        self.enc2 = nn.Sequential(
+            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=(3, 3), padding=1),
+            nn.GroupNorm(num_groups=8, num_channels=64),
+            nn.LeakyReLU()
+        )
+        self.enc3 = nn.Sequential(
+            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=(3, 3), padding=1),
+            nn.GroupNorm(num_groups=8, num_channels=128),
+            nn.LeakyReLU()
+        )
+        self.bottleneck = nn.Sequential(
+            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=(3, 3), padding=1),
+            nn.GroupNorm(num_groups=8, num_channels=256),
+            nn.LeakyReLU()
+        )
+        
+        # Decoder blocks
+        self.up3 = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False)
+        self.dec3 = nn.Sequential(
+            nn.Conv2d(in_channels=384, out_channels=128, kernel_size=(3, 3), padding=1),
+            nn.GroupNorm(num_groups=8, num_channels=128),
+            nn.LeakyReLU()
+        )
+        self.up2 = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False)
+        self.dec2 = nn.Sequential(
+            nn.Conv2d(in_channels=192, out_channels=64, kernel_size=(3, 3), padding=1),
+            nn.GroupNorm(num_groups=8, num_channels=64),
+            nn.LeakyReLU()
+        )
+        self.up1 = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False)
+        self.dec1 = nn.Sequential(
+            nn.Conv2d(in_channels=96, out_channels=32, kernel_size=(3, 3), padding=1),
+            nn.GroupNorm(num_groups=8, num_channels=32),
+            nn.LeakyReLU()
+        )
+        
+        # Output layer
+        self.out = nn.Sequential(
+            nn.Conv2d(in_channels=32, out_channels=1, kernel_size=(3, 3), padding=1),
+            nn.Tanh()
+        )
+        
+        # Pooling layer
+        self.pool = nn.MaxPool2d(kernel_size=(2, 2), stride=2)
+
+    def forward(self, x: torch.Tensor):
+        # x: (B, 15, 1, H, W) -> squeeze/reshape -> (B, 15, H, W)
+        x = x.squeeze(2)                    # # (B,15,1,H,W) -> (B,15,H,W)
+        s1 = self.enc1(x)                   # (B,32,128,128) <- skip1
+        s2 = self.enc2(self.pool(s1))       # (B,64,64,64)   <- skip2
+        s3 = self.enc3(self.pool(s2))       # (B,128,32,32)  <- skip3
+        b  = self.bottleneck(self.pool(s3)) # (B,256,16,16)
+
+        d3 = self.dec3(torch.cat([self.up3(b),  s3], dim=1))   # cat→384 -> 128, (B,128,32,32)
+        d2 = self.dec2(torch.cat([self.up2(d3), s2], dim=1))   # cat→192 -> 64,  (B,64,64,64)
+        d1 = self.dec1(torch.cat([self.up1(d2), s1], dim=1))   # cat→96  -> 32,  (B,32,128,128)
+
+        return self.out(d1)     # (B,1,128,128)
+    
+
+if __name__ == "__main__":
+    model = UNetPredictor()
+    x = torch.randn(2, 15, 1, 128, 128)
+    out = model(x)
+    print(out.shape)   # expected: (2, 1, 128, 128)

src/training/losses.py

@@ -0,0 +1,92 @@
+"""
+Module for custom loss functions.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class MemAELoss(nn.Module):
+    """MSE reconstruction + entropy regularization on attention weights."""
+
+    def __init__(self, entropy_weight: float = 0.0002):
+        super().__init__()
+        self.entropy_weight = entropy_weight   # alpha
+        self.mse = nn.MSELoss()
+
+    def forward(self, recon, target, attn):
+        """
+        Args:
+            recon:  (B, T, C, H, W) reconstruction
+            target: (B, T, C, H, W) input
+            attn:   (B, n_queries, N) attention weights
+        Returns:
+            total_loss, (recon_loss, entropy_loss)  # ayrı logla
+        """
+        eps = 1e-12
+
+        # Reconstruction
+        recon_loss = self.mse(recon, target)
+
+        # Entropy: per-query entropy, then mean
+        # E = mean( -sum_i ( w_i * log(w_i + eps) ) )
+        entropy = (-(attn * torch.log(attn + eps)).sum(dim=-1)).mean()
+
+        # Sum
+        total = recon_loss + self.entropy_weight * entropy
+
+        return total, (recon_loss, entropy)
+    
+
+class PredictionLoss(nn.Module):
+    """Intensity (L2) + gradient loss for future frame prediction."""
+
+    def __init__(self, grad_weight: float = 1.0):
+        super().__init__()
+        self.grad_weight = grad_weight   # lambda_grad
+
+    def forward(self, pred, target):
+        """
+        Args:
+            pred:   (B, 1, H, W) predicted frame
+            target: (B, 1, H, W) ground truth frame
+        Returns:
+            total, (intensity, gradient)
+        """
+        # Intensity (L2)
+        intensity = F.mse_loss(pred, target)
+
+        # Gradient loss
+        ## Horizontal (x) gradient (last axis = W)
+        pred_dx = torch.abs(pred[:, :, :, 1:] - pred[:, :, :, :-1])
+        target_dx = torch.abs(target[:, :, :, 1:] - target[:, :, :, :-1])
+        
+        ## Vertical (y) gradient (the axis before last = H)
+        pred_dy = torch.abs(pred[:, :, 1:, :] - pred[:, :, :-1, :])
+        target_dy = torch.abs(target[:, :, 1:, :] - target[:, :, :-1, :])
+        
+        ## loss: gradient differences
+        gradient = F.l1_loss(pred_dx, target_dx) + F.l1_loss(pred_dy, target_dy)
+
+        # Total
+        total = intensity + self.grad_weight * gradient
+
+        return total, (intensity, gradient)
+
+
+if __name__ == "__main__":
+    # Smoke test
+    # loss_fn = MemAELoss()
+    # recon = torch.randn(2, 16, 1, 128, 128)
+    # target = torch.randn(2, 16, 1, 128, 128)
+    # attn = torch.softmax(torch.randn(2, 1024, 2000), dim=-1)   # valid distribution
+    # total, (rl, ent) = loss_fn(recon, target, attn)
+    # print(f"total: {total.item():.4f}, recon: {rl.item():.4f}, entropy: {ent.item():.4f}")
+
+    # Prediction loss smoke test
+    loss_pred = PredictionLoss()
+    pred = torch.randn(2, 1, 128, 128)
+    target = torch.randn(2, 1, 128, 128)
+    total, (inten, grad) = loss_pred(pred, target)
+    print(f"total: {total.item():.4f}, intensity: {inten.item():.4f}, gradient: {grad.item():.4f}")

src/training/trainer.py

@@ -0,0 +1,183 @@
+"""
+Module for pytorch training and validation functions.
+"""
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader
+from src.training.losses import MemAELoss, PredictionLoss
+
+
+def train_one_epoch(model: nn.Module, dataloader: DataLoader, criterion: nn.MSELoss, optimizer: optim.Optimizer, device: str) -> float:
+    """
+    Function to train the vanilla autoencoder model on a single epoch. Returns the average training loss.
+    """
+    
+    # Set the model on train mode
+    model.train()
+    running_loss = 0.0
+
+    # Iterate within dataloader
+    for tensors, labels in dataloader:
+        # Move the tensors and labels to device
+        tensors, labels = tensors.to(device), labels.to(device)
+        
+        # Core 5-step optimization
+        optimizer.zero_grad(set_to_none=True) # set_to_none=True to optimize memory allocation
+        outputs = model(tensors)
+        loss = criterion(outputs, tensors)
+        loss.backward()
+        optimizer.step()
+
+        running_loss += loss.item() * tensors.size(0)
+
+    return running_loss / len(dataloader.dataset)
+
+
+def validate(model: nn.Module, dataloader: DataLoader, criterion: nn.MSELoss, device: str) -> float:
+    """
+    Function to evaluate the vanilla autoencoder model. Returns the average validation loss.
+    """
+
+    # Set the model on eval mode
+    model.eval()
+    running_loss = 0.0
+
+    # Deactivate the gradients for memory optimization
+    # NOTE: inference_mode eliminates gradient overhead, making it faster than no_grad but we'll need the tensors for the future so, no_grad is safer to use
+    with torch.no_grad():
+        # Iterate within dataloader
+        for tensors, labels in dataloader:
+            # Move the tensors and labels to device
+            tensors, labels = tensors.to(device), labels.to(device)
+
+            outputs = model(tensors)
+            loss = criterion(outputs, tensors)
+
+            running_loss += loss.item() * tensors.size(0)
+
+    return running_loss / len(dataloader.dataset)
+
+
+def train_one_epoch_memae(model: nn.Module, dataloader: DataLoader, criterion: MemAELoss, optimizer: optim.Optimizer, device: str) -> tuple:
+    """
+    Function to train the model on a single epoch for memory augmented autoencoder model. Returns the average training loss.
+    """
+    
+    # Set the model on train mode
+    model.train()
+    running_total = 0.0
+    running_recon = 0.0
+    running_entropy = 0.0
+
+    # Iterate within dataloader
+    for tensors, labels in dataloader:
+        # Move the tensors and labels to device
+        tensors, labels = tensors.to(device), labels.to(device)
+        
+        # Core 5-step optimization
+        optimizer.zero_grad(set_to_none=True) # set_to_none=True to optimize memory allocation
+        recon, attn = model(tensors)
+        loss, (recon_loss, entropy) = criterion(recon, tensors, attn)
+        loss.backward()
+        optimizer.step()
+
+        # Scale using batch size
+        bs = tensors.size(0)
+        running_total += loss.item() * bs
+        running_recon += recon_loss.item() * bs
+        running_entropy += entropy.item() * bs
+
+    n = len(dataloader.dataset)
+    return running_total / n, running_recon / n, running_entropy / n
+
+
+def validate_memae(model: nn.Module, dataloader: DataLoader, criterion: MemAELoss, device: str) -> tuple:
+    """
+    Function to evaluate the memory augmented autoencoder model. Returns the average validation loss.
+    """
+
+    # Set the model on eval mode
+    model.eval()
+    running_total = 0.0
+    running_recon = 0.0
+    running_entropy = 0.0
+
+    # Deactivate the gradients for memory optimization
+    # NOTE: inference_mode eliminates gradient overhead, making it faster than no_grad but we'll need the tensors for the future so, no_grad is safer to use
+    with torch.no_grad():
+        # Iterate within dataloader
+        for tensors, labels in dataloader:
+            # Move the tensors and labels to device
+            tensors, labels = tensors.to(device), labels.to(device)
+
+            recon, attn = model(tensors)
+            loss, (recon_loss, entropy) = criterion(recon, tensors, attn)
+
+            # Scale using batch size
+            bs = tensors.size(0)
+            running_total += loss.item() * bs
+            running_recon += recon_loss.item() * bs
+            running_entropy += entropy.item() * bs
+
+    n = len(dataloader.dataset)
+    return running_total / n, running_recon / n, running_entropy / n
+
+
+def train_one_epoch_pred(model: nn.Module, dataloader: DataLoader, criterion: PredictionLoss, optimizer: optim.Optimizer, device: str) -> tuple:
+    """
+    Function to train our prediction model.
+    """
+    
+    model.train()
+    running_total = 0.0
+    running_intensity = 0.0
+    running_gradient = 0.0
+
+    for inputs, targets in dataloader:
+        inputs, targets = inputs.to(device), targets.to(device)
+
+        optimizer.zero_grad(set_to_none=True)
+        preds = model(inputs)                                   # (B,1,H,W), single tensor
+        loss, (intensity, gradient) = criterion(preds, targets)
+        loss.backward()
+        optimizer.step()
+
+        bs = inputs.size(0)
+        running_total += loss.item() * bs
+        running_intensity += intensity.item() * bs
+        running_gradient += gradient.item() * bs
+
+    n = len(dataloader.dataset)
+    return running_total / n, running_intensity / n, running_gradient / n
+
+
+def validate_pred(model: nn.Module, dataloader: DataLoader, criterion: PredictionLoss, device: str) -> tuple:
+    """
+    Function to evaluate the prediction model. Returns the average validation, intensity and gradient losses.
+    """
+
+    # Set the model on eval mode
+    model.eval()
+    running_total = 0.0
+    running_intensity = 0.0
+    running_gradient = 0.0
+
+    with torch.no_grad():
+        # Iterate within dataloader
+        for inputs, targets in dataloader:
+            # Move the tensors and labels to device
+            inputs, targets = inputs.to(device), targets.to(device)
+
+            preds = model(inputs)
+            loss, (intensity, gradient) = criterion(preds, targets)
+
+            # Scale using batch size
+            bs = inputs.size(0)
+            running_total += loss.item() * bs
+            running_intensity += intensity.item() * bs
+            running_gradient += gradient.item() * bs
+
+    n = len(dataloader.dataset)
+    return running_total / n, running_intensity / n, running_gradient / n