Deploy GeoVision Pro

.dockerignore

@@ -0,0 +1,8 @@
+**/node_modules
+**/dist
+**/__pycache__
+**/*.pyc
+**/.git
+**/.env
+**/models
+**/*.db

Dockerfile

@@ -0,0 +1,46 @@
+# GeoVision Pro — single container (frontend + backend in one image).
+# Used for Hugging Face Spaces (Docker SDK) and any one-URL deployment.
+# Build context must be the `geovision-pro/` directory (sees frontend/ + backend/).
+
+# --- Stage 1: build the React frontend ---
+FROM node:20-slim AS web
+WORKDIR /web
+COPY frontend/package.json ./
+RUN npm install
+COPY frontend/ ./
+RUN npm run build          # -> /web/dist
+
+# --- Stage 2: Python backend that also serves the built frontend ---
+FROM python:3.12-slim
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        libgl1 libglib2.0-0 \
+        tesseract-ocr tesseract-ocr-deu tesseract-ocr-eng \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY backend/requirements.txt .
+# CPU torch + torchvision (GeoCLIP needs torchvision); installed from the CPU
+# index first so the requirements step won't pull the heavy CUDA build.
+RUN pip install --no-cache-dir --index-url https://download.pytorch.org/whl/cpu \
+        torch==2.5.1 torchvision==0.20.1 \
+    && pip install --no-cache-dir -r requirements.txt
+
+COPY backend/app ./app
+COPY backend/sql ./sql
+# Bundle the compiled frontend so FastAPI serves it at "/"
+COPY --from=web /web/dist ./app/static
+
+# Hugging Face Spaces defaults: writable caches under /tmp, SQLite (no Postgres),
+# models downloaded lazily on first request, app on port 7860.
+ENV HF_HOME=/tmp/hf \
+    GEOVISION_DATABASE_URL=sqlite+aiosqlite:////tmp/geovision.db \
+    GEOVISION_MODEL_LAZY_LOAD=true \
+    GEOVISION_NOMINATIM_EMAIL="" \
+    PORT=7860
+# Picarta (GeoSpy-class API) turns on by adding a Space *secret* named
+# GEOVISION_PICARTA_API_TOKEN (Settings → Variables and secrets) — no code
+# change; pydantic-settings reads it from the environment at startup.
+
+EXPOSE 7860
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}"]

README.md

@@ -0,0 +1,36 @@
+---
+title: GeoVision Pro
+emoji: 🌍
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: false
+license: mit
+---
+
+# GeoVision Pro
+
+KI-Geolocation aus Bildern/Videos. Reihenfolge (verlässlichste Quelle zuerst):
+EXIF-GPS → Schildtext (OCR) → **Referenzgalerie** (Bild-Retrieval gegen deine
+eigenen Geo-Fotos) → **Picarta-API** (GeoSpy-Klasse, optional) → GeoCLIP →
+StreetCLIP-Kontext. Läuft als ein Container (FastAPI serviert die React-App + API).
+
+> Erster Analyse-Request lädt einmalig die Modelle (GeoCLIP + StreetCLIP) — das
+> dauert auf der kostenlosen CPU ein paar Minuten, danach sind sie gecached.
+
+## Genauer machen (optional)
+
+**Picarta einschalten (am nächsten an GeoSpy):**
+1. Kostenlosen Token holen: https://picarta.ai → Account → API.
+2. Im Space: *Settings → Variables and secrets → New secret* →
+   Name `GEOVISION_PICARTA_API_TOKEN`, Wert = dein Token → Save.
+3. Space neu starten (*Restart*). Treffer erscheinen dann als „Picarta-API".
+
+**Eigene Galerie („Training mit mehr Bildern"):**
+Im Panel **„Eigene Galerie"** in der App ein geotaggtes Foto hochladen und Ort
+angeben (Ortsname, Koordinaten oder per Foto-GPS) — die App erkennt diese Orte
+danach genauer. Je mehr Fotos, desto besser.
+> ⚠️ Auf einem kostenlosen Space ohne *persistent storage* gehen die Galerie-
+> Fotos beim Neustart/Rebuild verloren. Für dauerhaftes Speichern in den Space-
+> Settings **Persistent storage** aktivieren (legt `/data` dauerhaft an).

backend/Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.12-slim
+
+# System deps: OpenCV runtime libs + Tesseract OCR (German + English)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        libgl1 libglib2.0-0 \
+        tesseract-ocr tesseract-ocr-deu tesseract-ocr-eng \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+# Install CPU torch + torchvision wheels by default (torchvision is required by
+# GeoCLIP). Override with a CUDA base image for GPU. Installing them from the CPU
+# index first means the later `-r requirements.txt` won't pull the heavy CUDA build.
+RUN pip install --no-cache-dir --index-url https://download.pytorch.org/whl/cpu \
+        torch==2.5.1 torchvision==0.20.1 \
+    && pip install --no-cache-dir -r requirements.txt
+
+COPY app ./app
+COPY sql ./sql
+
+ENV GEOVISION_DEBUG=false
+EXPOSE 8000
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

backend/app/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

backend/app/config.py

@@ -0,0 +1,68 @@
+"""Application configuration loaded from environment variables."""
+from functools import lru_cache
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_prefix="GEOVISION_", extra="ignore")
+
+    # General
+    app_name: str = "GeoVision Pro API"
+    debug: bool = False
+    cors_origins: str = "*"  # comma separated
+
+    # Database
+    database_url: str = "postgresql+asyncpg://geovision:geovision@localhost:5432/geovision"
+
+    # Vision model
+    # StreetCLIP is purpose-built for geolocation but large (~600MB).
+    # Fallback to a small CLIP keeps the service runnable on modest hardware.
+    vision_model: str = "geolocal/StreetCLIP"
+    vision_fallback_model: str = "openai/clip-vit-base-patch32"
+    device: str = "auto"  # "auto" | "cpu" | "cuda"
+    model_lazy_load: bool = True
+
+    # GeoCLIP — predicts real GPS coordinates (GeoSpy-style). Optional: if the
+    # `geoclip` package/weights are missing, we fall back to StreetCLIP country
+    # inference. This is what lifts results from "country guess" to coordinates.
+    enable_geoclip: bool = True
+    geoclip_top_k: int = 5         # number of coordinate candidates to return
+    # Accuracy boosters (no training needed, cost a bit more CPU time):
+    geoclip_tta: bool = True       # evaluate original + mirrored view, fuse the gallery probabilities
+    geoclip_candidate_pool: int = 64  # gallery entries fused before picking the top_k
+    geoclip_country_rerank: bool = True  # down-weight GeoCLIP coords whose country contradicts StreetCLIP
+
+    # Picarta — commercial GeoSpy-class API. Closest thing to GeoSpy accuracy
+    # (often city/street level). Optional: needs a free API token. If no token
+    # is set, the pipeline silently skips it and uses the open models instead.
+    # Get a token at https://picarta.ai (free tier available).
+    enable_picarta: bool = True
+    picarta_api_token: str = ""    # set GEOVISION_PICARTA_API_TOKEN to enable
+    picarta_url: str = "https://picarta.ai/classify"
+    picarta_top_k: int = 3         # number of coordinate candidates to request
+
+    # External services
+    nominatim_url: str = "https://nominatim.openstreetmap.org"
+    nominatim_email: str = ""  # set to identify yourself per OSM usage policy
+    http_timeout: float = 20.0
+
+    # Optional features
+    # Reference gallery: a folder of YOUR OWN geotagged photos. We embed them
+    # once (cached on disk) and match new photos against them — real image
+    # retrieval, the way commercial tools pinpoint places. The MORE geotagged
+    # images you add, the more places it can recognise. This is the honest,
+    # free version of "training with more images". Empty path disables it.
+    # Default points at HF persistent storage (/data); if that is not writable
+    # (free tier), the service automatically falls back to a /tmp folder. Set to
+    # "" to disable the gallery entirely.
+    reference_dir: str = "/data/reference"
+    reference_min_similarity: float = 0.86  # cosine threshold to trust a match as a location
+    reference_use_top_k: int = 5            # nearest neighbours fused into the estimate
+    enable_ocr: bool = True        # requires the `tesseract` binary on the host
+    max_video_frames: int = 12     # frames sampled per video
+    upload_max_mb: int = 40
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()

backend/app/core/cache.py

@@ -0,0 +1,39 @@
+"""A tiny thread-safe in-memory LRU+TTL cache for geocoding and embeddings.
+
+Deliberately dependency-free. For multi-process deployments swap this for Redis;
+the call sites only use get()/set().
+"""
+import threading
+import time
+from collections import OrderedDict
+from typing import Any, Optional
+
+
+class TTLCache:
+    def __init__(self, maxsize: int = 1024, ttl: float = 3600.0) -> None:
+        self._data: "OrderedDict[str, tuple[float, Any]]" = OrderedDict()
+        self._maxsize = maxsize
+        self._ttl = ttl
+        self._lock = threading.Lock()
+
+    def get(self, key: str) -> Optional[Any]:
+        with self._lock:
+            item = self._data.get(key)
+            if item is None:
+                return None
+            ts, value = item
+            if time.time() - ts > self._ttl:
+                self._data.pop(key, None)
+                return None
+            self._data.move_to_end(key)
+            return value
+
+    def set(self, key: str, value: Any) -> None:
+        with self._lock:
+            self._data[key] = (time.time(), value)
+            self._data.move_to_end(key)
+            while len(self._data) > self._maxsize:
+                self._data.popitem(last=False)
+
+
+geocode_cache = TTLCache(maxsize=2048, ttl=24 * 3600)

backend/app/core/logging.py

@@ -0,0 +1,19 @@
+"""Central logging setup."""
+import logging
+import sys
+
+
+def configure_logging(debug: bool = False) -> None:
+    level = logging.DEBUG if debug else logging.INFO
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(logging.Formatter(
+        "%(asctime)s %(levelname)-7s %(name)s | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    ))
+    root = logging.getLogger()
+    root.handlers.clear()
+    root.addHandler(handler)
+    root.setLevel(level)
+    # Quiet noisy libraries
+    for noisy in ("httpx", "PIL", "urllib3"):
+        logging.getLogger(noisy).setLevel(logging.WARNING)

backend/app/database.py

@@ -0,0 +1,31 @@
+"""Async SQLAlchemy engine/session setup."""
+from collections.abc import AsyncGenerator
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase
+
+from .config import get_settings
+
+settings = get_settings()
+
+engine = create_async_engine(settings.database_url, echo=settings.debug, pool_pre_ping=True)
+SessionLocal = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+async def get_session() -> AsyncGenerator[AsyncSession, None]:
+    async with SessionLocal() as session:
+        yield session
+
+
+async def init_models() -> None:
+    """Create tables on startup if they do not exist (dev convenience).
+
+    For production use the SQL migration in sql/schema.sql or Alembic.
+    """
+    from . import models  # noqa: F401  (register models)
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)

backend/app/main.py

@@ -0,0 +1,54 @@
+"""GeoVision Pro — FastAPI application entrypoint."""
+import os
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+from .config import get_settings
+from .core.logging import configure_logging
+from .database import init_models
+from .routers import analyze, health, jobs, reference, reports
+
+settings = get_settings()
+configure_logging(settings.debug)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Create tables on startup (dev). In prod, prefer sql/schema.sql or Alembic.
+    await init_models()
+    yield
+
+
+app = FastAPI(title=settings.app_name, version="1.0.0", lifespan=lifespan)
+
+origins = ["*"] if settings.cors_origins.strip() == "*" else \
+    [o.strip() for o in settings.cors_origins.split(",") if o.strip()]
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(health.router, prefix="/api")
+app.include_router(analyze.router, prefix="/api")
+app.include_router(jobs.router, prefix="/api")
+app.include_router(reports.router, prefix="/api")
+app.include_router(reference.router, prefix="/api")
+
+
+# Serve the built React frontend if it was bundled into the image (single-container
+# deployment, e.g. Hugging Face Space). The /api/* routes and /docs are registered
+# above, so they take precedence over this catch-all mount. When no build is present
+# (pure API mode), expose a small JSON index instead.
+_STATIC_DIR = os.path.join(os.path.dirname(__file__), "static")
+if os.path.isdir(_STATIC_DIR):
+    app.mount("/", StaticFiles(directory=_STATIC_DIR, html=True), name="frontend")
+else:
+    @app.get("/")
+    async def root() -> dict:
+        return {"name": settings.app_name, "docs": "/docs", "health": "/api/health"}

backend/app/models.py

@@ -0,0 +1,49 @@
+"""ORM models — persisted analyses and their candidates."""
+from datetime import datetime, timezone
+
+from sqlalchemy import JSON, DateTime, Float, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from .database import Base
+
+
+def _utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+class Analysis(Base):
+    __tablename__ = "analyses"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_utcnow, index=True)
+    kind: Mapped[str] = mapped_column(String(16), default="image")  # image | batch | video
+    source_name: Mapped[str] = mapped_column(String(255), default="")
+
+    # Best location summary (nullable when not determinable from the image)
+    best_label: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    best_lat: Mapped[float | None] = mapped_column(Float, nullable=True)
+    best_lon: Mapped[float | None] = mapped_column(Float, nullable=True)
+    best_confidence: Mapped[float | None] = mapped_column(Float, nullable=True)
+    location_source: Mapped[str] = mapped_column(String(32), default="inference")  # exif | ocr | inference
+
+    # Full structured result (signals, weights, hierarchy, reference matches)
+    result: Mapped[dict] = mapped_column(JSON, default=dict)
+
+    candidates: Mapped[list["Candidate"]] = relationship(
+        back_populates="analysis", cascade="all, delete-orphan", order_by="Candidate.rank"
+    )
+
+
+class Candidate(Base):
+    __tablename__ = "candidates"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    analysis_id: Mapped[int] = mapped_column(ForeignKey("analyses.id", ondelete="CASCADE"), index=True)
+    rank: Mapped[int] = mapped_column(Integer)
+    label: Mapped[str] = mapped_column(String(255))
+    confidence: Mapped[float] = mapped_column(Float)
+    lat: Mapped[float | None] = mapped_column(Float, nullable=True)
+    lon: Mapped[float | None] = mapped_column(Float, nullable=True)
+    reasoning: Mapped[str] = mapped_column(Text, default="")
+
+    analysis: Mapped[Analysis] = relationship(back_populates="candidates")

backend/app/routers/analyze.py

@@ -0,0 +1,90 @@
+"""Analysis endpoints: single image, batch, and video."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ..config import get_settings
+from ..database import get_session
+from ..models import Analysis, Candidate
+from ..schemas import AnalysisResult
+from ..services import fusion
+
+router = APIRouter(prefix="/analyze", tags=["analyze"])
+settings = get_settings()
+
+_IMAGE_TYPES = {"image/jpeg", "image/png", "image/webp", "image/heic", "image/heif"}
+_VIDEO_TYPES = {"video/mp4", "video/quicktime", "video/x-msvideo"}
+
+
+async def _read_limited(file: UploadFile) -> bytes:
+    data = await file.read()
+    if len(data) > settings.upload_max_mb * 1024 * 1024:
+        raise HTTPException(413, f"Datei zu groß (> {settings.upload_max_mb} MB).")
+    return data
+
+
+async def _persist(session: AsyncSession, result: AnalysisResult) -> AnalysisResult:
+    best = result.candidates[0] if result.candidates else None
+    row = Analysis(
+        kind=result.kind, source_name=result.source_name,
+        best_label=best.label if best else None,
+        best_lat=best.lat if best else None,
+        best_lon=best.lon if best else None,
+        best_confidence=best.confidence if best else None,
+        location_source=result.location_source,
+        result=result.model_dump(mode="json"),
+    )
+    for c in result.candidates:
+        row.candidates.append(Candidate(
+            rank=c.rank, label=str(c.label), confidence=c.confidence,
+            lat=c.lat, lon=c.lon, reasoning=c.reasoning))
+    session.add(row)
+    await session.commit()
+    await session.refresh(row)
+    result.id = row.id
+    result.created_at = row.created_at
+    return result
+
+
+@router.post("/image", response_model=AnalysisResult)
+async def analyze_image(file: UploadFile = File(...), session: AsyncSession = Depends(get_session)):
+    if file.content_type not in _IMAGE_TYPES:
+        raise HTTPException(415, f"Bildformat nicht unterstützt: {file.content_type}")
+    data = await _read_limited(file)
+    try:
+        result = await fusion.analyze_image(data, source_name=file.filename or "")
+    except Exception as exc:
+        raise HTTPException(500, f"Analyse fehlgeschlagen: {exc}") from exc
+    return await _persist(session, result)
+
+
+@router.post("/batch", response_model=list[AnalysisResult])
+async def analyze_batch(files: list[UploadFile] = File(...),
+                        session: AsyncSession = Depends(get_session)):
+    if not files:
+        raise HTTPException(400, "Keine Dateien.")
+    results: list[AnalysisResult] = []
+    for file in files:
+        if file.content_type not in _IMAGE_TYPES:
+            continue
+        data = await _read_limited(file)
+        try:
+            res = await fusion.analyze_image(data, source_name=file.filename or "")
+            results.append(await _persist(session, res))
+        except Exception as exc:  # keep batch going
+            results.append(AnalysisResult(source_name=file.filename or "",
+                                          uncertainty=f"Fehler: {exc}"))
+    return results
+
+
+@router.post("/video", response_model=AnalysisResult)
+async def analyze_video(file: UploadFile = File(...), session: AsyncSession = Depends(get_session)):
+    if file.content_type not in _VIDEO_TYPES:
+        raise HTTPException(415, f"Videoformat nicht unterstützt: {file.content_type}")
+    data = await _read_limited(file)
+    try:
+        result = await fusion.analyze_video(data, source_name=file.filename or "")
+    except Exception as exc:
+        raise HTTPException(500, f"Videoanalyse fehlgeschlagen: {exc}") from exc
+    return await _persist(session, result)

backend/app/routers/health.py

@@ -0,0 +1,34 @@
+"""Health & model status endpoints."""
+from fastapi import APIRouter
+
+from ..config import get_settings
+from ..services import ocr, picarta, reference
+from ..services.geoengine import get_geo_engine
+from ..services.vision import get_engine
+
+router = APIRouter(tags=["system"])
+settings = get_settings()
+
+
+@router.get("/health")
+async def health() -> dict:
+    return {"status": "ok", "app": settings.app_name}
+
+
+@router.get("/status")
+async def status() -> dict:
+    engine = get_engine()
+    idx = reference.get_index()
+    geolocated = sum(1 for e in idx if e.get("lat") is not None)
+    return {
+        "model_configured": settings.vision_model,
+        "model_loaded": engine.loaded,
+        "model_in_use": engine.model_name or None,
+        "ocr_available": ocr.available(),
+        "picarta_enabled": picarta.available(),
+        "geoclip_enabled": get_geo_engine().available,
+        "reference_images": len(idx),
+        "reference_geolocated": geolocated,
+        "reference_dir": reference.active_dir() or None,
+        "device": settings.device,
+    }

backend/app/routers/jobs.py

@@ -0,0 +1,41 @@
+"""History / stored analyses."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import desc, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ..database import get_session
+from ..models import Analysis
+from ..schemas import AnalysisListItem, AnalysisResult
+
+router = APIRouter(prefix="/jobs", tags=["jobs"])
+
+
+@router.get("", response_model=list[AnalysisListItem])
+async def list_jobs(limit: int = 50, session: AsyncSession = Depends(get_session)):
+    rows = (await session.execute(
+        select(Analysis).order_by(desc(Analysis.created_at)).limit(min(limit, 200))
+    )).scalars().all()
+    return rows
+
+
+@router.get("/{job_id}", response_model=AnalysisResult)
+async def get_job(job_id: int, session: AsyncSession = Depends(get_session)):
+    row = await session.get(Analysis, job_id)
+    if not row:
+        raise HTTPException(404, "Analyse nicht gefunden.")
+    data = dict(row.result)
+    data["id"] = row.id
+    data["created_at"] = row.created_at
+    return AnalysisResult.model_validate(data)
+
+
+@router.delete("/{job_id}")
+async def delete_job(job_id: int, session: AsyncSession = Depends(get_session)):
+    row = await session.get(Analysis, job_id)
+    if not row:
+        raise HTTPException(404, "Analyse nicht gefunden.")
+    await session.delete(row)
+    await session.commit()
+    return {"deleted": job_id}

backend/app/routers/reference.py

@@ -0,0 +1,81 @@
+"""Reference gallery management: grow the app's knowledge with your own photos.
+
+This is the practical, free "train it with more images" path. Upload a geotagged
+photo (or give a place/coordinates) and it is embedded and matched against future
+uploads. Accuracy for places you cover improves immediately.
+"""
+from __future__ import annotations
+
+from fastapi import APIRouter, File, Form, HTTPException, UploadFile
+
+from ..config import get_settings
+from ..services import geocode, reference
+from ..services.exif import extract_gps
+
+router = APIRouter(prefix="/reference", tags=["reference"])
+settings = get_settings()
+
+_IMAGE_TYPES = {"image/jpeg", "image/png", "image/webp", "image/heic", "image/heif"}
+
+
+@router.get("/list")
+async def list_reference() -> dict:
+    entries = reference.list_entries()
+    return {
+        "reference_images": len(entries),
+        "reference_geolocated": sum(1 for e in entries if e["lat"] is not None),
+        "entries": entries[-50:],  # most recent (avoid huge payloads)
+    }
+
+
+@router.post("/reload")
+async def reload_reference() -> dict:
+    count = reference.reload()
+    entries = reference.list_entries()
+    return {"reference_images": count,
+            "reference_geolocated": sum(1 for e in entries if e["lat"] is not None)}
+
+
+@router.post("/add")
+async def add_reference(
+    file: UploadFile = File(...),
+    lat: float | None = Form(None),
+    lon: float | None = Form(None),
+    place: str | None = Form(None),
+) -> dict:
+    """Add one photo to the gallery. Location is taken from (in order):
+    explicit lat/lon → a place name (geocoded) → the photo's own EXIF GPS.
+    """
+    if file.content_type not in _IMAGE_TYPES:
+        raise HTTPException(415, f"Bildformat nicht unterstützt: {file.content_type}")
+    data = await file.read()
+    if len(data) > settings.upload_max_mb * 1024 * 1024:
+        raise HTTPException(413, f"Datei zu groß (> {settings.upload_max_mb} MB).")
+
+    resolved_lat, resolved_lon, how = lat, lon, "Koordinaten"
+    if resolved_lat is None or resolved_lon is None:
+        if place and place.strip():
+            hits = await geocode.forward(place.strip(), limit=1)
+            if not hits:
+                raise HTTPException(422, f"Ort „{place}“ konnte nicht gefunden werden.")
+            resolved_lat, resolved_lon, how = hits[0]["lat"], hits[0]["lon"], f"Ort „{place}“"
+        else:
+            gps = extract_gps(data)
+            if gps.get("lat") is None or gps.get("lon") is None:
+                raise HTTPException(
+                    422,
+                    "Kein Standort angegeben. Gib Koordinaten oder einen Ort an, "
+                    "oder lade ein Foto mit GPS-Metadaten hoch.",
+                )
+            resolved_lat, resolved_lon, how = gps["lat"], gps["lon"], "EXIF-GPS des Fotos"
+
+    if not (-90 <= resolved_lat <= 90 and -180 <= resolved_lon <= 180):
+        raise HTTPException(422, "Ungültige Koordinaten.")
+
+    try:
+        result = reference.add_image(data, resolved_lat, resolved_lon,
+                                     name_hint=file.filename or "")
+    except Exception as exc:
+        raise HTTPException(500, f"Konnte nicht hinzufügen: {exc}") from exc
+    result.update({"lat": resolved_lat, "lon": resolved_lon, "source": how})
+    return result

backend/app/routers/reports.py

@@ -0,0 +1,48 @@
+"""Report export endpoints (PDF / CSV / JSON) for a stored analysis."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import Response
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ..database import get_session
+from ..models import Analysis
+from ..schemas import AnalysisResult
+from ..services import report
+
+router = APIRouter(prefix="/report", tags=["report"])
+
+
+async def _load(job_id: int, session: AsyncSession) -> AnalysisResult:
+    row = await session.get(Analysis, job_id)
+    if not row:
+        raise HTTPException(404, "Analyse nicht gefunden.")
+    data = dict(row.result)
+    data["id"] = row.id
+    data["created_at"] = row.created_at
+    return AnalysisResult.model_validate(data)
+
+
+@router.get("/{job_id}.json")
+async def report_json(job_id: int, session: AsyncSession = Depends(get_session)):
+    result = await _load(job_id, session)
+    return Response(report.to_json_bytes(result), media_type="application/json",
+                    headers={"Content-Disposition": f'attachment; filename="geovision_{job_id}.json"'})
+
+
+@router.get("/{job_id}.csv")
+async def report_csv(job_id: int, session: AsyncSession = Depends(get_session)):
+    result = await _load(job_id, session)
+    return Response(report.to_csv_bytes(result), media_type="text/csv",
+                    headers={"Content-Disposition": f'attachment; filename="geovision_{job_id}.csv"'})
+
+
+@router.get("/{job_id}.pdf")
+async def report_pdf(job_id: int, session: AsyncSession = Depends(get_session)):
+    result = await _load(job_id, session)
+    try:
+        pdf = report.to_pdf_bytes(result)
+    except Exception as exc:
+        raise HTTPException(500, f"PDF-Erzeugung fehlgeschlagen: {exc}") from exc
+    return Response(pdf, media_type="application/pdf",
+                    headers={"Content-Disposition": f'attachment; filename="geovision_{job_id}.pdf"'})

backend/app/schemas.py

@@ -0,0 +1,83 @@
+"""Pydantic response/request schemas."""
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class GpsInfo(BaseModel):
+    has_gps: bool = False
+    lat: Optional[float] = None
+    lon: Optional[float] = None
+    altitude: Optional[float] = None
+    timestamp: Optional[str] = None
+    camera: Optional[str] = None
+    address: Optional[str] = None
+
+
+class SignalScore(BaseModel):
+    label: str
+    score: float
+
+
+class SignalGroup(BaseModel):
+    """One visual-analysis category with its top zero-shot matches."""
+    name: str                 # e.g. "Landschaft", "Architektur"
+    top: list[SignalScore]
+    weight: float             # normalized contribution 0..1
+
+
+class LocationCandidate(BaseModel):
+    rank: int
+    label: str
+    confidence: float
+    lat: Optional[float] = None
+    lon: Optional[float] = None
+    reasoning: str = ""
+
+
+class Hierarchy(BaseModel):
+    continent: Optional[str] = None
+    country: Optional[str] = None
+    region: Optional[str] = None
+    city: Optional[str] = None
+    district: Optional[str] = None
+    # Honest note about which levels could not be derived
+    note: str = ""
+
+
+class ReferenceMatch(BaseModel):
+    name: str
+    similarity: float
+    lat: Optional[float] = None
+    lon: Optional[float] = None
+
+
+class AnalysisResult(BaseModel):
+    id: Optional[int] = None
+    created_at: Optional[datetime] = None
+    kind: str = "image"
+    source_name: str = ""
+
+    gps: GpsInfo = GpsInfo()
+    location_source: str = "inference"   # exif | ocr | reference | picarta | geoclip | inference
+    hierarchy: Hierarchy = Hierarchy()
+    candidates: list[LocationCandidate] = []
+    signals: list[SignalGroup] = []
+    ocr_text: str = ""
+    reference_matches: list[ReferenceMatch] = []
+    uncertainty: str = ""
+    model_used: str = ""
+
+
+class AnalysisListItem(BaseModel):
+    id: int
+    created_at: datetime
+    kind: str
+    source_name: str
+    best_label: Optional[str]
+    best_confidence: Optional[float]
+    location_source: str
+
+    class Config:
+        from_attributes = True

backend/app/services/exif.py

@@ -0,0 +1,77 @@
+"""EXIF / GPS extraction from image bytes — the only exact location source."""
+from __future__ import annotations
+
+import io
+from typing import Optional
+
+from PIL import Image, ExifTags
+
+# Register HEIC support if pillow-heif is available.
+try:  # pragma: no cover - optional dependency
+    import pillow_heif
+
+    pillow_heif.register_heif_opener()
+    HEIC_SUPPORTED = True
+except Exception:  # pragma: no cover
+    HEIC_SUPPORTED = False
+
+_GPS_TAG = next((k for k, v in ExifTags.TAGS.items() if v == "GPSInfo"), 34853)
+_GPS_KEYS = {v: k for k, v in ExifTags.GPSTAGS.items()}
+
+
+def _to_degrees(value) -> Optional[float]:
+    try:
+        d, m, s = value
+        return float(d) + float(m) / 60.0 + float(s) / 3600.0
+    except Exception:
+        return None
+
+
+def open_image(data: bytes) -> Image.Image:
+    """Open arbitrary supported image bytes as RGB."""
+    img = Image.open(io.BytesIO(data))
+    return img.convert("RGB")
+
+
+def extract_gps(data: bytes) -> dict:
+    """Return a dict with GPS + basic camera metadata. Never raises."""
+    out: dict = {"has_gps": False, "lat": None, "lon": None,
+                 "altitude": None, "timestamp": None, "camera": None}
+    try:
+        img = Image.open(io.BytesIO(data))
+        exif = img.getexif()
+        if not exif:
+            return out
+
+        make = exif.get(next((k for k, v in ExifTags.TAGS.items() if v == "Make"), None))
+        model = exif.get(next((k for k, v in ExifTags.TAGS.items() if v == "Model"), None))
+        if make or model:
+            out["camera"] = " ".join(str(x).strip() for x in (make, model) if x)
+        dto = exif.get(next((k for k, v in ExifTags.TAGS.items() if v == "DateTimeOriginal"), None))
+        if dto:
+            out["timestamp"] = str(dto)
+
+        gps = exif.get_ifd(_GPS_TAG) if hasattr(exif, "get_ifd") else None
+        if not gps:
+            return out
+
+        lat = _to_degrees(gps.get(_GPS_KEYS.get("GPSLatitude")))
+        lon = _to_degrees(gps.get(_GPS_KEYS.get("GPSLongitude")))
+        lat_ref = gps.get(_GPS_KEYS.get("GPSLatitudeRef"))
+        lon_ref = gps.get(_GPS_KEYS.get("GPSLongitudeRef"))
+        if lat is not None and lon is not None:
+            if lat_ref in ("S", b"S"):
+                lat = -lat
+            if lon_ref in ("W", b"W"):
+                lon = -lon
+            out.update(has_gps=True, lat=round(lat, 6), lon=round(lon, 6))
+
+        alt = gps.get(_GPS_KEYS.get("GPSAltitude"))
+        if alt is not None:
+            try:
+                out["altitude"] = round(float(alt), 1)
+            except Exception:
+                pass
+    except Exception:
+        return out
+    return out

backend/app/services/fusion.py

@@ -0,0 +1,461 @@
+"""Fusion: combine EXIF, vision signals, OCR and geocoding into one ranked result.
+
+Decision order for the *location* (most reliable first):
+  1. EXIF GPS            -> exact, location_source="exif"
+  2. OCR -> geocoded     -> real place from a readable sign, location_source="ocr"
+  3. Reference retrieval -> strong cosine match to YOUR geotagged gallery,
+                            location_source="reference" (grows with added images)
+  4. Picarta API         -> commercial GeoSpy-class coordinates (if a token is
+                            set), location_source="picarta"
+  5. GeoCLIP             -> predicted GPS coordinates (GeoSpy-style, open model),
+                            reverse-geocoded to place names, location_source="geoclip"
+  6. CLIP/StreetCLIP     -> country/region inference, location_source="inference"
+
+City / district from (5) and (6) are model estimates and are labelled as such in
+the hierarchy note. (1)/(2) provide exact/real places; (3) is as good as your
+gallery; (4) is external. Every model-based source is optional and the pipeline
+degrades cleanly to the next one if it is unavailable.
+"""
+from __future__ import annotations
+
+import asyncio
+from math import asin, cos, radians, sin, sqrt
+
+from PIL import Image
+
+from ..schemas import (AnalysisResult, GpsInfo, Hierarchy, LocationCandidate,
+                       ReferenceMatch, SignalGroup, SignalScore)
+from . import geocode, ocr, picarta, reference
+from .exif import extract_gps, open_image
+from .geoengine import get_geo_engine
+from .labels import (COUNTRY_PROMPT, COUNTRY_NAMES, COUNTRY_TO_CONTINENT,
+                     REGION_PROMPT, REGIONS, SIGNAL_GROUPS)
+from .vision import get_engine
+
+
+def _haversine_km(a: tuple[float, float], b: tuple[float, float]) -> float:
+    """Great-circle distance in km between two (lat, lon) points."""
+    lat1, lon1, lat2, lon2 = map(radians, (a[0], a[1], b[0], b[1]))
+    dlat, dlon = lat2 - lat1, lon2 - lon1
+    h = sin(dlat / 2) ** 2 + cos(lat1) * cos(lat2) * sin(dlon / 2) ** 2
+    return 2 * 6371.0 * asin(sqrt(h))
+
+
+def _short_label(addr: dict, display: str) -> str:
+    """Compact human label from a reverse-geocoded address."""
+    city = (addr.get("city") or addr.get("town") or addr.get("village")
+            or addr.get("municipality") or addr.get("county"))
+    region = addr.get("state") or addr.get("region")
+    country = addr.get("country")
+    parts = [p for p in (city, region, country) if p]
+    return ", ".join(parts) if parts else (display or "")
+
+
+def _analyze_signals(image: Image.Image) -> tuple[list[SignalGroup], dict]:
+    """Run each visual-analysis group; weight = top score, normalized across groups."""
+    engine = get_engine()
+    groups: list[SignalGroup] = []
+    tops: dict[str, tuple[str, float]] = {}
+    raw_weights: dict[str, float] = {}
+    for group_name, mapping in SIGNAL_GROUPS.items():
+        labels = list(mapping.keys())
+        prompts = list(mapping.values())
+        # zero_shot uses a template; here prompts are full sentences already
+        ranked = engine.zero_shot(image, prompts, template="{}", top_k=3)
+        prompt_to_label = {v: k for k, v in mapping.items()}
+        top = [SignalScore(label=prompt_to_label.get(p, p), score=round(s, 4)) for p, s in ranked]
+        groups.append(SignalGroup(name=group_name, top=top, weight=0.0))
+        if top:
+            tops[group_name] = (top[0].label, top[0].score)
+            raw_weights[group_name] = top[0].score
+    total = sum(raw_weights.values()) or 1.0
+    for g in groups:
+        g.weight = round(raw_weights.get(g.name, 0.0) / total, 3)
+    return groups, tops
+
+
+def _reasoning_from_signals(tops: dict, country: str) -> str:
+    bits = []
+    if "Landschaft" in tops:
+        bits.append(f"Landschaft ähnelt „{tops['Landschaft'][0]}“")
+    if "Architektur" in tops:
+        bits.append(f"Architektur weist auf „{tops['Architektur'][0]}“")
+    if "Infrastruktur" in tops:
+        bits.append(f"Infrastruktur passt zu „{tops['Infrastruktur'][0]}“")
+    if "Klima" in tops:
+        bits.append(f"Klima-Hinweise: „{tops['Klima'][0]}“")
+    joined = "; ".join(bits)
+    return f"{joined} → konsistent mit {country}." if joined else f"Modellähnlichkeit zu {country}."
+
+
+async def analyze_image(data: bytes, source_name: str = "") -> AnalysisResult:
+    image = open_image(data)
+    engine = get_engine()
+    geo = get_geo_engine()
+
+    # --- visual signals + coordinate prediction (CPU/GPU bound -> thread) ---
+    def _vision():
+        groups, tops = _analyze_signals(image)
+        countries = engine.zero_shot(image, COUNTRY_NAMES, template=COUNTRY_PROMPT, top_k=10)
+        region = None
+        if countries:
+            regs = REGIONS.get(countries[0][0])
+            if regs:
+                ranked = engine.zero_shot(image, regs, template=REGION_PROMPT, top_k=1)
+                if ranked:
+                    # strip the appended ", Country" for display
+                    region = ranked[0][0].split(",")[0]
+        img_vec = engine.embed_image(image)
+        geo_preds = geo.predict(image)  # [(lat, lon, prob), ...] or [] if unavailable
+        return groups, tops, countries, region, img_vec, geo_preds
+
+    groups, tops, countries, inferred_region, img_vec, geo_preds = await asyncio.to_thread(_vision)
+
+    # --- EXIF GPS ---
+    gps_raw = extract_gps(data)
+    gps = GpsInfo(**{k: gps_raw.get(k) for k in
+                     ("has_gps", "lat", "lon", "altitude", "timestamp", "camera")})
+
+    # --- OCR (optional) ---
+    ocr_text = ""
+    ocr_places: list[dict] = []
+    if ocr.available():
+        ocr_text = await asyncio.to_thread(ocr.read_text, image)
+        for q in ocr.candidate_queries(ocr_text):
+            hits = await geocode.forward(q, limit=2)
+            ocr_places.extend(hits)
+        # de-dup by rounded coords, keep most important
+        seen = set()
+        uniq = []
+        for p in sorted(ocr_places, key=lambda x: x["importance"], reverse=True):
+            key = (round(p["lat"], 3), round(p["lon"], 3))
+            if key in seen:
+                continue
+            seen.add(key)
+            uniq.append(p)
+        ocr_places = uniq[:5]
+
+    # --- Picarta (optional external GeoSpy-class API; only if a token is set) ---
+    picarta_preds = await picarta.predict(data)
+
+    # --- reference gallery: look-alikes (display) + retrieval geolocation ---
+    ref_matches = [ReferenceMatch(**m) for m in reference.match(img_vec, top_k=5)]
+    ref_geo = reference.geolocate(img_vec)  # None unless a strong geotagged match
+
+    # --- decide location source + hierarchy + candidates ---
+    hierarchy = Hierarchy()
+    candidates: list[LocationCandidate] = []
+    location_source = "inference"
+    uncertainty = ""
+
+    if gps.has_gps:
+        location_source = "exif"
+        rev = await geocode.reverse(gps.lat, gps.lon)
+        addr = (rev or {}).get("address", {})
+        gps.address = (rev or {}).get("display", "")
+        hierarchy = Hierarchy(
+            continent=None,
+            country=addr.get("country"),
+            region=addr.get("state") or addr.get("region"),
+            city=addr.get("city") or addr.get("town") or addr.get("village"),
+            district=addr.get("suburb") or addr.get("city_district"),
+            note="Exakt aus GPS-Metadaten.",
+        )
+        candidates.append(LocationCandidate(
+            rank=1, label=gps.address or f"{gps.lat:.5f}, {gps.lon:.5f}",
+            confidence=0.99, lat=gps.lat, lon=gps.lon,
+            reasoning="Exakte GPS-Koordinaten aus den EXIF-Metadaten des Fotos.",
+        ))
+        uncertainty = "Sehr gering — Standort stammt direkt aus GPS-Metadaten."
+
+    elif ocr_places:
+        location_source = "ocr"
+        top = ocr_places[0]
+        rev = await geocode.reverse(top["lat"], top["lon"])
+        addr = (rev or {}).get("address", {})
+        hierarchy = Hierarchy(
+            country=addr.get("country"),
+            region=addr.get("state") or addr.get("region"),
+            city=addr.get("city") or addr.get("town") or addr.get("village"),
+            district=addr.get("suburb") or addr.get("city_district"),
+            note="Aus lesbarem Text im Bild (Schild) abgeleitet und geocodiert.",
+        )
+        for i, p in enumerate(ocr_places, start=1):
+            short = ", ".join(p["display"].split(",")[:2])
+            candidates.append(LocationCandidate(
+                rank=i, label=short or p["display"],
+                confidence=round(min(0.9, 0.4 + p["importance"]), 3),
+                lat=p["lat"], lon=p["lon"],
+                reasoning="Aus erkanntem Schild-/Ortstext per Geocoding gefunden.",
+            ))
+        uncertainty = "Mittel — abhängig davon, ob der erkannte Text wirklich der Aufnahmeort ist."
+
+    elif ref_geo:
+        # --- Reference retrieval: strong match to YOUR geotagged gallery ----
+        location_source = "reference"
+        rev = await geocode.reverse(ref_geo["lat"], ref_geo["lon"])
+        addr = (rev or {}).get("address", {})
+        sim = ref_geo["similarity"]
+        hierarchy = Hierarchy(
+            continent=COUNTRY_TO_CONTINENT.get(addr.get("country")) if addr.get("country") else None,
+            country=addr.get("country"),
+            region=addr.get("state") or addr.get("region"),
+            city=addr.get("city") or addr.get("town") or addr.get("village") or addr.get("municipality"),
+            district=addr.get("suburb") or addr.get("city_district"),
+            note=f"Aus Bild-Retrieval gegen deine eigene Referenzgalerie "
+                 f"({ref_geo['n']} ähnliche Geo-Fotos, beste Ähnlichkeit {sim:.2f}). "
+                 "Genauigkeit hängt davon ab, wie nah deine Referenzbilder am Aufnahmeort liegen.",
+        )
+        for i, m in enumerate(ref_geo["matches"], start=1):
+            candidates.append(LocationCandidate(
+                rank=i,
+                label=_short_label(addr, (rev or {}).get("display", "")) if i == 1
+                      else f"{m['lat']:.4f}, {m['lon']:.4f} ({m['name']})",
+                confidence=round(min(0.99, m["similarity"]), 3),
+                lat=m["lat"], lon=m["lon"],
+                reasoning=f"Ähnlich zu Referenzbild „{m['name']}“ "
+                          f"(Kosinus-Ähnlichkeit {m['similarity']:.2f}).",
+            ))
+        uncertainty = (
+            f"Niedrig–mittel — Treffer in deiner Referenzgalerie (Ähnlichkeit {sim:.2f}). "
+            "Je näher ein Referenzfoto am echten Ort liegt, desto genauer."
+            if sim >= 0.92 else
+            f"Mittel — moderater Galerie-Treffer (Ähnlichkeit {sim:.2f}). "
+            "Mehr/nähere Referenzfotos verbessern das Ergebnis."
+        )
+
+    elif picarta_preds:
+        # --- Picarta: commercial GeoSpy-class API (token set) ---------------
+        location_source = "picarta"
+        top = picarta_preds[0]
+        rev = await geocode.reverse(top["lat"], top["lon"])
+        addr = (rev or {}).get("address", {})
+        country = top.get("country") or addr.get("country")
+        city = top.get("city") or addr.get("city") or addr.get("town") or addr.get("village")
+        hierarchy = Hierarchy(
+            continent=COUNTRY_TO_CONTINENT.get(country) if country else None,
+            country=country,
+            region=top.get("province") or addr.get("state") or addr.get("region"),
+            city=city,
+            district=addr.get("suburb") or addr.get("city_district"),
+            note="Von der Picarta-API (GeoSpy-Klasse) vorhergesagt — externe "
+                 "Bild-Geolokalisierung, oft stadt-/straßengenau. Koordinaten sind "
+                 "eine Schätzung des Anbieters, kein GPS.",
+        )
+        for i, p in enumerate(picarta_preds, start=1):
+            parts = [x for x in (p.get("city"), p.get("province"), p.get("country")) if x]
+            label = ", ".join(parts) or f"{p['lat']:.4f}, {p['lon']:.4f}"
+            candidates.append(LocationCandidate(
+                rank=i, label=label,
+                confidence=round(min(0.99, p.get("confidence", 0.0)), 3),
+                lat=p["lat"], lon=p["lon"],
+                reasoning="Picarta-API-Vorhersage (GeoSpy-Klasse).",
+            ))
+        uncertainty = ("Niedrig–mittel — Picarta-API (GeoSpy-Klasse), häufig stadt-/"
+                       "straßengenau. Externe Schätzung, kein GPS.")
+
+    elif geo_preds:
+        # --- GeoCLIP: real coordinate prediction (GeoSpy-style) -------------
+        location_source = "geoclip"
+        revs = []
+        for lat, lon, _ in geo_preds:
+            rev = await geocode.reverse(lat, lon)
+            revs.append(rev or {})
+        sc = countries[0][0] if countries else None
+
+        # StreetCLIP cross-check: down-weight GeoCLIP coordinates whose country
+        # contradicts StreetCLIP's country guess (catches gross "wrong country/
+        # continent" misses). Uses ISO codes so it is language-agnostic. One
+        # extra (cached) forward-geocode resolves StreetCLIP's top country code.
+        reranked = False
+        if settings.geoclip_country_rerank and sc:
+            sc_hits = await geocode.forward(sc, limit=1)
+            sc_code = (sc_hits[0].get("country_code") if sc_hits else None)
+            if sc_code:
+                scored = []
+                for (lat, lon, p), rev in zip(geo_preds, revs):
+                    code = (rev.get("address", {}) or {}).get("country_code")
+                    boost = 1.0 if code == sc_code else 0.4  # penalise disagreement
+                    scored.append((p * boost, lat, lon, p, rev))
+                scored.sort(key=lambda t: t[0], reverse=True)
+                geo_preds = [(lat, lon, p) for _, lat, lon, p, _ in scored]
+                revs = [rev for *_, rev in scored]
+                reranked = True
+
+        top_addr = revs[0].get("address", {})
+        hierarchy = Hierarchy(
+            continent=COUNTRY_TO_CONTINENT.get(top_addr.get("country")) if top_addr.get("country") else None,
+            country=top_addr.get("country"),
+            region=top_addr.get("state") or top_addr.get("region"),
+            city=top_addr.get("city") or top_addr.get("town") or top_addr.get("village")
+                 or top_addr.get("municipality"),
+            district=top_addr.get("suburb") or top_addr.get("city_district"),
+            note="Aus GeoCLIP-Koordinatenvorhersage (mit TTA-Mehrfachauswertung) "
+                 "rückwärts-geocodiert. Dies ist eine Modell-Schätzung der Koordinaten "
+                 "(kein GPS); die Stadt-/Stadtteil-Ebene kann ungenau sein."
+                 + (f" Per StreetCLIP-Ländercheck bestätigt/neu sortiert ({sc})." if reranked
+                    else (f" StreetCLIP-Kontext nennt {sc}." if sc else "")),
+        )
+        total = sum(p for _, _, p in geo_preds) or 1.0
+        for i, ((lat, lon, p), rev) in enumerate(zip(geo_preds, revs), start=1):
+            addr = rev.get("address", {})
+            label = _short_label(addr, rev.get("display", "")) or f"{lat:.4f}, {lon:.4f}"
+            candidates.append(LocationCandidate(
+                rank=i, label=label, confidence=round(p / total, 3),
+                lat=lat, lon=lon,
+                reasoning="GeoCLIP-Koordinatenvorhersage (approx.). "
+                          + _reasoning_from_signals(tops, hierarchy.country or "dem Land"),
+            ))
+        spread = (_haversine_km((geo_preds[0][0], geo_preds[0][1]),
+                                (geo_preds[1][0], geo_preds[1][1]))
+                  if len(geo_preds) > 1 else 0.0)
+        uncertainty = (
+            f"GeoCLIP-Koordinaten. Streuung Top-1↔Top-2: ~{spread:.0f} km. "
+            + ("Vorhersagen liegen nah beieinander → höhere Zuversicht. " if spread < 25
+               else "Vorhersagen streuen → geringere Zuversicht. ")
+            + (f"Mit StreetCLIP-Ländercheck abgeglichen ({sc}). " if reranked
+               else (f"StreetCLIP-Kontext nennt {sc}. " if sc else ""))
+            + "Koordinaten sind eine Modell-Schätzung, kein GPS."
+        )
+
+    else:
+        location_source = "inference"
+        top_country = countries[0][0] if countries else None
+        region_note = " Region ist eine grobe Inferenz." if inferred_region else ""
+        hierarchy = Hierarchy(
+            continent=COUNTRY_TO_CONTINENT.get(top_country) if top_country else None,
+            country=top_country,
+            region=inferred_region, city=None, district=None,
+            note="Stadt/Stadtteil sind aus dem Bildinhalt nicht zuverlässig bestimmbar "
+                 "(kein GPS, kein lesbares Ortsschild). Es wird ehrlich nur Land/Region geschätzt."
+                 + region_note,
+        )
+        # Geocode centroids of the top countries for map markers (limit network calls)
+        coords: dict[str, tuple[float, float]] = {}
+        for name, _ in countries[:5]:
+            hits = await geocode.forward(name, limit=1)
+            if hits:
+                coords[name] = (hits[0]["lat"], hits[0]["lon"])
+        for i, (name, score) in enumerate(countries, start=1):
+            latlon = coords.get(name)
+            candidates.append(LocationCandidate(
+                rank=i, label=name, confidence=round(score, 3),
+                lat=latlon[0] if latlon else None,
+                lon=latlon[1] if latlon else None,
+                reasoning=_reasoning_from_signals(tops, name),
+            ))
+        spread = countries[0][1] - countries[1][1] if len(countries) > 1 else 0.0
+        uncertainty = ("Hoch — reine Bildinferenz auf Land-/Regionsebene. "
+                       f"Abstand Top-1 zu Top-2: {spread:.2f}. Kein Stadt-/Adress-Treffer.")
+
+    return AnalysisResult(
+        kind="image", source_name=source_name,
+        gps=gps, location_source=location_source, hierarchy=hierarchy,
+        candidates=candidates[:10], signals=groups, ocr_text=ocr_text,
+        reference_matches=ref_matches, uncertainty=uncertainty,
+        model_used=engine.model_name or "(lazy)",
+    )
+
+
+async def analyze_video(data: bytes, source_name: str = "") -> AnalysisResult:
+    """Sample keyframes, analyse each, aggregate country votes."""
+    from .video import extract_keyframes
+
+    frames = await asyncio.to_thread(extract_keyframes, data)
+    if not frames:
+        res = AnalysisResult(kind="video", source_name=source_name,
+                             uncertainty="Keine Frames extrahierbar.")
+        return res
+
+    engine = get_engine()
+    geo = get_geo_engine()
+
+    def _analyze():
+        agg: dict[str, float] = {}
+        pts: list[tuple[float, float, float]] = []
+        for fr in frames:
+            for name, score in engine.zero_shot(fr, COUNTRY_NAMES, template=COUNTRY_PROMPT, top_k=5):
+                agg[name] = agg.get(name, 0.0) + score
+            preds = geo.predict(fr, top_k=1)
+            if preds:
+                pts.append(preds[0])
+        return agg, pts
+
+    agg, pts = await asyncio.to_thread(_analyze)
+
+    # --- GeoCLIP path: aggregate frame coordinates by their medoid ----------
+    if pts:
+        def _cost(i: int) -> float:
+            return sum(_haversine_km((pts[i][0], pts[i][1]), (q[0], q[1])) for q in pts)
+
+        medoid = min(range(len(pts)), key=_cost)
+        mlat, mlon, _ = pts[medoid]
+        spread = sum(_haversine_km((mlat, mlon), (q[0], q[1])) for q in pts) / len(pts)
+        rev = await geocode.reverse(mlat, mlon)
+        addr = (rev or {}).get("address", {})
+
+        uniq: dict[tuple[float, float], tuple[float, float, float]] = {}
+        for lat, lon, p in pts:
+            key = (round(lat, 2), round(lon, 2))
+            if key not in uniq or p > uniq[key][2]:
+                uniq[key] = (lat, lon, p)
+        ordered = sorted(uniq.values(),
+                         key=lambda q: _haversine_km((mlat, mlon), (q[0], q[1])))[:10]
+        candidates = []
+        for i, (lat, lon, p) in enumerate(ordered, start=1):
+            label = f"{lat:.4f}, {lon:.4f}"
+            if i <= 5:  # limit reverse-geocoding network calls
+                r = await geocode.reverse(lat, lon)
+                label = _short_label((r or {}).get("address", {}),
+                                     (r or {}).get("display", "")) or label
+            candidates.append(LocationCandidate(
+                rank=i, label=label, confidence=round(p, 3), lat=lat, lon=lon,
+                reasoning=f"GeoCLIP-Vorhersage aus Videoframe "
+                          f"(~{_haversine_km((mlat, mlon), (lat, lon)):.0f} km vom Zentrum).",
+            ))
+        return AnalysisResult(
+            kind="video", source_name=source_name, location_source="geoclip",
+            hierarchy=Hierarchy(
+                continent=COUNTRY_TO_CONTINENT.get(addr.get("country")) if addr.get("country") else None,
+                country=addr.get("country"),
+                region=addr.get("state") or addr.get("region"),
+                city=addr.get("city") or addr.get("town") or addr.get("village") or addr.get("municipality"),
+                district=addr.get("suburb") or addr.get("city_district"),
+                note=f"GeoCLIP-Koordinaten über {len(frames)} Frames; zentralster Punkt (Medoid) "
+                     f"rückwärts-geocodiert. Mittlere Streuung ~{spread:.0f} km. Modell-Schätzung, kein GPS.",
+            ),
+            candidates=candidates,
+            uncertainty=(f"Mittel — GeoCLIP-Koordinaten über {len(frames)} Frames, "
+                         f"mittlere Streuung zum Zentrum ~{spread:.0f} km. Kein GPS."),
+            model_used=engine.model_name or "(lazy)",
+        )
+
+    # --- fallback: StreetCLIP country vote ----------------------------------
+    total = sum(agg.values()) or 1.0
+    ranked = sorted(((k, v / total) for k, v in agg.items()), key=lambda x: x[1], reverse=True)[:10]
+
+    coords: dict[str, tuple[float, float]] = {}
+    for name, _ in ranked[:5]:
+        hits = await geocode.forward(name, limit=1)
+        if hits:
+            coords[name] = (hits[0]["lat"], hits[0]["lon"])
+
+    candidates = [
+        LocationCandidate(
+            rank=i, label=name, confidence=round(score, 3),
+            lat=coords.get(name, (None, None))[0], lon=coords.get(name, (None, None))[1],
+            reasoning=f"Konsens aus {len(frames)} analysierten Videoframes.",
+        )
+        for i, (name, score) in enumerate(ranked, start=1)
+    ]
+    top_country = ranked[0][0] if ranked else None
+    return AnalysisResult(
+        kind="video", source_name=source_name,
+        hierarchy=Hierarchy(continent=COUNTRY_TO_CONTINENT.get(top_country) if top_country else None,
+                            country=top_country,
+                            note=f"Aggregiert aus {len(frames)} Frames. Route wird bewusst nicht "
+                                 "rekonstruiert (aus Bildinhalt nicht zuverlässig möglich)."),
+        candidates=candidates, location_source="inference",
+        uncertainty="Hoch — Videoinferenz auf Land-/Regionsebene, Konsens über Frames.",
+        model_used=engine.model_name or "(lazy)",
+    )

backend/app/services/geocode.py

@@ -0,0 +1,79 @@
+"""Geocoding helpers backed by OpenStreetMap Nominatim (cached, rate-limited)."""
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Optional
+
+import httpx
+
+from ..config import get_settings
+from ..core.cache import geocode_cache
+
+settings = get_settings()
+_last_call = 0.0
+_lock = asyncio.Lock()
+
+
+def _headers() -> dict:
+    ua = "GeoVisionPro/1.0"
+    if settings.nominatim_email:
+        ua += f" ({settings.nominatim_email})"
+    return {"User-Agent": ua, "Accept": "application/json"}
+
+
+async def _rate_limited_get(client: httpx.AsyncClient, url: str, params: dict):
+    global _last_call
+    async with _lock:  # Nominatim asks for <= 1 request/second
+        wait = 1.0 - (time.time() - _last_call)
+        if wait > 0:
+            await asyncio.sleep(wait)
+        _last_call = time.time()
+    return await client.get(url, params=params, headers=_headers())
+
+
+async def forward(query: str, limit: int = 3) -> list[dict]:
+    """Search a free-text place query -> list of {display, lat, lon, importance}."""
+    query = (query or "").strip()
+    if not query:
+        return []
+    cache_key = f"fwd:{limit}:{query.lower()}"
+    cached = geocode_cache.get(cache_key)
+    if cached is not None:
+        return cached
+    params = {"format": "jsonv2", "q": query, "limit": limit,
+              "accept-language": "de", "addressdetails": 1}
+    async with httpx.AsyncClient(timeout=settings.http_timeout) as client:
+        try:
+            r = await _rate_limited_get(client, f"{settings.nominatim_url}/search", params)
+            r.raise_for_status()
+            data = r.json()
+        except Exception:
+            return []
+    out = [
+        {"display": d.get("display_name", ""), "lat": float(d["lat"]), "lon": float(d["lon"]),
+         "importance": float(d.get("importance", 0.0)),
+         "country_code": (d.get("address", {}) or {}).get("country_code")}
+        for d in data if d.get("lat") and d.get("lon")
+    ]
+    geocode_cache.set(cache_key, out)
+    return out
+
+
+async def reverse(lat: float, lon: float) -> Optional[dict]:
+    """Reverse geocode coordinates -> {display, address}."""
+    cache_key = f"rev:{round(lat,5)}:{round(lon,5)}"
+    cached = geocode_cache.get(cache_key)
+    if cached is not None:
+        return cached
+    params = {"format": "jsonv2", "lat": lat, "lon": lon, "zoom": 14, "accept-language": "de"}
+    async with httpx.AsyncClient(timeout=settings.http_timeout) as client:
+        try:
+            r = await _rate_limited_get(client, f"{settings.nominatim_url}/reverse", params)
+            r.raise_for_status()
+            d = r.json()
+        except Exception:
+            return None
+    result = {"display": d.get("display_name", ""), "address": d.get("address", {})}
+    geocode_cache.set(cache_key, result)
+    return result

backend/app/services/geoengine.py

@@ -0,0 +1,130 @@
+"""GeoCLIP coordinate predictor — the GeoSpy-style core.
+
+GeoCLIP (Vivanco et al., NeurIPS 2023) predicts *real GPS coordinates* for an
+image, returning a ranked gallery of (lat, lon) with probabilities. It is the
+closest openly-available model to commercial tools such as GeoSpy: instead of
+only naming a country, it places the photo on the map.
+
+It is OPTIONAL. If the `geoclip` package or its weights cannot be loaded, the
+engine marks itself failed and callers transparently fall back to StreetCLIP
+country inference. Heavy imports (torch, geoclip) happen only inside load(),
+so importing this module never pulls in those dependencies.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import tempfile
+import threading
+from typing import Optional
+
+from PIL import Image
+
+from ..config import get_settings
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+
+class GeoEngine:
+    def __init__(self) -> None:
+        self._model = None
+        self._device = "cpu"
+        self._lock = threading.Lock()
+        self._failed = False
+        self._name = "GeoCLIP"
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def available(self) -> bool:
+        """True until a load attempt has definitively failed."""
+        return settings.enable_geoclip and not self._failed
+
+    def load(self) -> None:
+        if self._model is not None or self._failed or not settings.enable_geoclip:
+            return
+        with self._lock:
+            if self._model is not None or self._failed:
+                return
+            try:
+                import torch
+                from geoclip import GeoCLIP
+
+                if settings.device == "auto":
+                    self._device = "cuda" if torch.cuda.is_available() else "cpu"
+                else:
+                    self._device = settings.device
+                logger.info("Loading GeoCLIP on %s ...", self._device)
+                self._model = GeoCLIP().to(self._device)
+                logger.info("GeoCLIP ready.")
+            except Exception as exc:  # package missing, no weights, OOM, ...
+                logger.warning(
+                    "GeoCLIP unavailable (%s) — falling back to StreetCLIP country inference.",
+                    exc,
+                )
+                self._failed = True
+
+    def _predict_one(self, image: Image.Image, top_k: int) -> list[tuple[float, float, float]]:
+        """Single forward pass. geoclip reads from a path, so we use a temp JPEG
+        (this also normalises HEIC/PNG inputs uniformly)."""
+        tmp = tempfile.NamedTemporaryFile(suffix=".jpg", delete=False)
+        try:
+            image.convert("RGB").save(tmp.name, "JPEG", quality=95)
+            tmp.close()
+            gps, probs = self._model.predict(tmp.name, top_k=top_k)
+            return [(float(lat), float(lon), float(p))
+                    for (lat, lon), p in zip(gps.tolist(), probs.tolist())]
+        finally:
+            try:
+                os.unlink(tmp.name)
+            except OSError:
+                pass
+
+    def predict(self, image: Image.Image, top_k: Optional[int] = None) -> list[tuple[float, float, float]]:
+        """Return [(lat, lon, prob), ...] best-first. Empty list if unavailable.
+
+        With TTA on (default), the image and its mirror are each scored against
+        the GeoCLIP GPS gallery and the per-coordinate probabilities are summed.
+        Because both views rank the *same* fixed gallery, this is a clean
+        ensemble that stabilises the prediction at no accuracy cost — only a bit
+        more CPU time.
+        """
+        self.load()
+        if self._model is None:
+            return []
+        top_k = top_k or settings.geoclip_top_k
+        pool = max(settings.geoclip_candidate_pool, top_k)
+
+        views = [image.convert("RGB")]
+        if settings.geoclip_tta:
+            from PIL import ImageOps
+            views.append(ImageOps.mirror(image.convert("RGB")))
+
+        try:
+            agg: dict[tuple[float, float], float] = {}
+            for view in views:
+                for lat, lon, p in self._predict_one(view, pool):
+                    key = (round(lat, 4), round(lon, 4))
+                    agg[key] = agg.get(key, 0.0) + p
+            if not agg:
+                return []
+            total = sum(agg.values()) or 1.0
+            ranked = sorted(((lat, lon, p / total) for (lat, lon), p in agg.items()),
+                            key=lambda t: t[2], reverse=True)
+            return ranked[:top_k]
+        except Exception as exc:
+            logger.warning("GeoCLIP prediction failed: %s", exc)
+            return []
+
+
+_geo: Optional[GeoEngine] = None
+
+
+def get_geo_engine() -> GeoEngine:
+    global _geo
+    if _geo is None:
+        _geo = GeoEngine()
+    return _geo

backend/app/services/labels.py

@@ -0,0 +1,95 @@
+"""Label data for zero-shot geolocation and visual signal analysis.
+
+Country list is curated (not exhaustive) to keep inference fast. StreetCLIP was
+trained on country-level prompts, so these prompts match its training distribution.
+"""
+
+# (country, continent)
+COUNTRIES: list[tuple[str, str]] = [
+    ("Germany", "Europe"), ("France", "Europe"), ("Italy", "Europe"), ("Spain", "Europe"),
+    ("Portugal", "Europe"), ("United Kingdom", "Europe"), ("Ireland", "Europe"),
+    ("Netherlands", "Europe"), ("Belgium", "Europe"), ("Switzerland", "Europe"),
+    ("Austria", "Europe"), ("Poland", "Europe"), ("Czechia", "Europe"), ("Slovakia", "Europe"),
+    ("Hungary", "Europe"), ("Romania", "Europe"), ("Bulgaria", "Europe"), ("Greece", "Europe"),
+    ("Croatia", "Europe"), ("Slovenia", "Europe"), ("Serbia", "Europe"), ("Norway", "Europe"),
+    ("Sweden", "Europe"), ("Finland", "Europe"), ("Denmark", "Europe"), ("Iceland", "Europe"),
+    ("Estonia", "Europe"), ("Latvia", "Europe"), ("Lithuania", "Europe"), ("Ukraine", "Europe"),
+    ("Russia", "Europe"), ("Turkey", "Asia"),
+    ("United States", "North America"), ("Canada", "North America"), ("Mexico", "North America"),
+    ("Guatemala", "North America"), ("Cuba", "North America"), ("Costa Rica", "North America"),
+    ("Brazil", "South America"), ("Argentina", "South America"), ("Chile", "South America"),
+    ("Peru", "South America"), ("Colombia", "South America"), ("Bolivia", "South America"),
+    ("Ecuador", "South America"), ("Uruguay", "South America"),
+    ("China", "Asia"), ("Japan", "Asia"), ("South Korea", "Asia"), ("India", "Asia"),
+    ("Thailand", "Asia"), ("Vietnam", "Asia"), ("Indonesia", "Asia"), ("Malaysia", "Asia"),
+    ("Philippines", "Asia"), ("Singapore", "Asia"), ("Taiwan", "Asia"), ("Cambodia", "Asia"),
+    ("Nepal", "Asia"), ("Sri Lanka", "Asia"), ("Pakistan", "Asia"), ("Bangladesh", "Asia"),
+    ("Israel", "Asia"), ("Jordan", "Asia"), ("United Arab Emirates", "Asia"),
+    ("Saudi Arabia", "Asia"), ("Iran", "Asia"), ("Kazakhstan", "Asia"),
+    ("Egypt", "Africa"), ("Morocco", "Africa"), ("Tunisia", "Africa"), ("Algeria", "Africa"),
+    ("South Africa", "Africa"), ("Kenya", "Africa"), ("Tanzania", "Africa"), ("Nigeria", "Africa"),
+    ("Ghana", "Africa"), ("Ethiopia", "Africa"), ("Namibia", "Africa"), ("Botswana", "Africa"),
+    ("Australia", "Oceania"), ("New Zealand", "Oceania"), ("Fiji", "Oceania"),
+]
+
+COUNTRY_TO_CONTINENT: dict[str, str] = {name: cont for name, cont in COUNTRIES}
+COUNTRY_NAMES: list[str] = [name for name, _ in COUNTRIES]
+
+COUNTRY_PROMPT = "a street level photo taken in {}"
+REGION_PROMPT = "a street level photo taken in {}"
+
+# Optional region prompts for a few large countries. Used only to refine the
+# "Region" level when the location is pure inference. Still inference (not exact).
+REGIONS: dict[str, list[str]] = {
+    "Germany": ["Bavaria, Germany", "Berlin, Germany", "Hamburg, Germany",
+                "North Rhine-Westphalia, Germany", "Saxony, Germany",
+                "Baden-Württemberg, Germany", "Hesse, Germany", "Lower Saxony, Germany"],
+    "United States": ["California, USA", "Texas, USA", "Florida, USA", "New York, USA",
+                      "Arizona, USA", "Colorado, USA", "Washington State, USA", "Louisiana, USA"],
+    "France": ["Île-de-France", "Provence, France", "Brittany, France", "Normandy, France",
+               "Occitanie, France", "Auvergne-Rhône-Alpes, France"],
+    "Italy": ["Tuscany, Italy", "Sicily, Italy", "Lombardy, Italy", "Veneto, Italy",
+              "Lazio, Italy", "Campania, Italy", "Piedmont, Italy"],
+    "Spain": ["Andalusia, Spain", "Catalonia, Spain", "Madrid, Spain", "Valencia, Spain",
+              "Galicia, Spain", "Basque Country, Spain"],
+    "United Kingdom": ["England", "Scotland", "Wales", "Northern Ireland"],
+}
+
+# Visual-analysis signal groups. Each maps a human label -> CLIP prompt.
+# The fusion step turns the top score of each group into an explainability weight.
+SIGNAL_GROUPS: dict[str, dict[str, str]] = {
+    "Landschaft": {
+        "Küste / Meer": "a photo of a coastline with the sea",
+        "Berge": "a photo of a mountain landscape",
+        "Wald": "a photo of a dense forest",
+        "Wüste": "a photo of a desert",
+        "Felder / Ebene": "a photo of open farmland and fields",
+        "Stadtlandschaft": "a photo of an urban cityscape",
+        "Tropisch": "a photo of a tropical landscape with palm trees",
+        "See / Fluss": "a photo of a lake or river",
+    },
+    "Architektur": {
+        "Nordeuropäisch / Backstein": "a photo of north european brick architecture",
+        "Mediterran": "a photo of mediterranean architecture with terracotta roofs",
+        "Nordamerikanisch (Vorstadt)": "a photo of north american suburban houses",
+        "Ostasiatisch": "a photo of east asian architecture",
+        "Hochhäuser / modern": "a photo of modern skyscrapers and glass facades",
+        "Altstadt / historisch": "a photo of a historic old town",
+        "Tropisch / informell": "a photo of informal tropical buildings",
+    },
+    "Infrastruktur": {
+        "Europäische Straßenmarkierung": "a photo of european road markings and signs",
+        "US-Straßen / Ampeln": "a photo of north american roads with hanging traffic lights",
+        "Linksverkehr": "a photo of a left-hand traffic road",
+        "Asiatische Stadtinfrastruktur": "a photo of asian urban street infrastructure",
+        "Ländliche Straße": "a photo of a rural road",
+        "Bahn / Gleise": "a photo of railway tracks and trains",
+    },
+    "Klima": {
+        "Schnee / Winter": "a snowy winter scene",
+        "Trocken / arid": "a dry arid climate scene",
+        "Feucht / grün": "a humid lush green climate scene",
+        "Gemäßigt": "a temperate climate scene",
+        "Tropisch heiß": "a hot tropical climate scene",
+    },
+}

backend/app/services/ocr.py

@@ -0,0 +1,76 @@
+"""Optional OCR via Tesseract (host binary). Reads signs/place names from images.
+
+Per project boundary: this is general signage/text reading. It is NOT used for
+license-plate numbers or person identification.
+"""
+from __future__ import annotations
+
+import logging
+import re
+
+from PIL import Image, ImageOps
+
+from ..config import get_settings
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+try:  # pragma: no cover - optional dependency
+    import pytesseract
+
+    _TESS = True
+except Exception:  # pragma: no cover
+    _TESS = False
+
+
+def available() -> bool:
+    if not (settings.enable_ocr and _TESS):
+        return False
+    try:
+        pytesseract.get_tesseract_version()
+        return True
+    except Exception:
+        return False
+
+
+def _preprocess(image: Image.Image) -> Image.Image:
+    gray = ImageOps.grayscale(image)
+    gray = ImageOps.autocontrast(gray, cutoff=2)
+    w, h = gray.size
+    longest = max(w, h)
+    if longest < 1600:
+        scale = min(2.5, 1600 / longest)
+        gray = gray.resize((int(w * scale), int(h * scale)))
+    return gray
+
+
+def read_text(image: Image.Image, lang: str = "deu+eng") -> str:
+    if not available():
+        return ""
+    try:
+        txt = pytesseract.image_to_string(_preprocess(image), lang=lang)
+    except Exception as exc:  # missing language pack etc.
+        logger.warning("OCR failed: %s", exc)
+        return ""
+    return txt.strip()
+
+
+def candidate_queries(text: str, max_queries: int = 4) -> list[str]:
+    """Turn OCR text into geocodable place-name candidates."""
+    lines = []
+    for raw in text.splitlines():
+        cleaned = re.sub(r"[^\w\s\-.,&äöüÄÖÜß]", " ", raw, flags=re.UNICODE)
+        cleaned = re.sub(r"\s+", " ", cleaned).strip()
+        if len(cleaned) >= 3 and re.search(r"[A-Za-zÄÖÜäöü]{3,}", cleaned):
+            lines.append(cleaned)
+    queries: list[str] = []
+    if lines:
+        queries.append(", ".join(lines[:4]))
+    queries.extend(l for l in lines[:5] if len(l) >= 4)
+    # de-duplicate preserving order
+    seen, out = set(), []
+    for q in queries:
+        if q.lower() not in seen:
+            seen.add(q.lower())
+            out.append(q)
+    return out[:max_queries]

backend/app/services/picarta.py

@@ -0,0 +1,117 @@
+"""Picarta predictor — the commercial, GeoSpy-class location API.
+
+Picarta (https://picarta.ai) is the closest publicly-available service to
+GeoSpy in accuracy: it routinely returns city- and street-level guesses, not
+just a country. It is OPTIONAL and OFF unless a token is configured:
+
+  * Set GEOVISION_PICARTA_API_TOKEN to your (free-tier) token to enable it.
+  * Without a token, ``available`` is False and the pipeline transparently
+    falls back to the open models (reference retrieval / GeoCLIP / StreetCLIP).
+
+Honesty note: this sends the image to an external service. We only call it when
+a token is explicitly set, and we say so in the result's source label.
+"""
+from __future__ import annotations
+
+import base64
+import logging
+from typing import Optional
+
+import httpx
+
+from ..config import get_settings
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+
+def available() -> bool:
+    return bool(settings.enable_picarta and settings.picarta_api_token.strip())
+
+
+def _coerce_float(value) -> Optional[float]:
+    try:
+        if value is None:
+            return None
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _gps_from_entry(entry: dict) -> tuple[Optional[float], Optional[float]]:
+    """Pull (lat, lon) out of one prediction entry across Picarta's field shapes."""
+    gps = entry.get("gps")
+    if isinstance(gps, (list, tuple)) and len(gps) >= 2:
+        return _coerce_float(gps[0]), _coerce_float(gps[1])
+    lat = entry.get("ai_lat", entry.get("lat", entry.get("latitude")))
+    lon = entry.get("ai_lon", entry.get("lon", entry.get("longitude")))
+    return _coerce_float(lat), _coerce_float(lon)
+
+
+def parse_response(data: dict) -> list[dict]:
+    """Normalise a Picarta response into [{lat, lon, confidence, country, city,
+    province}, ...] best-first. Pure function (no I/O) so it is unit-testable.
+    """
+    if not isinstance(data, dict):
+        return []
+    out: list[dict] = []
+
+    topk = data.get("topk_predictions_dict")
+    if isinstance(topk, dict):
+        # keys are usually "1", "2", ... -> sort numerically when possible
+        def _key(k):
+            try:
+                return int(k)
+            except (TypeError, ValueError):
+                return 1_000_000
+        for k in sorted(topk.keys(), key=_key):
+            entry = topk[k] or {}
+            addr = entry.get("address") if isinstance(entry.get("address"), dict) else entry
+            lat, lon = _gps_from_entry(entry)
+            if lat is None or lon is None:
+                continue
+            out.append({
+                "lat": lat, "lon": lon,
+                "confidence": _coerce_float(entry.get("confidence")) or 0.0,
+                "country": addr.get("country"),
+                "city": addr.get("city") or addr.get("town"),
+                "province": addr.get("province") or addr.get("state"),
+            })
+
+    if not out:
+        # fall back to the single top-level prediction
+        lat = _coerce_float(data.get("ai_lat"))
+        lon = _coerce_float(data.get("ai_lon"))
+        if lat is not None and lon is not None:
+            out.append({
+                "lat": lat, "lon": lon,
+                "confidence": _coerce_float(data.get("ai_confidence")) or 0.0,
+                "country": data.get("ai_country"),
+                "city": data.get("ai_city"),
+                "province": data.get("ai_province"),
+            })
+    return out
+
+
+async def predict(image_bytes: bytes) -> list[dict]:
+    """Call Picarta and return normalised predictions. [] on any failure."""
+    if not available():
+        return []
+    payload = {
+        "TOKEN": settings.picarta_api_token.strip(),
+        "IMAGE": base64.b64encode(image_bytes).decode("ascii"),
+        "TOP_K": settings.picarta_top_k,
+    }
+    try:
+        async with httpx.AsyncClient(timeout=settings.http_timeout) as client:
+            r = await client.post(settings.picarta_url, json=payload,
+                                  headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            data = r.json()
+    except Exception as exc:
+        logger.warning("Picarta request failed (%s) — falling back to open models.", exc)
+        return []
+    preds = parse_response(data)
+    if not preds:
+        logger.info("Picarta returned no usable prediction; falling back.")
+    return preds

backend/app/services/reference.py

@@ -0,0 +1,275 @@
+"""Reference image gallery — real image-retrieval geolocation.
+
+HONEST DESIGN: there is no bundled "global image database" (that would be a fake).
+Instead, point GEOVISION_REFERENCE_DIR at a folder of YOUR OWN geotagged images.
+We embed them once (cached to disk so restarts and additions are cheap) and match
+new photos against them with cosine similarity. This is exactly how commercial
+tools pinpoint a place: retrieval against known, located images.
+
+"Training with more images" lives here: the more geotagged photos you drop into
+the folder, the more places the app can recognise — no GPU, no retraining.
+
+Each reference image gets coordinates from, in order:
+  1. its EXIF GPS, or
+  2. a "lat,lon" pattern in its filename, e.g.  cafe_48.8584_2.2945.jpg
+Images without coordinates are still indexed (they show as look-alikes) but do
+not contribute to the location estimate.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import re
+import threading
+from uuid import uuid4
+
+import numpy as np
+
+from ..config import get_settings
+from .exif import extract_gps, open_image
+from .vision import get_engine
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+_IMG_EXT = {".jpg", ".jpeg", ".png", ".webp", ".bmp"}
+_CACHE_NAME = ".geovision_ref_index.npz"
+_COORD_RE = re.compile(r"(-?\d{1,2}\.\d{3,})[,_ ]+(-?\d{1,3}\.\d{3,})")
+_FALLBACK_DIR = "/tmp/geovision_reference"
+
+_index: list[dict] | None = None
+_dir_override: str | None = None
+_lock = threading.Lock()
+
+
+def active_dir() -> str:
+    """The reference folder currently in use (may be a writable fallback)."""
+    return _dir_override or settings.reference_dir
+
+
+def ensure_writable_dir() -> str:
+    """Return a writable reference folder, creating it; fall back to /tmp if the
+    configured dir (e.g. /data without persistent storage) is not writable."""
+    global _dir_override
+    target = active_dir()
+    for candidate in (target, _FALLBACK_DIR):
+        if not candidate:
+            continue
+        try:
+            os.makedirs(candidate, exist_ok=True)
+            probe = os.path.join(candidate, ".write_test")
+            with open(probe, "w") as fh:
+                fh.write("ok")
+            os.remove(probe)
+            if candidate != target:
+                _dir_override = candidate
+                logger.warning("Reference dir %s not writable — using %s instead.", target, candidate)
+            return candidate
+        except OSError:
+            continue
+    raise RuntimeError("No writable reference directory available.")
+
+
+def coords_from_name(name: str) -> tuple[float, float] | tuple[None, None]:
+    """Parse a 'lat,lon' (or 'lat_lon') pattern from a filename. (None, None) if absent."""
+    m = _COORD_RE.search(os.path.splitext(os.path.basename(name))[0])
+    if not m:
+        return None, None
+    lat, lon = float(m.group(1)), float(m.group(2))
+    if -90 <= lat <= 90 and -180 <= lon <= 180:
+        return lat, lon
+    return None, None
+
+
+def _scan(root: str) -> list[tuple[str, float]]:
+    """Recursively list (relative_path, mtime) for supported images under root."""
+    found: list[tuple[str, float]] = []
+    for dirpath, _dirs, files in os.walk(root):
+        for fname in files:
+            if os.path.splitext(fname)[1].lower() not in _IMG_EXT:
+                continue
+            full = os.path.join(dirpath, fname)
+            rel = os.path.relpath(full, root)
+            try:
+                found.append((rel, os.path.getmtime(full)))
+            except OSError:
+                continue
+    return sorted(found)
+
+
+def _load_cache(root: str) -> dict[str, dict]:
+    """Load the on-disk embedding cache keyed by relative path -> {vec, lat, lon, mtime}."""
+    path = os.path.join(root, _CACHE_NAME)
+    if not os.path.isfile(path):
+        return {}
+    try:
+        npz = np.load(path, allow_pickle=True)
+        names = npz["names"]
+        vecs = npz["vecs"]
+        lats = npz["lats"]
+        lons = npz["lons"]
+        mtimes = npz["mtimes"]
+    except Exception as exc:
+        logger.warning("Reference cache unreadable (%s) — rebuilding.", exc)
+        return {}
+    out: dict[str, dict] = {}
+    for i, name in enumerate(names):
+        lat = float(lats[i]); lon = float(lons[i])
+        out[str(name)] = {
+            "vec": vecs[i].astype("float32"),
+            "lat": None if np.isnan(lat) else lat,
+            "lon": None if np.isnan(lon) else lon,
+            "mtime": float(mtimes[i]),
+        }
+    return out
+
+
+def _save_cache(root: str, entries: list[dict]) -> None:
+    path = os.path.join(root, _CACHE_NAME)
+    try:
+        np.savez(
+            path,
+            names=np.array([e["name"] for e in entries], dtype=object),
+            vecs=np.array([e["vec"] for e in entries], dtype="float32"),
+            lats=np.array([np.nan if e["lat"] is None else e["lat"] for e in entries], dtype="float64"),
+            lons=np.array([np.nan if e["lon"] is None else e["lon"] for e in entries], dtype="float64"),
+            mtimes=np.array([e["mtime"] for e in entries], dtype="float64"),
+        )
+    except Exception as exc:
+        logger.warning("Could not write reference cache: %s", exc)
+
+
+def _build_index() -> list[dict]:
+    root = active_dir()
+    if not root or not os.path.isdir(root):
+        return []
+    scanned = _scan(root)
+    if not scanned:
+        return []
+    cache = _load_cache(root)
+    engine = get_engine()
+    entries: list[dict] = []
+    embedded = reused = 0
+    for rel, mtime in scanned:
+        cached = cache.get(rel)
+        if cached is not None and abs(cached["mtime"] - mtime) < 1e-6:
+            entries.append({"name": rel, "vec": cached["vec"],
+                            "lat": cached["lat"], "lon": cached["lon"], "mtime": mtime})
+            reused += 1
+            continue
+        full = os.path.join(root, rel)
+        try:
+            with open(full, "rb") as fh:
+                data = fh.read()
+            vec = engine.embed_image(open_image(data))
+            gps = extract_gps(data)
+            lat, lon = gps.get("lat"), gps.get("lon")
+            if lat is None or lon is None:
+                lat, lon = coords_from_name(rel)
+            entries.append({"name": rel, "vec": vec, "lat": lat, "lon": lon, "mtime": mtime})
+            embedded += 1
+        except Exception as exc:
+            logger.warning("Reference image %s skipped: %s", rel, exc)
+    if embedded:
+        _save_cache(root, entries)
+    located = sum(1 for e in entries if e["lat"] is not None)
+    logger.info("Reference index: %d images (%d new, %d cached, %d geolocated).",
+                len(entries), embedded, reused, located)
+    return entries
+
+
+def get_index() -> list[dict]:
+    global _index
+    if _index is None:
+        with _lock:
+            if _index is None:
+                _index = _build_index()
+    return _index
+
+
+def reload() -> int:
+    """Force a rebuild (e.g. after adding images). Returns the image count."""
+    global _index
+    with _lock:
+        _index = _build_index()
+    return len(_index)
+
+
+def list_entries() -> list[dict]:
+    """Current gallery contents (for the UI): name + coordinates, newest last."""
+    return [{"name": e["name"], "lat": e["lat"], "lon": e["lon"]} for e in get_index()]
+
+
+def add_image(data: bytes, lat: float, lon: float, name_hint: str = "") -> dict:
+    """Add one geotagged photo to the gallery: embed it, persist it (with the
+    coordinates encoded in the filename so it survives a rebuild that re-scans
+    the folder), and append it to the live in-memory index — effective at once.
+    """
+    root = ensure_writable_dir()
+    engine = get_engine()
+    image = open_image(data)
+    vec = engine.embed_image(image)
+    # letters-only stem keeps the coordinate parser unambiguous
+    safe = re.sub(r"[^A-Za-z]+", "", name_hint)[:30] or "ref"
+    fname = f"{safe}-{uuid4().hex[:6]}_{float(lat):.5f}_{float(lon):.5f}.jpg"
+    path = os.path.join(root, fname)
+    image.convert("RGB").save(path, "JPEG", quality=92)
+
+    idx = get_index()  # build (without the new file) before appending
+    idx.append({"name": fname, "vec": vec,
+                "lat": float(lat), "lon": float(lon),
+                "mtime": os.path.getmtime(path)})
+    _save_cache(root, idx)
+    return {
+        "name": fname,
+        "reference_images": len(idx),
+        "reference_geolocated": sum(1 for e in idx if e["lat"] is not None),
+    }
+
+
+def match(image_vec: "np.ndarray", top_k: int = 5) -> list[dict]:
+    """Top-k look-alikes by cosine similarity (for display)."""
+    idx = get_index()
+    if not idx:
+        return []
+    sims = [
+        {"name": e["name"], "similarity": round(float(np.dot(image_vec, e["vec"])), 4),
+         "lat": e["lat"], "lon": e["lon"]}
+        for e in idx
+    ]
+    sims.sort(key=lambda x: x["similarity"], reverse=True)
+    return sims[:top_k]
+
+
+def geolocate(image_vec: "np.ndarray") -> dict | None:
+    """Retrieval-based location estimate from the geotagged references.
+
+    Fuses the nearest geotagged neighbours (cosine >= threshold) into a
+    similarity-weighted centroid. Returns None if nothing clears the bar, so the
+    pipeline cleanly falls through to the next source.
+    """
+    idx = get_index()
+    if not idx:
+        return None
+    located = [e for e in idx if e["lat"] is not None and e["lon"] is not None]
+    if not located:
+        return None
+    scored = sorted(
+        ((float(np.dot(image_vec, e["vec"])), e) for e in located),
+        key=lambda x: x[0], reverse=True,
+    )
+    top = [(s, e) for s, e in scored[: settings.reference_use_top_k]
+           if s >= settings.reference_min_similarity]
+    if not top:
+        return None
+    wsum = sum(s for s, _ in top) or 1.0
+    lat = sum(s * e["lat"] for s, e in top) / wsum
+    lon = sum(s * e["lon"] for s, e in top) / wsum
+    matches = [{"name": e["name"], "similarity": round(s, 4),
+                "lat": e["lat"], "lon": e["lon"]} for s, e in top]
+    return {
+        "lat": lat, "lon": lon,
+        "similarity": top[0][0],            # best single match (confidence proxy)
+        "n": len(top),
+        "matches": matches,
+    }

backend/app/services/report.py

@@ -0,0 +1,117 @@
+"""Report generation: JSON, CSV and PDF (Executive Summary) from an AnalysisResult."""
+from __future__ import annotations
+
+import csv
+import io
+
+from ..schemas import AnalysisResult
+
+
+def to_json_bytes(result: AnalysisResult) -> bytes:
+    return result.model_dump_json(indent=2).encode("utf-8")
+
+
+def to_csv_bytes(result: AnalysisResult) -> bytes:
+    buf = io.StringIO()
+    w = csv.writer(buf)
+    w.writerow(["rank", "label", "confidence", "lat", "lon", "reasoning"])
+    for c in result.candidates:
+        w.writerow([c.rank, c.label, c.confidence, c.lat or "", c.lon or "", c.reasoning])
+    return ("" + buf.getvalue()).encode("utf-8")
+
+
+def to_pdf_bytes(result: AnalysisResult) -> bytes:
+    """Render a clean one/two-page PDF report. Requires reportlab."""
+    from reportlab.lib import colors
+    from reportlab.lib.pagesizes import A4
+    from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
+    from reportlab.lib.units import mm
+    from reportlab.platypus import (Paragraph, SimpleDocTemplate, Spacer, Table,
+                                    TableStyle)
+
+    buf = io.BytesIO()
+    doc = SimpleDocTemplate(buf, pagesize=A4, title="GeoVision Pro Report",
+                            leftMargin=18 * mm, rightMargin=18 * mm,
+                            topMargin=16 * mm, bottomMargin=16 * mm)
+    styles = getSampleStyleSheet()
+    h1 = ParagraphStyle("h1", parent=styles["Heading1"], textColor=colors.HexColor("#0b1f3a"))
+    h2 = ParagraphStyle("h2", parent=styles["Heading2"], textColor=colors.HexColor("#274060"))
+    body = styles["BodyText"]
+    small = ParagraphStyle("small", parent=body, fontSize=8, textColor=colors.grey)
+
+    elems = [Paragraph("GeoVision Pro — Standortbericht", h1)]
+    elems.append(Paragraph(f"Quelle: {result.source_name or '—'}  |  "
+                           f"Typ: {result.kind}  |  Modell: {result.model_used}", small))
+    elems.append(Spacer(1, 8))
+
+    # Executive summary
+    elems.append(Paragraph("Executive Summary", h2))
+    best = result.candidates[0] if result.candidates else None
+    summary = (f"Wahrscheinlichster Ort: <b>{best.label}</b> "
+               f"(Konfidenz {best.confidence:.0%}). " if best else "Kein Standortkandidat. ")
+    summary += f"Quelle der Standortbestimmung: <b>{result.location_source}</b>. "
+    summary += f"Unsicherheit: {result.uncertainty}"
+    elems.append(Paragraph(summary, body))
+    elems.append(Spacer(1, 6))
+
+    # Hierarchy
+    h = result.hierarchy
+    rows = [["Ebene", "Wert"]]
+    for lbl, val in [("Kontinent", h.continent), ("Land", h.country),
+                     ("Region", h.region), ("Stadt", h.city), ("Stadtteil", h.district)]:
+        rows.append([lbl, val or "— (nicht bestimmbar)"])
+    t = Table(rows, colWidths=[40 * mm, 120 * mm])
+    t.setStyle(TableStyle([
+        ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#274060")),
+        ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
+        ("GRID", (0, 0), (-1, -1), 0.4, colors.HexColor("#c9d4e3")),
+        ("FONTSIZE", (0, 0), (-1, -1), 9),
+        ("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#eef3f9")]),
+    ]))
+    elems.append(Paragraph("Standort-Hierarchie", h2))
+    elems.append(t)
+    if h.note:
+        elems.append(Paragraph(h.note, small))
+    elems.append(Spacer(1, 8))
+
+    # Candidates
+    elems.append(Paragraph("Standort-Hypothesen (Top 10)", h2))
+    crows = [["#", "Ort", "Konfidenz", "Begründung"]]
+    for c in result.candidates:
+        crows.append([str(c.rank), Paragraph(str(c.label), small),
+                      f"{c.confidence:.0%}", Paragraph(c.reasoning, small)])
+    ct = Table(crows, colWidths=[8 * mm, 52 * mm, 20 * mm, 80 * mm])
+    ct.setStyle(TableStyle([
+        ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#274060")),
+        ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
+        ("GRID", (0, 0), (-1, -1), 0.4, colors.HexColor("#c9d4e3")),
+        ("FONTSIZE", (0, 0), (-1, -1), 8),
+        ("VALIGN", (0, 0), (-1, -1), "TOP"),
+    ]))
+    elems.append(ct)
+    elems.append(Spacer(1, 8))
+
+    # Signal weights
+    if result.signals:
+        elems.append(Paragraph("Erklärung — Gewichtung der Bildmerkmale", h2))
+        srows = [["Kategorie", "Top-Merkmal", "Gewicht"]]
+        for g in result.signals:
+            top = g.top[0].label if g.top else "—"
+            srows.append([g.name, top, f"{g.weight:.0%}"])
+        st = Table(srows, colWidths=[45 * mm, 75 * mm, 25 * mm])
+        st.setStyle(TableStyle([
+            ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#274060")),
+            ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
+            ("GRID", (0, 0), (-1, -1), 0.4, colors.HexColor("#c9d4e3")),
+            ("FONTSIZE", (0, 0), (-1, -1), 9),
+        ]))
+        elems.append(st)
+
+    elems.append(Spacer(1, 10))
+    elems.append(Paragraph(
+        "Hinweis: GeoVision Pro liefert exakte Orte nur bei GPS-Metadaten oder lesbaren "
+        "Ortsschildern. Reine Bildinferenz erreicht Land-/Regionsebene, nicht Hausnummern.",
+        small))
+
+    doc.build(elems)
+    return buf.getvalue()

backend/app/services/video.py

@@ -0,0 +1,77 @@
+"""Video frame sampling via OpenCV.
+
+Honest scope: we sample evenly spaced, sharp frames and analyse them as images,
+then aggregate. We do NOT reconstruct a precise travel route from pixels — that is
+not reliably possible. The aggregate location is the consensus of analysed frames.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import tempfile
+
+import numpy as np
+from PIL import Image
+
+from ..config import get_settings
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+
+def _sharpness(gray: "np.ndarray") -> float:
+    import cv2
+
+    return float(cv2.Laplacian(gray, cv2.CV_64F).var())
+
+
+def extract_keyframes(data: bytes, max_frames: int | None = None) -> list[Image.Image]:
+    """Sample up to `max_frames` evenly spaced, reasonably sharp frames."""
+    import cv2
+
+    max_frames = max_frames or settings.max_video_frames
+    tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    try:
+        tmp.write(data)
+        tmp.flush()
+        tmp.close()
+        cap = cv2.VideoCapture(tmp.name)
+        total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) or 0
+        if total <= 0:
+            # Fallback: read sequentially
+            frames = []
+            ok, frame = cap.read()
+            while ok and len(frames) < max_frames:
+                frames.append(frame)
+                for _ in range(15):
+                    ok, frame = cap.read()
+            cap.release()
+            return [_to_pil(f) for f in frames]
+
+        # Sample 3x candidate positions, keep the sharpest in each bucket.
+        positions = np.linspace(0, total - 1, num=min(max_frames * 3, total)).astype(int)
+        picked: list[tuple[float, "np.ndarray"]] = []
+        for pos in positions:
+            cap.set(cv2.CAP_PROP_POS_FRAMES, int(pos))
+            ok, frame = cap.read()
+            if not ok:
+                continue
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            picked.append((_sharpness(gray), frame))
+        cap.release()
+
+        picked.sort(key=lambda x: x[0], reverse=True)
+        chosen = [f for _, f in picked[:max_frames]]
+        return [_to_pil(f) for f in chosen]
+    finally:
+        try:
+            os.unlink(tmp.name)
+        except OSError:
+            pass
+
+
+def _to_pil(frame_bgr) -> Image.Image:
+    import cv2
+
+    rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+    return Image.fromarray(rgb)

backend/app/services/vision.py

@@ -0,0 +1,126 @@
+"""Vision engine: CLIP / StreetCLIP zero-shot geolocation + scene analysis.
+
+This is the honest core. StreetCLIP gives strong COUNTRY / REGION level signals.
+It does NOT pinpoint streets or buildings — that is a research limitation, not a bug.
+The engine exposes:
+  * zero_shot(image, labels, template) -> ranked (label, score)
+  * embed_image(image) -> L2-normalized numpy vector (for reference similarity)
+"""
+from __future__ import annotations
+
+import logging
+import threading
+from typing import Optional
+
+import numpy as np
+from PIL import Image
+
+from ..config import get_settings
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+
+class VisionEngine:
+    def __init__(self) -> None:
+        self._model = None
+        self._processor = None
+        self._device = "cpu"
+        self._model_name = ""
+        self._text_cache: dict[tuple, "np.ndarray"] = {}
+        self._logit_scale = 100.0
+        self._lock = threading.Lock()
+
+    # ---- lifecycle -------------------------------------------------------
+    @property
+    def model_name(self) -> str:
+        return self._model_name
+
+    @property
+    def loaded(self) -> bool:
+        return self._model is not None
+
+    def load(self) -> None:
+        if self._model is not None:
+            return
+        with self._lock:
+            if self._model is not None:
+                return
+            import torch
+            from transformers import CLIPModel, CLIPProcessor
+
+            if settings.device == "auto":
+                self._device = "cuda" if torch.cuda.is_available() else "cpu"
+            else:
+                self._device = settings.device
+
+            for name in (settings.vision_model, settings.vision_fallback_model):
+                try:
+                    logger.info("Loading vision model %s on %s ...", name, self._device)
+                    self._model = CLIPModel.from_pretrained(name).to(self._device).eval()
+                    self._processor = CLIPProcessor.from_pretrained(name)
+                    self._model_name = name
+                    self._logit_scale = float(self._model.logit_scale.exp().item())
+                    logger.info("Vision model ready: %s", name)
+                    return
+                except Exception as exc:  # try fallback
+                    logger.warning("Failed to load %s: %s", name, exc)
+                    self._model = None
+            raise RuntimeError("No vision model could be loaded (check network / disk / model name).")
+
+    # ---- inference -------------------------------------------------------
+    def _encode_text(self, labels: tuple[str, ...], template: str) -> "np.ndarray":
+        key = (self._model_name, template, labels)
+        cached = self._text_cache.get(key)
+        if cached is not None:
+            return cached
+        import torch
+
+        prompts = [template.format(lbl) for lbl in labels]
+        inputs = self._processor(text=prompts, return_tensors="pt", padding=True).to(self._device)
+        with torch.no_grad():
+            feats = self._model.get_text_features(**inputs)
+        feats = feats / feats.norm(p=2, dim=-1, keepdim=True)
+        arr = feats.cpu().numpy().astype("float32")
+        self._text_cache[key] = arr
+        return arr
+
+    def embed_image(self, image: Image.Image) -> "np.ndarray":
+        self.load()
+        import torch
+
+        inputs = self._processor(images=image, return_tensors="pt").to(self._device)
+        with torch.no_grad():
+            feats = self._model.get_image_features(**inputs)
+        feats = feats / feats.norm(p=2, dim=-1, keepdim=True)
+        return feats.cpu().numpy().astype("float32")[0]
+
+    def zero_shot(
+        self,
+        image: Image.Image,
+        labels: list[str],
+        template: str = "a photo of {}",
+        top_k: Optional[int] = None,
+    ) -> list[tuple[str, float]]:
+        """Return labels ranked by softmax probability (sums to 1 over `labels`)."""
+        self.load()
+        img_vec = self.embed_image(image)  # (D,)
+        txt = self._encode_text(tuple(labels), template)  # (N, D)
+        logits = (txt @ img_vec) * self._logit_scale  # (N,)
+        logits = logits - logits.max()
+        probs = np.exp(logits)
+        probs = probs / probs.sum()
+        ranked = sorted(zip(labels, probs.tolist()), key=lambda x: x[1], reverse=True)
+        return ranked[:top_k] if top_k else ranked
+
+
+_engine: Optional[VisionEngine] = None
+
+
+def get_engine() -> VisionEngine:
+    global _engine
+    if _engine is None:
+        _engine = VisionEngine()
+        if not settings.model_lazy_load:
+            _engine.load()
+    return _engine

backend/pytest.ini

@@ -0,0 +1,4 @@
+[pytest]
+pythonpath = .
+testpaths = tests
+addopts = -q

backend/requirements.txt

@@ -0,0 +1,38 @@
+# Core API
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+python-multipart==0.0.18
+pydantic==2.10.4
+pydantic-settings==2.7.1
+
+# Database (async)
+SQLAlchemy==2.0.36
+asyncpg==0.30.0              # PostgreSQL (docker-compose / production)
+aiosqlite==0.20.0           # SQLite (single-container / Hugging Face Space)
+
+# HTTP client (geocoding)
+httpx==0.28.1
+
+# Imaging
+Pillow==11.1.0
+pillow-heif==0.21.0          # HEIC/HEIF support
+numpy==2.2.1
+
+# Vision model (CLIP / StreetCLIP)
+torch==2.5.1
+torchvision==0.20.1          # required by GeoCLIP
+transformers==4.48.0
+
+# GeoCLIP — real GPS-coordinate prediction (the GeoSpy-style core).
+# Pulls its own weights from HuggingFace on first use. Optional at runtime:
+# the service degrades to StreetCLIP country inference if it cannot load.
+geoclip==1.2.0
+
+# Video frame extraction
+opencv-python-headless==4.11.0.86
+
+# Reports
+reportlab==4.2.5
+
+# Optional OCR (also needs the `tesseract-ocr` system package + language data)
+pytesseract==0.3.13

backend/sql/schema.sql

@@ -0,0 +1,31 @@
+-- GeoVision Pro — PostgreSQL schema (production reference).
+-- The app can also create these via SQLAlchemy on startup (dev convenience),
+-- but for production run this file or an Alembic migration.
+
+CREATE TABLE IF NOT EXISTS analyses (
+    id              SERIAL PRIMARY KEY,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    kind            VARCHAR(16) NOT NULL DEFAULT 'image',
+    source_name     VARCHAR(255) NOT NULL DEFAULT '',
+    best_label      VARCHAR(255),
+    best_lat        DOUBLE PRECISION,
+    best_lon        DOUBLE PRECISION,
+    best_confidence DOUBLE PRECISION,
+    location_source VARCHAR(32) NOT NULL DEFAULT 'inference',
+    result          JSONB NOT NULL DEFAULT '{}'::jsonb
+);
+
+CREATE INDEX IF NOT EXISTS idx_analyses_created_at ON analyses (created_at DESC);
+
+CREATE TABLE IF NOT EXISTS candidates (
+    id          SERIAL PRIMARY KEY,
+    analysis_id INTEGER NOT NULL REFERENCES analyses (id) ON DELETE CASCADE,
+    rank        INTEGER NOT NULL,
+    label       VARCHAR(255) NOT NULL,
+    confidence  DOUBLE PRECISION NOT NULL,
+    lat         DOUBLE PRECISION,
+    lon         DOUBLE PRECISION,
+    reasoning   TEXT NOT NULL DEFAULT ''
+);
+
+CREATE INDEX IF NOT EXISTS idx_candidates_analysis_id ON candidates (analysis_id);

backend/tests/test_fusion.py

@@ -0,0 +1,17 @@
+"""Unit tests for pure logic that does NOT require the vision model."""
+from app.services.labels import COUNTRY_TO_CONTINENT, COUNTRY_NAMES
+from app.services.ocr import candidate_queries
+
+
+def test_continent_mapping_complete():
+    assert all(c in COUNTRY_TO_CONTINENT for c in COUNTRY_NAMES)
+    assert COUNTRY_TO_CONTINENT["Germany"] == "Europe"
+    assert COUNTRY_TO_CONTINENT["Japan"] == "Asia"
+
+
+def test_candidate_queries_extracts_lines():
+    text = "Hotel Bellevue\nZermatt\n!!\nab"
+    q = candidate_queries(text)
+    assert any("Zermatt" in s for s in q)
+    # the joined query of meaningful lines should be first
+    assert "Hotel Bellevue" in q[0]

backend/tests/test_health.py

@@ -0,0 +1,15 @@
+"""Smoke test for the health endpoint (no model download required)."""
+import os
+
+os.environ.setdefault("GEOVISION_DATABASE_URL", "sqlite+aiosqlite:///./test.db")
+
+from fastapi.testclient import TestClient  # noqa: E402
+
+from app.main import app  # noqa: E402
+
+
+def test_health():
+    with TestClient(app) as client:
+        r = client.get("/api/health")
+        assert r.status_code == 200
+        assert r.json()["status"] == "ok"

backend/tests/test_picarta_reference.py

@@ -0,0 +1,49 @@
+"""Unit tests for the new Picarta + reference logic (no model / network needed)."""
+from app.services.picarta import parse_response
+from app.services.reference import coords_from_name
+
+
+def test_parse_response_topk():
+    data = {
+        "ai_lat": 48.8584, "ai_lon": 2.2945, "ai_country": "France", "ai_city": "Paris",
+        "topk_predictions_dict": {
+            "1": {"gps": [48.8584, 2.2945], "confidence": 0.62,
+                  "address": {"country": "France", "city": "Paris", "province": "Île-de-France"}},
+            "2": {"gps": [45.764, 4.8357], "confidence": 0.18,
+                  "address": {"country": "France", "city": "Lyon"}},
+        },
+    }
+    preds = parse_response(data)
+    assert len(preds) == 2
+    assert preds[0]["city"] == "Paris"
+    assert preds[0]["confidence"] == 0.62
+    assert abs(preds[0]["lat"] - 48.8584) < 1e-6
+    assert preds[1]["city"] == "Lyon"
+
+
+def test_parse_response_toplevel_fallback():
+    # no topk dict -> use the single ai_* prediction
+    data = {"ai_lat": 35.6895, "ai_lon": 139.6917, "ai_country": "Japan", "ai_city": "Tokyo"}
+    preds = parse_response(data)
+    assert len(preds) == 1
+    assert preds[0]["country"] == "Japan"
+    assert abs(preds[0]["lon"] - 139.6917) < 1e-6
+
+
+def test_parse_response_empty():
+    assert parse_response({}) == []
+    assert parse_response({"topk_predictions_dict": {}}) == []
+    assert parse_response(None) == []
+
+
+def test_coords_from_name():
+    assert coords_from_name("cafe_48.8584_2.2945.jpg") == (48.8584, 2.2945)
+    assert coords_from_name("48.8584,2.2945.png") == (48.8584, 2.2945)
+    # negative coordinates
+    assert coords_from_name("spot_-33.8688_151.2093.jpg") == (-33.8688, 151.2093)
+
+
+def test_coords_from_name_none():
+    assert coords_from_name("holiday_photo.jpg") == (None, None)
+    # out-of-range rejected
+    assert coords_from_name("x_999.123_2.234.jpg") == (None, None)

frontend/Dockerfile

@@ -0,0 +1,13 @@
+# --- build stage ---
+FROM node:20-alpine AS build
+WORKDIR /app
+COPY package.json ./
+RUN npm install
+COPY . .
+RUN npm run build
+
+# --- serve stage ---
+FROM nginx:1.27-alpine
+COPY --from=build /app/dist /usr/share/nginx/html
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+EXPOSE 80

frontend/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="de">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>GeoVision Pro</title>
+    <link rel="preconnect" href="https://unpkg.com" />
+    <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

frontend/nginx.conf

@@ -0,0 +1,20 @@
+server {
+    listen 80;
+    server_name _;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    # SPA fallback
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    # Proxy API to the backend service (docker-compose network name: backend)
+    location /api/ {
+        proxy_pass http://backend:8000/api/;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        client_max_body_size 64m;
+        proxy_read_timeout 300s;
+    }
+}

frontend/package-lock.json

@@ -0,0 +1,2805 @@
+{
+  "name": "geovision-pro-frontend",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "geovision-pro-frontend",
+      "version": "1.0.0",
+      "dependencies": {
+        "leaflet": "^1.9.4",
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1"
+      },
+      "devDependencies": {
+        "@types/leaflet": "^1.9.15",
+        "@types/react": "^18.3.18",
+        "@types/react-dom": "^18.3.5",
+        "@vitejs/plugin-react": "^4.3.4",
+        "autoprefixer": "^10.4.20",
+        "postcss": "^8.4.49",
+        "tailwindcss": "^3.4.17",
+        "typescript": "^5.7.2",
+        "vite": "^6.0.5"
+      }
+    },
+    "node_modules/@alloc/quick-lru": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz",
+      "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "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/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.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
+      "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",
+      "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",
+      "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",
+      "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",
+      "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",
+      "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",
+      "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",
+      "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",
+      "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",
+      "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",
+      "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",
+      "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",
+      "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",
+      "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",
+      "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",
+      "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",
+      "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",
+      "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",
+      "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",
+      "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",
+      "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "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/@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.stat": "2.0.5",
+        "run-parallel": "^1.1.9"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.stat": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.walk": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.scandir": "2.1.5",
+        "fastq": "^1.6.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "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.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.61.0.tgz",
+      "integrity": "sha512-dnxczajOqt0gesZlN5pGQ1s1imQVrsmCw5G2Ci4oM+0WvNz3pyRnlWrT7McoZIb8VlFwCawdmbWRmxRn7HI+VQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.61.0.tgz",
+      "integrity": "sha512-Bp3JpGP00Vu3f238ivRrjf7z3xSzVPXqCmaJYA9t2c+c8vKYvOzmXF7LkkeUalTEGd6cZcSWe+PFIP3Vy48fRg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.61.0.tgz",
+      "integrity": "sha512-zaYIpr670mUmmZ1tVzUFplbQbG7h3Gugx3L5FoqhsC2m/YnLlR1a7zVLmXNPy+iY1tFPEbNG+HHBXZGyId0G5w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.61.0.tgz",
+      "integrity": "sha512-+P49fvkv2dSoeevUW+lgZ/I2JHSsJCK1Lyjj7Cu6E4UHG4tS9XIefzIjo5qhgELjAclnen1rLzK2PMKJdo+Dyg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.61.0.tgz",
+      "integrity": "sha512-l3FAAOyKJXH2ea6KNFN+MMgC/rnE94YGLXs2ehYqDcCoHt1DpvgWX75BhUJxN38XojP7Ul+4H8PRn7EdyqSDrw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.61.0.tgz",
+      "integrity": "sha512-VokPN3TSctKj65cyCNPaUh4vMFA8awxOot/0sp+4J7ZlNRKQEhXhawqPwajoi8H5ZFt61i0ugZJuTKXBjGJ17Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.61.0.tgz",
+      "integrity": "sha512-DxH0P3wxm+Yzs/p3zrk9dw1rURu8p0Nv5+MRK/L7OtnLNg5rLZraSBFZ8iUXOd9f2BlhJyEpIZUH/emjq4UJ4g==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.61.0.tgz",
+      "integrity": "sha512-T6ZvMNe84kAz6TBWHC7hGAoEtzP1LWYw/AqayGWEF6uISt3Abk/st06LqRD9THd7Xz3NxzurUpzAuEAUbZf+nw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.61.0.tgz",
+      "integrity": "sha512-q/4hzvQkDs8b4jIBab1pnLiiM0ayTZsN2amBFPDzuyZxjEd4wDwx0UJFYM3cOZzSf5Kw8fnWSprJzIBMkcR44Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.61.0.tgz",
+      "integrity": "sha512-vvYWX3akdEAY6km+9wAqFDnk6pQsbJKVnj7xawcvs/+fdlYBGp+U+Qq/lLfpIxYIZvZLHMAKD9HLdacSx/r3dw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.61.0.tgz",
+      "integrity": "sha512-DePa5cqOxDP/Zp0VOXpeWaGew5iIv5DXp9NYbzkX5PFQyWVX9184WCTh3hvr/7lhXo8ZVlbFLkz8+o/q1dU6gA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.61.0.tgz",
+      "integrity": "sha512-LV8aWMB8UChglMCEzs7RkN0GsH29RJaLLqwm9fCIjlqwxQTiWAqNcc7wjBkH31hV0PU/yVxGYvrYsgfea2qw6g==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.61.0.tgz",
+      "integrity": "sha512-QoNSnwQtaeNu5grdBbsL0tt1uyl5EnS8DA8Mr3nluMXbhdQNyhN+G4tBax7VCdxLKj8YJ0/4OO9Ho84jMnJtKA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.61.0.tgz",
+      "integrity": "sha512-/zZp5MKapIIApE8trN8qLGNSiRN9TUoaUZ1cmVu4XnVdd5LQLOXTtyi+vtfUbNnT3iyjzpPqYeKXmvJ+gJGYWw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.61.0.tgz",
+      "integrity": "sha512-RbrzcD3aJ1k3UbtMRRBNwojdVVyXjuVAFTfn/xPa6EEl6GE9Sm/akPgFTb9aAC9pMKGJ6CtWxaGrqWcabH+ySg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.61.0.tgz",
+      "integrity": "sha512-ZF+onDsBso8PJf1XaG9lB+O9RnBpKGnY6OrzC4CSHrtC1jb6jWLTKK4bRqdoCXHd22gyr2hiYmEAm8Wns/BOCw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.61.0.tgz",
+      "integrity": "sha512-Atk0aSIk5Zx2Wuh9dgRQgLP0Koc8hOeYpbWryMXyk8G8/HmPkwPPkMqIIDhrXHHYqfUzSJA/I7IWSBv8xSmRBA==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.61.0.tgz",
+      "integrity": "sha512-0uMOcf3eZ5K+K4cYHkdxShFMPlPXCOdfDFEFn9dNYAEEd2cVvmOfH7zFgRVoDgmtQ1m9k5q7qfrHzyMAubKYUA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.61.0.tgz",
+      "integrity": "sha512-mvFtE4A/t/7hRJ7X8Ozmu8FsIkAUat2nzl12pgU337BRmq87AQUJztwHz2Zv5/tjo9/C95E66CK03SI/ToEDJw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.61.0.tgz",
+      "integrity": "sha512-z9b9+aTxvt8n2rNltMPvyaUfB8NJ+CVyOrGK/MdIKHx7B+lXmZpm/XbRsU7Rpf3fRqJ2uS6mBJiJveCtq8LHDg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.61.0.tgz",
+      "integrity": "sha512-jXaXFqKMehsOc+g8R6oo33RRC6w07G9jDBxAE5eAKX7mOcCbZloYIPNhfG9Wl+P9O9IWHFO4OJgPi1Ml2qkt7w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.61.0.tgz",
+      "integrity": "sha512-OXNWVFocS2IA4+QplhTZZ2a+8hPZR7T8KuozsNmJKK8y7cp83StHvGksfHzPG3wczWTczyWHVQuqeiTUbjiyBg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.61.0.tgz",
+      "integrity": "sha512-AlAbNtBO637LxSldqV43z0FfXoGfl2TW1DgAg/bs7aQswFbDewz2SJm3BUhiGfbOVtW571xbc9p+REdxhyN/Eg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.61.0.tgz",
+      "integrity": "sha512-QRSrQXyJ1M4tjNXdR0/G/IgV6lzfQQJYBjlWIEYkY2Xs86DRl/iEpQ4blMDjJxSl7n19eDKKXMg0AmuBVYy8pQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.61.0.tgz",
+      "integrity": "sha512-tkuFxhvKO/HlGd0VsINF6vHSYH8AF8W0TcNxKDK6JZmrehngFj78pToc8iemtnvwilDjs2G/qSzYFhe9U8q+fw==",
+      "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/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/@types/geojson": {
+      "version": "7946.0.16",
+      "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.16.tgz",
+      "integrity": "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/leaflet": {
+      "version": "1.9.21",
+      "resolved": "https://registry.npmjs.org/@types/leaflet/-/leaflet-1.9.21.tgz",
+      "integrity": "sha512-TbAd9DaPGSnzp6QvtYngntMZgcRk+igFELwR2N99XZn7RXUdKgsXMR+28bUO0rPsWp8MIu/f47luLIQuSLYv/w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/geojson": "*"
+      }
+    },
+    "node_modules/@types/prop-types": {
+      "version": "15.7.15",
+      "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
+      "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/react": {
+      "version": "18.3.30",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.30.tgz",
+      "integrity": "sha512-3ek6mwJL5/VBewBcY4S66cqlCtK3qi4WIq37Z0m/NHw1hjhI7274Mx1qz/+ggSzyBCOEf7eHjBN6INjPAWYfYw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/prop-types": "*",
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "18.3.7",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz",
+      "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^18.0.0"
+      }
+    },
+    "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/any-promise": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
+      "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/arg": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",
+      "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/autoprefixer": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.5.0.tgz",
+      "integrity": "sha512-FMhOoZV4+qR6aTUALKX2rEqGG+oyATvwBt9IIzVR5rMa2HRWPkxf+P+PAJLD1I/H5/II+HuZcBJYEFBpq39ong==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/autoprefixer"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.28.2",
+        "caniuse-lite": "^1.0.30001787",
+        "fraction.js": "^5.3.4",
+        "picocolors": "^1.1.1",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "bin": {
+        "autoprefixer": "bin/autoprefixer"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      },
+      "peerDependencies": {
+        "postcss": "^8.1.0"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.33",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.33.tgz",
+      "integrity": "sha512-bA6+tcSLpz2tIEdDXZPpPTIuxBcC4+w6SieaYyfigIa4h8GlFxbA17v22Vx3JUtuZQj9SgOsnbK+aTBzyDyEuw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "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/camelcase-css": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz",
+      "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001793",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001793.tgz",
+      "integrity": "sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA==",
+      "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/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/chokidar/node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/commander": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
+      "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==",
+      "dev": true,
+      "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/cssesc": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
+      "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "cssesc": "bin/cssesc"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "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==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "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/didyoumean": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz",
+      "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/dlv": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz",
+      "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.366",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.366.tgz",
+      "integrity": "sha512-OlRuhb688YTCzzU3gXPLn6nGyd+F+53INE1qaKKlu6kETErE8FYsyDh0XqXEU+uBRn0MpCzz2vfNwORhkap8qg==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",
+      "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.12",
+        "@esbuild/android-arm": "0.25.12",
+        "@esbuild/android-arm64": "0.25.12",
+        "@esbuild/android-x64": "0.25.12",
+        "@esbuild/darwin-arm64": "0.25.12",
+        "@esbuild/darwin-x64": "0.25.12",
+        "@esbuild/freebsd-arm64": "0.25.12",
+        "@esbuild/freebsd-x64": "0.25.12",
+        "@esbuild/linux-arm": "0.25.12",
+        "@esbuild/linux-arm64": "0.25.12",
+        "@esbuild/linux-ia32": "0.25.12",
+        "@esbuild/linux-loong64": "0.25.12",
+        "@esbuild/linux-mips64el": "0.25.12",
+        "@esbuild/linux-ppc64": "0.25.12",
+        "@esbuild/linux-riscv64": "0.25.12",
+        "@esbuild/linux-s390x": "0.25.12",
+        "@esbuild/linux-x64": "0.25.12",
+        "@esbuild/netbsd-arm64": "0.25.12",
+        "@esbuild/netbsd-x64": "0.25.12",
+        "@esbuild/openbsd-arm64": "0.25.12",
+        "@esbuild/openbsd-x64": "0.25.12",
+        "@esbuild/openharmony-arm64": "0.25.12",
+        "@esbuild/sunos-x64": "0.25.12",
+        "@esbuild/win32-arm64": "0.25.12",
+        "@esbuild/win32-ia32": "0.25.12",
+        "@esbuild/win32-x64": "0.25.12"
+      }
+    },
+    "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/fast-glob": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
+      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.stat": "^2.0.2",
+        "@nodelib/fs.walk": "^1.2.3",
+        "glob-parent": "^5.1.2",
+        "merge2": "^1.3.0",
+        "micromatch": "^4.0.8"
+      },
+      "engines": {
+        "node": ">=8.6.0"
+      }
+    },
+    "node_modules/fast-glob/node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/fastq": {
+      "version": "1.20.1",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz",
+      "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "reusify": "^1.0.4"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fraction.js": {
+      "version": "5.3.4",
+      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz",
+      "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/rawify"
+      }
+    },
+    "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/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "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/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-core-module": {
+      "version": "2.16.2",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.2.tgz",
+      "integrity": "sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "hasown": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/jiti": {
+      "version": "1.21.7",
+      "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
+      "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jiti": "bin/jiti.js"
+      }
+    },
+    "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/leaflet": {
+      "version": "1.9.4",
+      "resolved": "https://registry.npmjs.org/leaflet/-/leaflet-1.9.4.tgz",
+      "integrity": "sha512-nxS1ynzJOmOlHp+iL3FyWqK89GtNL8U8rvlMOsQdTTssxZwCXh8N2NB3GDQOL+YR3XnWyZAxwQixURb+FA74PA==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/lilconfig": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
+      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antonk52"
+      }
+    },
+    "node_modules/lines-and-columns": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
+      "dev": true,
+      "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/merge2": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/micromatch": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "braces": "^3.0.3",
+        "picomatch": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=8.6"
+      }
+    },
+    "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/mz": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
+      "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "any-promise": "^1.0.0",
+        "object-assign": "^4.0.1",
+        "thenify-all": "^1.0.0"
+      }
+    },
+    "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/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "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==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-hash": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz",
+      "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "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/picomatch": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/pify": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
+      "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/pirates": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz",
+      "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "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/postcss-import": {
+      "version": "15.1.0",
+      "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz",
+      "integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "postcss-value-parser": "^4.0.0",
+        "read-cache": "^1.0.0",
+        "resolve": "^1.1.7"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.0.0"
+      }
+    },
+    "node_modules/postcss-js": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.1.0.tgz",
+      "integrity": "sha512-oIAOTqgIo7q2EOwbhb8UalYePMvYoIeRY2YKntdpFQXNosSu3vLrniGgmH9OKs/qAkfoj5oB3le/7mINW1LCfw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "camelcase-css": "^2.0.1"
+      },
+      "engines": {
+        "node": "^12 || ^14 || >= 16"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4.21"
+      }
+    },
+    "node_modules/postcss-load-config": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz",
+      "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "lilconfig": "^3.1.1"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "jiti": ">=1.21.0",
+        "postcss": ">=8.0.9",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        },
+        "postcss": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/postcss-nested": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz",
+      "integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "postcss-selector-parser": "^6.1.1"
+      },
+      "engines": {
+        "node": ">=12.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.2.14"
+      }
+    },
+    "node_modules/postcss-selector-parser": {
+      "version": "6.1.2",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+      "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postcss-value-parser": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+      "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/queue-microtask": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "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-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/read-cache": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
+      "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "pify": "^2.3.0"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/resolve": {
+      "version": "1.22.12",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz",
+      "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "is-core-module": "^2.16.1",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      },
+      "bin": {
+        "resolve": "bin/resolve"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/reusify": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
+      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "iojs": ">=1.0.0",
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.61.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.61.0.tgz",
+      "integrity": "sha512-T9mWdbWfQtp0B5lv/HX+wrhYsmXRlcWnXXmJbXqKJhlRaoS6KMhq0gpyzW4UJfclcxrEdLnTgjT2NjruLONu0g==",
+      "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.61.0",
+        "@rollup/rollup-android-arm64": "4.61.0",
+        "@rollup/rollup-darwin-arm64": "4.61.0",
+        "@rollup/rollup-darwin-x64": "4.61.0",
+        "@rollup/rollup-freebsd-arm64": "4.61.0",
+        "@rollup/rollup-freebsd-x64": "4.61.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.61.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.61.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.61.0",
+        "@rollup/rollup-linux-arm64-musl": "4.61.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.61.0",
+        "@rollup/rollup-linux-loong64-musl": "4.61.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.61.0",
+        "@rollup/rollup-linux-ppc64-musl": "4.61.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.61.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.61.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.61.0",
+        "@rollup/rollup-linux-x64-gnu": "4.61.0",
+        "@rollup/rollup-linux-x64-musl": "4.61.0",
+        "@rollup/rollup-openbsd-x64": "4.61.0",
+        "@rollup/rollup-openharmony-arm64": "4.61.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.61.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.61.0",
+        "@rollup/rollup-win32-x64-gnu": "4.61.0",
+        "@rollup/rollup-win32-x64-msvc": "4.61.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/run-parallel": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "queue-microtask": "^1.2.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/sucrase": {
+      "version": "3.35.1",
+      "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz",
+      "integrity": "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.2",
+        "commander": "^4.0.0",
+        "lines-and-columns": "^1.1.6",
+        "mz": "^2.7.0",
+        "pirates": "^4.0.1",
+        "tinyglobby": "^0.2.11",
+        "ts-interface-checker": "^0.1.9"
+      },
+      "bin": {
+        "sucrase": "bin/sucrase",
+        "sucrase-node": "bin/sucrase-node"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/supports-preserve-symlinks-flag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/tailwindcss": {
+      "version": "3.4.19",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz",
+      "integrity": "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@alloc/quick-lru": "^5.2.0",
+        "arg": "^5.0.2",
+        "chokidar": "^3.6.0",
+        "didyoumean": "^1.2.2",
+        "dlv": "^1.1.3",
+        "fast-glob": "^3.3.2",
+        "glob-parent": "^6.0.2",
+        "is-glob": "^4.0.3",
+        "jiti": "^1.21.7",
+        "lilconfig": "^3.1.3",
+        "micromatch": "^4.0.8",
+        "normalize-path": "^3.0.0",
+        "object-hash": "^3.0.0",
+        "picocolors": "^1.1.1",
+        "postcss": "^8.4.47",
+        "postcss-import": "^15.1.0",
+        "postcss-js": "^4.0.1",
+        "postcss-load-config": "^4.0.2 || ^5.0 || ^6.0",
+        "postcss-nested": "^6.2.0",
+        "postcss-selector-parser": "^6.1.2",
+        "resolve": "^1.22.8",
+        "sucrase": "^3.35.0"
+      },
+      "bin": {
+        "tailwind": "lib/cli.js",
+        "tailwindcss": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/thenify": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz",
+      "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "any-promise": "^1.0.0"
+      }
+    },
+    "node_modules/thenify-all": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz",
+      "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "thenify": ">= 3.1.0 < 4"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.17",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tinyglobby/node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tinyglobby/node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/ts-interface-checker": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
+      "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "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/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vite": {
+      "version": "6.4.3",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.3.tgz",
+      "integrity": "sha512-NTKlcQjlAK7MlQoyb6LgaqHc8sso/pVyUJYWMws3jg21uTJw/LddqIFPcPqP6PzpgbIcZyKI85sFE4HBrQDA8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.3",
+        "rollup": "^4.34.9",
+        "tinyglobby": "^0.2.13"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.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 || >=22.0.0",
+        "jiti": ">=1.21.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite/node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite/node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "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,27 @@
+{
+  "name": "geovision-pro-frontend",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "leaflet": "^1.9.4",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/leaflet": "^1.9.15",
+    "@types/react": "^18.3.18",
+    "@types/react-dom": "^18.3.5",
+    "@vitejs/plugin-react": "^4.3.4",
+    "autoprefixer": "^10.4.20",
+    "postcss": "^8.4.49",
+    "tailwindcss": "^3.4.17",
+    "typescript": "^5.7.2",
+    "vite": "^6.0.5"
+  }
+}

frontend/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};

frontend/src/App.tsx

@@ -0,0 +1,114 @@
+import { useCallback, useEffect, useState } from "react";
+import {
+  analyzeBatch, analyzeImage, analyzeVideo, deleteJob, listJobs,
+} from "./api";
+import type { AnalysisResult, JobListItem } from "./types";
+import UploadPanel from "./components/UploadPanel";
+import ReferencePanel from "./components/ReferencePanel";
+import MapView from "./components/MapView";
+import CandidateList from "./components/CandidateList";
+import Explain from "./components/Explain";
+import HistoryPanel from "./components/HistoryPanel";
+import ReportButtons from "./components/ReportButtons";
+
+export default function App() {
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+  const [result, setResult] = useState<AnalysisResult | null>(null);
+  const [batch, setBatch] = useState<AnalysisResult[]>([]);
+  const [jobs, setJobs] = useState<JobListItem[]>([]);
+
+  const refreshJobs = useCallback(async () => {
+    try { setJobs(await listJobs()); } catch { /* ignore */ }
+  }, []);
+
+  useEffect(() => { refreshJobs(); }, [refreshJobs]);
+
+  const run = useCallback(async (fn: () => Promise<void>) => {
+    setBusy(true); setError("");
+    try { await fn(); } catch (e) { setError((e as Error).message); }
+    finally { setBusy(false); refreshJobs(); }
+  }, [refreshJobs]);
+
+  const onImages = (files: File[]) => run(async () => {
+    if (files.length === 1) {
+      const r = await analyzeImage(files[0]);
+      setResult(r); setBatch([]);
+    } else {
+      const rs = await analyzeBatch(files);
+      setBatch(rs); setResult(rs[0] || null);
+    }
+  });
+
+  const onVideo = (file: File) => run(async () => {
+    const r = await analyzeVideo(file);
+    setResult(r); setBatch([]);
+  });
+
+  const openJob = (id: number) => run(async () => {
+    const r = await fetch(`${import.meta.env.VITE_API_BASE || "/api"}/jobs/${id}`).then((x) => x.json());
+    setResult(r); setBatch([]);
+  });
+
+  const removeJob = async (id: number) => { await deleteJob(id); refreshJobs(); if (result?.id === id) setResult(null); };
+
+  return (
+    <div className="min-h-full">
+      <header className="border-b border-edge bg-panel/60 backdrop-blur sticky top-0 z-[1000]">
+        <div className="max-w-6xl mx-auto px-4 py-3 flex items-center justify-between">
+          <div className="font-extrabold text-xl">Geo<span className="text-accent">Vision</span> Pro</div>
+          <div className="text-xs text-muted hidden sm:block">
+            Land/Region zuverlässig · Stadt nur bei GPS/Schild · transparente Unsicherheit
+          </div>
+        </div>
+      </header>
+
+      <main className="max-w-6xl mx-auto px-4 py-5 grid lg:grid-cols-3 gap-4">
+        {/* Left: map + candidates (main focus) */}
+        <section className="lg:col-span-2 space-y-4">
+          <div className="card">
+            <div className="flex items-center justify-between mb-3">
+              <h2 className="font-bold">Karte</h2>
+              {result && <ReportButtons id={result.id} />}
+            </div>
+            <MapView candidates={result?.candidates ?? []} />
+            {result?.model_used && (
+              <p className="text-xs text-muted mt-2">Modell: {result.model_used}</p>
+            )}
+          </div>
+          {result && <CandidateList result={result} />}
+          {batch.length > 1 && (
+            <div className="card">
+              <h2 className="font-bold mb-2">Batch-Ergebnisse ({batch.length})</h2>
+              <div className="space-y-1 text-sm">
+                {batch.map((b, i) => (
+                  <button key={i} onClick={() => setResult(b)}
+                    className="w-full text-left bg-panel2 border border-edge rounded-lg px-3 py-2 hover:border-accent">
+                    <span className="font-semibold">{b.candidates[0]?.label || "—"}</span>
+                    <span className="text-muted"> · {b.source_name}</span>
+                  </button>
+                ))}
+              </div>
+            </div>
+          )}
+        </section>
+
+        {/* Right: upload + explain + history */}
+        <section className="space-y-4">
+          <UploadPanel busy={busy} onImages={onImages} onVideo={onVideo} />
+          {error && (
+            <div className="card border-rose-700/50 text-rose-300 text-sm">Fehler: {error}</div>
+          )}
+          <ReferencePanel />
+          {result && <Explain result={result} />}
+          <HistoryPanel jobs={jobs} onOpen={openJob} onDelete={removeJob} />
+        </section>
+      </main>
+
+      <footer className="max-w-6xl mx-auto px-4 py-6 text-xs text-muted">
+        Keine Personenidentifikation · Kennzeichen nur als Format/Farbe, keine OCR konkreter Nummern ·
+        Karte © OpenStreetMap · Geocoding Nominatim
+      </footer>
+    </div>
+  );
+}

