'first'

.gitattributes

@@ -0,0 +1 @@
+model/classifier.pkl filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,252 @@
+import os
+import json
+import difflib
+import warnings
+warnings.filterwarnings("ignore")
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+
+from classifier import predict, ucitaj_model
+from feature_extraction import extract_all_features
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# INICIJALIZACIJA
+# ─────────────────────────────────────────────────────────────────────────────
+
+app = Flask(__name__)
+
+# CORS dopušta React frontendu (localhost:3000) da komunicira s ovim serverom
+CORS(app, resources={r"/api/*": {"origins": "*"}})
+
+# Učitaj model jednom pri pokretanju servera
+# (Ne učitavamo za svaki zahtjev — to bi bilo presporo)
+print("Učitavam model...")
+MODEL, SCALER, FEATURE_NAMES = ucitaj_model()
+
+if MODEL is None:
+    print("UPOZORENJE: Model nije pronađen.")
+    print("Pokreni prvo: python classifier.py")
+else:
+    print(f"Model učitan ({len(FEATURE_NAMES)} značajki).")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# POMOĆNE FUNKCIJE
+# ─────────────────────────────────────────────────────────────────────────────
+
+def greska(poruka: str, status: int = 400):
+    """Vraća JSON odgovor s greškom."""
+    return jsonify({"error": poruka}), status
+
+
+def izracunaj_slicnost(kod_a: str, kod_b: str) -> float:
+    return difflib.SequenceMatcher(None, kod_a.strip(), kod_b.strip()).ratio()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# RUTE
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.route("/api/health", methods=["GET"])
+def health():
+    """
+    Provjera radi li server i je li model učitan.
+
+    React frontend poziva ovo pri pokretanju da provjeri
+    može li komunicirati sa serverom.
+
+    Odgovor:
+        {
+            "status": "ok",
+            "model_loaded": true,
+            "feature_count": 40
+        }
+    """
+    return jsonify({
+        "status":        "ok",
+        "model_loaded":  MODEL is not None,
+        "feature_count": len(FEATURE_NAMES) if FEATURE_NAMES else 0,
+    })
+
+
+@app.route("/api/analyze", methods=["POST"])
+def analyze():
+    """
+    Analizira jedan isječak koda i vraća procjenu AI podrijetla.
+
+    Zahtjev (JSON):
+        {
+            "code":     "def foo(x): return x",   ← obavezno
+            "language": "python",                  ← opcionalno
+            "filename": "main.py"                  ← opcionalno
+        }
+
+    Odgovor (JSON):
+        {
+            "ai_probability":    0.73,
+            "verdict":           "Vjerojatno AI",
+            "detected_language": "python",
+            "top_features": [
+                {"name": "avg_identifier_length", "value": 8.5, "importance": 0.084},
+                ...
+            ],
+            "all_features": { ... },
+            "error": null
+        }
+    """
+    podaci = request.get_json(silent=True)
+    if not podaci:
+        return greska("Zahtjev mora sadržavati JSON tijelo.")
+
+    kod = podaci.get("code", "").strip()
+    if not kod:
+        return greska("Polje 'code' je obavezno i ne smije biti prazno.")
+
+    if len(kod) > 100_000:
+        return greska("Kod je predugačak. Maksimalno 100.000 znakova.")
+
+    jezik   = podaci.get("language")
+    datoteka = podaci.get("filename")
+
+    rezultat = predict(
+        code=kod,
+        language=jezik,
+        filename=datoteka,
+        model=MODEL,
+        scaler=SCALER,
+        feature_names=FEATURE_NAMES,
+    )
+
+    return jsonify(rezultat)
+
+
+@app.route("/api/analyze-batch", methods=["POST"])
+def analyze_batch():
+   
+    podaci = request.get_json(silent=True)
+    if not podaci:
+        return greska("Zahtjev mora sadržavati JSON tijelo.")
+
+    submissions = podaci.get("submissions", [])
+    if not submissions:
+        return greska("Polje 'submissions' je prazno.")
+
+    if len(submissions) > 200:
+        return greska("Maksimalno 200 kodova po zahtjevu.")
+
+    rezultati = []
+    for sub in submissions:
+        sub_id  = sub.get("id", "nepoznat")
+        kod     = sub.get("code", "").strip()
+        jezik   = sub.get("language")
+        datoteka = sub.get("filename")
+
+        if not kod:
+            rezultati.append({
+                "id":    sub_id,
+                "error": "Prazni kod."
+            })
+            continue
+
+        rez = predict(
+            code=kod,
+            language=jezik,
+            filename=datoteka,
+            model=MODEL,
+            scaler=SCALER,
+            feature_names=FEATURE_NAMES,
+        )
+        rez["id"] = sub_id
+        rezultati.append(rez)
+
+    # Sažetak za tablični prikaz
+    probs = [
+        r["ai_probability"]
+        for r in rezultati
+        if r.get("ai_probability") is not None
+    ]
+
+    summary = {
+        "total":    len(rezultati),
+        "high_risk":   sum(1 for p in probs if p >= 0.70),
+        "medium_risk": sum(1 for p in probs if 0.40 <= p < 0.70),
+        "low_risk":    sum(1 for p in probs if p < 0.40),
+        "avg_ai_probability": round(sum(probs) / len(probs), 4) if probs else 0.0,
+    }
+
+    return jsonify({"results": rezultati, "summary": summary})
+
+
+@app.route("/api/similarity", methods=["POST"])
+def similarity():
+    podaci = request.get_json(silent=True)
+    if not podaci:
+        return greska("Zahtjev mora sadržavati JSON tijelo.")
+
+    submissions = podaci.get("submissions", [])
+    if len(submissions) < 2:
+        return greska("Potrebna su najmanje 2 koda za usporedbu.")
+
+    if len(submissions) > 100:
+        return greska("Maksimalno 100 kodova po zahtjevu.")
+
+    ids   = [s.get("id", f"kod_{i}") for i, s in enumerate(submissions)]
+    codes = [s.get("code", "") for s in submissions]
+    n     = len(codes)
+
+    # Izgradi n×n matricu sličnosti
+    # matrix[i][j] = sličnost između koda i i koda j
+    matrica = [[0.0] * n for _ in range(n)]
+    sumnjivi_parovi = []
+
+    for i in range(n):
+        for j in range(n):
+            if i == j:
+                matrica[i][j] = 1.0
+            elif j > i:
+                sim = izracunaj_slicnost(codes[i], codes[j])
+                matrica[i][j] = round(sim, 4)
+                matrica[j][i] = round(sim, 4)
+
+                # Označi kao sumnjivo ako je sličnost > 70%
+                if sim > 0.70:
+                    sumnjivi_parovi.append({
+                        "id_a":       ids[i],
+                        "id_b":       ids[j],
+                        "similarity": round(sim, 4),
+                    })
+
+    # Sortiraj sumnjive parove po sličnosti (najsličniji prvi)
+    sumnjivi_parovi.sort(key=lambda x: x["similarity"], reverse=True)
+
+    return jsonify({
+        "ids":              ids,
+        "matrix":           matrica,
+        "suspicious_pairs": sumnjivi_parovi,
+    })
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# POKRETANJE
+# ─────────────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    print("\n" + "=" * 50)
+    print("  AI Code Detector — Backend")
+    print("=" * 50)
+    print("  Server pokrenut na: http://localhost:5000")
+    print("  API rute:")
+    print("    GET  /api/health")
+    print("    POST /api/analyze")
+    print("    POST /api/analyze-batch")
+    print("    POST /api/similarity")
+    print("\n  Zaustavi server s Ctrl+C")
+    print("=" * 50 + "\n")
+
+    app.run(
+        host="0.0.0.0",
+        port=5000,
+        debug=True,    
+    )

classifier.py

