Deploy: integrate visual style analysis, remove filename scoring layer

.dockerignore

@@ -0,0 +1,10 @@
+.venv/
+__pycache__/
+*.pyc
+.git/
+.gemini/
+database/
+frontend/static/uploads/
+*.db
+.DS_Store
+.gitignore

.gitignore

@@ -0,0 +1,146 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script run during development
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nosenv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Translations
+*.mo
+*.gmo
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# Virtual Environments
+.venv/
+venv/
+ENV/
+env/
+ENV/
+ENV/local/
+ENV/lib/
+
+# Poetry
+.poetry/
+
+# Pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, if you're executing a microservice that you deploy, you should commit Pipfile.lock.
+#   Pipfile.lock
+
+# PEP 582; used by e.g. pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+.env.production
+.env.development
+.env.staging
+
+# Spyder project settings
+.spyderproject
+.spyder-py3
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# OS metadata
+.DS_Store
+Thumbs.db
+
+# IDEs
+.vscode/
+.idea/
+
+# Custom Exclusions for ImgAuth AI
+ImgAuthAI.zip
+node_modules/
+dist/
+out/
+
+# Generated heatmap uploads (runtime artifacts, not source files)
+frontend/static/uploads/

Dockerfile

@@ -0,0 +1,52 @@
+# Use a slim Python 3.11 base image
+FROM python:3.11-slim
+
+# Install system dependencies needed for OpenCV, PyTorch, and general builds
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libgl1 \
+    libglib2.0-0 \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set up user and working directory (required for HF Spaces)
+# HF Spaces runs containers with user UID 1000
+RUN useradd -m -u 1000 user
+WORKDIR /code
+
+# Set Hugging Face cache directory to a writeable location
+ENV HF_HOME=/code/.cache/huggingface
+RUN mkdir -p /code/.cache/huggingface && chown -R user:user /code
+
+# Copy requirements file first to leverage Docker cache
+COPY --chown=user:user requirements.txt /code/requirements.txt
+
+# Install dependencies
+# Optimize PyTorch installation to use CPU-only binaries to save space
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir torch==2.3.0 torchvision==0.18.0 --index-url https://download.pytorch.org/whl/cpu && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application files
+COPY --chown=user:user . /code
+
+# Pre-download Hugging Face models during build to speed up container startup.
+# This avoids container startup timeouts and lazy-loading delays.
+RUN python -c "\
+from transformers import pipeline; \
+pipeline('image-classification', model='umm-maybe/AI-image-detector'); \
+pipeline('image-classification', model='dima806/ai_vs_real_image_detection'); \
+pipeline('image-classification', model='Organika/sdxl-detector') \
+"
+
+# Set permissions
+RUN chmod -R 777 /code
+
+# Switch to non-root user
+USER user
+
+# Expose port 7860 (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Run uvicorn server mapping to port 7860
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

PROJECT_OVERVIEW.md

@@ -0,0 +1,152 @@
+# ImgAuth AI — Project Overview & Architecture Guide
+
+Welcome to the official documentation and technical overview of **ImgAuth AI**. This guide is designed to explain how our AI Image Authenticity Detector works in simple language, breaking down the backend analysis pipelines, the deep learning models, the forensic heuristics, the explainability heatmaps, and the frontend design.
+
+---
+
+## 📌 Project Goal & Philosophy
+
+**ImgAuth AI** is a major college project developed by **Team VisionGuard** (Vishal, Prince M., Prince D., and Raksha). 
+
+### The Core Philosophy: *“Simple on the surface, powerful underneath.”*
+* **For Everyday Users**: It works like a clean, minimal SaaS tool. You drag and drop an image, click a button, and immediately get a clear binary answer: **Likely AI-Generated** or **Likely Authentic**, accompanied by a confidence percentage and three simple reasons.
+* **For Investigators & Researchers**: Under a collapsed **"Show Technical Analysis"** drawer, the app reveals detailed forensic logs, individual model scores, neural network attentions, and math-heavy metrics (such as Kurtosis, Spectral ratios, and Compression ghosts).
+
+---
+
+## 🔄 End-to-End Image Processing Workflow
+
+When a user uploads an image, the system processes it in six main steps:
+
+```mermaid
+graph TD
+    A[User Uploads Image] --> B[Step 1: Filename Scan]
+    A --> C[Step 2: Metadata Inspection]
+    A --> D[Step 3: Deep Learning Models]
+    A --> E[Step 4: Forensic Heuristics]
+    B & C & D & E --> F[Step 5: Scoring Engine]
+    F --> G[Step 6: Explainability Heatmaps]
+    G --> H[Frontend Results Displayed]
+```
+
+1. **Upload & Reading**: The frontend sends the image to the FastAPI backend as a binary stream. The backend loads it using **Pillow** (PIL) and **OpenCV** in memory (without saving it to disk for privacy).
+2. **Parallel Scans**: The image is fed simultaneously into four analysis layers:
+   - Filename clues
+   - Metadata headers
+   - 3 Deep Learning neural networks
+   - 5 Digital forensic algorithms
+3. **Consolidation**: The **Scoring Engine** takes the probabilities from all layers, applies a dynamic weighting formula based on the strength of the clues, and calculates a final AI probability score.
+4. **Heatmap Generation**: If the image contains a valid vision signature, the system runs ViT (Vision Transformer) attention scans to map exactly which parts of the image look suspicious.
+5. **Response**: The server returns a structured JSON containing the verdict, final score, detailed breakdown, heatmaps, and diagnostic logs.
+6. **Smooth Render**: The frontend receives the JSON, updates the visual elements, and smoothly scrolls the user down to the results.
+
+---
+
+## 🛡️ The Multi-Layer Detection Architecture
+
+ImgAuth AI uses a **four-layer defense system** to catch generated media.
+
+### Layer 1: Filename Analysis
+Many AI generators assign unique default filenames to their creations. The backend scans the file name against regular expression (regex) patterns:
+* **Midjourney**: Typically uses 4 dash-separated hexadecimal blocks followed by a seed number (e.g., `user_description_abcd1234-ef56-7890-abcd-1234567890ab.png`).
+* **Stable Diffusion / DALL-E / Bing**: Often contain timestamps, prompt keywords, or specific prefix indicators (e.g., `DALL·E 2026-...`, `BingCreator_...`).
+* **Why it matters**: If a match is found, it is a near-guarantee (92% weight) that the image is AI-generated, bypassing heavy computation or helping confirm suspect classifications.
+
+### Layer 2: Metadata Analysis
+Digital cameras embed metadata (EXIF data) inside image files containing details like camera model, exposure, GPS coordinates, and creation software. AI generators either:
+* Strip all metadata completely (leaving a blank EXIF profile).
+* Write their generator signature (e.g., software tags like `"Adobe Firefly"`, `"DALL-E"`, or `"Stable Diffusion"`).
+* **How it works**: The backend parses the raw file bytes looking for telltale creator software tags or signs of metadata stripping.
+
+### Layer 3: Deep Learning Ensemble
+We feed the image into three separate state-of-the-art neural networks hosted on Hugging Face. Combining their opinions avoids the bias of a single model:
+
+| Model ID | Name | Architecture Type | What It Focuses On | Weight |
+| :--- | :--- | :--- | :--- | :--- |
+| `umm-maybe/AI-image-detector` | **umm-maybe ViT** | Vision Transformer (ViT) | Global semantic consistency (does the overall scene make physical sense?) | 25% |
+| `dima806/ai_vs_real_image_detection` | **dima806 CNN** | Convolutional Neural Network (CNN) | Local textures and pixel anomalies (brush strokes, unnatural blending) | 25% |
+| `Organika/sdxl-detector` | **Organika SDXL** | Specialized CNN | Specific artifacts produced by Stable Diffusion XL generators | 25% |
+
+---
+
+### Layer 4: Advanced Forensic Heuristics
+Deep learning models can be fooled by filters or resizing. To counter this, ImgAuth AI uses **five math-based forensic checks** that look at the physics of pixels:
+
+#### 1. Noise Kurtosis Analysis (Weight: 8%)
+* **Concept**: Real cameras capture random high-frequency thermal noise in pixels. When AI generates an image, it smooths out or over-complicates this noise.
+* **How it works**: We apply a **Laplacian filter** to isolate high-frequency details (noise), flatten the pixels into a 1D list, and calculate its **kurtosis** (a statistical measure of how "peaky" or "flat" the distribution is).
+  * *High Kurtosis (> 1.5)*: Leptokurtic curve. Means noise is natural and random (Likely Authentic).
+  * *Low/Negative Kurtosis (< 0)*: Platykurtic curve. Means noise is highly uniform or artificially smooth (Likely AI-Generated).
+
+#### 2. Deep Feature Inconsistency (DFI) (Weight: 7%)
+* **Concept**: Generative models create images patch-by-patch, which often leads to subtle boundary mismatches between different areas of the image.
+* **How it works**: We pass the image through the Vision Transformer (ViT) and extract the hidden features of the very last neural layer. We calculate the mathematical similarity (Cosine Similarity) between every single patch and the average of all patches.
+  * If the variance of these similarities is high, it shows that different parts of the image have inconsistent mathematical characteristics—a classic indicator of patch-based AI generation.
+
+#### 3. FFT Spectral Analysis (Weight: 5%)
+* **Concept**: When generating an image, AI algorithms upscale pixel grids, which leaves behind faint, repeating grid-like patterns called "periodic artifacts" (invisible to the human eye).
+* **How it works**: We perform a **Fast Fourier Transform (FFT)** to convert the image from pixels (spatial domain) into frequencies (spectral domain). We look for abnormal high-frequency spikes.
+  * A high ratio of periodic spikes in the outer rings of the frequency map indicates unnatural, repeating grid artifacts common in AI generation.
+
+#### 4. Color Histogram Analysis (Weight: 3%)
+* **Concept**: Real photographs have smooth, gradual transitions of colors due to natural lighting. AI-generated images often have abrupt color steps or overly simplified color palettes.
+* **How it works**: We plot the color histograms (Red, Green, Blue channels) and calculate the mathematical **roughness** (standard deviation of the differences between consecutive histogram bars).
+  * *Rough/Jaggered histograms*: Natural transitions (Likely Authentic).
+  * *Extremely smooth histograms*: Artificially simplified color distributions (Likely AI-Generated).
+
+#### 5. JPEG Ghost Analysis (Weight: 2%)
+* **Concept**: When you edit or save an image, it undergoes compression. Real images saved multiple times have complex compression "history". AI images are usually generated and saved once, exhibiting highly uniform compression.
+* **How it works**: We compress the image at different quality levels (e.g., 60%, 70%, 80%) and calculate the difference between the re-compressed versions.
+  * If the difference (ghost spread) is very low and uniform across the image, it suggests the image was synthetically generated and compressed only once.
+
+---
+
+## 🧮 Scoring Engine & Decision Logic
+
+The scoring engine implements **dynamic weighting**. The weights of the layers shift depending on how strong the clues are:
+
+1. **Strong Filename Trigger**: If the filename matches a generator pattern, we skip complex weights and apply:
+   * **92% Filename** + **4% Metadata** + **4% Models & Forensics**
+   * This immediately pushes the AI probability high while incorporating safety margins.
+2. **Medium Clue / No Clue**: If the filename has no obvious markers, the weights distribute:
+   * **10% Filename** + **45% Metadata** + **45% Models & Forensics**
+3. **Ensemble Aggregation**: The Deep Learning models and the 5 Forensic Heuristics are aggregated based on their individual weights ($25\% + 25\% + 25\% + 8\% + 7\% + 5\% + 3\% + 2\% = 100\%$).
+4. **Binary Verdict Threshold**:
+   * If $\text{Final AI Score} > 50\%$, the verdict is **Likely AI-Generated**.
+   * If $\text{Final AI Score} \le 50\%$, the verdict is **Likely Authentic**.
+   * *Confidence Label*: Derived from how far the score is from the $50\%$ middle boundary (e.g., $95\%$ score is "Very High Confidence", $55\%$ is "Low Confidence").
+
+---
+
+## 📊 What the Frontend Graphs & Heatmaps Show
+
+When analysis is complete, two visual graphs (heatmaps) are rendered under the **AI Focus Areas** tab:
+
+### 1. AI Attention Areas (ViT Attention Map)
+* **What it is**: A visual representation of where the Vision Transformer's neural layers "looked" the most when making its decision.
+* **How to read it**:
+  * **Red/Warm spots**: Areas where the AI model detected suspicious structures, textures, or anomalies (e.g., malformed eyes, weird background blending, or floating pixels).
+  * **Blue/Cool spots**: Neutral areas that the model ignored as background or normal textures.
+* **Value**: Gives the user a visual explanation of *why* the models classified the image as AI-generated.
+
+### 2. Pattern Irregularities (DFI Heatmap)
+* **What it is**: A map representing the mathematical inconsistencies (cosine distance variance) between patches of the image.
+* **How to read it**:
+  * **Highly fractured/hot spots**: Areas where pixel characteristics deviate sharply from the surrounding regions, highlighting copy-paste edges, localized AI inpainting, or upscaling borders.
+  * **Uniform blue fields**: Smooth, physically consistent regions typical of natural, unaltered photography.
+
+---
+
+## 💻 Tech Stack & Component Responsibilities
+
+The project is built entirely on a lightweight, performant, and modern Python/JS stack:
+
+| Component | Technology | Purpose |
+| :--- | :--- | :--- |
+| **Server/API** | `FastAPI` (Python) | High-performance, asynchronous web server that handles API endpoints. |
+| **Deep Learning** | `PyTorch` & `Transformers` | Loads and runs inference on the Hugging Face vision models. |
+| **Forensics** | `OpenCV`, `NumPy`, `SciPy` | Performs fast matrix math, FFT frequency transforms, noise extraction, and image resizing. |
+| **Structure** | HTML5 | Semantically structures the layout, navigation, cards, and drawers. |
+| **Styling** | CSS3 (Vanilla) | Custom styling utilizing a dark premium theme, glassmorphism card surfaces, purple gradients, responsive media queries, and transition animations. |
+| **Logic** | JavaScript (Vanilla) | Handles drag-and-drop file uploads, coordinates loading states, parses API JSON responses, dynamically updates the DOM, renders base64 heatmaps, and saves/retrieves history using browser `localStorage`. |
+| **Deployment** | `Docker` | Containers the app, installs CPU-optimized PyTorch binaries, and pre-caches the Hugging Face models for easy hosting on Hugging Face Spaces. |

README.md

@@ -0,0 +1,116 @@
+---
+title: ImgAuth AI
+emoji: 🛡️
+colorFrom: purple
+colorTo: indigo
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# ImgAuth AI — Image Authenticity Detector
+
+🛡️ **ImgAuth AI** is a state-of-the-art web application designed to detect AI-generated and manipulated images. Built with a "simple on the surface, powerful underneath" philosophy, it combines deep learning models with advanced digital forensics heuristics to deliver clear, binary verdicts: **Likely AI-Generated** or **Likely Authentic**.
+
+Developed as a Major Project by **Team VisionGuard** (student team of 4).
+
+---
+
+## 🚀 Key Features
+
+- **Binary Classification**: Simplified verdicts removing ambiguity ("Likely AI-Generated" or "Likely Authentic").
+- **Deep Learning Ensemble**: Combined predictions from 3 Hugging Face model pipelines:
+  - `umm-maybe/AI-image-detector`
+  - `dima806/ai_vs_real_image_detection`
+  - `Organika/sdxl-detector`
+- **5 Forensic Heuristics**: Multi-layer analysis for technical validation:
+  1. *Noise Kurtosis Analysis* (checks high-frequency noise distributions)
+  2. *Deep Feature Inconsistency (DFI)* (checks patch-level consistency of Vision Transformer embeddings)
+  3. *FFT Spectral Analysis* (identifies periodic artifacts in frequency domain)
+  4. *Color Histogram Analysis* (detects synthetic pixel roughness/smoothness)
+  5. *JPEG Ghost Analysis* (detects double compression artifacts in JPEG files)
+- **AI Focus Areas (Explainability)**: Visual heatmaps showing ViT Attention Maps and Deep Feature Inconsistencies.
+- **Collapsible Technical Drawer**: Advanced forensic signal logs, weights, and metrics available for researchers, while maintaining a clean, technical-jargon-free interface for everyday users.
+- **Privacy First**: Fully stateless architecture; no images are stored permanently. Scanning history is saved only in local browser storage (`localStorage`).
+
+---
+
+## 👥 Meet Team VisionGuard
+
+- **Vishal Chauhan** (Computer Science & Engineering, Project Lead)
+- **Prince Mishra** (Computer Science & Engineering, Backend Developer)
+- **Prince Dubey** (Computer Science & Engineering, Security & Testing)
+- **Raksha** (Computer Science & Engineering, Frontend Developer)
+
+---
+
+## 🛠️ Technology Stack
+
+- **Backend**: FastAPI, Uvicorn, PyTorch, Hugging Face Transformers, OpenCV, NumPy, SciPy
+- **Frontend**: Vanilla HTML5, CSS3 (Modern dark-theme layout with purple gradients & glassmorphism), Vanilla JavaScript
+- **Deployment**: Docker, Hugging Face Spaces
+
+---
+
+## 💻 Local Setup and Running
+
+To run this application locally on your machine, follow these steps:
+
+### Prerequisites
+- Python 3.10+
+- Pip package manager
+
+### Installation
+
+1. **Clone the repository**:
+   ```bash
+   git clone <repository-url>
+   cd imgauth-ai
+   ```
+
+2. **Create and activate a virtual environment**:
+   - **Windows (PowerShell)**:
+     ```powershell
+     python -m venv .venv
+     .\.venv\Scripts\activate
+     ```
+   - **macOS/Linux**:
+     ```bash
+     python -m venv .venv
+     source .venv/bin/activate
+     ```
+
+3. **Install dependencies**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Run the server**:
+   ```bash
+   python run.py
+   ```
+   *The app will start running at:* `http://localhost:5000`
+
+---
+
+## 🐳 Running with Docker
+
+Alternatively, build and run via Docker:
+
+1. **Build the image**:
+   ```bash
+   docker build -t imgauth-ai .
+   ```
+
+2. **Run the container**:
+   ```bash
+   docker run -p 7860:7860 imgauth-ai
+   ```
+   *Open browser to:* `http://localhost:7860`
+
+---
+
+## ⚖️ License & Attribution
+
+- **Non-Commercial**: This project uses the `Organika/sdxl-detector` model, licensed under CC BY-NC 4.0. It is intended strictly for non-commercial educational and research purposes.
+- **Model Attribution**: All deep learning classifications are handled by model weights published by the Hugging Face community.

