Initial deploy

Dockerfile

@@ -0,0 +1,78 @@
+# HuggingFace Space — Unified Dockerfile
+#
+# Combines all 3 services (encoder + api + frontend) into one container.
+# HuggingFace Spaces only exposes port 7860 and doesn't support docker-compose.
+#
+# Architecture inside this container:
+#   supervisord manages 3 processes:
+#     - encoder (uvicorn on port 8001) — ONNX CLIP inference
+#     - api     (uvicorn on port 8000) — FAISS search + Whisper
+#     - nginx   (on port 7860)         — serves frontend + proxies /api → 8000
+#
+# On startup, start.sh downloads models + embeddings from HuggingFace Hub.
+
+# ── Stage 1: Build React frontend ─────────────────────────────────────────
+FROM node:18-alpine AS frontend-builder
+
+WORKDIR /app/frontend
+COPY services/frontend/package.json services/frontend/package-lock.json* ./
+RUN npm ci
+COPY services/frontend/ .
+
+# API is proxied via nginx at /api on port 7860
+ARG VITE_API_URL=""
+ENV VITE_API_URL=$VITE_API_URL
+RUN npm run build
+
+# ── Stage 2: Main runtime image ────────────────────────────────────────────
+FROM python:3.11-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    nginx \
+    supervisor \
+    ffmpeg \
+    git \
+    gcc \
+    g++ \
+    libgomp1 \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# ── Install Python dependencies ────────────────────────────────────────────
+COPY services/encoder/requirements.txt /tmp/encoder-requirements.txt
+COPY services/api/requirements.txt /tmp/api-requirements.txt
+
+RUN pip install --no-cache-dir --default-timeout=1200 \
+    -r /tmp/encoder-requirements.txt \
+    -r /tmp/api-requirements.txt \
+    huggingface_hub
+
+# ── Copy application code ──────────────────────────────────────────────────
+COPY services/encoder/main.py /app/encoder/main.py
+COPY services/api/main.py /app/api/main.py
+
+# ── Copy compiled frontend ─────────────────────────────────────────────────
+COPY --from=frontend-builder /app/frontend/dist /usr/share/nginx/html
+
+# ── Nginx config ───────────────────────────────────────────────────────────
+COPY hf-space/nginx.conf /etc/nginx/conf.d/default.conf
+RUN rm -f /etc/nginx/sites-enabled/default
+
+# ── Supervisord config ─────────────────────────────────────────────────────
+COPY hf-space/supervisord.conf /etc/supervisor/conf.d/supervisord.conf
+
+# ── Startup script ─────────────────────────────────────────────────────────
+COPY hf-space/start.sh /start.sh
+RUN chmod +x /start.sh
+
+# ── Create required directories ────────────────────────────────────────────
+RUN mkdir -p /app/models /app/embeddings /app/images /app/data /var/log/supervisor
+
+# HuggingFace Spaces runs as non-root user (uid 1000)
+RUN chown -R 1000:1000 /app /var/log/supervisor /var/lib/nginx /var/log/nginx \
+    && chmod -R 755 /app
+
+EXPOSE 7860
+
+CMD ["/start.sh"]

nginx.conf

@@ -0,0 +1,27 @@
+server {
+    listen 7860;
+
+    # Serve React frontend
+    location / {
+        root /usr/share/nginx/html;
+        index index.html;
+        try_files $uri $uri/ /index.html;
+    }
+
+    # Proxy /api → FastAPI on port 8000
+    # Frontend calls /api/search/text instead of http://localhost:8000/search/text
+    location /api/ {
+        proxy_pass http://127.0.0.1:8000/;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_read_timeout 60s;
+        client_max_body_size 20M;
+    }
+
+    # Proxy /images → static image files served by API
+    location /images/ {
+        proxy_pass http://127.0.0.1:8000/images/;
+        proxy_set_header Host $host;
+        proxy_read_timeout 30s;
+    }
+}

services/api/Dockerfile

@@ -0,0 +1,48 @@
+# services/api/Dockerfile
+#
+# WHY THIS IS SEPARATE FROM THE ENCODER:
+#   If they were one container:
+#   - Restart API → also restarts encoder → 3s model reload on every code change
+#   - Scale horizontally → each replica carries the 90MB model in RAM
+#   - One crash takes down both search logic AND inference
+#
+#   Separate containers = independent restart, scale, update, and failure domains.
+#
+# THIS CONTAINER IS LIGHTER than the encoder:
+#   - No onnxruntime (that's the encoder's job)
+#   - Needs faiss-cpu, whisper, httpx (for calling encoder)
+#   - Target size: ~600MB
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+     git \
+    # ffmpeg is needed by Whisper to decode audio files (mp3, wav, webm, etc.)
+    # Without it, Whisper can only handle raw PCM.
+    # Size cost: ~80MB — worth it for voice search capability.
+    
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --upgrade pip setuptools wheel
+# RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir --no-build-isolation -r requirements.txt
+COPY main.py .
+
+# Create directories for runtime data
+# embeddings/ and data/ are mounted as volumes — not baked in
+RUN mkdir -p embeddings data images
+
+EXPOSE 8000
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"
+
+# 2 workers for the API (it's I/O bound — waiting on encoder HTTP calls)
+# I/O-bound services benefit from multiple workers because while one worker
+# waits for the encoder response, another can handle a new request.
+# The encoder is CPU-bound — multiple workers there would fight for CPU.
+CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "2"]

services/api/main.py