@@ -0,0 +1,706 @@
+"""
+classifier.py
+=============
+Trenira Random Forest klasifikator na datasetu izvučenih značajki,
+evaluira ga i sprema na disk za korištenje u web aplikaciji.
+
+Pokretanje (treniranje):
+    python classifier.py
+
+Korištenje iz drugog fajla (predikcija):
+    from classifier import predict
+    result = predict(code="def foo(x): return x", language="python")
+    print(result["ai_probability"])   # npr. 0.73
+    print(result["verdict"])          # "Vjerojatno AI"
+    print(result["top_features"])     # koje značajke su bile ključne
+"""
+
+import os
+import csv
+import pickle
+import warnings
+warnings.filterwarnings("ignore")
+
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import train_test_split, cross_val_score
+from sklearn.metrics import (
+    classification_report,
+    confusion_matrix,
+    roc_auc_score,
+)
+from sklearn.preprocessing import StandardScaler
+
+from feature_extraction import extract_all_features
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# KONFIGURACIJA
+# ─────────────────────────────────────────────────────────────────────────────
+
+DATASET_PATH  = os.path.join("data", "dataset.csv")
+MODEL_DIR     = "model"
+MODEL_PATH    = os.path.join(MODEL_DIR, "classifier.pkl")
+SCALER_PATH   = os.path.join(MODEL_DIR, "scaler.pkl")
+FEATURES_PATH = os.path.join(MODEL_DIR, "feature_names.pkl")
+
+# Kolone koje ne koristimo kao značajke za treniranje
+IGNORED_COLUMNS = {"label", "source", "detected_language", "model_available"}
+
+# Značajka perplexity je -1.0 kad model nije učitan — tretiramo kao missing
+PERPLEXITY_MISSING = -1.0
+
+# Random Forest parametri
+RF_PARAMS = {
+    "n_estimators":  300,    # broj stabala — više = stabilnije, ali sporije
+    "max_depth":     None,   # bez ograničenja dubine (stabla rastu do čistih listova)
+    "min_samples_leaf": 2,   # svaki list mora imati min. 2 primjera (smanjuje overfitting)
+    "class_weight": "balanced",  # kompenzira neuravnotežene klase (više human nego AI)
+    "random_state":  42,
+    "n_jobs":       -1,      # koristi sve dostupne CPU jezgre
+}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# UČITAVANJE DATASETA
+# ─────────────────────────────────────────────────────────────────────────────
+
+def ucitaj_dataset(path: str):
+    """
+    Učitava dataset.csv i vraća feature matricu X i vektor oznaka y.
+
+    Tretira -1.0 vrijednosti (perplexity bez modela) kao 0.0
+    jer klasifikator ne smije vidjeti negativne vrijednosti kao signal.
+
+    Parametri:
+        path (str): Putanja do CSV datoteke.
+
+    Vraća:
+        X (np.ndarray):         Matrica značajki oblika (n_samples, n_features).
+        y (np.ndarray):         Vektor oznaka (0=human, 1=ai).
+        feature_names (list):   Nazivi stupaca koji odgovaraju stupcima X.
+    """
+    if not os.path.exists(path):
+        raise FileNotFoundError(
+            f"Dataset nije pronađen na '{path}'.\n"
+            f"Pokreni prvo: python download_dataset.py"
+        )
+
+    redovi = []
+    with open(path, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            redovi.append(row)
+
+    if not redovi:
+        raise ValueError("Dataset je prazan.")
+
+    # Odredi nazive značajki (svi stupci osim ignoriranih)
+    sve_kolone = list(redovi[0].keys())
+    feature_names = [c for c in sve_kolone if c not in IGNORED_COLUMNS]
+
+    X_rows = []
+    y_list = []
+
+    for row in redovi:
+        try:
+            y_list.append(int(row["label"]))
+
+            # Pretvori svaku značajku u float
+            # Perplexity -1.0 → 0.0 (nije dostupan, ne smije biti signal)
+            vrijednosti = []
+            for feat in feature_names:
+                val = float(row[feat])
+                if feat == "perplexity" and val == PERPLEXITY_MISSING:
+                    val = 0.0
+                vrijednosti.append(val)
+
+            X_rows.append(vrijednosti)
+
+        except (ValueError, KeyError):
+            continue   # preskoči neispravne retke
+
+    X = np.array(X_rows, dtype=np.float32)
+    y = np.array(y_list, dtype=np.int32)
+
+    print(f"  Učitano {len(y)} primjera, {len(feature_names)} značajki")
+    print(f"  Human (0): {sum(y == 0)}  |  AI (1): {sum(y == 1)}")
+
+    return X, y, feature_names
+
+
+# ──────────���──────────────────────────────────────────────────────────────────
+# TRENIRANJE
+# ─────────────────────────────────────────────────────────────────────────────
+
+def treniraj(X, y, feature_names):
+    """
+    Trenira Random Forest klasifikator i vraća trenirani model zajedno
+    sa scalerom i rezultatima evaluacije.
+
+    Pipeline:
+        1. Podijeli podatke 80% trening / 20% test
+        2. Normalizira značajke (StandardScaler)
+        3. Trenira Random Forest
+        4. Evaluira na test skupu
+        5. Pokreće 5-fold cross-validation za pouzdaniju procjenu
+
+    Parametri:
+        X (np.ndarray):       Matrica značajki.
+        y (np.ndarray):       Vektor oznaka.
+        feature_names (list): Nazivi značajki.
+
+    Vraća:
+        model:   Trenirani RandomForestClassifier.
+        scaler:  Trenirani StandardScaler.
+        metrics: Rječnik s metrikama evaluacije.
+    """
+    # 1. Podjela na trening i test skup
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42, stratify=y
+        # stratify=y osigurava da i trening i test imaju isti omjer klasa
+    )
+    print(f"\n  Trening: {len(y_train)} primjera")
+    print(f"  Test:    {len(y_test)} primjera")
+
+    # 2. Normalizacija — StandardScaler svaku značajku svede na
+    #    srednju vrijednost 0 i standardnu devijaciju 1.
+    #    VAŽNO: scaler se fitira SAMO na trening skupu,
+    #    a transformira i trening i test (da ne bi "curilo" znanje)
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled  = scaler.transform(X_test)
+
+    # 3. Treniranje Random Foresta
+    print("\n  Treniram Random Forest...")
+    model = RandomForestClassifier(**RF_PARAMS)
+    model.fit(X_train_scaled, y_train)
+
+    # 4. Evaluacija na test skupu
+    y_pred      = model.predict(X_test_scaled)
+    y_pred_prob = model.predict_proba(X_test_scaled)[:, 1]
+
+    print("\n" + "─" * 50)
+    print("  REZULTATI EVALUACIJE")
+    print("─" * 50)
+    print(classification_report(
+        y_test, y_pred,
+        target_names=["Human (0)", "AI (1)"],
+        digits=3
+    ))
+
+    # Matrica zabune — pokazuje lažno pozitivne i lažno negativne
+    cm = confusion_matrix(y_test, y_pred)
+    tn, fp, fn, tp = cm.ravel()
+    print(f"  Matrica zabune:")
+    print(f"    Ispravno human:      {tn}  (true negative)")
+    print(f"    Lažno označen AI:    {fp}  (false positive)")
+    print(f"    Propušten AI:        {fn}  (false negative)")
+    print(f"    Ispravno AI:         {tp}  (true positive)\n")
+
+    # AUC-ROC — mjera kvalitete rankiranja (0.5=slučajno, 1.0=savršeno)
+    auc = roc_auc_score(y_test, y_pred_prob)
+    print(f"  AUC-ROC: {auc:.4f}")
+
+    # 5. Cross-validation — pouzdanija procjena jer trenira/testira 5 puta
+    print("\n  5-fold cross-validation (može potrajati minutu)...")
+    X_scaled_full = scaler.transform(X)
+    cv_scores = cross_val_score(
+        model, X_scaled_full, y,
+        cv=5, scoring="f1", n_jobs=-1
+    )
+    print(f"  CV F1 scores: {[f'{s:.3f}' for s in cv_scores]}")
+    print(f"  CV F1 prosjek: {cv_scores.mean():.3f} "
+          f"(±{cv_scores.std():.3f})")
+
+    # Top 10 najvažnijih značajki
+    importances = model.feature_importances_
+    top_idx = np.argsort(importances)[::-1][:10]
+    print("\n  Top 10 najvažnijih značajki:")
+    for rank, idx in enumerate(top_idx, 1):
+        print(f"    {rank:2}. {feature_names[idx]:<38} {importances[idx]:.4f}")
+
+    metrics = {
+        "auc_roc":    auc,
+        "cv_f1_mean": cv_scores.mean(),
+        "cv_f1_std":  cv_scores.std(),
+        "true_negative":   int(tn),
+        "false_positive":  int(fp),
+        "false_negative":  int(fn),
+        "true_positive":   int(tp),
+    }
+
+    return model, scaler, metrics
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SPREMANJE MODELA
+# ─────────────────────────────────────────────────────────────────────────────
+
+def spremi_model(model, scaler, feature_names):
+    """
+    Sprema trenirani model, scaler i listu naziva značajki na disk.
+
+    Sva tri fajla su potrebna za predikciju:
+      - model     : donosi odluku
+      - scaler    : normalizira ulaz na isti način kao pri treniranju
+      - feature_names : osigurava da se značajke šalju u ispravnom redoslijedu
+
+    Parametri:
+        model:          Trenirani RandomForestClassifier.
+        scaler:         Trenirani StandardScaler.
+        feature_names:  Lista naziva značajki.
+    """
+    os.makedirs(MODEL_DIR, exist_ok=True)
+
+    with open(MODEL_PATH,    "wb") as f: pickle.dump(model,         f)
+    with open(SCALER_PATH,   "wb") as f: pickle.dump(scaler,        f)
+    with open(FEATURES_PATH, "wb") as f: pickle.dump(feature_names, f)
+
+    print(f"\n  Model spremljen u:          {MODEL_PATH}")
+    print(f"  Scaler spremljen u:         {SCALER_PATH}")
+    print(f"  Nazivi značajki spremljeni: {FEATURES_PATH}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PREDIKCIJA — koristi se iz web aplikacije
+# ─────────────────────────────────────────────────────────────────────────────
+
+def ucitaj_model():
+    """
+    Učitava model, scaler i nazive značajki s diska.
+    Poziva se jednom pri pokretanju web servera.
+
+    Vraća:
+        (model, scaler, feature_names) ili (None, None, None) ako model ne postoji.
+    """
+    if not all(os.path.exists(p) for p in [MODEL_PATH, SCALER_PATH, FEATURES_PATH]):
+        return None, None, None
+
+    with open(MODEL_PATH,    "rb") as f: model         = pickle.load(f)
+    with open(SCALER_PATH,   "rb") as f: scaler        = pickle.load(f)
+    with open(FEATURES_PATH, "rb") as f: feature_names = pickle.load(f)
+
+    return model, scaler, feature_names
+
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# GENERIRANJE OBJAŠNJENJA
+# ─────────────────────────────────────────────────────────────────────────────
+
+def generate_explanations(features: dict, ai_prob: float) -> list:
+    """
+    Generira listu objašnjenja na engleskom jeziku koja opisuju
+    zašto kod izgleda AI generiran ili čovječji.
+
+    Svako objašnjenje je rječnik s:
+      "text"     — rečenica objašnjenja
+      "severity" — "high" | "medium" | "low" | "positive"
+      "feature"  — naziv značajke na koju se objašnjenje odnosi
+
+    Pragovi su kalibrirani na temelju tipičnih vrijednosti u
+    AI-Detector i HMCorp datasetovima.
+
+    Parametri:
+        features (dict): Rječnik značajki iz extract_all_features().
+        ai_prob (float): Vjerojatnost AI podrijetla (0.0 – 1.0).
+
+    Vraća:
+        list: Lista rječnika s objašnjenjima, sortirana po ozbiljnosti.
+    """
+    objasnjenja = []
+
+    def dodaj(text, severity, feature):
+        objasnjenja.append({"text": text, "severity": severity, "feature": feature})
+
+    # ── IMENOVANJE ─────────────────────────────────────────────────────────
+
+    avg_id_len = features.get("avg_identifier_length", 0)
+    if avg_id_len > 7.5:
+        dodaj(
+            f"Identifier names are unusually long and descriptive "
+            f"(average {avg_id_len:.1f} characters). "
+            f"AI-generated code consistently favours verbose, self-documenting names "
+            f"such as 'calculate_average_value' over typical student shorthand like 'avg'.",
+            "high", "avg_identifier_length"
+        )
+    elif avg_id_len > 5.5:
+        dodaj(
+            f"Identifier names are moderately long (average {avg_id_len:.1f} characters), "
+            f"which is slightly above the typical range for human-written student code.",
+            "medium", "avg_identifier_length"
+        )
+    elif avg_id_len < 2.5 and avg_id_len > 0:
+        dodaj(
+            f"Identifier names are very short (average {avg_id_len:.1f} characters), "
+            f"consistent with a human programmer's preference for concise variable names.",
+            "positive", "avg_identifier_length"
+        )
+
+    naming_cons = features.get("naming_consistency", 0)
+    if naming_cons > 0.85:
+        dodaj(
+            f"Naming convention is highly consistent throughout the submission "
+            f"({naming_cons * 100:.0f}% of identifiers follow the same pattern). "
+            f"Human programmers typically mix conventions, especially in longer submissions.",
+            "high", "naming_consistency"
+        )
+    elif naming_cons < 0.3 and naming_cons > 0:
+        dodaj(
+            f"Naming convention varies across the submission, which is characteristic "
+            f"of code written incrementally by a human programmer.",
+            "positive", "naming_consistency"
+        )
+
+    single_char = features.get("single_char_name_ratio", 0)
+    if single_char < 0.03 and features.get("num_functions", 0) > 1:
+        dodaj(
+            f"No single-character variable names were detected. "
+            f"Human programmers routinely use short names such as 'i', 'x', or 'n' "
+            f"in loops and helper functions; their absence is atypical.",
+            "medium", "single_char_name_ratio"
+        )
+    elif single_char > 0.25:
+        dodaj(
+            f"A notable proportion of variables use single-character names "
+            f"({single_char * 100:.0f}%), which is common in human-written code.",
+            "positive", "single_char_name_ratio"
+        )
+
+    # ── KOMENTARI I DOCSTRINGOVI ───────────────────────────────────────────
+
+    comment_ratio = features.get("comment_ratio", 0)
+    if comment_ratio > 0.30:
+        dodaj(
+            f"Comment density is substantially above average — "
+            f"{comment_ratio * 100:.0f}% of lines contain inline comments. "
+            f"AI models tend to annotate nearly every logical step, "
+            f"whereas students typically comment only non-obvious sections.",
+            "high", "comment_ratio"
+        )
+    elif comment_ratio > 0.18:
+        dodaj(
+            f"Comment density ({comment_ratio * 100:.0f}% of lines) is higher than "
+            f"typically observed in student submissions at this level.",
+            "medium", "comment_ratio"
+        )
+    elif comment_ratio < 0.03:
+        dodaj(
+            f"Very few or no inline comments are present, which is more consistent "
+            f"with human-written code at this stage of the course.",
+            "positive", "comment_ratio"
+        )
+
+    num_docs = features.get("num_docstrings", 0)
+    num_fns  = features.get("num_functions", 1)
+    if num_docs > 0 and num_fns > 0:
+        doc_coverage = num_docs / num_fns
+        if doc_coverage >= 0.9:
+            dodaj(
+                f"Every function in the submission includes a formal docstring "
+                f"({num_docs} of {num_fns} functions documented). "
+                f"Complete docstring coverage is a strong marker of AI-generated code; "
+                f"students rarely document all functions unless explicitly required.",
+                "high", "num_docstrings"
+            )
+        elif doc_coverage >= 0.5:
+            dodaj(
+                f"More than half of the functions include docstrings "
+                f"({num_docs} of {num_fns}), which is above the student average.",
+                "medium", "num_docstrings"
+            )
+
+    # ── STRUKTURNE ZNAČAJKE ────────────────────────────────────────────────
+
+    avg_fn_len = features.get("avg_function_length", 0)
+    if avg_fn_len > 20:
+        dodaj(
+            f"Functions are notably long on average ({avg_fn_len:.0f} lines). "
+            f"AI models tend to produce complete, self-contained implementations; "
+            f"students more often break logic across multiple smaller functions "
+            f"or leave parts incomplete.",
+            "medium", "avg_function_length"
+        )
+    elif avg_fn_len > 0 and avg_fn_len < 5:
+        dodaj(
+            f"Functions are very short on average ({avg_fn_len:.1f} lines), "
+            f"which may indicate a human programmer's incremental coding style.",
+            "positive", "avg_function_length"
+        )
+
+    try_density = features.get("try_density", 0)
+    if try_density > 0.06:
+        dodaj(
+            f"The submission contains a relatively high density of try/except blocks. "
+            f"Comprehensive error handling across all edge cases is a pattern "
+            f"commonly exhibited by AI generators, which anticipate and handle "
+            f"exceptions that students typically overlook.",
+            "medium", "try_density"
+        )
+
+    nesting = features.get("max_nesting_depth", 0)
+    if nesting > 5:
+        dodaj(
+            f"Code nesting reaches a depth of {int(nesting)} levels. "
+            f"While not conclusive, deeply nested logic can reflect an AI model's "
+            f"tendency to handle all conditional branches explicitly.",
+            "medium", "max_nesting_depth"
+        )
+
+    # ── STATISTIČKA ANALIZA ────────────────────────────────────────────────
+
+    token_entropy = features.get("token_entropy", 0)
+    if token_entropy > 0 and token_entropy < 3.8:
+        dodaj(
+            f"Token entropy is low ({token_entropy:.2f}), indicating that the vocabulary "
+            f"of the submission is repetitive and predictable. "
+            f"This is consistent with language model output, which tends to reuse "
+            f"the same phrasing and structural patterns.",
+            "high", "token_entropy"
+        )
+    elif token_entropy > 5.5:
+        dodaj(
+            f"Token entropy is relatively high ({token_entropy:.2f}), suggesting "
+            f"a diverse and varied vocabulary more typical of human authorship.",
+            "positive", "token_entropy"
+        )
+
+    perplexity = features.get("perplexity", -1)
+    if perplexity != -1 and perplexity > 0:
+        if perplexity < 8:
+            dodaj(
+                f"The code's perplexity score is very low ({perplexity:.1f}), meaning "
+                f"a language model finds the token sequence highly predictable. "
+                f"This strongly suggests the code was generated by a similar model.",
+                "high", "perplexity"
+            )
+        elif perplexity < 20:
+            dodaj(
+                f"Perplexity ({perplexity:.1f}) falls within a range that is "
+                f"moderately consistent with AI-generated code.",
+                "medium", "perplexity"
+            )
+        elif perplexity > 50:
+            dodaj(
+                f"Perplexity is high ({perplexity:.1f}), indicating the code "
+                f"contains patterns that a language model would consider unexpected — "
+                f"a characteristic of human authorship.",
+                "positive", "perplexity"
+            )
+
+    # ── FORMATIRANJE ───────────────────────────────────────────────────────
+
+    trailing = features.get("trailing_whitespace_ratio", 0)
+    if trailing > 0.15:
+        dodaj(
+            f"A notable proportion of lines contain trailing whitespace "
+            f"({trailing * 100:.0f}%), which is typical of code edited by hand "
+            f"and inconsistent with AI-generated output.",
+            "positive", "trailing_whitespace_ratio"
+        )
+
+    op_cons = features.get("operator_spacing_consistency", 0)
+    if op_cons > 0.95:
+        dodaj(
+            f"Spacing around operators is perfectly consistent throughout the submission. "
+            f"AI models apply style conventions uniformly; human programmers "
+            f"occasionally deviate, particularly under time pressure.",
+            "medium", "operator_spacing_consistency"
+        )
+
+    # Ako nema signala, dodaj neutralnu poruku
+    if not objasnjenja:
+        if ai_prob > 0.5:
+            dodaj(
+                "No single dominant signal was identified; the classification is based "
+                "on a combination of subtle stylistic and structural patterns.",
+                "medium", "combined"
+            )
+        else:
+            dodaj(
+                "No strong AI-generation markers were detected. "
+                "The submission's style and structure are consistent with human authorship.",
+                "positive", "combined"
+            )
+
+    # Sortiraj: high → medium → positive/low
+    priority = {"high": 0, "medium": 1, "low": 2, "positive": 3}
+    objasnjenja.sort(key=lambda x: priority.get(x["severity"], 2))
+
+    return objasnjenja
+
+
+def predict(code: str, language: str = None, filename: str = None,
+            model=None, scaler=None, feature_names=None) -> dict:
+    """
+    Analizira isječak koda i vraća procjenu vjerojatnosti AI podrijetla.
+
+    Ako model/scaler/feature_names nisu proslijeđeni, automatski ih učita s diska.
+
+    Parametri:
+        code (str):          Izvorni kod za analizu.
+        language (str):      Programski jezik (opcionalno, automatska detekcija).
+        filename (str):      Ime datoteke (opcionalno, pomaže detekciji jezika).
+        model:               Učitani model (opcionalno, za višekratnu upotrebu).
+        scaler:              Učitani scaler (opcionalno).
+        feature_names (list):Lista naziva značajki (opcionalno).
+
+    Vraća:
+        dict s ključevima:
+            "ai_probability"  – float 0.0-1.0, vjerojatnost AI podrijetla
+            "verdict"         – string s tumačenjem rezultata
+            "detected_language" – prepoznati programski jezik
+            "top_features"    – lista (naziv, vrijednost) top 5 značajki
+            "all_features"    – rječnik svih izvučenih značajki
+            "error"           – string s greškom, ili None ako je sve OK
+    """
+    # Učitaj model ako nije proslijeđen
+    if model is None:
+        model, scaler, feature_names = ucitaj_model()
+
+    if model is None:
+        return {
+            "ai_probability":     None,
+            "verdict":            "Model nije dostupan",
+            "detected_language":  None,
+            "top_features":       [],
+            "all_features":       {},
+            "error": "Model nije treniran. Pokreni: python classifier.py"
+        }
+
+    # Izvuci značajke
+    sve_znacajke = extract_all_features(
+        code=code, language=language, filename=filename
+    )
+
+    # Složi feature vektor u TOČNO isti redosljed kao pri treniranju
+    feature_vector = []
+    for feat in feature_names:
+        val = sve_znacajke.get(feat, 0.0)
+        if feat == "perplexity" and val == PERPLEXITY_MISSING:
+            val = 0.0
+        feature_vector.append(float(val))
+
+    X = np.array([feature_vector], dtype=np.float32)
+    X_scaled = scaler.transform(X)
+
+    # Predikcija
+    ai_prob = float(model.predict_proba(X_scaled)[0][1])
+
+    # Tumačenje
+    if ai_prob >= 0.80:
+        verdict = "Vjerojatno AI"
+    elif ai_prob >= 0.60:
+        verdict = "Moguće AI"
+    elif ai_prob >= 0.40:
+        verdict = "Nejasno"
+    elif ai_prob >= 0.20:
+        verdict = "Moguće čovječji"
+    else:
+        verdict = "Vjerojatno čovječji"
+
+    # Top 5 značajki koje su doprinijele odluci
+    importances = model.feature_importances_
+    top_idx = np.argsort(importances)[::-1][:5]
+    top_features = [
+        {
+            "name":       feature_names[i],
+            "value":      round(feature_vector[i], 4),
+            "importance": round(float(importances[i]), 4),
+        }
+        for i in top_idx
+    ]
+
+    # Generiraj objašnjenja zašto je kod klasificiran ovako
+    objasnjenja = generate_explanations(sve_znacajke, ai_prob)
+
+    return {
+        "ai_probability":    round(ai_prob, 4),
+        "verdict":           verdict,
+        "detected_language": sve_znacajke.get("detected_language", "nepoznat"),
+        "top_features":      top_features,
+        "all_features":      sve_znacajke,
+        "explanations":      objasnjenja,
+        "error":             None,
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# GLAVNI PROGRAM
+# ─────────────────────────────────────────────────────────────────────────────
+
+def main():
+    print("=" * 50)
+    print("  Treniranje klasifikatora")
+    print("=" * 50)
+
+    # Učitaj dataset
+    print(f"\n  Učitavam dataset iz '{DATASET_PATH}'...")
+    X, y, feature_names = ucitaj_dataset(DATASET_PATH)
+
+    # Treniraj
+    model, scaler, metrics = treniraj(X, y, feature_names)
+
+    # Spremi
+    spremi_model(model, scaler, feature_names)
+
+    # Brzi test predikcije
+    print("\n" + "─" * 50)
+    print("  BRZI TEST PREDIKCIJE")
+    print("─" * 50)
+
+    test_kodovi = {
+        "AI Python": '''
+def calculate_fibonacci(n: int) -> list:
+    """
+    Generate a Fibonacci sequence up to n terms.
+
+    Args:
+        n: The number of terms to generate.
+
+    Returns:
+        A list containing the Fibonacci sequence.
+    """
+    if n <= 0:
+        raise ValueError("Number of terms must be positive.")
+    fibonacci_sequence = [0, 1]
+    for i in range(2, n):
+        next_value = fibonacci_sequence[i - 1] + fibonacci_sequence[i - 2]
+        fibonacci_sequence.append(next_value)
+    return fibonacci_sequence[:n]
+''',
+        "Human Python": '''
+def fib(n):
+    # quick fib
+    a, b = 0, 1
+    res = []
+    for _ in range(n):
+        res.append(a)
+        a, b = b, a+b
+    return res
+''',
+    }
+
+    for naziv, kod in test_kodovi.items():
+        rezultat = predict(kod, model=model, scaler=scaler,
+                          feature_names=feature_names)
+        prob = rezultat["ai_probability"]
+        verdict = rezultat["verdict"]
+        lang = rezultat["detected_language"]
+        print(f"\n  [{naziv}]")
+        print(f"    Jezik:           {lang}")
+        print(f"    AI vjerojatnost: {prob:.1%}")
+        print(f"    Zaključak:       {verdict}")
+        print(f"    Ključne značajke:")
+        for feat in rezultat["top_features"]:
+            print(f"      {feat['name']:<35} vrijednost={feat['value']:.4f}")
+
+    print("\n" + "=" * 50)
+    print("  Treniranje završeno.")
+    print("  Sljedeći korak: python app.py")
+    print("=" * 50)
+
+
+if __name__ == "__main__":
+    main()

download_dataset.py

@@ -0,0 +1,261 @@
+import os
+import csv
+import time
+
+from datasets import load_dataset
+
+from feature_extraction import extract_all_features
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# KONFIGURACIJA
+# ─────────────────────────────────────────────────────────────────────────────
+
+OUTPUT_DIR  = "data"
+OUTPUT_FILE = os.path.join(OUTPUT_DIR, "dataset.csv")
+
+# Koliko primjera uzeti po datasetu (None = sve)
+# Za prvi brzi test stavi npr. 500, za pravo treniranje None
+MAX_SAMPLES_PER_DATASET = None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PARSERI ZA SVAKI DATASET
+# Svaki dataset ima svoju strukturu — ove funkcije je normaliziraju
+# u isti format: lista rječnika s ključevima "code", "label", "language"
+# ─────────────────────────────────────────────────────────────────────────────
+
+def parse_aigcodeset(max_samples=None):
+    print("  Skidanje AIGCodeSet dataseta...")
+    try:
+        ds = load_dataset("basakdemirok/AIGCodeSet", split="train")
+    except Exception as e:
+        print(f"  [GREŠKA] Nije moguće skinuti AIGCodeSet: {e}")
+        return []
+
+    primjeri = []
+    for row in ds:
+        # Izvuci kod — provjeri moguće nazive kolona
+        code = row.get("code") or row.get("source_code") or row.get("content") or ""
+        if not code or not code.strip():
+            continue
+
+        # Odredi oznaku — sve što nije "human" je AI
+        raw_label = str(row.get("label", "")).lower()
+        if "human" in raw_label:
+            label = 0  # ljudski kod
+        else:
+            label = 1  # AI generirani kod
+
+        primjeri.append({
+            "code":     code,
+            "label":    label,
+            "language": "python",   # AIGCodeSet je samo Python
+            "source":   "AIGCodeSet",
+        })
+
+        if max_samples and len(primjeri) >= max_samples:
+            break
+
+    human_count = sum(1 for p in primjeri if p["label"] == 0)
+    ai_count    = sum(1 for p in primjeri if p["label"] == 1)
+    print(f"  Učitano {len(primjeri)} primjera "
+          f"({human_count} human, {ai_count} AI)")
+    return primjeri
+
+
+def parse_ai_code_detection(max_samples=None):
+    print("  Skidanje ai-code-detection dataseta...")
+    try:
+        ds = load_dataset("serafeimdossas/ai-code-detection", split="train")
+    except Exception as e:
+        print(f"  [GREŠKA] Nije moguće skinuti ai-code-detection: {e}")
+        return []
+
+    primjeri = []
+    for row in ds:
+        code = row.get("code") or row.get("solution") or row.get("content") or ""
+        if not code or not code.strip():
+            continue
+
+        raw_label = str(row.get("label", "")).lower()
+        if "human" in raw_label:
+            label = 0
+        else:
+            label = 1
+
+        primjeri.append({
+            "code":     code,
+            "label":    label,
+            "language": "python",
+            "source":   "ai-code-detection",
+        })
+
+        if max_samples and len(primjeri) >= max_samples:
+            break
+
+    human_count = sum(1 for p in primjeri if p["label"] == 0)
+    ai_count    = sum(1 for p in primjeri if p["label"] == 1)
+    print(f"  Učitano {len(primjeri)} primjera "
+          f"({human_count} human, {ai_count} AI)")
+    return primjeri
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# IZVLAČENJE ZNAČAJKI I SPREMANJE U CSV
+# ─────────────────────────────────────────────────────────────────────────────
+
+def procesiraj_i_spremi(primjeri: list, output_path: str) -> None:
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+    uspjesno = 0
+    greske   = 0
+    pisac    = None
+    f        = None
+
+    print(f"\n  Izvlačim značajke iz {len(primjeri)} primjera...")
+    start_time = time.time()
+
+    for i, primjer in enumerate(primjeri):
+
+        # Ispis napretka svaki 100 primjera
+        if i > 0 and i % 100 == 0:
+            proteklo = time.time() - start_time
+            preostalo = (proteklo / i) * (len(primjeri) - i)
+            print(f"  [{i}/{len(primjeri)}] "
+                  f"~{preostalo:.0f}s preostalo...", end="\r")
+
+        try:
+            # Izvuci sve značajke
+            znacajke = extract_all_features(
+                code=primjer["code"],
+                language=primjer["language"],
+            )
+
+            # Dodaj oznaku i izvor uz značajke
+            redak = {
+                "label":  primjer["label"],
+                **znacajke,
+                "source": primjer["source"],
+            }
+
+            # Otvori CSV i piši zaglavlje samo pri prvom retku
+            if pisac is None:
+                f = open(output_path, "w", newline="", encoding="utf-8")
+                pisac = csv.DictWriter(f, fieldnames=list(redak.keys()))
+                pisac.writeheader()
+
+            pisac.writerow(redak)
+            uspjesno += 1
+
+        except Exception as e:
+            greske += 1
+            if greske <= 5:   # ispiši samo prvih 5 grešaka
+                print(f"\n  [UPOZORENJE] Greška na primjeru {i}: {e}")
+
+    if f:
+        f.close()
+
+    trajanje = time.time() - start_time
+    print(f"\n  Gotovo za {trajanje:.1f}s")
+    print(f"  Uspješno: {uspjesno} / {len(primjeri)}")
+    if greske:
+        print(f"  Greške:   {greske} (preskočeni)")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# STATISTIKA O DATASETU
+# ─────────────────────────────────────────────────────────────────────────────
+
+def ispisi_statistiku(csv_path: str) -> None:
+    """
+    Učita gotovi CSV i ispiše osnovnu statistiku:
+    broj primjera, omjer klasa, raspodjela po sourceu.
+    """
+    if not os.path.exists(csv_path):
+        print("  CSV ne postoji, nema statistike.")
+        return
+
+    redovi = []
+    with open(csv_path, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        redovi = list(reader)
+
+    if not redovi:
+        print("  CSV je prazan.")
+        return
+
+    ukupno    = len(redovi)
+    human     = sum(1 for r in redovi if r["label"] == "0")
+    ai        = sum(1 for r in redovi if r["label"] == "1")
+    num_feats = len(redovi[0]) - 2   # -2 za label i source
+
+    # Statistika po sourceu
+    from collections import Counter
+    sources = Counter(r["source"] for r in redovi)
+
+    print(f"\n{'═' * 50}")
+    print(f"  STATISTIKA DATASETA")
+    print(f"{'═' * 50}")
+    print(f"  Ukupno primjera:     {ukupno}")
+    print(f"  Human (label=0):     {human}  ({100*human/ukupno:.1f}%)")
+    print(f"  AI    (label=1):     {ai}  ({100*ai/ukupno:.1f}%)")
+    print(f"  Broj značajki:       {num_feats}")
+    print(f"\n  Po datasetu:")
+    for source, count in sources.most_common():
+        print(f"    {source:<30} {count}")
+    print(f"\n  Spremljeno u: {csv_path}")
+    print(f"{'═' * 50}\n")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# GLAVNI PROGRAM
+# ─────────────────────────────────────────────────────────────────────────────
+
+def main():
+    print("=" * 50)
+    print("  Preuzimanje dataseta i izvlačenje značajki")
+    print("=" * 50)
+
+    print("\nKoji dataset želiš preuzeti?")
+    print("  1 — AIGCodeSet (7.583 Python primjera)")
+    print("  2 — ai-code-detection (Rosetta Code + CodeNet)")
+    print("  3 — Oba spojena (preporučeno)")
+
+    odabir = input("\nOdabir (1/2/3): ").strip()
+
+    # Brzi test mod
+    print("\nBrzi test mod? (uzima samo 200 primjera, brže za provjeru)")
+    test_mod = input("(d/n, Enter za ne): ").strip().lower()
+    max_s = 200 if test_mod in ("d", "da", "y", "yes") else MAX_SAMPLES_PER_DATASET
+
+    # Skidanje odabranog dataseta
+    print()
+    svi_primjeri = []
+
+    if odabir in ("1", "3"):
+        svi_primjeri += parse_aigcodeset(max_samples=max_s)
+
+    if odabir in ("2", "3"):
+        svi_primjeri += parse_ai_code_detection(max_samples=max_s)
+
+    if not svi_primjeri:
+        print("\n  Nema primjera za procesiranje. Provjeri internetsku vezu.")
+        return
+
+    human_ukupno = sum(1 for p in svi_primjeri if p["label"] == 0)
+    ai_ukupno    = sum(1 for p in svi_primjeri if p["label"] == 1)
+    print(f"\n  Ukupno primjera za procesiranje: {len(svi_primjeri)}"
+          f"  ({human_ukupno} human, {ai_ukupno} AI)")
+
+    # Izvuci značajke i spremi CSV
+    procesiraj_i_spremi(svi_primjeri, OUTPUT_FILE)
+
+    # Ispiši statistiku
+    ispisi_statistiku(OUTPUT_FILE)
+
+    print("  Sljedeći korak: python classifier.py")
+
+
+if __name__ == "__main__":
+    main()

feature_extraction.py

@@ -0,0 +1,625 @@
+"""
+feature_extraction.py
+=====================
+Višejezično izvlačenje značajki iz programskog koda.
+
+Podržani jezici: Python, JavaScript, TypeScript, Java, C, C++, Go, Rust, Ruby
+
+Organizirano po načinima detekcije:
+  1. Stilska detekcija     – komentari, imenovanje, formatiranje
+  2. Strukturna detekcija  – AST analiza, složenost, tok kontrole
+  3. Statistička detekcija – perplexity pomoću jezičnog modela
+
+Glavna funkcija:
+    extract_all_features(code, language=None, filename=None) -> dict
+"""
+
+import re
+import math
+from collections import Counter
+from tree_sitter import Language, Parser
+
+from language_config import (
+    get_config,
+    detect_language_from_code,
+    detect_language_from_extension,
+)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# POMOĆNE FUNKCIJE
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _safe_divide(a: float, b: float, default: float = 0.0) -> float:
+    """Dijeljenje koje ne puca na nuli."""
+    return a / b if b != 0 else default
+
+
+def _get_lines(code: str) -> list:
+    """Vraća sve linije koda kao listu stringova."""
+    return code.splitlines()
+
+
+def _build_tree(code: str, ts_module):
+    """
+    Parsira kod pomoću Tree-sitter i vraća stablo.
+    Koristi modul specifičan za jezik (npr. tree_sitter_python).
+    Vraća None ako parsiranje ne uspije.
+    """
+    try:
+        lang = Language(ts_module.language())
+        parser = Parser(lang)
+        return parser.parse(code.encode("utf-8", errors="replace"))
+    except Exception:
+        return None
+
+
+def _walk_tree(node) -> list:
+    """
+    Prolazi kroz cijelo Tree-sitter stablo i vraća listu svih čvorova.
+    Ekvivalent ast.walk() iz Pythonovog standardnog modula.
+    """
+    result = [node]
+    for child in node.children:
+        result.extend(_walk_tree(child))
+    return result
+
+
+def _count_node_types(all_nodes: list, type_names: list) -> int:
+    """Broji koliko se puta pojavljuje bilo koji od zadanih tipova čvorova."""
+    if not type_names:
+        return 0
+    return sum(1 for n in all_nodes if n.type in type_names)
+
+
+def _get_node_depth(node, current: int = 0) -> int:
+    """Rekurzivno računa maksimalnu dubinu stabla."""
+    if not node.children:
+        return current
+    return max(_get_node_depth(child, current + 1) for child in node.children)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# NAČIN 1: STILSKA DETEKCIJA
+# ─────────────────────────────────────────────────────────────────────────────
+
+def extract_style_features(code: str, lang_config: dict) -> dict:
+    """
+    Izvlači stilske značajke iz koda.
+
+    Radi za sve jezike jer:
+      - komentare prepoznaje regex obrascem iz lang_config
+        (svaki jezik ima drugu sintaksu komentara)
+      - identifikatore uzima iz Tree-sitter stabla
+        (tree-sitter radi za sve podržane jezike)
+      - formatiranje gleda direktno po linijama
+        (potpuno universalno — vrijedi za sve jezike)
+
+    Parametri:
+        code (str):         Izvorni kod kao string.
+        lang_config (dict): Konfiguracija jezika iz language_config.py.
+
+    Vraća:
+        dict: Stilske značajke s float/int vrijednostima.
+    """
+    lines = _get_lines(code)
+    total_lines = len(lines) if lines else 1
+
+    # ── KOMENTARI ──────────────────────────────────────────────────────────
+    # Svaki jezik ima drugačiji simbol — Python koristi #, Java/JS koriste //
+    # Regex obrazac je definiran u language_config.py za svaki jezik.
+
+    inline_pat = lang_config["inline_comment"]
+    comment_lines = [l for l in lines if re.match(inline_pat, l)]
+    num_comment_lines = len(comment_lines)
+
+    # Prosječna duljina komentara u riječima
+    comment_words_total = sum(
+        len(re.sub(inline_pat, "", l).strip().split())
+        for l in comment_lines
+    )
+    avg_comment_length_words = _safe_divide(comment_words_total, num_comment_lines)
+
+    # Blok komentari: /* ... */ u Java/JS/C, =begin...=end u Ruby
+    num_block_comments = 0
+    if lang_config["block_comment"]:
+        start, end = lang_config["block_comment"]
+        num_block_comments = len(re.findall(
+            re.escape(start) + r"[\s\S]*?" + re.escape(end),
+            code
+        ))
+
+    # Ukupan udio komentara u znakovima
+    total_comment_chars = sum(len(l) for l in comment_lines)
+    comment_to_code_ratio = _safe_divide(total_comment_chars, max(len(code), 1))
+
+    # Dokumentacijski komentari (docstring, JSDoc, Javadoc...)
+    num_docstrings = 0
+    if lang_config.get("docstring_pattern"):
+        num_docstrings = len(re.findall(lang_config["docstring_pattern"], code))
+
+    # ── IMENOVANJE (iz Tree-sitter stabla) ────────────────────────────────
+    # Tree-sitter za svaki jezik daje čvorove tipa "identifier"
+    # koji sadrže nazive varijabli, funkcija, argumenata itd.
+
+    identifier_names = []
+    function_names = []
+
+    tree = _build_tree(code, lang_config["ts_module"])
+    if tree:
+        all_nodes = _walk_tree(tree.root_node)
+        id_types = lang_config["node_types"].get("identifier", ["identifier"])
+        fn_types = lang_config["node_types"].get("function", [])
+
+        # Skupljamo sve identifikatore
+        for node in all_nodes:
+            if node.type in id_types and node.text:
+                name = node.text.decode("utf-8", errors="replace")
+                if len(name) >= 1:
+                    identifier_names.append(name)
+
+        # Skupljamo nazive funkcija — tražimo "identifier" dijete
+        # unutar čvora koji označava funkciju
+        for node in all_nodes:
+            if node.type in fn_types:
+                for child in node.children:
+                    if child.type in id_types and child.text:
+                        fn_name = child.text.decode("utf-8", errors="replace")
+                        function_names.append(fn_name)
+                        break
+
+    avg_identifier_length = _safe_divide(
+        sum(len(n) for n in identifier_names), len(identifier_names)
+    )
+    avg_function_name_length = _safe_divide(
+        sum(len(n) for n in function_names), len(function_names)
+    )
+
+    # Jednoslovna imena (i, x, n, k...) — čovječji kod ih ima više
+    single_char_count = sum(1 for n in identifier_names if len(n) == 1)
+    single_char_ratio = _safe_divide(single_char_count, len(identifier_names))
+
+    # Leksička raznolikost: visoka = raznovrsni nazivi (čovjek), niska = AI ponavlja obrasce
+    lexical_diversity = _safe_divide(
+        len(set(identifier_names)), len(identifier_names)
+    )
+
+    # Konvencije imenovanja
+    def is_snake_case(n):
+        return "_" in n and n == n.lower() and not n.startswith("_")
+
+    def is_camel_case(n):
+        return (len(n) > 1 and not n.startswith("_")
+                and n[0].islower() and any(c.isupper() for c in n)
+                and "_" not in n)
+
+    def is_pascal_case(n):
+        return (len(n) > 1 and n[0].isupper()
+                and any(c.islower() for c in n) and "_" not in n)
+
+    total_ids = max(len(identifier_names), 1)
+    snake_count  = sum(1 for n in identifier_names if is_snake_case(n))
+    camel_count  = sum(1 for n in identifier_names if is_camel_case(n))
+    pascal_count = sum(1 for n in identifier_names if is_pascal_case(n))
+
+    snake_ratio = _safe_divide(snake_count, total_ids)
+    camel_ratio = _safe_divide(camel_count, total_ids)
+
+    # Konzistentnost imenovanja: 1.0 = svi identifikatori u istom stilu (tipično AI)
+    naming_consistency = _safe_divide(
+        max(snake_count, camel_count, pascal_count), total_ids
+    )
+
+    # ── FORMATIRANJE (potpuno universalno za sve jezike) ───────────────────
+
+    non_empty_lines = [l for l in lines if l.strip()]
+    empty_line_ratio = _safe_divide(total_lines - len(non_empty_lines), total_lines)
+
+    line_lengths = [len(l) for l in non_empty_lines] if non_empty_lines else [0]
+    avg_line_length = _safe_divide(sum(line_lengths), len(line_lengths))
+    max_line_length = max(line_lengths) if line_lengths else 0
+
+    # Tabovi vs razmaci za uvlačenje
+    tab_lines = sum(1 for l in lines if l.startswith("\t"))
+    uses_tabs = int(tab_lines > len(lines) * 0.1)
+
+    # Trailing whitespace — razmaci na kraju linije
+    trailing_ws = sum(1 for l in lines if l != l.rstrip())
+    trailing_ws_ratio = _safe_divide(trailing_ws, total_lines)
+
+    # Konzistentnost razmaka oko operatora (= == != < >...)
+    with_space    = len(re.findall(r"\s[=!<>]=?\s", code))
+    without_space = len(re.findall(r"[^\s=!<>][=!<>]=[^\s=]", code))
+    operator_consistency = _safe_divide(
+        max(with_space, without_space), with_space + without_space
+    )
+
+    return {
+        # Komentari
+        "num_comment_lines":            num_comment_lines,
+        "comment_ratio":                _safe_divide(num_comment_lines, total_lines),
+        "avg_comment_length_words":     avg_comment_length_words,
+        "comment_to_code_ratio":        comment_to_code_ratio,
+        "num_block_comments":           num_block_comments,
+        "num_docstrings":               num_docstrings,
+        # Imenovanje
+        "avg_identifier_length":        avg_identifier_length,
+        "avg_function_name_length":     avg_function_name_length,
+        "single_char_name_ratio":       single_char_ratio,
+        "lexical_diversity":            lexical_diversity,
+        "snake_case_ratio":             snake_ratio,
+        "camel_case_ratio":             camel_ratio,
+        "naming_consistency":           naming_consistency,
+        # Formatiranje
+        "total_lines":                  total_lines,
+        "empty_line_ratio":             empty_line_ratio,
+        "avg_line_length":              avg_line_length,
+        "max_line_length":              max_line_length,
+        "uses_tabs":                    uses_tabs,
+        "trailing_whitespace_ratio":    trailing_ws_ratio,
+        "operator_spacing_consistency": operator_consistency,
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# NAČIN 2: STRUKTURNA DETEKCIJA
+# ─────────────────────────────────────────────────────────────────────────────
+
+def extract_structural_features(code: str, lang_config: dict) -> dict:
+    """
+    Izvlači strukturne značajke iz koda pomoću Tree-sitter AST analize.
+
+    Tree-sitter radi za sve podržane jezike — jedina razlika su nazivi
+    čvorova (npr. "function_definition" u Pythonu vs "method_declaration"
+    u Javi), a to je riješeno kroz lang_config["node_types"].
+
+    Parametri:
+        code (str):         Izvorni kod kao string.
+        lang_config (dict): Konfiguracija jezika iz language_config.py.
+
+    Vraća:
+        dict: Strukturne značajke, ili rječnik nula ako parsiranje ne uspije.
+    """
+    empty_result = {k: 0 for k in [
+        "ast_depth", "ast_node_count", "unique_node_type_ratio",
+        "num_functions", "avg_function_length", "max_function_length",
+        "avg_args_per_function", "num_classes", "num_imports",
+        "num_if_statements", "num_for_loops", "num_while_loops",
+        "num_try_blocks", "num_lambdas",
+        "max_nesting_depth", "avg_nesting_depth",
+        "cyclomatic_complexity_approx",
+    ]}
+
+    tree = _build_tree(code, lang_config["ts_module"])
+    if tree is None:
+        return empty_result
+
+    root = tree.root_node
+    all_nodes = _walk_tree(root)
+    nt = lang_config["node_types"]
+
+    # ── AST STABLO ─────────────────────────────────────────────────────────
+
+    ast_depth = _get_node_depth(root)
+    ast_node_count = len(all_nodes)
+    node_type_counts = Counter(n.type for n in all_nodes)
+    unique_node_type_ratio = _safe_divide(len(node_type_counts), ast_node_count)
+
+    # ── FUNKCIJE ───────────────────────────────────────────────────────────
+
+    function_nodes = [n for n in all_nodes if n.type in nt.get("function", [])]
+    num_functions = len(function_nodes)
+
+    # Duljina svake funkcije u linijama koda
+    function_lengths = [
+        fn.end_point[0] - fn.start_point[0] + 1
+        for fn in function_nodes
+    ]
+    avg_function_length = _safe_divide(sum(function_lengths), len(function_lengths))
+    max_function_length = max(function_lengths) if function_lengths else 0
+
+    # Broj parametara po funkciji
+    args_counts = []
+    for fn in function_nodes:
+        for child in fn.children:
+            if child.type in ("parameters", "formal_parameters",
+                              "parameter_list", "argument_list"):
+                params = [c for c in child.children
+                          if c.type not in ("(", ")", ",", "self")]
+                args_counts.append(len(params))
+                break
+    avg_args_per_function = _safe_divide(sum(args_counts), len(args_counts))
+
+    # ── KLASE I IMPORTI ────────────────────────────────────────────────────
+
+    num_classes = _count_node_types(all_nodes, nt.get("class", []))
+    num_imports = _count_node_types(all_nodes, nt.get("import", []))
+
+    # ── TOK KONTROLE ───────────────────────────────────────────────────────
+
+    num_if      = _count_node_types(all_nodes, nt.get("if", []))
+    num_for     = _count_node_types(all_nodes, nt.get("for", []))
+    num_while   = _count_node_types(all_nodes, nt.get("while", []))
+    num_try     = _count_node_types(all_nodes, nt.get("try", []))
+    num_lambdas = _count_node_types(all_nodes, nt.get("lambda", []))
+
+    # ── DUBINA UGNIJEŽĐENOSTI ──────────────────────────────────────────────
+
+    nesting_types = set(
+        nt.get("if", []) + nt.get("for", []) +
+        nt.get("while", []) + nt.get("function", [])
+    )
+
+    def collect_depths(node, depth=0):
+        depths = []
+        for child in node.children:
+            if child.type in nesting_types:
+                depths.append(depth + 1)
+                depths.extend(collect_depths(child, depth + 1))
+            else:
+                depths.extend(collect_depths(child, depth))
+        return depths
+
+    nesting_depths = collect_depths(root)
+    max_nesting_depth = max(nesting_depths) if nesting_depths else 0
+    avg_nesting_depth = _safe_divide(sum(nesting_depths), len(nesting_depths))
+
+    # ── APROKSIMACIJA CIKLOMATSKE SLOŽENOSTI ──────────────────────────────
+    # CC ≈ 1 + broj grananja, dijeljeno brojem funkcija
+    # Standardna aproksimacija koja radi za sve jezike.
+
+    total_branches = 1 + num_if + num_for + num_while + num_try
+    cyclomatic_approx = (
+        _safe_divide(total_branches, num_functions)
+        if num_functions > 0
+        else float(total_branches)
+    )
+
+    # ── NORMALIZACIJA PO VELIČINI KODA ────────────────────────────────────
+    # Apsolutni brojevi (num_if, num_for...) ovise o veličini koda.
+    # Dijeljenjem s brojem nepraznih linija dobivamo gustoću koja je
+    # usporediva između kratkih i dugih kodova.
+    # Npr. 3 if-a u 10 linija (0.30) vs 3 if-a u 100 linija (0.03)
+    # — apsolutni broj je isti, ali gustoća govori pravu priču.
+
+    lines_all = _get_lines(code)
+    non_empty = max(sum(1 for l in lines_all if l.strip()), 1)
+
+    if_density       = _safe_divide(num_if,        non_empty)
+    for_density      = _safe_divide(num_for,       non_empty)
+    while_density    = _safe_divide(num_while,     non_empty)
+    try_density      = _safe_divide(num_try,       non_empty)
+    function_density = _safe_divide(num_functions, non_empty)
+    class_density    = _safe_divide(num_classes,   non_empty)
+    import_density   = _safe_divide(num_imports,   non_empty)
+    lambda_density   = _safe_divide(num_lambdas,   non_empty)
+
+    # Broj AST čvorova po liniji — AI kod ima predvidljive strukture
+    ast_nodes_per_line = _safe_divide(ast_node_count, non_empty)
+
+    # ── ENTROPIJA KODA ────────────────────────────────────────────────────
+    # Entropija mjeri raznolikost i nepredvidljivost koda.
+    # Visoka entropija = raznolik, nepredvidljiv kod = vjerojatno čovjek
+    # Niska entropija  = ponavljajući, predvidljiv kod = možda AI
+    #
+    # Formula: H = -sum(p * log2(p)) za svaki jedinstveni element
+
+    import math as _math
+    from collections import Counter as _Counter
+
+    # Entropija znakova — distribucija pojedinih znakova u kodu
+    char_counts = _Counter(code)
+    total_chars = len(code) if code else 1
+    char_entropy = -sum(
+        (c / total_chars) * _math.log2(c / total_chars)
+        for c in char_counts.values()
+    )
+
+    # Entropija tokena — raznolikost na razini imenskih jedinica i simbola
+    # Bolji signal od entropije znakova jer gleda smislene jezične jedinice
+    tokens = re.findall(r"[a-zA-Z_]\w*|[0-9]+|[^\w\s]", code)
+    token_counts = _Counter(tokens)
+    total_tokens = len(tokens) if tokens else 1
+    token_entropy = -sum(
+        (c / total_tokens) * _math.log2(c / total_tokens)
+        for c in token_counts.values()
+    )
+
+    return {
+        # AST metrike (neovisne o veličini)
+        "ast_depth":                    ast_depth,
+        "unique_node_type_ratio":       unique_node_type_ratio,
+        "ast_nodes_per_line":           ast_nodes_per_line,
+        # Funkcije (prosjeci su već neovisni o veličini)
+        "avg_function_length":          avg_function_length,
+        "max_function_length":          max_function_length,
+        "avg_args_per_function":        avg_args_per_function,
+        # Gustoće — normalizirane po nepraznim linijama koda
+        "function_density":             function_density,
+        "class_density":                class_density,
+        "import_density":               import_density,
+        "if_density":                   if_density,
+        "for_density":                  for_density,
+        "while_density":                while_density,
+        "try_density":                  try_density,
+        "lambda_density":               lambda_density,
+        # Ugniježđenost i složenost (već neovisni o veličini)
+        "max_nesting_depth":            max_nesting_depth,
+        "avg_nesting_depth":            avg_nesting_depth,
+        "cyclomatic_complexity_approx": cyclomatic_approx,
+        # Entropija
+        "char_entropy":                 char_entropy,
+        "token_entropy":                token_entropy,
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# NAČIN 3: STATISTIČKA DETEKCIJA (Perplexity)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def extract_statistical_features(code: str, model=None, tokenizer=None) -> dict:
+    """
+    Računa perplexity koda pomoću jezičnog modela.
+
+    Niski perplexity → model je "očekivao" kod → vjerojatno AI.
+    Visoki perplexity → model je "iznenađen" → vjerojatno čovjek.
+
+    Metoda je jezično-agnostična — isti model prima kod u bilo kojem jeziku.
+    Ako model nije proslijeđen (None), vraća -1 i ostatak pipeline-a nastavlja
+    normalno bez statističke značajke.
+    """
+    if model is None or tokenizer is None:
+        return {"perplexity": -1.0, "model_available": 0}
+
+    try:
+        import torch
+
+        inputs = tokenizer(
+            code, return_tensors="pt", truncation=True, max_length=512
+        )
+        with torch.no_grad():
+            outputs = model(inputs["input_ids"], labels=inputs["input_ids"])
+            loss = outputs.loss
+
+        perplexity = math.exp(loss.item())
+
+    except Exception as e:
+        print(f"  [UPOZORENJE] Perplexity nije izračunat: {e}")
+        perplexity = -1.0
+
+    return {"perplexity": perplexity, "model_available": 1}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# KOMBINIRANA FUNKCIJA — ulazna točka
+# ─────────────────────────────────────────────────────────────────────────────
+
+def extract_all_features(
+    code: str,
+    language=None,
+    filename=None,
+    model=None,
+    tokenizer=None,
+) -> dict:
+    """
+    Izvlači SVE značajke iz koda u jednom pozivu.
+
+    Jezik se određuje ovim redoslijedom:
+      1. Argument language (ako je zadan)
+      2. Nastavak datoteke iz filename (ako je zadan)
+      3. Heuristike iz samog koda (automatska detekcija)
+
+    Parametri:
+        code (str):          Izvorni kod kao string.
+        language (str|None): Naziv jezika (npr. "python", "java").
+        filename (str|None): Ime datoteke (npr. "main.py").
+        model:               (opcionalno) HuggingFace model za perplexity.
+        tokenizer:           (opcionalno) HuggingFace tokenizator.
+
+    Vraća:
+        dict: Sve značajke + ključ "detected_language".
+    """
+    # Određivanje jezika
+    if language is not None:
+        detected_lang = language.lower()
+    elif filename is not None:
+        detected_lang = (detect_language_from_extension(filename)
+                         or detect_language_from_code(code))
+    else:
+        detected_lang = detect_language_from_code(code)
+
+    lang_config = get_config(detected_lang)
+
+    # Izvlačenje značajki po metodama
+    style_feats       = extract_style_features(code, lang_config)
+    structural_feats  = extract_structural_features(code, lang_config)
+    statistical_feats = extract_statistical_features(code, model, tokenizer)
+
+    return {
+        "detected_language": detected_lang,
+        **style_feats,
+        **structural_feats,
+        **statistical_feats,
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# BRZI TEST — pokreni: python feature_extraction.py
+# ─────────────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+
+    test_cases = {
+        "Python (AI)": ("python", '''
+def calculate_average(numbers: list) -> float:
+    """Calculate the arithmetic mean of a list of numbers."""
+    if not numbers:
+        raise ValueError("Cannot calculate average of an empty list.")
+    total_sum = sum(numbers)
+    count = len(numbers)
+    return total_sum / count
+'''),
+        "Python (Human)": ("python", '''
+def avg(nums):
+    # quick avg
+    return sum(nums) / len(nums)
+'''),
+        "JavaScript (AI)": ("javascript", '''
+/**
+ * Calculates the average of an array of numbers.
+ */
+function calculateAverage(numbers) {
+    if (!numbers || numbers.length === 0) {
+        throw new Error("Cannot calculate average of an empty array.");
+    }
+    const totalSum = numbers.reduce((acc, val) => acc + val, 0);
+    return totalSum / numbers.length;
+}
+'''),
+        "Java (AI)": ("java", '''
+/**
+ * Calculates the average of an integer array.
+ */
+public class Calculator {
+    public static double calculateAverage(int[] numbers) {
+        if (numbers == null || numbers.length == 0) {
+            throw new IllegalArgumentException("Array must not be empty.");
+        }
+        int totalSum = 0;
+        for (int currentNumber : numbers) {
+            totalSum += currentNumber;
+        }
+        return (double) totalSum / numbers.length;
+    }
+}
+'''),
+    }
+
+    KEY_FEATURES = [
+        ("Prepoznat jezik",            "detected_language"),
+        ("Omjer komentara",            "comment_ratio"),
+        ("Broj docstringova",          "num_docstrings"),
+        ("Prosj. duljina identif.",    "avg_identifier_length"),
+        ("Prosj. duljina fun. naziva", "avg_function_name_length"),
+        ("Jednoslovna imena",          "single_char_name_ratio"),
+        ("Konzistentnost imenovanja",  "naming_consistency"),
+        ("Broj funkcija",              "num_functions"),
+        ("Prosj. duljina funkcije",    "avg_function_length"),
+        ("Max ugniježđenost",          "max_nesting_depth"),
+        ("Aproks. složenost (CC)",     "cyclomatic_complexity_approx"),
+        ("Perplexity",                 "perplexity"),
+    ]
+
+    for label, (lang, code) in test_cases.items():
+        print(f"\n{'═' * 55}")
+        print(f"  {label}")
+        print(f"{'═' * 55}")
+        features = extract_all_features(code, language=lang)
+        for display_name, key in KEY_FEATURES:
+            val = features.get(key, "N/A")
+            if isinstance(val, float):
+                print(f"  {display_name:<32} {val:.4f}")
+            else:
+                print(f"  {display_name:<32} {val}")
+
+    print(f"\n  Ukupno značajki: {len(features)}")

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/README.md

@@ -0,0 +1,16 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.

frontend/eslint.config.js

@@ -0,0 +1,21 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      globals: globals.browser,
+      parserOptions: { ecmaFeatures: { jsx: true } },
+    },
+  },
+])

frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>CodeSentinel</title>
+    <link rel="icon" type="image/svg+xml" href="/shield.svg" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package-lock.json

@@ -0,0 +1,1677 @@
+{
+  "name": "codesentinel-frontend",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "codesentinel-frontend",
+      "version": "1.0.0",
+      "dependencies": {
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1"
+      },
+      "devDependencies": {
+        "@vitejs/plugin-react": "^4.3.1",
+        "vite": "^5.4.2"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.3",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.3.tgz",
+      "integrity": "sha512-LIVqM46zQWZhj17qA8wb4nW/ixr2y1Nw+r1etiAWgRM6U1IqP+LNhL1yg440jYZR72jCWcWbLWzIosH+uP1fqg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
+      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helpers": "^7.28.6",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.1",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
+      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
+      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz",
+      "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.3",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.3.tgz",
+      "integrity": "sha512-b3ctpQwp+PROvU/cttc4OYl4MzfJUWy6FZg+PMXfzmt/+39iHVF0sDfqay8TQM3JA2EUOyKcFZt75jWriQijsA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
+      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
+      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.27",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",
+      "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.3.tgz",
+      "integrity": "sha512-x35CNW/ANXG3hE/EZpRU8MXX1JDN86hBb2wMGAtltkz7pc6cxgjpy1OMMfDosOQ+2hWqIkag/fGok1Yady9nGw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.3.tgz",
+      "integrity": "sha512-xw3xtkDApIOGayehp2+Rz4zimfkaX65r4t47iy+ymQB2G4iJCBBfj0ogVg5jpvjpn8UWn/+q9tprxleYeNp3Hw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.3.tgz",
+      "integrity": "sha512-vo6Y5Qfpx7/5EaamIwi0WqW2+zfiusVihKatLvtN1VFVy3D13uERk/6gZLU1UiHRL6fDXqj/ELIeVRGnvcTE1g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.3.tgz",
+      "integrity": "sha512-D+0QGcZhBzTN82weOnsSlY7V7+RMmPuF1CkbxyMAGE8+ZHeUjyb76ZiWmBlCu//AQQONvxcqRbwZTajZKqjuOw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.3.tgz",
+      "integrity": "sha512-6HnvHCT7fDyj6R0Ph7A6x8dQS/S38MClRWeDLqc0MdfWkxjiu1HSDYrdPhqSILzjTIC/pnXbbJbo+ft+gy/9hQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.3.tgz",
+      "integrity": "sha512-KHLgC3WKlUYW3ShFKnnosZDOJ0xjg9zp7au3sIm2bs/tGBeC2ipmvRh/N7JKi0t9Ue20C0dpEshi8WUubg+cnA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.3.tgz",
+      "integrity": "sha512-DV6fJoxEYWJOvaZIsok7KrYl0tPvga5OZ2yvKHNNYyk/2roMLqQAbGhr78EQ5YhHpnhLKJD3S1WFusAkmUuV5g==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.3.tgz",
+      "integrity": "sha512-mQKoJAzvuOs6F+TZybQO4GOTSMUu7v0WdxEk24krQ/uUxXoPTtHjuaUuPmFhtBcM4K0ons8nrE3JyhTuCFtT/w==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.3.tgz",
+      "integrity": "sha512-Whjj2qoiJ6+OOJMGptTYazaJvjOJm+iKHpXQM1P3LzGjt7Ff++Tp7nH4N8J/BUA7R9IHfDyx4DJIflifwnbmIA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.3.tgz",
+      "integrity": "sha512-4YTNHKqGng5+yiZt3mg77nmyuCfmNfX4fPmyUapBcIk+BdwSwmCWGXOUxhXbBEkFHtoN5boLj/5NON+u5QC9tg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.3.tgz",
+      "integrity": "sha512-SU3kNlhkpI4UqlUc2VXPGK9o886ZsSeGfMAX2ba2b8DKmMXq4AL7KUrkSWVbb7koVqx41Yczx6dx5PNargIrEA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.3.tgz",
+      "integrity": "sha512-6lDLl5h4TXpB1mTf2rQWnAk/LcXrx9vBfu/DT5TIPhvMhRWaZ5MxkIc8u4lJAmBo6klTe1ywXIUHFjylW505sg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.3.tgz",
+      "integrity": "sha512-BMo8bOw8evlup/8G+cj5xWtPyp93xPdyoSN16Zy90Q2QZ0ZYRhCt6ZJSwbrRzG9HApFabjwj2p25TUPDWrhzqQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.3.tgz",
+      "integrity": "sha512-E0L8X1dZN1/Rph+5VPF6Xj2G7JJvMACVXtamTJIDrVI44Y3K+G8gQaMEAavbqCGTa16InptiVrX6eM6pmJ+7qA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.3.tgz",
+      "integrity": "sha512-oZJ/WHaVfHUiRAtmTAeo3DcevNsVvH8mbvodjZy7D5QKvCefO371SiKRpxoDcCxB3PTRTLayWBkvmDQKTcX/sw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.3.tgz",
+      "integrity": "sha512-Dhbyh7j9FybM3YaTgaHmVALwA8AkUwTPccyCQ79TG9AJUsMQqgN1DDEZNr4+QUfwiWvLDumW5vdwzoeUF+TNxQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.3.tgz",
+      "integrity": "sha512-cJd1X5XhHHlltkaypz1UcWLA8AcoIi1aWhsvaWDskD1oz2eKCypnqvTQ8ykMNI0RSmm7NkTdSqSSD7zM0xa6Ig==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.3.tgz",
+      "integrity": "sha512-DAZDBHQfG2oQuhY7mc6I3/qB4LU2fQCjRvxbDwd/Jdvb9fypP4IJ4qmtu6lNjes6B531AI8cg1aKC2di97bUxA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.3.tgz",
+      "integrity": "sha512-cRxsE8c13mZOh3vP+wLDxpQBRrOHDIGOWyDL93Sy0Ga8y515fBcC2pjUfFwUe5T7tqvTvWbCpg1URM/AXdWIXA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.3.tgz",
+      "integrity": "sha512-QaWcIgRxqEdQdhJqW4DJctsH6HCmo5vHxY0krHSX4jMtOqfzC+dqDGuHM87bu4H8JBeibWx7jFz+h6/4C8wA5Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.3.tgz",
+      "integrity": "sha512-AaXwSvUi3QIPtroAUw1t5yHGIyqKEXwH54WUocFolZhpGDruJcs8c+xPNDRn4XiQsS7MEwnYsHW2l0MBLDMkWg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.3.tgz",
+      "integrity": "sha512-65LAKM/bAWDqKNEelHlcHvm2V+Vfb8C6INFxQXRHCvaVN1rJfwr4NvdP4FyzUaLqWfaCGaadf6UbTm8xJeYfEg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.3.tgz",
+      "integrity": "sha512-EEM2gyhBF5MFnI6vMKdX1LAosE627RGBzIoGMdLloPZkXrUN0Ckqgr2Qi8+J3zip/8NVVro3/FjB+tjhZUgUHA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.3.tgz",
+      "integrity": "sha512-E5Eb5H/DpxaoXH++Qkv28RcUJboMopmdDUALBczvHMf7hNIxaDZqwY5lK12UK1BHacSmvupoEWGu+n993Z0y1A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.3.tgz",
+      "integrity": "sha512-hPt/bgL5cE+Qp+/TPHBqptcAgPzgj46mPcg/16zNUmbQk0j+mOEQV/+Lqu8QRtDV3Ek95Q6FeFITpuhl6OTsAA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
+      "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.28.0",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.27",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.17.0"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.29",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.29.tgz",
+      "integrity": "sha512-Asa2krT+XTPZINCS+2QcyS8WTkObE77RwkydwF7h6DmnKqbvlalz93m/dnphUyCa6SWSP51VgtEUf2FN+gelFQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001792",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001792.tgz",
+      "integrity": "sha512-hVLMUZFgR4JJ6ACt1uEESvQN1/dBVqPAKY0hgrV70eN3391K6juAfTjKZLKvOMsx8PxA7gsY1/tLMMTcfFLLpw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.353",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.353.tgz",
+      "integrity": "sha512-kOrWphBi8TOZyiJZqsgqIle0lw+tzmnQK83pV9dZUd01Nm2POECSyFQMAuarzZdYqQW7FH9RaYOuaRo3h+bQ3w==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.12",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
+      "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.44",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.44.tgz",
+      "integrity": "sha512-5WUyunoPMsvvEhS8AxHtRzP+oA8UCkJ7YRxatWKjngndhDGLiqEVAQKWjFAiAiuL8zMRGzGSJxFnLetoa43qGQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/postcss": {
+      "version": "8.5.14",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.14.tgz",
+      "integrity": "sha512-SoSL4+OSEtR99LHFZQiJLkT59C5B1amGO1NzTwj7TT1qCUgUO6hxOvzkOYxD+vMrXBM3XJIKzokoERdqQq/Zmg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/react": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0",
+        "scheduler": "^0.23.2"
+      },
+      "peerDependencies": {
+        "react": "^18.3.1"
+      }
+    },
+    "node_modules/react-refresh": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.60.3",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.3.tgz",
+      "integrity": "sha512-pAQK9HalE84QSm4Po3EmWIZPd3FnjkShVkiMlz1iligWYkWQ7wHYd1PF/T7QZ5TVSD6uSTon5gBVMSM4JfBV+A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.60.3",
+        "@rollup/rollup-android-arm64": "4.60.3",
+        "@rollup/rollup-darwin-arm64": "4.60.3",
+        "@rollup/rollup-darwin-x64": "4.60.3",
+        "@rollup/rollup-freebsd-arm64": "4.60.3",
+        "@rollup/rollup-freebsd-x64": "4.60.3",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.60.3",
+        "@rollup/rollup-linux-arm-musleabihf": "4.60.3",
+        "@rollup/rollup-linux-arm64-gnu": "4.60.3",
+        "@rollup/rollup-linux-arm64-musl": "4.60.3",
+        "@rollup/rollup-linux-loong64-gnu": "4.60.3",
+        "@rollup/rollup-linux-loong64-musl": "4.60.3",
+        "@rollup/rollup-linux-ppc64-gnu": "4.60.3",
+        "@rollup/rollup-linux-ppc64-musl": "4.60.3",
+        "@rollup/rollup-linux-riscv64-gnu": "4.60.3",
+        "@rollup/rollup-linux-riscv64-musl": "4.60.3",
+        "@rollup/rollup-linux-s390x-gnu": "4.60.3",
+        "@rollup/rollup-linux-x64-gnu": "4.60.3",
+        "@rollup/rollup-linux-x64-musl": "4.60.3",
+        "@rollup/rollup-openbsd-x64": "4.60.3",
+        "@rollup/rollup-openharmony-arm64": "4.60.3",
+        "@rollup/rollup-win32-arm64-msvc": "4.60.3",
+        "@rollup/rollup-win32-ia32-msvc": "4.60.3",
+        "@rollup/rollup-win32-x64-gnu": "4.60.3",
+        "@rollup/rollup-win32-x64-msvc": "4.60.3",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      }
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    }
+  }
+}