backend/detectors/filename_detector.py

@@ -0,0 +1,117 @@
+import re
+import os
+
+STRONG_AI_KEYWORDS = {
+    "midjourney": 70, "dall-e": 70, "dalle": 70, "stable-diffusion": 70,
+    "stablediffusion": 70, "sdxl": 70, "sd3": 70, "sd35": 70,
+    "firefly": 70, "ideogram": 70, "imagen": 70, "kling": 70,
+    "sora": 70, "runway": 70, "pika": 70,
+    "chatgpt": 70, "openai": 70, "gpt4": 70, "gpt-4": 70, "gpt4o": 70,
+    "gemini": 70, "claude": 70, "perplexity": 70, "copilot": 70,
+    "leonardo": 70, "nanobanana": 70, "nano-banana": 70, "flux": 70,
+    "pixart": 70, "playground": 70, "kolors": 70, "hunyuan": 70,
+    "cogview": 70, "deepfloyd": 70, "kandinsky": 70, "wuerstchen": 70,
+    "animagine": 70, "waifu": 60,
+    "comfyui": 70, "automatic1111": 70, "a1111": 70, "fooocus": 70,
+    "invokeai": 70, "forge": 60,
+    "txt2img": 70, "img2img": 70, "t2i": 60, "i2i": 60,
+}
+
+MEDIUM_AI_KEYWORDS = {
+    "generated": 35, "ai-generated": 35, "aigenerated": 35,
+    "fake": 25, "synthetic": 25, "deepfake": 30,
+    "aiimage": 30, "ai_image": 30, "ai-image": 30,
+    "upscaled": 15, "inpainted": 20, "outpainted": 20,
+    "dreamshaper": 25, "juggernaut": 25, "realisticvision": 25,
+    "deepdream": 20, "artbreeder": 20, "nightcafe": 20,
+    "craiyon": 20, "dreamstudio": 25, "prompthero": 20,
+    "civitai": 25, "tensor-art": 20, "tensorart": 20,
+    "diffusion": 20, "lora": 15, "checkpoint": 15,
+}
+
+REAL_KEYWORDS = {
+    "photo": 8, "raw": 8, "dsc": 10, "dscn": 10, "dscf": 10,
+    "img_": 8, "img-": 8, "canon": 10, "nikon": 10, "sony": 10,
+    "iphone": 10, "samsung": 8, "pixel": 10, "oneplus": 8,
+    "screenshot": 5, "scan": 8, "pxl_": 10,
+    "snap": 6, "dcim": 10, "camera": 8,
+    "fujifilm": 10, "olympus": 10, "panasonic": 10, "leica": 10,
+    "gopro": 10, "dji_": 10, "mavic": 10,
+}
+
+
+def analyze_filename(filename: str) -> dict:
+    name = filename.lower()
+    name_no_ext = os.path.splitext(name)[0]
+
+    strong_hits, medium_hits, real_hits = [], [], []
+    strong_ai, medium_ai, real_pts = 0, 0, 0
+    signals = []
+
+    for kw, pts in STRONG_AI_KEYWORDS.items():
+        if kw in name_no_ext:
+            strong_ai = max(strong_ai, pts)
+            strong_hits.append(kw)
+            signals.append(f"[AI] Strong AI keyword: '{kw}'")
+
+    for kw, pts in MEDIUM_AI_KEYWORDS.items():
+        if kw in name_no_ext:
+            medium_ai = max(medium_ai, pts)
+            medium_hits.append(kw)
+            signals.append(f"[INFO] Medium AI keyword: '{kw}'")
+
+    for kw, pts in REAL_KEYWORDS.items():
+        if kw in name_no_ext:
+            real_pts += pts
+            real_hits.append(kw)
+            signals.append(f"[REAL] Camera keyword: '{kw}' (+{pts} Real pts)")
+
+    if re.search(r'[a-f0-9]{16,}', name_no_ext):
+        medium_ai = max(medium_ai, 30)
+        signals.append("[INFO] Long hex string pattern (common AI export naming)")
+
+    if re.search(r'[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}', name_no_ext):
+        medium_ai = max(medium_ai, 25)
+        signals.append("[INFO] UUID v4 pattern detected (common AI platform export)")
+
+    if re.search(r'(seed|cfg|step|sampler|guidance|scheduler)[_\-]?\d+', name_no_ext):
+        strong_ai = max(strong_ai, 70)
+        signals.append("[AI] Generation parameter pattern (seed/cfg/step)")
+
+    if re.search(r'^(0{2,}\d+[\-_]|grid[\-_]|tmp[\-_])', name_no_ext):
+        medium_ai = max(medium_ai, 25)
+        signals.append("[INFO] WebUI output naming pattern (sequential numbering)")
+
+    if re.search(r'(1024x1024|512x512|768x768|1024x768|1216x832|832x1216)', name_no_ext):
+        medium_ai = max(medium_ai, 20)
+        signals.append("[INFO] Common AI resolution in filename")
+
+    if strong_ai >= 60:
+        bucket = "strong_ai_trigger"
+        ai_pts = min(strong_ai, 70)
+        real_pts = min(real_pts, 10)
+        priority_note = "Filename flagged — but pixel analysis will confirm or override."
+    elif medium_ai >= 25:
+        bucket = "medium_ai_suspicion"
+        ai_pts = min(medium_ai, 50)
+        real_pts = min(real_pts, 15)
+        priority_note = "Suspicious filename — models and forensics will verify."
+    else:
+        bucket = "neutral_or_real_hint"
+        ai_pts = 0
+        real_pts = max(real_pts, 5)
+        priority_note = "No suspicious filename signals."
+
+    if signals:
+        signals.append("[NOTE] Filename can be easily changed — this layer has low reliability.")
+
+    return {
+        "bucket": bucket,
+        "ai_points": ai_pts,
+        "real_points": min(real_pts, 25),
+        "strong_hits": strong_hits,
+        "medium_hits": medium_hits,
+        "real_hits": real_hits,
+        "signals": signals if signals else ["No suspicious filename patterns detected."],
+        "priority_note": priority_note,
+    }

backend/detectors/image_detector.py