@@ -0,0 +1,557 @@
+"""
+services/api/main.py
+====================
+WHY THIS IS A SEPARATE SERVICE FROM THE ENCODER:
+  This service handles:
+    - FAISS index (search logic)
+    - Whisper (voice transcription)
+    - Request routing
+    - Feedback storage
+    - Result reranking
+
+  The encoder handles:
+    - ONNX inference (heavy ML model)
+
+  Separation means: if FAISS crashes, encoder keeps running.
+  If encoder needs to be swapped for GPU, API logic doesn't change.
+  They communicate over HTTP on the internal Docker network.
+
+WHISPER FOR VOICE SEARCH:
+  OpenAI Whisper is a speech-to-text model.
+  We use the "tiny" variant (39MB):
+    tiny:   39MB,  ~2s for 5s audio,  ~88% word accuracy
+    base:   74MB,  ~3s for 5s audio,  ~91% word accuracy
+    small:  244MB, ~6s for 5s audio,  ~94% word accuracy
+    medium: 769MB, ~15s for 5s audio, ~96% word accuracy
+    large:  1.5GB, ~30s for 5s audio, ~98% word accuracy
+
+  We chose TINY because:
+    - Search queries are short (3-10 words), not medical transcription
+    - 88% accuracy on "dog running in park" is effectively 100%
+    - 2 seconds latency vs 30 seconds for large is massive UX difference
+    - 39MB vs 1.5GB — fits comfortably in our Docker container
+
+  TRADEOFF: If user has strong accent or says complex phrases,
+  tiny might mishear. For a demo/portfolio, fine. For production,
+  add an option to select model size.
+
+THE RERANKER:
+  FAISS returns top-K results by vector distance.
+  Distance is a good but imperfect proxy for relevance.
+  The reranker applies additional signals:
+    1. Feedback boost: if user previously liked an image, boost similar ones
+    2. Diversity: don't return 10 photos from the same category
+    3. Recency: optionally boost recently added images
+
+  This is a LIGHTWEIGHT reranker — no neural network, just heuristics.
+  A full cross-encoder reranker (like BERT) would be more accurate but
+  adds 50-100ms latency. For search, perceived speed matters more than
+  marginal accuracy improvements.
+"""
+
+import os
+import io
+import pickle
+import logging
+import time
+import sqlite3
+from pathlib import Path
+from typing import Optional
+from contextlib import asynccontextmanager
+
+import numpy as np
+import faiss
+import httpx
+from fastapi import FastAPI, HTTPException, UploadFile, File
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+
+# ── Logging ───────────────────────────────────────────────────────────────────
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [api] %(message)s")
+log = logging.getLogger(__name__)
+
+# ── Configuration from environment ───────────────────────────────────────────
+# Using env vars (not hardcoded) so Docker Compose can configure them
+ENCODER_URL = os.getenv("ENCODER_URL", "http://encoder:8001")
+EMBEDDINGS_DIR = os.getenv("EMBEDDINGS_DIR", "embeddings")
+IMAGES_DIR = os.getenv("IMAGES_DIR", "images")
+DB_PATH = os.getenv("DB_PATH", "data/search.db")
+NPROBE = int(os.getenv("FAISS_NPROBE", "10"))
+
+# ── Global state ──────────────────────────────────────────────────────────────
+faiss_index = None
+metadata: list[dict] = []
+whisper_model = None
+db_conn: Optional[sqlite3.Connection] = None
+
+
+# ── Lifespan (replaces @app.on_event, modern FastAPI pattern) ─────────────────
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Load all resources on startup, clean up on shutdown."""
+    global faiss_index, metadata, whisper_model, db_conn
+
+    # Load FAISS index
+    index_path = os.path.join(EMBEDDINGS_DIR, "faiss.index")
+    meta_path = os.path.join(EMBEDDINGS_DIR, "metadata.pkl")
+
+    if Path(index_path).exists():
+        log.info(f"Loading FAISS index from {index_path}...")
+        faiss_index = faiss.read_index(index_path)
+        faiss_index.nprobe = NPROBE  # set search-time parameter
+        log.info(f"  Index loaded: {faiss_index.ntotal} vectors")
+    else:
+        log.warning(f"No FAISS index at {index_path}. Run ingest.py first.")
+
+    if Path(meta_path).exists():
+        with open(meta_path, "rb") as f:
+            metadata = pickle.load(f)
+        log.info(f"  Metadata loaded: {len(metadata)} records")
+
+    # Load Whisper (lazy — only if installed)
+    try:
+        import whisper
+        log.info("Loading Whisper tiny model for voice search...")
+        whisper_model = whisper.load_model("tiny")
+        log.info("  Whisper ready.")
+    except ImportError:
+        log.warning("Whisper not installed. Voice search disabled. "
+                    "Install with: pip install openai-whisper")
+    except Exception as e:
+        log.warning(f"Whisper load failed: {e}")
+
+    # Setup SQLite for feedback + query logging
+    Path(DB_PATH).parent.mkdir(parents=True, exist_ok=True)
+    db_conn = sqlite3.connect(DB_PATH, check_same_thread=False)
+    _init_db(db_conn)
+    log.info("Database ready.")
+
+    log.info("API service ready.")
+    yield  # ← app runs here
+
+    # Cleanup on shutdown
+    if db_conn:
+        db_conn.close()
+
+
+def _init_db(conn: sqlite3.Connection):
+    """Create tables if they don't exist."""
+    conn.executescript("""
+        CREATE TABLE IF NOT EXISTS queries (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            query_text TEXT,
+            query_type TEXT,   -- 'text', 'image', 'voice'
+            result_count INTEGER,
+            latency_ms REAL,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+
+        CREATE TABLE IF NOT EXISTS feedback (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            image_path TEXT NOT NULL,
+            query_text TEXT,
+            vote INTEGER NOT NULL,  -- +1 = thumbs up, -1 = thumbs down
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+    """)
+    conn.commit()
+
+
+app = FastAPI(
+    title="Visual Search API",
+    description="Semantic image search powered by CLIP + FAISS + Whisper",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Serve image files statically
+# This lets the React frontend load actual images
+images_path = Path(IMAGES_DIR)
+if images_path.exists():
+    app.mount("/images", StaticFiles(directory=str(images_path)), name="images")
+
+
+# ── Pydantic schemas ──────────────────────────────────────────────────────────
+class SearchResult(BaseModel):
+    path: str          # relative path for frontend to construct URL
+    url: str           # full URL to fetch the image
+    category: str
+    score: float       # similarity score 0-1 (higher = more similar)
+    rank: int
+
+class SearchResponse(BaseModel):
+    results: list[SearchResult]
+    query: str
+    query_type: str
+    total_found: int
+    latency_ms: float
+    encoder_latency_ms: float
+
+class FeedbackRequest(BaseModel):
+    image_path: str
+    query: str
+    vote: int  # +1 or -1
+
+class StatsResponse(BaseModel):
+    total_images: int
+    total_queries: int
+    index_type: str
+    nprobe: int
+    whisper_available: bool
+
+
+# ── Core search logic ─────────────────────────────────────────────────────────
+async def get_embedding_for_text(text: str) -> tuple[np.ndarray, float]:
+    """Call encoder service to get text embedding."""
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        resp = await client.post(
+            f"{ENCODER_URL}/embed/text",
+            json={"text": text},
+        )
+        if resp.status_code != 200:
+            raise HTTPException(502, f"Encoder error: {resp.text}")
+        data = resp.json()
+        return np.array(data["embedding"], dtype=np.float32), data["latency_ms"]
+
+
+async def get_embedding_for_image(image_bytes: bytes) -> tuple[np.ndarray, float]:
+    """Call encoder service to get image embedding."""
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        resp = await client.post(
+            f"{ENCODER_URL}/embed/image/upload",
+            files={"file": ("image.jpg", image_bytes, "image/jpeg")},
+        )
+        if resp.status_code != 200:
+            raise HTTPException(502, f"Encoder error: {resp.text}")
+        data = resp.json()
+        return np.array(data["embedding"], dtype=np.float32), data["latency_ms"]
+
+
+def faiss_search(
+    query_embedding: np.ndarray,
+    k: int = 20,
+) -> list[tuple[int, float]]:
+    """
+    Search FAISS index.
+    Returns list of (metadata_index, distance) sorted by distance ascending.
+
+    WHY k=20 when user wants top-10:
+      We fetch 20 (2x) because the reranker may reorder them.
+      Fetching more candidates = reranker has more to work with.
+      This is called "over-fetching" — standard practice in two-stage retrieval.
+    """
+    if faiss_index is None:
+        raise HTTPException(503, "FAISS index not loaded. Run ingest.py first.")
+
+    # FAISS expects shape [1, 512] for single query
+    query = query_embedding.reshape(1, -1)
+
+    # D = distances, I = indices into metadata list
+    D, I = faiss_index.search(query, k)
+
+    results = []
+    for dist, idx in zip(D[0], I[0]):
+        if idx == -1:  # -1 means FAISS couldn't find enough results
+            continue
+        results.append((int(idx), float(dist)))
+
+    return results
+
+
+def rerank(
+    results: list[tuple[int, float]],
+    query: str,
+    top_k: int = 10,
+) -> list[tuple[int, float]]:
+    """
+    Apply feedback signals to reorder FAISS results.
+
+    WHAT RERANKING DOES:
+      FAISS gives us [img1, img2, img3...] ordered by vector distance.
+      But vector distance doesn't know:
+        - Which images a USER has liked before
+        - Whether we're showing too many similar images (diversity)
+
+      The reranker adjusts scores based on this context.
+
+    FEEDBACK BOOST:
+      If user previously gave thumbs up to an image similar to the query,
+      we boost its score slightly. Not a lot — we don't want to overfit
+      to one user's preferences, but enough to personalize.
+
+    DIVERSITY PENALTY:
+      If we already have 3 images from the same category in top results,
+      the 4th one gets a small penalty. Prevents showing 10 dog photos
+      when searching "animals".
+
+    WHY NOT A NEURAL RERANKER:
+      Cross-encoder models (BERT-based) can rerank with 95%+ accuracy
+      but add 50-200ms latency per result set.
+      Our lightweight heuristic adds <1ms.
+      For a portfolio project, the heuristic is the right call.
+      For a production search engine serving 10k QPS, neural reranking
+      on a GPU is the right call.
+    """
+    if db_conn is None or not results:
+        return results[:top_k]
+
+    # Get feedback data for these image paths
+    relevant_paths = [metadata[idx]["path"] for idx, _ in results if idx < len(metadata)]
+    placeholders = ",".join(["?"] * len(relevant_paths))
+    cursor = db_conn.execute(
+        f"SELECT image_path, SUM(vote) as score FROM feedback "
+        f"WHERE image_path IN ({placeholders}) GROUP BY image_path",
+        relevant_paths,
+    )
+    feedback_scores = {row[0]: row[1] for row in cursor.fetchall()}
+
+    # Diversity tracking
+    category_counts: dict[str, int] = {}
+
+    adjusted = []
+    for idx, dist in results:
+        if idx >= len(metadata):
+            continue
+        record = metadata[idx]
+        path = record["path"]
+        category = record.get("category", "unknown")
+
+        # Convert L2 distance to similarity score [0, 1]
+        # L2 distance 0 = identical, grows as vectors diverge
+        # We convert: similarity = 1 / (1 + distance)
+        similarity = 1.0 / (1.0 + dist)
+
+        # Apply feedback boost
+        user_vote = feedback_scores.get(path, 0)
+        if user_vote > 0:
+            similarity *= 1.15  # 15% boost for liked images
+        elif user_vote < 0:
+            similarity *= 0.70  # 30% penalty for disliked images
+
+        # Apply diversity penalty
+        count_in_category = category_counts.get(category, 0)
+        if count_in_category >= 3:
+            similarity *= 0.90  # 10% penalty if category is already represented
+
+        category_counts[category] = count_in_category + 1
+        adjusted.append((idx, similarity))
+
+    # Sort by adjusted similarity descending
+    adjusted.sort(key=lambda x: x[1], reverse=True)
+    return adjusted[:top_k]
+
+
+def build_response(
+    ranked: list[tuple[int, float]],
+    query: str,
+    query_type: str,
+    encoder_latency: float,
+    total_latency: float,
+) -> SearchResponse:
+    """Build the final response from ranked results."""
+    results = []
+    for rank, (idx, score) in enumerate(ranked):
+        if idx >= len(metadata):
+            continue
+        record = metadata[idx]
+        path = record["path"]
+        # Convert local filesystem path to URL the frontend can use
+        # Docker volume mounts images at /images/ route
+        relative = path.replace("\\", "/")
+        # Extract everything after 'images/'
+        parts = relative.split("images/")
+        url_path = parts[-1] if len(parts) > 1 else os.path.basename(path)
+
+        results.append(SearchResult(
+            path=path,
+            url=f"/images/{url_path}",
+            category=record.get("category", "unknown"),
+            score=round(min(score, 1.0), 4),
+            rank=rank + 1,
+        ))
+
+    return SearchResponse(
+        results=results,
+        query=query,
+        query_type=query_type,
+        total_found=len(results),
+        latency_ms=round(total_latency, 1),
+        encoder_latency_ms=round(encoder_latency, 1),
+    )
+
+
+def log_query(query: str, query_type: str, result_count: int, latency_ms: float):
+    """Store query in SQLite for analytics."""
+    if db_conn:
+        try:
+            db_conn.execute(
+                "INSERT INTO queries (query_text, query_type, result_count, latency_ms) VALUES (?,?,?,?)",
+                (query, query_type, result_count, latency_ms),
+            )
+            db_conn.commit()
+        except Exception as e:
+            log.warning(f"Failed to log query: {e}")
+
+
+# ── API Endpoints ─────────────────────────────────────────────────────────────
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "ok",
+        "index_loaded": faiss_index is not None,
+        "image_count": faiss_index.ntotal if faiss_index else 0,
+        "whisper_available": whisper_model is not None,
+    }
+
+
+@app.get("/stats", response_model=StatsResponse)
+async def stats():
+    total_queries = 0
+    if db_conn:
+        row = db_conn.execute("SELECT COUNT(*) FROM queries").fetchone()
+        total_queries = row[0] if row else 0
+
+    index_type = "none"
+    if faiss_index:
+        index_type = type(faiss_index).__name__
+
+    return StatsResponse(
+        total_images=faiss_index.ntotal if faiss_index else 0,
+        total_queries=total_queries,
+        index_type=index_type,
+        nprobe=NPROBE,
+        whisper_available=whisper_model is not None,
+    )
+
+
+@app.get("/search/text")
+async def search_text(q: str, k: int = 10):
+    """
+    Text → image search.
+    User types "dog running in park" → returns top-k matching images.
+    """
+    if not q.strip():
+        raise HTTPException(400, "Query cannot be empty")
+
+    t0 = time.perf_counter()
+    embedding, encoder_ms = await get_embedding_for_text(q)
+    raw_results = faiss_search(embedding, k=k * 2)
+    ranked = rerank(raw_results, q, top_k=k)
+    latency = (time.perf_counter() - t0) * 1000
+
+    log_query(q, "text", len(ranked), latency)
+    return build_response(ranked, q, "text", encoder_ms, latency)
+
+
+@app.post("/search/image")
+async def search_image(file: UploadFile = File(...), k: int = 10):
+    """
+    Image → similar image search (reverse image search).
+    User uploads a photo → returns visually similar images.
+    """
+    t0 = time.perf_counter()
+    contents = await file.read()
+    embedding, encoder_ms = await get_embedding_for_image(contents)
+    raw_results = faiss_search(embedding, k=k * 2)
+    ranked = rerank(raw_results, "image_query", top_k=k)
+    latency = (time.perf_counter() - t0) * 1000
+
+    log_query("image_upload", "image", len(ranked), latency)
+    return build_response(ranked, "image_upload", "image", encoder_ms, latency)
+
+
+@app.post("/search/voice")
+async def search_voice(file: UploadFile = File(...), k: int = 10):
+    """
+    Voice → image search.
+    User speaks "show me photos of mountains at sunset"
+    → Whisper transcribes → CLIP searches → returns images.
+
+    Flow:
+      Audio file → Whisper tiny → transcribed text → same as /search/text
+    """
+    if whisper_model is None:
+        raise HTTPException(503, "Voice search not available. Whisper not installed.")
+
+    t0 = time.perf_counter()
+
+    # Save audio to temp file (Whisper needs a file path, not bytes)
+    import tempfile
+    audio_bytes = await file.read()
+    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
+        tmp.write(audio_bytes)
+        tmp_path = tmp.name
+
+    try:
+        # Whisper transcription
+        # fp16=False because we're on CPU (FP16 is GPU-only)
+        t_whisper = time.perf_counter()
+        result = whisper_model.transcribe(tmp_path, fp16=False, language="en")
+        whisper_ms = (time.perf_counter() - t_whisper) * 1000
+        transcription = result["text"].strip()
+        log.info(f"Voice transcription ({whisper_ms:.0f}ms): '{transcription}'")
+    finally:
+        os.unlink(tmp_path)  # clean up temp file
+
+    if not transcription:
+        raise HTTPException(400, "Could not transcribe audio")
+
+    # Now treat it exactly like a text search
+    embedding, encoder_ms = await get_embedding_for_text(transcription)
+    raw_results = faiss_search(embedding, k=k * 2)
+    ranked = rerank(raw_results, transcription, top_k=k)
+    latency = (time.perf_counter() - t0) * 1000
+
+    log_query(transcription, "voice", len(ranked), latency)
+
+    response = build_response(ranked, transcription, "voice", encoder_ms, latency)
+    # Add transcription to response so frontend can show "I heard: ..."
+    return {**response.dict(), "transcription": transcription, "whisper_ms": round(whisper_ms, 1)}
+
+
+@app.post("/feedback")
+async def submit_feedback(req: FeedbackRequest):
+    """
+    Store user feedback (thumbs up/down) for a search result.
+    Used by the reranker to personalize future results.
+    """
+    if req.vote not in (-1, 1):
+        raise HTTPException(400, "vote must be +1 or -1")
+    if db_conn:
+        db_conn.execute(
+            "INSERT INTO feedback (image_path, query_text, vote) VALUES (?,?,?)",
+            (req.image_path, req.query, req.vote),
+        )
+        db_conn.commit()
+    return {"status": "ok"}
+
+
+@app.get("/queries/recent")
+async def recent_queries(limit: int = 20):
+    """Return recent search queries for analytics."""
+    if db_conn is None:
+        return {"queries": []}
+    rows = db_conn.execute(
+        "SELECT query_text, query_type, result_count, latency_ms, timestamp "
+        "FROM queries ORDER BY timestamp DESC LIMIT ?",
+        (limit,),
+    ).fetchall()
+    return {"queries": [
+        {"query": r[0], "type": r[1], "results": r[2],
+         "latency_ms": r[3], "timestamp": r[4]}
+        for r in rows
+    ]}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")