frontend/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "codesentinel-frontend",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.3.1",
+    "vite": "^5.4.2"
+  }
+}

frontend/src/App.css

@@ -0,0 +1,184 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}

frontend/src/App.jsx

@@ -0,0 +1,62 @@
+import { useState, useEffect } from 'react'
+import Navbar from './components/Navbar'
+import AnalyzeScreen from './screens/AnalyzeScreen'
+import BatchScreen from './screens/BatchScreen'
+import SimilarityScreen from './screens/SimilarityScreen'
+import DetailScreen from './screens/DetailScreen'
+
+export default function App() {
+  const [screen, setScreen] = useState('analyze')
+  const [detailRow, setDetailRow] = useState(null)
+  const [serverOk, setServerOk] = useState(null)
+
+  useEffect(() => {
+    fetch('/api/health')
+      .then(r => r.json())
+      .then(d => setServerOk(d.model_loaded))
+      .catch(() => setServerOk(false))
+  }, [])
+
+  const navigate = (s) => { setScreen(s); setDetailRow(null) }
+  const openDetail = (row) => { setDetailRow(row); setScreen('detail') }
+
+  return (
+    <div style={{ minHeight: '100vh', background: '#0A0F1C', position: 'relative' }}>
+      {/* Atmospheric glow */}
+      <div style={{
+        position: 'fixed', inset: 0, pointerEvents: 'none', zIndex: 0,
+        background: 'radial-gradient(ellipse 1200px 600px at 50% -10%, rgba(0,212,255,0.08), transparent 60%)',
+      }}/>
+
+      <div style={{ position: 'relative', zIndex: 1 }}>
+        <Navbar active={screen === 'detail' ? 'batch' : screen} onNavigate={navigate}/>
+
+        {/* Server status banner */}
+        {serverOk === false && (
+          <div style={{
+            background: 'rgba(239,68,68,0.12)', borderBottom: '1px solid rgba(239,68,68,0.25)',
+            padding: '10px 80px', display: 'flex', alignItems: 'center', gap: 10, fontSize: 13, color: '#EF4444',
+          }}>
+            <span>⚠</span>
+            <span>Flask server not reachable. Start it with: <code style={{ fontFamily: 'JetBrains Mono, monospace', background: 'rgba(239,68,68,0.12)', padding: '2px 6px', borderRadius: 4 }}>python app.py</code></span>
+          </div>
+        )}
+
+        {serverOk === true && screen === 'analyze' && (
+          <div style={{
+            background: 'rgba(16,185,129,0.08)', borderBottom: '1px solid rgba(16,185,129,0.15)',
+            padding: '8px 80px', display: 'flex', alignItems: 'center', gap: 10, fontSize: 12, color: '#10B981',
+          }}>
+            <span style={{ width: 6, height: 6, borderRadius: '50%', background: '#10B981', display: 'inline-block' }}/>
+            Server connected · Model loaded
+          </div>
+        )}
+
+        {screen === 'analyze'    && <AnalyzeScreen/>}
+        {screen === 'batch'      && <BatchScreen onOpenRow={openDetail}/>}
+        {screen === 'similarity' && <SimilarityScreen/>}
+        {screen === 'detail'     && <DetailScreen row={detailRow} onBack={() => setScreen('batch')}/>}
+      </div>
+    </div>
+  )
+}