@@ -0,0 +1,523 @@
+import io
+import numpy as np
+import cv2
+from PIL import Image
+from scipy.stats import kurtosis as sp_kurtosis
+
+MODEL_CACHE = {}
+
+
+def load_models():
+    from transformers import pipeline
+    import torch
+
+    device_id = 0 if torch.cuda.is_available() else -1
+    print(f"[ImgAuth] Using device: {'GPU (cuda:0)' if device_id == 0 else 'CPU'}")
+
+    model_ids = [
+        ("umm_maybe", "umm-maybe/AI-image-detector"),
+        ("dima806",   "dima806/ai_vs_real_image_detection"),
+        ("organika",  "Organika/sdxl-detector"),
+    ]
+    for key, model_id in model_ids:
+        if key not in MODEL_CACHE:
+            try:
+                print(f"[ImgAuth] Loading model: {model_id}")
+                MODEL_CACHE[key] = pipeline(
+                    "image-classification", model=model_id, device=device_id, framework="pt"
+                )
+            except Exception as e:
+                print(f"[ImgAuth] Failed to load {model_id}: {e}")
+                MODEL_CACHE[key] = None
+    return MODEL_CACHE
+
+
+def run_model(pipe, img):
+    try:
+        preds = pipe(img)
+        ai_s, real_s = 0.0, 0.0
+        for p in preds:
+            label = p["label"].lower()
+            if any(k in label for k in ["ai", "fake", "artificial", "generated", "synthetic"]):
+                ai_s = max(ai_s, p["score"])
+            elif any(k in label for k in ["real", "human", "natural", "authentic"]):
+                real_s = max(real_s, p["score"])
+        if ai_s == 0 and real_s == 0 and len(preds) >= 2:
+            ai_s = preds[0]["score"]
+            real_s = preds[1]["score"]
+        elif ai_s == 0 and real_s == 0:
+            ai_s, real_s = 0.5, 0.5
+        total = ai_s + real_s or 1
+        return {
+            "ai_prob": round(ai_s / total, 4),
+            "real_prob": round(real_s / total, 4),
+            "raw": preds,
+        }
+    except Exception as e:
+        return {"ai_prob": 0.5, "real_prob": 0.5, "raw": [], "error": str(e)}
+
+
+def run_model_multiscale(pipe, img_full):
+    img_512 = img_full.copy()
+    img_512.thumbnail((512, 512))
+    result_512 = run_model(pipe, img_512)
+
+    w, h = img_full.size
+    import torch
+    if w > 600 and h > 600 and torch.cuda.is_available():
+        crop_size = min(w, h, 384)
+        cx, cy = w // 2, h // 2
+        half = crop_size // 2
+        center_crop = img_full.crop((cx - half, cy - half, cx + half, cy + half))
+        result_crop = run_model(pipe, center_crop)
+        ai_prob = result_512["ai_prob"] * 0.65 + result_crop["ai_prob"] * 0.35
+        real_prob = result_512["real_prob"] * 0.65 + result_crop["real_prob"] * 0.35
+        return {
+            "ai_prob": round(ai_prob, 4),
+            "real_prob": round(real_prob, 4),
+            "raw": result_512["raw"],
+        }
+    return result_512
+
+
+def noise_kurtosis_analysis(img):
+    try:
+        gray = np.array(img.convert("L"), dtype=np.float64)
+        residual = cv2.Laplacian(gray, cv2.CV_64F)
+        flat = residual.flatten()
+        flat = flat[np.abs(flat) > 0.5]
+        if len(flat) < 100:
+            return {"ai_prob": 0.5, "real_prob": 0.5, "kurtosis": 0.0,
+                    "detail": "Insufficient noise data"}
+
+        k = float(sp_kurtosis(flat, fisher=True))
+
+        if k > 5.0:
+            ai_prob = 0.12
+        elif k > 2.5:
+            ai_prob = 0.28
+        elif k > 1.0:
+            ai_prob = 0.42
+        elif k > 0.0:
+            ai_prob = 0.55
+        elif k > -0.5:
+            ai_prob = 0.65
+        else:
+            ai_prob = 0.78
+
+        label = "leptokurtic (real-like)" if k > 1.5 else "platykurtic (AI-like)" if k < 0 else "borderline"
+        return {
+            "ai_prob": round(ai_prob, 4),
+            "real_prob": round(1 - ai_prob, 4),
+            "kurtosis": round(k, 3),
+            "detail": f"Excess kurtosis={k:.3f} -> {label}",
+        }
+    except Exception as e:
+        return {"ai_prob": 0.5, "real_prob": 0.5, "kurtosis": 0.0,
+                "detail": f"Error: {str(e)[:60]}"}
+
+
+import torch
+
+
+def extract_vit_features_and_attentions(img):
+    try:
+        pipe = MODEL_CACHE.get("umm_maybe")
+        if not pipe or not hasattr(pipe, "model") or not hasattr(pipe, "image_processor"):
+            return None
+
+        model = pipe.model
+        processor = pipe.image_processor
+
+        inputs = processor(images=img, return_tensors="pt")
+        # Match device of inputs to device of model (CPU or GPU)
+        model_device = next(model.parameters()).device
+        inputs = {k: v.to(model_device) for k, v in inputs.items()}
+
+        with torch.no_grad():
+            outputs = model(**inputs, output_attentions=True, output_hidden_states=True)
+
+        return {
+            "logits": outputs.logits,
+            "attentions": outputs.attentions,
+            "hidden_states": outputs.hidden_states
+        }
+    except Exception as e:
+        print(f"[ImgAuth] Feature/Attention extraction error: {e}")
+        return None
+
+
+def deep_feature_inconsistency_analysis(vit_data):
+    try:
+        if not vit_data or "hidden_states" not in vit_data:
+            return {"ai_prob": 0.5, "real_prob": 0.5, "variance": 0.0, "detail": "ViT data unavailable", "cos_dist": None, "grid_w": 0, "grid_h": 0, "patch_features": None}
+
+        last_hidden = vit_data["hidden_states"][-1][0].cpu()
+        N = last_hidden.shape[0]
+
+        import math
+        root_N = int(round(math.sqrt(N)))
+        if root_N * root_N == N:
+            patch_features = last_hidden
+            grid_w = grid_h = root_N
+        else:
+            root_N_minus_1 = int(round(math.sqrt(N - 1)))
+            if root_N_minus_1 * root_N_minus_1 == N - 1:
+                patch_features = last_hidden[1:, :]
+                grid_w = grid_h = root_N_minus_1
+            else:
+                patch_features = last_hidden[1:, :]
+                N_patches = N - 1
+                grid_w = int(math.sqrt(N_patches))
+                grid_h = N_patches // grid_w
+                patch_features = patch_features[:grid_w * grid_h, :]
+
+        mean_feat = torch.mean(patch_features, dim=0, keepdim=True)
+        cos_sim = torch.nn.functional.cosine_similarity(patch_features, mean_feat, dim=1)
+        cos_dist = 1.0 - cos_sim
+
+        dist_variance = float(torch.var(cos_dist).item())
+
+        if dist_variance > 0.0035:
+            ai_prob = 0.76
+            detail = f"High deep feature inconsistency (variance={dist_variance:.6f})"
+        elif dist_variance > 0.0018:
+            ai_prob = 0.62
+            detail = f"Moderate deep feature inconsistency (variance={dist_variance:.6f})"
+        elif dist_variance > 0.0006:
+            ai_prob = 0.44
+            detail = f"Normal feature consistency (variance={dist_variance:.6f})"
+        else:
+            ai_prob = 0.28
+            detail = f"High feature uniformity (variance={dist_variance:.6f})"
+
+        return {
+            "ai_prob": round(ai_prob, 4),
+            "real_prob": round(1.0 - ai_prob, 4),
+            "variance": round(dist_variance, 6),
+            "cos_dist": cos_dist,
+            "grid_w": grid_w,
+            "grid_h": grid_h,
+            "patch_features": patch_features,
+            "detail": detail
+        }
+    except Exception as e:
+        return {"ai_prob": 0.5, "real_prob": 0.5, "variance": 0.0, "detail": f"Error: {str(e)[:60]}", "cos_dist": None, "grid_w": 0, "grid_h": 0, "patch_features": None}
+
+
+def _encode_overlay_to_base64(img_bgr):
+    """Encode a BGR numpy array to a Base64 JPEG data URL string."""
+    success, buffer = cv2.imencode(".jpg", img_bgr, [cv2.IMWRITE_JPEG_QUALITY, 85])
+    if not success:
+        return None
+    import base64
+    b64 = base64.b64encode(buffer).decode("utf-8")
+    return f"data:image/jpeg;base64,{b64}"
+
+
+def generate_heatmap_overlay(img, vit_data, cos_dist_tensor, grid_w, grid_h, patch_features):
+    """Generate attention and DFI heatmap overlays entirely in memory.
+    Returns Base64-encoded JPEG data URL strings (no files written to disk).
+    """
+    try:
+        w, h = img.size
+        img_np = np.array(img.convert("RGB"))
+        img_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
+
+        att_b64 = None
+        dfi_b64 = None
+
+        # ── Attention Heatmap ────────────────────────────────────────────────
+        attentions = vit_data.get("attentions") if vit_data else None
+        att_grid = None
+        if attentions:
+            try:
+                last_layer_att = attentions[-1][0].cpu()
+                if last_layer_att.ndim == 3:
+                    avg_att = torch.mean(last_layer_att, dim=0)
+                    if avg_att.shape[0] == patch_features.shape[0]:
+                        cls_attention = avg_att.mean(dim=0)
+                    else:
+                        cls_attention = avg_att[0, 1:]
+                    if cls_attention.numel() == grid_w * grid_h:
+                        att_grid = cls_attention.reshape(grid_w, grid_h).numpy()
+            except Exception as e:
+                print(f"[ImgAuth] Attention extraction error: {e}")
+
+        # Fallback to feature norm if attention parsing fails
+        if att_grid is None and patch_features is not None and grid_w > 0 and grid_h > 0:
+            try:
+                norm_feat = torch.norm(patch_features, dim=1)
+                att_grid = norm_feat.reshape(grid_w, grid_h).numpy()
+            except Exception as e:
+                print(f"[ImgAuth] Feature norm fallback error: {e}")
+
+        if att_grid is not None:
+            g_min, g_max = att_grid.min(), att_grid.max()
+            att_grid = (att_grid - g_min) / (g_max - g_min + 1e-8)
+            att_resized = cv2.resize((att_grid * 255).astype(np.uint8), (w, h), interpolation=cv2.INTER_CUBIC)
+            heatmap_att = cv2.applyColorMap(att_resized, cv2.COLORMAP_JET)
+            overlay_att = cv2.addWeighted(img_bgr, 0.6, heatmap_att, 0.4, 0)
+            att_b64 = _encode_overlay_to_base64(overlay_att)
+
+        # ── DFI Heatmap ���─────────────────────────────────────────────────────
+        if cos_dist_tensor is not None and grid_w > 0 and grid_h > 0:
+            dist_grid = cos_dist_tensor.reshape(grid_w, grid_h).numpy()
+            g_min, g_max = dist_grid.min(), dist_grid.max()
+            dist_grid = (dist_grid - g_min) / (g_max - g_min + 1e-8)
+            dist_resized = cv2.resize((dist_grid * 255).astype(np.uint8), (w, h), interpolation=cv2.INTER_CUBIC)
+            heatmap_dfi = cv2.applyColorMap(dist_resized, cv2.COLORMAP_JET)
+            overlay_dfi = cv2.addWeighted(img_bgr, 0.6, heatmap_dfi, 0.4, 0)
+            dfi_b64 = _encode_overlay_to_base64(overlay_dfi)
+
+        return att_b64, dfi_b64
+    except Exception as e:
+        print(f"[ImgAuth] Error generating heatmaps: {e}")
+        return None, None
+
+
+def fft_spectral_analysis(img):
+    try:
+        gray = np.array(img.convert("L"), dtype=np.float64)
+        size = min(gray.shape[0], gray.shape[1], 512)
+        gray = cv2.resize(gray, (size, size))
+
+        f_transform = np.fft.fft2(gray)
+        f_shift = np.fft.fftshift(f_transform)
+        magnitude = np.log1p(np.abs(f_shift))
+
+        center = size // 2
+        mask = np.ones_like(magnitude, dtype=bool)
+        mask[center - 5:center + 5, center - 5:center + 5] = False
+        outer_mag = magnitude[mask]
+
+        mean_mag = np.mean(outer_mag)
+        std_mag = np.std(outer_mag)
+        spike_threshold = mean_mag + 5.0 * std_mag
+        spike_count = np.sum(magnitude[mask] > spike_threshold)
+        spike_ratio = spike_count / len(outer_mag) if len(outer_mag) > 0 else 0
+        sr = float(spike_ratio)
+
+        if sr > 0.01:
+            ai_prob = 0.72
+            detail = f"Periodic artifacts detected (spike ratio={sr:.4f})"
+        elif sr > 0.005:
+            ai_prob = 0.58
+            detail = f"Minor spectral anomalies ({sr:.4f})"
+        elif sr > 0.002:
+            ai_prob = 0.48
+            detail = f"Faint spectral patterns ({sr:.4f})"
+        else:
+            ai_prob = 0.38
+            detail = f"Clean spectrum (no periodic artifacts)"
+
+        return {
+            "ai_prob": round(ai_prob, 4),
+            "real_prob": round(1 - ai_prob, 4),
+            "spike_ratio": round(sr, 5),
+            "detail": detail,
+        }
+    except Exception as e:
+        return {"ai_prob": 0.5, "real_prob": 0.5, "spike_ratio": 0.0,
+                "detail": f"Error: {str(e)[:60]}"}
+
+
+def color_histogram_analysis(img):
+    try:
+        rgb = np.array(img.convert("RGB"))
+        roughness_scores = []
+        for channel in range(3):
+            hist, _ = np.histogram(rgb[:, :, channel], bins=64, range=(0, 256))
+            hist = hist.astype(np.float64)
+            hist /= (hist.sum() + 1e-10)
+            diffs = np.diff(hist)
+            roughness_scores.append(float(np.std(diffs)))
+
+        avg_roughness = np.mean(roughness_scores)
+
+        if avg_roughness > 0.010:
+            ai_prob = 0.25
+            detail = f"Natural histogram roughness ({avg_roughness:.5f})"
+        elif avg_roughness > 0.006:
+            ai_prob = 0.38
+            detail = f"Moderate histogram roughness ({avg_roughness:.5f})"
+        elif avg_roughness > 0.003:
+            ai_prob = 0.52
+            detail = f"Smooth histogram ({avg_roughness:.5f}) — possibly synthetic"
+        else:
+            ai_prob = 0.68
+            detail = f"Very smooth histogram ({avg_roughness:.5f}) — likely AI"
+
+        return {
+            "ai_prob": round(ai_prob, 4),
+            "real_prob": round(1 - ai_prob, 4),
+            "roughness": round(avg_roughness, 6),
+            "detail": detail,
+        }
+    except Exception as e:
+        return {"ai_prob": 0.5, "real_prob": 0.5, "roughness": 0.0,
+                "detail": f"Error: {str(e)[:60]}"}
+
+
+def jpeg_ghost_analysis(img):
+    try:
+        if img.format not in ("JPEG", "JPG", None):
+            return {"ai_prob": 0.5, "real_prob": 0.5, "detail": "Not a JPEG"}
+
+        rgb = np.array(img.convert("RGB"), dtype=np.float64)
+        ghost_scores = []
+        for q in [60, 70, 80]:
+            buf = io.BytesIO()
+            img.save(buf, "JPEG", quality=q)
+            buf.seek(0)
+            recomp = np.array(Image.open(buf).convert("RGB"), dtype=np.float64)
+            diff = np.abs(rgb - recomp)
+            ghost_scores.append(float(np.mean(diff)))
+
+        min_ghost = min(ghost_scores)
+        max_ghost = max(ghost_scores)
+        spread = max_ghost - min_ghost
+
+        if spread < 1.0:
+            ai_prob = 0.58
+            detail = f"Low ghost spread ({spread:.2f}) — uniform compression (possibly synthetic)"
+        elif spread < 3.0:
+            ai_prob = 0.45
+            detail = f"Normal ghost spread ({spread:.2f})"
+        else:
+            ai_prob = 0.38
+            detail = f"High ghost spread ({spread:.2f}) — natural re-compression history"
+
+        return {
+            "ai_prob": round(ai_prob, 4),
+            "real_prob": round(1 - ai_prob, 4),
+            "ghost_spread": round(spread, 3),
+            "detail": detail,
+        }
+    except Exception as e:
+        return {"ai_prob": 0.5, "real_prob": 0.5, "ghost_spread": 0.0,
+                "detail": f"Error: {str(e)[:60]}"}
+
+
+def analyze_image_models(image_bytes: bytes) -> dict:
+    img_full = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+
+    models = load_models()
+    votes = []
+    signals = []
+
+    # 1. Run ViT Feature Extraction and Attentions
+    vit_data = extract_vit_features_and_attentions(img_full)
+
+    model_info = [
+        ("umm_maybe", "umm-maybe ViT",          0.25),
+        ("dima806",   "dima806 CNN",            0.25),
+        ("organika",  "Organika SDXL-Detector",  0.25),
+    ]
+    active_dl_weight = 0.0
+    for key, name, w in model_info:
+        if models.get(key):
+            r = run_model_multiscale(models[key], img_full)
+            votes.append({
+                "detector": name, "type": "deep_learning",
+                "ai_prob": r["ai_prob"], "real_prob": r["real_prob"], "weight": w,
+            })
+            active_dl_weight += w
+            signals.append(f"{name}: {int(r['ai_prob'] * 100)}% AI probability")
+        else:
+            signals.append(f"{name}: unavailable")
+
+    if active_dl_weight == 0:
+        pass
+    else:
+        for v in votes:
+            if v["type"] == "deep_learning":
+                v["weight"] = v["weight"] * (0.75 / active_dl_weight)
+
+    # 2. Run Noise Kurtosis
+    nk = noise_kurtosis_analysis(img_full)
+    votes.append({
+        "detector": "Noise Kurtosis Analysis", "type": "forensic",
+        "ai_prob": nk["ai_prob"], "real_prob": nk["real_prob"], "weight": 0.08,
+        "detail": nk.get("detail", ""), "kurtosis": nk.get("kurtosis", 0),
+    })
+    signals.append(f"Noise Kurtosis: {nk['detail']}")
+
+    # 3. Run Deep Feature Inconsistency (DFI) instead of ELA
+    dfi = deep_feature_inconsistency_analysis(vit_data)
+    votes.append({
+        "detector": "Deep Feature Inconsistency (DFI)", "type": "forensic",
+        "ai_prob": dfi["ai_prob"], "real_prob": dfi["real_prob"], "weight": 0.07,
+        "detail": dfi.get("detail", ""), "variance": dfi.get("variance", 0),
+    })
+    signals.append(f"DFI: {dfi['detail']}")
+
+    # 4. Run FFT Spectral
+    fft = fft_spectral_analysis(img_full)
+    votes.append({
+        "detector": "FFT Spectral Analysis", "type": "forensic",
+        "ai_prob": fft["ai_prob"], "real_prob": fft["real_prob"], "weight": 0.05,
+        "detail": fft.get("detail", ""), "spike_ratio": fft.get("spike_ratio", 0),
+    })
+    signals.append(f"FFT: {fft['detail']}")
+
+    # 5. Run Color Histogram
+    ch = color_histogram_analysis(img_full)
+    votes.append({
+        "detector": "Color Histogram Analysis", "type": "forensic",
+        "ai_prob": ch["ai_prob"], "real_prob": ch["real_prob"], "weight": 0.03,
+        "detail": ch.get("detail", ""), "roughness": ch.get("roughness", 0),
+    })
+    signals.append(f"Color Histogram: {ch['detail']}")
+
+    # 6. Run JPEG Ghost
+    jg = jpeg_ghost_analysis(img_full)
+    votes.append({
+        "detector": "JPEG Ghost Analysis", "type": "forensic",
+        "ai_prob": jg["ai_prob"], "real_prob": jg["real_prob"], "weight": 0.02,
+        "detail": jg.get("detail", ""), "ghost_spread": jg.get("ghost_spread", 0),
+    })
+    signals.append(f"JPEG Ghost: {jg['detail']}")
+
+    # Generate explainability overlays (in-memory Base64, no disk writes)
+    att_path, dfi_path = generate_heatmap_overlay(
+        img_full,
+        vit_data,
+        dfi.get("cos_dist"),
+        dfi.get("grid_w", 0),
+        dfi.get("grid_h", 0),
+        dfi.get("patch_features"),
+    )
+
+    # Delete non-serializable PyTorch tensors from returned dictionary
+    for k in ["cos_dist", "patch_features"]:
+        if k in dfi:
+            del dfi[k]
+
+    total_w = sum(v["weight"] for v in votes) or 1
+    w_ai = sum(v["ai_prob"] * v["weight"] for v in votes) / total_w
+    w_real = sum(v["real_prob"] * v["weight"] for v in votes) / total_w
+    tot = w_ai + w_real or 1
+    w_ai /= tot
+    w_real /= tot
+
+    dl_pct = int(min(active_dl_weight / total_w * 100, 100))
+    forensic_pct = 100 - dl_pct
+
+    return {
+        "ai_points": int(w_ai * 100),
+        "real_points": int(w_real * 100),
+        "weighted_ai_prob": round(w_ai, 4),
+        "votes": votes,
+        "signals": signals,
+        "forensics": {
+            "kurtosis": nk, "dfi": dfi, "fft": fft,
+            "color_histogram": ch, "jpeg_ghost": jg,
+        },
+        "attention_heatmap": att_path,
+        "dfi_heatmap": dfi_path,
+        "priority_note": f"DL-dominant ensemble: 3 models ({dl_pct}%) + 5 forensics ({forensic_pct}%).",
+    }
+
+
+

backend/detectors/metadata_detector.py

@@ -0,0 +1,163 @@
+import io
+
+
+def analyze_metadata(image_bytes: bytes) -> dict:
+    ai_pts, real_pts = 0, 0
+    signals = []
+
+    try:
+        from PIL import Image
+        from PIL.ExifTags import TAGS
+
+        img = Image.open(io.BytesIO(image_bytes))
+
+        exif_data = {}
+        raw = None
+        try:
+            raw = img._getexif()
+            if raw:
+                exif_data = {
+                    TAGS.get(k, k): v
+                    for k, v in raw.items()
+                    if isinstance(v, (str, int, float, bytes))
+                }
+        except Exception:
+            pass
+
+        camera_fields_found = 0
+        for field in ["Make", "Model", "LensMake", "LensModel",
+                      "FocalLength", "ExposureTime", "FNumber", "ISOSpeedRatings"]:
+            if field in exif_data:
+                camera_fields_found += 1
+
+        if camera_fields_found >= 3:
+            real_pts += 25
+            signals.append(f"[REAL] {camera_fields_found} camera EXIF fields found (+25 Real)")
+        elif camera_fields_found >= 1:
+            real_pts += 10
+            signals.append(f"[REAL] {camera_fields_found} camera EXIF field(s) found (+10 Real)")
+
+        gps_tags = [k for k in (exif_data or {}) if isinstance(k, str) and "GPS" in k]
+        if not gps_tags and raw:
+            if 0x8825 in raw or 34853 in raw:
+                gps_tags = ["GPSInfo"]
+        if gps_tags:
+            real_pts += 15
+            signals.append("[REAL] GPS geolocation data present (+15 Real)")
+
+        software = str(exif_data.get("Software", "")).lower()
+        ai_software_keywords = [
+            "stable diffusion", "midjourney", "comfyui", "diffusers",
+            "drawthings", "invoke", "fooocus", "flux", "dall-e", "dalle",
+            "nanobanana", "nano banana", "pixart", "playground",
+            "automatic1111", "a1111", "novelai", "tensorrt",
+            "chatgpt", "gemini", "copilot",
+        ]
+        for kw in ai_software_keywords:
+            if kw in software:
+                ai_pts += 35
+                signals.append(f"[AI] EXIF Software = AI tool '{kw}' (+35 AI)")
+                break
+
+        photo_editors = ["photoshop", "lightroom", "gimp", "capture one",
+                         "darktable", "rawtherapee", "snapseed"]
+        for ed in photo_editors:
+            if ed in software:
+                real_pts += 5
+                signals.append(f"[REAL] Photo editor '{ed}' in Software tag (+5 Real)")
+                break
+
+        if img.format == "PNG":
+            png_keys = [str(k).lower() for k in img.info.keys()]
+            ai_png_keys = ["prompt", "parameters", "workflow", "invokeai",
+                           "comfy", "negative_prompt", "steps", "sampler",
+                           "cfg_scale", "seed", "model", "generation_data"]
+            for k in ai_png_keys:
+                if any(k in pk for pk in png_keys):
+                    ai_pts += 35
+                    signals.append(f"[AI] PNG metadata key '{k}' found (AI generator output) (+35 AI)")
+                    break
+
+            for key, value in img.info.items():
+                if isinstance(value, str) and len(value) > 50:
+                    val_lower = value.lower()
+                    if any(w in val_lower for w in ["negative prompt", "cfg scale",
+                                                     "seed:", "steps:", "sampler"]):
+                        ai_pts += 30
+                        signals.append("[AI] PNG text contains generation parameters (+30 AI)")
+                        break
+
+        if img.format in ("JPEG", "JPG") and not exif_data:
+            ai_pts += 5
+            signals.append("[INFO] JPEG has no EXIF — weak signal, common in shared photos (+5 AI)")
+
+        if img.format in ("JPEG", "JPG") and not exif_data and not raw:
+            try:
+                data = image_bytes
+                if data[0:2] == b'\xff\xd8':
+                    has_app1 = b'\xff\xe1' in data[:20]
+                    if not has_app1:
+                        ai_pts += 3
+                        signals.append("[INFO] JPEG missing APP1 marker — metadata may have been stripped (+3 AI)")
+            except Exception:
+                pass
+
+        xmp = img.info.get("xmp", b"")
+        if isinstance(xmp, bytes):
+            xmp = xmp.decode("utf-8", errors="ignore")
+
+        if xmp:
+            if "c2pa" in xmp.lower() or "contentcredentials" in xmp.lower():
+                real_pts += 20
+                signals.append("[REAL] C2PA content credentials found (+20 Real)")
+
+            if "ai-generated" in xmp.lower() or "ai_generated" in xmp.lower():
+                ai_pts += 25
+                signals.append("[AI] XMP marks image as AI-generated (+25 AI)")
+
+            if "photoshop" in xmp.lower() or "lightroom" in xmp.lower():
+                real_pts += 5
+                signals.append("[REAL] Adobe editing history in XMP (+5 Real)")
+
+        w, h = img.size
+        common_ai_sizes = [
+            (512, 512), (768, 768), (1024, 1024), (2048, 2048),
+            (1024, 768), (768, 1024),
+            (1216, 832), (832, 1216),
+            (1344, 768), (768, 1344),
+            (1152, 896), (896, 1152),
+            (1536, 1024), (1024, 1536),
+            (1024, 576), (576, 1024),
+        ]
+        if (w, h) in common_ai_sizes:
+            ai_pts += 8
+            signals.append(f"[INFO] Resolution {w}x{h} is common AI generation size (+8 AI)")
+
+        if w == h and w >= 512:
+            ai_pts += 5
+            signals.append(f"[INFO] Perfect square ({w}x{h}) — uncommon for cameras (+5 AI)")
+
+        if img.format in ("JPEG", "JPG"):
+            try:
+                qtables = img.quantization
+                if qtables:
+                    avg_quant = sum(sum(t) for t in qtables.values()) / sum(len(t) for t in qtables.values())
+                    if avg_quant < 3:
+                        ai_pts += 5
+                        signals.append("[INFO] Extremely high JPEG quality (typical of AI output) (+5 AI)")
+            except Exception:
+                pass
+
+        if img.mode == "RGBA":
+            if img.format in ("JPEG", "JPG"):
+                signals.append("[INFO] Image has alpha channel in JPEG (unusual)")
+
+    except Exception as e:
+        signals.append(f"[ERROR] Metadata error: {str(e)[:60]}")
+
+    return {
+        "ai_points": min(ai_pts, 65),
+        "real_points": min(real_pts, 45),
+        "signals": signals or ["No strong metadata signals found."],
+        "weight": 0.25,
+    }