services/api/requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+faiss-cpu==1.7.4
+numpy==1.26.4
+httpx==0.26.0
+# openai-whisper==20231117
+git+https://github.com/openai/whisper.git
+pydantic==2.5.3
+python-multipart==0.0.7
+aiofiles==23.2.1
+python-multipart

services/encoder/Dockerfile

@@ -0,0 +1,78 @@
+# services/encoder/Dockerfile
+#
+# WHY python:3.11-slim AND NOT python:3.11:
+#   The full python:3.11 image is ~900MB — it includes compilers, dev headers,
+#   documentation, and dozens of tools you never need at runtime.
+#   python:3.11-slim is ~130MB — just the runtime.
+#
+#   We do need build tools temporarily to compile some Python packages
+#   (onnxruntime has C extensions). We install them, build, then remove them.
+#   This is called a multi-stage awareness pattern — using build deps only
+#   when needed.
+#
+# FINAL IMAGE SIZE TARGET: ~800MB
+#   - python:3.11-slim base: 130MB
+#   - onnxruntime: ~400MB (it's big — ONNX runtime is a full inference engine)
+#   - clip + torchvision: ~150MB (we need torchvision for preprocessing)
+#   - Our code: <1MB
+#   - ONNX model files: ~90MB (mounted as volume, not baked in)
+#
+# WHY NOT ALPINE (even smaller base):
+#   Alpine uses musl libc instead of glibc.
+#   onnxruntime ships pre-compiled wheels built against glibc.
+#   Using Alpine would require compiling onnxruntime from source: 2+ hours.
+#   Not worth it for a <100MB size difference.
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system deps needed to build Python packages with C extensions
+# --no-install-recommends: only install exactly what's listed, not suggested packages
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    gcc \
+    g++ \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+# rm -rf /var/lib/apt/lists/ removes the package cache after install
+# Every RUN command creates a Docker layer. The cleanup MUST be in the same
+# RUN to actually reduce layer size. If you put it in a separate RUN,
+# the cache files are already baked into the previous layer.
+
+COPY requirements.txt .
+RUN pip install --default-timeout=1200 --no-cache-dir -r requirements.txt
+# --no-cache-dir: don't store pip's download cache in the image
+# pip normally caches to speed up repeated installs, but in Docker
+# we build once and run many times — cache just wastes space.
+
+# Copy only the application code (not scripts, not embeddings)
+COPY main.py .
+
+# Create directory for model files
+# Actual models are mounted via Docker volume — NOT baked into the image.
+# WHY NOT BAKE IN:
+#   If models are in the image, every model update requires rebuilding the image.
+#   With volumes, you can update models without touching Docker.
+#   Also: 90MB model in image = 90MB transferred on every docker pull.
+RUN mkdir -p models
+
+# Port 8001: encoder service (internal, not exposed to host directly)
+EXPOSE 8001
+
+# HEALTHCHECK: Docker polls this to know if the service is ready.
+# --interval: check every 30s
+# --timeout: fail if no response in 10s
+# --start-period: wait 60s before starting checks (model loading takes time)
+# --retries: mark unhealthy after 3 consecutive failures
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8001/health')"
+
+# Run with uvicorn (ASGI server for FastAPI)
+# --host 0.0.0.0: listen on all interfaces (needed inside Docker)
+# --port 8001: encoder port
+# --workers 1: ONE worker. Why?
+#   ONNX sessions are NOT safely forkable.
+#   Multiple workers would each load the 90MB model into RAM.
+#   For CPU-bound inference, multiple workers don't help — use async instead.
+CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8001", "--workers", "1"]