frontend/src/api/client.js

@@ -0,0 +1,31 @@
+// api/client.js — sve API pozive na Flask backend
+
+const BASE = '/api'
+
+async function request(method, path, body) {
+  const res = await fetch(`${BASE}${path}`, {
+    method,
+    headers: { 'Content-Type': 'application/json' },
+    body: body ? JSON.stringify(body) : undefined,
+  })
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}))
+    throw new Error(err.error || `HTTP ${res.status}`)
+  }
+  return res.json()
+}
+
+// Provjera statusa servera
+export const checkHealth = () => request('GET', '/health')
+
+// Analiza jednog isječka koda
+export const analyzeCode = (code, language, filename) =>
+  request('POST', '/analyze', { code, language, filename })
+
+// Analiza više kodova odjednom
+export const analyzeBatch = (submissions) =>
+  request('POST', '/analyze-batch', { submissions })
+
+// Matrica sličnosti
+export const computeSimilarity = (submissions) =>
+  request('POST', '/similarity', { submissions })

frontend/src/components/CodeEditor.jsx

@@ -0,0 +1,105 @@
+import { LangBadge } from './primitives'
+
+function SyntaxTinted({ code }) {
+  const tokens = code.split(/(\b(?:def|return|if|else|elif|for|while|import|from|class|in|not|and|or|True|False|None|self|function|const|let|var|=>|public|private|static|void|int|string|bool)\b|"[^"]*"|'[^']*'|`[^`]*`|#[^\n]*|\/\/[^\n]*|\/\*[\s\S]*?\*\/|\b\d+\b)/g)
+  return tokens.map((t, i) => {
+    if (/^(def|return|if|else|elif|for|while|import|from|class|in|not|and|or|True|False|None|self|function|const|let|var|public|private|static|void|int|string|bool)$/.test(t))
+      return <span key={i} style={{ color: '#22E0FF' }}>{t}</span>
+    if (/^["'`].*["'`]$/.test(t)) return <span key={i} style={{ color: '#10B981' }}>{t}</span>
+    if (/^(#|\/\/)/.test(t)) return <span key={i} style={{ color: '#64748B', fontStyle: 'italic' }}>{t}</span>
+    if (/^\d+$/.test(t)) return <span key={i} style={{ color: '#F59E0B' }}>{t}</span>
+    return <span key={i}>{t}</span>
+  })
+}
+
+export default function CodeEditor({ code, onChange, lang = 'Python', readOnly = false, height = 360, annotations = [], filename }) {
+  const lines = (code || '').split('\n')
+  const displayName = filename || 'submission.' + (lang === 'Python' ? 'py' : lang === 'Java' ? 'java' : lang === 'JavaScript' ? 'js' : 'txt')
+
+  return (
+    <div style={{
+      background: '#0F172A', border: '1px solid rgba(148,163,184,0.12)',
+      borderRadius: 10, overflow: 'hidden', boxShadow: 'inset 0 1px 0 rgba(255,255,255,0.03)',
+    }}>
+      {/* Header bar */}
+      <div style={{
+        display: 'flex', alignItems: 'center', justifyContent: 'space-between',
+        padding: '10px 14px', borderBottom: '1px solid rgba(148,163,184,0.12)',
+        background: 'rgba(15,23,41,0.6)',
+      }}>
+        <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
+          <div style={{ display: 'flex', gap: 6 }}>
+            <span style={{ width: 10, height: 10, borderRadius: '50%', background: '#EF4444', opacity: 0.6 }}/>
+            <span style={{ width: 10, height: 10, borderRadius: '50%', background: '#F59E0B', opacity: 0.6 }}/>
+            <span style={{ width: 10, height: 10, borderRadius: '50%', background: '#10B981', opacity: 0.6 }}/>
+          </div>
+          <span style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 12, color: '#94A3B8' }}>{displayName}</span>
+        </div>
+        <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+          {!readOnly && <span style={{ fontSize: 10, color: '#64748B', letterSpacing: '0.04em', textTransform: 'uppercase' }}>Auto-detected</span>}
+          <LangBadge lang={lang}/>
+        </div>
+      </div>
+
+      {/* Editor body */}
+      <div style={{ display: 'flex', height, position: 'relative', overflow: 'hidden' }}>
+        {/* Line numbers */}
+        <div style={{
+          padding: '12px 12px 12px 16px', background: 'rgba(10,15,28,0.4)',
+          fontFamily: 'JetBrains Mono, monospace', fontSize: 12, lineHeight: 1.7,
+          color: '#475569', textAlign: 'right', userSelect: 'none',
+          borderRight: '1px solid rgba(148,163,184,0.08)', minWidth: 44,
+          overflowY: 'hidden',
+        }}>
+          {lines.map((_, i) => {
+            const ann = annotations.find(a => a.line === i + 1)
+            return (
+              <div key={i} style={{
+                color: ann ? (ann.tone === 'red' ? '#EF4444' : '#F59E0B') : '#475569',
+                fontWeight: ann ? 600 : 400,
+              }}>{i + 1}</div>
+            )
+          })}
+        </div>
+
+        {/* Code area */}
+        <div style={{ flex: 1, position: 'relative', overflow: 'auto' }}>
+          {annotations.map((a, i) => (
+            <div key={i} style={{
+              position: 'absolute', left: 0, right: 0,
+              top: `calc(12px + ${a.line - 1} * 1.7em)`, height: '1.7em',
+              background: a.tone === 'red' ? 'rgba(239,68,68,0.08)' : 'rgba(245,158,11,0.08)',
+              borderLeft: `2px solid ${a.tone === 'red' ? '#EF4444' : '#F59E0B'}`,
+              pointerEvents: 'none', zIndex: 1,
+            }}>
+              {a.note && (
+                <span style={{
+                  position: 'absolute', right: 12, top: '50%', transform: 'translateY(-50%)',
+                  fontSize: 10, color: a.tone === 'red' ? '#EF4444' : '#F59E0B',
+                  fontFamily: 'Inter, sans-serif', background: a.tone === 'red' ? 'rgba(239,68,68,0.12)' : 'rgba(245,158,11,0.12)',
+                  padding: '2px 6px', borderRadius: 4,
+                }}>⚠ {a.note}</span>
+              )}
+            </div>
+          ))}
+          {readOnly ? (
+            <pre style={{
+              margin: 0, padding: '12px 16px',
+              fontFamily: 'JetBrains Mono, monospace', fontSize: 12, lineHeight: 1.7,
+              color: '#CBD5E1', whiteSpace: 'pre', overflow: 'visible',
+            }}><SyntaxTinted code={code}/></pre>
+          ) : (
+            <textarea value={code} onChange={e => onChange && onChange(e.target.value)}
+              spellCheck="false" placeholder="Paste your code here…"
+              style={{
+                width: '100%', height: '100%', border: 'none', outline: 'none', resize: 'none',
+                background: 'transparent', color: '#CBD5E1',
+                fontFamily: 'JetBrains Mono, monospace', fontSize: 12, lineHeight: 1.7,
+                padding: '12px 16px',
+              }}/>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}

frontend/src/components/DetailSidebar.jsx

@@ -0,0 +1,65 @@
+import { Card, Label, Badge, Icon } from './primitives'
+
+function SuspiciousPair({ a, b, similarity }) {
+  const color = similarity >= 85 ? '#EF4444' : '#F59E0B'
+  return (
+    <Card hoverable style={{ padding: '16px 20px' }}>
+      <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
+        <div>
+          <div style={{ display: 'flex', alignItems: 'center', gap: 10, marginBottom: 6 }}>
+            <span style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 14, fontWeight: 600, color: '#F8FAFC' }}>{a}</span>
+            <Icon name="chevronRight" size={14} color="#64748B"/>
+            <span style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 14, fontWeight: 600, color: '#F8FAFC' }}>{b}</span>
+          </div>
+          <div style={{ fontSize: 12, color: '#64748B' }}>High structural similarity detected</div>
+        </div>
+        <div style={{ textAlign: 'right' }}>
+          <div style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 28, fontWeight: 700, color, lineHeight: 1 }}>
+            {similarity}<span style={{ fontSize: 14 }}>%</span>
+          </div>
+          <div style={{ fontSize: 10, color: '#64748B', letterSpacing: '0.04em', textTransform: 'uppercase', marginTop: 4 }}>Similar</div>
+        </div>
+      </div>
+    </Card>
+  )
+}
+
+export { SuspiciousPair }
+
+export default function DetailSidebar({ features }) {
+  const groups = features.reduce((acc, f) => {
+    const cat = f.category || 'Other';
+    (acc[cat] = acc[cat] || []).push(f)
+    return acc
+  }, {})
+
+  return (
+    <div style={{ display: 'flex', flexDirection: 'column', gap: 20 }}>
+      {Object.entries(groups).map(([cat, items]) => (
+        <Card key={cat} style={{ padding: 18 }}>
+          <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', marginBottom: 14 }}>
+            <Label style={{ marginBottom: 0 }}>{cat}</Label>
+            <span style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 11, color: '#64748B' }}>{items.length}</span>
+          </div>
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 10 }}>
+            {items.map((f, i) => {
+              const color = f.severity === 'high' ? '#EF4444' : f.severity === 'medium' ? '#F59E0B' : '#10B981'
+              const pct = f.severity === 'high' ? 85 : f.severity === 'medium' ? 55 : 22
+              return (
+                <div key={i}>
+                  <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'baseline', marginBottom: 4 }}>
+                    <span style={{ fontSize: 12, color: '#CBD5E1' }}>{f.name}</span>
+                    <span style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 12, fontWeight: 600, color }}>{f.value}</span>
+                  </div>
+                  <div style={{ height: 3, background: 'rgba(148,163,184,0.10)', borderRadius: 2, overflow: 'hidden' }}>
+                    <div style={{ width: `${pct}%`, height: '100%', background: color }}/>
+                  </div>
+                </div>
+              )
+            })}
+          </div>
+        </Card>
+      ))}
+    </div>
+  )
+}

frontend/src/components/Dropzone.jsx

@@ -0,0 +1,46 @@
+import { useState } from 'react'
+import { Icon } from './primitives'
+
+export default function Dropzone({ files = [], onUpload }) {
+  const [dragOver, setDragOver] = useState(false)
+  return (
+    <div
+      onDragOver={e => { e.preventDefault(); setDragOver(true) }}
+      onDragLeave={() => setDragOver(false)}
+      onDrop={e => { e.preventDefault(); setDragOver(false); onUpload && onUpload(e.dataTransfer.files) }}
+      onClick={() => { const i = document.createElement('input'); i.type = 'file'; i.multiple = true; i.accept = '.py,.js,.java,.cpp,.ts,.go,.rs,.rb,.c,.h'; i.onchange = e => onUpload && onUpload(e.target.files); i.click() }}
+      style={{
+        border: `1.5px dashed ${dragOver ? 'rgba(0,212,255,0.6)' : 'rgba(148,163,184,0.25)'}`,
+        borderRadius: 12, padding: '48px 24px', textAlign: 'center',
+        background: dragOver ? 'rgba(0,212,255,0.04)' : 'rgba(17,24,39,0.5)',
+        cursor: 'pointer', transition: 'all .12s cubic-bezier(0.22,1,0.36,1)',
+        backdropFilter: 'blur(20px)',
+      }}>
+      <div style={{
+        width: 56, height: 56, margin: '0 auto 18px', borderRadius: 12,
+        background: 'rgba(0,212,255,0.10)', border: '1px solid rgba(0,212,255,0.25)',
+        display: 'flex', alignItems: 'center', justifyContent: 'center',
+      }}>
+        <Icon name="upload" size={24} color="#00D4FF"/>
+      </div>
+      <div style={{ fontSize: 18, fontWeight: 600, color: '#F8FAFC', marginBottom: 6 }}>
+        {files.length > 0 ? `${files.length} files ready to analyze` : 'Drop student files here or click to upload'}
+      </div>
+      <div style={{ fontSize: 13, color: '#64748B' }}>
+        Accepts <span style={{ fontFamily: 'JetBrains Mono, monospace', color: '#94A3B8' }}>.py .js .java .cpp .ts .go .rs</span> · max 200 files
+      </div>
+      {files.length > 0 && (
+        <div style={{ marginTop: 20, display: 'flex', justifyContent: 'center', gap: 6, flexWrap: 'wrap', maxWidth: 600, marginLeft: 'auto', marginRight: 'auto' }}>
+          {files.slice(0, 10).map((f, i) => (
+            <span key={i} style={{
+              fontFamily: 'JetBrains Mono, monospace', fontSize: 11,
+              padding: '4px 10px', background: 'rgba(0,212,255,0.08)',
+              border: '1px solid rgba(0,212,255,0.20)', borderRadius: 6, color: '#00D4FF',
+            }}>{f.name || f}</span>
+          ))}
+          {files.length > 10 && <span style={{ fontSize: 11, color: '#64748B', alignSelf: 'center' }}>+{files.length - 10} more</span>}
+        </div>
+      )}
+    </div>
+  )
+}

frontend/src/components/ExplanationPanel.jsx