backend/detectors/scoring_engine.py

@@ -0,0 +1,132 @@
+def calculate_final_score(fn, md, ml):
+    w_fn, w_md, w_ml = 0.00, 0.10, 0.90
+    mode = "Standard analysis mode"
+    mode_detail = "Deep learning models and forensics drive the verdict, metadata is secondary"
+
+    def share(a, r):
+        t = a + r
+        if t == 0:
+            return 50.0, 50.0
+        return (a / t) * 100, (r / t) * 100
+
+    def share_md(a, r):
+        # Smoothing baseline to prevent small metadata points from dominating
+        baseline = 30.0
+        t = a + r + baseline
+        return ((a + baseline / 2) / t) * 100, ((r + baseline / 2) / t) * 100
+
+    fn_a, fn_r = 0.0, 100.0
+    md_a, md_r = share_md(md.get("ai_points", 0), md.get("real_points", 0))
+
+    # Incorporate Visual Style & Symmetry analysis
+    st = ml.get("style", {})
+    st_ai_points = st.get("ai_points", 0)
+    st_real_points = st.get("real_points", 0)
+
+    def share_st(a, r):
+        baseline = 20.0
+        t = a + r + baseline
+        return ((a + baseline / 2) / t) * 100, ((r + baseline / 2) / t) * 100
+
+    st_a, st_r = share_st(st_ai_points, st_real_points)
+    base_ml_a, base_ml_r = share(ml.get("ai_points", 0), ml.get("real_points", 0))
+
+    # Grouped Models/Forensics layer combines models (90%) and style analysis (10%)
+    ml_a = base_ml_a * 0.90 + st_a * 0.10
+    ml_r = base_ml_r * 0.90 + st_r * 0.10
+
+    ai_s = fn_a * w_fn + md_a * w_md + ml_a * w_ml
+    real_s = fn_r * w_fn + md_r * w_md + ml_r * w_ml
+    tot = ai_s + real_s or 1
+    ai_s = round((ai_s / tot) * 100, 1)
+    real_s = round((real_s / tot) * 100, 1)
+
+    forensic_override = False
+    forensics = ml.get("forensics", {})
+    if forensics:
+        kurt_ai = forensics.get("kurtosis", {}).get("ai_prob", 0.5)
+        dfi_ai = forensics.get("dfi", {}).get("ai_prob", 0.5)
+        model_ai = ml.get("weighted_ai_prob", 0.5)
+        forensic_avg = (kurt_ai + dfi_ai) / 2
+        if abs(forensic_avg - model_ai) > 0.40:
+            forensic_override = True
+
+    if ai_s >= 50:
+        verdict = "Fake"
+        if ai_s >= 85:
+            confidence = "Very High"
+            color = "#ef4444"
+        elif ai_s >= 70:
+            confidence = "High"
+            color = "#f87171"
+        else:
+            confidence = "Medium"
+            color = "#f97316"
+    else:
+        verdict = "Real"
+        if ai_s <= 15:
+            confidence = "Very High"
+            color = "#22c55e"
+        elif ai_s <= 30:
+            confidence = "High"
+            color = "#4ade80"
+        else:
+            confidence = "Medium"
+            color = "#86efac"
+
+    if forensic_override:
+        if confidence in ("Very High", "High"):
+            confidence = "Medium"
+        elif confidence == "Medium":
+            confidence = "Low"
+
+    breakdown = [
+        {
+            "layer": "Filename Analysis",
+            "ai_pts": 0,
+            "real_pts": 0,
+            "weight_pct": "0%",
+            "signals": ["Filename analysis disabled."],
+            "mode": "Layer deactivated.",
+        },
+        {
+            "layer": "Metadata Analysis",
+            "ai_pts": md.get("ai_points", 0),
+            "real_pts": md.get("real_points", 0),
+            "weight_pct": f"{int(w_md * 100)}%",
+            "signals": md.get("signals", []),
+            "mode": "Metadata-provenance layer.",
+        },
+        {
+            "layer": "AI Model and Forensic Detectors",
+            "ai_pts": int(ml_a),
+            "real_pts": int(ml_r),
+            "weight_pct": f"{int(w_ml * 100)}%",
+            "signals": ml.get("signals", []),
+            "votes": ml.get("votes", []),
+            "forensics": ml.get("forensics", {}),
+            "mode": ml.get("priority_note", "") + " With visual style & symmetry checks.",
+        },
+    ]
+
+    summary = (
+        f"Scoring mode: {mode}. "
+        f"Final AI score: {ai_s}%. "
+        f"Verdict: {verdict} (Confidence: {confidence}). "
+        f"{mode_detail}."
+    )
+    if forensic_override:
+        summary += " Forensic signals conflict with model predictions."
+
+    return {
+        "verdict": verdict,
+        "ai_score": ai_s,
+        "real_score": real_s,
+        "confidence": confidence,
+        "color": color,
+        "breakdown": breakdown,
+        "summary": summary,
+        "scoring_mode": mode,
+        "forensic_override": forensic_override,
+        "weights": {"filename": w_fn, "metadata": w_md, "models": w_ml},
+    }

backend/detectors/style_detector.py

@@ -0,0 +1,66 @@
+import cv2
+import numpy as np
+from PIL import Image
+
+def analyze_visual_style(img: Image.Image) -> dict:
+    signals = []
+    ai_pts = 0
+    real_pts = 0
+    correlation = 0.5
+    lap_var = 100.0
+
+    try:
+        # Convert PIL Image to grayscale numpy array
+        img_rgb = np.array(img.convert("RGB"))
+        gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
+
+        # 1. Symmetry Analysis
+        # AI images (especially portraits or generated objects) often exhibit unnatural bilateral symmetry
+        h, w = gray.shape
+        size = min(h, w, 256)
+        resized = cv2.resize(gray, (size, size))
+        flipped = cv2.flip(resized, 1)  # Horizontal flip
+
+        # Calculate Pearson correlation coefficient between original and flipped halves, checking std first
+        std_val = np.std(resized)
+        if std_val > 1e-4:
+            corr_matrix = np.corrcoef(resized.flat, flipped.flat)
+            if corr_matrix.shape == (2, 2):
+                correlation = float(corr_matrix[0, 1])
+                if np.isnan(correlation):
+                    correlation = 0.5
+
+        if correlation > 0.94:
+            ai_pts += 15
+            signals.append(f"[STYLE] Unnaturally high horizontal symmetry (corr={correlation:.3f}) (+15 AI)")
+        elif correlation > 0.88:
+            ai_pts += 5
+            signals.append(f"[STYLE] Moderate horizontal symmetry (corr={correlation:.3f}) (+5 AI)")
+        elif correlation < 0.35:
+            real_pts += 10
+            signals.append(f"[STYLE] Natural asymmetry (corr={correlation:.3f}) (+10 Real)")
+
+        # 2. Over-smoothing / Blur Detection
+        # AI textures are often unnaturally smooth or lack fine, high-frequency camera noise
+        lap_var = float(cv2.Laplacian(gray, cv2.CV_64F).var())
+
+        if lap_var < 50.0:
+            ai_pts += 12
+            signals.append(f"[STYLE] Extremely smooth texture / low local contrast (var={lap_var:.2f}) (+12 AI)")
+        elif lap_var < 150.0:
+            ai_pts += 6
+            signals.append(f"[STYLE] Soft textures / over-smoothing (var={lap_var:.2f}) (+6 AI)")
+        elif lap_var > 600.0:
+            real_pts += 10
+            signals.append(f"[STYLE] High-frequency natural textures (var={lap_var:.2f}) (+10 Real)")
+
+    except Exception as e:
+        signals.append(f"[ERROR] Style analysis error: {str(e)[:60]}")
+
+    return {
+        "ai_points": min(ai_pts, 30),
+        "real_points": min(real_pts, 20),
+        "signals": signals if signals else ["No style anomalies detected."],
+        "symmetry_correlation": round(correlation, 4),
+        "texture_variance": round(lap_var, 2),
+    }

backend/main.py

@@ -0,0 +1,77 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+from datetime import datetime
+from pathlib import Path
+from backend.detectors.image_detector import analyze_image_models
+from backend.detectors.metadata_detector import analyze_metadata
+from backend.detectors.scoring_engine import calculate_final_score
+from backend.detectors.style_detector import analyze_visual_style
+from PIL import Image
+import io
+
+app = FastAPI(title="ImgAuth AI API")
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+BASE_DIR = Path(__file__).parent
+FRONTEND = BASE_DIR.parent / "frontend"
+PUBLIC = BASE_DIR.parent / "public"
+app.mount("/static", StaticFiles(directory=str(FRONTEND / "static")), name="static")
+app.mount("/public", StaticFiles(directory=str(PUBLIC)), name="public")
+
+
+@app.on_event("startup")
+async def startup():
+    print("ImgAuth AI started -> http://localhost:5000")
+    try:
+        print("[ImgAuth] Preloading models on startup...")
+        from backend.detectors.image_detector import load_models
+        load_models()
+        print("[ImgAuth] Models preloaded successfully.")
+    except Exception as e:
+        print(f"[ImgAuth] Warning: failed to preload models: {e}")
+
+
+@app.get("/")
+async def root():
+    return FileResponse(str(FRONTEND / "index.html"))
+
+
+@app.post("/api/detect")
+async def detect(file: UploadFile = File(...)):
+    if not file.content_type.startswith("image/"):
+        raise HTTPException(400, "Only image files are accepted.")
+    contents = await file.read()
+    if len(contents) > 10 * 1024 * 1024:
+        raise HTTPException(400, "File too large. Max 10 MB.")
+
+    fn = {}
+    md = analyze_metadata(contents)
+    ml = analyze_image_models(contents)
+
+    try:
+        img_full = Image.open(io.BytesIO(contents)).convert("RGB")
+        st = analyze_visual_style(img_full)
+    except Exception as e:
+        st = {"ai_points": 0, "real_points": 0, "signals": [f"[ERROR] Style loading: {str(e)[:50]}"]}
+
+    ml["style"] = st
+    if "signals" in ml and "signals" in st:
+        ml["signals"].extend(st["signals"])
+
+    res = calculate_final_score(fn, md, ml)
+
+    return JSONResponse({
+        "filename": file.filename,
+        "verdict": res["verdict"],
+        "ai_score": res["ai_score"],
+        "real_score": res["real_score"],
+        "confidence": res["confidence"],
+        "color": res["color"],
+        "layers": {"filename": fn, "metadata": md, "models": ml},
+        "breakdown": res["breakdown"],
+        "summary": res["summary"],
+        "timestamp": datetime.now().isoformat()
+    })

frontend/index.html