services/encoder/main.py

@@ -0,0 +1,255 @@
+"""
+services/encoder/main.py
+========================
+WHY A SEPARATE ENCODER SERVICE:
+  The encoder (ONNX CLIP model) is the heaviest component:
+    - ~90MB model file to load into RAM
+    - Startup time: ~3 seconds to initialize ONNX Runtime session
+    - CPU-intensive: uses all cores during inference
+
+  If we put this inside the API service:
+    1. Every API restart also restarts the encoder (3s downtime)
+    2. Can't scale encoder independently (what if we add GPU later?)
+    3. API crashes take down inference capability
+    4. Can't swap the model without touching search logic
+
+  As a SEPARATE SERVICE:
+    - Encoder loads once, stays up
+    - API restarts don't kill it
+    - Swap ONNX → TensorRT (GPU) by changing ONE service
+    - Can run on a different machine if needed
+
+  The communication cost: one HTTP call per search query (~1ms on localhost)
+  That's a fine tradeoff for the decoupling benefits.
+
+WHY FASTAPI OVER FLASK:
+  Flask: synchronous, one request at a time per worker
+  FastAPI: async, handles multiple concurrent requests with one worker
+
+  For an encoder service that does CPU-bound inference:
+    - Both are fine for single requests
+    - FastAPI's automatic OpenAPI docs at /docs is useful for debugging
+    - Pydantic validation catches malformed inputs before they hit inference
+    - Type hints make the code self-documenting
+    - FastAPI is what real ML serving frameworks (Ray Serve, BentoML) use
+"""
+
+import os
+import io
+import base64
+import time
+import logging
+import numpy as np
+import onnxruntime as ort
+from pathlib import Path
+from typing import Optional
+
+from fastapi import FastAPI, HTTPException, UploadFile, File
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import clip
+from PIL import Image
+from torchvision import transforms
+
+# ── Logging setup ────────────────────────────────────────────────────────────
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [encoder] %(message)s")
+log = logging.getLogger(__name__)
+
+# ── CLIP image preprocessing ─────────────────────────────────────────────────
+# Replicated from CLIP source — we don't need all of PyTorch, just this transform
+PREPROCESS = transforms.Compose([
+    transforms.Resize(224, interpolation=transforms.InterpolationMode.BICUBIC),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=[0.48145466, 0.4578275, 0.40821073],
+        std=[0.26862954, 0.26130258, 0.27577711],
+    ),
+])
+
+# ── App setup ─────────────────────────────────────────────────────────────────
+app = FastAPI(
+    title="Visual Search Encoder",
+    description="ONNX INT8 CLIP encoder — converts images and text to 512-dim vectors",
+    version="1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # tighter in production
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ── Global encoder state ──────────────────────────────────────────────────────
+# WHY GLOBAL STATE (not dependency injection):
+#   ONNX InferenceSession is NOT thread-safe to CREATE, but IS thread-safe to RUN.
+#   We create it once at startup and share it.
+#   FastAPI's @app.on_event("startup") runs before any requests are served.
+
+vision_session: Optional[ort.InferenceSession] = None
+text_session: Optional[ort.InferenceSession] = None
+vision_input_name: str = ""
+text_input_name: str = ""
+startup_time: float = 0.0
+
+
+@app.on_event("startup")
+async def load_models():
+    global vision_session, text_session, vision_input_name, text_input_name, startup_time
+
+    models_dir = os.getenv("MODELS_DIR", "models")
+    # vision_path = os.path.join(models_dir, "clip_vision_int8.onnx")
+    vision_path = os.path.join(models_dir, "clip_vision_fp32.onnx")
+    text_path = os.path.join(models_dir, "clip_text_int8.onnx")
+    # text_path = os.path.join(models_dir, "clip_text_int8.onnx")
+
+    # Session options: tune threading
+    # intra_op = parallelism within a single operation (e.g. matrix multiply)
+    # inter_op = parallelism between operations in the graph
+    # For inference-only with small batches: max intra, min inter
+    opts = ort.SessionOptions()
+    opts.intra_op_num_threads = os.cpu_count()
+    opts.inter_op_num_threads = 1
+    opts.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
+
+    providers = ["CPUExecutionProvider"]
+    if "CUDAExecutionProvider" in ort.get_available_providers():
+        providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
+        log.info("CUDA GPU available — using GPU for inference")
+    else:
+        log.info("No CUDA GPU found — using CPU with INT8 optimizations")
+
+    t0 = time.perf_counter()
+
+    if Path(vision_path).exists():
+        vision_session = ort.InferenceSession(vision_path, opts, providers=providers)
+        vision_input_name = vision_session.get_inputs()[0].name
+        log.info(f"Vision encoder loaded: {vision_path}")
+    else:
+        log.warning(f"Vision model not found at {vision_path}. Run export_to_onnx.py first.")
+
+    if Path(text_path).exists():
+        text_session = ort.InferenceSession(text_path, opts, providers=providers)
+        text_input_name = text_session.get_inputs()[0].name
+        log.info(f"Text encoder loaded: {text_path}")
+    else:
+        log.warning(f"Text model not found at {text_path}. Run export_to_onnx.py first.")
+
+    startup_time = time.perf_counter() - t0
+    log.info(f"Encoder service ready in {startup_time:.2f}s")
+
+
+# ── Pydantic models (request/response schemas) ────────────────────────────────
+class TextEmbedRequest(BaseModel):
+    text: str
+
+class EmbeddingResponse(BaseModel):
+    embedding: list[float]
+    latency_ms: float
+
+class HealthResponse(BaseModel):
+    status: str
+    vision_loaded: bool
+    text_loaded: bool
+    startup_time_s: float
+
+
+# ── Helper functions ──────────────────────────────────────────────────────────
+def l2_normalize(v: np.ndarray) -> np.ndarray:
+    """L2 normalize a vector. Makes cosine similarity == dot product."""
+    norm = np.linalg.norm(v)
+    return v / max(norm, 1e-8)
+
+
+def embed_image_array(arr: np.ndarray) -> tuple[list[float], float]:
+    """Run vision encoder on a preprocessed image array."""
+    t0 = time.perf_counter()
+    output = vision_session.run(None, {vision_input_name: arr})
+    emb = l2_normalize(output[0][0])
+    latency_ms = (time.perf_counter() - t0) * 1000
+    return emb.tolist(), latency_ms
+
+
+# ── Endpoints ─────────────────────────────────────────────────────────────────
+
+@app.get("/health", response_model=HealthResponse)
+async def health():
+    """Docker health check + status."""
+    return HealthResponse(
+        status="ok",
+        vision_loaded=vision_session is not None,
+        text_loaded=text_session is not None,
+        startup_time_s=round(startup_time, 2),
+    )
+
+
+@app.post("/embed/text", response_model=EmbeddingResponse)
+async def embed_text(req: TextEmbedRequest):
+    """
+    Convert text query → 512-dim CLIP embedding.
+    Called by the API service on every text search.
+    """
+    if text_session is None:
+        raise HTTPException(503, "Text encoder not loaded")
+    if not req.text.strip():
+        raise HTTPException(400, "Text cannot be empty")
+
+    t0 = time.perf_counter()
+
+    # Tokenize: convert text string → integer token IDs
+    # CLIP uses a BPE tokenizer with max length 77
+    # We still need the clip library for tokenization (it's tiny, no PyTorch needed at runtime)
+    import clip as clip_tokenizer
+    tokens = clip_tokenizer.tokenize([req.text]).numpy()  # shape: [1, 77]
+
+    output = text_session.run(None, {text_input_name: tokens})
+    emb = l2_normalize(output[0][0])
+
+    latency_ms = (time.perf_counter() - t0) * 1000
+    return EmbeddingResponse(embedding=emb.tolist(), latency_ms=round(latency_ms, 2))
+
+
+@app.post("/embed/image/upload", response_model=EmbeddingResponse)
+async def embed_image_upload(file: UploadFile = File(...)):
+    """
+    Convert uploaded image → 512-dim CLIP embedding.
+    Used for reverse image search (search by image instead of text).
+    """
+    if vision_session is None:
+        raise HTTPException(503, "Vision encoder not loaded")
+
+    try:
+        contents = await file.read()
+        img = Image.open(io.BytesIO(contents)).convert("RGB")
+    except Exception as e:
+        raise HTTPException(400, f"Invalid image: {e}")
+
+    tensor = PREPROCESS(img).unsqueeze(0).numpy()
+    emb, latency_ms = embed_image_array(tensor)
+    return EmbeddingResponse(embedding=emb, latency_ms=round(latency_ms, 2))
+
+
+@app.post("/embed/image/base64", response_model=EmbeddingResponse)
+async def embed_image_base64(data: dict):
+    """
+    Convert base64-encoded image → embedding.
+    Alternative to file upload for frontend that already has base64 data.
+    """
+    if vision_session is None:
+        raise HTTPException(503, "Vision encoder not loaded")
+
+    try:
+        img_data = base64.b64decode(data["image"])
+        img = Image.open(io.BytesIO(img_data)).convert("RGB")
+    except Exception as e:
+        raise HTTPException(400, f"Invalid base64 image: {e}")
+
+    tensor = PREPROCESS(img).unsqueeze(0).numpy()
+    emb, latency_ms = embed_image_array(tensor)
+    return EmbeddingResponse(embedding=emb, latency_ms=round(latency_ms, 2))
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8001, log_level="info")