@@ -0,0 +1,130 @@
+// ExplanationPanel.jsx — prikaz objašnjenja zašto je kod klasificiran ovako
+
+import { Card, Label, Icon } from './primitives'
+
+const SEVERITY_CONFIG = {
+  high: {
+    color: '#EF4444',
+    bg: 'rgba(239,68,68,0.08)',
+    border: 'rgba(239,68,68,0.25)',
+    icon: 'xCircle',
+    label: 'Strong signal',
+  },
+  medium: {
+    color: '#F59E0B',
+    bg: 'rgba(245,158,11,0.08)',
+    border: 'rgba(245,158,11,0.25)',
+    icon: 'alert',
+    label: 'Moderate signal',
+  },
+  low: {
+    color: '#94A3B8',
+    bg: 'rgba(148,163,184,0.06)',
+    border: 'rgba(148,163,184,0.15)',
+    icon: 'filter',
+    label: 'Weak signal',
+  },
+  positive: {
+    color: '#10B981',
+    bg: 'rgba(16,185,129,0.08)',
+    border: 'rgba(16,185,129,0.25)',
+    icon: 'check',
+    label: 'Human indicator',
+  },
+}
+
+export default function ExplanationPanel({ explanations, verdict, aiProbability }) {
+  if (!explanations || explanations.length === 0) return null
+
+  const highCount   = explanations.filter(e => e.severity === 'high').length
+  const medCount    = explanations.filter(e => e.severity === 'medium').length
+  const posCount    = explanations.filter(e => e.severity === 'positive').length
+
+  return (
+    <Card style={{ padding: 24, marginTop: 24 }}>
+      {/* Header */}
+      <div style={{ display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between', marginBottom: 20 }}>
+        <div>
+          <Label style={{ marginBottom: 6 }}>Analysis reasoning</Label>
+          <p style={{ margin: 0, fontSize: 13, color: '#64748B', lineHeight: 1.5, maxWidth: 560 }}>
+            The following signals contributed to the classification. Strong signals carry the most weight;
+            human indicators suggest characteristics inconsistent with AI generation.
+          </p>
+        </div>
+        {/* Signal summary pills */}
+        <div style={{ display: 'flex', gap: 8, flexShrink: 0, marginLeft: 24 }}>
+          {highCount > 0 && (
+            <span style={{ display: 'inline-flex', alignItems: 'center', gap: 5, padding: '4px 10px', borderRadius: 999, fontSize: 11, fontWeight: 600, background: 'rgba(239,68,68,0.12)', border: '1px solid rgba(239,68,68,0.30)', color: '#EF4444' }}>
+              <span style={{ width: 5, height: 5, borderRadius: '50%', background: '#EF4444' }}/>
+              {highCount} strong
+            </span>
+          )}
+          {medCount > 0 && (
+            <span style={{ display: 'inline-flex', alignItems: 'center', gap: 5, padding: '4px 10px', borderRadius: 999, fontSize: 11, fontWeight: 600, background: 'rgba(245,158,11,0.12)', border: '1px solid rgba(245,158,11,0.30)', color: '#F59E0B' }}>
+              <span style={{ width: 5, height: 5, borderRadius: '50%', background: '#F59E0B' }}/>
+              {medCount} moderate
+            </span>
+          )}
+          {posCount > 0 && (
+            <span style={{ display: 'inline-flex', alignItems: 'center', gap: 5, padding: '4px 10px', borderRadius: 999, fontSize: 11, fontWeight: 600, background: 'rgba(16,185,129,0.12)', border: '1px solid rgba(16,185,129,0.30)', color: '#10B981' }}>
+              <span style={{ width: 5, height: 5, borderRadius: '50%', background: '#10B981' }}/>
+              {posCount} human
+            </span>
+          )}
+        </div>
+      </div>
+
+      {/* Explanation items */}
+      <div style={{ display: 'flex', flexDirection: 'column', gap: 10 }}>
+        {explanations.map((exp, i) => {
+          const cfg = SEVERITY_CONFIG[exp.severity] || SEVERITY_CONFIG.low
+          return (
+            <div key={i} style={{
+              display: 'flex', gap: 14, alignItems: 'flex-start',
+              padding: '14px 16px',
+              background: cfg.bg,
+              border: `1px solid ${cfg.border}`,
+              borderRadius: 10,
+              animation: `fadeIn .25s ease ${i * 0.04}s both`,
+            }}>
+              {/* Icon */}
+              <div style={{
+                flexShrink: 0, width: 28, height: 28, borderRadius: 8,
+                background: `${cfg.color}18`,
+                display: 'flex', alignItems: 'center', justifyContent: 'center', marginTop: 1,
+              }}>
+                <Icon name={cfg.icon} size={14} color={cfg.color}/>
+              </div>
+
+              {/* Text */}
+              <div style={{ flex: 1, minWidth: 0 }}>
+                <div style={{ display: 'flex', alignItems: 'center', gap: 8, marginBottom: 5 }}>
+                  <span style={{ fontSize: 10, fontWeight: 600, letterSpacing: '0.06em', textTransform: 'uppercase', color: cfg.color }}>
+                    {cfg.label}
+                  </span>
+                  <span style={{ fontSize: 10, color: '#475569', fontFamily: 'JetBrains Mono, monospace' }}>
+                    {exp.feature.replace(/_/g, ' ')}
+                  </span>
+                </div>
+                <p style={{ margin: 0, fontSize: 13, color: '#CBD5E1', lineHeight: 1.65 }}>
+                  {exp.text}
+                </p>
+              </div>
+            </div>
+          )
+        })}
+      </div>
+
+      {/* Footer disclaimer */}
+      <div style={{
+        marginTop: 16, paddingTop: 16,
+        borderTop: '1px solid rgba(148,163,184,0.10)',
+        fontSize: 12, color: '#475569', lineHeight: 1.55, fontStyle: 'italic',
+      }}>
+        CodeSentinel reports statistical signals, not academic-integrity verdicts.
+        A high AI probability score should be treated as a starting point for review,
+        not as conclusive evidence. Confirm findings with the student before taking any action.
+      </div>
+    </Card>
+  )
+}

frontend/src/components/FeatureCard.jsx

@@ -0,0 +1,50 @@
+import { Card, Badge, Icon, Label } from './primitives'
+
+export function FeatureCard({ name, value, severity = 'low', unit = '', icon }) {
+  const tones = {
+    high:   { color: '#EF4444', label: 'HIGH',   tone: 'red',   pct: 85 },
+    medium: { color: '#F59E0B', label: 'MEDIUM', tone: 'amber', pct: 55 },
+    low:    { color: '#10B981', label: 'LOW',    tone: 'green', pct: 22 },
+  }
+  const t = tones[severity] || tones.low
+  return (
+    <Card hoverable>
+      <div style={{ display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between', marginBottom: 12 }}>
+        <div style={{ display: 'flex', alignItems: 'center', gap: 8, color: '#94A3B8' }}>
+          {icon && <Icon name={icon} size={14}/>}
+          <Label style={{ marginBottom: 0 }}>{name}</Label>
+        </div>
+        <Badge tone={t.tone} size="sm">{t.label}</Badge>
+      </div>
+      <div style={{
+        fontFamily: 'JetBrains Mono, monospace', fontSize: 28, fontWeight: 700,
+        color: '#F8FAFC', lineHeight: 1, fontVariantNumeric: 'tabular-nums',
+      }}>{value}<span style={{ fontSize: 14, color: '#64748B', marginLeft: 4 }}>{unit}</span></div>
+      <div style={{ height: 4, background: 'rgba(148,163,184,0.10)', borderRadius: 2, marginTop: 14, overflow: 'hidden' }}>
+        <div style={{ width: `${t.pct}%`, height: '100%', background: t.color, borderRadius: 2, transition: 'width .6s cubic-bezier(0.22,1,0.36,1)' }}/>
+      </div>
+    </Card>
+  )
+}
+
+export function StatCard({ label, value, delta, deltaColor = '#94A3B8', icon, iconColor = '#00D4FF' }) {
+  return (
+    <Card>
+      <div style={{ display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between', marginBottom: 12 }}>
+        <Label style={{ marginBottom: 0 }}>{label}</Label>
+        <div style={{
+          width: 32, height: 32, borderRadius: 8,
+          background: `${iconColor}15`, border: `1px solid ${iconColor}30`,
+          display: 'flex', alignItems: 'center', justifyContent: 'center',
+        }}>
+          <Icon name={icon} size={16} color={iconColor}/>
+        </div>
+      </div>
+      <div style={{
+        fontFamily: 'JetBrains Mono, monospace', fontSize: 32, fontWeight: 700,
+        color: '#F8FAFC', lineHeight: 1, fontVariantNumeric: 'tabular-nums',
+      }}>{value}</div>
+      {delta && <div style={{ fontSize: 12, color: deltaColor, marginTop: 8 }}>{delta}</div>}
+    </Card>
+  )
+}

frontend/src/components/Heatmap.jsx

@@ -0,0 +1,200 @@
+import { useState } from 'react'
+
+// Pretvara vrijednost 0-100 u boju:
+// tamno plava (0%) → cyan (50%) → amber (75%) → crvena (100%)
+function colorFor(v) {
+  if (v == null) return '#0F1729'
+  if (v < 30) {
+    const t = v / 30
+    return `rgb(${Math.round(15 + t * 10)}, ${Math.round(28 + t * 40)}, ${Math.round(60 + t * 80)})`
+  }
+  if (v < 60) {
+    const t = (v - 30) / 30
+    return `rgb(${Math.round(25 + t * (0 - 25))}, ${Math.round(68 + t * (212 - 68))}, ${Math.round(140 + t * (255 - 140))})`
+  }
+  if (v < 80) {
+    const t = (v - 60) / 20
+    return `rgb(${Math.round(t * 245)}, ${Math.round(212 + t * (158 - 212))}, ${Math.round(255 + t * (11 - 255))})`
+  }
+  const t = (v - 80) / 20
+  return `rgb(${Math.round(245 + t * (239 - 245))}, ${Math.round(158 + t * (68 - 158))}, ${Math.round(11 + t * (68 - 11))})`
+}
+
+export default function Heatmap({ data, ids }) {
+  const [tip, setTip] = useState(null)
+
+  if (!data || !ids || ids.length === 0) {
+    return (
+      <div style={{ padding: 40, textAlign: 'center', color: '#64748B', fontSize: 14 }}>
+        No similarity data available.
+      </div>
+    )
+  }
+
+  const n = ids.length
+
+  // Veličina ćelije: veća za manji broj fajlova, manja za veći broj
+  // Min 20px, max 80px — tako da uvijek bude vidljivo
+  const cellSize = Math.max(20, Math.min(80, Math.floor(480 / n)))
+  const labelW   = 72
+  const showPct  = cellSize >= 36   // prikaži postotak u ćeliji ako ima mjesta
+
+  return (
+    <div style={{ position: 'relative' }}>
+
+      {/* Upozorenje za mali broj fajlova */}
+      {n < 3 && (
+        <div style={{
+          marginBottom: 16, padding: '10px 14px',
+          background: 'rgba(245,158,11,0.08)', border: '1px solid rgba(245,158,11,0.25)',
+          borderRadius: 8, fontSize: 12, color: '#F59E0B',
+        }}>
+          Heatmap je najkorisniji s 3 ili više datoteka. Trenutno prikazuje {n} datoteke.
+        </div>
+      )}
+
+      <div style={{ overflowX: 'auto', overflowY: 'auto' }}>
+        {/* Gornji labeli (kosi tekst) */}
+        <div style={{ display: 'flex', marginLeft: labelW }}>
+          {ids.map((id, i) => (
+            <div key={i} style={{
+              width: cellSize, flexShrink: 0,
+              height: labelW,
+              display: 'flex', alignItems: 'flex-end', justifyContent: 'center',
+              paddingBottom: 8,
+            }}>
+              <span style={{
+                fontFamily: 'JetBrains Mono, monospace',
+                fontSize: Math.max(8, Math.min(11, cellSize * 0.35)),
+                color: '#94A3B8',
+                transform: 'rotate(-45deg)',
+                transformOrigin: 'bottom center',
+                whiteSpace: 'nowrap',
+                display: 'block',
+              }}>{id}</span>
+            </div>
+          ))}
+        </div>
+
+        {/* Grid s lijeve strane labelima */}
+        <div style={{ display: 'flex' }}>
+
+          {/* Lijevi labeli */}
+          <div style={{ display: 'flex', flexDirection: 'column', width: labelW, flexShrink: 0 }}>
+            {ids.map((id, i) => (
+              <div key={i} style={{
+                height: cellSize, flexShrink: 0,
+                display: 'flex', alignItems: 'center', justifyContent: 'flex-end',
+                paddingRight: 10,
+                fontFamily: 'JetBrains Mono, monospace',
+                fontSize: Math.max(8, Math.min(11, cellSize * 0.35)),
+                color: '#94A3B8',
+                whiteSpace: 'nowrap',
+              }}>{id}</div>
+            ))}
+          </div>
+
+          {/* Matrica ćelija */}
+          <div style={{
+            display: 'flex', flexDirection: 'column',
+            border: '1px solid rgba(148,163,184,0.15)',
+            borderRadius: 6, overflow: 'hidden',
+          }}>
+            {data.map((row, i) => (
+              <div key={i} style={{ display: 'flex' }}>
+                {row.map((v, j) => {
+                  // Backend vraća 0.0–1.0, colorFor treba 0–100
+                  const pct = Math.round(v * 100)
+                  const isDiag = i === j
+                  const bg = isDiag ? '#1F2937' : colorFor(pct)
+
+                  // Boja teksta unutar ćelije — tamna za svijetle boje, bijela za tamne
+                  const textColor = pct > 45 && pct < 75 ? '#0A0F1C' : '#FFFFFF'
+
+                  return (
+                    <div key={j}
+                      onMouseEnter={e => setTip({ x: e.clientX, y: e.clientY, a: ids[i], b: ids[j], pct, isDiag })}
+                      onMouseMove={e =>  setTip({ x: e.clientX, y: e.clientY, a: ids[i], b: ids[j], pct, isDiag })}
+                      onMouseLeave={() => setTip(null)}
+                      style={{
+                        width: cellSize, height: cellSize, flexShrink: 0,
+                        background: bg,
+                        border: '1px solid rgba(10,15,28,0.3)',
+                        cursor: isDiag ? 'default' : 'pointer',
+                        display: 'flex', alignItems: 'center', justifyContent: 'center',
+                        transition: 'filter .1s',
+                        position: 'relative',
+                      }}>
+                      {/* Postotak unutar ćelije (samo ako ima mjesta i nije dijagonala) */}
+                      {showPct && !isDiag && (
+                        <span style={{
+                          fontFamily: 'JetBrains Mono, monospace',
+                          fontSize: Math.max(8, cellSize * 0.28),
+                          fontWeight: 700,
+                          color: textColor,
+                          userSelect: 'none',
+                          lineHeight: 1,
+                        }}>{pct}%</span>
+                      )}
+                      {/* Dijagonala — prikaži "—" */}
+                      {isDiag && showPct && (
+                        <span style={{ fontSize: cellSize * 0.3, color: '#475569' }}>—</span>
+                      )}
+                    </div>
+                  )
+                })}
+              </div>
+            ))}
+          </div>
+        </div>
+      </div>
+
+      {/* Legenda */}
+      <div style={{ marginTop: 20, display: 'flex', alignItems: 'center', gap: 12 }}>
+        <span style={{ fontSize: 11, color: '#94A3B8', letterSpacing: '0.04em', textTransform: 'uppercase' }}>Similarity</span>
+        <div style={{
+          display: 'flex', height: 10, width: 200, borderRadius: 4,
+          overflow: 'hidden', border: '1px solid rgba(148,163,184,0.10)',
+        }}>
+          {Array.from({ length: 40 }).map((_, i) => (
+            <div key={i} style={{ flex: 1, background: colorFor(i * 2.5 + 1) }}/>
+          ))}
+        </div>
+        <div style={{ display: 'flex', gap: 16, fontSize: 10, fontFamily: 'JetBrains Mono, monospace' }}>
+          <span style={{ color: '#64748B' }}>0%</span>
+          <span style={{ color: '#00D4FF' }}>50%</span>
+          <span style={{ color: '#F59E0B' }}>75%</span>
+          <span style={{ color: '#EF4444' }}>100%</span>
+        </div>
+      </div>
+
+      {/* Tooltip */}
+      {tip && !tip.isDiag && (
+        <div style={{
+          position: 'fixed', left: tip.x + 14, top: tip.y + 14,
+          background: 'rgba(10,15,28,0.97)', border: '1px solid rgba(0,212,255,0.4)',
+          padding: '10px 14px', borderRadius: 8, zIndex: 200,
+          fontFamily: 'JetBrains Mono, monospace', fontSize: 11, color: '#F8FAFC',
+          boxShadow: '0 8px 24px rgba(0,0,0,0.5)', pointerEvents: 'none',
+        }}>
+          <div style={{ color: '#94A3B8', fontSize: 10, marginBottom: 4 }}>
+            {tip.a} ↔ {tip.b}
+          </div>
+          <div style={{
+            fontSize: 20, fontWeight: 700,
+            color: colorFor(tip.pct),
+            lineHeight: 1,
+          }}>
+            {tip.pct}%
+          </div>
+          <div style={{ fontSize: 10, color: '#64748B', marginTop: 3 }}>
+            {tip.pct >= 80 ? 'Very high similarity' :
+             tip.pct >= 60 ? 'High similarity' :
+             tip.pct >= 40 ? 'Moderate similarity' :
+             'Low similarity'}
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}

frontend/src/components/Navbar.jsx

@@ -0,0 +1,68 @@
+import { useState } from 'react'
+import { Button } from './primitives'
+
+function NavLink({ active, onClick, children }) {
+  const [hover, setHover] = useState(false)
+  return (
+    <button onClick={onClick}
+      onMouseEnter={() => setHover(true)} onMouseLeave={() => setHover(false)}
+      style={{
+        background: active ? 'rgba(0,212,255,0.08)' : 'transparent',
+        border: 'none', padding: '8px 14px', borderRadius: 8,
+        fontFamily: 'Inter, sans-serif', fontSize: 14,
+        fontWeight: active ? 600 : 500,
+        color: active ? '#00D4FF' : hover ? '#F8FAFC' : '#CBD5E1',
+        cursor: 'pointer', transition: 'all .12s cubic-bezier(0.22,1,0.36,1)',
+      }}>
+      {children}
+    </button>
+  )
+}
+
+export default function Navbar({ active, onNavigate }) {
+  const tabs = [
+    { id: 'analyze',    label: 'Analyze' },
+    { id: 'batch',      label: 'Batch Upload' },
+    { id: 'similarity', label: 'Similarity' },
+  ]
+  return (
+    <header style={{
+      position: 'sticky', top: 0, zIndex: 50, height: 72,
+      background: 'rgba(10,15,28,0.80)',
+      backdropFilter: 'blur(16px)', WebkitBackdropFilter: 'blur(16px)',
+      borderBottom: '1px solid rgba(148,163,184,0.12)',
+    }}>
+      <div style={{
+        maxWidth: 1280, height: '100%', margin: '0 auto',
+        padding: '0 80px',
+        display: 'flex', alignItems: 'center', justifyContent: 'space-between',
+      }}>
+        <div style={{ display: 'flex', alignItems: 'center', gap: 10, cursor: 'pointer' }}
+          onClick={() => onNavigate('analyze')}>
+          <svg width="28" height="28" viewBox="0 0 32 32" fill="none">
+            <path d="M16 1L2 6v10c0 8.5 5.8 16 14 18 8.2-2 14-9.5 14-18V6L16 1z" fill="#111827" stroke="#00D4FF" strokeWidth="1.5"/>
+            <path d="M10 16l4 4 8-8" stroke="#00D4FF" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"/>
+          </svg>
+          <div style={{ fontSize: 18, fontWeight: 700, letterSpacing: '-0.02em', color: '#F8FAFC' }}>
+            Code<span style={{ color: '#00D4FF' }}>Sentinel</span>
+          </div>
+        </div>
+        <nav style={{ display: 'flex', alignItems: 'center', gap: 4 }}>
+          {tabs.map(t => (
+            <NavLink key={t.id} active={active === t.id} onClick={() => onNavigate(t.id)}>
+              {t.label}
+            </NavLink>
+          ))}
+        </nav>
+        <div style={{ display: 'flex', alignItems: 'center', gap: 12 }}>
+          <div style={{
+            width: 32, height: 32, borderRadius: '50%',
+            background: 'linear-gradient(135deg, #00D4FF, #06B6D4)',
+            display: 'flex', alignItems: 'center', justifyContent: 'center',
+            color: '#0A0F1C', fontWeight: 700, fontSize: 12,
+          }}>CS</div>
+        </div>
+      </div>
+    </header>
+  )
+}

frontend/src/components/ResultGauge.jsx

@@ -0,0 +1,60 @@
+import { useState, useEffect } from 'react'
+import { Badge } from './primitives'
+
+export default function ResultGauge({ value, size = 200, animate = true }) {
+  const [display, setDisplay] = useState(animate ? 0 : value)
+
+  useEffect(() => {
+    if (!animate) { setDisplay(value); return }
+    let raf, start
+    const dur = 800
+    const tick = (t) => {
+      if (!start) start = t
+      const p = Math.min((t - start) / dur, 1)
+      const eased = 1 - Math.pow(1 - p, 3)
+      setDisplay(Math.round(value * eased))
+      if (p < 1) raf = requestAnimationFrame(tick)
+    }
+    raf = requestAnimationFrame(tick)
+    return () => cancelAnimationFrame(raf)
+  }, [value, animate])
+
+  const color = value >= 70 ? '#EF4444' : value >= 40 ? '#F59E0B' : '#10B981'
+  const verdict = value >= 70 ? 'LIKELY AI-GENERATED' : value >= 40 ? 'POSSIBLY AI-GENERATED' : 'LIKELY HUMAN-WRITTEN'
+  const tone = value >= 70 ? 'red' : value >= 40 ? 'amber' : 'green'
+  const r = 42, c = 2 * Math.PI * r
+  const offset = c - (display / 100) * c
+
+  return (
+    <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', gap: 14 }}>
+      <div style={{ position: 'relative', width: size, height: size }}>
+        <svg viewBox="0 0 100 100" style={{ width: '100%', height: '100%', transform: 'rotate(-90deg)' }}>
+          <circle cx="50" cy="50" r={r} fill="none" stroke="#1F2937" strokeWidth="8"/>
+          <circle cx="50" cy="50" r={r} fill="none" stroke={color} strokeWidth="8"
+            strokeDasharray={c} strokeDashoffset={offset} strokeLinecap="round"
+            style={{ transition: 'stroke-dashoffset .1s linear', filter: `drop-shadow(0 0 6px ${color}66)` }}/>
+        </svg>
+        <div style={{
+          position: 'absolute', inset: 0,
+          display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center',
+        }}>
+          <div style={{
+            fontFamily: 'JetBrains Mono, monospace', fontSize: size * 0.26, fontWeight: 700,
+            color: '#F8FAFC', lineHeight: 1, fontVariantNumeric: 'tabular-nums',
+          }}>{display}<span style={{ color, fontSize: size * 0.13 }}>%</span></div>
+          <div style={{ fontSize: 10, color: '#64748B', letterSpacing: '0.08em', marginTop: 4, textTransform: 'uppercase' }}>AI probability</div>
+        </div>
+      </div>
+      <Badge tone={tone}>{verdict}</Badge>
+      <div style={{ width: '100%', maxWidth: 240 }}>
+        <div style={{ display: 'flex', justifyContent: 'space-between', fontSize: 10, color: '#64748B', marginBottom: 6, letterSpacing: '0.04em', textTransform: 'uppercase' }}>
+          <span>Confidence</span>
+          <span style={{ color: '#CBD5E1', fontFamily: 'JetBrains Mono, monospace' }}>—</span>
+        </div>
+        <div style={{ height: 4, background: 'rgba(148,163,184,0.10)', borderRadius: 2, overflow: 'hidden' }}>
+          <div style={{ width: '100%', height: '100%', background: `linear-gradient(90deg, ${color}, ${color}aa)`, borderRadius: 2 }}/>
+        </div>
+      </div>
+    </div>
+  )
+}

frontend/src/components/ResultsTable.jsx

@@ -0,0 +1,113 @@
+import { useState } from 'react'
+import { Badge, LangBadge, Icon } from './primitives'
+
+function cellStyle(i, hover, first) {
+  return {
+    padding: '14px 18px', fontSize: 13,
+    borderBottom: '1px solid rgba(148,163,184,0.08)',
+    background: hover ? 'rgba(0,212,255,0.04)' : i % 2 === 1 ? '#131B2E' : 'transparent',
+    boxShadow: hover && first ? 'inset 2px 0 0 #00D4FF' : 'none',
+    transition: 'background .12s cubic-bezier(0.22,1,0.36,1)',
+  }
+}
+
+export default function ResultsTable({ rows, onOpen }) {
+  const [sortKey, setSortKey] = useState('ai_probability')
+  const [sortDir, setSortDir] = useState('desc')
+  const [hover, setHover] = useState(null)
+
+  const sorted = [...rows].sort((a, b) => {
+    const dir = sortDir === 'asc' ? 1 : -1
+    if (a[sortKey] < b[sortKey]) return -dir
+    if (a[sortKey] > b[sortKey]) return dir
+    return 0
+  })
+
+  const toggle = (k) => {
+    if (sortKey === k) setSortDir(sortDir === 'asc' ? 'desc' : 'asc')
+    else { setSortKey(k); setSortDir('desc') }
+  }
+
+  const Th = ({ k, children, style }) => (
+    <th onClick={() => toggle(k)} style={{
+      fontSize: 11, textTransform: 'uppercase', letterSpacing: '0.04em',
+      fontWeight: 500, color: sortKey === k ? '#00D4FF' : '#94A3B8',
+      textAlign: 'left', padding: '14px 18px', background: '#0F1729',
+      borderBottom: '1px solid rgba(148,163,184,0.12)',
+      cursor: 'pointer', userSelect: 'none', ...style,
+    }}>
+      <span style={{ display: 'inline-flex', alignItems: 'center', gap: 6 }}>
+        {children}
+        {sortKey === k && <span style={{ fontSize: 9 }}>{sortDir === 'asc' ? '▲' : '▼'}</span>}
+      </span>
+    </th>
+  )
+
+  return (
+    <div style={{
+      background: 'rgba(17,24,39,0.6)', border: '1px solid rgba(148,163,184,0.12)',
+      borderRadius: 12, overflow: 'hidden', backdropFilter: 'blur(20px)',
+      boxShadow: 'inset 0 1px 0 rgba(255,255,255,0.03)',
+    }}>
+      <table style={{ width: '100%', borderCollapse: 'separate', borderSpacing: 0 }}>
+        <thead>
+          <tr>
+            <Th k="id">Student ID</Th>
+            <Th k="file">File</Th>
+            <Th k="detected_language">Language</Th>
+            <Th k="ai_probability">AI Probability</Th>
+            <Th k="verdict">Verdict</Th>
+            <th style={{ background: '#0F1729', borderBottom: '1px solid rgba(148,163,184,0.12)', padding: '14px 18px' }}/>
+          </tr>
+        </thead>
+        <tbody>
+          {sorted.map((r, i) => {
+            const prob = Math.round((r.ai_probability || 0) * 100)
+            const tone = prob >= 70 ? 'red' : prob >= 40 ? 'amber' : 'green'
+            const label = prob >= 70 ? 'LIKELY AI' : prob >= 40 ? 'POSSIBLY AI' : 'LIKELY HUMAN'
+            const probColor = prob >= 70 ? '#EF4444' : prob >= 40 ? '#F59E0B' : '#10B981'
+            const isHover = hover === i
+            return (
+              <tr key={r.id || i}
+                onMouseEnter={() => setHover(i)} onMouseLeave={() => setHover(null)}
+                onClick={() => onOpen && onOpen(r)} style={{ cursor: 'pointer' }}>
+                <td style={cellStyle(i, isHover, true)}>
+                  <span style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 13, color: '#F8FAFC' }}>{r.id}</span>
+                </td>
+                <td style={cellStyle(i, isHover)}>
+                  <span style={{ display: 'inline-flex', alignItems: 'center', gap: 8 }}>
+                    <Icon name="fileCode" size={14} color="#64748B"/>
+                    <span style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 13, color: '#CBD5E1' }}>{r.file || '—'}</span>
+                  </span>
+                </td>
+                <td style={cellStyle(i, isHover)}>
+                  <LangBadge lang={r.detected_language ? (r.detected_language.charAt(0).toUpperCase() + r.detected_language.slice(1)) : 'Unknown'}/>
+                </td>
+                <td style={cellStyle(i, isHover)}>
+                  <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
+                    <div style={{ width: 80, height: 4, background: 'rgba(148,163,184,0.10)', borderRadius: 2, overflow: 'hidden' }}>
+                      <div style={{ width: `${prob}%`, height: '100%', background: probColor }}/>
+                    </div>
+                    <span style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 13, fontWeight: 700, color: probColor, fontVariantNumeric: 'tabular-nums', minWidth: 36 }}>{prob}%</span>
+                  </div>
+                </td>
+                <td style={cellStyle(i, isHover)}><Badge tone={tone}>{label}</Badge></td>
+                <td style={cellStyle(i, isHover)}>
+                  <button onClick={e => { e.stopPropagation(); onOpen && onOpen(r) }}
+                    style={{
+                      background: 'transparent', border: 'none', cursor: 'pointer',
+                      color: isHover ? '#00D4FF' : '#64748B',
+                      display: 'inline-flex', alignItems: 'center', gap: 4,
+                      fontSize: 12, fontWeight: 500, padding: 6,
+                    }}>
+                    <Icon name="eye" size={14}/>
+                  </button>
+                </td>
+              </tr>
+            )
+          })}
+        </tbody>
+      </table>
+    </div>
+  )
+}

frontend/src/components/primitives.jsx

@@ -0,0 +1,188 @@
+import { useState } from 'react'
+
+export function Icon({ name, size = 18, color, strokeWidth = 1.5, style }) {
+  const paths = {
+    shield: <><path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z"/><path d="m9 12 2 2 4-4"/></>,
+    code: <><polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/></>,
+    upload: <><path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"/><path d="M12 12v9"/><path d="m8 17 4-5 4 5"/></>,
+    play: <polygon points="5 3 19 12 5 21 5 3"/>,
+    download: <><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></>,
+    search: <><circle cx="11" cy="11" r="7"/><path d="m21 21-4.3-4.3"/></>,
+    alert: <><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z"/><line x1="12" y1="9" x2="12" y2="13"/><circle cx="12" cy="17" r=".5"/></>,
+    check: <><path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/><polyline points="22 4 12 14.01 9 11.01"/></>,
+    filter: <><line x1="4" y1="6" x2="20" y2="6"/><line x1="6" y1="12" x2="18" y2="12"/><line x1="9" y1="18" x2="15" y2="18"/></>,
+    chevron: <polyline points="6 9 12 15 18 9"/>,
+    chevronRight: <polyline points="9 18 15 12 9 6"/>,
+    chevronLeft: <polyline points="15 18 9 12 15 6"/>,
+    file: <><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14 2 14 8 20 8"/></>,
+    fileCode: <><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14 2 14 8 20 8"/><path d="m10 13-2 2 2 2"/><path d="m14 17 2-2-2-2"/></>,
+    users: <><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/></>,
+    chart: <><path d="M3 3v18h18"/><rect x="7" y="13" width="3" height="6"/><rect x="12" y="9" width="3" height="10"/><rect x="17" y="5" width="3" height="14"/></>,
+    xCircle: <><circle cx="12" cy="12" r="10"/><line x1="15" y1="9" x2="9" y2="15"/><line x1="9" y1="9" x2="15" y2="15"/></>,
+    external: <><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/><polyline points="15 3 21 3 21 9"/><line x1="10" y1="14" x2="21" y2="3"/></>,
+    eye: <><path d="M2 12s3-7 10-7 10 7 10 7-3 7-10 7-10-7-10-7z"/><circle cx="12" cy="12" r="3"/></>,
+    sort: <><path d="m21 16-4 4-4-4"/><path d="M17 20V4"/><path d="m3 8 4-4 4 4"/><path d="M7 4v16"/></>,
+    arrowLeft: <><line x1="19" y1="12" x2="5" y2="12"/><polyline points="12 19 5 12 12 5"/></>,
+    sparkles: <><path d="m12 3-1.9 5.8a2 2 0 0 1-1.3 1.3L3 12l5.8 1.9a2 2 0 0 1 1.3 1.3L12 21l1.9-5.8a2 2 0 0 1 1.3-1.3L21 12l-5.8-1.9a2 2 0 0 1-1.3-1.3L12 3z"/></>,
+    x: <><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></>,
+  }
+  return (
+    <svg width={size} height={size} viewBox="0 0 24 24" fill="none"
+      stroke={color || 'currentColor'} strokeWidth={strokeWidth}
+      strokeLinecap="round" strokeLinejoin="round" style={style}>
+      {paths[name] || null}
+    </svg>
+  )
+}
+
+export function Button({ variant = 'primary', size = 'md', icon, iconRight, children, onClick, style, disabled }) {
+  const [hover, setHover] = useState(false)
+  const [pressed, setPressed] = useState(false)
+  const base = {
+    display: 'inline-flex', alignItems: 'center', gap: 8,
+    height: size === 'sm' ? 32 : size === 'lg' ? 48 : 40,
+    padding: size === 'sm' ? '0 12px' : size === 'lg' ? '0 24px' : '0 18px',
+    borderRadius: 8, fontFamily: 'Inter, sans-serif',
+    fontSize: size === 'sm' ? 13 : size === 'lg' ? 15 : 14,
+    fontWeight: 600, cursor: disabled ? 'not-allowed' : 'pointer',
+    border: '1px solid transparent',
+    transition: 'all .12s cubic-bezier(0.22,1,0.36,1)',
+    opacity: disabled ? 0.4 : 1,
+    transform: pressed ? 'scale(0.98)' : 'scale(1)',
+    whiteSpace: 'nowrap',
+  }
+  const variants = {
+    primary: {
+      background: hover ? '#22E0FF' : '#00D4FF', color: '#0A0F1C',
+      boxShadow: pressed ? 'none' : hover ? '0 0 32px rgba(0,212,255,0.4)' : '0 0 20px rgba(0,212,255,0.2)',
+    },
+    secondary: {
+      background: 'transparent', color: hover ? '#F8FAFC' : '#CBD5E1',
+      borderColor: hover ? 'rgba(148,163,184,0.30)' : 'rgba(148,163,184,0.12)',
+    },
+    ghost: {
+      background: hover ? 'rgba(148,163,184,0.06)' : 'transparent',
+      color: hover ? '#F8FAFC' : '#94A3B8', border: 'none',
+    },
+    danger: {
+      background: hover ? 'rgba(239,68,68,0.20)' : 'rgba(239,68,68,0.12)',
+      color: '#EF4444', borderColor: 'rgba(239,68,68,0.35)',
+    },
+  }
+  return (
+    <button style={{ ...base, ...variants[variant], ...style }}
+      onMouseEnter={() => setHover(true)} onMouseLeave={() => { setHover(false); setPressed(false) }}
+      onMouseDown={() => setPressed(true)} onMouseUp={() => setPressed(false)}
+      onClick={disabled ? undefined : onClick} disabled={disabled}>
+      {icon && <Icon name={icon} size={16}/>}
+      {children}
+      {iconRight && <Icon name={iconRight} size={16}/>}
+    </button>
+  )
+}
+
+export function Badge({ tone = 'cyan', children, dot = true, size = 'md' }) {
+  const tones = {
+    cyan:  { bg: 'rgba(0,212,255,0.12)',  bd: 'rgba(0,212,255,0.30)',  fg: '#00D4FF' },
+    red:   { bg: 'rgba(239,68,68,0.14)',  bd: 'rgba(239,68,68,0.35)',  fg: '#EF4444' },
+    amber: { bg: 'rgba(245,158,11,0.14)', bd: 'rgba(245,158,11,0.35)', fg: '#F59E0B' },
+    green: { bg: 'rgba(16,185,129,0.14)', bd: 'rgba(16,185,129,0.35)', fg: '#10B981' },
+    slate: { bg: 'rgba(148,163,184,0.10)',bd: 'rgba(148,163,184,0.25)',fg: '#94A3B8' },
+  }
+  const t = tones[tone]
+  return (
+    <span style={{
+      display: 'inline-flex', alignItems: 'center', gap: 6,
+      padding: size === 'sm' ? '3px 8px' : '5px 11px',
+      borderRadius: 999, fontSize: size === 'sm' ? 10 : 11, fontWeight: 600,
+      letterSpacing: '0.04em', border: `1px solid ${t.bd}`,
+      background: t.bg, color: t.fg, lineHeight: 1, whiteSpace: 'nowrap',
+    }}>
+      {dot && <span style={{ width: 5, height: 5, borderRadius: '50%', background: t.fg }}/>}
+      {children}
+    </span>
+  )
+}
+
+export function LangBadge({ lang }) {
+  const colors = { Python: '#3776AB', JavaScript: '#F7DF1E', Java: '#F89820', 'C++': '#00599C', Go: '#00ADD8', Rust: '#CE422B', Ruby: '#CC342D', TypeScript: '#3178C6' }
+  return (
+    <span style={{
+      display: 'inline-flex', alignItems: 'center', gap: 6,
+      padding: '4px 10px', borderRadius: 6,
+      fontFamily: 'JetBrains Mono, monospace', fontSize: 11, fontWeight: 500,
+      background: '#1F2937', border: '1px solid rgba(148,163,184,0.12)',
+      color: '#CBD5E1', lineHeight: 1,
+    }}>
+      <span style={{ width: 8, height: 8, borderRadius: 2, background: colors[lang] || '#94A3B8' }}/>
+      {lang || 'Unknown'}
+    </span>
+  )
+}
+
+export function Card({ children, style, glow, hoverable, onClick }) {
+  const [hover, setHover] = useState(false)
+  return (
+    <div onClick={onClick}
+      onMouseEnter={() => setHover(true)} onMouseLeave={() => setHover(false)}
+      style={{
+        background: 'rgba(17,24,39,0.6)',
+        border: `1px solid ${hover && hoverable ? 'rgba(148,163,184,0.24)' : 'rgba(148,163,184,0.12)'}`,
+        borderRadius: 12, padding: 20,
+        backdropFilter: 'blur(20px)', WebkitBackdropFilter: 'blur(20px)',
+        boxShadow: glow
+          ? 'inset 0 1px 0 rgba(255,255,255,0.03), 0 0 24px rgba(0,212,255,0.15)'
+          : 'inset 0 1px 0 rgba(255,255,255,0.03)',
+        cursor: onClick ? 'pointer' : 'default',
+        transition: 'border-color .12s cubic-bezier(0.22,1,0.36,1)',
+        ...style,
+      }}>
+      {children}
+    </div>
+  )
+}
+
+export function Input({ icon, placeholder, value, onChange, style, type = 'text' }) {
+  const [focus, setFocus] = useState(false)
+  return (
+    <div style={{
+      display: 'flex', alignItems: 'center', gap: 8,
+      height: 40, padding: '0 14px',
+      background: '#1F2937',
+      border: `1px solid ${focus ? 'rgba(0,212,255,0.40)' : 'rgba(148,163,184,0.12)'}`,
+      borderRadius: 8,
+      boxShadow: focus ? '0 0 0 3px rgba(0,212,255,0.10)' : 'none',
+      transition: 'all .12s cubic-bezier(0.22,1,0.36,1)',
+      ...style,
+    }}>
+      {icon && <Icon name={icon} size={16} color="#94A3B8"/>}
+      <input type={type} value={value} placeholder={placeholder}
+        onFocus={() => setFocus(true)} onBlur={() => setFocus(false)}
+        onChange={e => onChange && onChange(e.target.value)}
+        style={{
+          flex: 1, background: 'transparent', border: 'none', outline: 'none',
+          color: '#F8FAFC', fontFamily: 'Inter, sans-serif', fontSize: 14,
+        }}/>
+    </div>
+  )
+}
+
+export function Label({ children, style }) {
+  return (
+    <div style={{
+      fontSize: 11, textTransform: 'uppercase', letterSpacing: '0.04em',
+      fontWeight: 500, color: '#94A3B8', ...style,
+    }}>{children}</div>
+  )
+}
+
+export function Spinner({ size = 32 }) {
+  return (
+    <div style={{
+      width: size, height: size, borderRadius: '50%',
+      border: '2px solid rgba(0,212,255,0.20)',
+      borderTopColor: '#00D4FF',
+      animation: 'spin 0.8s linear infinite',
+    }}/>
+  )
+}

frontend/src/index.css

@@ -0,0 +1,111 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+#root {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}

frontend/src/main.jsx

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

frontend/src/screens/AnalyzeScreen.jsx

@@ -0,0 +1,202 @@
+import { useState } from 'react'
+import { Button, Card, Label, Icon, Spinner, LangBadge } from '../components/primitives'
+import CodeEditor from '../components/CodeEditor'
+import ResultGauge from '../components/ResultGauge'
+import { FeatureCard } from '../components/FeatureCard'
+import { analyzeCode } from '../api/client'
+import ExplanationPanel from '../components/ExplanationPanel'
+
+const SAMPLE = `def calculate_factorial_recursive(number_to_compute):
+    """Calculate factorial using recursive approach with input validation."""
+    if not isinstance(number_to_compute, int):
+        raise TypeError("Input must be an integer value")
+    if number_to_compute < 0:
+        raise ValueError("Factorial undefined for negative numbers")
+    if number_to_compute <= 1:
+        return 1
+    return number_to_compute * calculate_factorial_recursive(number_to_compute - 1)
+
+
+def main_execution_function():
+    """Main entry point for the factorial computation program."""
+    user_input_value = 10
+    final_result = calculate_factorial_recursive(user_input_value)
+    print(f"The factorial of {user_input_value} is {final_result}")
+
+
+if __name__ == "__main__":
+    main_execution_function()`
+
+function severityFor(key, value) {
+  const highKeys = ['avg_identifier_length', 'avg_function_name_length', 'naming_consistency', 'comment_ratio', 'num_docstrings']
+  const medKeys  = ['token_entropy', 'char_entropy', 'cyclomatic_complexity_approx', 'avg_function_length']
+  if (highKeys.includes(key)) return value > 5 ? 'high' : 'medium'
+  if (medKeys.includes(key)) return 'medium'
+  return 'low'
+}
+
+function formatFeatureVal(key, val) {
+  if (typeof val === 'number') {
+    if (key.includes('ratio') || key.includes('density')) return (val * 100).toFixed(1) + '%'
+    if (key.includes('entropy')) return val.toFixed(2)
+    if (Number.isInteger(val)) return String(val)
+    return val.toFixed(2)
+  }
+  return String(val)
+}
+
+const FEATURE_LABELS = {
+  avg_identifier_length:    { label: 'Avg. identifier length', icon: 'code' },
+  naming_consistency:       { label: 'Naming consistency', icon: 'sparkles' },
+  comment_ratio:            { label: 'Comment density', icon: 'fileCode' },
+  token_entropy:            { label: 'Token entropy', icon: 'chart' },
+  cyclomatic_complexity_approx: { label: 'Avg. complexity', icon: 'chart' },
+  avg_function_length:      { label: 'Avg. function length', icon: 'code' },
+}
+
+export default function AnalyzeScreen() {
+  const [code, setCode] = useState(SAMPLE)
+  const [result, setResult] = useState(null)
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState(null)
+
+  const run = async () => {
+    if (!code.trim()) return
+    setLoading(true); setError(null); setResult(null)
+    try {
+      const data = await analyzeCode(code)
+      setResult(data)
+    } catch (e) {
+      setError(e.message)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const topFeatures = result ? Object.entries(FEATURE_LABELS).map(([key, meta]) => ({
+    name: meta.label,
+    icon: meta.icon,
+    value: formatFeatureVal(key, result.all_features?.[key] ?? 0),
+    severity: severityFor(key, result.all_features?.[key] ?? 0),
+  })) : []
+
+  const lang = result?.detected_language
+  const langDisplay = lang ? lang.charAt(0).toUpperCase() + lang.slice(1) : 'Python'
+
+  return (
+    <div>
+      {/* Hero */}
+      <section style={{ padding: '80px 80px 48px', textAlign: 'center', position: 'relative' }}>
+        <div style={{
+          position: 'absolute', inset: 0,
+          backgroundImage: 'linear-gradient(to right, rgba(148,163,184,0.04) 1px, transparent 1px), linear-gradient(to bottom, rgba(148,163,184,0.04) 1px, transparent 1px)',
+          backgroundSize: '32px 32px', pointerEvents: 'none',
+          maskImage: 'radial-gradient(ellipse at center, black 30%, transparent 70%)',
+        }}/>
+        <div style={{ position: 'relative' }}>
+          <div style={{
+            display: 'inline-flex', alignItems: 'center', gap: 8,
+            padding: '6px 14px', borderRadius: 999,
+            background: 'rgba(0,212,255,0.08)', border: '1px solid rgba(0,212,255,0.20)',
+            marginBottom: 24,
+          }}>
+            <span style={{ width: 6, height: 6, borderRadius: '50%', background: '#00D4FF', boxShadow: '0 0 8px #00D4FF' }}/>
+            <span style={{ fontSize: 12, color: '#00D4FF', fontWeight: 500, letterSpacing: '0.04em' }}>v1.0 · 42 statistical signals</span>
+          </div>
+          <h1 style={{ fontSize: 56, fontWeight: 700, letterSpacing: '-0.02em', lineHeight: 1.05, color: '#F8FAFC', margin: '0 0 20px', maxWidth: 800, marginLeft: 'auto', marginRight: 'auto' }}>
+            Detect <span style={{ color: '#00D4FF' }}>AI-generated</span> code instantly
+          </h1>
+          <p style={{ fontSize: 18, color: '#94A3B8', lineHeight: 1.55, maxWidth: 600, margin: '0 auto 32px' }}>
+            CodeSentinel analyzes 42 statistical signals — identifier patterns, comment density, structural rhythm — to estimate the probability that a submission was written by a large language model.
+          </p>
+          <Button variant="primary" size="lg" icon="play" onClick={() => document.getElementById('analyzer')?.scrollIntoView({ behavior: 'smooth', block: 'start' })}>
+            Start analyzing
+          </Button>
+        </div>
+      </section>
+
+      {/* Analyzer */}
+      <section id="analyzer" style={{ padding: '24px 80px 80px', maxWidth: 1280, margin: '0 auto' }}>
+        <div style={{ display: 'grid', gridTemplateColumns: '1fr 360px', gap: 24, marginBottom: 32 }}>
+          <div>
+            <Label style={{ marginBottom: 10 }}>Paste or edit code</Label>
+            <CodeEditor code={code} onChange={setCode} lang={langDisplay} height={380}/>
+            <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginTop: 16 }}>
+              <div style={{ fontSize: 12, color: '#64748B', fontFamily: 'JetBrains Mono, monospace' }}>
+                {code.split('\n').length} lines · {code.length} chars
+              </div>
+              <Button variant="primary" icon="play" onClick={run} disabled={loading || !code.trim()}>
+                {loading ? 'Analyzing…' : 'Analyze code'}
+              </Button>
+            </div>
+          </div>
+
+          <Card glow style={{ padding: 24, display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', minHeight: 340 }}>
+            {loading ? (
+              <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', gap: 16 }}>
+                <Spinner size={40}/>
+                <div style={{ fontSize: 13, color: '#94A3B8', letterSpacing: '0.04em', textTransform: 'uppercase' }}>Analyzing…</div>
+              </div>
+            ) : error ? (
+              <div style={{ textAlign: 'center', padding: 20 }}>
+                <Icon name="alert" size={32} color="#EF4444"/>
+                <div style={{ fontSize: 13, color: '#EF4444', marginTop: 12 }}>{error}</div>
+                <div style={{ fontSize: 11, color: '#64748B', marginTop: 6 }}>Make sure the Flask server is running</div>
+              </div>
+            ) : result ? (
+              <ResultGauge value={Math.round(result.ai_probability * 100)} size={200}/>
+            ) : (
+              <div style={{ padding: 40, textAlign: 'center' }}>
+                <Icon name="sparkles" size={32} color="#475569"/>
+                <div style={{ fontSize: 14, color: '#64748B', marginTop: 14 }}>Run an analysis to see results</div>
+              </div>
+            )}
+          </Card>
+        </div>
+
+        {result && (
+          <div style={{ animation: 'fadeIn .3s ease' }}>
+            <div style={{ display: 'flex', alignItems: 'baseline', justifyContent: 'space-between', marginBottom: 18 }}>
+              <h2 style={{ fontSize: 24, fontWeight: 600, color: '#F8FAFC', margin: 0, letterSpacing: '-0.01em' }}>Feature breakdown</h2>
+              <div style={{ display: 'flex', alignItems: 'center', gap: 12 }}>
+                <LangBadge lang={langDisplay}/>
+                <span style={{ fontSize: 12, color: '#64748B' }}>Top 6 of 42 signals · sorted by suspicion</span>
+              </div>
+            </div>
+            <div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: 16, marginBottom: 32 }}>
+              {topFeatures.map((f, i) => <FeatureCard key={i} {...f}/>)}
+            </div>
+
+            {result.top_features?.length > 0 && (
+              <Card style={{ padding: 24 }}>
+                <Label style={{ marginBottom: 16 }}>Key signals</Label>
+                <div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
+                  {result.top_features.map((f, i) => (
+                    <div key={i} style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+                      <span style={{ fontSize: 13, color: '#CBD5E1' }}>{f.name.replace(/_/g, ' ')}</span>
+                      <div style={{ display: 'flex', alignItems: 'center', gap: 12 }}>
+                        <div style={{ width: 80, height: 3, background: 'rgba(148,163,184,0.10)', borderRadius: 2, overflow: 'hidden' }}>
+                          <div style={{ width: `${Math.round(f.importance * 1000)}%`, height: '100%', background: '#00D4FF' }}/>
+                        </div>
+                        <span style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 12, color: '#94A3B8', minWidth: 40, textAlign: 'right' }}>
+                          {f.value}
+                        </span>
+                      </div>
+                    </div>
+                  ))}
+                </div>
+              </Card>
+            )}
+
+            {/* Explanations panel */}
+            <ExplanationPanel
+              explanations={result.explanations}
+              verdict={result.verdict}
+              aiProbability={result.ai_probability}
+            />
+          </div>
+        )}
+      </section>
+    </div>
+  )
+}

frontend/src/screens/BatchScreen.jsx

@@ -0,0 +1,138 @@
+import { useState } from 'react'
+import { Button, Card, Label, Icon, Spinner, Input } from '../components/primitives'
+import Dropzone from '../components/Dropzone'
+import ResultsTable from '../components/ResultsTable'
+import { StatCard } from '../components/FeatureCard'
+import { analyzeBatch } from '../api/client'
+
+export default function BatchScreen({ onOpenRow }) {
+  const [files, setFiles] = useState([])
+  const [results, setResults] = useState([])
+  const [summary, setSummary] = useState(null)
+  const [loading, setLoading] = useState(false)
+  const [progress, setProgress] = useState(0)
+  const [error, setError] = useState(null)
+  const [search, setSearch] = useState('')
+
+  const handleFiles = (fileList) => {
+    const arr = Array.from(fileList)
+    setFiles(arr); setResults([]); setSummary(null); setError(null)
+  }
+
+  const runBatch = async () => {
+    if (!files.length) return
+    setLoading(true); setError(null); setProgress(0)
+
+    const submissions = await Promise.all(files.map(async (f) => ({
+      id: f.name.replace(/\.[^.]+$/, ''),
+      file: f.name,
+      code: await f.text(),
+    })))
+
+    try {
+      const data = await analyzeBatch(submissions)
+      const withFile = data.results.map((r, i) => ({ ...r, file: submissions[i]?.file || r.id }))
+      setResults(withFile)
+      setSummary(data.summary)
+      setProgress(100)
+    } catch (e) {
+      setError(e.message)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const exportCSV = () => {
+    if (!results.length) return
+    const headers = ['id', 'file', 'detected_language', 'ai_probability', 'verdict']
+    const rows = results.map(r => headers.map(h => {
+      const v = r[h]
+      return typeof v === 'number' ? (h === 'ai_probability' ? Math.round(v * 100) + '%' : v) : (v || '')
+    }))
+    const csv = [headers, ...rows].map(r => r.join(',')).join('\n')
+    const a = Object.assign(document.createElement('a'), { href: URL.createObjectURL(new Blob([csv])), download: 'codesentinel_results.csv' })
+    a.click()
+  }
+
+  const filtered = results.filter(r =>
+    !search || r.id?.toLowerCase().includes(search.toLowerCase()) || r.file?.toLowerCase().includes(search.toLowerCase())
+  )
+
+  return (
+    <div style={{ padding: '40px 80px 80px', maxWidth: 1280, margin: '0 auto' }}>
+      <div style={{ marginBottom: 32 }}>
+        <Label style={{ marginBottom: 8 }}>Batch analysis</Label>
+        <h1 style={{ fontSize: 40, fontWeight: 700, letterSpacing: '-0.02em', color: '#F8FAFC', margin: 0, lineHeight: 1.1 }}>
+          Class overview
+        </h1>
+        <p style={{ fontSize: 15, color: '#94A3B8', marginTop: 12, marginBottom: 0, maxWidth: 600 }}>
+          Drop a folder of submissions, then sort by AI probability to triage your grading queue.
+        </p>
+      </div>
+
+      {/* Upload zone */}
+      {!results.length && (
+        <div style={{ marginBottom: 24 }}>
+          <Dropzone files={files} onUpload={handleFiles}/>
+          {files.length > 0 && (
+            <div style={{ display: 'flex', justifyContent: 'flex-end', marginTop: 16 }}>
+              <Button variant="primary" icon="play" onClick={runBatch} disabled={loading}>
+                {loading ? 'Analyzing…' : `Analyze ${files.length} file${files.length !== 1 ? 's' : ''}`}
+              </Button>
+            </div>
+          )}
+        </div>
+      )}
+
+      {loading && (
+        <Card style={{ padding: 40, textAlign: 'center', marginBottom: 24 }}>
+          <Spinner size={40} style={{ margin: '0 auto 16px' }}/>
+          <div style={{ fontSize: 14, color: '#94A3B8' }}>Analyzing {files.length} files…</div>
+          <div style={{ width: 240, height: 4, background: 'rgba(148,163,184,0.10)', borderRadius: 2, margin: '16px auto 0', overflow: 'hidden' }}>
+            <div style={{ width: '60%', height: '100%', background: '#00D4FF', animation: 'pulse 1.2s ease-in-out infinite' }}/>
+          </div>
+        </Card>
+      )}
+
+      {error && (
+        <Card style={{ padding: 20, marginBottom: 24, borderColor: 'rgba(239,68,68,0.35)', background: 'rgba(239,68,68,0.06)' }}>
+          <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
+            <Icon name="alert" size={16} color="#EF4444"/>
+            <span style={{ fontSize: 14, color: '#EF4444' }}>{error}</span>
+          </div>
+        </Card>
+      )}
+
+      {summary && (
+        <>
+          {/* Stat cards */}
+          <div style={{ display: 'grid', gridTemplateColumns: 'repeat(4, 1fr)', gap: 16, marginBottom: 24 }}>
+            <StatCard label="Total submissions" value={summary.total} delta="files analyzed" icon="users" iconColor="#00D4FF"/>
+            <StatCard label="High risk" value={summary.high_risk} delta="≥ 70% AI probability" deltaColor="#EF4444" icon="alert" iconColor="#EF4444"/>
+            <StatCard label="Medium risk" value={summary.medium_risk} delta="40–69% probability" deltaColor="#F59E0B" icon="alert" iconColor="#F59E0B"/>
+            <StatCard label="Low risk" value={summary.low_risk} delta="< 40% probability" deltaColor="#10B981" icon="check" iconColor="#10B981"/>
+          </div>
+
+          {/* Success bar */}
+          <div style={{ marginBottom: 24, padding: '14px 18px', background: 'rgba(16,185,129,0.06)', border: '1px solid rgba(16,185,129,0.20)', borderRadius: 10, display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
+            <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
+              <Icon name="check" size={16} color="#10B981"/>
+              <span style={{ fontSize: 13, color: '#CBD5E1' }}>Analyzed <strong style={{ color: '#F8FAFC' }}>{summary.total} files</strong> — avg. AI probability: <strong style={{ color: '#F8FAFC' }}>{Math.round(summary.avg_ai_probability * 100)}%</strong></span>
+            </div>
+            <div style={{ display: 'flex', gap: 8 }}>
+              <Button variant="secondary" size="sm" icon="upload" onClick={() => { setResults([]); setSummary(null); setFiles([]) }}>Re-upload</Button>
+              <Button variant="primary" size="sm" icon="download" onClick={exportCSV}>Export CSV</Button>
+            </div>
+          </div>
+
+          {/* Toolbar */}
+          <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 16 }}>
+            <Input icon="search" placeholder="Search by student ID or filename…" value={search} onChange={setSearch} style={{ width: 320 }}/>
+          </div>
+
+          <ResultsTable rows={filtered} onOpen={onOpenRow}/>
+        </>
+      )}
+    </div>
+  )
+}

frontend/src/screens/DetailScreen.jsx

@@ -0,0 +1,105 @@
+import { Button, Card, Badge, Label, Icon, LangBadge } from '../components/primitives'
+import CodeEditor from '../components/CodeEditor'
+import ResultGauge from '../components/ResultGauge'
+import DetailSidebar from '../components/DetailSidebar'
+import ExplanationPanel from '../components/ExplanationPanel'
+
+function buildFeatures(allFeatures) {
+  if (!allFeatures) return []
+
+  const styleKeys = ['avg_identifier_length', 'avg_function_name_length', 'single_char_name_ratio', 'naming_consistency', 'comment_ratio', 'num_docstrings', 'lexical_diversity', 'trailing_whitespace_ratio']
+  const structKeys = ['num_functions', 'avg_function_length', 'max_nesting_depth', 'cyclomatic_complexity_approx', 'if_density', 'for_density', 'ast_depth']
+  const statKeys = ['char_entropy', 'token_entropy', 'perplexity']
+
+  const toFeature = (key, category) => {
+    const val = allFeatures[key]
+    if (val === undefined || val === null) return null
+    const fmtVal = typeof val === 'number'
+      ? (key.includes('ratio') || key.includes('density') ? (val * 100).toFixed(1) + '%' : val.toFixed ? val.toFixed(2) : String(val))
+      : String(val)
+    const severity = key.includes('length') && val > 6 ? 'high'
+      : key === 'naming_consistency' && val > 0.7 ? 'high'
+      : key === 'comment_ratio' && val > 0.2 ? 'high'
+      : key.includes('entropy') ? 'medium'
+      : 'low'
+    return { name: key.replace(/_/g, ' '), value: fmtVal, severity, category }
+  }
+
+  return [
+    ...styleKeys.map(k => toFeature(k, 'Style')),
+    ...structKeys.map(k => toFeature(k, 'Structure')),
+    ...statKeys.map(k => toFeature(k, 'Statistical')),
+  ].filter(Boolean)
+}
+
+function buildAnnotations(topFeatures) {
+  if (!topFeatures?.length) return []
+  return topFeatures.slice(0, 2).map((f, i) => ({
+    line: (i + 1) * 2,
+    tone: f.importance > 0.06 ? 'red' : 'amber',
+    note: `Suspicious: ${f.name.replace(/_/g, ' ')}`,
+  }))
+}
+
+export default function DetailScreen({ row, onBack }) {
+  if (!row) return null
+
+  const prob = Math.round((row.ai_probability || 0) * 100)
+  const tone = prob >= 70 ? 'red' : prob >= 40 ? 'amber' : 'green'
+  const label = prob >= 70 ? 'LIKELY AI' : prob >= 40 ? 'POSSIBLY AI' : 'LIKELY HUMAN'
+  const lang = row.detected_language || 'python'
+  const langDisplay = lang.charAt(0).toUpperCase() + lang.slice(1)
+
+  const features = buildFeatures(row.all_features)
+  const annotations = buildAnnotations(row.top_features)
+  const code = row.code || '// Code not available'
+
+  return (
+    <div style={{ padding: '32px 80px 80px', maxWidth: 1280, margin: '0 auto' }}>
+      <button onClick={onBack} style={{
+        background: 'transparent', border: 'none', color: '#94A3B8', cursor: 'pointer',
+        display: 'inline-flex', alignItems: 'center', gap: 6, padding: 0, marginBottom: 20, fontSize: 13,
+      }}>
+        <Icon name="arrowLeft" size={14}/> Back to batch
+      </button>
+
+      {/* Header */}
+      <Card style={{ marginBottom: 24, padding: 24 }}>
+        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', gap: 32 }}>
+          <div>
+            <div style={{ display: 'flex', alignItems: 'center', gap: 12, marginBottom: 10 }}>
+              <span style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 24, fontWeight: 700, color: '#F8FAFC' }}>{row.id}</span>
+              <LangBadge lang={langDisplay}/>
+              <Badge tone={tone}>{label}</Badge>
+            </div>
+            <div style={{ display: 'flex', alignItems: 'center', gap: 8, color: '#94A3B8', fontSize: 13 }}>
+              <Icon name="fileCode" size={14}/>
+              <span style={{ fontFamily: 'JetBrains Mono, monospace' }}>{row.file || row.id}</span>
+            </div>
+          </div>
+          <ResultGauge value={prob} size={140} animate={false}/>
+        </div>
+      </Card>
+
+      <div style={{ display: 'grid', gridTemplateColumns: '1fr 360px', gap: 24, alignItems: 'start' }}>
+        <div>
+          <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 12 }}>
+            <Label style={{ marginBottom: 0 }}>Annotated source</Label>
+            {annotations.length > 0 && (
+              <span style={{ fontSize: 11, color: '#64748B' }}>{annotations.length} suspicious lines flagged</span>
+            )}
+          </div>
+          <CodeEditor code={code} readOnly lang={langDisplay} height={420} annotations={annotations} filename={row.file}/>
+
+          <ExplanationPanel
+            explanations={row.explanations}
+            verdict={row.verdict}
+            aiProbability={row.ai_probability}
+          />
+        </div>
+
+        <DetailSidebar features={features}/>
+      </div>
+    </div>
+  )
+}