@@ -0,0 +1,494 @@
+<!DOCTYPE html>
+<html lang="en" data-theme="dark">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>ImgAuth AI — Check if an Image is AI-Generated</title>
+  <meta name="description" content="Free AI image authenticity checker. Upload any image to instantly find out if it is real or AI-generated. Private, fast, no account needed." />
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  <link href="https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@300;400;500;600;700;800&display=swap" rel="stylesheet" />
+  <link rel="stylesheet" href="/static/css/style.css" />
+</head>
+<body>
+
+  <!-- ── HEADER ─────────────────────────────────────────────────── -->
+  <header class="header">
+    <div class="header-inner">
+      <a class="logo" href="/">
+        <svg width="28" height="28" viewBox="0 0 32 32" fill="none">
+          <rect width="32" height="32" rx="8" fill="url(#lg1)"/>
+          <path d="M8 22L13 12L17 19L20 15L24 22H8Z" fill="white" opacity="0.9"/>
+          <circle cx="22" cy="11" r="3" fill="white" opacity="0.75"/>
+          <defs>
+            <linearGradient id="lg1" x1="0" y1="0" x2="32" y2="32">
+              <stop stop-color="#7c3aed"/><stop offset="1" stop-color="#a855f7"/>
+            </linearGradient>
+          </defs>
+        </svg>
+        <span>ImgAuth <span class="logo-accent">AI</span></span>
+      </a>
+      <nav class="nav-links">
+        <a href="#how-it-works" class="nav-link">How it works</a>
+        <a href="#about" class="nav-link">About</a>
+        <a href="#team" class="nav-link">Team</a>
+        <button class="theme-btn" data-theme-toggle aria-label="Toggle theme">🌙</button>
+      </nav>
+    </div>
+  </header>
+
+  <!-- ── HERO ───────────────────────────────────────────────────── -->
+  <section class="hero">
+    <div class="hero-eyebrow">
+      <svg width="10" height="10" viewBox="0 0 10 10"><circle cx="5" cy="5" r="5" fill="currentColor"/></svg>
+      AI Image Authenticity Checker
+    </div>
+    <h1>Check if an image is<br><span class="grad">AI-generated</span></h1>
+    <p class="hero-sub">Upload any image and our AI analyzes visual patterns, metadata, and forensic signals to estimate whether it was AI-generated or authentic.</p>
+    <div class="hero-stats">
+      <div class="stat"><div class="stat-num">3+</div><div class="stat-label">AI Models</div></div>
+      <div class="stat"><div class="stat-num">5+</div><div class="stat-label">Forensic Signals</div></div>
+      <div class="stat"><div class="stat-num">100%</div><div class="stat-label">Private</div></div>
+    </div>
+  </section>
+
+  <!-- ── UPLOAD ─────────────────────────────────────────────────── -->
+  <section class="upload-section" id="uploadSection">
+    <div class="upload-card" id="uploadCard">
+      <!-- Drop Zone -->
+      <div class="drop-zone" id="dropZone">
+        <div class="drop-icon">
+          <svg width="26" height="26" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+            <polyline points="17 8 12 3 7 8"/><line x1="12" y1="3" x2="12" y2="15"/>
+          </svg>
+        </div>
+        <p class="drop-title">Drop your image here</p>
+        <p class="drop-sub">PNG, JPG, or WEBP · Max 10 MB</p>
+        <label class="btn btn-primary" for="fileInput">Select Image</label>
+        <input type="file" id="fileInput" accept="image/*" hidden />
+        <p class="drop-hint">or drag and drop</p>
+      </div>
+
+      <!-- Preview Zone -->
+      <div class="preview-zone" id="previewZone" style="display:none">
+        <div class="preview-img-box">
+          <img id="previewImg" src="" alt="Selected image preview" />
+        </div>
+        <div class="preview-filename" id="previewFilename">—</div>
+        <div class="preview-actions">
+          <button class="btn btn-primary" id="analyzeBtn">
+            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><circle cx="11" cy="11" r="8"/><path d="m21 21-4.35-4.35"/></svg>
+            Check Image
+          </button>
+          <button class="btn btn-ghost" id="clearBtn">Choose Different</button>
+        </div>
+      </div>
+    </div>
+  </section>
+
+  <!-- ── LOADING OVERLAY ────────────────────────────────────────── -->
+  <div class="loading-overlay" id="loadingOverlay" style="display:none">
+    <div class="loading-card">
+      <div class="spinner-ring"></div>
+      <p class="loading-title">Analyzing your image</p>
+      <p class="loading-sub">This usually takes 10–30 seconds</p>
+      <div class="steps-list">
+        <div class="step" id="step1">Reading image metadata</div>
+        <div class="step" id="step2">Analyzing visual textures</div>
+        <div class="step" id="step3">Running AI detection models</div>
+        <div class="step" id="step4">Checking camera fingerprint</div>
+        <div class="step" id="step5">Mapping pixel irregularities</div>
+        <div class="step" id="step6">Calculating authenticity score</div>
+      </div>
+    </div>
+  </div>
+
+  <!-- ── RESULT SECTION ─────────────────────────────────────────── -->
+  <section class="result-section" id="resultSection" style="display:none">
+    <div class="result-wrap">
+
+      <!-- Verdict Card -->
+      <div class="verdict-card">
+        <div class="verdict-layout">
+          <div class="result-img-panel">
+            <img id="resultImg" src="" alt="Analyzed image" />
+          </div>
+          <div class="verdict-info">
+            <!-- Badge + Confidence -->
+            <div>
+              <div class="verdict-badge" id="resultBadge">—</div>
+            </div>
+            <h2 class="verdict-heading" id="resultVerdict">—</h2>
+            <p class="confidence-label" id="resultConfidenceLevel">—</p>
+
+            <!-- Gauge Bar -->
+            <div class="gauge-wrap">
+              <div class="gauge-meta">
+                <span>Likely Authentic</span>
+                <span>Likely AI-Generated</span>
+              </div>
+              <div class="gauge-track">
+                <div class="gauge-fill" id="gaugeFill" style="width:0%"></div>
+                <div class="gauge-dot"  id="gaugeDot"  style="left:0%"></div>
+              </div>
+              <div class="gauge-vals">
+                <span id="realPct">—</span>
+                <span id="aiPct">—</span>
+              </div>
+            </div>
+
+            <!-- Summary -->
+            <p class="verdict-summary-text" id="resultSummary">—</p>
+          </div>
+        </div>
+      </div>
+
+      <!-- Why This Result -->
+      <div>
+        <p class="result-block-title">Why this result?</p>
+        <div class="why-grid">
+          <div class="why-card">
+            <div class="why-icon purple">🎨</div>
+            <h4>Visual Patterns</h4>
+            <p id="explainVisual">—</p>
+          </div>
+          <div class="why-card">
+            <div class="why-icon blue">🤖</div>
+            <h4>AI Model Analysis</h4>
+            <p id="explainModels">—</p>
+          </div>
+          <div class="why-card">
+            <div class="why-icon teal">📷</div>
+            <h4>Metadata Check</h4>
+            <p id="explainMetadata">—</p>
+          </div>
+        </div>
+      </div>
+
+      <!-- AI Focus Areas -->
+      <div id="focusAreas" style="display:none">
+        <p class="result-block-title">AI Focus Areas</p>
+        <div class="focus-grid">
+          <div class="focus-card">
+            <h4>AI Attention Areas</h4>
+            <p>Where our models focused most during analysis.</p>
+            <div class="heatmap-box">
+              <img id="attentionHeatmapImg" src="" alt="AI Attention Map" />
+            </div>
+          </div>
+          <div class="focus-card" id="dfiCardContainer" style="display:none">
+            <h4>Pattern Irregularities</h4>
+            <p>Texture inconsistencies detected in pixel patterns.</p>
+            <div class="heatmap-box">
+              <img id="dfiHeatmapImg" src="" alt="Pattern Irregularities" />
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <!-- Advanced Technical Analysis (Collapsed) -->
+      <div class="verdict-card adv-section" id="advancedDetails">
+        <button class="adv-toggle" id="advancedToggle" aria-expanded="false">
+          <span>Show Technical Analysis</span>
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5">
+            <polyline points="6 9 12 15 18 9"/>
+          </svg>
+        </button>
+        <div class="adv-body" id="advancedBody" style="display:none">
+          <div class="adv-grid" id="advancedContent"></div>
+        </div>
+      </div>
+
+      <!-- CTA -->
+      <div class="result-cta">
+        <button class="btn btn-primary" id="newScanBtn">Check Another Image</button>
+      </div>
+
+    </div>
+  </section>
+
+  <!-- ── HOW IT WORKS ────────────────────────────────────────────── -->
+  <section class="how-section" id="how-it-works">
+    <div class="page-wrap">
+      <div class="section-header">
+        <div class="section-tag">Simple Process</div>
+        <h2 class="section-title">How It Works</h2>
+        <p class="section-desc">Three simple steps to check any image in seconds.</p>
+      </div>
+      <div class="how-grid">
+        <div class="how-card">
+          <div class="how-num">01</div>
+          <h3>Upload an image</h3>
+          <p>PNG, JPG, or WEBP. Your image is processed instantly in memory and never stored on our servers.</p>
+        </div>
+        <div class="how-card">
+          <div class="how-num">02</div>
+          <h3>AI analyzes patterns</h3>
+          <p>We run multiple deep learning models and forensic checks on visual textures, metadata, and pixel patterns.</p>
+        </div>
+        <div class="how-card">
+          <div class="how-num">03</div>
+          <h3>Get your estimate</h3>
+          <p>Receive a clear authenticity score with simple explanations of why the result was reached.</p>
+        </div>
+      </div>
+    </div>
+  </section>
+
+  <!-- ── ABOUT ───────────────────────────────────────────────────── -->
+  <section class="about-section" id="about">
+    <div class="page-wrap">
+      <div class="about-grid">
+        <div class="about-text">
+          <div class="section-tag">College Major Project</div>
+          <h2>About ImgAuth AI</h2>
+          <p>ImgAuth AI is an academic AI and cybersecurity project developed to detect AI-generated or manipulated images using deep learning and forensic analysis techniques.</p>
+          <p>The platform combines multiple state-of-the-art AI models and forensic signals to estimate whether an image may be synthetic or authentic — making cutting-edge detection accessible to everyone.</p>
+          <p>Built as a college major project focused on AI safety, digital trust, and media authenticity in an age of rapidly advancing generative AI.</p>
+        </div>
+        <div class="about-visual">
+          <div class="about-stat-grid">
+            <div class="about-stat">
+              <div class="about-stat-num">3</div>
+              <div class="about-stat-label">AI Detection Models</div>
+            </div>
+            <div class="about-stat">
+              <div class="about-stat-num">5+</div>
+              <div class="about-stat-label">Forensic Analyzers</div>
+            </div>
+            <div class="about-stat">
+              <div class="about-stat-num">0</div>
+              <div class="about-stat-label">Images Stored</div>
+            </div>
+            <div class="about-stat">
+              <div class="about-stat-num">4</div>
+              <div class="about-stat-label">Team Members</div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </section>
+
+  <!-- ── PROJECT HIGHLIGHTS ─────────────────────────────────────── -->
+  <section class="highlights-section" id="highlights">
+    <div class="page-wrap">
+      <div class="section-header">
+        <div class="section-tag">Capabilities</div>
+        <h2 class="section-title">Project Highlights</h2>
+        <p class="section-desc">What makes ImgAuth AI powerful under the hood.</p>
+      </div>
+      <div class="highlights-grid">
+        <div class="highlight-card">
+          <div class="highlight-icon">🧠</div>
+          <h4>Multi-Model AI Detection</h4>
+          <p>Three independent deep learning models vote on whether an image is AI-generated, increasing accuracy and reducing bias.</p>
+        </div>
+        <div class="highlight-card">
+          <div class="highlight-icon">🔬</div>
+          <h4>Visual Forensic Analysis</h4>
+          <p>Noise kurtosis, FFT spectral analysis, and deep feature inconsistency mapping expose subtle AI generation artifacts.</p>
+        </div>
+        <div class="highlight-card">
+          <div class="highlight-icon">🗺️</div>
+          <h4>Explainable AI Visualization</h4>
+          <p>Heatmaps and attention maps highlight exactly which regions of the image influenced the detection result.</p>
+        </div>
+        <div class="highlight-card">
+          <div class="highlight-icon">🔒</div>
+          <h4>Privacy-Focused Processing</h4>
+          <p>All analysis happens in-memory. Images are never written to disk, stored in databases, or shared with third parties.</p>
+        </div>
+        <div class="highlight-card">
+          <div class="highlight-icon">⚡</div>
+          <h4>Real-Time Image Scanning</h4>
+          <p>Fast pipeline design minimizes model load time. Results are typically delivered within 10–30 seconds.</p>
+        </div>
+        <div class="highlight-card">
+          <div class="highlight-icon">📊</div>
+          <h4>Confidence Scoring System</h4>
+          <p>A weighted ensemble scoring engine combines all signals into a single, calibrated authenticity confidence score.</p>
+        </div>
+      </div>
+    </div>
+  </section>
+
+  <!-- ── TECHNOLOGY STACK ────────────────────────────────────────── -->
+  <section class="tech-section" id="tech">
+    <div class="page-wrap">
+      <div class="section-header">
+        <div class="section-tag">Built With</div>
+        <h2 class="section-title">Technology Stack</h2>
+        <p class="section-desc">Modern tools and frameworks powering the platform.</p>
+      </div>
+      <div class="tech-grid">
+        <div class="tech-group">
+          <div class="tech-group-label">Frontend</div>
+          <div class="tech-chips">
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#e34c26"></span>HTML5</span>
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#264de4"></span>CSS3</span>
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#f7df1e"></span>JavaScript</span>
+          </div>
+        </div>
+        <div class="tech-group">
+          <div class="tech-group-label">Backend</div>
+          <div class="tech-chips">
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#009688"></span>FastAPI</span>
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#3776ab"></span>Python 3.11</span>
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#10b981"></span>Uvicorn</span>
+          </div>
+        </div>
+        <div class="tech-group">
+          <div class="tech-group-label">AI / ML</div>
+          <div class="tech-chips">
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#ee4c2c"></span>PyTorch</span>
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#f59e0b"></span>HuggingFace</span>
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#7c3aed"></span>ViT Model</span>
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#a855f7"></span>CNN Model</span>
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#06b6d4"></span>OpenCV</span>
+          </div>
+        </div>
+        <div class="tech-group">
+          <div class="tech-group-label">Deployment</div>
+          <div class="tech-chips">
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#ff6b35"></span>HuggingFace Spaces</span>
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#24292e"></span>Docker</span>
+            <span class="tech-chip"><span class="tech-chip-dot" style="background:#2563eb"></span>GitHub</span>
+          </div>
+        </div>
+      </div>
+    </div>
+  </section>
+
+  <!-- ── MEET THE TEAM ───────────────────────────────────────────── -->
+  <section class="team-section" id="team">
+    <div class="page-wrap">
+      <div class="section-header">
+        <div class="section-tag">The Builders</div>
+        <h2 class="section-title">Meet the Team</h2>
+        <p class="section-desc">Four students building at the intersection of AI, cybersecurity, and design.</p>
+      </div>
+      <div class="team-grid">
+
+        <!-- Vishal -->
+        <div class="team-card">
+          <div class="team-avatar team-avatar--photo" style="background-image:url('https://raw.githubusercontent.com/Raksha-dev11/ImgAuth/main/frontend/static/images/vishal.jpeg'); background-size: 90%; background-position: center 15%;"></div>
+          <div class="team-name">Vishal Chauhan</div>
+          <div class="team-role">Project Lead &amp; Detection Logic</div>
+          <div class="team-branch">CCS</div>
+          <p class="team-desc">Designed overall architecture, coordinated module integration, defined the scoring strategy, and supervised technical direction and core detector logic.</p>
+          <div class="team-links">
+            <a href="https://github.com/metaexploder" class="team-link" aria-label="GitHub" target="_blank" rel="noopener noreferrer">
+              <svg width="15" height="15" viewBox="0 0 24 24" fill="currentColor"><path d="M12 0C5.374 0 0 5.373 0 12c0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23A11.509 11.509 0 0 1 12 5.803c1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576C20.566 21.797 24 17.3 24 12c0-6.627-5.373-12-12-12z"/></svg>
+            </a>
+            <a href="https://www.linkedin.com/in/vishal8448" class="team-link" aria-label="LinkedIn" target="_blank" rel="noopener noreferrer">
+              <svg width="15" height="15" viewBox="0 0 24 24" fill="currentColor"><path d="M20.447 20.452h-3.554v-5.569c0-1.328-.027-3.037-1.852-3.037-1.853 0-2.136 1.445-2.136 2.939v5.667H9.351V9h3.414v1.561h.046c.477-.9 1.637-1.85 3.37-1.85 3.601 0 4.267 2.37 4.267 5.455v6.286zM5.337 7.433a2.062 2.062 0 0 1-2.063-2.065 2.064 2.064 0 1 1 2.063 2.065zm1.782 13.019H3.555V9h3.564v11.452zM22.225 0H1.771C.792 0 0 .774 0 1.729v20.542C0 23.227.792 24 1.771 24h20.451C23.2 24 24 23.227 24 22.271V1.729C24 .774 23.2 0 22.222 0h.003z"/></svg>
+            </a>
+          </div>
+        </div>
+
+        <!-- Prince Mishra -->
+        <div class="team-card">
+          <div class="team-avatar team-avatar--photo" style="background-image:url('https://raw.githubusercontent.com/Raksha-dev11/ImgAuth/main/frontend/static/images/princemishra.jpeg')"></div>
+          <div class="team-name">Prince Mishra</div>
+          <div class="team-role">Backend &amp; API Developer</div>
+          <div class="team-branch">CSE</div>
+          <p class="team-desc">Implemented FastAPI routes, file validation, request handling, backend orchestration, and API-result communication between all system layers.</p>
+          <div class="team-links">
+            <a href="https://github.com/Prince1605" class="team-link" aria-label="GitHub" target="_blank" rel="noopener noreferrer">
+              <svg width="15" height="15" viewBox="0 0 24 24" fill="currentColor"><path d="M12 0C5.374 0 0 5.373 0 12c0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23A11.509 11.509 0 0 1 12 5.803c1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576C20.566 21.797 24 17.3 24 12c0-6.627-5.373-12-12-12z"/></svg>
+            </a>
+            <a href="https://www.linkedin.com/in/prince-mishra-86bb8b343/" class="team-link" aria-label="LinkedIn" target="_blank" rel="noopener noreferrer">
+              <svg width="15" height="15" viewBox="0 0 24 24" fill="currentColor"><path d="M20.447 20.452h-3.554v-5.569c0-1.328-.027-3.037-1.852-3.037-1.853 0-2.136 1.445-2.136 2.939v5.667H9.351V9h3.414v1.561h.046c.477-.9 1.637-1.85 3.37-1.85 3.601 0 4.267 2.37 4.267 5.455v6.286zM5.337 7.433a2.062 2.062 0 0 1-2.063-2.065 2.064 2.064 0 1 1 2.063 2.065zm1.782 13.019H3.555V9h3.564v11.452zM22.225 0H1.771C.792 0 0 .774 0 1.729v20.542C0 23.227.792 24 1.771 24h20.451C23.2 24 24 23.227 24 22.271V1.729C24 .774 23.2 0 22.222 0h.003z"/></svg>
+            </a>
+          </div>
+        </div>
+
+        <!-- Prince Dubey -->
+        <div class="team-card">
+          <div class="team-avatar team-avatar--photo" style="background-image:url('https://raw.githubusercontent.com/Raksha-dev11/ImgAuth/main/frontend/static/images/princedubey.jpeg')"></div>
+          <div class="team-name">Prince Dubey</div>
+          <div class="team-role">Security, Testing &amp; Docs</div>
+          <div class="team-branch">CSE</div>
+          <p class="team-desc">Managed QA workflows, testing strategies, bug tracking, documentation, and security review of file handling and user interactions.</p>
+          <div class="team-links">
+            <a href="https://github.com/PR1NC3-DUB3Y" class="team-link" aria-label="GitHub" target="_blank" rel="noopener noreferrer">
+              <svg width="15" height="15" viewBox="0 0 24 24" fill="currentColor"><path d="M12 0C5.374 0 0 5.373 0 12c0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23A11.509 11.509 0 0 1 12 5.803c1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576C20.566 21.797 24 17.3 24 12c0-6.627-5.373-12-12-12z"/></svg>
+            </a>
+            <a href="https://www.linkedin.com/in/prince-dubey-8a0b65271" class="team-link" aria-label="LinkedIn" target="_blank" rel="noopener noreferrer">
+              <svg width="15" height="15" viewBox="0 0 24 24" fill="currentColor"><path d="M20.447 20.452h-3.554v-5.569c0-1.328-.027-3.037-1.852-3.037-1.853 0-2.136 1.445-2.136 2.939v5.667H9.351V9h3.414v1.561h.046c.477-.9 1.637-1.85 3.37-1.85 3.601 0 4.267 2.37 4.267 5.455v6.286zM5.337 7.433a2.062 2.062 0 0 1-2.063-2.065 2.064 2.064 0 1 1 2.063 2.065zm1.782 13.019H3.555V9h3.564v11.452zM22.225 0H1.771C.792 0 0 .774 0 1.729v20.542C0 23.227.792 24 1.771 24h20.451C23.2 24 24 23.227 24 22.271V1.729C24 .774 23.2 0 22.222 0h.003z"/></svg>
+            </a>
+          </div>
+        </div>
+
+        <!-- Raksha -->
+        <div class="team-card">
+          <div class="team-avatar team-avatar--photo" style="background-image:url('https://raw.githubusercontent.com/Raksha-dev11/ImgAuth/main/frontend/static/images/raksha.jpeg'); background-size: 90%; background-position: center 15%;"></div>
+          <div class="team-name">Raksha</div>
+          <div class="team-role">Frontend &amp; UI Developer</div>
+          <div class="team-branch">CSE</div>
+          <p class="team-desc">Designed the upload interface, result dashboard, theme system, history display, and client-side interaction logic throughout the application.</p>
+          <div class="team-links">
+            <a href="https://github.com/Raksha-dev11" class="team-link" aria-label="GitHub" target="_blank" rel="noopener noreferrer">
+              <svg width="15" height="15" viewBox="0 0 24 24" fill="currentColor"><path d="M12 0C5.374 0 0 5.373 0 12c0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23A11.509 11.509 0 0 1 12 5.803c1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576C20.566 21.797 24 17.3 24 12c0-6.627-5.373-12-12-12z"/></svg>
+            </a>
+            <a href="https://www.linkedin.com/in/raksha-thakur-ba9316326" class="team-link" aria-label="LinkedIn" target="_blank" rel="noopener noreferrer">
+              <svg width="15" height="15" viewBox="0 0 24 24" fill="currentColor"><path d="M20.447 20.452h-3.554v-5.569c0-1.328-.027-3.037-1.852-3.037-1.853 0-2.136 1.445-2.136 2.939v5.667H9.351V9h3.414v1.561h.046c.477-.9 1.637-1.85 3.37-1.85 3.601 0 4.267 2.37 4.267 5.455v6.286zM5.337 7.433a2.062 2.062 0 0 1-2.063-2.065 2.064 2.064 0 1 1 2.063 2.065zm1.782 13.019H3.555V9h3.564v11.452zM22.225 0H1.771C.792 0 0 .774 0 1.729v20.542C0 23.227.792 24 1.771 24h20.451C23.2 24 24 23.227 24 22.271V1.729C24 .774 23.2 0 22.222 0h.003z"/></svg>
+            </a>
+          </div>
+        </div>
+
+      </div>
+    </div>
+  </section>
+
+  <!-- ── FOOTER ──────────────────────────────────────────────────── -->
+  <footer class="footer">
+    <div class="footer-inner">
+      <div class="footer-top">
+        <div>
+          <div class="footer-brand-name">ImgAuth <span class="logo-accent">AI</span></div>
+          <p class="footer-brand-desc">A college AI &amp; cybersecurity project. Detect AI-generated images using deep learning and forensic analysis.</p>
+          <p class="footer-privacy-note">🔒 Images are processed in-memory and never permanently stored.</p>
+        </div>
+        <div class="footer-col">
+          <h5>Product</h5>
+          <ul>
+            <li><a href="#uploadSection">Check an Image</a></li>
+            <li><a href="#how-it-works">How it works</a></li>
+            <li><a href="#highlights">Features</a></li>
+          </ul>
+        </div>
+        <div class="footer-col">
+          <h5>Project</h5>
+          <ul>
+            <li><a href="#about">About</a></li>
+            <li><a href="#tech">Tech Stack</a></li>
+            <li><a href="#team">Meet the Team</a></li>
+          </ul>
+        </div>
+        <div class="footer-col">
+          <h5>Resources</h5>
+          <ul>
+            <li><a href="https://github.com" target="_blank" rel="noopener">GitHub</a></li>
+            <li><a href="https://huggingface.co/umm-maybe/AI-image-detector" target="_blank" rel="noopener">umm-maybe Model</a></li>
+            <li><a href="https://huggingface.co/dima806/ai_vs_real_image_detection" target="_blank" rel="noopener">dima806 Model</a></li>
+          </ul>
+        </div>
+      </div>
+      <div class="footer-bottom">
+        <p class="footer-copy">&copy; 2026 ImgAuth AI &mdash; Built by Team VisionGuard</p>
+        <p class="footer-attribution">
+          Powered by:
+          <a href="https://huggingface.co/umm-maybe/AI-image-detector" target="_blank" rel="noopener">umm-maybe/AI-image-detector</a> &middot;
+          <a href="https://huggingface.co/dima806/ai_vs_real_image_detection" target="_blank" rel="noopener">dima806/ai_vs_real_image_detection</a> &middot;
+          <a href="https://huggingface.co/Organika/sdxl-detector" target="_blank" rel="noopener">Organika/sdxl-detector</a>
+        </p>
+      </div>
+    </div>
+  </footer>
+
+  <script src="/static/js/app.js"></script>
+</body>
+</html>