services/encoder/requirements.txt

@@ -0,0 +1,15 @@
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+onnxruntime==1.19.2
+numpy==1.26.4
+Pillow==10.2.0
+# torchvision==0.17.0
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch==2.2.0+cpu
+torchvision==0.17.0+cpu
+# clip is needed only for tokenization at runtime (text encoder)
+# We get it from the OpenAI repo
+git+https://github.com/openai/CLIP.git
+httpx==0.26.0
+pydantic==2.5.3
+python-multipart==0.0.7

services/frontend/Dockerfile

@@ -0,0 +1,62 @@
+# services/frontend/Dockerfile
+#
+# MULTI-STAGE BUILD — the most important Docker pattern to understand.
+#
+# STAGE 1 (builder): Install Node.js, install dependencies, compile React → static HTML/JS/CSS
+# STAGE 2 (runtime): Copy ONLY the compiled output into a tiny Nginx image
+#
+# WHY TWO STAGES:
+#   node:18-alpine (with node_modules) = ~400MB
+#   nginx:alpine serving static files = ~25MB
+#
+#   React is a build-time framework. "npm run build" compiles your JSX into
+#   plain JavaScript that any browser can run. Once compiled, you don't need
+#   Node.js anymore — just a web server to serve the static files.
+#
+#   Without multi-stage: 400MB image with Node.js sitting idle
+#   With multi-stage: 25MB image, same result
+#
+# This is the standard production pattern for any React/Vue/Angular app.
+
+# ── Stage 1: Build ────────────────────────────────────────────────────────────
+FROM node:18-alpine AS builder
+
+WORKDIR /app
+
+# Copy package files first, THEN source code.
+# WHY: Docker caches each layer. If you copy everything at once,
+# any file change (even a .jsx edit) invalidates the npm install cache.
+# By copying package.json first, npm install is only re-run when
+# dependencies actually change — not on every code edit.
+# This saves minutes on rebuilds.
+COPY package.json package-lock.json* ./
+RUN npm ci
+# npm ci = "clean install" — uses exact versions from package-lock.json
+# Faster and more deterministic than npm install for CI/Docker builds
+
+COPY . .
+
+# Build the React app
+# Vite compiles JSX → JS, bundles, minifies, tree-shakes
+# Output goes to /app/dist/
+ARG VITE_API_URL=
+ENV VITE_API_URL=$VITE_API_URL
+RUN npm run build
+
+# ── Stage 2: Serve ────────────────────────────────────────────────────────────
+FROM nginx:alpine
+
+# Copy compiled static files from builder stage
+COPY --from=builder /app/dist /usr/share/nginx/html
+
+# Custom Nginx config to handle React Router (SPA routing)
+# Without this, refreshing on /search returns 404 because Nginx
+# doesn't know React handles routing — it looks for a /search folder.
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+
+EXPOSE 3000
+
+HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
+    CMD wget -qO- http://localhost:3000/ || exit 1
+
+CMD ["nginx", "-g", "daemon off;"]

services/frontend/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Visual Search</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

services/frontend/nginx.conf

@@ -0,0 +1,23 @@
+server {
+    listen 3000;
+
+    root /usr/share/nginx/html;
+    index index.html;
+
+    # SPA fallback: any route that doesn't match a file gets index.html
+    # React Router handles the rest client-side
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    # Cache static assets aggressively (they have content hashes in filenames)
+    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff2)$ {
+        expires 1y;
+        add_header Cache-Control "public, immutable";
+    }
+
+    # Don't cache index.html (so new deploys are picked up immediately)
+    location = /index.html {
+        add_header Cache-Control "no-cache";
+    }
+}

services/frontend/package-lock.json