frontend/src/api.ts

@@ -0,0 +1,69 @@
+import type { AnalysisResult, JobListItem } from "./types";
+
+const BASE = import.meta.env.VITE_API_BASE || "/api";
+
+async function handle<T>(res: Response): Promise<T> {
+  if (!res.ok) {
+    let detail = res.statusText;
+    try { detail = (await res.json()).detail || detail; } catch { /* ignore */ }
+    throw new Error(detail);
+  }
+  return res.json() as Promise<T>;
+}
+
+export async function analyzeImage(file: File): Promise<AnalysisResult> {
+  const fd = new FormData();
+  fd.append("file", file);
+  return handle(await fetch(`${BASE}/analyze/image`, { method: "POST", body: fd }));
+}
+
+export async function analyzeBatch(files: File[]): Promise<AnalysisResult[]> {
+  const fd = new FormData();
+  files.forEach((f) => fd.append("files", f));
+  return handle(await fetch(`${BASE}/analyze/batch`, { method: "POST", body: fd }));
+}
+
+export async function analyzeVideo(file: File): Promise<AnalysisResult> {
+  const fd = new FormData();
+  fd.append("file", file);
+  return handle(await fetch(`${BASE}/analyze/video`, { method: "POST", body: fd }));
+}
+
+export async function listJobs(limit = 50): Promise<JobListItem[]> {
+  return handle(await fetch(`${BASE}/jobs?limit=${limit}`));
+}
+
+export async function deleteJob(id: number): Promise<void> {
+  await fetch(`${BASE}/jobs/${id}`, { method: "DELETE" });
+}
+
+export function reportUrl(id: number, fmt: "pdf" | "csv" | "json"): string {
+  return `${BASE}/report/${id}.${fmt}`;
+}
+
+export async function getStatus(): Promise<Record<string, unknown>> {
+  return handle(await fetch(`${BASE}/status`));
+}
+
+export interface ReferenceEntry { name: string; lat: number | null; lon: number | null; }
+export interface ReferenceList {
+  reference_images: number;
+  reference_geolocated: number;
+  entries: ReferenceEntry[];
+}
+
+export async function listReference(): Promise<ReferenceList> {
+  return handle(await fetch(`${BASE}/reference/list`));
+}
+
+export async function addReference(
+  file: File,
+  opts: { place?: string; lat?: number; lon?: number },
+): Promise<Record<string, unknown>> {
+  const fd = new FormData();
+  fd.append("file", file);
+  if (opts.place) fd.append("place", opts.place);
+  if (opts.lat !== undefined && !Number.isNaN(opts.lat)) fd.append("lat", String(opts.lat));
+  if (opts.lon !== undefined && !Number.isNaN(opts.lon)) fd.append("lon", String(opts.lon));
+  return handle(await fetch(`${BASE}/reference/add`, { method: "POST", body: fd }));
+}