frontend/static/css/style.css

@@ -0,0 +1,693 @@
+/* ═══════════════════════════════════════════════════════════════
+   ImgAuth AI — Premium Dark UI System
+   ═══════════════════════════════════════════════════════════════ */
+
+@import url('https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:ital,wght@0,300;0,400;0,500;0,600;0,700;0,800;1,400&display=swap');
+
+/* ── Design Tokens ─────────────────────────────────────────────── */
+:root {
+  --bg:            #080810;
+  --bg-secondary:  #0d0d1a;
+  --surface:       rgba(255,255,255,0.04);
+  --surface-solid: #111122;
+  --surface-hover: rgba(255,255,255,0.07);
+  --border:        rgba(255,255,255,0.08);
+  --border-hover:  rgba(255,255,255,0.16);
+
+  --text:          #f1f1f8;
+  --text-2:        #9898b8;
+  --text-3:        #5a5a7a;
+
+  --purple:        #7c3aed;
+  --purple-light:  #a855f7;
+  --purple-glow:   rgba(124,58,237,0.20);
+  --purple-grad:   linear-gradient(135deg, #7c3aed 0%, #a855f7 100%);
+
+  --green:         #10b981;
+  --green-bg:      rgba(16,185,129,0.12);
+  --green-border:  rgba(16,185,129,0.30);
+  --orange:        #f59e0b;
+  --orange-bg:     rgba(245,158,11,0.12);
+  --orange-border: rgba(245,158,11,0.30);
+  --red:           #ef4444;
+  --red-bg:        rgba(239,68,68,0.12);
+  --red-border:    rgba(239,68,68,0.30);
+
+  --radius-xl:  20px;
+  --radius-lg:  16px;
+  --radius-md:  12px;
+  --radius-sm:   8px;
+  --radius-xs:   6px;
+
+  --font: 'Plus Jakarta Sans', -apple-system, system-ui, sans-serif;
+  --mono: 'JetBrains Mono', 'Fira Code', monospace;
+
+  --shadow-sm:  0 2px 8px rgba(0,0,0,0.3);
+  --shadow-md:  0 4px 24px rgba(0,0,0,0.4);
+  --shadow-lg:  0 8px 48px rgba(0,0,0,0.5);
+  --shadow-purple: 0 0 32px rgba(124,58,237,0.25);
+
+  --transition: 0.22s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+[data-theme="light"] {
+  --bg:            #f5f4fb;
+  --bg-secondary:  #eeedf8;
+  --surface:       rgba(255,255,255,0.80);
+  --surface-solid: #ffffff;
+  --surface-hover: rgba(255,255,255,0.95);
+  --border:        rgba(0,0,0,0.08);
+  --border-hover:  rgba(0,0,0,0.16);
+  --text:          #0d0d1a;
+  --text-2:        #44445a;
+  --text-3:        #9898b0;
+  --purple-glow:   rgba(124,58,237,0.10);
+  --shadow-md:     0 4px 24px rgba(0,0,0,0.08);
+  --shadow-lg:     0 8px 48px rgba(0,0,0,0.12);
+}
+
+/* ── Reset ──────────────────────────────────────────────────────── */
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+html { scroll-behavior: smooth; }
+body {
+  background: var(--bg);
+  color: var(--text);
+  font-family: var(--font);
+  line-height: 1.6;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  overflow-x: hidden;
+}
+a { color: inherit; text-decoration: none; }
+img { max-width: 100%; display: block; }
+button { font-family: var(--font); }
+
+/* ── Scrollbar ──────────────────────────────────────────────────── */
+::-webkit-scrollbar { width: 6px; }
+::-webkit-scrollbar-track { background: var(--bg); }
+::-webkit-scrollbar-thumb { background: rgba(124,58,237,0.4); border-radius: 3px; }
+
+/* ── Layout Wrappers ────────────────────────────────────────────── */
+.page-wrap { max-width: 1100px; margin: 0 auto; padding: 0 24px; }
+.section-wrap { max-width: 900px; margin: 0 auto; padding: 0 24px; }
+
+/* ── Header ─────────────────────────────────────────────────────── */
+.header {
+  position: sticky; top: 0; z-index: 200;
+  background: rgba(8,8,16,0.80);
+  backdrop-filter: blur(20px);
+  -webkit-backdrop-filter: blur(20px);
+  border-bottom: 1px solid var(--border);
+  transition: background var(--transition);
+}
+[data-theme="light"] .header { background: rgba(245,244,251,0.85); }
+
+.header-inner {
+  max-width: 1200px; margin: 0 auto; padding: 0 24px;
+  height: 64px; display: flex; align-items: center; gap: 16px;
+}
+.logo {
+  display: flex; align-items: center; gap: 10px;
+  font-weight: 800; font-size: 1.1rem; letter-spacing: -0.02em;
+  flex-shrink: 0;
+}
+.logo-accent {
+  background: var(--purple-grad);
+  -webkit-background-clip: text; -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+.nav-links { display: flex; align-items: center; gap: 8px; margin-left: auto; }
+.nav-link {
+  color: var(--text-2); font-size: 0.875rem; font-weight: 500;
+  padding: 6px 14px; border-radius: var(--radius-sm);
+  transition: color var(--transition), background var(--transition);
+}
+.nav-link:hover { color: var(--text); background: var(--surface-hover); }
+.theme-btn {
+  width: 38px; height: 38px; border-radius: 50%;
+  background: var(--surface); border: 1px solid var(--border);
+  color: var(--text-2); cursor: pointer; font-size: 1rem;
+  display: flex; align-items: center; justify-content: center;
+  transition: var(--transition); flex-shrink: 0;
+}
+.theme-btn:hover { border-color: var(--purple); color: var(--purple); background: var(--purple-glow); }
+
+/* ── Buttons ────────────────────────────────────────────────────── */
+.btn {
+  display: inline-flex; align-items: center; justify-content: center; gap: 8px;
+  padding: 12px 28px; border-radius: var(--radius-md);
+  font-family: var(--font); font-size: 0.9rem; font-weight: 700;
+  border: none; cursor: pointer; transition: var(--transition);
+  white-space: nowrap;
+}
+.btn-primary {
+  background: var(--purple-grad); color: #fff;
+  box-shadow: 0 4px 16px rgba(124,58,237,0.30);
+}
+.btn-primary:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 8px 28px rgba(124,58,237,0.45);
+}
+.btn-primary:active { transform: translateY(0); }
+.btn-ghost {
+  background: transparent; color: var(--text-2);
+  border: 1px solid var(--border);
+}
+.btn-ghost:hover { border-color: var(--border-hover); color: var(--text); background: var(--surface-hover); }
+.btn-sm { padding: 8px 18px; font-size: 0.82rem; }
+
+/* ── Hero ───────────────────────────────────────────────────────── */
+.hero {
+  padding: 96px 24px 64px;
+  text-align: center;
+  position: relative;
+  overflow: hidden;
+}
+.hero::before {
+  content: '';
+  position: absolute; inset: 0;
+  background:
+    radial-gradient(ellipse 60% 50% at 50% 0%, rgba(124,58,237,0.18) 0%, transparent 70%);
+  pointer-events: none;
+}
+.hero-eyebrow {
+  display: inline-flex; align-items: center; gap: 8px;
+  background: var(--purple-glow); border: 1px solid rgba(124,58,237,0.30);
+  color: var(--purple-light); font-size: 0.78rem; font-weight: 700;
+  padding: 5px 16px; border-radius: 999px; margin-bottom: 28px;
+  letter-spacing: 0.04em; text-transform: uppercase;
+}
+.hero h1 {
+  font-size: clamp(2.4rem, 5.5vw, 3.6rem);
+  font-weight: 800; line-height: 1.12;
+  letter-spacing: -0.03em; margin-bottom: 20px;
+}
+.hero h1 .grad {
+  background: var(--purple-grad);
+  -webkit-background-clip: text; -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+.hero-sub {
+  color: var(--text-2); font-size: 1.05rem; line-height: 1.65;
+  max-width: 580px; margin: 0 auto 48px;
+}
+.hero-stats {
+  display: flex; justify-content: center; gap: 48px;
+  flex-wrap: wrap;
+}
+.stat { text-align: center; }
+.stat-num { font-size: 1.6rem; font-weight: 800; color: var(--purple-light); }
+.stat-label { font-size: 0.78rem; color: var(--text-3); font-weight: 500; }
+
+/* ── Upload ─────────────────────────────────────────────────────── */
+.upload-section { padding: 0 24px 80px; }
+.upload-card {
+  max-width: 580px; margin: 0 auto;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-xl);
+  backdrop-filter: blur(12px);
+  box-shadow: var(--shadow-md);
+  overflow: hidden;
+  transition: border-color var(--transition), box-shadow var(--transition);
+}
+.upload-card:hover { border-color: rgba(124,58,237,0.30); box-shadow: var(--shadow-purple); }
+
+.drop-zone {
+  padding: 52px 32px; text-align: center;
+  border: 2px dashed var(--border);
+  border-radius: var(--radius-lg);
+  margin: 16px;
+  cursor: pointer;
+  transition: var(--transition);
+  position: relative;
+}
+.drop-zone:hover, .drop-zone.drag-over {
+  border-color: var(--purple);
+  background: var(--purple-glow);
+}
+.drop-icon {
+  width: 64px; height: 64px;
+  background: var(--purple-glow);
+  border: 1px solid rgba(124,58,237,0.25);
+  border-radius: var(--radius-lg);
+  display: flex; align-items: center; justify-content: center;
+  margin: 0 auto 20px; color: var(--purple-light);
+  transition: transform var(--transition);
+}
+.drop-zone:hover .drop-icon { transform: translateY(-4px); }
+.drop-title { font-size: 1.15rem; font-weight: 700; margin-bottom: 6px; }
+.drop-sub { color: var(--text-2); font-size: 0.875rem; margin-bottom: 24px; }
+.drop-hint { color: var(--text-3); font-size: 0.78rem; margin-top: 14px; }
+
+.preview-zone { padding: 28px; text-align: center; }
+.preview-img-box {
+  border-radius: var(--radius-md);
+  overflow: hidden; border: 1px solid var(--border);
+  margin: 0 auto 16px; max-height: 280px;
+  background: rgba(0,0,0,0.3);
+  display: flex; align-items: center; justify-content: center;
+}
+.preview-img-box img { max-height: 280px; object-fit: contain; width: 100%; }
+.preview-filename {
+  font-size: 0.85rem; font-weight: 600; color: var(--text-2);
+  margin-bottom: 20px; word-break: break-all;
+}
+.preview-actions { display: flex; gap: 10px; justify-content: center; flex-wrap: wrap; }
+
+/* ── Loading ─────────────────────────────────────────────────────── */
+.loading-overlay {
+  position: fixed; inset: 0; z-index: 500;
+  background: rgba(8,8,16,0.88);
+  backdrop-filter: blur(12px);
+  display: flex; align-items: center; justify-content: center;
+}
+.loading-card {
+  background: var(--surface-solid);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-xl);
+  padding: 44px 40px; width: 420px; max-width: 90vw;
+  box-shadow: var(--shadow-lg); text-align: center;
+}
+.spinner-ring {
+  width: 56px; height: 56px; margin: 0 auto 28px;
+  border: 3px solid var(--border);
+  border-top-color: var(--purple);
+  border-radius: 50%;
+  animation: spin 0.85s cubic-bezier(0.5, 0.1, 0.4, 0.9) infinite;
+}
+@keyframes spin { to { transform: rotate(360deg); } }
+.loading-title { font-size: 1.15rem; font-weight: 700; margin-bottom: 6px; }
+.loading-sub { font-size: 0.82rem; color: var(--text-2); margin-bottom: 28px; }
+.steps-list { text-align: left; display: flex; flex-direction: column; gap: 6px; }
+.step {
+  padding: 8px 14px; border-radius: var(--radius-sm);
+  font-size: 0.82rem; color: var(--text-3);
+  display: flex; align-items: center; gap: 10px;
+  transition: var(--transition);
+}
+.step::before { content: '○'; font-size: 0.7rem; flex-shrink: 0; }
+.step.active { background: var(--purple-glow); color: var(--purple-light); font-weight: 600; }
+.step.active::before { content: '●'; color: var(--purple); animation: pulse 1s infinite; }
+.step.done { color: var(--green); }
+.step.done::before { content: '✓'; color: var(--green); }
+@keyframes pulse { 0%,100%{opacity:1} 50%{opacity:0.4} }
+
+/* ── Result Section ─────────────────────────────────────────────── */
+.result-section { padding: 16px 24px 64px; }
+.result-wrap { max-width: 900px; margin: 0 auto; display: flex; flex-direction: column; gap: 28px; }
+
+/* Verdict Card */
+.verdict-card {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-xl);
+  backdrop-filter: blur(12px);
+  overflow: hidden;
+  box-shadow: var(--shadow-md);
+}
+.verdict-layout {
+  display: grid; grid-template-columns: 260px 1fr;
+}
+.result-img-panel {
+  background: rgba(0,0,0,0.25);
+  display: flex; align-items: center; justify-content: center;
+  padding: 28px;
+  border-right: 1px solid var(--border);
+}
+.result-img-panel img {
+  max-height: 220px; border-radius: var(--radius-md);
+  border: 1px solid var(--border);
+  object-fit: cover;
+  width: 100%;
+}
+.verdict-info { padding: 32px 36px; display: flex; flex-direction: column; gap: 20px; }
+
+.verdict-badge {
+  display: inline-flex; align-items: center; gap: 8px;
+  padding: 6px 16px; border-radius: 999px;
+  font-size: 0.78rem; font-weight: 800;
+  text-transform: uppercase; letter-spacing: 0.05em;
+  width: fit-content;
+}
+.verdict-badge.is-ai {
+  background: var(--red-bg); color: var(--red);
+  border: 1px solid var(--red-border);
+}
+.verdict-badge.is-real {
+  background: var(--green-bg); color: var(--green);
+  border: 1px solid var(--green-border);
+}
+.verdict-badge svg { width: 12px; height: 12px; }
+
+.verdict-heading { font-size: 1.8rem; font-weight: 800; letter-spacing: -0.025em; line-height: 1.2; }
+.verdict-heading.is-ai { color: var(--red); }
+.verdict-heading.is-real { color: var(--green); }
+
+.confidence-label { font-size: 0.85rem; color: var(--text-2); font-weight: 500; }
+
+.gauge-wrap {}
+.gauge-meta {
+  display: flex; justify-content: space-between;
+  font-size: 0.75rem; color: var(--text-3); font-weight: 600; margin-bottom: 8px;
+}
+.gauge-track {
+  height: 10px; background: rgba(255,255,255,0.06);
+  border-radius: 999px; position: relative;
+  border: 1px solid var(--border);
+}
+.gauge-fill {
+  height: 100%; border-radius: 999px;
+  background: linear-gradient(90deg, var(--green) 0%, var(--orange) 48%, var(--red) 100%);
+  transition: width 1.3s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+.gauge-dot {
+  position: absolute; top: 50%;
+  transform: translate(-50%, -50%);
+  width: 18px; height: 18px; border-radius: 50%;
+  background: #fff; border: 3px solid var(--purple);
+  box-shadow: 0 0 0 3px var(--purple-glow), 0 2px 8px rgba(0,0,0,0.4);
+  transition: left 1.3s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+.gauge-vals {
+  display: flex; justify-content: space-between;
+  font-size: 0.82rem; font-weight: 700; margin-top: 8px;
+}
+
+.verdict-summary-text {
+  font-size: 0.9rem; line-height: 1.6; color: var(--text-2);
+  padding: 14px 18px;
+  background: rgba(255,255,255,0.03);
+  border-left: 3px solid var(--purple);
+  border-radius: 0 var(--radius-sm) var(--radius-sm) 0;
+}
+
+/* Why This Result */
+.result-block-title {
+  font-size: 1.1rem; font-weight: 700; letter-spacing: -0.01em;
+  margin-bottom: 16px;
+}
+.why-grid { display: grid; grid-template-columns: repeat(3,1fr); gap: 16px; }
+.why-card {
+  background: var(--surface); border: 1px solid var(--border);
+  border-radius: var(--radius-lg); padding: 22px;
+  transition: border-color var(--transition), transform var(--transition);
+}
+.why-card:hover { border-color: var(--border-hover); transform: translateY(-2px); }
+.why-icon {
+  width: 38px; height: 38px; border-radius: var(--radius-sm);
+  display: flex; align-items: center; justify-content: center;
+  font-size: 1.1rem; margin-bottom: 14px;
+}
+.why-icon.purple { background: var(--purple-glow); border: 1px solid rgba(124,58,237,0.25); }
+.why-icon.blue   { background: rgba(59,130,246,0.12); border: 1px solid rgba(59,130,246,0.25); }
+.why-icon.teal   { background: rgba(20,184,166,0.12); border: 1px solid rgba(20,184,166,0.25); }
+.why-card h4 { font-size: 0.9rem; font-weight: 700; margin-bottom: 8px; }
+.why-card p { font-size: 0.82rem; color: var(--text-2); line-height: 1.55; }
+
+/* AI Focus Areas */
+.focus-grid { display: grid; grid-template-columns: repeat(2,1fr); gap: 20px; }
+.focus-card {
+  background: var(--surface); border: 1px solid var(--border);
+  border-radius: var(--radius-lg); padding: 22px;
+}
+.focus-card h4 { font-size: 0.9rem; font-weight: 700; margin-bottom: 4px; }
+.focus-card p { font-size: 0.78rem; color: var(--text-3); margin-bottom: 14px; }
+.heatmap-box {
+  border-radius: var(--radius-sm); overflow: hidden;
+  border: 1px solid var(--border);
+  background: #000; aspect-ratio: 4/3;
+  display: flex; align-items: center; justify-content: center;
+}
+.heatmap-box img { width: 100%; height: 100%; object-fit: contain; }
+
+/* Advanced Toggle */
+.adv-section { border-top: 1px solid var(--border); }
+.adv-toggle {
+  width: 100%; background: none; border: none;
+  display: flex; align-items: center; justify-content: center; gap: 8px;
+  color: var(--text-3); font-size: 0.82rem; font-weight: 600;
+  padding: 18px 0; cursor: pointer;
+  transition: color var(--transition);
+}
+.adv-toggle:hover { color: var(--text-2); }
+.adv-toggle svg { transition: transform 0.25s ease; }
+.adv-toggle[aria-expanded="true"] svg { transform: rotate(180deg); }
+.adv-body {
+  background: rgba(0,0,0,0.2); border-top: 1px solid var(--border);
+  padding: 24px;
+}
+.adv-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(240px,1fr)); gap: 14px; }
+.adv-card {
+  background: var(--surface); border: 1px solid var(--border);
+  border-radius: var(--radius-md); padding: 16px;
+}
+.adv-card-title {
+  font-size: 0.8rem; font-weight: 700; color: var(--text-2);
+  margin-bottom: 12px; text-transform: uppercase; letter-spacing: 0.04em;
+}
+.adv-list { list-style: none; display: flex; flex-direction: column; gap: 7px; }
+.adv-list li {
+  display: flex; justify-content: space-between; align-items: center;
+  font-size: 0.78rem; color: var(--text-2);
+  padding-bottom: 6px; border-bottom: 1px solid var(--border);
+}
+.adv-list li:last-child { border: none; padding-bottom: 0; }
+.adv-val { font-family: var(--mono); font-size: 0.75rem; color: var(--text); font-weight: 600; }
+.adv-log {
+  grid-column: 1 / -1;
+  background: rgba(0,0,0,0.3); border: 1px solid var(--border);
+  border-radius: var(--radius-md); padding: 16px;
+  max-height: 180px; overflow-y: auto;
+  font-family: var(--mono); font-size: 0.73rem;
+  color: var(--text-2); line-height: 1.8;
+}
+
+.result-cta { text-align: center; padding-top: 8px; }
+
+/* ── How It Works ────────────────────────────────────────────────── */
+.how-section {
+  padding: 96px 24px;
+  background: var(--bg-secondary);
+  border-top: 1px solid var(--border);
+}
+.section-header { text-align: center; margin-bottom: 56px; }
+.section-tag {
+  display: inline-block;
+  background: var(--purple-glow); color: var(--purple-light);
+  border: 1px solid rgba(124,58,237,0.25);
+  font-size: 0.72rem; font-weight: 700; text-transform: uppercase;
+  letter-spacing: 0.06em; padding: 4px 14px; border-radius: 999px; margin-bottom: 14px;
+}
+.section-title { font-size: clamp(1.6rem, 3.5vw, 2.2rem); font-weight: 800; letter-spacing: -0.025em; margin-bottom: 10px; }
+.section-desc { font-size: 0.95rem; color: var(--text-2); max-width: 520px; margin: 0 auto; }
+
+.how-grid { display: grid; grid-template-columns: repeat(3,1fr); gap: 24px; }
+.how-card {
+  background: var(--surface); border: 1px solid var(--border);
+  border-radius: var(--radius-lg); padding: 32px 24px;
+  text-align: center; transition: var(--transition);
+  position: relative; overflow: hidden;
+}
+.how-card::before {
+  content: '';
+  position: absolute; top: 0; left: 0; right: 0; height: 2px;
+  background: var(--purple-grad); opacity: 0;
+  transition: opacity var(--transition);
+}
+.how-card:hover { border-color: var(--border-hover); transform: translateY(-4px); box-shadow: var(--shadow-md); }
+.how-card:hover::before { opacity: 1; }
+.how-num {
+  font-size: 2.4rem; font-weight: 800; color: var(--purple-light);
+  opacity: 0.35; line-height: 1; margin-bottom: 20px;
+}
+.how-card h3 { font-size: 1rem; font-weight: 700; margin-bottom: 10px; }
+.how-card p { font-size: 0.85rem; color: var(--text-2); line-height: 1.55; }
+
+/* ── About Section ───────────────────────────────────────────────── */
+.about-section { padding: 96px 24px; border-top: 1px solid var(--border); }
+.about-grid { display: grid; grid-template-columns: 1fr 420px; gap: 60px; align-items: center; }
+.about-text .section-tag { margin-bottom: 14px; }
+.about-text h2 { font-size: clamp(1.6rem, 3vw, 2.2rem); font-weight: 800; letter-spacing: -0.025em; margin-bottom: 20px; }
+.about-text p { font-size: 0.92rem; color: var(--text-2); line-height: 1.75; margin-bottom: 14px; }
+.about-visual {
+  background: var(--surface); border: 1px solid var(--border);
+  border-radius: var(--radius-xl); padding: 36px;
+  position: relative; overflow: hidden;
+}
+.about-visual::before {
+  content: '';
+  position: absolute; top: -60px; right: -60px; width: 200px; height: 200px;
+  background: radial-gradient(circle, rgba(124,58,237,0.25) 0%, transparent 70%);
+  pointer-events: none;
+}
+.about-stat-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; }
+.about-stat {
+  background: rgba(0,0,0,0.2); border: 1px solid var(--border);
+  border-radius: var(--radius-md); padding: 20px;
+}
+.about-stat-num { font-size: 1.6rem; font-weight: 800; color: var(--purple-light); margin-bottom: 4px; }
+.about-stat-label { font-size: 0.78rem; color: var(--text-2); font-weight: 500; }
+
+/* ── Project Highlights ──────────────────────────────────────────── */
+.highlights-section {
+  padding: 96px 24px;
+  background: var(--bg-secondary);
+  border-top: 1px solid var(--border);
+}
+.highlights-grid { display: grid; grid-template-columns: repeat(3,1fr); gap: 20px; }
+.highlight-card {
+  background: var(--surface); border: 1px solid var(--border);
+  border-radius: var(--radius-lg); padding: 28px;
+  transition: var(--transition);
+}
+.highlight-card:hover { border-color: rgba(124,58,237,0.35); box-shadow: 0 0 24px rgba(124,58,237,0.10); transform: translateY(-2px); }
+.highlight-icon {
+  width: 46px; height: 46px; border-radius: var(--radius-md);
+  background: var(--purple-glow); border: 1px solid rgba(124,58,237,0.25);
+  display: flex; align-items: center; justify-content: center;
+  font-size: 1.3rem; margin-bottom: 16px;
+}
+.highlight-card h4 { font-size: 0.95rem; font-weight: 700; margin-bottom: 8px; }
+.highlight-card p { font-size: 0.82rem; color: var(--text-2); line-height: 1.5; }
+
+/* ── Tech Stack ──────────────────────────────────────────────────── */
+.tech-section { padding: 96px 24px; border-top: 1px solid var(--border); }
+.tech-grid { display: grid; grid-template-columns: repeat(4,1fr); gap: 20px; }
+.tech-group {
+  background: var(--surface); border: 1px solid var(--border);
+  border-radius: var(--radius-lg); padding: 24px;
+}
+.tech-group-label {
+  font-size: 0.72rem; font-weight: 700; text-transform: uppercase;
+  letter-spacing: 0.06em; color: var(--text-3); margin-bottom: 16px;
+}
+.tech-chips { display: flex; flex-wrap: wrap; gap: 8px; }
+.tech-chip {
+  display: flex; align-items: center; gap: 6px;
+  background: rgba(255,255,255,0.05); border: 1px solid var(--border);
+  border-radius: var(--radius-xs); padding: 5px 11px;
+  font-size: 0.78rem; font-weight: 600; color: var(--text-2);
+  transition: var(--transition);
+}
+.tech-chip:hover { border-color: var(--purple); color: var(--purple-light); background: var(--purple-glow); }
+.tech-chip-dot { width: 6px; height: 6px; border-radius: 50%; flex-shrink: 0; }
+
+/* ── Team Section ────────────────────────────────────────────────── */
+.team-section {
+  padding: 96px 24px;
+  background: var(--bg-secondary);
+  border-top: 1px solid var(--border);
+}
+.team-grid { display: grid; grid-template-columns: repeat(4,1fr); gap: 20px; }
+.team-card {
+  background: var(--surface); border: 1px solid var(--border);
+  border-radius: var(--radius-lg); padding: 28px 24px;
+  text-align: center; transition: var(--transition);
+  position: relative; overflow: hidden;
+}
+.team-card::after {
+  content: '';
+  position: absolute; inset: 0;
+  background: linear-gradient(135deg, rgba(124,58,237,0.06) 0%, transparent 60%);
+  opacity: 0; transition: opacity var(--transition);
+  pointer-events: none;
+}
+.team-card:hover { border-color: rgba(124,58,237,0.35); transform: translateY(-4px); box-shadow: var(--shadow-md); }
+.team-card:hover::after { opacity: 1; }
+.team-avatar {
+  width: 72px; height: 72px; border-radius: 50%;
+  background: var(--purple-grad); display: flex; align-items: center;
+  justify-content: center; font-size: 1.5rem; font-weight: 800;
+  color: #fff; margin: 0 auto 18px;
+  box-shadow: 0 0 0 4px rgba(124,58,237,0.20);
+}
+.team-avatar--photo { background-size: cover; background-position: center top; background-color: transparent; font-size: 0; }
+.team-avatar--photo img { display: none; }
+.team-name { font-size: 1rem; font-weight: 700; margin-bottom: 4px; }
+.team-role {
+  font-size: 0.78rem; font-weight: 600;
+  color: var(--purple-light); margin-bottom: 8px;
+}
+.team-branch {
+  display: inline-block; font-size: 0.7rem; font-weight: 700;
+  background: var(--purple-glow); color: var(--purple-light);
+  border: 1px solid rgba(124,58,237,0.20);
+  padding: 2px 10px; border-radius: 999px; margin-bottom: 14px;
+}
+.team-desc { font-size: 0.79rem; color: var(--text-2); line-height: 1.55; margin-bottom: 20px; }
+.team-links { display: flex; justify-content: center; gap: 10px; }
+.team-link {
+  width: 34px; height: 34px; border-radius: var(--radius-sm);
+  background: var(--surface-hover); border: 1px solid var(--border);
+  display: flex; align-items: center; justify-content: center;
+  color: var(--text-2); transition: var(--transition); font-size: 0.85rem;
+}
+.team-link:hover { border-color: var(--purple); color: var(--purple-light); background: var(--purple-glow); }
+
+/* ── Footer ──────────────────────────────────────────────────────── */
+.footer { padding: 60px 24px 40px; border-top: 1px solid var(--border); }
+.footer-inner { max-width: 1100px; margin: 0 auto; }
+.footer-top { display: grid; grid-template-columns: 2fr 1fr 1fr 1fr; gap: 48px; margin-bottom: 48px; }
+.footer-brand-name { font-size: 1.1rem; font-weight: 800; margin-bottom: 10px; letter-spacing: -0.01em; }
+.footer-brand-desc { font-size: 0.83rem; color: var(--text-2); line-height: 1.6; max-width: 280px; }
+.footer-privacy-note {
+  margin-top: 16px;
+  font-size: 0.75rem; color: var(--text-3);
+  display: flex; align-items: center; gap: 6px;
+}
+.footer-col h5 { font-size: 0.78rem; font-weight: 700; text-transform: uppercase; letter-spacing: 0.05em; color: var(--text-3); margin-bottom: 16px; }
+.footer-col ul { list-style: none; display: flex; flex-direction: column; gap: 10px; }
+.footer-col li { font-size: 0.83rem; color: var(--text-2); }
+.footer-col a { transition: color var(--transition); }
+.footer-col a:hover { color: var(--purple-light); }
+.footer-bottom {
+  border-top: 1px solid var(--border); padding-top: 28px;
+  display: flex; flex-wrap: wrap; justify-content: space-between; align-items: center; gap: 16px;
+}
+.footer-copy { font-size: 0.78rem; color: var(--text-3); }
+.footer-attribution { font-size: 0.72rem; color: var(--text-3); line-height: 1.6; }
+.footer-attribution a { color: var(--purple-light); }
+.footer-attribution a:hover { text-decoration: underline; }
+
+/* ── Divider ─────────────────────────────────────────────────────── */
+.divider {
+  height: 1px; background: linear-gradient(90deg, transparent, var(--border), transparent);
+  border: none; margin: 0;
+}
+
+/* ── Responsive ──────────────────────────────────────────────────── */
+@media (max-width: 1024px) {
+  .tech-grid { grid-template-columns: repeat(2,1fr); }
+  .team-grid  { grid-template-columns: repeat(2,1fr); }
+  .about-grid { grid-template-columns: 1fr; }
+  .about-visual { max-width: 500px; }
+  .footer-top { grid-template-columns: 1fr 1fr; gap: 32px; }
+}
+@media (max-width: 768px) {
+  .hero { padding: 72px 20px 48px; }
+  .hero-stats { gap: 28px; }
+  .verdict-layout { grid-template-columns: 1fr; }
+  .result-img-panel { border-right: none; border-bottom: 1px solid var(--border); padding: 24px; }
+  .result-img-panel img { max-height: 200px; }
+  .verdict-info { padding: 24px; gap: 16px; }
+  .verdict-heading { font-size: 1.5rem; }
+  .why-grid { grid-template-columns: 1fr; gap: 12px; }
+  .focus-grid { grid-template-columns: 1fr; }
+  .how-grid { grid-template-columns: 1fr; gap: 16px; }
+  .highlights-grid { grid-template-columns: 1fr; gap: 14px; }
+  .tech-grid { grid-template-columns: 1fr 1fr; }
+  .team-grid { grid-template-columns: 1fr 1fr; }
+  .nav-link { display: none; }
+  .footer-top { grid-template-columns: 1fr; gap: 28px; }
+  .footer-bottom { flex-direction: column; text-align: center; }
+}
+@media (max-width: 480px) {
+  .hero h1 { font-size: 1.9rem; }
+  .team-grid { grid-template-columns: 1fr; }
+  .tech-grid { grid-template-columns: 1fr; }
+  .preview-actions { flex-direction: column; }
+  .preview-actions .btn { width: 100%; }
+  .upload-section { padding: 0 16px 64px; }
+  .result-section { padding: 16px 16px 48px; }
+}