@@ -0,0 +1,1681 @@
+{
+  "name": "visual-search-frontend",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "visual-search-frontend",
+      "version": "1.0.0",
+      "dependencies": {
+        "react": "^18.2.0",
+        "react-dom": "^18.2.0"
+      },
+      "devDependencies": {
+        "@vitejs/plugin-react": "^4.2.0",
+        "vite": "^5.0.0"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz",
+      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
+      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helpers": "^7.28.6",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@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.1",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
+      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@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.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "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.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
+      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz",
+      "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz",
+      "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
+      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
+      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.27",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",
+      "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.1.tgz",
+      "integrity": "sha512-d6FinEBLdIiK+1uACUttJKfgZREXrF0Qc2SmLII7W2AD8FfiZ9Wjd+rD/iRuf5s5dWrr1GgwXCvPqOuDquOowA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.1.tgz",
+      "integrity": "sha512-YjG/EwIDvvYI1YvYbHvDz/BYHtkY4ygUIXHnTdLhG+hKIQFBiosfWiACWortsKPKU/+dUwQQCKQM3qrDe8c9BA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.1.tgz",
+      "integrity": "sha512-mjCpF7GmkRtSJwon+Rq1N8+pI+8l7w5g9Z3vWj4T7abguC4Czwi3Yu/pFaLvA3TTeMVjnu3ctigusqWUfjZzvw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.1.tgz",
+      "integrity": "sha512-haZ7hJ1JT4e9hqkoT9R/19XW2QKqjfJVv+i5AGg57S+nLk9lQnJ1F/eZloRO3o9Scy9CM3wQ9l+dkXtcBgN5Ew==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.1.tgz",
+      "integrity": "sha512-czw90wpQq3ZsAVBlinZjAYTKduOjTywlG7fEeWKUA7oCmpA8xdTkxZZlwNJKWqILlq0wehoZcJYfBvOyhPTQ6w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.1.tgz",
+      "integrity": "sha512-KVB2rqsxTHuBtfOeySEyzEOB7ltlB/ux38iu2rBQzkjbwRVlkhAGIEDiiYnO2kFOkJp+Z7pUXKyrRRFuFUKt+g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.1.tgz",
+      "integrity": "sha512-L+34Qqil+v5uC0zEubW7uByo78WOCIrBvci69E7sFASRl0X7b/MB6Cqd1lky/CtcSVTydWa2WZwFuWexjS5o6g==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.1.tgz",
+      "integrity": "sha512-n83O8rt4v34hgFzlkb1ycniJh7IR5RCIqt6mz1VRJD6pmhRi0CXdmfnLu9dIUS6buzh60IvACM842Ffb3xd6Gg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.1.tgz",
+      "integrity": "sha512-Nql7sTeAzhTAja3QXeAI48+/+GjBJ+QmAH13snn0AJSNL50JsDqotyudHyMbO2RbJkskbMbFJfIJKWA6R1LCJQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.1.tgz",
+      "integrity": "sha512-+pUymDhd0ys9GcKZPPWlFiZ67sTWV5UU6zOJat02M1+PiuSGDziyRuI/pPue3hoUwm2uGfxdL+trT6Z9rxnlMA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.1.tgz",
+      "integrity": "sha512-VSvgvQeIcsEvY4bKDHEDWcpW4Yw7BtlKG1GUT4FzBUlEKQK0rWHYBqQt6Fm2taXS+1bXvJT6kICu5ZwqKCnvlQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.1.tgz",
+      "integrity": "sha512-4LqhUomJqwe641gsPp6xLfhqWMbQV04KtPp7/dIp0nzPxAkNY1AbwL5W0MQpcalLYk07vaW9Kp1PBhdpZYYcEw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.1.tgz",
+      "integrity": "sha512-tLQQ9aPvkBxOc/EUT6j3pyeMD6Hb8QF2BTBnCQWP/uu1lhc9AIrIjKnLYMEroIz/JvtGYgI9dF3AxHZNaEH0rw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.1.tgz",
+      "integrity": "sha512-RMxFhJwc9fSXP6PqmAz4cbv3kAyvD1etJFjTx4ONqFP9DkTkXsAMU4v3Vyc5BgzC+anz7nS/9tp4obsKfqkDHg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.1.tgz",
+      "integrity": "sha512-QKgFl+Yc1eEk6MmOBfRHYF6lTxiiiV3/z/BRrbSiW2I7AFTXoBFvdMEyglohPj//2mZS4hDOqeB0H1ACh3sBbg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.1.tgz",
+      "integrity": "sha512-RAjXjP/8c6ZtzatZcA1RaQr6O1TRhzC+adn8YZDnChliZHviqIjmvFwHcxi4JKPSDAt6Uhf/7vqcBzQJy0PDJg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.1.tgz",
+      "integrity": "sha512-wcuocpaOlaL1COBYiA89O6yfjlp3RwKDeTIA0hM7OpmhR1Bjo9j31G1uQVpDlTvwxGn2nQs65fBFL5UFd76FcQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.1.tgz",
+      "integrity": "sha512-77PpsFQUCOiZR9+LQEFg9GClyfkNXj1MP6wRnzYs0EeWbPcHs02AXu4xuUbM1zhwn3wqaizle3AEYg5aeoohhg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.1.tgz",
+      "integrity": "sha512-5cIATbk5vynAjqqmyBjlciMJl1+R/CwX9oLk/EyiFXDWd95KpHdrOJT//rnUl4cUcskrd0jCCw3wpZnhIHdD9w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.1.tgz",
+      "integrity": "sha512-cl0w09WsCi17mcmWqqglez9Gk8isgeWvoUZ3WiJFYSR3zjBQc2J5/ihSjpl+VLjPqjQ/1hJRcqBfLjssREQILw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.1.tgz",
+      "integrity": "sha512-4Cv23ZrONRbNtbZa37mLSueXUCtN7MXccChtKpUnQNgF010rjrjfHx3QxkS2PI7LqGT5xXyYs1a7LbzAwT0iCA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.1.tgz",
+      "integrity": "sha512-i1okWYkA4FJICtr7KpYzFpRTHgy5jdDbZiWfvny21iIKky5YExiDXP+zbXzm3dUcFpkEeYNHgQ5fuG236JPq0g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.1.tgz",
+      "integrity": "sha512-u09m3CuwLzShA0EYKMNiFgcjjzwqtUMLmuCJLeZWjjOYA3IT2Di09KaxGBTP9xVztWyIWjVdsB2E9goMjZvTQg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.1.tgz",
+      "integrity": "sha512-k+600V9Zl1CM7eZxJgMyTUzmrmhB/0XZnF4pRypKAlAgxmedUA+1v9R+XOFv56W4SlHEzfeMtzujLJD22Uz5zg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.1.tgz",
+      "integrity": "sha512-lWMnixq/QzxyhTV6NjQJ4SFo1J6PvOX8vUx5Wb4bBPsEb+8xZ89Bz6kOXpfXj9ak9AHTQVQzlgzBEc1SyM27xQ==",
+      "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.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
+      "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.28.0",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.27",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.17.0"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.16",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.16.tgz",
+      "integrity": "sha512-Lyf3aK28zpsD1yQMiiHD4RvVb6UdMoo8xzG2XzFIfR9luPzOpcBlAsT/qfB1XWS1bxWT+UtE4WmQgsp297FYOA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001787",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001787.tgz",
+      "integrity": "sha512-mNcrMN9KeI68u7muanUpEejSLghOKlVhRqS/Za2IeyGllJ9I9otGpR9g3nsw7n4W378TE/LyIteA0+/FOZm4Kg==",
+      "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/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/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/electron-to-chromium": {
+      "version": "1.5.334",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.334.tgz",
+      "integrity": "sha512-mgjZAz7Jyx1SRCwEpy9wefDS7GvNPazLthHg8eQMJ76wBdGQQDW33TCrUTvQ4wzpmOrv2zrFoD3oNufMdyMpog==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/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/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "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.37",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.37.tgz",
+      "integrity": "sha512-1h5gKZCF+pO/o3Iqt5Jp7wc9rH3eJJ0+nh/CIoiRwjRxde/hAHyLPXYN4V3CqKAbiZPSeJFSWHmJsbkicta0Eg==",
+      "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/postcss": {
+      "version": "8.5.9",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.9.tgz",
+      "integrity": "sha512-7a70Nsot+EMX9fFU3064K/kdHWZqGVY+BADLyXc8Dfv+mTLLVl6JzJpPaCZ2kQL9gIJvKXSLMHhqdRRjwQeFtw==",
+      "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.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "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",
+      "peer": true,
+      "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/rollup": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.1.tgz",
+      "integrity": "sha512-VmtB2rFU/GroZ4oL8+ZqXgSA38O6GR8KSIvWmEFv63pQ0G6KaBH9s07PO8XTXP4vI+3UJUEypOfjkGfmSBBR0w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.60.1",
+        "@rollup/rollup-android-arm64": "4.60.1",
+        "@rollup/rollup-darwin-arm64": "4.60.1",
+        "@rollup/rollup-darwin-x64": "4.60.1",
+        "@rollup/rollup-freebsd-arm64": "4.60.1",
+        "@rollup/rollup-freebsd-x64": "4.60.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.60.1",
+        "@rollup/rollup-linux-arm-musleabihf": "4.60.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.60.1",
+        "@rollup/rollup-linux-arm64-musl": "4.60.1",
+        "@rollup/rollup-linux-loong64-gnu": "4.60.1",
+        "@rollup/rollup-linux-loong64-musl": "4.60.1",
+        "@rollup/rollup-linux-ppc64-gnu": "4.60.1",
+        "@rollup/rollup-linux-ppc64-musl": "4.60.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.60.1",
+        "@rollup/rollup-linux-riscv64-musl": "4.60.1",
+        "@rollup/rollup-linux-s390x-gnu": "4.60.1",
+        "@rollup/rollup-linux-x64-gnu": "4.60.1",
+        "@rollup/rollup-linux-x64-musl": "4.60.1",
+        "@rollup/rollup-openbsd-x64": "4.60.1",
+        "@rollup/rollup-openharmony-arm64": "4.60.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.60.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.60.1",
+        "@rollup/rollup-win32-x64-gnu": "4.60.1",
+        "@rollup/rollup-win32-x64-msvc": "4.60.1",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      }
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/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/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    }
+  }
+}

services/frontend/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "visual-search-frontend",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.2.0",
+    "vite": "^5.0.0"
+  }
+}

services/frontend/src/App.jsx

@@ -0,0 +1,153 @@
+import { useState, useRef, useCallback } from "react"
+import SearchBar from "./components/SearchBar"
+import ResultGrid from "./components/ResultGrid"
+import StatsBar from "./components/StatsBar"
+import VoiceButton from "./components/VoiceButton"
+
+const API = import.meta.env.VITE_API_URL || "http://localhost:8000"
+
+export default function App() {
+  const [results, setResults] = useState([])
+  const [query, setQuery] = useState("")
+  const [queryType, setQueryType] = useState("")
+  const [transcription, setTranscription] = useState("")
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState("")
+  const [latency, setLatency] = useState(null)
+  const [stats, setStats] = useState(null)
+
+  // ── Search handlers ───────────────────────────────────────────────────────
+
+  const searchText = useCallback(async (text) => {
+    if (!text.trim()) return
+    setLoading(true)
+    setError("")
+    setTranscription("")
+    try {
+      const res = await fetch(`${API}/search/text?q=${encodeURIComponent(text)}&k=12`)
+      if (!res.ok) throw new Error(await res.text())
+      const data = await res.json()
+      setResults(data.results)
+      setQuery(data.query)
+      setQueryType("text")
+      setLatency({ total: data.latency_ms, encoder: data.encoder_latency_ms })
+    } catch (e) {
+      setError(e.message)
+    } finally {
+      setLoading(false)
+    }
+  }, [])
+
+  const searchImage = useCallback(async (file) => {
+    setLoading(true)
+    setError("")
+    setTranscription("")
+    const form = new FormData()
+    form.append("file", file)
+    try {
+      const res = await fetch(`${API}/search/image?k=12`, { method: "POST", body: form })
+      if (!res.ok) throw new Error(await res.text())
+      const data = await res.json()
+      setResults(data.results)
+      setQuery("uploaded image")
+      setQueryType("image")
+      setLatency({ total: data.latency_ms, encoder: data.encoder_latency_ms })
+    } catch (e) {
+      setError(e.message)
+    } finally {
+      setLoading(false)
+    }
+  }, [])
+
+  const searchVoice = useCallback(async (audioBlob) => {
+    setLoading(true)
+    setError("")
+    const form = new FormData()
+    form.append("file", audioBlob, "voice.wav")
+    try {
+      const res = await fetch(`${API}/search/voice?k=12`, { method: "POST", body: form })
+      if (!res.ok) throw new Error(await res.text())
+      const data = await res.json()
+      setResults(data.results)
+      setQuery(data.query)
+      setQueryType("voice")
+      setTranscription(data.transcription || "")
+      setLatency({ total: data.latency_ms, encoder: data.encoder_latency_ms, whisper: data.whisper_ms })
+    } catch (e) {
+      setError(e.message)
+    } finally {
+      setLoading(false)
+    }
+  }, [])
+
+  const submitFeedback = useCallback(async (imagePath, vote) => {
+    try {
+      await fetch(`${API}/feedback`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ image_path: imagePath, query, vote }),
+      })
+    } catch (e) {
+      console.warn("Feedback failed:", e)
+    }
+  }, [query])
+
+  return (
+    <div className="app">
+      <header className="header">
+        <h1 className="logo">Visual Search</h1>
+        <p className="tagline">Search images by text, voice, or image — powered by CLIP + FAISS</p>
+      </header>
+
+      <main className="main">
+        <div className="search-area">
+          <SearchBar onSearch={searchText} onImageUpload={searchImage} loading={loading} />
+          <VoiceButton onResult={searchVoice} loading={loading} />
+        </div>
+
+        {transcription && (
+          <div className="transcription">
+            <span className="transcription-label">Heard:</span> "{transcription}"
+          </div>
+        )}
+
+        {latency && (
+          <StatsBar
+            latency={latency}
+            resultCount={results.length}
+            queryType={queryType}
+          />
+        )}
+
+        {error && <div className="error">{error}</div>}
+
+        {loading && (
+          <div className="loading">
+            <div className="spinner" />
+            <span>Searching{queryType === "voice" ? " (transcribing...)" : ""}...</span>
+          </div>
+        )}
+
+        {!loading && results.length > 0 && (
+          <ResultGrid results={results} onFeedback={submitFeedback} apiBase={API} />
+        )}
+
+        {!loading && results.length === 0 && !error && query && (
+          <div className="empty">No results found for "{query}"</div>
+        )}
+
+        {!query && !loading && (
+          <div className="hero-hint">
+            <div className="hint-grid">
+              {["dog running in rain", "mountain sunset", "busy city market", "rocket launch"].map(q => (
+                <button key={q} className="hint-chip" onClick={() => searchText(q)}>
+                  {q}
+                </button>
+              ))}
+            </div>
+          </div>
+        )}
+      </main>
+    </div>
+  )
+}