frontend/src/screens/SimilarityScreen.jsx

@@ -0,0 +1,125 @@
+import { useState } from 'react'
+import { Button, Card, Label, Icon, Input, Spinner } from '../components/primitives'
+import Heatmap from '../components/Heatmap'
+import { SuspiciousPair } from '../components/DetailSidebar'
+import Dropzone from '../components/Dropzone'
+import { computeSimilarity } from '../api/client'
+
+export default function SimilarityScreen() {
+  const [files, setFiles] = useState([])
+  const [result, setResult] = useState(null)
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState(null)
+  const [threshold, setThreshold] = useState(0.70)
+
+  const run = async () => {
+    if (files.length < 2) { setError('Need at least 2 files to compare.'); return }
+    setLoading(true); setError(null)
+    const submissions = await Promise.all(files.map(async f => ({
+      id: f.name.replace(/\.[^.]+$/, ''),
+      code: await f.text(),
+    })))
+    try {
+      const data = await computeSimilarity(submissions)
+      setResult(data)
+    } catch (e) {
+      setError(e.message)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const suspiciousPairs = result?.suspicious_pairs?.filter(p => p.similarity >= threshold) || []
+
+  return (
+    <div style={{ padding: '40px 80px 80px', maxWidth: 1280, margin: '0 auto' }}>
+      <div style={{ marginBottom: 32 }}>
+        <Label style={{ marginBottom: 8 }}>Cross-submission analysis</Label>
+        <h1 style={{ fontSize: 40, fontWeight: 700, letterSpacing: '-0.02em', color: '#F8FAFC', margin: 0, lineHeight: 1.1 }}>
+          Submission similarity
+        </h1>
+        <p style={{ fontSize: 15, color: '#94A3B8', marginTop: 12, marginBottom: 0, maxWidth: 640 }}>
+          High similarity between submissions may indicate shared AI prompts. Pairs above the threshold are surfaced below the heatmap.
+        </p>
+      </div>
+
+      {!result && (
+        <div style={{ marginBottom: 24 }}>
+          <Dropzone files={files} onUpload={f => { setFiles(Array.from(f)); setResult(null); setError(null) }}/>
+          {files.length >= 2 && (
+            <div style={{ display: 'flex', justifyContent: 'flex-end', marginTop: 16 }}>
+              <Button variant="primary" icon="play" onClick={run} disabled={loading}>
+                {loading ? 'Computing…' : `Compare ${files.length} submissions`}
+              </Button>
+            </div>
+          )}
+        </div>
+      )}
+
+      {loading && (
+        <Card style={{ padding: 40, textAlign: 'center' }}>
+          <Spinner size={40} style={{ margin: '0 auto 16px' }}/>
+          <div style={{ fontSize: 14, color: '#94A3B8' }}>Computing pairwise similarity…</div>
+        </Card>
+      )}
+
+      {error && (
+        <Card style={{ padding: 20, marginBottom: 24, borderColor: 'rgba(239,68,68,0.35)' }}>
+          <div style={{ display: 'flex', gap: 10 }}><Icon name="alert" size={16} color="#EF4444"/><span style={{ color: '#EF4444', fontSize: 14 }}>{error}</span></div>
+        </Card>
+      )}
+
+      {result && (
+        <>
+          <div style={{ display: 'grid', gridTemplateColumns: '1fr 280px', gap: 24, alignItems: 'start', marginBottom: 40 }}>
+            <Card style={{ padding: 24 }}>
+              <Heatmap ids={result.ids} data={result.matrix}/>
+            </Card>
+
+            <Card style={{ padding: 18 }}>
+              <Label style={{ marginBottom: 14 }}>Filters</Label>
+              <div style={{ marginBottom: 18 }}>
+                <div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: 8 }}>
+                  <span style={{ fontSize: 12, color: '#CBD5E1' }}>Similarity threshold</span>
+                  <span style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 12, color: '#00D4FF', fontWeight: 600 }}>{Math.round(threshold * 100)}%</span>
+                </div>
+                <input type="range" min="0" max="100" value={Math.round(threshold * 100)}
+                  onChange={e => setThreshold(e.target.value / 100)}
+                  style={{ width: '100%', accentColor: '#00D4FF' }}/>
+              </div>
+              <div style={{ padding: '12px 14px', background: 'rgba(0,212,255,0.06)', borderRadius: 8, border: '1px solid rgba(0,212,255,0.15)' }}>
+                <div style={{ fontSize: 12, color: '#94A3B8', marginBottom: 4 }}>Suspicious pairs</div>
+                <div style={{ fontFamily: 'JetBrains Mono, monospace', fontSize: 24, fontWeight: 700, color: suspiciousPairs.length > 0 ? '#EF4444' : '#10B981' }}>
+                  {suspiciousPairs.length}
+                </div>
+              </div>
+              <div style={{ marginTop: 14 }}>
+                <Button variant="secondary" size="sm" icon="upload" onClick={() => { setResult(null); setFiles([]) }} style={{ width: '100%' }}>
+                  Re-upload
+                </Button>
+              </div>
+            </Card>
+          </div>
+
+          <div>
+            <div style={{ display: 'flex', alignItems: 'baseline', justifyContent: 'space-between', marginBottom: 18 }}>
+              <h2 style={{ fontSize: 24, fontWeight: 600, color: '#F8FAFC', margin: 0, letterSpacing: '-0.01em' }}>Suspicious pairs</h2>
+              <span style={{ fontSize: 12, color: '#64748B' }}>{suspiciousPairs.length} pairs above {Math.round(threshold * 100)}%</span>
+            </div>
+            <div style={{ display: 'flex', flexDirection: 'column', gap: 10 }}>
+              {suspiciousPairs.map((p, i) => (
+                <SuspiciousPair key={i} a={p.id_a} b={p.id_b} similarity={Math.round(p.similarity * 100)}/>
+              ))}
+              {suspiciousPairs.length === 0 && (
+                <Card style={{ padding: 40, textAlign: 'center' }}>
+                  <Icon name="check" size={32} color="#10B981"/>
+                  <div style={{ fontSize: 14, color: '#94A3B8', marginTop: 10 }}>No pairs exceed the {Math.round(threshold * 100)}% threshold</div>
+                </Card>
+              )}
+            </div>
+          </div>
+        </>
+      )}
+    </div>
+  )
+}