frontend/static/js/app.js

@@ -0,0 +1,397 @@
+/* ═══════════════════════════════════════════════════════════════
+   ImgAuth AI — Frontend Logic
+   ─ Binary verdict: Likely AI-Generated vs Likely Authentic
+   ─ Bug fix: result section scrolls into view after analysis
+   ═══════════════════════════════════════════════════════════════ */
+
+// ── Theme Toggle ──────────────────────────────────────────────────
+(function () {
+  const html = document.documentElement;
+  const btn  = document.querySelector('[data-theme-toggle]');
+  let theme  = localStorage.getItem('imgauth-theme') || 'dark';
+
+  html.setAttribute('data-theme', theme);
+  if (btn) btn.textContent = theme === 'dark' ? '🌙' : '☀️';
+
+  if (btn) {
+    btn.addEventListener('click', () => {
+      theme = theme === 'dark' ? 'light' : 'dark';
+      html.setAttribute('data-theme', theme);
+      btn.textContent = theme === 'dark' ? '🌙' : '☀️';
+      localStorage.setItem('imgauth-theme', theme);
+    });
+  }
+})();
+
+// ── Element Refs ──────────────────────────────────────────────────
+const fileInput     = document.getElementById('fileInput');
+const dropZone      = document.getElementById('dropZone');
+const previewZone   = document.getElementById('previewZone');
+const previewImg    = document.getElementById('previewImg');
+const previewFilename = document.getElementById('previewFilename');
+const analyzeBtn    = document.getElementById('analyzeBtn');
+const clearBtn      = document.getElementById('clearBtn');
+const loadingOverlay = document.getElementById('loadingOverlay');
+const resultSection = document.getElementById('resultSection');
+const newScanBtn    = document.getElementById('newScanBtn');
+
+let selectedFile = null;
+
+// ── File Handling ─────────────────────────────────────────────────
+fileInput.addEventListener('change', e => handleFile(e.target.files[0]));
+
+dropZone.addEventListener('dragover', e => {
+  e.preventDefault();
+  dropZone.classList.add('drag-over');
+});
+dropZone.addEventListener('dragleave', () => dropZone.classList.remove('drag-over'));
+dropZone.addEventListener('drop', e => {
+  e.preventDefault();
+  dropZone.classList.remove('drag-over');
+  const f = e.dataTransfer.files[0];
+  if (f) handleFile(f);
+});
+
+function handleFile(file) {
+  if (!file || !file.type.startsWith('image/')) {
+    showToast('Please select a valid image file (PNG, JPG, WEBP).', 'error');
+    return;
+  }
+  if (file.size > 10 * 1024 * 1024) {
+    showToast('File too large. Maximum size is 10 MB.', 'error');
+    return;
+  }
+  selectedFile = file;
+  const reader = new FileReader();
+  reader.onload = ev => {
+    previewImg.src       = ev.target.result;
+    previewFilename.textContent = file.name;
+    dropZone.style.display   = 'none';
+    previewZone.style.display = 'block';
+    resultSection.style.display = 'none';
+  };
+  reader.readAsDataURL(file);
+}
+
+clearBtn.addEventListener('click', resetToUpload);
+
+// ── Analyze ───────────────────────────────────────────────────────
+analyzeBtn.addEventListener('click', async () => {
+  if (!selectedFile) return;
+  showLoading();
+  try {
+    const form = new FormData();
+    form.append('file', selectedFile);
+    const res  = await fetch('/api/detect', { method: 'POST', body: form });
+    const data = await res.json();
+    if (!res.ok) throw new Error(data.detail || 'Server error');
+    hideLoading();
+    showResult(data);
+  } catch (err) {
+    hideLoading();
+    showToast('Error: ' + err.message, 'error');
+  }
+});
+
+newScanBtn.addEventListener('click', resetToUpload);
+
+function resetToUpload() {
+  resultSection.style.display = 'none';
+  previewZone.style.display   = 'none';
+  dropZone.style.display      = 'block';
+  selectedFile  = null;
+  fileInput.value = '';
+  // Scroll back up to the upload section
+  document.getElementById('uploadSection').scrollIntoView({ behavior: 'smooth', block: 'start' });
+}
+
+// ── Loading Steps ─────────────────────────────────────────────────
+let stepTimer = null;
+const STEP_IDS = ['step1','step2','step3','step4','step5','step6'];
+
+function showLoading() {
+  // Reset all steps
+  STEP_IDS.forEach(id => {
+    const el = document.getElementById(id);
+    if (el) el.className = 'step';
+  });
+  loadingOverlay.style.display = 'flex';
+  let i = 0;
+  stepTimer = setInterval(() => {
+    if (i < STEP_IDS.length) {
+      if (i > 0) {
+        const prev = document.getElementById(STEP_IDS[i - 1]);
+        if (prev) prev.className = 'step done';
+      }
+      const cur = document.getElementById(STEP_IDS[i]);
+      if (cur) cur.className = 'step active';
+      i++;
+    }
+  }, 700);
+}
+
+function hideLoading() {
+  clearInterval(stepTimer);
+  loadingOverlay.style.display = 'none';
+}
+
+// ── Show Result ───────────────────────────────────────────────────
+function showResult(data) {
+  const aiScore  = typeof data.ai_score  === 'number' ? data.ai_score  : 50;
+  const realScore = typeof data.real_score === 'number' ? data.real_score : 50;
+
+  // ── Populate result image
+  document.getElementById('resultImg').src = previewImg.src;
+
+  // ── Binary verdict (no "Uncertain" category)
+  const isAI = aiScore > 50;
+
+  const badge   = document.getElementById('resultBadge');
+  const verdict = document.getElementById('resultVerdict');
+
+  if (isAI) {
+    badge.textContent = '🔴 AI-Generated';
+    badge.className   = 'verdict-badge is-ai';
+    verdict.textContent = 'Likely AI-Generated';
+    verdict.className   = 'verdict-heading is-ai';
+  } else {
+    badge.textContent = '🟢 Authentic';
+    badge.className   = 'verdict-badge is-real';
+    verdict.textContent = 'Likely Authentic';
+    verdict.className   = 'verdict-heading is-real';
+  }
+
+  // ── Confidence label — based on distance from 50%
+  const margin = Math.abs(aiScore - 50);
+  let confidenceLabel;
+  if      (margin >= 35) confidenceLabel = 'Very High Confidence';
+  else if (margin >= 20) confidenceLabel = 'High Confidence';
+  else if (margin >= 10) confidenceLabel = 'Medium Confidence';
+  else                   confidenceLabel = 'Low Confidence';
+  document.getElementById('resultConfidenceLevel').textContent = confidenceLabel;
+
+  // ── Gauge bar (animate after a tick so CSS transition fires)
+  setTimeout(() => {
+    document.getElementById('gaugeFill').style.width = aiScore + '%';
+    document.getElementById('gaugeDot').style.left   = aiScore + '%';
+    document.getElementById('realPct').textContent   = realScore.toFixed(1) + '%';
+    document.getElementById('aiPct').textContent     = aiScore.toFixed(1) + '%';
+  }, 80);
+
+  // ── Plain-language summary
+  document.getElementById('resultSummary').textContent = buildSummary(aiScore);
+
+  // ── "Why this result" cards
+  buildWhyCards(data, aiScore);
+
+  // ── Heatmaps
+  buildHeatmaps(data);
+
+  // ── Advanced technical section
+  buildAdvanced(data);
+
+  // ── Advanced toggle — clone to remove stale listeners
+  const oldBtn = document.getElementById('advancedToggle');
+  const newBtn = oldBtn.cloneNode(true);
+  oldBtn.parentNode.replaceChild(newBtn, oldBtn);
+  newBtn.addEventListener('click', function () {
+    const body   = document.getElementById('advancedBody');
+    const isOpen = body.style.display === 'block';
+    body.style.display = isOpen ? 'none' : 'block';
+    this.setAttribute('aria-expanded', String(!isOpen));
+    this.querySelector('span').textContent = isOpen
+      ? 'Show Technical Analysis'
+      : 'Hide Technical Analysis';
+  });
+
+  // ── Show result section then scroll TO IT  ← BUG FIX
+  resultSection.style.display = 'block';
+  setTimeout(() => {
+    resultSection.scrollIntoView({ behavior: 'smooth', block: 'start' });
+  }, 60);
+}
+
+// ── Build plain-language summary ──────────────────────────────────
+function buildSummary(aiScore) {
+  if (aiScore >= 80) return 'This image shows strong patterns typically found in AI-generated content. Multiple models flagged it with high confidence.';
+  if (aiScore >= 60) return 'This image shows several patterns commonly associated with AI-generated images.';
+  if (aiScore >= 50) return 'This image leans towards AI-generated, but the signal is relatively weak.';
+  if (aiScore >= 35) return 'This image appears to be authentic, though some minor signals were detected.';
+  return 'This image shows patterns consistent with authentic, real-world photographs.';
+}
+
+// ── Build "Why this result" cards ─────────────────────────────────
+function buildWhyCards(data, aiScore) {
+  // Visual Patterns
+  let visualText;
+  if (aiScore >= 70)
+    visualText = 'Detected unusual texture patterns and edge artifacts commonly found in AI-generated images.';
+  else if (aiScore >= 50)
+    visualText = 'Some visual patterns are consistent with AI generation, though results are mixed.';
+  else
+    visualText = 'Visual patterns appear natural and consistent with authentic photographs.';
+  document.getElementById('explainVisual').textContent = visualText;
+
+  // AI Model Analysis
+  let modelText;
+  if (aiScore >= 70)
+    modelText = 'Multiple AI detection models identified patterns strongly associated with AI-generated images.';
+  else if (aiScore >= 50)
+    modelText = 'AI detection models show a mild lean toward generated content.';
+  else
+    modelText = 'AI models detected characteristics more consistent with real, authentic photographs.';
+  document.getElementById('explainModels').textContent = modelText;
+
+  // Metadata Check
+  let metaText = 'No reliable camera metadata was found. This may indicate the image was generated or heavily edited.';
+  const mdLayer = (data.breakdown || []).find(b => b.layer === 'Metadata Analysis');
+  if (mdLayer && mdLayer.signals) {
+    const sigs = mdLayer.signals.join(' ');
+    if (sigs.includes('camera EXIF') || sigs.includes('GPS'))
+      metaText = 'Camera metadata was found, suggesting the image may have been captured with a real device.';
+    else if (sigs.includes('Software = AI') || sigs.includes('PNG metadata key'))
+      metaText = 'Metadata explicitly references AI generation tools — a strong indicator of synthetic origin.';
+  }
+  document.getElementById('explainMetadata').textContent = metaText;
+}
+
+// ── Build Heatmaps ────────────────────────────────────────────────
+function buildHeatmaps(data) {
+  const focusAreas = document.getElementById('focusAreas');
+  const dfiCard    = document.getElementById('dfiCardContainer');
+  const attImg     = document.getElementById('attentionHeatmapImg');
+  const dfiImg     = document.getElementById('dfiHeatmapImg');
+
+  let hasAny = false;
+  const ml = data.layers && data.layers.models ? data.layers.models : {};
+
+  if (ml.attention_heatmap) {
+    attImg.src = ml.attention_heatmap;
+    hasAny = true;
+  }
+  if (ml.dfi_heatmap) {
+    dfiImg.src = ml.dfi_heatmap;
+    dfiCard.style.display = 'block';
+    hasAny = true;
+  } else {
+    dfiCard.style.display = 'none';
+  }
+
+  focusAreas.style.display = hasAny ? 'block' : 'none';
+}
+
+// ── Build Advanced Technical Section ─────────────────────────────
+function buildAdvanced(data) {
+  const container = document.getElementById('advancedContent');
+  container.innerHTML = '';
+
+  const fnLayer = (data.breakdown || []).find(b => b.layer === 'Filename Analysis');
+  const mdLayer = (data.breakdown || []).find(b => b.layer === 'Metadata Analysis');
+  const mlLayer = (data.breakdown || []).find(b => b.layer === 'AI Model and Forensic Detectors');
+
+  const votes    = mlLayer ? (mlLayer.votes    || []) : [];
+  const forensics = mlLayer ? (mlLayer.forensics || {}) : {};
+
+  // Card 1 — Model Results
+  const dlVotes = votes.filter(v => v.type === 'deep_learning');
+  const modelItems = dlVotes.length
+    ? dlVotes.map(v => `<li><span>${esc(v.detector)}</span><span class="adv-val">${(v.ai_prob * 100).toFixed(1)}% AI</span></li>`).join('')
+    : '<li><span>No models available</span></li>';
+  container.appendChild(makeAdvCard('Model Results', modelItems));
+
+  // Card 2 — Forensic Signatures
+  const fmtNum = (v, dec = 4) => (v !== undefined && v !== null) ? Number(v).toFixed(dec) : 'N/A';
+  const kurtosis  = forensics.kurtosis   || {};
+  const dfi       = forensics.dfi        || {};
+  const fft       = forensics.fft        || {};
+  const chist     = forensics.color_histogram || {};
+  const jpeg      = forensics.jpeg_ghost  || {};
+  const jpegNA    = jpeg.detail === 'Not a JPEG' || !jpeg.ghost_spread;
+  const forensicItems = `
+    <li><span>Noise Kurtosis</span>    <span class="adv-val">${fmtNum(kurtosis.kurtosis)}</span></li>
+    <li><span>DFI Variance</span>      <span class="adv-val">${fmtNum(dfi.variance, 5)}</span></li>
+    <li><span>FFT Spike Ratio</span>   <span class="adv-val">${fmtNum(fft.spike_ratio, 5)}</span></li>
+    <li><span>Histogram Roughness</span><span class="adv-val">${fmtNum(chist.roughness, 6)}</span></li>
+    <li><span>JPEG Ghost Spread</span> <span class="adv-val">${jpegNA ? 'N/A (non-JPEG)' : fmtNum(jpeg.ghost_spread, 3)}</span></li>
+  `;
+  container.appendChild(makeAdvCard('Advanced Signals', forensicItems));
+
+  // Card 3 — Layer Weights
+  const weightItems = `
+    <li><span>Filename Weight</span>  <span class="adv-val">${fnLayer ? fnLayer.weight_pct : '0%'}</span></li>
+    <li><span>Filename AI Score</span><span class="adv-val">${fnLayer ? fnLayer.ai_pts + ' pts' : '—'}</span></li>
+    <li><span>Metadata Weight</span>  <span class="adv-val">${mdLayer ? mdLayer.weight_pct : '0%'}</span></li>
+    <li><span>Metadata AI Score</span><span class="adv-val">${mdLayer ? mdLayer.ai_pts + ' pts' : '—'}</span></li>
+    <li><span>Model & Forensic Wt</span><span class="adv-val">${mlLayer ? mlLayer.weight_pct : '0%'}</span></li>
+    <li><span>Model AI Score</span>   <span class="adv-val">${mlLayer ? mlLayer.ai_pts + ' pts' : '—'}</span></li>
+  `;
+  container.appendChild(makeAdvCard('Layer Breakdown', weightItems));
+
+  // Signal Log — full width
+  const allSignals = [
+    ...(fnLayer ? fnLayer.signals || [] : []),
+    ...(mdLayer ? mdLayer.signals || [] : []),
+    ...(mlLayer ? mlLayer.signals || [] : []),
+  ];
+  const logHtml = allSignals.length
+    ? allSignals.map(s => {
+        const clean = esc(s)
+          .replace(/^\[AI\]\s*/i,    '<span style="color:var(--red)">⚠ </span>')
+          .replace(/^\[REAL\]\s*/i,  '<span style="color:var(--green)">✓ </span>')
+          .replace(/^\[INFO\]\s*/i,  '<span style="color:var(--text-3)">ℹ </span>')
+          .replace(/^\[ERROR\]\s*/i, '<span style="color:var(--orange)">✕ </span>');
+        return clean;
+      }).join('\n')
+    : 'No signals detected.';
+
+  const logEl = document.createElement('div');
+  logEl.className = 'adv-log';
+  logEl.style.gridColumn = '1 / -1';
+  logEl.innerHTML = `<div style="font-size:0.72rem;font-weight:700;text-transform:uppercase;letter-spacing:0.05em;color:var(--text-3);margin-bottom:10px;">Diagnostic Signal Log</div>${logHtml}`;
+  container.appendChild(logEl);
+}
+
+function makeAdvCard(title, itemsHtml) {
+  const card = document.createElement('div');
+  card.className = 'adv-card';
+  card.innerHTML = `<div class="adv-card-title">${title}</div><ul class="adv-list">${itemsHtml}</ul>`;
+  return card;
+}
+
+// ── Toast Notification ────────────────────────────────────────────
+function showToast(msg, type = 'info') {
+  // Remove existing toast if any
+  const old = document.getElementById('imgauth-toast');
+  if (old) old.remove();
+
+  const toast = document.createElement('div');
+  toast.id = 'imgauth-toast';
+  toast.style.cssText = `
+    position:fixed; bottom:28px; left:50%; transform:translateX(-50%);
+    background:${type === 'error' ? 'var(--red-bg)' : 'var(--surface-solid)'};
+    border:1px solid ${type === 'error' ? 'var(--red-border)' : 'var(--border)'};
+    color:var(--text); padding:12px 24px; border-radius:10px;
+    font-size:0.875rem; font-weight:600; font-family:var(--font);
+    box-shadow:var(--shadow-lg); z-index:9999;
+    animation:fadeInUp 0.25s ease;
+  `;
+  toast.textContent = msg;
+  document.body.appendChild(toast);
+  setTimeout(() => toast.remove(), 4000);
+}
+
+// Add toast animation
+const toastStyle = document.createElement('style');
+toastStyle.textContent = `
+  @keyframes fadeInUp {
+    from { opacity:0; transform:translateX(-50%) translateY(12px); }
+    to   { opacity:1; transform:translateX(-50%) translateY(0); }
+  }
+`;
+document.head.appendChild(toastStyle);
+
+// ── Utility ───────────────────────────────────────────────────────
+function esc(str) {
+  if (!str) return '';
+  return String(str).replace(/[&<>"']/g, m => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#039;'}[m]));
+}

requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.111.0
+uvicorn==0.29.0
+python-multipart==0.0.9
+Pillow==10.3.0
+transformers==4.41.0
+torch==2.3.0
+torchvision==0.18.0
+numpy==1.26.4
+opencv-python-headless==4.9.0.80
+scipy==1.13.1

run.py

@@ -0,0 +1,8 @@
+import subprocess, sys
+
+try:
+    subprocess.run([sys.executable, "-m", "uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "5000"])
+except KeyboardInterrupt:
+    print("\nImgAuth AI server stopped.")
+    sys.exit(0)
+