services/frontend/src/components/ResultGrid.jsx

@@ -0,0 +1,76 @@
+import { useState } from "react"
+
+export function ResultGrid({ results, onFeedback, apiBase }) {
+  const [votes, setVotes] = useState({})
+
+  const vote = (path, v) => {
+    setVotes(prev => ({ ...prev, [path]: v }))
+    onFeedback(path, v)
+  }
+
+  return (
+    <div className="result-grid">
+      {results.map((r) => (
+        <div key={r.path} className="result-card">
+          <div className="result-img-wrap">
+            <img
+              src={`${apiBase}${r.url}`}
+              alt={r.category}
+              className="result-img"
+              loading="lazy"
+              onError={e => { e.target.style.display = "none" }}
+            />
+          </div>
+          <div className="result-meta">
+            <span className="result-category">{r.category.replace(/_/g, " ")}</span>
+            <span className="result-score">{(r.score * 100).toFixed(1)}%</span>
+          </div>
+          <div className="result-actions">
+            <button
+              className={`vote-btn ${votes[r.path] === 1 ? "voted-up" : ""}`}
+              onClick={() => vote(r.path, 1)}
+              title="Relevant"
+            >+</button>
+            <button
+              className={`vote-btn ${votes[r.path] === -1 ? "voted-down" : ""}`}
+              onClick={() => vote(r.path, -1)}
+              title="Not relevant"
+            >−</button>
+          </div>
+        </div>
+      ))}
+    </div>
+  )
+}
+
+export default ResultGrid
+
+export function StatsBar({ latency, resultCount, queryType }) {
+  const icons = { text: "T", image: "I", voice: "V" }
+  return (
+    <div className="stats-bar">
+      <span className="stat">
+        <span className="stat-label">type</span>
+        <span className="stat-value">{icons[queryType] || "?"} {queryType}</span>
+      </span>
+      <span className="stat">
+        <span className="stat-label">results</span>
+        <span className="stat-value">{resultCount}</span>
+      </span>
+      <span className="stat">
+        <span className="stat-label">total</span>
+        <span className="stat-value">{latency.total?.toFixed(0)}ms</span>
+      </span>
+      <span className="stat">
+        <span className="stat-label">encoder</span>
+        <span className="stat-value">{latency.encoder?.toFixed(0)}ms</span>
+      </span>
+      {latency.whisper && (
+        <span className="stat">
+          <span className="stat-label">whisper</span>
+          <span className="stat-value">{latency.whisper?.toFixed(0)}ms</span>
+        </span>
+      )}
+    </div>
+  )
+}

services/frontend/src/components/SearchBar.jsx

@@ -0,0 +1,55 @@
+import { useState, useRef } from "react"
+
+export default function SearchBar({ onSearch, onImageUpload, loading }) {
+  const [text, setText] = useState("")
+  const fileRef = useRef()
+
+  const handleSubmit = (e) => {
+    e.preventDefault()
+    if (text.trim()) onSearch(text.trim())
+  }
+
+  const handleFile = (e) => {
+    const file = e.target.files?.[0]
+    if (file) onImageUpload(file)
+  }
+
+  const handleDrop = (e) => {
+    e.preventDefault()
+    const file = e.dataTransfer.files?.[0]
+    if (file && file.type.startsWith("image/")) onImageUpload(file)
+  }
+
+  return (
+    <form className="search-bar" onSubmit={handleSubmit}
+      onDragOver={e => e.preventDefault()} onDrop={handleDrop}>
+      <input
+        className="search-input"
+        type="text"
+        placeholder="Search images... (or drag & drop an image)"
+        value={text}
+        onChange={e => setText(e.target.value)}
+        disabled={loading}
+      />
+      <button type="submit" className="search-btn" disabled={loading || !text.trim()}>
+        Search
+      </button>
+      <button
+        type="button"
+        className="upload-btn"
+        onClick={() => fileRef.current?.click()}
+        disabled={loading}
+        title="Search by image"
+      >
+        Upload
+      </button>
+      <input
+        ref={fileRef}
+        type="file"
+        accept="image/*"
+        style={{ display: "none" }}
+        onChange={handleFile}
+      />
+    </form>
+  )
+}

services/frontend/src/components/StatsBar.jsx

@@ -0,0 +1 @@
+export { StatsBar as default } from "./ResultGrid"

services/frontend/src/components/VoiceButton.jsx

@@ -0,0 +1,69 @@
+import { useState, useRef } from "react"
+
+/*
+WHY THIS COMPONENT EXISTS:
+  The Web MediaRecorder API lets us record audio from the microphone.
+  We record while button is held down, stop on release.
+  Send the recorded blob as WAV to /search/voice.
+
+  Browser compatibility note:
+  - Chrome: records as webm/opus by default
+  - Safari: records as mp4/aac
+  Whisper handles both formats natively so we don't need to convert.
+*/
+
+export default function VoiceButton({ onResult, loading }) {
+  const [recording, setRecording] = useState(false)
+  const [supported, setSupported] = useState(!!navigator.mediaDevices?.getUserMedia)
+  const mediaRef = useRef(null)
+  const chunksRef = useRef([])
+
+  const startRecording = async () => {
+    if (recording || loading) return
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true })
+      const recorder = new MediaRecorder(stream)
+      chunksRef.current = []
+
+      recorder.ondataavailable = e => {
+        if (e.data.size > 0) chunksRef.current.push(e.data)
+      }
+
+      recorder.onstop = () => {
+        const blob = new Blob(chunksRef.current, { type: "audio/wav" })
+        stream.getTracks().forEach(t => t.stop())
+        onResult(blob)
+      }
+
+      recorder.start()
+      mediaRef.current = recorder
+      setRecording(true)
+    } catch (e) {
+      console.error("Mic access denied:", e)
+      setSupported(false)
+    }
+  }
+
+  const stopRecording = () => {
+    if (mediaRef.current && recording) {
+      mediaRef.current.stop()
+      setRecording(false)
+    }
+  }
+
+  if (!supported) return null
+
+  return (
+    <button
+      className={`voice-btn ${recording ? "recording" : ""}`}
+      onMouseDown={startRecording}
+      onMouseUp={stopRecording}
+      onTouchStart={startRecording}
+      onTouchEnd={stopRecording}
+      disabled={loading && !recording}
+      title="Hold to record voice search"
+    >
+      {recording ? "● Release to search" : "Hold to speak"}
+    </button>
+  )
+}

services/frontend/src/index.css