frontend/src/styles/tokens.css

@@ -0,0 +1,53 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500;700&display=swap');
+
+:root {
+  --cs-canvas:       #0A0F1C;
+  --cs-panel:        #0F1729;
+  --cs-raised:       #111827;
+  --cs-input:        #1F2937;
+  --cs-input-soft:   #131B2E;
+  --cs-cyan:         #00D4FF;
+  --cs-cyan-strong:  #22E0FF;
+  --cs-teal:         #06B6D4;
+  --cs-cyan-soft:    rgba(0,212,255,0.12);
+  --cs-cyan-glow:    rgba(0,212,255,0.25);
+  --cs-green:        #10B981;
+  --cs-green-soft:   rgba(16,185,129,0.14);
+  --cs-amber:        #F59E0B;
+  --cs-amber-soft:   rgba(245,158,11,0.14);
+  --cs-red:          #EF4444;
+  --cs-red-soft:     rgba(239,68,68,0.14);
+  --cs-fg-1:         #F8FAFC;
+  --cs-fg-2:         #CBD5E1;
+  --cs-fg-3:         #94A3B8;
+  --cs-fg-4:         #64748B;
+  --cs-border:       rgba(148,163,184,0.12);
+  --cs-border-hover: rgba(148,163,184,0.24);
+  --cs-border-focus: rgba(0,212,255,0.40);
+  --cs-font-sans:    'Inter', system-ui, sans-serif;
+  --cs-font-mono:    'JetBrains Mono', 'Fira Code', monospace;
+  --cs-shadow-glow:  0 0 24px rgba(0,212,255,0.25);
+  --cs-shadow-lift:  0 8px 24px rgba(0,0,0,0.40);
+  --cs-shadow-inset: inset 0 1px 0 rgba(255,255,255,0.03);
+  --cs-ease:         cubic-bezier(0.22,1,0.36,1);
+  --cs-dur:          240ms;
+}
+
+*, *::before, *::after { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  background: var(--cs-canvas);
+  color: var(--cs-fg-2);
+  font-family: var(--cs-font-sans);
+  font-size: 14px;
+  -webkit-font-smoothing: antialiased;
+}
+
+::-webkit-scrollbar { width: 8px; height: 8px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: rgba(148,163,184,0.2); border-radius: 4px; }
+::-webkit-scrollbar-thumb:hover { background: rgba(0,212,255,0.4); }
+
+@keyframes spin { to { transform: rotate(360deg); } }
+@keyframes fadeIn { from { opacity: 0; transform: translateY(8px); } to { opacity: 1; transform: translateY(0); } }

frontend/vite.config.js

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 3000,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:5000',
+        changeOrigin: true,
+      }
+    }
+  }
+})

language_config.py