frontend/src/components/CandidateList.tsx

@@ -0,0 +1,60 @@
+import type { AnalysisResult } from "../types";
+
+const SOURCE_LABEL: Record<string, string> = {
+  exif: "GPS-Metadaten (exakt)",
+  ocr: "Schildtext (geocodiert)",
+  reference: "Referenzgalerie (Bild-Retrieval)",
+  picarta: "Picarta-API (GeoSpy-Klasse)",
+  geoclip: "GeoCLIP-Koordinaten (Modell-Schätzung)",
+  inference: "Bildinferenz (Land/Region)",
+};
+
+export default function CandidateList({ result }: { result: AnalysisResult }) {
+  const h = result.hierarchy;
+  return (
+    <div className="card">
+      <div className="flex items-center justify-between mb-3">
+        <h2 className="font-bold">Standort-Hypothesen</h2>
+        <span className="text-xs px-2 py-1 rounded-full border border-edge text-muted">
+          {SOURCE_LABEL[result.location_source] || result.location_source}
+        </span>
+      </div>
+
+      {/* Hierarchy */}
+      <div className="grid grid-cols-2 sm:grid-cols-5 gap-2 mb-3 text-center text-sm">
+        {[["Kontinent", h.continent], ["Land", h.country], ["Region", h.region],
+          ["Stadt", h.city], ["Stadtteil", h.district]].map(([k, v]) => (
+          <div key={k as string} className="bg-panel2 rounded-lg p-2 border border-edge">
+            <div className="text-muted text-[11px]">{k}</div>
+            <div className="font-semibold truncate">{(v as string) || "—"}</div>
+          </div>
+        ))}
+      </div>
+      {h.note && <p className="text-xs text-muted mb-3">{h.note}</p>}
+
+      {/* Candidates */}
+      <div className="space-y-2">
+        {result.candidates.map((c) => (
+          <div key={c.rank} className="bg-panel2 rounded-lg p-3 border border-edge">
+            <div className="flex items-center gap-3">
+              <span className="text-muted font-bold w-5">{c.rank}</span>
+              <span className="flex-1 font-semibold truncate">{c.label}</span>
+              <span className="text-muted text-sm tabular-nums">{Math.round(c.confidence * 100)}%</span>
+            </div>
+            <div className="bar mt-2"><span style={{ width: `${Math.round(c.confidence * 100)}%` }} /></div>
+            {c.reasoning && <p className="text-xs text-muted mt-2">{c.reasoning}</p>}
+          </div>
+        ))}
+        {result.candidates.length === 0 && (
+          <p className="text-muted text-sm">Keine Kandidaten ermittelt.</p>
+        )}
+      </div>
+
+      {result.uncertainty && (
+        <div className="mt-3 text-xs text-amber-300/90 bg-amber-500/5 border border-amber-700/40 rounded-lg p-2.5">
+          ⚠️ Unsicherheit: {result.uncertainty}
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/components/Explain.tsx

@@ -0,0 +1,55 @@
+import type { AnalysisResult } from "../types";
+
+export default function Explain({ result }: { result: AnalysisResult }) {
+  return (
+    <div className="card">
+      <h2 className="font-bold mb-3">Erklärung (Explainable AI)</h2>
+      <p className="text-xs text-muted mb-3">
+        Gewichte = relative Sicherheit jeder Bildmerkmal-Kategorie. Sie zeigen, welche Hinweise die
+        Schätzung getragen haben — keine erfundenen Zahlen.
+      </p>
+      <div className="space-y-3">
+        {result.signals.map((g) => (
+          <div key={g.name}>
+            <div className="flex justify-between text-sm">
+              <span className="font-semibold">{g.name}</span>
+              <span className="text-muted tabular-nums">{Math.round(g.weight * 100)}%</span>
+            </div>
+            <div className="bar mt-1"><span style={{ width: `${Math.round(g.weight * 100)}%` }} /></div>
+            <div className="text-xs text-muted mt-1">
+              {g.top.map((t) => `${t.label} (${Math.round(t.score * 100)}%)`).join(" · ")}
+            </div>
+          </div>
+        ))}
+        {result.signals.length === 0 && <p className="text-muted text-sm">Keine Merkmalsanalyse (z. B. Video).</p>}
+      </div>
+
+      {result.ocr_text && (
+        <div className="mt-4">
+          <div className="font-semibold text-sm mb-1">Erkannter Text (OCR)</div>
+          <pre className="text-xs bg-panel2 border border-edge rounded-lg p-2 whitespace-pre-wrap">{result.ocr_text}</pre>
+        </div>
+      )}
+
+      <div className="mt-4">
+        <div className="font-semibold text-sm mb-1">Referenzvergleich</div>
+        {result.reference_matches.length > 0 ? (
+          <ul className="text-xs text-muted space-y-1">
+            {result.reference_matches.map((m) => (
+              <li key={m.name} className="flex justify-between">
+                <span className="truncate">{m.name}</span>
+                <span className="tabular-nums">{Math.round(m.similarity * 100)}%</span>
+              </li>
+            ))}
+          </ul>
+        ) : (
+          <p className="text-xs text-muted">
+            Keine eigene Referenz-Bilddatenbank konfiguriert. Für „ähnliche Bilder weltweit" das Foto
+            in eine Bildsuche geben:{" "}
+            <a className="text-accent2" href="https://lens.google.com/" target="_blank" rel="noopener">Google Lens</a>.
+          </p>
+        )}
+      </div>
+    </div>
+  );
+}

frontend/src/components/HistoryPanel.tsx

@@ -0,0 +1,30 @@
+import type { JobListItem } from "../types";
+
+interface Props {
+  jobs: JobListItem[];
+  onOpen: (id: number) => void;
+  onDelete: (id: number) => void;
+}
+
+export default function HistoryPanel({ jobs, onOpen, onDelete }: Props) {
+  return (
+    <div className="card">
+      <h2 className="font-bold mb-3">Verlauf</h2>
+      {jobs.length === 0 && <p className="text-muted text-sm">Noch keine Analysen.</p>}
+      <div className="space-y-2 max-h-[360px] overflow-auto pr-1">
+        {jobs.map((j) => (
+          <div key={j.id} className="flex items-center gap-2 bg-panel2 border border-edge rounded-lg p-2">
+            <button onClick={() => onOpen(j.id)} className="flex-1 text-left min-w-0">
+              <div className="font-semibold text-sm truncate">{j.best_label || "—"}</div>
+              <div className="text-xs text-muted">
+                {new Date(j.created_at).toLocaleString("de-DE")} · {j.kind} · {j.location_source}
+                {j.best_confidence != null && ` · ${Math.round(j.best_confidence * 100)}%`}
+              </div>
+            </button>
+            <button onClick={() => onDelete(j.id)} className="text-rose-400 px-2 text-lg" title="Löschen">×</button>
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}

frontend/src/components/MapView.tsx

@@ -0,0 +1,61 @@
+import { useEffect, useRef } from "react";
+import L from "leaflet";
+import type { LocationCandidate } from "../types";
+
+interface Props {
+  candidates: LocationCandidate[];
+}
+
+// Interactive world map: best candidate emphasized, alternatives shown,
+// a probability radius drawn around the top hit, and a light heat overlay.
+export default function MapView({ candidates }: Props) {
+  const elRef = useRef<HTMLDivElement>(null);
+  const mapRef = useRef<L.Map | null>(null);
+  const layerRef = useRef<L.LayerGroup | null>(null);
+
+  useEffect(() => {
+    if (!elRef.current || mapRef.current) return;
+    const map = L.map(elRef.current, { worldCopyJump: true }).setView([20, 0], 2);
+    L.tileLayer("https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", {
+      maxZoom: 19,
+      attribution: "© OpenStreetMap-Mitwirkende",
+    }).addTo(map);
+    layerRef.current = L.layerGroup().addTo(map);
+    mapRef.current = map;
+  }, []);
+
+  useEffect(() => {
+    const map = mapRef.current;
+    const layer = layerRef.current;
+    if (!map || !layer) return;
+    layer.clearLayers();
+
+    const located = candidates.filter((c) => c.lat != null && c.lon != null);
+    if (located.length === 0) {
+      map.setView([20, 0], 2);
+      return;
+    }
+
+    located.forEach((c, i) => {
+      const isTop = i === 0;
+      const radiusKm = Math.max(40, (1 - c.confidence) * 600); // higher uncertainty -> bigger radius
+      L.circle([c.lat!, c.lon!], {
+        radius: radiusKm * 1000,
+        color: isTop ? "#56d4c4" : "#6c8cff",
+        weight: isTop ? 2 : 1,
+        opacity: isTop ? 0.9 : 0.4,
+        fillColor: isTop ? "#56d4c4" : "#6c8cff",
+        fillOpacity: isTop ? 0.18 : 0.07,
+      }).addTo(layer);
+
+      L.marker([c.lat!, c.lon!])
+        .addTo(layer)
+        .bindPopup(`<b>#${c.rank} ${c.label}</b><br/>${Math.round(c.confidence * 100)}%`);
+    });
+
+    const top = located[0];
+    map.setView([top.lat!, top.lon!], located.length === 1 ? 6 : 4);
+  }, [candidates]);
+
+  return <div ref={elRef} className="w-full h-[440px] rounded-xl border border-edge" />;
+}

frontend/src/components/ReferencePanel.tsx

@@ -0,0 +1,100 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { addReference, listReference } from "../api";
+import type { ReferenceList } from "../api";
+
+/**
+ * Grow the app's accuracy with your own geotagged photos — the practical,
+ * free "train it with more images" path. Pick a photo, say where it was taken
+ * (place name OR coordinates OR rely on the photo's own GPS), and add it.
+ */
+export default function ReferencePanel() {
+  const [info, setInfo] = useState<ReferenceList | null>(null);
+  const [file, setFile] = useState<File | null>(null);
+  const [place, setPlace] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [msg, setMsg] = useState("");
+  const [err, setErr] = useState("");
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  const refresh = useCallback(async () => {
+    try { setInfo(await listReference()); } catch { /* ignore */ }
+  }, []);
+  useEffect(() => { refresh(); }, [refresh]);
+
+  const add = useCallback(async () => {
+    if (!file) { setErr("Bitte zuerst ein Foto wählen."); return; }
+    setBusy(true); setErr(""); setMsg("");
+    try {
+      // Allow "lat, lon" typed directly into the place field.
+      const m = place.match(/^\s*(-?\d{1,2}\.\d+)\s*[,; ]\s*(-?\d{1,3}\.\d+)\s*$/);
+      const opts = m
+        ? { lat: parseFloat(m[1]), lon: parseFloat(m[2]) }
+        : { place: place.trim() || undefined };
+      const r = await addReference(file, opts);
+      setMsg(`Hinzugefügt ✓ (${r.reference_images} Fotos in der Galerie, Quelle: ${r.source})`);
+      setFile(null); setPlace("");
+      if (inputRef.current) inputRef.current.value = "";
+      refresh();
+    } catch (e) {
+      setErr((e as Error).message);
+    } finally { setBusy(false); }
+  }, [file, place, refresh]);
+
+  return (
+    <div className="card">
+      <h2 className="font-bold mb-1">Eigene Galerie (genauer machen)</h2>
+      <p className="text-xs text-muted mb-3">
+        Füge geotaggte Fotos hinzu — die App erkennt diese Orte danach deutlich
+        genauer. Je mehr, desto besser.
+        {info != null && (
+          <> {" "}<span className="text-accent">{info.reference_images} Fotos</span>
+            {" "}({info.reference_geolocated} mit Ort).</>
+        )}
+      </p>
+
+      <input
+        ref={inputRef}
+        type="file"
+        accept="image/*,.heic,.heif"
+        className="block w-full text-sm mb-2 file:mr-3 file:py-1.5 file:px-3 file:rounded-lg
+          file:border-0 file:bg-accent file:text-black file:font-semibold"
+        onChange={(e) => setFile(e.target.files?.[0] ?? null)}
+      />
+      <input
+        type="text"
+        value={place}
+        onChange={(e) => setPlace(e.target.value)}
+        placeholder='Ort (z. B. "Marienplatz, München") oder "48.1372, 11.5755"'
+        className="w-full bg-panel2 border border-edge rounded-lg px-3 py-2 text-sm mb-1"
+      />
+      <p className="text-[11px] text-muted mb-2">
+        Leer lassen, wenn das Foto bereits GPS-Daten enthält.
+      </p>
+
+      <button
+        onClick={add}
+        disabled={busy}
+        className="w-full bg-accent text-black font-semibold rounded-lg py-2 text-sm
+          disabled:opacity-50"
+      >
+        {busy ? "Füge hinzu …" : "Zur Galerie hinzufügen"}
+      </button>
+
+      {msg && <div className="text-emerald-400 text-xs mt-2">{msg}</div>}
+      {err && <div className="text-rose-300 text-xs mt-2">Fehler: {err}</div>}
+
+      {info && info.entries.length > 0 && (
+        <div className="mt-3 max-h-32 overflow-auto text-xs text-muted space-y-1">
+          {info.entries.slice().reverse().map((e, i) => (
+            <div key={i} className="flex justify-between gap-2">
+              <span className="truncate">{e.name}</span>
+              <span className="shrink-0">
+                {e.lat != null && e.lon != null ? `${e.lat.toFixed(3)}, ${e.lon.toFixed(3)}` : "—"}
+              </span>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}