@@ -0,0 +1,94 @@
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+:root {
+  --bg: #0f0f0f;
+  --surface: #1a1a1a;
+  --border: #2a2a2a;
+  --text: #e8e8e8;
+  --muted: #888;
+  --accent: #6366f1;
+  --accent-hover: #818cf8;
+  --danger: #ef4444;
+  --success: #22c55e;
+  --radius: 8px;
+}
+
+body { background: var(--bg); color: var(--text); font-family: system-ui, sans-serif; font-size: 15px; line-height: 1.5; }
+
+.app { max-width: 1200px; margin: 0 auto; padding: 24px 16px; }
+
+.header { text-align: center; margin-bottom: 32px; }
+.logo { font-size: 28px; font-weight: 600; letter-spacing: -0.5px; }
+.tagline { color: var(--muted); font-size: 14px; margin-top: 6px; }
+
+.search-area { display: flex; gap: 10px; flex-wrap: wrap; }
+
+.search-bar { display: flex; flex: 1; gap: 8px; min-width: 300px; }
+.search-input {
+  flex: 1; background: var(--surface); border: 1px solid var(--border);
+  color: var(--text); border-radius: var(--radius); padding: 10px 14px;
+  font-size: 15px; outline: none; transition: border-color .15s;
+}
+.search-input:focus { border-color: var(--accent); }
+.search-input::placeholder { color: var(--muted); }
+
+button { cursor: pointer; border: none; border-radius: var(--radius); font-size: 14px; font-weight: 500; transition: all .15s; }
+button:disabled { opacity: .4; cursor: not-allowed; }
+
+.search-btn { background: var(--accent); color: #fff; padding: 10px 20px; }
+.search-btn:hover:not(:disabled) { background: var(--accent-hover); }
+
+.upload-btn { background: var(--surface); color: var(--text); border: 1px solid var(--border); padding: 10px 16px; }
+.upload-btn:hover:not(:disabled) { border-color: var(--accent); }
+
+.voice-btn {
+  background: var(--surface); color: var(--text); border: 1px solid var(--border);
+  padding: 10px 18px; white-space: nowrap;
+}
+.voice-btn:hover:not(:disabled) { border-color: var(--accent); }
+.voice-btn.recording { background: #450a0a; border-color: var(--danger); color: var(--danger); animation: pulse 1s ease-in-out infinite; }
+@keyframes pulse { 0%,100% { opacity: 1 } 50% { opacity: .6 } }
+
+.transcription { margin-top: 12px; font-size: 14px; color: var(--muted); }
+.transcription-label { font-weight: 500; color: var(--text); }
+
+.stats-bar { display: flex; gap: 20px; margin-top: 16px; padding: 10px 14px; background: var(--surface); border-radius: var(--radius); border: 1px solid var(--border); flex-wrap: wrap; }
+.stat { display: flex; flex-direction: column; gap: 2px; }
+.stat-label { font-size: 11px; color: var(--muted); text-transform: uppercase; letter-spacing: .5px; }
+.stat-value { font-size: 14px; font-weight: 500; }
+
+.error { margin-top: 16px; padding: 12px 16px; background: #450a0a; border: 1px solid var(--danger); border-radius: var(--radius); color: var(--danger); font-size: 14px; }
+
+.loading { display: flex; align-items: center; gap: 12px; margin-top: 40px; color: var(--muted); font-size: 15px; }
+.spinner { width: 20px; height: 20px; border: 2px solid var(--border); border-top-color: var(--accent); border-radius: 50%; animation: spin .7s linear infinite; }
+@keyframes spin { to { transform: rotate(360deg) } }
+
+.empty { text-align: center; color: var(--muted); margin-top: 60px; font-size: 15px; }
+
+.hero-hint { text-align: center; margin-top: 60px; }
+.hint-grid { display: flex; flex-wrap: wrap; gap: 10px; justify-content: center; margin-top: 16px; }
+.hint-chip { background: var(--surface); color: var(--muted); border: 1px solid var(--border); padding: 8px 16px; border-radius: 20px; font-size: 13px; }
+.hint-chip:hover { border-color: var(--accent); color: var(--text); }
+
+.result-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(220px, 1fr)); gap: 16px; margin-top: 24px; }
+
+.result-card { background: var(--surface); border: 1px solid var(--border); border-radius: var(--radius); overflow: hidden; transition: border-color .15s, transform .15s; }
+.result-card:hover { border-color: var(--accent); transform: translateY(-2px); }
+
+.result-img-wrap { aspect-ratio: 4/3; overflow: hidden; background: #111; }
+.result-img { width: 100%; height: 100%; object-fit: cover; }
+
+.result-meta { display: flex; justify-content: space-between; align-items: center; padding: 8px 10px; }
+.result-category { font-size: 12px; color: var(--muted); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 70%; }
+.result-score { font-size: 12px; font-weight: 600; color: var(--accent); }
+
+.result-actions { display: flex; gap: 6px; padding: 0 10px 10px; }
+.vote-btn { flex: 1; background: transparent; border: 1px solid var(--border); color: var(--muted); padding: 4px 8px; font-size: 16px; border-radius: 6px; }
+.vote-btn:hover { border-color: var(--text); color: var(--text); }
+.vote-btn.voted-up { background: #14532d; border-color: var(--success); color: var(--success); }
+.vote-btn.voted-down { background: #450a0a; border-color: var(--danger); color: var(--danger); }
+
+@media (max-width: 600px) {
+  .search-area { flex-direction: column; }
+  .result-grid { grid-template-columns: repeat(2, 1fr); gap: 10px; }
+}

services/frontend/src/main.jsx

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

services/frontend/vite.config.js

@@ -0,0 +1,21 @@
+import { defineConfig } from "vite"
+import react from "@vitejs/plugin-react"
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 3000,
+    proxy: {
+      // In dev mode, proxy /search/* and /images/* to the API
+      // This avoids CORS issues when running outside Docker
+      "/search": "http://localhost:8000",
+      "/feedback": "http://localhost:8000",
+      "/images": "http://localhost:8000",
+      "/health": "http://localhost:8000",
+      "/stats": "http://localhost:8000",
+    },
+  },
+  build: {
+    outDir: "dist",
+  },
+})

start.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+set -e
+
+echo "=========================================="
+echo "  Visual Search — HuggingFace Space"
+echo "=========================================="
+
+HF_USER="darshvit20"
+MODEL_REPO="${HF_USER}/visual-search-clip"
+DATASET_REPO="${HF_USER}/visual-search-dataset"
+
+# ── Download ONNX models if not already present ────────────────────────────
+if [ ! -f "/app/models/clip_vision_int8.onnx" ]; then
+    echo "[1/3] Downloading ONNX models from HuggingFace..."
+    python3 -c "
+from huggingface_hub import hf_hub_download, list_repo_files
+import os
+
+repo = '${MODEL_REPO}'
+dest = '/app/models'
+os.makedirs(dest, exist_ok=True)
+
+for f in list_repo_files(repo, repo_type='model'):
+    print(f'  Downloading {f}...')
+    hf_hub_download(repo_id=repo, filename=f, repo_type='model', local_dir=dest)
+
+print('  Models ready.')
+"
+else
+    echo "[1/3] Models already present, skipping download."
+fi
+
+# ── Download embeddings if not already present ─────────────────────────────
+if [ ! -f "/app/embeddings/faiss.index" ]; then
+    echo "[2/3] Downloading embeddings from HuggingFace..."
+    python3 -c "
+from huggingface_hub import hf_hub_download, list_repo_files
+import os
+
+repo = '${DATASET_REPO}'
+dest = '/app/embeddings'
+os.makedirs(dest, exist_ok=True)
+
+for f in list_repo_files(repo, repo_type='dataset'):
+    if f.startswith('embeddings/') or f in ['faiss.index', 'metadata.pkl']:
+        print(f'  Downloading {f}...')
+        hf_hub_download(repo_id=repo, filename=f, repo_type='dataset', local_dir=dest)
+
+print('  Embeddings ready.')
+"
+else
+    echo "[2/3] Embeddings already present, skipping download."
+fi
+
+# ── Wait for encoder to be healthy before starting API ─────────────────────
+echo "[3/3] Starting services..."
+
+# Start supervisord in background temporarily to boot encoder first
+supervisord -c /etc/supervisor/conf.d/supervisord.conf &
+SUPER_PID=$!
+
+# Wait for encoder to be ready (max 60s)
+echo "  Waiting for encoder to load ONNX model..."
+for i in $(seq 1 30); do
+    if python3 -c "import urllib.request; urllib.request.urlopen('http://localhost:8001/health')" 2>/dev/null; then
+        echo "  Encoder ready!"
+        break
+    fi
+    sleep 2
+done
+
+# Hand off to supervisord (foreground)
+wait $SUPER_PID

supervisord.conf

@@ -0,0 +1,37 @@
+[supervisord]
+nodaemon=true
+logfile=/var/log/supervisor/supervisord.log
+pidfile=/var/run/supervisord.pid
+user=root
+
+[program:encoder]
+command=python -m uvicorn main:app --host 0.0.0.0 --port 8001 --workers 1
+directory=/app/encoder
+environment=MODELS_DIR="/app/models",OMP_NUM_THREADS="2"
+autostart=true
+autorestart=true
+startretries=3
+stdout_logfile=/var/log/supervisor/encoder.log
+stderr_logfile=/var/log/supervisor/encoder.log
+priority=1
+
+[program:api]
+command=python -m uvicorn main:app --host 0.0.0.0 --port 8000 --workers 1
+directory=/app/api
+environment=ENCODER_URL="http://127.0.0.1:8001",EMBEDDINGS_DIR="/app/embeddings",IMAGES_DIR="/app/images",DB_PATH="/app/data/search.db",FAISS_NPROBE="10"
+autostart=true
+autorestart=true
+startretries=3
+stdout_logfile=/var/log/supervisor/api.log
+stderr_logfile=/var/log/supervisor/api.log
+; Wait for encoder to be ready before starting API
+; supervisord doesn't have depends_on, so we handle this in start.sh
+priority=2
+
+[program:nginx]
+command=nginx -g "daemon off;"
+autostart=true
+autorestart=true
+stdout_logfile=/var/log/supervisor/nginx.log
+stderr_logfile=/var/log/supervisor/nginx.log
+priority=3