@@ -0,0 +1,281 @@
+import re
+import tree_sitter_python
+import tree_sitter_javascript
+import tree_sitter_java
+import tree_sitter_cpp
+import tree_sitter_c
+import tree_sitter_go
+import tree_sitter_rust
+import tree_sitter_ruby
+import tree_sitter_typescript
+
+
+LANGUAGE_CONFIGS: dict = {
+
+    # ── Python ────────────────────────────────────────────────────────────
+    "python": {
+        "ts_module": tree_sitter_python,
+        "extensions": [".py"],
+        "inline_comment": r"^\s*#",
+        "block_comment": None,
+        "docstring_pattern": r'"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'',
+        "node_types": {
+            "function":   ["function_definition"],
+            "class":      ["class_definition"],
+            "if":         ["if_statement"],
+            "for":        ["for_statement"],
+            "while":      ["while_statement"],
+            "try":        ["try_statement"],
+            "import":     ["import_statement", "import_from_statement"],
+            "identifier": ["identifier"],
+            "lambda":     ["lambda"],
+        },
+    },
+
+    # ── JavaScript ────────────────────────────────────────────────────────
+    "javascript": {
+        "ts_module": tree_sitter_javascript,
+        "extensions": [".js", ".mjs", ".cjs"],
+        "inline_comment": r"^\s*//",
+        "block_comment": ("/*", "*/"),
+        "docstring_pattern": r"/\*\*[\s\S]*?\*/",
+        "node_types": {
+            "function":   ["function_declaration", "arrow_function",
+                           "function_expression", "method_definition"],
+            "class":      ["class_declaration", "class"],
+            "if":         ["if_statement"],
+            "for":        ["for_statement", "for_in_statement"],
+            "while":      ["while_statement"],
+            "try":        ["try_statement"],
+            "import":     ["import_statement"],
+            "identifier": ["identifier"],
+            "lambda":     ["arrow_function"],
+        },
+    },
+
+    # ── TypeScript ────────────────────────────────────────────────────────
+    "typescript": {
+        "ts_module": tree_sitter_typescript,
+        "extensions": [".ts"],
+        "inline_comment": r"^\s*//",
+        "block_comment": ("/*", "*/"),
+        "docstring_pattern": r"/\*\*[\s\S]*?\*/",
+        "node_types": {
+            "function":   ["function_declaration", "arrow_function",
+                           "function_expression", "method_definition"],
+            "class":      ["class_declaration"],
+            "if":         ["if_statement"],
+            "for":        ["for_statement", "for_in_statement"],
+            "while":      ["while_statement"],
+            "try":        ["try_statement"],
+            "import":     ["import_statement"],
+            "identifier": ["identifier"],
+            "lambda":     ["arrow_function"],
+        },
+    },
+
+    # ── Java ──────────────────────────────────────────────────────────────
+    "java": {
+        "ts_module": tree_sitter_java,
+        "extensions": [".java"],
+        "inline_comment": r"^\s*//",
+        "block_comment": ("/*", "*/"),
+        "docstring_pattern": r"/\*\*[\s\S]*?\*/",
+        "node_types": {
+            "function":   ["method_declaration", "constructor_declaration"],
+            "class":      ["class_declaration", "interface_declaration",
+                           "enum_declaration"],
+            "if":         ["if_statement"],
+            "for":        ["for_statement", "enhanced_for_statement"],
+            "while":      ["while_statement"],
+            "try":        ["try_statement"],
+            "import":     ["import_declaration"],
+            "identifier": ["identifier"],
+            "lambda":     ["lambda_expression"],
+        },
+    },
+
+    # ── C ─────────────────────────────────────────────────────────────────
+    "c": {
+        "ts_module": tree_sitter_c,
+        "extensions": [".c", ".h"],
+        "inline_comment": r"^\s*//",
+        "block_comment": ("/*", "*/"),
+        "docstring_pattern": r"/\*\*[\s\S]*?\*/",
+        "node_types": {
+            "function":   ["function_definition"],
+            "class":      ["struct_specifier", "union_specifier"],
+            "if":         ["if_statement"],
+            "for":        ["for_statement"],
+            "while":      ["while_statement"],
+            "try":        [],
+            "import":     ["preproc_include"],
+            "identifier": ["identifier"],
+            "lambda":     [],
+        },
+    },
+
+    # ── C++ ───────────────────────────────────────────────────────────────
+    "cpp": {
+        "ts_module": tree_sitter_cpp,
+        "extensions": [".cpp", ".cc", ".cxx", ".hpp"],
+        "inline_comment": r"^\s*//",
+        "block_comment": ("/*", "*/"),
+        "docstring_pattern": r"/\*\*[\s\S]*?\*/",
+        "node_types": {
+            "function":   ["function_definition"],
+            "class":      ["class_specifier", "struct_specifier"],
+            "if":         ["if_statement"],
+            "for":        ["for_statement", "for_range_loop"],
+            "while":      ["while_statement"],
+            "try":        ["try_statement"],
+            "import":     ["preproc_include"],
+            "identifier": ["identifier"],
+            "lambda":     ["lambda_expression"],
+        },
+    },
+
+    # ── Go ────────────────────────────────────────────────────────────────
+    "go": {
+        "ts_module": tree_sitter_go,
+        "extensions": [".go"],
+        "inline_comment": r"^\s*//",
+        "block_comment": ("/*", "*/"),
+        "docstring_pattern": None,
+        "node_types": {
+            "function":   ["function_declaration", "method_declaration"],
+            "class":      ["type_declaration"],
+            "if":         ["if_statement"],
+            "for":        ["for_statement"],
+            "while":      ["for_statement"],
+            "try":        [],
+            "import":     ["import_declaration"],
+            "identifier": ["identifier"],
+            "lambda":     ["func_literal"],
+        },
+    },
+
+    # ── Rust ──────────────────────────────────────────────────────────────
+    "rust": {
+        "ts_module": tree_sitter_rust,
+        "extensions": [".rs"],
+        "inline_comment": r"^\s*//",
+        "block_comment": ("/*", "*/"),
+        "docstring_pattern": r"///.*",
+        "node_types": {
+            "function":   ["function_item"],
+            "class":      ["struct_item", "impl_item", "trait_item"],
+            "if":         ["if_expression"],
+            "for":        ["for_expression"],
+            "while":      ["while_expression"],
+            "try":        ["match_expression"],
+            "import":     ["use_declaration"],
+            "identifier": ["identifier"],
+            "lambda":     ["closure_expression"],
+        },
+    },
+
+    # ── Ruby ──────────────────────────────────────────────────────────────
+    "ruby": {
+        "ts_module": tree_sitter_ruby,
+        "extensions": [".rb"],
+        "inline_comment": r"^\s*#",
+        "block_comment": ("=begin", "=end"),
+        "docstring_pattern": None,
+        "node_types": {
+            "function":   ["method", "singleton_method"],
+            "class":      ["class", "module"],
+            "if":         ["if", "unless"],
+            "for":        ["for"],
+            "while":      ["while", "until"],
+            "try":        ["begin"],
+            "import":     [],
+            "identifier": ["identifier"],
+            "lambda":     ["lambda"],
+        },
+    },
+
+}
+
+
+def get_config(language: str) -> dict:
+    key = language.lower().strip()
+    if key not in LANGUAGE_CONFIGS:
+        supported = ", ".join(sorted(LANGUAGE_CONFIGS.keys()))
+        raise ValueError(
+            f"Jezik '{language}' nije podržan.\n"
+            f"Podržani jezici: {supported}"
+        )
+    return LANGUAGE_CONFIGS[key]
+
+
+def detect_language_from_extension(filename: str):
+
+    filename = filename.lower()
+    for lang, config in LANGUAGE_CONFIGS.items():
+        for ext in config["extensions"]:
+            if filename.endswith(ext):
+                return lang
+    return None
+
+
+def detect_language_from_code(code: str) -> str:
+   
+    scores = {lang: 0 for lang in LANGUAGE_CONFIGS}
+
+    # Python
+    if re.search(r"\bdef\s+\w+\s*\(", code):       scores["python"] += 3
+    if re.search(r'"""', code):                     scores["python"] += 2
+    if re.search(r"\bself\b", code):                scores["python"] += 2
+    if re.search(r"\bprint\s*\(", code):            scores["python"] += 1
+    if re.search(r":\s*$", code, re.MULTILINE):     scores["python"] += 1
+
+    # Java
+    if re.search(r"\bpublic\s+class\b", code):      scores["java"] += 4
+    if re.search(r"\bSystem\.out\b", code):         scores["java"] += 3
+    if re.search(r"\bpublic\s+static\b", code):     scores["java"] += 2
+    if re.search(r"\bvoid\s+main\b", code):         scores["java"] += 2
+
+    # JavaScript
+    if re.search(r"\bconst\s+\w+\s*=", code):      scores["javascript"] += 2
+    if re.search(r"=>\s*[{(]", code):               scores["javascript"] += 3
+    if re.search(r"\bconsole\.log\b", code):        scores["javascript"] += 3
+
+    # TypeScript
+    if re.search(r":\s*(string|number|boolean|void)\b", code):
+        scores["typescript"] += 4
+    if re.search(r"\binterface\s+\w+", code):       scores["typescript"] += 4
+
+    # C / C++
+    if re.search(r"#include\s*[<\"]", code):
+        scores["cpp"] += 3
+        scores["c"] += 3
+    if re.search(r"\bstd::", code):                 scores["cpp"] += 4
+    if re.search(r"\bcout\b", code):                scores["cpp"] += 4
+    if re.search(r"\bcin\b", code):                 scores["cpp"] += 4
+    if re.search(r"\busing\s+namespace\b", code):   scores["cpp"] += 4
+    if re.search(r"\btemplate\s*<", code):          scores["cpp"] += 3
+    if re.search(r"\bvector\s*<", code):            scores["cpp"] += 3
+    if re.search(r"\bstring\b", code) and re.search(r"#include", code):
+        scores["cpp"] += 2
+    if re.search(r"\bprintf\s*\(", code):           scores["c"] += 3
+    if re.search(r"\bscanf\s*\(", code):            scores["c"] += 3
+    if re.search(r"\bmalloc\s*\(", code):           scores["c"] += 3
+
+    # Go
+    if re.search(r"\bfunc\s+\w+\s*\(", code):      scores["go"] += 4
+    if re.search(r"\bpackage\s+\w+", code):         scores["go"] += 4
+    if re.search(r"\bfmt\.Print", code):            scores["go"] += 3
+
+    # Rust
+    if re.search(r"\bfn\s+\w+\s*\(", code):        scores["rust"] += 4
+    if re.search(r"\blet\s+mut\b", code):           scores["rust"] += 4
+    if re.search(r"\bprintln!\s*\(", code):         scores["rust"] += 3
+
+    # Ruby
+    if re.search(r"\bdef\s+\w+", code) and re.search(r"\bend\b", code):
+        scores["ruby"] += 3
+    if re.search(r"\bputs\s+", code):              scores["ruby"] += 3
+
+    best = max(scores, key=lambda l: scores[l])
+    return best if scores[best] > 0 else "python"

main.py

@@ -0,0 +1,239 @@
+from feature_extraction import extract_all_features
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# UČITAVANJE MODELA
+# ─────────────────────────────────────────────────────────────────────────────
+
+MODEL_NAME = "Salesforce/codegen-350M-mono"
+
+
+def ucitaj_model():
+   
+    try:
+        from transformers import AutoTokenizer, AutoModelForCausalLM
+        import torch
+
+        print(f"  Učitavam model '{MODEL_NAME}'...")
+        print("  (Pri prvom pokretanju ovo može potrajati par minuta.)\n")
+
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        model     = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            torch_dtype=torch.float32,   # float32 radi na CPU bez GPU-a
+        )
+        model.eval()   # isključi dropout — samo inferenca, ne treniranje
+
+        num_params = sum(p.numel() for p in model.parameters()) // 1_000_000
+        print(f"  Model učitan ({num_params}M parametara).\n")
+        return model, tokenizer
+
+    except ImportError:
+        print("  [UPOZORENJE] transformers ili torch nisu instalirani.")
+        print("  Pokreni: pip install transformers torch\n")
+        return None, None
+
+    except Exception as e:
+        print(f"  [UPOZORENJE] Model nije mogao biti učitan: {e}\n")
+        return None, None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# UNOS KODA
+# ─────────────────────────────────────────────────────────────────────────────
+
+def ucitaj_kod() -> str:
+   
+    print("Zalijepi kod ispod, a kad završiš pritisni Enter dva puta:\n")
+    linije = []
+    prazni_zaredom = 0
+
+    while True:
+        linija = input()
+        if linija == "":
+            prazni_zaredom += 1
+            if prazni_zaredom >= 2:
+                break
+            linije.append(linija)
+        else:
+            prazni_zaredom = 0
+            linije.append(linija)
+
+    return "\n".join(linije).strip()
+
+
+def ucitaj_iz_datoteke(putanja: str) -> str:
+    
+    try:
+        with open(putanja, "r", encoding="utf-8") as f:
+            sadrzaj = f.read()
+        print(f"  Učitano {len(sadrzaj.splitlines())} linija iz '{putanja}'.")
+        return sadrzaj
+    except FileNotFoundError:
+        print(f"\n  [GREŠKA] Datoteka '{putanja}' nije pronađena.")
+        print(  "  Provjeri je li datoteka u istom folderu kao main.py.")
+        return ""
+    except Exception as e:
+        print(f"\n  [GREŠKA] Problem pri čitanju datoteke: {e}")
+        return ""
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# ISPIS REZULTATA
+# ─────────────────────────────────────────────────────────────────────────────
+
+def ispisi_znacajke(features: dict) -> None:
+    
+    jezik = features.get("detected_language", "nepoznat")
+    print(f"\n{'═' * 55}")
+    print(f"  Prepoznat jezik: {jezik.upper()}")
+    print(f"{'═' * 55}")
+
+    # ── Stilska detekcija ──────────────────────────────────────
+    print("\n  [ STILSKA DETEKCIJA — komentari, imenovanje, formatiranje ]\n")
+
+    stilske = [
+        ("Broj linija s komentarom",        "num_comment_lines"),
+        ("Udio komentara (%)",               "comment_ratio"),
+        ("Prosj. duljina komentara (rij.)",  "avg_comment_length_words"),
+        ("Udio komentara u znakovima",       "comment_to_code_ratio"),
+        ("Broj blok komentara",              "num_block_comments"),
+        ("Broj docstringova / JSDoc",        "num_docstrings"),
+        ("Prosj. duljina identifikatora",    "avg_identifier_length"),
+        ("Prosj. duljina naziva funkcija",   "avg_function_name_length"),
+        ("Udio jednoslovnih naziva",         "single_char_name_ratio"),
+        ("Leksička raznolikost naziva",      "lexical_diversity"),
+        ("Udio snake_case stila",            "snake_case_ratio"),
+        ("Udio camelCase stila",             "camel_case_ratio"),
+        ("Konzistentnost imenovanja",        "naming_consistency"),
+        ("Ukupno linija",                    "total_lines"),
+        ("Udio praznih linija",              "empty_line_ratio"),
+        ("Prosj. duljina linije (znakovi)",  "avg_line_length"),
+        ("Max duljina linije",               "max_line_length"),
+        ("Koristi tabove (1=da, 0=ne)",      "uses_tabs"),
+        ("Udio linija s trailing space",     "trailing_whitespace_ratio"),
+        ("Konzistentnost razmaka operatori", "operator_spacing_consistency"),
+    ]
+
+    for naziv, kljuc in stilske:
+        val = features.get(kljuc, "N/A")
+        if isinstance(val, float):
+            print(f"    {naziv:<38} {val:.4f}")
+        else:
+            print(f"    {naziv:<38} {val}")
+
+    # ── Strukturna detekcija ───────────────────────────────────
+    print("\n  [ STRUKTURNA DETEKCIJA — AST, složenost, tok kontrole ]\n")
+
+    strukturne = [
+        ("Dubina AST stabla",                "ast_depth"),
+        ("Broj čvorova u AST stablu",        "ast_node_count"),
+        ("Raznolikost tipova čvorova",       "unique_node_type_ratio"),
+        ("Broj funkcija / metoda",           "num_functions"),
+        ("Prosj. duljina funkcije (linije)", "avg_function_length"),
+        ("Max duljina funkcije (linije)",    "max_function_length"),
+        ("Prosj. broj argumenata",           "avg_args_per_function"),
+        ("Broj klasa",                       "num_classes"),
+        ("Broj importa",                     "num_imports"),
+        ("Broj if naredbi",                  "num_if_statements"),
+        ("Broj for petlji",                  "num_for_loops"),
+        ("Broj while petlji",                "num_while_loops"),
+        ("Broj try/catch blokova",           "num_try_blocks"),
+        ("Broj lambda izraza",               "num_lambdas"),
+        ("Max dubina ugniježđenosti",        "max_nesting_depth"),
+        ("Prosj. dubina ugniježđenosti",     "avg_nesting_depth"),
+        ("Aproks. ciklomatska složenost",    "cyclomatic_complexity_approx"),
+    ]
+
+    for naziv, kljuc in strukturne:
+        val = features.get(kljuc, "N/A")
+        if isinstance(val, float):
+            print(f"    {naziv:<38} {val:.4f}")
+        else:
+            print(f"    {naziv:<38} {val}")
+
+    # ── Statistička detekcija ──────────────────────────────────
+    print("\n  [ STATISTIČKA DETEKCIJA — perplexity ]\n")
+
+    perp     = features.get("perplexity", -1.0)
+    dostupan = features.get("model_available", 0)
+
+    if dostupan == 0:
+        print("    Model nije učitan — perplexity nije izračunat.")
+    else:
+        print(f"    {'Perplexity':<38} {perp:.4f}")
+
+        # Grubo tumačenje perplexityja za CodeGEN-350M
+        if perp < 5:
+            tumacenje = "vrlo nizak → vjerojatno AI"
+        elif perp < 20:
+            tumacenje = "nizak → moguće AI"
+        elif perp < 60:
+            tumacenje = "srednji → nejasno"
+        else:
+            tumacenje = "visok → vjerojatno čovjek"
+        print(f"    {'Tumačenje':<38} {tumacenje}")
+
+    print(f"\n{'═' * 55}")
+    print(f"  Ukupno izvučeno značajki: {len(features) - 1}")
+    print(f"{'═' * 55}\n")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# GLAVNI PROGRAM
+# ─────────────────────────────────────────────────────────────────────────────
+
+def main():
+    print("=" * 55)
+    print("  Ekstraktor značajki koda")
+    print("  (za detekciju AI generiranog koda)")
+    print("=" * 55)
+
+    # Pitaj korisnika želi li učitati model za perplexity
+    print("\nŽeliš li učitati model za izračun perplexityja?")
+    print("  d — Da (skida ~700 MB pri prvom pokretanju)")
+    print("  n — Ne (perplexity će biti preskočen)\n")
+    odabir_model = input("Odabir (d/n): ").strip().lower()
+
+    model, tokenizer = None, None
+    if odabir_model in ("d", "da", "y", "yes"):
+        model, tokenizer = ucitaj_model()
+
+    # Način unosa koda
+    print("\nNačin unosa koda:")
+    print("  1 — Zalijepi kod direktno u terminal")
+    print("  2 — Učitaj iz datoteke (npr. kod.txt)")
+
+    while True:
+        print()
+        odabir = input("Odaberi način unosa (1 ili 2): ").strip()
+
+        if odabir == "1":
+            kod = ucitaj_kod()
+
+        elif odabir == "2":
+            putanja = input("Putanja do datoteke (Enter za 'kod.txt'): ").strip()
+            if putanja == "":
+                putanja = "kod.txt"
+            kod = ucitaj_iz_datoteke(putanja)
+
+        else:
+            print("  Unesi 1 ili 2.")
+            continue
+
+        if not kod:
+            print("  Kod je prazan. Pokušaj ponovno.")
+            continue
+
+        print("\nIzvlačim značajke...")
+        znacajke = extract_all_features(kod, model=model, tokenizer=tokenizer)
+        ispisi_znacajke(znacajke)
+
+        odgovor = input("Želiš li analizirati još jedan isječak koda? (da/ne): ")
+        if odgovor.strip().lower() not in ("da", "d", "yes", "y"):
+            print("\nZatvaram program.")
+            break
+
+
+if __name__ == "__main__":
+    main()

model/classifier.pkl

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

primjeri/1.py

@@ -0,0 +1,10 @@
+# This program adds two numbers
+
+num1 = 1.5
+num2 = 6.3
+
+# Add two numbers
+sum = num1 + num2
+
+# Display the sum
+print('The sum of {0} and {1} is {2}'.format(num1, num2, sum))

primjeri/11.py

@@ -0,0 +1,9 @@
+# This program adds two numbers
+
+num1 = 1.5
+num2 = 6.3
+
+sum = num1 + num2
+
+# Display the sum
+print('The sum of {0} and {1} is {2}'.format(num1, num2, sum))

primjeri/ai.py

@@ -0,0 +1,116 @@
+def calculate_standard_deviation(numerical_values: list) -> float:
+    """
+    Calculate the standard deviation of a list of numerical values.
+
+    Standard deviation measures the amount of variation or dispersion
+    in a dataset relative to its mean value.
+
+    Args:
+        numerical_values: A list of numeric values to analyze.
+
+    Returns:
+        The standard deviation as a floating point number.
+
+    Raises:
+        ValueError: If the input list is empty or contains fewer than two values.
+        TypeError: If the input contains non-numeric values.
+    """
+    if not numerical_values:
+        raise ValueError("Input list must not be empty.")
+    if len(numerical_values) < 2:
+        raise ValueError("Standard deviation requires at least two values.")
+    if not all(isinstance(value, (int, float)) for value in numerical_values):
+        raise TypeError("All values in the input list must be numeric.")
+
+    total_count = len(numerical_values)
+    arithmetic_mean = sum(numerical_values) / total_count
+    squared_differences = [(value - arithmetic_mean) ** 2 for value in numerical_values]
+    variance_value = sum(squared_differences) / (total_count - 1)
+    standard_deviation_result = variance_value ** 0.5
+
+    return standard_deviation_result
+
+
+def find_outliers_using_std_deviation(
+    numerical_values: list,
+    threshold_multiplier: float = 2.0
+) -> list:
+    """
+    Identify outliers in a dataset using standard deviation method.
+
+    Values that fall more than threshold_multiplier standard deviations
+    away from the mean are considered outliers.
+
+    Args:
+        numerical_values: A list of numeric values to analyze.
+        threshold_multiplier: The number of standard deviations to use
+                              as the outlier threshold. Defaults to 2.0.
+
+    Returns:
+        A list of values identified as outliers.
+    """
+    if not numerical_values:
+        raise ValueError("Input list must not be empty.")
+
+    arithmetic_mean = sum(numerical_values) / len(numerical_values)
+    standard_deviation_value = calculate_standard_deviation(numerical_values)
+    lower_bound_value = arithmetic_mean - (threshold_multiplier * standard_deviation_value)
+    upper_bound_value = arithmetic_mean + (threshold_multiplier * standard_deviation_value)
+
+    identified_outliers = [
+        value for value in numerical_values
+        if value < lower_bound_value or value > upper_bound_value
+    ]
+
+    return identified_outliers
+
+
+def normalize_numerical_dataset(numerical_values: list) -> list:
+    """
+    Normalize a list of numerical values to the range [0, 1].
+
+    Normalization is performed using min-max scaling, which transforms
+    each value proportionally within the original range.
+
+    Args:
+        numerical_values: A list of numeric values to normalize.
+
+    Returns:
+        A list of normalized values in the range [0, 1].
+    """
+    if not numerical_values:
+        raise ValueError("Input list must not be empty.")
+
+    minimum_value = min(numerical_values)
+    maximum_value = max(numerical_values)
+
+    if minimum_value == maximum_value:
+        return [0.0 for _ in numerical_values]
+
+    value_range = maximum_value - minimum_value
+    normalized_values = [
+        (value - minimum_value) / value_range
+        for value in numerical_values
+    ]
+
+    return normalized_values
+
+
+def main_execution_function():
+    """
+    Main entry point demonstrating statistical analysis functions.
+    """
+    sample_numerical_dataset = [12, 15, 14, 10, 18, 45, 13, 11, 16, 14]
+
+    calculated_deviation = calculate_standard_deviation(sample_numerical_dataset)
+    print(f"Standard deviation: {calculated_deviation:.4f}")
+
+    detected_outliers = find_outliers_using_std_deviation(sample_numerical_dataset)
+    print(f"Detected outliers: {detected_outliers}")
+
+    normalized_dataset = normalize_numerical_dataset(sample_numerical_dataset)
+    print(f"Normalized values: {[round(v, 3) for v in normalized_dataset]}")
+
+
+if __name__ == "__main__":
+    main_execution_function()